Keystore ใน Android — คืออะไร สถาปัตยกรรม และการเข้ารหัส

Keystore ใน Android คืออะไร?

Android Keystore — ส่วนประกอบระบบของแพลตฟอร์ม Android ที่ให้ API สำหรับการสร้างเก็บและใช้งานคีย์การเข้ารหัสในสภาพแวดล้อมที่ได้รับการป้องกัน ไม่เหมือนไลบรารีการเข้ารหัสแบบซอฟต์แวร์ (Bouncy Castle, Conscrypt) Keystore รับประกันว่าคีย์ส่วนตัวจะไม่ออกจากพื้นที่การดำเนินการแบบแยกออก

Keystore ปรากฏใน Android 4.3 (API 18) ในฐานะผู้ให้บริการซอฟต์แวร์ที่รองรับ RSA ตั้งแต่ Android 6.0 (API 23) Keystore ได้รับการสนับสนุนไฮฟ์แวร์ผ่าน Keymaster Hardware Abstraction Layer (HAL) ซึ่งมอบหมายการดำเนินการเข้ารหัสให้กับ Trusted Execution Environment (TEE) บนอุปกรณ์ที่เข้ากันได้ ตาม Android Compatibility Definition Document (2025) อุปกรณ์ Android 9+ ทุกเครื่องต้องรองรับ Keystore ไฮฟ์แวร์ผ่าน TEE หรือ StrongBox

คีย์ใน Keystore ถูกระบุโดยชื่อแฝง (alias) — สตริงที่ส่งต่อเมื่อสร้างหรือโหลดคีย์ Keystore ไม่อนุญาตให้ได้รับวัสดุดิบของคีย์: เมธอด getEncoded() คืนค่า null สำหรับคีย์ที่สร้างใน Keystore นี่คือความแตกต่างโดยพื้นฐานจากคีย์ซอฟต์แวร์ — ผู้โจมตีไม่สามารถแยกคีย์ส่วนตัวได้แม้เมื่อควบคุมอุปกรณ์ได้อย่างสมบูรณ์

Keystore ถูกผนวกกับกลไกความปลอดภัยอื่นของ Android: การยืนยันแบบไบโอเมตริกซ์ (BiometricPrompt) การเข้ารหัสระดับไฟล์ (File-Based Encryption) และฟังก์ชันการตรวจสอบ SafetyNet/Play Integrity คีย์สามารถถูกกำหนดค่าให้ลบอัตโนมัติภายใต้เงื่อนไขบางประการ: เมื่อลบรหัสผ่าน เมื่อเพิ่มลายนิ้วมือใหม่หรือเมื่อหมดอายุการใช้งาน

สถาปัตยกรรม Android Keystore

สถาปัตยกรรมของ Android Keystore ประกอบด้วยการดำเนินการสามระดับที่แตกต่างกันตามระดับการป้องกันด้วยฮาร์ดแวร์ ระดับขึ้นอยู่กับความสามารถของฮาร์ดแวร์ของอุปกรณ์

Keystore ที่รองรับโดยฮาร์ดแวร์ (TEE)

TEE (Trusted Execution Environment) — พื้นที่แยกออกที่ทำงานคู่ขนานกับระบบปฏิบัติการหลักบนโปรเซเซอร์เดียวกัน TEE ใช้เทคโนโลยี ARM TrustZone ซึ่งแบ่งแกนทางกายภาพของโปรเซเซอร์ออกเป็นสองส่วนเสมือนจริง: Normal World (Android) และ Secure World (TEE) โค้ดใน Secure World สามารถเข้าถึงหน่วยความจำและอุปกรณ์ต่อพ่วงที่ Normal World ไม่สามารถเข้าถึงได้

เมื่อแอปเรียกการดำเนินการเข้ารหัสผ่าน Keystore คำขอจะถูกส่งผ่าน Keymaster HAL ไปยัง TEE ซึ่งการดำเนินการจะถูกดำเนินโดยฮาร์ดแวร์ ผลลัพธ์จะถูกส่งคืนไปยังแอป แต่คีย์ส่วนตัวจะยังคงอยู่ในหน่วยความจำที่ได้รับการป้องกันของ TEE TEE ได้รับการรับรองว่าเหมาะสมกับ GlobalPlatform TEE Protection Profile และเป็นข้อกำหนดที่จำเป็นสำหรับ Android 9+ บนอุปกรณ์ที่มีโปรเซเซอร์ที่รองรับ TrustZone

