Five minutes separated a public repository secret find from Azure Key Vault data theft in one case Microsoft watched end to end. Key Eater is the late-2026 campaign in which operators used the ARTEX agentic AI framework to mine public repositories for exposed Entra application client secrets and related cloud credentials, then signed in as service principals with those valid secrets and no interactive user MFA prompt. According to the Microsoft Security Blog on 5 November 2026, successful service-principal authentications from 199.19.77.84 and associated infrastructure spanned multiple application IDs and tenants from about 28 October 2026, and compromised apps went on to request Graph and Key Vault tokens, pull SharePoint and OneDrive files, and read mailbox items.
How ARTEX turned GitHub secrets into service-principal access
ARTEX activity against public GitHub started in August 2026. Operators fed the agentic tooling large volumes of queries aimed at organization names, secret keywords, and cloud and AI service strings. The goal was not a clever zero-day against Entra. It was industrial search for credentials people had already pasted into repos and left sitting there.
Valid Entra application client secrets are long-lived shared secrets. Anyone who holds the secret can present it as the application. Microsoft’s write-up is blunt on the product side: Microsoft identified no product vulnerability. Possession of valid secrets by themselves enabled app-only access. That is the whole initial-access story. The secret left the vault of “private” development practice and became a reusable credential on the open internet.
Microsoft recorded successful service-principal authentications from 199.19.77.84 across multiple application IDs and tenants beginning around 28 October 2026. A related address, 199.19.77.18, appeared as a Tor exit node that may mix unrelated traffic, so secondary IPs need careful reading. What does not need careful reading is the auth model. App-only client-secret authentication is not an interactive workforce login. It does not present a password field to a human, does not fire a push, and does not wait for a FIDO ceremony. The stolen secret is the proof.
Microsoft’s own language on exposure is operational, not theoretical. Publicly exposed credentials remain usable until revoked or rotated. Removing the original disclosure alone does not remediate the exposure. Organizations that find their secrets in public repositories must assume the exposed secrets and associated applications are compromised. That assumption is the correct incident-response posture, not a nice-to-have.
Todyl’s parallel telemetry on overlapping infrastructure fills in the defender-side clock. First stolen-app access in its monitored set hit at 08:45 UTC on 1 November 2026. By 3 November, bulk downloads and sweeps crossed 15 client tenants. Microsoft states a similar campaign on the same IPs was reported by Todyl. Individual victim company names are not in the public write-ups, and totals outside that monitored set are unknown.
| Control surface | What attackers used | Why it failed here |
|---|---|---|
| Entra app client secret | Secret found on public GitHub | Long-lived secret, no human second factor |
| Service-principal sign-in | App-only auth with stolen secret | No user MFA prompt by design |
| Multitenant / vendor apps | Downstream tenant reach | One secret, many customer tenancies |
| Session / refresh tokens | Graph, Key Vault, DevOps reuse | Replay after the secret already worked |
What stolen app credentials unlocked next
Compromised multitenant and vendor-owned application credentials authenticated into downstream customer tenants. That pattern matters for MSPs and software vendors whose apps sit in many directories at once. One leaked secret is not one mailbox. It is a path into every tenant that trusted the app registration.
Inside those tenants, operators enumerated Azure subscriptions, resource groups, permissions, AI model deployments, and service configurations. They obtained tokens for single-tenant OAuth applications local to the target. Compromised apps requested Microsoft Graph, Key Vault, and related tokens. Content searches dominated Graph traffic. SharePoint and OneDrive files came down. Mailbox items were read. In Todyl’s view of the activity, 45 app registrations were targeted, more than 33 authentications succeeded, 27 organizations were touched including MSP downstream clients, 81 files were downloaded, and about 2,279 mailbox items were accessed.
Target shopping lists read like a cloud credential scavenger hunt: storage account keys, App Service settings, connection strings and publishing credentials, AI and ML connections and datastores, AKS user credentials, Foundry Tools style AI service credentials. Agents used compromised OAuth apps with Run Command on Azure VMs. ARM and Key Vault probing showed adaptive behavior. Key Vault metadata enumeration failed with HTTP 400, then succeeded about 28 seconds later after the client switched to ARM API version 2023-07-01 and received HTTP 200. That is not a confused script. That is tooling that retries until the cloud API answers.
Todyl also observed Azure DevOps federated-identity use and user session-token replays, plus later Conditional Access blocks on refresh-token replays across its monitored set. Token replay here is the aftershock of credential use that already succeeded. Revoking refresh tokens and tightening Conditional Access can interrupt the encore. It does not un-send the secret that was sitting in a public repo in August.
One observed case collapses the whole chain into a single stopwatch reading. According to Microsoft Threat Intelligence, an AI agent found exposed credentials in a public repository and had already pulled material from Azure Key Vault only five minutes later. Human dwell-time folklore does not apply when the hunter is an agent looping search, authenticate, enumerate, and exfiltrate.
Why user MFA never entered this path
Workforce MFA debates usually start at the human login box. Key Eater never needed that box. Service-principal sign-ins with stolen application client secrets are app-only. There is no employee to vish, no push to fatigue, no OTP to relay, and no helpdesk recovery secret to social-engineer. Sources do not describe an interactive user login path as the primary vector, and they do not show user MFA being defeated on these app-only sign-ins because user MFA was not in the ceremony.
That is an architecture gap, not a “users clicked badly” story. Long-lived client secrets in source control, CI logs, sample apps, and forgotten forks are still treated like configuration trivia in too many engineering cultures. Multitenant vendor apps amplify the blast radius when those secrets leak. Downstream customers inherit the vendor’s secret hygiene whether they know it or not.
Session and refresh token replay against Graph, Key Vault, SharePoint, mail, and Azure DevOps is what you get after the secret already worked. Conditional Access eventually blocked some refresh-token replays in Todyl’s set. That is containment after access, not prevention of the secret harvest. Shortening token lifetimes forces the operator to re-authenticate sooner. It does not rotate the client secret that is still valid in the attacker’s notes.
Named threat-actor attribution is absent from the public record. Full provenance of every stolen secret is not established beyond public-repo exposure in the observed cases. Secondary IPs used for shell-in-UA, App Service token attempts, or AI workload recon are not fully proven as one actor for every hit. None of those gaps softens the mechanism Microsoft did document: agentic search, exposed Entra app secrets, service-principal sign-in, cloud resource and mailbox reach.
Defenders who only measure “MFA coverage on users” will score this campaign as a mystery. The scoreboard that matters is workload identity: where client secrets still exist, how long they live, whether they ever touched a public git history, which multitenant apps can reach customer tenants, and how fast rotation and revocation run when a scanner lights up. Human phishing-proof login is still necessary for people. It does not substitute for killing shared app secrets that never asked a person anything.
The defensive side of this case is covered in the related article on mfa2point0.com: why user MFA never applied to Key Eater service-principal secrets.
FAQ
How did Key Eater attackers get into Entra tenants?
Key Eater operators got in by using valid Entra application client secrets found through ARTEX searches of public GitHub repositories, then completing service-principal (app-only) sign-ins. According to Microsoft’s 5 November 2026 Security Blog, those sign-ins needed no interactive user MFA prompt because app-only client-secret authentication does not challenge a human. Successful authentications from infrastructure including 199.19.77.84 crossed multiple application IDs and tenants from about 28 October 2026.
Did Key Eater bypass user MFA on Microsoft 365 or Entra?
Key Eater did not bypass user MFA on an interactive workforce login as the primary path. Stolen application client secrets authenticated as the app itself. Microsoft reported no product vulnerability; possession of valid secrets by themselves enabled app-only access. User MFA never sat in front of those service-principal sign-ins, so framing this as an MFA push-fatigue or OTP-relay story misses the mechanism.
What data and cloud resources did compromised apps reach?
Compromised apps requested Microsoft Graph and Key Vault tokens, downloaded SharePoint and OneDrive files, accessed mailbox items, and enumerated Azure subscriptions, resource groups, permissions, and service configurations. Todyl’s monitored set saw 27 organizations impacted including MSP downstream clients, 81 files downloaded, about 2,279 mailbox items accessed, 45 app registrations targeted, and more than 33 successful authentications. In one Microsoft-observed case, five minutes elapsed between discovering a secret in a public repository and pulling material from Azure Key Vault.
Why did multitenant and vendor app secrets matter so much?
Multitenant and vendor-owned application credentials, once stolen at the source, authenticated into downstream customer tenants. That reuse turned a single exposed secret into cross-tenant reach without a fresh human login in each customer directory. Attackers then pulled tokens for single-tenant OAuth apps inside those tenants and continued enumeration and collection. MSP-style downstream exposure in Todyl’s numbers follows directly from that trust pattern.
Does deleting the secret from GitHub stop Key Eater-style access?
Deleting the secret from GitHub does not stop access by itself. Microsoft states publicly exposed credentials remain usable until revoked or rotated, and removing the original disclosure alone does not remediate the exposure. Organizations that find secrets in public repositories must assume the secrets and associated applications are compromised, rotate them, revoke tokens, and review every tenant and API permission those apps could touch.