Keystore i Android — vad det är, arkitektur och kryptografi

Vad är Keystore i Android?

Android Keystore — en systemkomponent i Android-plattformen som tillhandahåller API för att generera, lagra och använda kryptografiska nycklar i en skyddad miljö. Till skillnad från programvarubaserade kryptografiska bibliotek (Bouncy Castle, Conscrypt) garanterar Keystore att privata nycklar aldrig lämnar det isolerade exekveringsområdet.

Keystore dök upp i Android 4.3 (API 18) som en programvaruleverantör med RSA-stöd. Från och med Android 6.0 (API 23) fick Keystore hårdvarustöd genom Keymaster Hardware Abstraction Layer (HAL), som delegerar kryptografiska operationer till Trusted Execution Environment (TEE) på kompatibla enheter. Enligt Android Compatibility Definition Document (2025) måste alla enheter med Android 9+ stödja hårdvaru-Keystore via TEE eller StrongBox.

Nycklar i Keystore identifieras av ett alias — en sträng som skickas vid skapande eller laddning av nyckeln. Keystore tillåter inte att råmaterialet för nyckeln erhålls: metoder som getEncoded() returnerar null för nycklar skapade i Keystore. Detta är en grundläggande skillnad från programvarunycklar — en angripare kan inte extrahera den privata nyckeln även med fullständig kontroll över enheten.

Keystore är integrerat med andra säkerhetsmekanismer i Android: biometrisk autentisering (BiometricPrompt), filnivåkryptering (File-Based Encryption) och verifieringsfunktioner som SafetyNet / Play Integrity. Nycklar kan konfigureras för automatisk borttagning under vissa förutsättningar: vid borttagning av lösenordskod, vid tillägg av nytt fingeravtryck eller efter utgången av giltighetstiden.

Arkitektur för Android Keystore

Arkitekturen för Android Keystore omfattar tre implementeringsnivåer som skiljer sig när det gäller graden av hårdvaruskydd. Nivån beror på enhetens hårdvarukapacitet.

Hardware-backed Keystore (TEE)

TEE (Trusted Execution Environment) — ett isolerat område som arbetar parallellt med huvudoperativsystemet på samma processor. TEE använder ARM TrustZone-teknik, som delar den fysiska processorkärnan i två virtuella delar: Normal World (Android) och Secure World (TEE). Kod i Secure World har åtkomst till minne och kringutrustning som inte är tillgängliga från Normal World.

När en app anropar en kryptografisk operation via Keystore skickas begäran via Keymaster HAL till TEE, där operationen utförs i hårdvara. Resultatet returneras till appen, men den privata nyckeln förblir i TEE:s skyddade minne. TEE är certifierat enligt GlobalPlatform TEE Protection Profile och är ett obligatoriskt krav för Android 9+ på enheter med processorer som stödjer TrustZone.

TEE stödjer algoritmerna AES/GCM (128, 256 bitar), RSA (2048, 4096 bitar), EC (P-256, P-384, P-521) och HMAC-SHA256. TEE:s prestanda är lägre än programvarubaserad kryptografi (20–40 % lägre), men för typiska operationer (JWT-signering, sessionsnyckeldekryptering) överstiger fördröjningen inte 10–50 ms.

StrongBox Keymaster

StrongBox — ett dedikerat säkerhetschip, fysiskt separerat från huvudprocessorn. Till skillnad från TEE, som delar processortid med Android, har StrongBox egen CPU, RAM, True Random Number Generator (TRNG) och skyddad lagring (One-Time Programmable memory). StrongBox är certifierat enligt Common Criteria EAL 4+ och Secure IC Protection Profile.

StrongBox är tillgängligt på enheter med Android 9+ förutsatt att ett lämpligt chip finns (t.ex. Titan M på Google Pixel, Knox på Samsung Galaxy). Utvecklaren aktiverar StrongBox via flaggan setIsStrongBoxBacked(true) i KeyGenParameterSpec. Vid avsaknad av hårdvarustöd ignoreras flaggan och Keystore växlar till TEE.

Begränsningar för StrongBox: stödjer en begränsad uppsättning algoritmer (AES-256, EC P-256, HMAC-SHA256), operationskö — högst en åt gången, antal operationer — begränsat av chipets resurser. StrongBox är inte avsett för högbelastningsscenarier — använd TEE för frekventa operationer och StrongBox endast för kritiska nycklar (masterkrypteringsnycklar, signeringsnycklar).

Software-based Keystore

