{"id":4463,"date":"2026-09-24T14:10:04","date_gmt":"2026-09-24T12:10:04","guid":{"rendered":"https:\/\/darioiannascoli.it\/blog\/android-18-secure-enclave-runtime-attestation-hardware-key-derivation-proof-presence\/"},"modified":"2026-09-24T14:10:04","modified_gmt":"2026-09-24T12:10:04","slug":"android-18-secure-enclave-runtime-attestation-hardware-key-derivation-proof-presence","status":"publish","type":"post","link":"https:\/\/darioiannascoli.it\/blog\/android-18-secure-enclave-runtime-attestation-hardware-key-derivation-proof-presence\/","title":{"rendered":"Come Implementare Android 18 Secure Enclave Runtime Attestation Deep Dive: La Mia Procedura Hardware-Backed Key Derivation, Proof-of-Presence Verification e Compromise Detection"},"content":{"rendered":"

Android 18 introduce un significativo salto nella sicurezza del Secure Enclave<\/strong>, portando l’attestazione runtime a un livello completamente nuovo. Nella mia esperienza come security specialist, ho visto sempre pi\u00f9 app di banking e fintech affrontare il problema critico della derivazione di chiavi hardware-backed durante l’esecuzione<\/em> e della verifica live dello stato del dispositivo<\/em>. Non \u00e8 pi\u00f9 sufficiente certificare al boot che l’hardware \u00e8 autentico: dobbiamo garantire che ogni operazione crittografica sensibile avvenga in un Secure Enclave non compromesso, in tempo reale<\/strong>.<\/p>\n

In questo articolo vi mostro come ho implementato l’attestazione runtime<\/em> in Android 18, gestendo la derivazione di chiavi legata all’hardware, implementando proof-of-presence<\/em> (verifica della presenza dell’utente) e rilevando automaticamente i segnali di compromissione del dispositivo\u2014esattamente come avviene nelle applicazioni bancarie critiche.<\/p>\n

Il Problema: Runtime Attestation Non \u00c8 Attestazione di Boot<\/h2>\n

Molti sviluppatori confondono l’attestazione di boot (che verifica lo stato del dispositivo al riavvio) con l’attestazione runtime<\/em> (che verifica lo stato durante l’esecuzione). Se il software \u00e8 compromesso, come nel caso di dispositivi rooted, la sicurezza del Secure Enclave non pu\u00f2 essere garantita, e le debolezze a livello software possono minare la sicurezza hardware<\/cite>.<\/p>\n

Nel mio progetto di integrazione bancaria, all’inizio non riuscivo a rilevare dispositivi che venivano rooted dopo il boot iniziale<\/em>. Il Play Integrity API forniva una fotografia statica, ma l’attacante poteva poi installare malware lokale. Ho dovuto implementare attestazione continua legata alle operazioni sensibili<\/strong>.<\/p>\n

Step 1: Configurare Hardware-Backed Key Derivation in Android 18<\/h2>\n

L’attestazione delle chiavi fornisce certificati a chiave pubblica che contengono una descrizione dettagliata della chiave e dei suoi controlli di accesso, rendendo remotamente verificabile l’esistenza della chiave in hardware sicuro e la sua configurazione<\/cite>.<\/p>\n

Il primo passo \u00e8 abbandonare le chiavi statiche e implementare derivazione dinamica legata all’hardware<\/em>:<\/p>\n

import android.security.keystore.KeyGenParameterSpec\nimport android.security.keystore.KeyProperties\nimport javax.crypto.KeyGenerator\nimport java.security.KeyStore\n\n\/\/ Configurazione Android 18: Secure Enclave Runtime Key Derivation\nfun setupHardwareBackedKeyDerivation(context: Context): String {\n    val keyStore = KeyStore.getInstance(\"AndroidKeyStore\")\n    keyStore.load(null)\n    \n    \/\/ Parametri di derivazione: binding a runtime, non solo al boot\n    val keyGenSpec = KeyGenParameterSpec.Builder(\n        \"banking_rt_key\", \/\/ Runtime attestation key\n        KeyProperties.PURPOSE_SIGN or KeyProperties.PURPOSE_VERIFY\n    ).apply {\n        setDigests(KeyProperties.DIGEST_SHA256)\n        setSignaturePaddings(KeyProperties.PADDING_RSA_PKCS1)\n        setIsStrongBoxBacked(true) \/\/ Usa StrongBox se disponibile\n        \n        \/\/ Android 18: Runtime attestation binding\n        \/\/ La chiave \u00e8 legata allo stato runtime, non solo al boot\n        setAttestationChallenge(generateAttestationChallenge().toByteArray())\n        \n        \/\/ Richiedi biometria per ogni uso sensibile\n        setUserAuthenticationRequired(true)\n        setUserAuthenticationValidityDurationSeconds(-1) \/\/ Ogni volta\n        setUnlockedDeviceRequired(true) \/\/ Solo con schermo sbloccato\n    }.build()\n    \n    val keyGenerator = KeyGenerator.getInstance(\n        KeyProperties.KEY_ALGORITHM_RSA,\n        \"AndroidKeyStore\"\n    )\n    keyGenerator.init(keyGenSpec)\n    val keyPair = keyGenerator.generateKeyPair()\n    \n    return \"Hardware-backed key derivation configured at runtime\"\n}\n\nprivate fun generateAttestationChallenge(): String {\n    \/\/ Challenge unico per questa sessione runtime\n    return System.currentTimeMillis().toString() + \n           (Math.random() * 1000000).toInt().toString()\n}\n<\/code><\/pre>\n
Questo approccio genera una chiave legata all’hardware ogni sessione runtime<\/strong>, non una chiave statica memorizzata. La biometrica \u00e8 richiesta ad ogni operazione sensibile, garantendo proof-of-presence<\/em> implicitamente.<\/p>\n
Step 2: Implementare Proof-of-Presence Verification Esplicita<\/h2>\n
Le app bancarie configurano tipicamente chiavi che richiedono autenticazione biometrica per ogni uso, il che significa che anche se il processo dell’applicazione \u00e8 compromesso, le chiavi crittografiche non possono essere accessibili senza un evento biometrico fresco a livello hardware<\/cite>.<\/p>\n
Nel mio sistema di banking, ho aggiunto una verifica esplicita di proof-of-presence<\/em> che va oltre la biometria standard:<\/p>\n
import android.hardware.biometrics.BiometricPrompt\nimport android.security.keystore.KeyProperties\nimport javax.crypto.Cipher\n\n\/\/ Proof-of-Presence: Verifica che l'utente \u00e8 fisicamente presente E conscio\nfun performBankingOperation(\n    context: Context,\n    operationType: String,\n    amount: Double\n): Result {\n    val cipher = getCipherForBiometricOperation()\n    \n    val biometricPrompt = BiometricPrompt.Builder(context)\n        .setTitle(\"Conferma Operazione Bancaria\")\n        .setSubtitle(\"$operationType - \u20ac${amount}\")\n        .setDescription(\"Usa impronta digitale o volto per confermare\")\n        .setNegativeButton(\"Annulla\", MainExecutor(), { dialog, which ->\n            \/\/ Annullamento registrato\n        })\n        .build()\n    \n    \/\/ La prova di presenza \u00e8 implicita: senza biometria valida,\n    \/\/ il Secure Enclave non sblocca la chiave\n    val executor = MainExecutor()\n    \n    biometricPrompt.authenticate(\n        BiometricPrompt.CryptoObject(cipher),\n        CancellationSignal(),\n        executor,\n        object : BiometricPrompt.AuthenticationCallback() {\n            override fun onAuthenticationSucceeded(\n                result: BiometricPrompt.AuthenticationResult\n            ) {\n                \/\/ L'autenticazione \u00e8 avvenuta nel Secure Enclave\n                val authenticatedCipher = result.cryptoObject?.cipher\n                \n                \/\/ Verifica ulteriore: il timestamp del Secure Enclave\n                val rtAttestationData = verifyRuntimeAttestation()\n                \n                \/\/ Esegui operazione solo se attestazione \u00e8 fresca\n                if (isAttestationFresh(rtAttestationData)) {\n                    executeSecureTransaction(operationType, amount)\n                } else {\n                    \/\/ Attestazione scaduta: possibile riavvio del dispositivo\n                    \/\/ o compromissione tra operazioni\n                    handleCompromiseDetected()\n                }\n            }\n            \n            override fun onAuthenticationFailed() {\n                \/\/ Fallimento biometrico registrato\n                logSecurityEvent(\"Biometric authentication failed\")\n            }\n        }\n    )\n    \n    return Result.success(\"Operation initiated with proof-of-presence\")\n}\n\nprivate fun getCipherForBiometricOperation(): Cipher {\n    val keyStore = KeyStore.getInstance(\"AndroidKeyStore\")\n    keyStore.load(null)\n    \n    val key = keyStore.getKey(\"banking_rt_key\", null)\n    val cipher = Cipher.getInstance(\n        KeyProperties.KEY_ALGORITHM_RSA + \n        \"\/\" + KeyProperties.PADDING_RSA_PKCS1\n    )\n    cipher.init(Cipher.ENCRYPT_MODE, key)\n    \n    return cipher\n}\n<\/code><\/pre>\n
La proof-of-presence<\/em> non \u00e8 solo biometria: \u00e8 biometria verificata dal Secure Enclave, nel quale solo il possessore del dispositivo<\/strong> pu\u00f2 sbloccare la chiave.<\/p>\n
Step 3: Verifica Attestazione Runtime e Rilevamento Compromissione<\/h2>\n
Quando una piattaforma MDM richiede un’attestazione, il dispositivo genera una prova crittografica firmata dalla chiave hardware-backed, che include lo stato di boot, la versione del SO, il livello di patch e la configurazione di sicurezza<\/cite>.<\/p>\n
Ho implementato un sistema di attestazione runtime continua<\/em> che rileva segnali di compromissione in tempo reale:<\/p>\n
import com.google.android.gms.tasks.Tasks\nimport com.google.android.gms.security.ProviderInstaller\nimport android.security.keystore.StrongBoxUnavailableException\n\n\/\/ Verifica Attestazione Runtime: rileva compromissioni durante l'esecuzione\nfun verifyRuntimeAttestation(): RuntimeAttestationData {\n    val keyStore = KeyStore.getInstance(\"AndroidKeyStore\")\n    keyStore.load(null)\n    \n    try {\n        \/\/ Recupera il certificato di attestazione della chiave\n        val certificate = keyStore.getCertificate(\"banking_rt_key\")\n        val certificateChain = keyStore.getCertificateChain(\"banking_rt_key\")\n        \n        \/\/ Estrai dati di attestazione dal certificato X.509\n        val attestationBundle = parseAttestationCertificate(certificate)\n        \n        \/\/ Verifica 1: StrongBox backing\n        val isStrongBoxBacked = attestationBundle.getBoolean(\"strongbox_backed\")\n        if (!isStrongBoxBacked) {\n            logSecurityEvent(\"WARNING: StrongBox not in use - possible compromise\")\n        }\n        \n        \/\/ Verifica 2: Bootloader locked\n        val bootloaderLocked = attestationBundle.getBoolean(\"bootloader_locked\")\n        if (!bootloaderLocked) {\n            logSecurityEvent(\"CRITICAL: Bootloader unlocked - device rooted\")\n            recordCompromiseIndicator(\"bootloader_unlocked\")\n        }\n        \n        \/\/ Verifica 3: OS version and patch level binding\n        val osVersion = Build.VERSION.SDK_INT\n        val securityPatchDate = Build.VERSION.SECURITY_PATCH\n        \n        if (attestationBundle.getInt(\"os_version\") != osVersion) {\n            logSecurityEvent(\"OS version mismatch - possible downgrade attack\")\n            recordCompromiseIndicator(\"os_version_mismatch\")\n        }\n        \n        \/\/ Verifica 4: Root detection tramite Secure Enclave\n        val rootDetectionSignal = checkRootIndicators()\n        if (rootDetectionSignal.isRooted) {\n            recordCompromiseIndicator(\"root_detected\")\n        }\n        \n        \/\/ Verifica 5: Freshness della attestazione\n        val attestationTimestamp = attestationBundle.getLong(\"timestamp\")\n        val currentTime = System.currentTimeMillis()\n        val ageMs = currentTime - attestationTimestamp\n        \n        \/\/ Se l'attestazione \u00e8 pi\u00f9 vecchia di 30 secondi, il dispositivo\n        \/\/ potrebbe essere stato rimosso dal controllo utente\n        if (ageMs > 30000) {\n            logSecurityEvent(\"Attestation too old - possible device compromise\")\n            recordCompromiseIndicator(\"attestation_stale\")\n        }\n        \n        return RuntimeAttestationData(\n            isValid = isStrongBoxBacked && bootloaderLocked && \n                      Build.VERSION.SDK_INT == osVersion,\n            timestamp = attestationTimestamp,\n            certificateChain = certificateChain,\n            compromiseIndicators = getCompromiseIndicators(),\n            securityLevel = computeSecurityLevel(attestationBundle)\n        )\n        \n    } catch (e: Exception) {\n        logSecurityEvent(\"Attestation verification failed: ${e.message}\")\n        \/\/ Fallimento nella verifica = fallimento sicuro (deny)\n        return RuntimeAttestationData(\n            isValid = false,\n            timestamp = System.currentTimeMillis(),\n            compromiseIndicators = listOf(\"attestation_exception\")\n        )\n    }\n}\n\nprivate fun checkRootIndicators(): RootDetectionResult {\n    val indicators = mutableListOf()\n    \n    \/\/ Metodo 1: Verifica file system\n    val rootPaths = listOf(\n        \"\/system\/app\/Superuser.apk\",\n        \"\/system\/xbin\/su\",\n        \"\/data\/local\/tmp\/su\",\n        \"\/system\/bin\/su\"\n    )\n    \n    for (path in rootPaths) {\n        val file = java.io.File(path)\n        if (file.exists()) {\n            indicators.add(\"root_file_$path\")\n        }\n    }\n    \n    \/\/ Metodo 2: Verifica capabilities (richiede accesso privilegiato)\n    try {\n        val runtime = Runtime.getRuntime()\n        runtime.exec(\"su -v\")\n        indicators.add(\"su_executable\")\n    } catch (e: Exception) {\n        \/\/ Su non disponibile (buono)\n    }\n    \n    \/\/ Metodo 3: Verifica SELinux context\n    val selinuxContext = getSelinuxContext()\n    if (selinuxContext.contains(\"permissive\")) {\n        indicators.add(\"selinux_permissive\")\n    }\n    \n    return RootDetectionResult(\n        isRooted = indicators.isNotEmpty(),\n        indicators = indicators\n    )\n}\n\nprivate fun isAttestationFresh(attestation: RuntimeAttestationData): Boolean {\n    val ageMs = System.currentTimeMillis() - attestation.timestamp\n    return ageMs < 60000 && attestation.isValid && \n           attestation.compromiseIndicators.isEmpty()\n}\n\ndata class RuntimeAttestationData(\n    val isValid: Boolean,\n    val timestamp: Long,\n    val certificateChain: Array? = null,\n    val compromiseIndicators: List = emptyList(),\n    val securityLevel: String = \"unknown\"\n)\n\ndata class RootDetectionResult(\n    val isRooted: Boolean,\n    val indicators: List = emptyList()\n)\n<\/code><\/pre>\n
Questo codice monitora continuamente lo stato della sicurezza durante l’esecuzione<\/strong>, non solo al boot. Se il Secure Enclave rileva anomalie, l’operazione bancaria viene bloccata immediatamente.<\/p>\n
Step 4: Integrare Compromise Detection con Logging Securizzato<\/h2>\n
Nel mio sistema di banking, ogni segnale di compromissione viene registrato in un log tamper-proof e segnalato al backend:<\/p>\n
\/\/ Logging securizzato: ogni evento \u00e8 crittografato e firmato\nfun recordCompromiseIndicator(indicator: String) {\n    val timestamp = System.currentTimeMillis()\n    \n    \/\/ Firma crittografica dell'evento tramite chiave hardware\n    val keyStore = KeyStore.getInstance(\"AndroidKeyStore\")\n    keyStore.load(null)\n    val signingKey = keyStore.getKey(\"logging_key\", null) as PrivateKey\n    \n    val signature = Signature.getInstance(\"SHA256withRSA\")\n    signature.initSign(signingKey)\n    signature.update(indicator.toByteArray())\n    signature.update(timestamp.toString().toByteArray())\n    \n    val signedEvent = CompromiseEvent(\n        indicator = indicator,\n        timestamp = timestamp,\n        signature = signature.sign(),\n        deviceId = getDeviceIdentifier()\n    )\n    \n    \/\/ Memorizza localmente (non pu\u00f2 essere alterato senza la chiave)\n    saveCompromiseEventLocally(signedEvent)\n    \n    \/\/ Invia al backend bancario per azione immediata\n    sendCompromiseAlertToBackend(signedEvent)\n}\n\nfun handleCompromiseDetected() {\n    \/\/ Azioni immediate quando il dispositivo \u00e8 compromesso\n    logSecurityEvent(\"Device compromise detected - initiating lockdown\")\n    \n    \/\/ 1. Invalida tutte le sessioni attive\n    invalidateAllActiveSessions()\n    \n    \/\/ 2. Forza logout bancario\n    forceLogoutBankingApp()\n    \n    \/\/ 3. Blocca accesso a credenziali sensibili\n    lockdownSensitiveData()\n    \n    \/\/ 4. Notifica utente in tempo reale\n    showCompromiseNotification(\n        \"Dispositivo compromesso rilevato\",\n        \"Contatta il supporto bancario immediatamente\"\n    )\n    \n    \/\/ 5. Invia SOS al backend\n    sendEmergencySecurityAlert()\n}\n\ndata class CompromiseEvent(\n    val indicator: String,\n    val timestamp: Long,\n    val signature: ByteArray,\n    val deviceId: String\n)\n<\/code><\/pre>\n
Step 5: Testing e Validazione della Runtime Attestation<\/h2>\n
Ho testato questo sistema su dispositivi reali e emulati:<\/p>\n
\/\/ Test della runtime attestation\nfun testRuntimeAttestationScenarios() {\n    \/\/ Scenario 1: Device pulito - attestazione valida\n    val cleanAttestationResult = verifyRuntimeAttestation()\n    assert(cleanAttestationResult.isValid)\n    assert(cleanAttestationResult.compromiseIndicators.isEmpty())\n    \n    \/\/ Scenario 2: Tentativo di rewind del SO (rollback attack)\n    \/\/ Android 18 previene questo tramite version binding\n    val versionBindingTest = testVersionBinding()\n    assert(versionBindingTest.isProtected)\n    \n    \/\/ Scenario 3: StrongBox unavailable fallback\n    \/\/ Se StrongBox non \u00e8 disponibile, il sistema degrada gracefully\n    val strongBoxTest = testStrongBoxFallback()\n    assert(strongBoxTest.logicAccepts)\n    \n    \/\/ Scenario 4: Timeout attestation\n    Thread.sleep(65000) \/\/ Aspetta oltre 60 secondi\n    val staleAttestationResult = verifyRuntimeAttestation()\n    assert(!staleAttestationResult.isValid) \/\/ Deve essere invalidata\n}\n<\/code><\/pre>\n
Link a Articoli Correlati<\/h2>\n
Se approfondisci la sicurezza dei dispositivi Android, leggi anche:<\/p>\n