DEV Community

Cover image for Google is patching keyboxes and yet fake accounts are growing
Garou 公敵
Garou 公敵

Posted on Originally published at areyougarou.com

Google is patching keyboxes and yet fake accounts are growing

Originally published on areyougarou.com.

TL;DR: Google Play Integrity no longer keeps fake accounts out: a rooted phone relays its hardware key attestation to a second rooted phone that passes. On our phones a rooted Pixel 6a earned a passing verdict from a separate Nothing Phone 2a, over the Ommega relay. Back it with an on-device check for the relayed key and device fingerprinting, as SEON or Intakto do.

Why do abusers create fake accounts? Because they're profitable.
Social media scams cost Americans $2.1B in 2025, 8x the 2020 figure
Bank-transfer scams cost UK customers $767.3M in 2025, +19% on 2024
Romance scams cost UK victims $52.2M in 2025, +23% on 2024
Fake sign-ups: 8.3% of account-creation attempts were suspected fraud in 2025, +18% on 2024
Same goes for competitive games, crypto wallets, web3, you name it.

And it's profitable because it's easy. If it weren't, numbers would be shrinking, not growing.
There are only two major bottlenecks for the abusers: The first one is Google Play Integrity. The attacker knows that all major apps evaluate Play Integrity as part of his fraud score. If the device falls short of device integrity, you get bombarded with rate limits, captchas and face verifications. Genuine users get harmed in the process.

Google has been fighting for years to bolt in the secure environment and flagging the leaked keyboxes.
But attackers are already 2 years past that.

Is root + strong integrity needed to set up an Android bot farm? Yes, it's mandatory to bypass various detections (automation, geolocation spoofing, proxy, ...). You can obtain both (root + strong integrity) in various ways, but I want to tackle the one that's been growing the most in popularity: We'll call it the Oracle Device.
The solution is already freely available and open source on GitHub.

The method is simple: two phones. The app on the relayer asks for an attested key the normal way, a KeyPairGenerator for the AndroidKeyStore with setAttestationChallenge(nonce). On an honest phone that call runs app → keystore2 (the system keystore service) → the IKeyMintDevice HAL, where the secure chip mints and signs the attestation. The Oracle Device trick hooks keystore2 on the relayer and reroutes that generateKey call across the network to the oracle, whose own IKeyMintDevice signs it and hands the certificate chain back.
There are two things to get right. The first is identity: keystore2 stamps every attestation with Tag::ATTESTATION_APPLICATION_ID, a value it builds itself from the caller (the package name, the signing-certificate digest and the UID) and that the app is not allowed to set. So the oracle must feed its KeyMint the relayer app's ATTESTATION_APPLICATION_ID, not its own, and overriding that tag on the signing side is a privileged write. Which is the second thing: both phones are rooted. The relayer needs root to hook keystore2 and intercept the generateKey before the local chip answers; the oracle needs it to inject the relayer's identity tag into its own KeyMint call.1
Here's the paradox: how does the oracle pass strong integrity if it has to be a rooted Android phone?

You use a phone that passes strong integrity even though it is rooted: the Nothing Phone 2A, through its MediaTek exploit (Fenrir). Its root is what lets it fake a locked, clean state while you still fully own the phone.
At this point you might ask: Why not simply use the Nothing Phone 2A, instead of setting up this whole mess?
Because the second major bottleneck is machine learning and device fingerprinting. Trying to register thousands of accounts with the same niche device model is not exactly the definition of "blending with real traffic", you eventually get caught by solutions like Arkose Labs, SEON or Intakto.
But with the Oracle keybox now you can connect multiple devices to the same oracle and scale the operations.

Why should we care?

Ommega is increasing in adoption exponentially (star history):

.ax{font-size:12px;fill:currentColor;opacity:0.85}

050100150200
SepOctNov



200 stars
3

Pay attention: 200 stars happened in just 3 months

Yuri, Tryigit and Evokerr are all selling strong integrity as a product.