Software-based Keystore — en programvaruimplementering som används på enheter utan hårdvarustöd för TEE eller StrongBox. Nycklar lagras krypterade i filsystemet, men den privata nyckeln kan tillfälligt dekrypteras i RAM. Programvaru-Keystore är mindre säkert — en angripare med root-åtkomst kan fånga upp nyckeln i minnet.

Från och med Android 12 (API 31) kräver Google hårdvarustöd för Keystore för alla nya enheter. Enheter med Android 9–11 kan ha programvaru-Keystore på budgetmodeller. Utvecklaren kan kontrollera skyddsnivån via KeyStore.getKeyCharacteristics() — attributet SECURITY_LEVEL_TRUSTED_ENVIRONMENT eller SECURITY_LEVEL_STRONGBOX bekräftar hårdvaruskydd.

Algoritmer och funktioner som stöds

Android Keystore stödjer ett brett spektrum av kryptografiska algoritmer indelade i kategorier baserat på nyckeltyp. Valet av algoritm påverkar prestanda, kompatibilitet och säkerhetsnivå.

AES (Advanced Encryption Standard) — symmetrisk kryptering för att skydda data på enheten. Rekommenderat läge: AES/GCM/NoPadding (256 bitar). GCM tillhandahåller autentiserad kryptering (AEAD) — verifiering av integriteten hos krypterade data. IV-storlek (initieringsvektor): 12 byte för GCM. Använd inte AES/ECB — det ger inte tillräckligt skydd.

RSA (Rivest–Shamir–Adleman) — asymmetrisk kryptering för att skydda sessionsnycklar och digitala signaturer. Rekommenderad storlek: 2048 eller 4096 bitar. Lägen: RSA/ECB/PKCS1Padding (kryptering) och RSA/ECB/PKCS1Sign (signatur). RSA 1024 anses föråldrat och rekommenderas inte för nya applikationer (NIST SP 800-131A Rev. 2).

EC (Elliptic Curve) — asymmetrisk kryptografi på elliptiska kurvor för signatur och nyckelutbyte. Kurvor som stöds: secp256r1 (P-256, obligatorisk), secp384r1 (P-384) och secp521r1 (P-521). EC ger jämförbar säkerhet med RSA med betydligt mindre nyckelstorlek. P-256 rekommenderas för de flesta scenarier: det stöds av alla enheter och ger 128-bitars säkerhetsnivå.

HMAC (Hash-based Message Authentication Code) — symmetrisk meddelandeautentisering. Hashfunktioner som stöds: SHA-256, SHA-384, SHA-512. HMAC används för att verifiera integriteten och autenticiteten hos data, till exempel för att verifiera webhook-begäranden eller kontrollera konfigurationsintegritet.

Alla algoritmer kan bindas till biometrisk autentisering via KeyGenParameterSpec.Builder.setUserAuthenticationRequired(true). På Android 11+ finns flaggan setUserAuthenticationParameters() med en timeout (i sekunder) under vilken nyckeln är tillgänglig efter biometrisk autentisering, utan upprepad begäran.

Kodexempel: generering och användning av nycklar

Låt oss titta på praktiska exempel på att arbeta med Android Keystore i Kotlin: generering av en AES-nyckel, kryptering av data och skapande av ett asymmetriskt par för signatur.

Generera en AES-nyckel i Keystore

Exemplet skapar en 256-bitars AES/GCM-nyckel med bindning till biometrisk autentisering. Nyckeln är inte tillgänglig för export via getEncoded().

import android.security.keystore.KeyGenParameterSpec
import android.security.keystore.KeyProperties
import java.security.KeyStore

private val keyStore = KeyStore.getInstance("AndroidKeyStore").apply { load(null) }

fun generateAesKey(alias: String) {
    val spec = KeyGenParameterSpec.Builder(
        alias,
        KeyProperties.PURPOSE_ENCRYPT or
        KeyProperties.PURPOSE_DECRYPT
    )
    .setKeySize(256)
    .setBlockModes(KeyProperties.KEY_BLOCK_MODE_GCM)
    .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
    .setUserAuthenticationRequired(true)
    .setInvalidatedByBiometricEnrollment(true)
    .build()

    val generator = KeyGenerator.getInstance(
        KeyProperties.KEY_ALGORITHM_AES,
        "AndroidKeyStore"
    )
    generator.init(spec)
    generator.generateKey()
}

Kryptering av data med AES/GCM

Exemplet krypterar data med en nyckel från Android Keystore. Cipher hämtar nyckeln via alias, initierar AES/GCM-kryptering och returnerar krypterade data tillsammans med IV.

