Keystore (Android): apa itu, arsitektur dan prinsip kerja

Apa itu Android Keystore?

Android Keystore — adalah penyedia kriptografi (provider) yang diimplementasikan di Android mulai API 1 (Android 1.0), tetapi dukungan perangkat keras penuh muncul dengan Android 4.3 (API 18). Keystore memecahkan masalah penyimpanan aman kunci pribadi sedemikian rupa sehingga bahkan jika sistem operasi dikompromikan, penyerang tidak dapat mengekstrak kunci dalam bentuk terbuka.

Arsitektur KeyStore di Android

Arsitektur Android Keystore terdiri dari tiga lapisan: API aplikasi (java.security.KeyStore), layanan sistem (keystore daemon) dan lapisan perangkat keras (Keymaster HAL). Aplikasi mengakses melalui API Java Cryptography Architecture (JCA) standar, dan layanan sistem merutekan permintaan ke Keymaster yang berjalan di TEE.

Semua operasi kriptografi dengan kunci (tanda tangan, dekripsi) dilakukan di dalam TEE atau Secure Element. Kunci tidak pernah meninggalkan lingkungan aman — aplikasi hanya menerima alias untuk merujuk ke kunci. Ini adalah perbedaan fundamental dari KeyStore perangkat lunak, di mana kunci berpotensi dapat diakses di memori proses.

Perbedaan dari Java KeyStore

JKS (Java KeyStore) standar atau BKS (Bouncy Castle) menyimpan kunci dalam file yang dilindungi kata sandi. Android Keystore menyimpan kunci dalam isolasi perangkat keras, di mana mereka dilindungi bahkan dari pengguna root. JKS rentan terhadap akses langsung ke sistem file, Android Keystore — tidak.

Perbedaan lain: di Android Keystore, kunci memiliki parameter penggunaan yang ketat (purpose — hanya sign/verify/encrypt/decrypt) yang ditetapkan saat pembuatan. Mereka tidak dapat diubah setelahnya, yang mencegah penyalahgunaan kunci.

Bagaimana cara kerja Android Keystore?

Saat membuat kunci baru, aplikasi memanggil KeyPairGenerator atau KeyGenerator dengan KeyGenParameterSpec, yang berisi semua parameter kunci masa depan. Sistem meneruskan permintaan ke Keymaster HAL, yang menghasilkan kunci di dalam TEE dan mengembalikan alias.

Proses pembuatan kunci

Metode KeyGenParameterSpec.Builder menerima parameter wajib: nama kunci di Keystore, tujuan (PURPOSE_SIGN, PURPOSE_ENCRYPT), algoritma (RSA, EC, AES). Tambahan: digest (SHA-256), padding (PKCS7), userAuthenticationRequired (biometrik), keyValidityStart/End (batasan waktu).

Setelah mengatur parameter, KeyPairGenerator.generateKeyPair() mengembalikan KeyPair, di mana PrivateKey adalah objek yang mendelegasikan operasi ke Keymaster. Kunci publik dapat diekstrak, kunci pribadi — tidak. Itu hanya ada di dalam TEE.

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

