The number that stuck with me was one. One compromised developer identity. From there Storm-3068 read source code, pulled long-lived cloud credentials out of a CI/CD pipeline, and ended up with standing control of Azure infrastructure. No zero-day. No exotic malware. A stolen login and a series of defaults nobody had bothered to change.
I read Microsoft’s analysis on the 29th, closed the tab, and then did the only useful thing you can do with a report like that: I ran the same path against my own estate to see how far I’d get. Here’s what I found, roughly in the order I found it.
The first hour was about how the identity got in
Microsoft’s account starts with a compromised developer account. Not a service account, a human, with a laptop, an IDE, and repo access. The interesting question isn’t how it was phished; it’s why the phish worked all the way to a token.
So I started where the attacker would: sign-in logs, filtered to my developer group. I wanted to know how many of them could authenticate with something a phishing kit can replay.
That list was longer than I wanted. “MFA capable” and “phishing-resistant” are not the same sentence. SMS, voice, and the Authenticator number-match prompt all survive a decent man-in-the-middle proxy, the attacker relays the prompt, you approve it, they keep the session token. Storm-3068 didn’t need your password after that point. They needed your session, and a token doesn’t care which browser it lands in.
The control that breaks this stage is boring and specific: require phishing-resistant credentials, passkeys or certificate-based auth, for anyone who can touch source or pipelines, and enforce it with a Conditional Access authentication strength.
Report-only first. I have watched a well-meaning “require passkey” policy lock a release team out of Azure DevOps at 5pm on a Friday. Don’t be that person.
By late morning I was inside the repo, and the repo was the vault
Here’s the part the report is polite about and I’ll be blunt about: the source code wasn’t the prize. The secrets in and around the source code were. Storm-3068 read the pipeline definitions, found credentials, and used them. That’s the whole trick.
Pipeline secrets are where good intentions go to rot. Someone needed a service principal client secret in 2023 to unblock a deployment, dropped it into a variable group “temporarily,” and it’s still there, non-expiring, over-permissioned, and readable by anyone who can edit the pipeline. I found three of those in twenty minutes of my own repos. One of them had Contributor at the subscription scope.
So I went looking for the blast radius. This is the query I’d start any post-incident triage with, service principals holding privileged roles across the tenant:
And the credential side of the same coin, app registrations with secrets or certificates, so you know which identities can be impersonated with a string of text:
Any app with a passwordCredential is an app whose keys can live in a pipeline variable, a wiki page, or a former employee’s Notes app. Count them. The number is your problem.
The fix I got wrong before I got it right
My first instinct was to rotate all the secrets and shorten their lifetime. Ninety days, alerts on expiry, the usual. I did it. Then I realized I’d just built a faster treadmill. A ninety-day secret is still a bearer credential that a pipeline log, a compromised runner, or an over-broad repo read can leak. Rotation reduces the window. It doesn’t remove the thing being stolen.
The actual fix is to delete the secret entirely. Workload identity federation lets a pipeline exchange its own OIDC token for an Azure access token, no stored client secret, nothing to exfiltrate, and access that only works from the pipeline you configured.
Note the subject. It’s pinned to one repo and one environment. A token minted for a pull-request branch, or a fork, or a different repo, doesn’t match and gets nothing. That’s the property Storm-3068 would have run into: a credential that can’t be lifted out of context because there’s no credential to lift.
Azure Pipelines has the same pattern via workload identity federation service connections. Turn it on, then go find every classic service connection still holding a secret and kill it.
The afternoon lesson: standing access was the real gift
Once the attacker had a working service principal, nothing expired and nothing questioned it. That’s the design flaw underneath the whole chain, the pipeline identity had permanent rights to production. Human admins in a half-decent tenant go through PIM for elevation. The workload identities running deployments usually don’t, and they’re the ones with Contributor everywhere.
You can’t put every service principal behind just-in-time elevation, but you can scope them to death. That over-privileged principal I found didn’t need subscription Contributor; it needed to restart three app services in one resource group. Least privilege is unglamorous and it is the single control that would have turned “full Azure control” into “annoying but contained.”
For the human side, I also checked which of my Conditional Access policies actually applied to the DevOps and Azure management planes, because a policy that exempts “developer tooling” is a policy the attacker will happily use:
Look for exclusions. Every exclusion is a door. The break-glass account is fine; the “temporary” exclusion for a CI service account from 2024 is not.
What I’d tell you before you start
The instinct after reading this is to call it a pipeline problem and hand it to the DevOps team. It isn’t. It’s an identity problem that happens to pass through a pipeline. The credential got in as a person, moved as a repo secret, and did damage as a cloud principal, three different identity surfaces, three different teams, and the attacker treated them as one continuous path because they are.
So treat them as one. The principle worth writing on the wall: a credential is not trustworthy because it came out of your repo. Your repo is not a vault, your pipeline is not a security boundary, and a service principal secret is a password that happens to belong to a robot.
Run the four queries above this week. If any of them return a service principal with subscription Owner and a non-expiring secret, you already know how your version of this story ends. Go federate it before someone else does.