fun encryptData(alias: String, plaintext: ByteArray): ByteArray {
    val cipher = Cipher.getInstance("AES/GCM/NoPadding")
    val secretKey = keyStore.getKey(alias, null) as SecretKey
    cipher.init(Cipher.ENCRYPT_MODE, secretKey)

    val iv = cipher.getIV()
    val encrypted = cipher.doFinal(plaintext)

    // IV + krypterad data
    return iv + encrypted
}

fun decryptData(alias: String, ciphertextWithIv: ByteArray): ByteArray {
    val iv = ciphertextWithIv.copyOfRange(0, 12)
    val encrypted = ciphertextWithIv.copyOfRange(12, ciphertextWithIv.size)

    val cipher = Cipher.getInstance("AES/GCM/NoPadding")
    val secretKey = keyStore.getKey(alias, null) as SecretKey
    val spec = GCMParameterSpec(128, iv)
    cipher.init(Cipher.DECRYPT_MODE, secretKey, spec)

    return cipher.doFinal(encrypted)
}

Generera ett RSA-par för signatur

Exemplet skapar ett RSA-2048-nyckelpar i Keystore med bindning till StrongBox. Den privata nyckeln används för signatur, den offentliga nyckeln kan exporteras via getEncoded().

fun generateRsaKeyPair(alias: String) {
    val spec = KeyGenParameterSpec.Builder(
        alias,
        KeyProperties.PURPOSE_SIGN or
        KeyProperties.PURPOSE_VERIFY
    )
    .setKeySize(2048)
    .setSignaturePaddings(
        KeyProperties.SIGNATURE_PADDING_RSA_PKCS1
    )
    .setDigests(KeyProperties.DIGEST_SHA256)
    .setIsStrongBoxBacked(true)
    .build()

    val pair = KeyPairGenerator.getInstance(
        KeyProperties.KEY_ALGORITHM_RSA,
        "AndroidKeyStore"
    ).apply { init(spec) }
     .generateKeyPair()

    // Offentlig nyckel kan exporteras
    val publicKey = pair.public // X509EncodedKeySpec
}

Bästa praxis för att arbeta med Android Keystore

Effektiv användning av Android Keystore kräver efterlevnad av regler som ger maximalt skydd samtidigt som prestandan bibehålls.

Använd KeyGenParameterSpec med minimalt nödvändiga parametrar: ange endast de purpose, block modes och paddings som faktiskt används. Överflödiga parametrar (t.ex. PURPOSE_ENCRYPT för en nyckel som endast används för signatur) skapar ytterligare attackvektorer. Android rekommenderar att uttryckligen ange digest för signatur — SHA256 är den lägsta acceptabla nivån (SHA1 är föråldrad).

Bind nycklar till biometri för kritiska operationer: setUserAuthenticationRequired(true) garanterar att nyckeln endast kan användas efter biometrisk autentisering. På Android 11+ använd setUserAuthenticationParameters() med en timeout (rekommenderas 30–60 sekunder) för att inte kräva biometri för varje operation inom samma session. setInvalidatedByBiometricEnrollment(true) tar automatiskt bort nyckeln när ett nytt fingeravtryck eller ansikte läggs till — detta förhindrar åtkomst med gamla biometriska data.

Kontrollera säkerhetsnivån vid initieringsstadiet: använd KeyStore.getKeyCharacteristics() för att bestämma SECURITY_LEVEL. Om enheten endast stödjer programvaru-Keystore (SECURITY_LEVEL_SOFTWARE), fatta ett beslut: antingen avvisa funktionaliteten eller använd ytterligare kryptering (t.ex. linda nyckeln med användarens lösenord). Förlita dig inte på StrongBox om det inte är garanterat — ange alltid flaggan setIsStrongBoxBacked(true) och kontrollera resultatet via getKeyCharacteristics.

Uppdatera nycklar enligt schema: kryptografiska nycklar har en rekommenderad livslängd. NIST SP 800-57 rekommenderar att byta AES-nycklar varje 1–2 år, RSA/EC-par varje 2–3 år. Implementera en nyckelrotationsmekanism: när appen startar, kontrollera nyckelns skapelsedatum (KeyGenParameterSpec.Builder.setKeyValidityStart/End) och generera en ny nyckel när den går ut. Gamla data krypterade med den gamla nyckeln måste dekrypteras och återkrypteras med den nya.

Använd inte Keystore för stora datamängder: Keystore är avsett för att lagra nycklar (några hundra byte), inte för att kryptera stora filer. För datakryptering, använd schemat: generera en slumpmässig AES-nyckel (DEK — Data Encryption Key), kryptera data med denna nyckel och kryptera DEK med Keystore-nyckeln (KEK — Key Encryption Key). Android EncryptedSharedPreferences använder precis detta schema: master-nyckeln i Keystore, data i AES-256 GCM.