TEE รองรับอัลกอริทึม AES/GCM (128, 256 บิต), RSA (2048, 4096 บิต), EC (P-256, P-384, P-521) และ HMAC-SHA256 ประสิทธิภาพของ TEE ต่ำกว่าการเข้ารหัสแบบซอฟต์แวร์ (20–40% ต่ำกว่า) แต่สำหรับการดำเนินการทั่วไประยะเวลาไม่เกิน 10–50 ms

StrongBox Keymaster

StrongBox — ชิปความปลอดภัยแบบเดดิเคต แยกออกจากโปรเซเซอร์หลักทางกายภาพ ไม่เหมือน TEE ที่แบ่งเวลาโปรเซเซอร์กับ Android StrongBox มี CPU, RAM, True Random Number Generator (TRNG) และหน่วยความจำที่ได้รับการป้องกัน (One-Time Programmable memory) เป็นของตัวเอง StrongBox ได้รับการรับรอง Common Criteria EAL 4+ และ Secure IC Protection Profile

StrongBox พร้อมใช้งานบนอุปกรณ์ Android 9+ ที่มีชิปที่สอดคล้อง (เช่น Titan M บน Google Pixel, Knox บน Samsung Galaxy) นักพัฒนาเปิดใช้งาน StrongBox ผ่านแฟลก setIsStrongBoxBacked(true) ใน KeyGenParameterSpec หากไม่มีการรองรับด้วยฮาร์ดแวร์ แฟลกจะถูกละเลย และ Keystore จะเปลี่ยนไปใช้ TEE

ข้อจำกัดของ StrongBox: รองรับชุดอัลกอริทึมที่จำกัด (AES-256, EC P-256, HMAC-SHA256) คิวการดำเนินการ — ไม่เกินหนึ่งรายการในเวลาเดียวกัน จำนวนการดำเนินการ — จำกัดโดยทรัพยากรชิป StrongBox ไม่ได้ออกแบบมาสำหรับสถานการณ์ที่มีภาระสูง — ใช้ TEE สำหรับการดำเนินการบ่อยครั้ง และ StrongBox สำหรับคีย์ที่สำคัญเท่านั้น (คีย์หลักสำหรับการเข้ารหัส คีย์ลงนาม)

Keystore แบบซอฟต์แวร์

Keystore แบบซอฟต์แวร์ — การดำเนินงานด้วยซอฟต์แวร์ที่ใช้บนอุปกรณ์ที่ไม่มีการรองรับ TEE หรือ StrongBox ด้วยฮาร์ดแวร์ คีย์จะถูกเก็บในรูปแบบแปลงข้อมูลในระบบไฟล์ แต่คีย์ส่วนตัวอาจถูกถอดรหัสชั่วคราวใน RAM Keystore แบบซอฟต์แวร์ มีความปลอดภัยน้อยกว่า — ผู้โจมตีที่มีสิทธิ์รูทสามารถดักดึงคีย์ในหน่วยความจำได้

ตั้งแต่ Android 12 (API 31) Google กำหนดให้อุปกรณ์ใหม่ทุกเครื่องต้องรองรับ Keystore ด้วยฮาร์ดแวร์ อุปกรณ์ Android 9–11 อาจมี Keystore แบบซอฟต์แวร์ในรุ่นราคาประหยัด นักพัฒนาสามารถตรวจสอบระดับการป้องกันได้ผ่าน KeyStore.getKeyCharacteristics() — แอตทริบิวต์ SECURITY_LEVEL_TRUSTED_ENVIRONMENT หรือ SECURITY_LEVEL_STRONGBOX ยืนยันการป้องกันด้วยฮาร์ดแวร์

อัลกอริทึมและฟังก์ชันที่รองรับ

Android Keystore รองรับชุดอัลกอริทึมด้านการเข้ารหัสที่หลากหลาย แบ่งตามประเภทของคีย์ การเลือกอัลกอริทึมมีผลต่อประสิทธิภาพความเข้ากันได้และระดับความปลอดภัย