Tryigit even sells The Apex™ tier. It sounds very alpha male, very sigma.

The trajectory is strongly pointed at solutions where anyone can build internally a strong-integrity oracle or rent it from third parties.
Compared to 2 years ago, this is an upgrade for bot farms for two reasons:
1) The attacker doesn't have to wait for leaked keyboxes;
2) Device recall becomes close to useless since one oracle costs $60 and can be resold for $50 on eBay, costing the attacker barely $10 per burned keybox.

This is who you're fighting against

Now that we know the mechanism, how can we catch fake accounts?

This is where it gets interesting.
As you might know by now, our research is aimed specifically at catching scaled operations with economic incentives for the attacker.

We asked ourselves:
"Is there any computationally inexpensive check with the lowest false positive rate we can introduce that catches the scaled operations?"

As you might imagine, these requirements rule out lots of juicy approaches.
After 200 hours of combined research, we found two solutions. We are keeping the second one proprietary.

The solution we'll disclose here starts from an interesting analysis: 96% of devices have screen lock.
We generate a signing key with setUserAuthenticationRequired(true) and a short validity window (setUserAuthenticationParameters, device-credential or biometric), so the secure chip will sign with it only in the seconds after the user unlocks the phone, and we attest it with setAttestationChallenge. To use such a key, KeyMint (the secure-chip service that signs) demands a hardware auth token: a small proof that the user just authenticated, minted by Gatekeeper (the lock-screen service) or the biometric chip and signed with an HMAC secret that Gatekeeper and KeyMint agree on at boot and that never leaves this one phone's secure hardware.

A relay cannot honor that requirement. The key lives on the oracle's KeyMint, but the unlock happens on the relayer, and the oracle cannot verify an auth token minted by a different phone's Gatekeeper. That leaves the relay two moves, and both give it away. It can keep the requirement, in which case the sign simply fails, no unlock will ever satisfy it. Or it can drop the requirement so the key signs freely, and that drop gets written by the oracle's own chip into the signed attestation, where the relayer cannot touch it. Either way, you asked for an auth-bound key and the phone cannot hand you an honest one.

We measured the drop on the live relay. The relayer asked for the auth-bound key; the Nothing Phone 2a issued it three times out of three with noAuthRequired, its userAuthType and authTimeout stripped, and every signature went through with no unlock at all. The genuine Pixel 6 Pro kept userAuthType=3 and authTimeout=3600 and signed only after a PIN unlock. And it didn't misfire on a real user: a genuine phone always attests back the requirement you asked for, and a phone with no secure lock screen throws InvalidAlgorithmParameterException at key creation, so it is skipped, never accused.
This check fits fintech and banking apps best: they usually require a secure lock screen, so coverage there is close to full.2

Assuming you're not in fintech, banking or payment: What happens if the user doesn't have screen lock activated? It covers 96% of devices. In the remaining 4% you have a weak signal to feed your server fraud score.
The check above is very hard to spoof, but not impossible. Introducing it will trigger a ban wave and give attackers a really bad weekend. And at the end of the day that's the goal: Raising costs for the attacker as much as possible so they attack our competitors instead. If we can do that without harming the real user in the process, we count that as a win.

Our research will increase as Oracle Device-based solutions increase in popularity, but most of it will probably be kept proprietary.


  1. We have reason to believe the relay works just as well with an oracle that is not rooted at all, an ordinary clean phone that already passes strong integrity on its own. If that holds, the signing side needs no compromised hardware anywhere, which would be far more damaging for Google than the rooted version we show here. As of now we have bigger priorities than to prove this attack class. Either way, the check stated here never assumes the oracle is rooted, so it catches both. ↩

  2. No rule we found names a lock screen, but the rules push banks toward strong authentication. In the EU: PSD2 Article 97 and Regulation (EU) 2018/389. The EBA says that, when a card is added to a phone wallet, unlocking the phone does not count as an authentication element if the card issuer does not control the screen lock (Q&A 2021_6145). ↩

Top comments (0)