Keystore Androidban — mi ez, architektúra és kriptográfia

Mi az a Keystore Androidban?

Android Keystore — az Android platform rendszerkomponense, amely API-t biztosít kriptográfiai kulcsok generálásához, tárolásához és használatához védett környezetben. Ellentétben a szoftveres kriptográfiai könyvtárakkal (Bouncy Castle, Conscrypt), a Keystore garantálja, hogy a privát kulcsok soha nem hagyják el az elkülönített végrehajtási területet.

A Keystore az Android 4.3-ban (API 18) jelent meg szoftveres szolgáltatóként RSA támogatással. Az Android 6.0-tól (API 23) kezdve a Keystore hardveres támogatást kapott a Keymaster Hardware Abstraction Layer (HAL) révén, amely a kriptográfiai műveleteket a Trusted Execution Environment (TEE) felé delegálja kompatibilis eszközökön. A Android Compatibility Definition Document (2025) szerint minden Android 9+ eszköz köteles hardveres Keystore-t támogatni TEE-n vagy StrongBox-on keresztül.

A Keystore-ban lévő kulcsokat alias (becenév) azonosítja — egy karakterlánc, amely a kulcs létrehozásakor vagy betöltésekor kerül átadásra. A Keystore nem teszi lehetővé a kulcs nyersanyagának megszerzését: a getEncoded() metódusok null-t adnak vissza a Keystore-ban létrehozott kulcsok esetén. Ez alapvető különbség a szoftveres kulcsokhoz képest — egy támadó nem tudja kinyerni a privát kulcsot, még az eszköz feletti teljes ellenőrzés birtokában sem.

A Keystore integrálva van más Android biztonsági mechanizmusokkal: biometrikus hitelesítés (BiometricPrompt), fájlszintű titkosítás (File-Based Encryption) és SafetyNet / Play Integrity ellenőrző funkciók. A kulcsok beállíthatók automatikus törlésre bizonyos feltételek mellett: a jelszó eltávolításakor, új ujjlenyomat hozzáadásakor vagy az érvényességi időszak lejártakor.

Az Android Keystore architektúrája

Az Android Keystore architektúrája három implementációs szintet foglal magában, amelyek a hardveres védelem mértékében különböznek. A szint az eszköz hardveres képességeitől függ.

Hardware-backed Keystore (TEE)

TEE (Trusted Execution Environment) — egy elkülönített terület, amely párhuzamosan működik a fő operációs rendszerrel ugyanazon a processzoron. A TEE ARM TrustZone technológiát használ, amely a fizikai processzormagot két virtuális részre osztja: Normal World (Android) és Secure World (TEE). A Secure World-ban lévő kód hozzáfér a memóriához és perifériákhoz, amelyek a Normal World-ből nem érhetők el.

Amikor egy alkalmazás kriptográfiai műveletet hív a Keystore-on keresztül, a kérés a Keymaster HAL-on keresztül elküldődik a TEE-be, ahol a művelet hardveresen végrehajtódik. Az eredmény visszakerül az alkalmazásba, de a privát kulcs a TEE védett memóriájában marad. A TEE a GlobalPlatform TEE Protection Profile szerint tanúsított, és kötelező követelmény az Android 9+ esetén a TrustZone-t támogató processzorral rendelkező eszközökön.

A TEE támogatja az AES/GCM (128, 256 bit), RSA (2048, 4096 bit), EC (P-256, P-384, P-521) és HMAC-SHA256 algoritmusokat. A TEE teljesítménye alacsonyabb, mint a szoftveres kriptográfié (20–40%-kal), de tipikus műveleteknél (JWT aláírás, munkamenet-kulcs visszafejtése) a késleltetés nem haladja meg a 10–50 ms-t.

StrongBox Keymaster

StrongBox — egy dedikált biztonsági chip, fizikailag elkülönítve a főprocesszortól. Ellentétben a TEE-vel, amely megosztja a processzoridőt az Androiddal, a StrongBox saját CPU-val, RAM-mal, True Random Number Generator (TRNG) és védett tárolóval (One-Time Programmable memory) rendelkezik. A StrongBox Common Criteria EAL 4+ és Secure IC Protection Profile tanúsítvánnyal rendelkezik.

