ระบบ Android Keystore

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

ระบบคีย์สโตร์ใช้โดย KeyChain API ที่เปิดตัวใน Android 4.0 (API ระดับ 14) รวมถึงฟีเจอร์ผู้ให้บริการ Android Keystore ที่เปิดตัวใน Android 4.3 (API ระดับ 18) เอกสารนี้จะอธิบายถึงกรณีและวิธีใช้ระบบ Keystore ของ Android

ฟีเจอร์การรักษาความปลอดภัย

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

การป้องกันการแยก

เนื้อหาคีย์ของคีย์สโตร์ Android ได้รับการปกป้องจากการดึงโดยใช้มาตรการความปลอดภัย 2 แบบดังนี้

• ข้อมูลสำคัญจะไม่เข้าสู่กระบวนการสมัคร เมื่อแอปดำเนินการทางวิทยาการเข้ารหัสโดยใช้คีย์ในคีย์สโตร์ Android ระบบจะส่งข้อความที่เป็นข้อความธรรมดา ข้อความที่เข้ารหัส และข้อความที่จะลงชื่อหรือยืนยันไปยังกระบวนการของระบบที่ดำเนินการทางวิทยาการเข้ารหัสลับ หากกระบวนการของแอปถูกบุกรุก ผู้โจมตีอาจใช้คีย์ของแอปได้ แต่จะดึงข้อมูลวัสดุคีย์ไม่ได้ (เช่น เพื่อนำไปใช้นอกอุปกรณ์ Android)
• คุณสามารถเชื่อมโยงข้อมูลคีย์กับฮาร์ดแวร์ที่ปลอดภัยของอุปกรณ์ Android เช่น Trusted Execution Environment (TEE) หรือ Secure Element (SE) เมื่อเปิดใช้ฟีเจอร์นี้สำหรับคีย์ เนื้อหาคีย์จะไม่แสดงนอกฮาร์ดแวร์ที่มีความปลอดภัย หากระบบปฏิบัติการ Android ถูกบุกรุกหรือผู้โจมตีอ่านที่จัดเก็บข้อมูลภายในของอุปกรณ์ได้ ผู้โจมตีอาจใช้คีย์คีย์สโตร์ Android ของแอปใดก็ได้ในอุปกรณ์ Android แต่จะดึงออกจากอุปกรณ์ไม่ได้ ฟีเจอร์นี้จะเปิดใช้ก็ต่อเมื่อฮาร์ดแวร์ที่มีความปลอดภัยของอุปกรณ์รองรับชุดค่าผสมของอัลกอริทึมของคีย์ โหมดบล็อก รูปแบบการเติม และข้อมูลสรุปที่อนุญาตให้ใช้คีย์

  หากต้องการตรวจสอบว่าฟีเจอร์นี้เปิดใช้สำหรับคีย์หรือไม่ ให้รับ KeyInfo สำหรับคีย์นั้น ขั้นตอนถัดไปจะขึ้นอยู่กับเวอร์ชัน SDK เป้าหมายของแอป

  • หากแอปกำหนดเป้าหมายเป็น Android 10 (API ระดับ 29) ขึ้นไป ให้ตรวจสอบค่าที่แสดงผลของ getSecurityLevel() ค่าที่แสดงผลตรงกับ KeyProperties.SecurityLevelEnum.TRUSTED_ENVIRONMENT หรือ KeyProperties.SecurityLevelEnum.STRONGBOX บ่งชี้ว่าคีย์อยู่ในฮาร์ดแวร์ที่ปลอดภัย
  • หากแอปกำหนดเป้าหมายเป็น Android 9 (API ระดับ 28) หรือต่ำกว่า ให้ตรวจสอบค่าบูลีนที่แสดงผลของ KeyInfo.isInsideSecurityHardware()

โมดูลความปลอดภัยแบบฮาร์ดแวร์

