Hardware-rooted proof that an on-chain action came from a genuine, uncompromised device · status as of 2026-10-20
As blockchain moves onto phones — mobile wallets, mobile validator nodes, and tokenization SDKs embedded in consumer apps — the device itself becomes part of the trust boundary. A signature is only as trustworthy as the environment that produced it. A Battua wallet running on a rooted Android phone, or a tokenization SDK inside a jailbroken iOS build or an emulator farm, can produce cryptographically valid transactions that nonetheless originate from a compromised or automated environment. Classical wallet security cannot see this: the ledger accepts any well-formed signature regardless of where it was created.
Aurigraph closes this gap with device attestation — a defense-in-depth layer that verifies, server-side, that a mobile action came from a real device running a genuine app binary, using the hardware roots of trust built into modern phones: Google Play Integrity on Android and Apple App Attest / DeviceCheck on iOS. The server-side verification pipeline — stateful single-use nonces, Play Integrity token decoding, and full two-phase App Attest verification — is implemented in the V12 tree and covered by unit, hermetic and integration tests (146 @Test methods across 12 attestation test classes plus a 9-case DeviceAttestationFlowIT, counted by annotation on V12 8b00dcf38; they run in the platform's CI and were not re-executed for this revision). Live end-to-end enablement is gated on externally provisioned credentials (a Google service-account key and the Apple App Attest root certificate), which an operator supplies at deploy time. This paper describes why device trust matters, how the hardware roots of trust work, what Aurigraph has built, what a verified device unlocks, and the honest limits of the model. For the underlying ledger and consensus substrate, see the Aurigraph DLT whitepaper.
V12
@Test
DeviceAttestationFlowIT
8b00dcf38
Mobile is where the next wave of on-chain users live, and it is also where the attacker's job is easiest. Three failure modes recur:
Rooted and jailbroken devices. Root or jailbreak removes the OS guarantees an app depends on. On a rooted device, an attacker can read process memory, hook signing routines, tamper with the app binary, and exfiltrate secrets that were supposed to be sandboxed. A wallet may sign a transaction the user never intended, or one whose parameters were silently altered.
Emulators and instrumented environments. Emulators and instrumentation frameworks let an attacker run thousands of synthetic "devices" at scale. This is the substrate for airdrop farming, faucet abuse, sybil attacks against staking or governance, and automated draining of any endpoint that assumes "one request equals one human on one phone."
Bots and replay tooling. Even without a rooted device, a captured request can be replayed. If a signing challenge or attestation can be reused, an attacker replays it to mint duplicate approvals or bypass a one-time check.
The common thread: a valid signature says this key signed this message, but it says nothing about the integrity of the environment that held the key. For a mobile validator node participating in consensus, or a wallet moving high-value tokenized assets, that missing half of the picture is exactly where the risk concentrates. Device attestation supplies the missing half.
Both major mobile platforms now expose a hardware-backed way to prove device and app integrity. Aurigraph consumes both.
Play Integrity lets a server ask Google a question the app cannot answer for itself: is this a genuine Android device, running an untampered copy of my app, with a licensed Play account? The flow is:
decodeIntegrityToken
MEETS_DEVICE_INTEGRITY
MEETS_STRONG_INTEGRITY
Because the token is signed by Google and decoded on the server, a rooted device or a repackaged app cannot forge a passing verdict — it can at most fail to produce one.
Apple's App Attest is built on a key pair generated inside the device's Secure Enclave, hardware that never releases the private key. It works in two phases:
DeviceCheck is the complementary Apple service for lightweight per-device state (e.g., two bits of persistent device flags and per-app usage signals), useful for coarse abuse-limiting where full App Attest is unnecessary.
Together these give a server a hardware-rooted answer to is this a real Apple device, running my real app, making a fresh request?
Aurigraph implements the server side of both flows — the part that actually decides trust. The client (mobile SDK / Battua) merely collects tokens; the verifier is where the checks have teeth. The design deliberately performs no trust decision on the device.
Every attestation begins with a server-issued nonce backed by a persistent store (attestation_nonces, migration V184). Nonces are single-use and redeem-before-verify: the verifier atomically consumes the nonce before doing any cryptographic work, and rejects anything stale (freshness window ≤ 5 minutes) or reused with distinct, structured error codes — NONCE_NOT_ISSUED, NONCE_EXPIRED, NONCE_ALREADY_USED. This is the primary replay defense and it is enforced in the database, not in memory.
attestation_nonces
NONCE_NOT_ISSUED
NONCE_EXPIRED
NONCE_ALREADY_USED
PlayIntegrityVerifier is wired to a GoogleIntegrityClient interface whose implementation performs the OAuth2 service-account JWT exchange and calls Google's decodeIntegrityToken. Verdict fields are parsed and evaluated against acceptance policy. Crucially, the Google client is interface-injected, so the full verification path — nonce binding, verdict parsing, policy enforcement — is exercised by tests without ever calling live Google.
PlayIntegrityVerifier
GoogleIntegrityClient
AppAttestVerifier implements the complete Apple flow:
AppAttestVerifier
1.2.840.113635.100.8.2
SHA-256(authenticatorData ‖ SHA-256(clientData))
keyId == SHA-256(uncompressed EC public-key point)
rpIdHash == SHA-256(appId)
app_attest_keys
keyId
KEY_NOT_ATTESTED
Discriminating negative tests — ASSERTION_SIGNATURE_INVALID, COUNTER_REGRESSION, NONCE_MISMATCH, KEY_ID_MISMATCH, APP_ID_MISMATCH, KEY_NOT_ATTESTED — all pass, which is what demonstrates the verification actually rejects tampering rather than rubber-stamping it. Errors surface as RFC 7807 ERR_ATTEST_* problem responses so clients can guide users to remediation.
ASSERTION_SIGNATURE_INVALID
COUNTER_REGRESSION
NONCE_MISMATCH
KEY_ID_MISMATCH
APP_ID_MISMATCH
ERR_ATTEST_*
The verification code is real and tested (146 @Test methods across 12 unit/crypto/hermetic/DTO test classes plus a 9-case DeviceAttestationFlowIT that boots the schema and runs the full /nonce → attest → assert path — with no live Google or Apple dependency; counts are by annotation on V12 8b00dcf38, results come from the platform CI rather than this document). What is not yet live end-to-end is the external wiring: the Google Play service-account key and the Apple App Attest root certificate are provisioned separately by an operator at deploy time, and the mobile-SDK native modules that collect tokens on-device remain gated. Until those secrets are supplied, the system makes no outbound call to Google or Apple — the relevant configuration defaults to empty and the path stays inert. This is a deliberate go-live gate, not a mock standing in for missing logic: the server-side decision engine is built; only the third-party credentials that let it talk to Google and Apple in production are pending.
/nonce → attest → assert
A verified device is not an end in itself — it is a gate that unlocks higher-trust actions. Attestation is designed to bind to identity and authorize tiered operations:
The result is that "who signed" is augmented by "on what, verified, device," and that fact can itself be recorded as an attestation event for the audit trail.
Attestation raises the attacker's cost substantially, but it is defense-in-depth, not a silver bullet. Honest limits:
On mobile, the device is part of the trust boundary, and a valid signature alone no longer tells the whole story. Aurigraph's device attestation layer supplies the missing half — hardware-rooted proof, verified server-side, that an on-chain action came from a genuine, uncompromised device. The verification engine is built and thoroughly tested: stateful single-use nonces, Play Integrity token decoding, and full two-phase App Attest verification with real cryptographic checks that demonstrably reject tampering. What remains before production is the operator-provisioned external wiring — a Google service-account key and the Apple root certificate — after which the same code runs live end-to-end. Combined with Battua's MPC custody and post-quantum signing, device attestation moves Aurigraph's mobile trust story from "a valid key signed this" to "a proven device, holding a distributed key, signed this" — a materially higher bar for any attacker.
DCAppAttestService
Explore: About · Products · Features · Whitepapers · Sustainability · Tokenized carbon credits · Real-world asset tokenization · SDK · Blog · Plain-text site index · Sitemap · Contact: contact@aurigraph.io