KeyStore (Android): mga pangunahing konsepto, API at paggana ng cryptographic storage

Ano ang KeyStore sa Android?

KeyStore sa Android — ay hindi isang hiwalay na aplikasyon o file, kundi isang cryptographic provider na nagpapatupad ng interface na java.security.KeyStore. Nagbibigay ito ng pinag-isang API para sa pag-iimbak at paggamit ng mga pribadong susi, simetriko na mga susi at mga sertipiko ng mga pinagkakatiwalaang awtoridad (CA). Ang provider ay nakarehistro sa ilalim ng pangalang “AndroidKeyStore” at naa-access sa pamamagitan ng karaniwang KeyStore.getInstance().

Ebolusyon ng Android KeyStore

Bago ang Android 4.3, ang mga cryptographic na operasyon ay isinasagawa sa pamamagitan ng software gamit ang Bouncy Castle. Sa Android 4.3 lumitaw ang Keymaster HAL 1.0, na nagbigay-daan sa paggamit ng TEE sa ARM TrustZone. Ang Android 6.0 (API 23) ay nagdagdag ng Keymaster 2.0 na may suporta para sa hardware authentication gamit ang fingerprint. Ang Android 9 (API 28) ay nagpakilala ng Keymaster 4.0 at StrongBox Keymaster para sa nakalaang Secure Element.

Ang bawat bersyon ng Keymaster ay nagdaragdag ng mga bagong kakayahan at nagpapabuti ng isolation ng mga susi. Ang mga modernong device (2022+) ay dapat sumuporta sa Keymaster 4.0 para sa sertipikasyon ng Google Mobile Services, na ginagarantiyahan ang pagkakaroon ng TEE para sa lahat ng Android application.

Arkitektura at mga bahagi

Ang Android KeyStore ay binubuo ng tatlong antas: Java API (KeyStore, KeyPairGenerator), system process na keystore (C++, gumagana bilang system service) at Keymaster HAL (library sa TEE o Secure Element). Ang aplikasyon ay tumatawag sa API, ang keystore service ay nagruruta ng kahilingan sa Keymaster, ang operasyon ay isinasagawa sa protektadong kapaligiran.

Lahat ng pribadong susi ay nakaimbak sa TEE at hindi mababasa mula sa user space. Kahit ang system keystore service ay walang access sa raw keys — tanging sa mga handle na tumuturo sa mga susi sa loob ng Keymaster.

Paano gumagana ang KeyStore bilang cryptographic provider?

Ang Android KeyStore ay nagpapatupad ng karaniwang interface ng JCA service provider. Kapag ang aplikasyon ay tumawag ng Cipher.getInstance(“RSA/ECB/PKCS1Padding”, “AndroidKeyStore”), ang Android Security Provider ay nagde-delegate ng operasyon sa Keymaster sa pamamagitan ng chain: Java → JNI → keystore service → Keymaster HAL.

Pagrehistro ng provider

Ang provider na AndroidKeyStore ay awtomatikong nagrerehistro sa pagsisimula ng proseso. Ang priyoridad nito ay mas mataas kaysa sa Bouncy Castle o Conscrypt. Kaya naman sa pagtawag ng KeyStore.getInstance() nang walang pagtukoy ng provider, sa karamihan ng mga kaso ay ibinabalik ang AndroidKeyStore. Para sa tahasang tawag, gamitin ang KeyStore.getInstance(“AndroidKeyStore”).

Ang bawat Android application ay may nakahiwalay na container sa KeyStore. Ang mga application na may parehong UID (shared userId) ay maaaring magkaroon ng shared access sa ilang mga susi, ngunit ang karaniwang configuration ay ginagarantiyahan na ang application A ay hindi mababasa ang mga susi ng application B.

Mga pamamaraan ng KeyStore at ang kanilang mga katangian

load(null) — pagsisimula ng KeyStore. Ang parameter ay palaging null para sa AndroidKeyStore. setEntry — pag-save ng susi na may pagtukoy ng KeyProtection (purposes, digest, padding). getEntry — pagkuha ng KeyStore.PrivateKeyEntry, SecretKeyEntry o TrustedCertificateEntry. containsAlias — pagsuri kung mayroong susi. deleteEntry — pagtanggal ng susi (hindi na maibabalik).

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

object KeyStoreManager {
    private val keyStore by lazy {
        KeyStore.getInstance("AndroidKeyStore").apply { load(null) }
    }

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

        val kpg = KeyPairGenerator.getInstance(
            KeyProperties.KEY_ALGORITHM_RSA,
            "AndroidKeyStore"
        )
        kpg.initialize(spec)
        kpg.generateKeyPair()
    }
}

Mga sinusuportahang algorithm at uri ng susi

Ang Android KeyStore ay sumusuporta sa isang malawak na hanay ng mga cryptographic algorithm, na nag-iiba depende sa bersyon ng Keymaster HAL sa device. Ang developer ay maaaring makakuha ng listahan ng mga sinusuportahang algorithm sa pamamagitan ng KeyGenParameterSpec.Builder sa pagtatangkang bumuo — ang mga hindi tugmang parameter ay nagdudulot ng InvalidAlgorithmParameterException.

Mga asymmetric algorithm

RSA (1024–4096 bit) — para sa lagda (PKCS1, PSS na may SHA-1/SHA-256/SHA-384/SHA-512) at encryption (OAEP na may SHA-1/SHA-256). EC (P-224, P-256, P-384, P-521) — para sa ECDSA lagda at ECDH key agreement. X25519 at Ed25519 — mula sa Android 12 (API 31) para sa mga modernong cryptographic protocol.