อุปกรณ์ที่รองรับซึ่งใช้ Android 9 (API ระดับ 28) ขึ้นไปจะมีKeymaster ของ StrongBox ซึ่งเป็นการใช้งาน Keymaster หรือ Keymint HAL ที่อยู่ในองค์ประกอบที่ปลอดภัยซึ่งมีลักษณะคล้ายกับโมดูลความปลอดภัยฮาร์ดแวร์ แม้ว่าโมดูลความปลอดภัยของฮาร์ดแวร์อาจหมายถึงการใช้งานที่หลากหลายของที่เก็บคีย์ ซึ่งการบุกรุกเคอร์เนล Linux ไม่สามารถเปิดเผยได้ เช่น TEE แต่ StrongBox จะหมายถึงอุปกรณ์อย่างองค์ประกอบที่ปลอดภัยแบบฝัง (eSE) หรือหน่วยประมวลผลที่ปลอดภัยใน SoC (iSE) อย่างชัดเจน

โมดูลมีองค์ประกอบดังนี้

• CPU ของตัวเอง
• พื้นที่เก็บข้อมูลที่ปลอดภัย
• โปรแกรมสร้างตัวเลขสุ่มจริง
• กลไกเพิ่มเติมในการต่อต้านการดัดแปลงแพ็กเกจและการโหลดแอปจากแหล่งที่ไม่รู้จักโดยไม่ได้รับอนุญาต
• ตัวจับเวลาที่ปลอดภัย
• PIN แจ้งการรีบูต (หรือเทียบเท่า) เช่น อินพุต/เอาต์พุตสำหรับการใช้งานทั่วไป (GPIO)

ระบบรองรับอัลกอริทึมและขนาดคีย์ชุดย่อยต่อไปนี้เพื่อรองรับการใช้งาน StrongBox แบบใช้พลังงานต่ำ

• RSA 2048
• AES 128 และ 256
• ECDSA, ECDH P-256
• HMAC-SHA256 (รองรับขนาดคีย์ระหว่าง 8 ถึง 64 ไบต์)
• Triple DES
• APDU ความยาวแบบขยาย
• เอกสารรับรองคีย์
• การสนับสนุนการแก้ไข H สำหรับการอัปเกรด

เมื่อสร้างหรือนําเข้าคีย์โดยใช้คลาส KeyStore คุณระบุค่ากําหนดในการจัดเก็บคีย์ใน Keymaster ของ StrongBox โดยส่ง true ไปยังเมธอด setIsStrongBoxBacked()

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

การให้สิทธิ์การใช้คีย์

Android Keystore อนุญาตให้แอประบุการใช้งานคีย์ที่ได้รับอนุญาตเมื่อสร้างหรือนำเข้าคีย์เพื่อหลีกเลี่ยงการใช้คีย์โดยไม่ได้รับอนุญาตในอุปกรณ์ Android เมื่อสร้างหรือนําเข้าคีย์แล้ว คุณจะเปลี่ยนแปลงการให้สิทธิ์ของคีย์ไม่ได้ จากนั้น Android Keystore จะบังคับใช้การให้สิทธิ์ทุกครั้งที่มีการใช้คีย์ ฟีเจอร์นี้เป็นฟีเจอร์ด้านความปลอดภัยขั้นสูงที่โดยทั่วไปจะมีประโยชน์ก็ต่อเมื่อข้อกำหนดของคุณระบุว่าการประนีประนอมกระบวนการสมัครหลังจากการสร้าง/นำเข้าคีย์ (แต่ไม่ใช่ก่อนหรือระหว่าง) ต้องไม่นำไปสู่การนำคีย์ไปใช้โดยไม่ได้รับอนุญาต

การให้สิทธิ์การใช้คีย์ที่รองรับจะแบ่งออกเป็นหมวดหมู่ต่อไปนี้

• การเข้ารหัส: คีย์ใช้ได้กับอัลกอริทึม การดำเนินการ หรือวัตถุประสงค์ของคีย์ที่ได้รับอนุญาตเท่านั้น (เข้ารหัส ถอดรหัส ลงนาม ยืนยัน) รูปแบบการเติม รูปแบบบล็อก หรือข้อมูลสรุป
• ช่วงเวลาที่ใช้งานได้: คีย์ได้รับอนุญาตให้ใช้งานได้ในช่วงเวลาที่กําหนดเท่านั้น
• การตรวจสอบสิทธิ์ผู้ใช้: จะใช้คีย์ได้ก็ต่อเมื่อผู้ใช้ได้รับการตรวจสอบสิทธิ์เมื่อเร็วๆ นี้ โปรดดูกำหนดให้ต้องมีการตรวจสอบสิทธิ์ผู้ใช้เพื่อใช้คีย์