A StrongBox Android 9+ eszközökön érhető el, ha a megfelelő chip rendelkezésre áll (pl. Titan M a Google Pixelben, Knox a Samsung Galaxy-ban). A fejlesztő a setIsStrongBoxBacked(true) flagon keresztül aktiválja a StrongBox-ot a KeyGenParameterSpec-ben. Hardveres támogatás hiányában a fl ag figyelmen kívül marad, és a Keystore átkapcsol TEE-re.

A StrongBox korlátai: korlátozott algoritmuskészletet támogat (AES-256, EC P-256, HMAC-SHA256), műveleti sor — legfeljebb egy egyszerre, a műveletek száma — a chip erőforrásai korlátozzák. A StrongBox nem nagy terhelésű forgatókönyvekhez készült — használja a TEE-t gyakori műveletekhez és a StrongBox-ot csak kritikus kulcsokhoz (master titkosítási kulcsok, aláírási kulcsok).

Software-based Keystore

Software-based Keystore — egy szoftveres implementáció, amelyet TEE vagy StrongBox hardveres támogatása nélküli eszközökön használnak. A kulcsok titkosítva vannak tárolva a fájlrendszerben, de a privát kulcs ideiglenesen visszafejthető a RAM-ban. A Szoftveres Keystore kevésbé biztonságos — egy root hozzáféréssel rendelkező támadó elfoghatja a kulcsot a memóriában.

Az Android 12-től (API 31) kezdve a Google hardveres Keystore támogatást követel meg minden új eszközhöz. Az Android 9–11 eszközök olcsóbb modelleken szoftveres Keystore-ral rendelkezhetnek. A fejlesztő a KeyStore.getKeyCharacteristics() segítségével ellenőrizheti a védelem szintjét — a SECURITY_LEVEL_TRUSTED_ENVIRONMENT vagy SECURITY_LEVEL_STRONGBOX attribútum megerősíti a hardveres védelmet.

Támogatott algoritmusok és funkciók

Az Android Keystore a kriptográfiai algoritmusok széles skáláját támogatja, kategóriákra osztva a kulcs típusa szerint. Az algoritmus választása befolyásolja a teljesítményt, kompatibilitást és biztonsági szintet.

AES (Advanced Encryption Standard) — szimmetrikus titkosítás az eszközön lévő adatok védelmére. Ajánlott mód: AES/GCM/NoPadding (256 bit). A GCM hitelesített titkosítást (AEAD) biztosít — a titkosított adatok integritásának ellenőrzését. IV (Inicializáló vektor) mérete: 12 bájt GCM esetén. Ne használjon AES/ECB-t — nem nyújt megfelelő védelmet.

RSA (Rivest–Shamir–Adleman) — aszimmetrikus titkosítás munkamenet-kulcsok és digitális aláírás védelmére. Ajánlott méret: 2048 vagy 4096 bit. Módok: RSA/ECB/PKCS1Padding (titkosítás) és RSA/ECB/PKCS1Sign (aláírás). Az RSA 1024 elavultnak számít, és nem ajánlott új alkalmazásokhoz (NIST SP 800-131A Rev. 2).

EC (Elliptic Curve) — aszimmetrikus kriptográfia elliptikus görbéken aláíráshoz és kulcscseréhez. Támogatott görbék: secp256r1 (P-256, kötelező), secp384r1 (P-384) és secp521r1 (P-521). Az EC összehasonlítható biztonságot nyújt az RSA-val, lényegesen kisebb kulcsmérettel. A P-256 ajánlott a legtöbb forgatókönyvhez: minden eszköz támogatja, és 128 bites biztonsági szintet nyújt.

HMAC (Hash-based Message Authentication Code) — üzenetek szimmetrikus hitelesítése. Támogatott hash függvények: SHA-256, SHA-384, SHA-512. A HMAC az adatok integritásának és hitelességének ellenőrzésére szolgál, például webhook kérések hitelesítésére vagy konfiguráció integritásának ellenőrzésére.

Az összes algoritmus köthető biometrikus hitelesítéshez a KeyGenParameterSpec.Builder.setUserAuthenticationRequired(true) segítségével. Android 11+-on elérhető a setUserAuthenticationParameters() fl ag, amely idŐtúclejárást (másodpercekben) ad meg, ameddig a kulcs elérhető biometrikus hitelesítés után, ismételt kérés nélkül.

Kódpéldák: kulcsok generálása és használata