Para sa mga asymmetric key Palaging bumuo sa loob ng Keymaster, HUWAG kailanman mag-import ng mga pribadong susi. Ang mga na-import na pribadong susi ay hindi protektado ng hardware — ang mga ito ay nakaimbak sa software layer at mahina kapag na-compromise ang AP.

Mga symmetric algorithm

AES (128, 256 bit) — para sa symmetric encryption sa mga mode na CBC, CTR, GCM. HMAC (SHA-1, SHA-256, SHA-512) — para sa pag-authenticate ng mga mensahe. ChaCha20 (Android 12+) — para sa high-performance stream encryption na may Poly1305 authentication.

Mga uri ng susi at ang kanilang serialization

KeyStore.PrivateKeyEntry — naglalaman ng pribadong susi (hindi ma-export) at chain ng sertipiko. KeyStore.SecretKeyEntry — para sa mga symmetric key. KeyStore.TrustedCertificateEntry — para sa mga pinagkakatiwalaang CA certificate. Ang mga pampublikong susi ay magagamit para sa pag-export sa pamamagitan ng keyStore.getCertificate(alias).publicKey.

Halimbawa ng pagbuo at paggamit ng mga susi

Tingnan natin ang isang kumpletong senaryo: pagbuo ng AES key para sa data encryption at pagbuo ng EC key para sa lagda na may biometric na proteksyon. Ang parehong mga susi ay ginawa sa loob ng Android KeyStore na may suporta sa hardware.

Pagbuo ng AES key para sa encryption

AES key ay ginagawa sa pamamagitan ng KeyGenerator na may KeyGenParameterSpec. Mga parameter: PURPOSE_ENCRYPT + PURPOSE_DECRYPT, BLOCK_MODE_GCM (inirerekomendang mode na may authentication), ENCRYPTION_PADDING_NONE (para sa GCM hindi kailangan ang padding).

import javax.crypto.KeyGenerator
import javax.crypto.Cipher
import javax.crypto.spec.GCMParameterSpec

fun generateAndEncrypt(alias: String, plainText: ByteArray): ByteArray {
    val spec = KeyGenParameterSpec.Builder(alias,
        KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT
    ).setBlockModes(KeyProperties.BLOCK_MODE_GCM)
     .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
     .setKeySize(256)
     .build()

    val kg = KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, "AndroidKeyStore")
    kg.initialize(spec)
    kg.generateKey()

    val cipher = Cipher.getInstance("AES/GCM/NoPadding")
    cipher.init(Cipher.ENCRYPT_MODE, getKeyFromStore(alias))
    return cipher.doFinal(plainText)
}

Lagda na may biometric na proteksyon

EC key na may userAuthenticationRequired=true ay nangangailangan ng authentication ng user bago ang bawat operasyon ng lagda. Para dito ginagamit ang BiometricPrompt na may CryptoObject na naglalaman ng Signature object. Pagkatapos ng matagumpay na biometric, pinapayagan ng Keymaster ang operasyon.

fun createBiometricSignKey(alias: String) {
    val spec = KeyGenParameterSpec.Builder(alias,
        KeyProperties.PURPOSE_SIGN
    ).setAlgorithmParameterSpec(
        ECGenParameterSpec("secp256r1")
    ).setDigests(KeyProperties.DIGEST_SHA256)
     .setUserAuthenticationRequired(true)
     .setInvalidatedByBiometricEnrollment(true)
     .build()

    val kpg = KeyPairGenerator.getInstance(
        KeyProperties.KEY_ALGORITHM_EC,
        "AndroidKeyStore"
    )
    kpg.initialize(spec)
    kpg.generateKeyPair()
}

KeyStore at seguridad sa device

Ang Android KeyStore ay nagbibigay ng hardware na mga garantiya sa seguridad na hindi kayang ibigay ng mga software KeyStore (JKS, BKS). Ang mga susi ay protektado sa antas ng SoC, at kahit ang buong kontrol sa Android user space ay hindi pinapayagan ang pagkuha ng pribadong susi.

Key Attestation (Android 8.1+)

Key Attestation — mekanismo na nagpapahintulot sa application (at server) na i-verify kung saang kapaligiran ginawa ang susi. Ang Android Keystore ay pumipirma ng sertipiko na naglalaman ng listahan ng mga katangian ng susi: algorithm, laki, purges, hardware-backed (True/False), origin (GENERATED, IMPORTED). Ang server ay nagbe-verify ng chain ng sertipiko hanggang sa root certificate ng Google.

Ito ay kritikal para sa mga pinansyal na application: maaaring kailanganin ng server na ang susi ay ginawa sa hardware na kapaligiran (Hardware-Backed = True) at tanggihan ang mga susi na ginawa sa software Keystore. Pinipigilan ng Key Attestation ang mga pag-atake kung saan pinapalitan ng attacker ang Keystore ng emulator.

Pag-invalidate ng mga susi sa pagbabago ng biometric

setInvalidatedByBiometricEnrollment(true) ay nangangahulugan na ang susi ay awtomatikong tatanggalin ng Keymaster kapag binago o tinanggal ang biometric template ng user. Ito ay proteksyon laban sa mga pag-atake kung saan idinaragdag ng attacker ang kanyang sariling fingerprint sa umiiral na account. Pagkatapos magdagdag ng bagong fingerprint, ang mga lumang susi ay nagiging hindi ma-access.

Ang counter ng bigong biometric authentication attempts ay pinamamahalaan din ng Keymaster. Pagkatapos ng maxBiometricAttempt (itinakda ng tagagawa, karaniwang 5) hinaharangan ng Keymaster ang lahat ng operasyon na may biometric key sa loob ng 30 segundo. Pagkatapos ng 10 bigong pagtatangka — hanggang sa pagpasok ng password ng device (lihim na PIN).