เพื่อเป็นการเพิ่มมาตรการรักษาความปลอดภัยสำหรับคีย์ที่มีข้อมูลคีย์อยู่ภายในฮาร์ดแวร์ที่มีความปลอดภัย (ดู KeyInfo.isInsideSecurityHardware() หรือสำหรับแอปที่กำหนดเป้าหมายเป็น Android 10 (API ระดับ 29) ขึ้นไป ให้ดู KeyInfo.getSecurityLevel()) ฮาร์ดแวร์ที่มีความปลอดภัยอาจบังคับใช้การให้สิทธิ์การใช้คีย์บางอย่าง ทั้งนี้ขึ้นอยู่กับอุปกรณ์ Android ฮาร์ดแวร์ที่มีความปลอดภัยมักจะบังคับใช้การเข้ารหัสและการตรวจสอบสิทธิ์ของผู้ใช้ รวมถึงการให้สิทธิ์ อย่างไรก็ตาม ฮาร์ดแวร์ที่ปลอดภัยมักจะไม่บังคับใช้การให้สิทธิ์ช่วงเวลาความถูกต้องชั่วคราว เนื่องจากโดยปกติจะไม่มีนาฬิกาแบบเรียลไทม์ที่ปลอดภัยเป็นอิสระ

คุณค้นหาได้ว่าฮาร์ดแวร์ที่ปลอดภัยมีการบังคับใช้การให้สิทธิ์การตรวจสอบสิทธิ์ผู้ใช้ของคีย์หรือไม่โดยใช้ KeyInfo.isUserAuthenticationRequirementEnforcedBySecureHardware()

เลือกระหว่างพวงกุญแจกับผู้ให้บริการ Android Keystore

ใช้ KeyChain API เมื่อคุณต้องการข้อมูลเข้าสู่ระบบทั่วทั้งระบบ เมื่อแอปขอใช้ข้อมูลเข้าสู่ระบบผ่าน KeyChain API ผู้ใช้จะเลือกจาก UI ที่ระบบมีให้ ซึ่งเป็นข้อมูลเข้าสู่ระบบที่ติดตั้งไว้ที่แอปเข้าถึงได้ วิธีนี้ช่วยให้แอปหลายแอปใช้ข้อมูลเข้าสู่ระบบชุดเดียวกันเมื่อได้รับความยินยอมจากผู้ใช้

ใช้ผู้ให้บริการ Android Keystore เพื่ออนุญาตให้แอปแต่ละแอปจัดเก็บข้อมูลเข้าสู่ระบบของตนเอง ซึ่งจะมีเพียงแอปนั้นเท่านั้นที่เข้าถึงได้ วิธีนี้ช่วยให้แอปจัดการข้อมูลเข้าสู่ระบบที่ใช้งานได้เฉพาะแอปนั้นๆ ในขณะเดียวกันก็ให้ประโยชน์ด้านความปลอดภัยเช่นเดียวกับที่ KeyChain API มีให้สำหรับข้อมูลเข้าสู่ระบบทั้งระบบ วิธีนี้ไม่จําเป็นให้ผู้ใช้เลือกข้อมูลเข้าสู่ระบบ

ใช้ผู้ให้บริการ Android Keystore

หากต้องการใช้ฟีเจอร์นี้ คุณต้องใช้คลาส KeyStore แบบมาตรฐาน และ KeyPairGenerator หรือ KeyGenerator พร้อมกับผู้ให้บริการ AndroidKeyStore ที่เปิดตัวใน Android 4.3 (API ระดับ 18)

AndroidKeyStore ได้รับการลงทะเบียนเป็นประเภท KeyStore เพื่อใช้กับเมธอด KeyStore.getInstance(type) และใช้เป็นผู้ให้บริการเพื่อใช้กับเมธอด KeyPairGenerator.getInstance(algorithm, provider) และ KeyGenerator.getInstance(algorithm, provider)

เนื่องจากการดำเนินการเข้ารหัสอาจใช้เวลานาน แอปจึงควรหลีกเลี่ยงการใช้ AndroidKeyStore ในเธรดหลักเพื่อให้ UI ของแอปยังคงตอบสนอง (StrictMode ช่วยคุณค้นหาสถานที่ที่ไม่ใช่เช่นนั้น)

