Back to the blog
AndroidSecurityPrivacy

ASN Bank blocks GrapheneOS: the Play Integrity problem

November 07, 2026·6 min read·Diego Horvatti

A Dutch bank that calls itself "idealistic" just locked the door on people using the most secure phone on the market. ASN Bank now blocks its app on Android devices without Google certification, and that includes GrapheneOS. The report is in PrivSec's banking app compatibility repository, which the community maintains itself. The irony is hard to miss. The user who cares most about security became the suspect.

It's worth a closer look, because this isn't only the bank's call. The same decision shows up in every app that needs to "trust the device". If you work with React Native or on a fintech backend, it will land on your desk sooner or later.

What happened with ASN Bank

ASN is part of de Volksbank, a group that also owns SNS and RegioBank. The brand positions itself as a sustainable and ethical bank. It's fair to assume its customers include more privacy-minded people than average.

Even so, the app started refusing devices that fail Google's integrity check. In practice, anyone running GrapheneOS, and almost certainly anyone on another alternative ROM, opens the app and hits a wall.

The most likely mechanism is the Play Integrity API. It's the tool Google offers so an app can ask whether it's running on an "approved" Android. As far as the report shows, the bank hasn't explained the reason publicly or offered any alternative.

How Play Integrity decides who to trust

The flow is simple. The app asks Google Play Services for a token. That token goes to your server. The server sends it to Google for decoding and gets back a verdict that looks roughly like this:

{
  "deviceIntegrity": {
    "deviceRecognitionVerdict": ["MEETS_BASIC_INTEGRITY"]
  },
  "appIntegrity": {
    "appRecognitionVerdict": "PLAY_RECOGNIZED"
  }
}

There are three common levels:

  • MEETS_BASIC_INTEGRITY: the device passes basic checks, even without certification.
  • MEETS_DEVICE_INTEGRITY: Google-certified Android, with official Play Services.
  • MEETS_STRONG_INTEGRITY: the same, plus hardware-backed proof and recent patches.

The detail that breaks everything is in the second item. "Certified by Google" doesn't mean "secure". It means the manufacturer signed a contract with Google. GrapheneOS runs on Pixels. It has a bootloader locked with its own key, working verified boot and up-to-date security patches. Technically, it's more hardened than plenty of vendor Android builds that get an update once a year. But it doesn't have Google's seal, because the project has no way to get it.

Google certification measures a business contract, not security.

The result: a 2021 Samsung with no update in months passes. A Pixel with GrapheneOS updated yesterday fails.

Why banks do this

To be fair to the bank: nobody on the fraud team wakes up wanting to annoy GrapheneOS users. The reasoning usually goes like this:

  1. Fraud in banking apps is expensive, and regulators push hard.
  2. A rooted device allows hooks, overlays and scam automation.
  3. Play Integrity hands you a ready-made yes or no, signed by Google.
  4. Blocking anyone who fails is one line of code and one less audit item.

It's the path of least resistance. And I get it. I like lazy solutions too, as long as they work.

The problem is this one doesn't work as well as it looks. Well-hidden root has passed the basic level for years, and tools like spoofing modules chase every change Google makes. People who want to commit fraud find a way. The ones left out are honest users who chose a more secure system and didn't want to hide it.

There's also a cost that doesn't show up on the spreadsheet. The bank now depends on an American company to decide who can access their own account. For a European bank that talks about autonomy and ethics, that's a strange choice.

Is there an alternative to Play Integrity?

Yes, and it's more precise: Android's own hardware key attestation. Every modern device has a secure chip (TEE or StrongBox) that generates a key and returns a certificate chain. That chain carries boot data: whether the bootloader is locked, whether verified boot passed, the patch level and the public key of the operating system that was verified.

With that, the server can say "I accept stock Android from manufacturers X and Y, and also GrapheneOS signed with this key". GrapheneOS itself publishes an attestation compatibility guide for app developers, with the official keys for its builds. In practice, it's an allowlist.

On the server, the logic looks something like this (simplified, after validating the certificate chain up to Google's root):

type Attestation = {
  verifiedBootState: 'Verified' | 'SelfSigned' | 'Unverified' | 'Failed'
  deviceLocked: boolean
  verifiedBootKey: string // hex hash of the OS key
  osPatchLevel: number    // e.g. 202610
}

// official build keys, taken from the GrapheneOS documentation
const ALLOWED_OS_KEYS = new Set<string>([/* ... */])

export function isTrustedDevice(a: Attestation, minPatch: number) {
  if (!a.deviceLocked) return false
  if (a.osPatchLevel < minPatch) return false
  if (a.verifiedBootState === 'Verified') return true // stock OS
  // alternative OS with a locked bootloader and a known key
  return a.verifiedBootState === 'SelfSigned' && ALLOWED_OS_KEYS.has(a.verifiedBootKey)
}

Notice the criteria are now about real security: locked bootloader, verified boot and a recent patch. No "has the business seal". Is it more work than if (verdict.includes('MEETS_DEVICE_INTEGRITY'))? Yes. A few hours of work, not a quarter.

What changes for app developers

If you work on an app that handles money, health or identity, here are three practical decisions:

Don't treat integrity as binary. Use the verdict as a risk signal, not as a gate. A device that fails could lose access to transfers above a certain amount, or require an extra confirmation. That's very different from not even opening the login screen.

Always validate on the server. I've seen React Native apps check the verdict on the client and unlock the screen based on a local boolean. That protects nothing. The token has to go to the backend, and the backend decides.

// wrong: the client decides
if (await checkIntegrityLocally()) navigate('Home')

// right: the server decides and returns the access level
const { accessLevel } = await api.post('/session/attest', { token })

Offer a way out. Browser-based online banking, a hardware token, anything. A block with no alternative locks customers out of their own accounts. In Europe, this starts to run into accessibility and competition debates, because it ties an essential service to a single operating system vendor.

Some scale helps here. The GrapheneOS community is small compared to the Android user base, so the bank probably ran the numbers and decided losing that slice didn't matter. But that slice is full of journalists, security researchers and people who work in tech. It's exactly the crowd that files GitHub issues and writes blog posts. This one, for example.

My take

I think ASN's decision is lazy in the worst sense. Not the lazy that solves the problem with less code. The lazy that outsources judgment and calls it security. Play Integrity is a useful tool as a signal. As the only access rule, it punishes people who do everything right and barely slows down people who want to do wrong.

If your app needs to trust the device, spend an afternoon on hardware attestation and a well-documented allowlist. Your fraud team stays protected, and you don't kick out your most careful users. That's the kind of small technical decision with real impact I try to apply in the projects I build.

LinkedIn summary

I run GrapheneOS on a Pixel, updated yesterday. The bank would still treat me as a suspect.

ASN Bank sells itself as an ethical bank. It now blocks any Android device without Google's seal, using Play Integrity.

The problem is that this seal measures a business contract, not security. A Samsung that hasn't seen an update in months passes. A hardened system, with a locked bootloader and current patches, fails.

People who want to commit fraud hide root and move on. The ones left out are the most careful users.

There is a technical fix: hardware attestation with a key allowlist, validated on the server. It takes an afternoon of work, not a quarter.

If your app needs to trust the device, treat integrity as a risk signal, not as a gate. I wrote about it on the blog, with code. I'd like to know how your team handles this.

#AndroidDev #ReactNative #InfoSec #Fintech #Privacy