AES (Advanced Encryption Standard) — การเข้ารหัสแบบสมมาตรสำหรับการปกป้องข้อมูลบนอุปกรณ์ โหมดที่แนะนำ: AES/GCM/NoPadding (256 บิต) GCM ให้การเข้ารหัสที่ได้รับการรับรองความถูกต้อง (AEAD) — ตรวจสอบความถูกต้องของข้อมูลที่ได้รับการเข้ารหัสแล้ว ขนาด IV (Initialization Vector) สำหรับ GCM: 12 ไบท์ อย่าใช้ AES/ECB — มันไม่ให้การป้องกันที่เหมาะสม

RSA (Rivest–Shamir–Adleman) — การเข้ารหัสแบบไม่สมมาตรสำหรับการปกป้องคีย์เซสชันและลายมือดิจิทัล ขนาดที่แนะนำ: 2048 หรือ 4096 บิต โหมด: RSA/ECB/PKCS1Padding (การเข้ารหัส) และ RSA/ECB/PKCS1Sign (ลายมือ) RSA 1024 ถือว่าล้าสมัยและไม่แนะนำสำหรับแอปพลิเคชันใหม่ (NIST SP 800-131A Rev. 2)

EC (Elliptic Curve) — การเข้ารหัสแบบไม่สมมาตรบนเส้นโค้งรีปสำหรับลายมือและการแลกเปลี่ยนคีย์ เส้นโค้งที่รองรับ: secp256r1 (P-256, จำเป็น), secp384r1 (P-384) และ secp521r1 (P-521) EC ให้ความปลอดภัยที่เท่ากันกับ RSA โดยมีขนาดคีย์ที่เล็กกว่ามาก P-256 เป็นที่แนะนำสำหรับสถานการณ์ส่วนใหญ่: รองรับโดยทุกอุปกรณ์และให้ระดับความปลอดภัย 128 บิต

HMAC (Hash-based Message Authentication Code) — การพิสูจน์แบบสมมาตรของข้อความ ฟังก์ชันแฮชที่รองรับ: SHA-256, SHA-384, SHA-512 HMAC ใช้สำหรับตรวจสอบความถูกต้องและความถูกต้องแท้ของข้อมูล เช่น สำหรับการตรวจสอบคำขอ webhook หรือตรวจสอบความถูกต้องของการกำหนดค่า

อัลกอริทึมทั้งหมดสามารถผูกกับการยืนยันแบบไบโอเมตริกซ์ผ่าน KeyGenParameterSpec.Builder.setUserAuthenticationRequired(true) บน Android 11+ มีแฟลก setUserAuthenticationParameters() ที่สามารถระบุหมดเวลา (ในวินาที) ที่คีย์จะพร้อมใช้งานหลังจากจากการยืนยันแบบไบโอเมตริกซ์โดยไม่ต้องขอใหม่

ตัวอย่างโค้ด: การสร้างและการใช้งานคีย์

ดูตัวอย่างเฉพาะเจาะจงกับ Android Keystore ใน Kotlin: การสร้างคีย์ AES, การเข้ารหัสข้อมูลและการสร้างคู่แบบไม่สมมาตรสำหรับลายมือ

การสร้างคีย์ AES ใน Keystore

ตัวอย่างสร้างคีย์ AES/GCM 256 บิตที่ผูกกับการยืนยันแบบไบโอเมตริกซ์ คีย์ไม่สามารถส่งออกผ่าน 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()
}

การเข้ารหัสข้อมูล AES/GCM

ตัวอย่างเข้ารหัสข้อมูลโดยใช้คีย์จาก Android Keystore Cipher ได้รับคีย์โดยชื่อแฝง เริ่มต้นการเข้ารหัส AES/GCM และส่งคืนข้อมูลที่เข้ารหัสแล้วพร้อมกับ 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 + ข้อมูลที่เข้ารหัสแล้ว
    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 สำหรับลายมือ

ตัวอย่างสร้างคู่คีย์ RSA-2048 ใน Keystore ที่ผูกกับ StrongBox คีย์ส่วนตัวใช้สำหรับลายมือ คีย์สาธารณะสามารถส่งออกผ่าน 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()

    // คีย์สาธารณะสามารถส่งออกได้
    val publicKey = pair.public // X509EncodedKeySpec
}