สร้างคีย์ส่วนตัวหรือคีย์ลับใหม่

หากต้องการสร้าง KeyPair ใหม่ที่มี PrivateKey คุณต้องระบุแอตทริบิวต์ X.509 เริ่มต้นของใบรับรอง คุณสามารถใช้ KeyStore.setKeyEntry() เพื่อแทนที่ใบรับรองในภายหลังด้วยใบรับรองที่รับรองโดยผู้ออกใบรับรอง (CA)

หากต้องการสร้างคู่คีย์ ให้ใช้ KeyPairGenerator กับ KeyGenParameterSpec ดังนี้

/*
 * Generate a new EC key pair entry in the Android Keystore by
 * using the KeyPairGenerator API. The private key can only be
 * used for signing or verification and only with SHA-256 or
 * SHA-512 as the message digest.
 */
val kpg: KeyPairGenerator = KeyPairGenerator.getInstance(
        KeyProperties.KEY_ALGORITHM_EC,
        "AndroidKeyStore"
)
val parameterSpec: KeyGenParameterSpec = KeyGenParameterSpec.Builder(
        alias,
        KeyProperties.PURPOSE_SIGN or KeyProperties.PURPOSE_VERIFY
).run {
    setDigests(KeyProperties.DIGEST_SHA256, KeyProperties.DIGEST_SHA512)
    build()
}

kpg.initialize(parameterSpec)

val kp = kpg.generateKeyPair()

/*
 * Generate a new EC key pair entry in the Android Keystore by
 * using the KeyPairGenerator API. The private key can only be
 * used for signing or verification and only with SHA-256 or
 * SHA-512 as the message digest.
 */
KeyPairGenerator kpg = KeyPairGenerator.getInstance(
        KeyProperties.KEY_ALGORITHM_EC, "AndroidKeyStore");
kpg.initialize(new KeyGenParameterSpec.Builder(
        alias,
        KeyProperties.PURPOSE_SIGN | KeyProperties.PURPOSE_VERIFY)
        .setDigests(KeyProperties.DIGEST_SHA256,
            KeyProperties.DIGEST_SHA512)
        .build());

KeyPair kp = kpg.generateKeyPair();

นำเข้าคีย์ที่เข้ารหัสไปยังฮาร์ดแวร์ที่มีความปลอดภัย

Android 9 (API ระดับ 28) ขึ้นไปช่วยให้คุณนําเข้าคีย์ที่เข้ารหัสอย่างปลอดภัยไปยังคีย์สโตร์ได้โดยใช้รูปแบบคีย์ที่เข้ารหัส ASN.1 จากนั้น Keymaster จะถอดรหัสคีย์ในคีย์สโตร์ เพื่อให้เนื้อหาของคีย์ไม่ปรากฏเป็นข้อความธรรมดาในหน่วยความจำโฮสต์ของอุปกรณ์ กระบวนการนี้ให้ความปลอดภัยเพิ่มเติมในการถอดรหัสคีย์

หากต้องการรองรับการนําเข้าคีย์ที่เข้ารหัสไปยังคีย์สโตร์อย่างปลอดภัย ให้ทําตามขั้นตอนต่อไปนี้

1. สร้างคู่คีย์ที่ใช้จุดประสงค์ PURPOSE_WRAP_KEY เราขอแนะนำให้คุณเพิ่มการรับรองลงในคู่คีย์นี้ด้วย

2. สร้างข้อความ ASN.1 สำหรับ SecureKeyWrapper ในเซิร์ฟเวอร์หรือเครื่องที่เชื่อถือ

   Wrapper ประกอบด้วยสคีมาต่อไปนี้

      KeyDescription ::= SEQUENCE {
          keyFormat INTEGER,
          authorizationList AuthorizationList
      }
   
      SecureKeyWrapper ::= SEQUENCE {
          wrapperFormatVersion INTEGER,
          encryptedTransportKey OCTET_STRING,
          initializationVector OCTET_STRING,
          keyDescription KeyDescription,
          secureKey OCTET_STRING,
          tag OCTET_STRING
      }
   