Nézzünk gyakorlati példákat az Android Keystore használatára Kotlinban: AES kulcs generálása, adatok titkosítása és aszimmetrikus pár létrehozása aláíráshoz.

AES kulcs generálása Keystore-ban

A példa egy 256 bites AES/GCM kulcsot hoz létre biometrikus hitelesítéshez kötve. A kulcs nem exportálható a getEncoded()-on keresztül.

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()
}

Adatok titkosítása AES/GCM-mel

A példa egy Android Keystore-ból származó kulcs segítségével titkosítja az adatokat. A Cipher alias alapján szerzi be a kulcsot, inicializálja az AES/GCM titkosítást, és visszaadja a titkosított adatokat az IV-vel együtt.

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 + titkosított adatok
    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)
}

RSA pár létrehozása aláíráshoz

A példa egy RSA-2048 kulcspárt hoz létre a Keystore-ban StrongBox-hoz kötve. A privát kulcs aláíráshoz használható, a nyilvános kulcs exportálható a getEncoded()-on keresztül.

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()

    // A nyilvános kulcs exportálható
    val publicKey = pair.public // X509EncodedKeySpec
}

Legjobb gyakorlatok az Android Keystore használatához

Az Android Keystore hatékony használata megköveteli a maximális védelmet biztosító szabályok betartását a teljesítmény megőrzése mellett.

Használja a KeyGenParameterSpec-et a minimálisan szükséges paraméterekkel: csak azokat a purpose, block modes és paddings értékeket adja meg, amelyeket ténylegesen használ. A többletparaméterek (pl. PURPOSE_ENCRYPT egy olyan kulcsnál, amelyet csak aláíráshoz használnak) többlet támadási vektorokat hoznak létre. Az Android javasolja a digest explicit megadását az aláíráshoz — a SHA256 a minimális elfogadható szint (az SHA1 elavult).

Kösse a kulcsokat biometriához a kritikus műveletekhez: a setUserAuthenticationRequired(true) garantálja, hogy a kulcs csak biometrikus hitelesítés után használható. Android 11+-on használja a setUserAuthenticationParameters() függvényt időtúclejárással (ajánlott 30–60 másodperc), hogy ne kérjen biometriát minden egyes művelethez egy munkameneten belül. A setInvalidatedByBiometricEnrollment(true) automatikusan törli a kulcsot új ujjlenyomat vagy arc hozzáadásakor — ez megakadályozza a hozzáférést régi biometrikus adatokkal.

Ellenőrizze a biztonsági szintet az inicializálási szakaszban: használja a KeyStore.getKeyCharacteristics()-t a SECURITY_LEVEL meghatározásához. Ha az eszköz csak szoftveres Keystore-t támogat (SECURITY_LEVEL_SOFTWARE), hozzon döntést: vagy utasítsa el a funkcionalitást, vagy használjon további titkosítást (pl. a kulcs becsomagolása a felhasználó jelszavával). Ne támaszkodjon a StrongBox-ra, ha az nem garantált — mindig adja meg a setIsStrongBoxBacked(true) fl agot, és ellenőrizze az eredményt a getKeyCharacteristics segítségével.

Frissítse a kulcsokat ütemezetten: a kriptográfiai kulcsok ajánlott élettartammal rendelkeznek. Az NIST SP 800-57 az AES kulcsok 1–2 évenkénti, az RSA/EC párok 2–3 évenkénti cseréjét javasolja. Valósítsa meg a kulcsrotációs mechanizmust: az alkalmazás indításakor ellenőrizze a kulcs létrehozásának dátumát (KeyGenParameterSpec.Builder.setKeyValidityStart/End), és generáljon új kulcsot a lejáratkor. A régi kulccsal titkosított régi adatokat vissza kell fejteni és újra kell titkosítani az újjal.

Ne használja a Keystore-t nagy adatokhoz: a Keystore kulcsok tárolására szolgál (néhány száz bájt), nem nagy fájlok titkosítására. Az adatok titkosításához használja a következő sémát: generáljon egy véletlenszerű AES kulcsot (DEK — Data Encryption Key), titkosítsa az adatokat ezzel a kulccsal, majd a DEK-et titkosítsa a Keystore kulccsal (KEK — Key Encryption Key). Az Android EncryptedSharedPreferences pontosan ezt a sémát használja: a master kulcs a Keystore-ban, az adatok — AES-256 GCM.