Storm-3068: A CI/CD Pipeline Is a Kubeconfig Exfiltration Machine
Microsoft's Storm-3068 report used zero malware to steal Kubernetes credentials, just a password reset, a pipeline edit, and permissions nobody had scoped down.
Key takeaways
- Storm-3068 took over an identity through self-service password reset, then edited an Azure DevOps pipeline authorized for more than 50 resources to collect kubeconfig files.
- The defense is least privilege on pipelines: authorize service connections per pipeline, bind them to namespace-scoped Roles, mint short-lived tokens per run, and alert on password resets followed by new authentication methods.
On this page
Storm-3068 stole Kubernetes credentials without a Kubernetes exploit. The attacker abused self-service password reset, registered their own authentication methods, then edited an Azure DevOps pipeline that could already reach more than 50 resources so it collected kubeconfig files. If your service connections reach a whole cluster instead of one namespace, you have the same exposure.
Verified against
Kubernetes v1.37 kubectl reference, Azure DevOps Services service connection docs (updated October 2026), against Microsoft's September 29, 2026 Storm-3068 write-up. Checked October 2026.
The chain, as Microsoft reported it
Microsoft's account, published September 29, 2026, starts with self-service password reset (SSPR) abuse: the attacker reached a user account through the reset flow, then took full control of the identity by registering attacker-controlled authentication methods. That move converts a one-time takeover into standing access, because the attacker can re-authenticate at will. From there, the attacker used the account's legitimate Azure DevOps access, with ordinary administrative tooling and scripts, to enumerate repositories, projects, pipelines, and deployment environments. They then modified a pipeline authorized to access more than 50 resources, deployed an agent that harvested kubeconfig files, and committed seven of them to a repository. Microsoft also describes the Atera remote management agent being installed through modified pipeline scripts and a Chisel reverse tunnel aimed at exposing the Kubernetes API server.
Why this is a pipeline problem, not an identity problem alone
It is tempting to read this as "patch the identity layer and move on." Phishing-resistant MFA matters, and Microsoft recommends it for privileged accounts. The part that should bother infrastructure teams is what happened after the takeover: a pipeline with broad cluster access did exactly what it was told, by an account that looked legitimate. The attacker needed no container escape, just a service connection scoped to more than it should have been and a pipeline job that could read cluster credentials and write them somewhere.
That is the uncomfortable generalization: almost every CI/CD pipeline touching Kubernetes has this shape today. Service connections get created once, scoped to "the cluster" because that was easier than scoping to a namespace, and nobody revisits them until an incident forces the question. We covered the parallel problem on the GitHub Actions side in GitHub Actions secrets: a workflow with more scope than its job needs is a liability that sits quiet until someone with legitimate-looking credentials finds it.
Scope service connections to a namespace, not a cluster
The fix is unglamorous: stop granting Azure DevOps service connections cluster-admin-equivalent kubeconfigs, and issue scoped Kubernetes service accounts instead. A pipeline that deploys to one namespace should hold a credential that can only touch that namespace.
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
name: pipeline-deployer
namespace: payments
rules:
- apiGroups: ["apps", ""]
resources: ["deployments", "services", "configmaps"]
verbs: ["get", "list", "update", "patch"]
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
name: pipeline-deployer-binding
namespace: payments
subjects:
- kind: ServiceAccount
name: ado-pipeline-deployer
namespace: payments
roleRef:
kind: Role
name: pipeline-deployer
apiGroup: rbac.authorization.k8s.io
A Role, not a ClusterRole, bound to a namespace-scoped service account means a stolen credential is worth one namespace's deployments, not the cluster. Repeat the pattern per environment rather than sharing one service connection across staging and production.
On the Azure DevOps side, the service connection docs say plainly that Grant access permission to all pipelines "isn't recommended"; authorize each pipeline individually and add approvals and checks to the connection. A connection every pipeline can use is a connection any edited pipeline can abuse.
Make credentials short-lived instead of static
A scoped kubeconfig that never expires is still a standing credential worth stealing. Pair namespace scoping with short-lived tokens so anything copied into a repo goes stale before anyone finds it.
TOKEN=$(kubectl create token ado-pipeline-deployer \
--namespace payments \
--duration 1h)
kubectl --server "$K8S_API_SERVER" \
--certificate-authority ca.crt \
--token "$TOKEN" \
--namespace payments \
rollout restart deployment/payments-api
Mint the token inside the pipeline run, keep it in a job-scoped variable, and let it expire. --duration is a request, and the kubectl reference notes the server may return a different lifetime, so check your API server's limits. The identity that mints tokens should be allowed to create tokens for that one service account and nothing else; for AKS, Microsoft's docs point Azure Resource Manager connections at workload identity federation rather than a stored secret. Static kubeconfigs sitting in a variable group or a repository are exactly what Storm-3068 went looking for.
Correlate the signals into one alert
Microsoft's guidance is to monitor password reset activity for unusual patterns, such as repeated attempts or resets targeting several users. We would go one step further and treat a reset followed by a new authentication method registration on the same identity as one correlated alert, because that sequence is the persistence move in this case. Most tenants log both events separately, and neither triggers anything on its own. Pair that with Azure DevOps audit logs and Git history (the sources Microsoft's investigators used to reconstruct the pipeline stage) correlated against Kubernetes API server audit logs, so a pipeline suddenly reading credentials shows up next to the identity event that enabled it, not three dashboards away. Unexpected installs of remote-management or tunneling tools from a build job deserve their own alert.
Audit what pipelines are authorized to touch, now
Before the next incident forces it, pull every service connection in your Azure DevOps organization and list what each one is scoped to. Microsoft's report noted the compromised pipeline was authorized against more than 50 resources, a number that reads like scope accumulated over years rather than scope anyone deliberately granted. The audit is an afternoon of work: list service connections, check which pipelines may use each, list the RBAC bound to each one's service account, and cut anything broader than the pipeline's actual deploy target. Microsoft also recommends branch protection, required approvals on code changes, and controlling who can create, modify, or run pipelines, since the attacker's foothold was a pipeline edit. Our Kubernetes security best practices checklist covers RBAC least privilege in more depth if you are starting from zero.
The decision, concretely
- Does a pipeline's service connection need to reach more than one namespace? If not, scope the Kubernetes RBAC to a
Role, not aClusterRole, and issue a namespace-bound service account. - Is the kubeconfig a static, long-lived credential sitting in a variable group? Replace it with a short-lived token minted at job runtime, scoped to that run.
- Does your identity monitoring treat a password reset and a new authentication method as separate, unrelated events? Correlate them into one rule.
- Have you listed what every Azure DevOps service connection is authorized to touch, and which pipelines may use it, in the last year? If nobody has checked, that is this quarter's security backlog item.
Questions people ask
What is Storm-3068?
Storm-3068 is the designation Microsoft gave the threat actor in its September 2026 write-up of an intrusion that went from a self-service password reset to stolen Kubernetes credentials. The actor registered its own authentication methods, enumerated Azure DevOps, modified a pipeline authorized for more than 50 resources, and committed seven harvested kubeconfig files to a repository, using legitimate tools rather than custom malware.
How do I limit what an Azure DevOps pipeline can do in Kubernetes?
Bind the service connection's Kubernetes service account to a namespace-scoped Role instead of a ClusterRole, authorize the connection for specific pipelines rather than all pipelines, and add approvals and checks. Mint short-lived tokens with kubectl create token --duration at job runtime instead of storing a static kubeconfig, so a copied credential expires within hours.
Why is self-service password reset a risk for DevOps accounts?
If an attacker can pass the reset flow, they can set a new password and register their own authentication methods, which gives them persistent access that looks like the legitimate user. Microsoft recommends limiting privileged accounts' exposure to SSPR, requiring phishing-resistant MFA, and monitoring reset activity for unusual patterns.
The call we'd make
Treat every pipeline with Kubernetes access as a kubeconfig-exfiltration risk by default, because Storm-3068 showed no malware is required to turn one into exactly that. Scope service connections to a namespace and to named pipelines, make the credentials short-lived, and wire the reset-plus-new-auth-method correlation into detection this month. None of this is exotic engineering; it is the least-privilege and log-correlation work most teams keep deferring until an incident makes it mandatory. Our notes on AI agent security cover the same scoped-credential discipline for agentic tooling with pipeline access.
Sources
Cite this article
Kiril Urbonas (2026). Storm-3068: A CI/CD Pipeline Is a Kubeconfig Exfiltration Machine. DevOpsNess. Updated 2026-11-15. https://www.devopsness.com/blog/storm-3068-azure-devops-kubernetes-credential-theft
[Storm-3068: A CI/CD Pipeline Is a Kubeconfig Exfiltration Machine](https://www.devopsness.com/blog/storm-3068-azure-devops-kubernetes-credential-theft) (Kiril Urbonas, DevOpsNess, updated 2026-11-15)
More from DevOps
Explore more articles in this category
Terragrunt Explained: When You Actually Need It
Terragrunt keeps large Terraform setups DRY and orchestrated, but small teams often pay its learning curve for little return.
Rust vs Go: Which Systems Language Should You Learn?
Both are fast, modern, and compiled, but they were built for different problems. This is the map: where each wins, what each costs, and how to pick for your next service, tool, or Wasm module.
Git Rebase vs Merge: When to Use Each
The rebase-vs-merge fight is mostly people talking past each other. Here's the rule we follow: rebase local work, merge shared branches.
You might have missed
Evergreen posts worth revisiting.