3. สร้างออบเจ็กต์ WrappedKeyEntry โดยส่งข้อความ ASN.1 เป็นอาร์เรย์ไบต์

4. ส่งออบเจ็กต์ WrappedKeyEntry นี้ไปยังการโอเวอร์โหลดของ setEntry() ที่ยอมรับออบเจ็กต์ Keystore.Entry

ทำงานกับรายการคีย์สโตร์

คุณเข้าถึงผู้ให้บริการ AndroidKeyStore ได้ผ่าน KeyStore API มาตรฐานทั้งหมด

แสดงรายการ

แสดงรายการรายการในคีย์สโตร์โดยการเรียกใช้เมธอด aliases()

/*
 * Load the Android KeyStore instance using the
 * AndroidKeyStore provider to list the currently stored entries.
 */
val ks: KeyStore = KeyStore.getInstance("AndroidKeyStore").apply {
   load(null)
}
val aliases: Enumeration<String> = ks.aliases()

/*
 * Load the Android KeyStore instance using the
 * AndroidKeyStore provider to list the currently stored entries.
 */
KeyStore ks = KeyStore.getInstance("AndroidKeyStore");
ks.load(null);
Enumeration<String> aliases = ks.aliases();

ลงนามและยืนยันข้อมูล

ลงนามข้อมูลโดยดึงข้อมูล KeyStore.Entry จากคีย์สโตร์และใช้ API ของ Signature เช่น sign():

/*
 * Use a PrivateKey in the KeyStore to create a signature over
 * some data.
 */
val ks: KeyStore = KeyStore.getInstance("AndroidKeyStore").apply {
    load(null)
}
val entry: KeyStore.Entry = ks.getEntry(alias, null)
if (entry !is KeyStore.PrivateKeyEntry) {
    Log.w(TAG, "Not an instance of a PrivateKeyEntry")
    return null
}
val signature: ByteArray = Signature.getInstance("SHA256withECDSA").run {
    initSign(entry.privateKey)
    update(data)
    sign()
}

/*
 * Use a PrivateKey in the KeyStore to create a signature over
 * some data.
 */
KeyStore ks = KeyStore.getInstance("AndroidKeyStore");
ks.load(null);
KeyStore.Entry entry = ks.getEntry(alias, null);
if (!(entry instanceof PrivateKeyEntry)) {
    Log.w(TAG, "Not an instance of a PrivateKeyEntry");
    return null;
}
Signature s = Signature.getInstance("SHA256withECDSA");
s.initSign(((PrivateKeyEntry) entry).getPrivateKey());
s.update(data);
byte[] signature = s.sign();

ในทํานองเดียวกัน ให้ยืนยันข้อมูลด้วยวิธีการ verify(byte[]) ดังนี้

/*
 * Verify a signature previously made by a private key in the
 * KeyStore. This uses the X.509 certificate attached to the
 * private key in the KeyStore to validate a previously
 * generated signature.
 */
val ks = KeyStore.getInstance("AndroidKeyStore").apply {
    load(null)
}
val entry = ks.getEntry(alias, null) as? KeyStore.PrivateKeyEntry
if (entry == null) {
    Log.w(TAG, "Not an instance of a PrivateKeyEntry")
    return false
}
val valid: Boolean = Signature.getInstance("SHA256withECDSA").run {
    initVerify(entry.certificate)
    update(data)
    verify(signature)
}

/*
 * Verify a signature previously made by a private key in the
 * KeyStore. This uses the X.509 certificate attached to the
 * private key in the KeyStore to validate a previously
 * generated signature.
 */
KeyStore ks = KeyStore.getInstance("AndroidKeyStore");
ks.load(null);
KeyStore.Entry entry = ks.getEntry(alias, null);
if (!(entry instanceof PrivateKeyEntry)) {
    Log.w(TAG, "Not an instance of a PrivateKeyEntry");
    return false;
}
Signature s = Signature.getInstance("SHA256withECDSA");
s.initVerify(((PrivateKeyEntry) entry).getCertificate());
s.update(data);
boolean valid = s.verify(signature);

กำหนดให้มีการตรวจสอบสิทธิ์ผู้ใช้เพื่อใช้งานคีย์