แนวปฏิบัติที่ดีที่สุดสำหรับ Android Keystore

การใช้งาน Android Keystore อย่างมีประสิทธิภาพต้องปฏิบัติตามกฎที่กำหนดเพื่อให้การป้องกันสูงสุดในขณะที่รักษาประสิทธิภาพ

ใช้ KeyGenParameterSpec ด้วยพารามิเตอร์ที่จำเป็นน้อยที่สุด: ระบุเฉพาะ purpose, block modes และ paddings ที่ใช้จริง พารามิเตอร์ที่เกินความจำเป็น (เช่น PURPOSE_ENCRYPT สำหรับคีย์ที่ใช้เพื่อลายมือเท่านั้น) สร้างเวกเตอร์การโจมตีที่ไม่จำเป็น Android แนะนำให้ระบุไดเจสต์สำหรับลายมืออย่างชัดเจน — SHA256 เป็นระดับต่ำสุดที่ยอมรับได้ (SHA1 ล้าสมัย)

ผูกคีย์กับไบโอเมตริกซ์สำหรับการดำเนินการที่สำคัญ: setUserAuthenticationRequired(true) รับประกันว่าคีย์สามารถใช้ได้หลังจากจากการยืนยันแบบไบโอเมตริกซ์เท่านั้น บน Android 11+ ใช้ setUserAuthenticationParameters() โดยระบุหมดเวลา (แนะนำ 30–60 วินาที) เพื่อไม่ต้องขอไบโอเมตริกซ์ทุกครั้งในเซสชันเดียวกัน setInvalidatedByBiometricEnrollment(true) จะลบคีย์โดยอัตโนมัติเมื่อเพิ่มลายนิ้วมือหรือใบหน้าใหม่ — ซึ่งป้องกันการเข้าถึงโดยใช้ข้อมูลไบโอเมตริกซ์เก่า

ตรวจสอบระดับความปลอดภัยในขั้นตอนเริ่มต้น: ใช้ KeyStore.getKeyCharacteristics() เพื่อกำหนด SECURITY_LEVEL หากอุปกรณ์รองรับเฉพาะ Keystore แบบซอฟต์แวร์ (SECURITY_LEVEL_SOFTWARE) ให้ตัดสินใจ: ปฏิเสธฟังก์ชันหรือใช้การเข้ารหัสเพิ่มเติม (เช่น ห่อคีย์ผ่านรหัสผ่านของผู้ใช้) อย่าพึ่งพา StrongBox หากไม่ได้รับการรับประกัน — ระบุแฟลก setIsStrongBoxBacked(true) เสมอ และตรวจสอบผลลัพธ์ผ่าน getKeyCharacteristics

อัพเดตคีย์ตามกำหนดเวลา: คีย์การเข้ารหัสมีอายุการใช้งานที่แนะนำ NIST SP 800-57 แนะนำให้เปลี่ยนคีย์ AES ทุก 1–2 ปี คู่ RSA/EC ทุก 2–3 ปี ดำเนินกลไกการหมุนเวียนคีย์: เมื่อเริ่มเชิงแอป ตรวจสอบวันที่สร้างคีย์ (KeyGenParameterSpec.Builder.setKeyValidityStart/End) และสร้างคีย์ใหม่เมื่อหมดอายุ ข้อมูลเก่าที่ถูกเข้ารหัสด้วยคีย์เก่าต้องถูกถอดรหัสและเข้ารหัสใหม่ด้วยคีย์ใหม่

อย่างใช้ Keystore สำหรับข้อมูลขนาดใหญ่: Keystore ถูออกแบบมาสำหรับการเก็บคีย์ (สองสามร้อยไบท์) ไม่ใช่สำหรับการเข้ารหัสไฟล์ขนาดใหญ่ สำหรับการเข้ารหัสข้อมูล ใช้โครงสร้าง: สร้างคีย์ AES แบบสุ่ม (DEK — Data Encryption Key) เข้ารหัสข้อมูลด้วยคีย์นี้ และเข้ารหัส DEK ด้วยคีย์ Keystore (KEK — Key Encryption Key) Android EncryptedSharedPreferences ใช้โครงสร้างนี้เหมือนกัน: คีย์หลักอยู่ใน Keystore ข้อมูล — AES-256 GCM