fun generateKey(alias: String) {
    val spec = KeyGenParameterSpec.Builder(alias,
        KeyProperties.PURPOSE_SIGN or KeyProperties.PURPOSE_VERIFY
    ).setDigests(KeyProperties.DIGEST_SHA256)
     .setSignaturePaddings(KeyProperties.SIGN_PADDING_RSA_PKCS1)
     .setUserAuthenticationRequired(true)
     .build()

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

Penandatanganan dan verifikasi

Signature untuk ECDSA atau RSA-PSS dibuat melalui API standar: Signature.getInstance(algorithm).initSign(privateKey). Operasi penandatanganan dilakukan di TEE: aplikasi mengirim data, Keymaster menandatanganinya secara perangkat keras dan mengembalikan tanda tangan. Kunci dan data tidak bercampur di memori bersama.

Untuk perlindungan biometrik, autentikasi pengguna melalui BiometricPrompt diperlukan sebelum penandatanganan. Tanpa autentikasi berhasil, Keymaster tidak menjalankan operasi, mengembalikan CryptoAuthenticationException.

import java.security.KeyStore
import java.security.Signature
import androidx.biometric.BiometricPrompt

fun signWithBiometric(alias: String) {
    val ks = KeyStore.getInstance("AndroidKeyStore")
    ks.load(null)
    val entry = ks.getEntry(alias, null) as KeyStore.PrivateKeyEntry
    val signature = Signature.getInstance("SHA256withRSA")
    signature.initSign(entry.privateKey)
    // BiometricPrompt dengan CryptoObject(signature) meminta FaceID/PIN
}

Jenis penyimpanan KeyStore

Android mendukung dua mode penyimpanan kunci: perangkat lunak (pada perangkat tanpa TEE) dan perangkat keras (pada perangkat dengan TEE atau Secure Element). Mode tergantung pada kemampuan SoC dan versi Android.

KeyStore Perangkat Lunak (hanya software)

Pada perangkat tanpa Trusted Execution Environment (sebelum Android 4.3 atau SoC murah) kunci disimpan dalam bentuk terenkripsi menggunakan kunci utama yang berasal dari kata sandi layar kunci. Mode ini kurang aman — kunci dapat diakses di memori proses selama operasi kriptografi.

Tingkat perlindungan didasarkan pada enkripsi file KeyStore menggunakan AES-256-GCM. Kunci enkripsi dihasilkan berdasarkan kata sandi atau PIN pengguna melalui Scrypt (PBKDF2 dengan jumlah iterasi besar).

KeyMaster Perangkat Keras (TEE/Secure Element)

Pada perangkat modern, Keymaster 4.x digunakan di TEE (ARM TrustZone). Kunci dihasilkan, disimpan dan digunakan secara eksklusif di dalam TrustZone. Bahkan kernel Linux tidak memiliki akses ke kunci pribadi — hanya Keymaster HAL yang dapat melakukan operasi.

Secure Element (misalnya eSE di Samsung Knox atau StrongBox di Google Pixel 3+) — adalah chip terpisah dengan prosesor dan memorinya sendiri. Ini bersertifikat Common Criteria EAL 4+ dan memberikan tingkat perlindungan maksimum, termasuk perlindungan terhadap pembukaan fisik.

Bekerja dengan KeyStore API

Android Keystore terintegrasi dengan Java Cryptography Architecture (JCA). Untuk mengakses penyedia, digunakan KeyStore.getInstance("AndroidKeyStore") standar. API tersedia mulai API 18.

Membuat dan memuat KeyStore

Metode KeyStore.load(null) memuat kontainer KeyStore aplikasi saat ini. Kata sandi tidak diperlukan — Android menggunakan konteks aplikasi dan UID-nya untuk membedakan akses. Setiap aplikasi hanya melihat entrinya sendiri, kecuali jika UID bersama digunakan.

Metode setEntry dan getEntry bekerja dengan KeyStore.PrivateKeyEntry, SecretKeyEntry atau TrustedCertificateEntry. Parameter ProtectionParameter selalu null untuk Android Keystore (perlindungan diimplementasikan di tingkat sistem).

import java.security.KeyStore
import java.security.cert.Certificate
import android.security.keystore.KeyProtection

fun storeSecretKey(alias: String, key: SecretKey) {
    val ks = KeyStore.getInstance("AndroidKeyStore")
    ks.load(null)
    val prot = KeyProtection.Builder(
        KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT
    ).setBlockModes(KeyProperties.BLOCK_MODE_GCM)
     .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
     .setUserAuthenticationRequired(true)
     .build()
    ks.setEntry(alias, KeyStore.SecretKeyEntry(key), prot)
}

Memeriksa jenis penyimpanan

Dengan KeyCharacteristics dapat ditentukan di lingkungan mana kunci disimpan: KeyStore perangkat lunak, TEE atau StrongBox. Metode getKeyCharacteristics() mengembalikan set bendera: FLAG_HARDWARE (keymaster), FLAG_SECURE_ELEMENT (StrongBox), FLAG_TRUSTED_USER_PRESENCE_REQUIRED (biometrik).

Algoritma dan keamanan

Android Keystore mendukung set algoritma kriptografi yang luas, dibagi menjadi tiga kategori: asimetris, simetris dan MAC. Dukungan untuk algoritma tertentu tergantung pada versi Keymaster HAL.

Algoritma yang didukung

RSA (1024–4096 bit) — untuk tanda tangan (PKCS1, PSS) dan enkripsi (OAEP, PKCS1). EC (P-224, P-256, P-384, P-521) — untuk tanda tangan ECDSA dan kesepakatan ECDH. AES (128, 256 bit) — untuk enkripsi simetris dalam mode CBC, CTR, GCM. HMAC (SHA1, SHA256, SHA512) — untuk autentikasi pesan.

Untuk setiap kunci ditetapkan setPurposes, yang membatasi operasi yang mungkin. Kunci RSA dengan PURPOSE_SIGN tidak dapat digunakan untuk enkripsi, bahkan jika penyerang memiliki akses ke API. Ini adalah penegakan penggunaan kunci di tingkat perangkat keras.

Perlindungan dari kompromi

Keymaster menyertakan penghitung percobaan autentikasi biometrik yang gagal. Setelah jumlah percobaan gagal yang ditentukan (dapat dikonfigurasi melalui setInvalidatedByBiometricEnrollment), kunci menjadi tidak dapat diakses dan memerlukan penghapusan/regenerasi. Saat semua template biometrik dihapus, semua kunci dengan userAuthenticationRequired=true secara otomatis menjadi tidak valid.

Juga didukung Key Attestation (Android 8.1+): atas permintaan aplikasi, Keymaster menandatangani sertifikat dengan informasi tentang karakteristik kunci (perangkat keras/perangkat lunak, algoritma, purges). Server dapat memverifikasi sertifikat ini untuk mengonfirmasi bahwa kunci dibuat di lingkungan tepercaya.