เมื่อสร้างหรือนําเข้าคีย์ลงใน AndroidKeyStore คุณสามารถกําหนดให้คีย์ได้รับอนุญาตให้ใช้งานได้ก็ต่อเมื่อผู้ใช้ได้รับการตรวจสอบสิทธิ์เท่านั้น ระบบจะตรวจสอบสิทธิ์ผู้ใช้โดยใช้ข้อมูลเข้าสู่ระบบของหน้าจอล็อกที่ปลอดภัยเพียงบางส่วน (รูปแบบ/PIN/รหัสผ่าน ข้อมูลเข้าสู่ระบบไบโอเมตริก)

ฟีเจอร์นี้เป็นฟีเจอร์การรักษาความปลอดภัยขั้นสูงที่โดยทั่วไปจะมีประโยชน์เฉพาะในกรณีที่ข้อกำหนดคือช่องโหว่ของกระบวนการของแอปพลิเคชันหลังจากสร้าง/นำเข้าคีย์ (แต่ก่อนหรือระหว่างนั้น) ไม่สามารถข้ามข้อกำหนดที่ต้องมีการตรวจสอบสิทธิ์ผู้ใช้เพื่อใช้คีย์ได้

เมื่อคีย์ได้รับอนุญาตให้ใช้งานได้เฉพาะในกรณีที่ผู้ใช้ได้รับการตรวจสอบสิทธิ์แล้ว คุณสามารถเรียกใช้ setUserAuthenticationParameters() เพื่อกําหนดค่าให้ทํางานในโหมดใดโหมดหนึ่งต่อไปนี้

ให้สิทธิ์เป็นระยะเวลาหนึ่ง

คีย์ทั้งหมดจะได้รับสิทธิ์ให้ใช้งานทันทีที่ผู้ใช้ตรวจสอบสิทธิ์โดยใช้ข้อมูลเข้าสู่ระบบที่ระบุ

ให้สิทธิ์ในช่วงระยะเวลาของการดำเนินการเข้ารหัสที่เฉพาะเจาะจง

การดำเนินการแต่ละรายการที่เกี่ยวข้องกับคีย์ที่เฉพาะเจาะจงต้องได้รับสิทธิ์จากผู้ใช้เป็นรายบุคคล

แอปของคุณจะเริ่มกระบวนการนี้ด้วยการเรียกใช้ authenticate() ในอินสแตนซ์ของ BiometricPrompt

สำหรับคีย์แต่ละรายการที่คุณสร้าง คุณจะเลือกรองรับข้อมูลเข้าสู่ระบบไบโอเมตริกที่รัดกุม ข้อมูลเข้าสู่ระบบหน้าจอล็อก หรือทั้ง 2 ประเภทก็ได้ หากต้องการตรวจสอบว่าผู้ใช้ได้ตั้งค่าข้อมูลเข้าสู่ระบบที่กุญแจของแอปใช้หรือไม่ ให้เรียกใช้ canAuthenticate()

หากคีย์รองรับเฉพาะข้อมูลเข้าสู่ระบบไบโอเมตริก คีย์จะใช้งานไม่ได้โดยค่าเริ่มต้นทุกครั้งที่มีการเพิ่มการลงทะเบียนข้อมูลไบโอเมตริกใหม่ คุณสามารถกำหนดค่าให้คีย์ใช้งานได้ต่อไปเมื่อมีการเพิ่มการลงทะเบียนข้อมูลไบโอเมตริกใหม่ โดยส่ง false ไปยัง setInvalidatedByBiometricEnrollment()

ดูข้อมูลเพิ่มเติมเกี่ยวกับวิธีเพิ่มความสามารถในการตรวจสอบสิทธิ์ด้วยข้อมูลไบโอเมตริกลงในแอป รวมถึงวิธีแสดงกล่องโต้ตอบการตรวจสอบสิทธิ์ด้วยข้อมูลไบโอเมตริก

อัลกอริทึมที่รองรับ

• Cipher
• KeyGenerator
• KeyFactory
• KeyStore (รองรับประเภทคีย์เดียวกับ KeyGenerator และ KeyPairGenerator)
• KeyPairGenerator
• Mac
• Signature
• SecretKeyFactory

บทความในบล็อก

ดูบล็อกโพสต์ การรวมการเข้าถึงที่เก็บคีย์ใน ICS