KeyProtection Klasse

Definition

[Android.Runtime.Register("android/security/keystore/KeyProtection", ApiSince=23, DoNotGenerateAcw=true)]
public sealed class KeyProtection : Java.Lang.Object, IDisposable, Java.Interop.IJavaPeerable, Java.Security.KeyStore.IProtectionParameter

[<Android.Runtime.Register("android/security/keystore/KeyProtection", ApiSince=23, DoNotGenerateAcw=true)>]
type KeyProtection = class
    inherit Object
    interface KeyStore.IProtectionParameter
    interface IJavaObject
    interface IDisposable
    interface IJavaPeerable

Vererbung

Object

Object

KeyProtection

Attribute

RegisterAttribute

Implementiert

IJavaObject IJavaPeerable KeyStore.IProtectionParameter IDisposable

Hinweise

Angabe, wie ein Schlüssel- oder Schlüsselpaar gesichert wird, wenn es in das Android Keystore-System importiert wird. Diese Klasse gibt autorisierte Verwendungen des importierten Schlüssels an, z. B. ob die Benutzerauthentifizierung für die Verwendung des Schlüssels erforderlich ist, für welche Vorgänge der Schlüssel autorisiert ist (z. B. Entschlüsselung, aber nicht signieren), mit welchen Parametern (z. B. nur mit einem bestimmten Abstandsschema oder Digest) und den Gültigkeits- und Enddaten des Schlüssels. Schlüsselverwendungsautorisierungen, die in dieser Klasse ausgedrückt werden, gelten nur für geheime Schlüssel und private Schlüssel – öffentliche Schlüssel können für alle unterstützten Vorgänge verwendet werden.

Um ein Schlüssel- oder Schlüsselpaar in den Android Keystore zu importieren, erstellen Sie eine Instanz dieser Klasse, indem Sie die Instanz java.security.KeyStore#setEntry(String, java.security.KeyStore.Entry, ProtectionParameter) KeyStore.setEntry mit Builder dem zu importierenden Schlüssel- oder Schlüsselpaar übergeben.

Um den geheimen/symmetrischen oder privaten Schlüssel aus dem Android Keystore zu erhalten, verwenden java.security.KeyStore#getKey(String, char[]) KeyStore.getKey(String, null) oder java.security.KeyStore#getEntry(String, java.security.KeyStore.ProtectionParameter) KeyStore.getEntry(String, null). Um den öffentlichen Schlüssel aus dem Android Keystore zu erhalten, verwenden java.security.KeyStore#getCertificate(String) Sie und dann Certificate#getPublicKey().

Um algorithmusspezifische öffentliche Parameter von Schlüsselpaaren zu erhalten, die im Android Keystore gespeichert sind, implementieren java.security.interfaces.ECKey oder java.security.interfaces.RSAKey schnittstellen seine privaten Schlüssel, während seine öffentlichen Schlüssel implementieren oder schnittstellen implementierenjava.security.interfaces.ECPublicKey.java.security.interfaces.RSAPublicKey

HINWEIS: Auf das schlüsselmaterial der im Android Keystore gespeicherten Schlüssel kann nicht zugegriffen werden.

Instanzen dieser Klasse sind unveränderlich.

<h3>Bekannte Probleme</h3> Ein bekannter Fehler in Android 6.0 (API Level 23) bewirkt, dass benutzerauthentifizierungsbezogene Autorisierungen auch für öffentliche Schlüssel erzwungen werden. Um dieses Problem zu umgehen, extrahieren Sie das öffentliche Schlüsselmaterial, das außerhalb von Android Keystore verwendet werden soll. Zum Beispiel:

{@code
            PublicKey unrestrictedPublicKey =
                    KeyFactory.getInstance(publicKey.getAlgorithm()).generatePublic(
                            new X509EncodedKeySpec(publicKey.getEncoded()));
            }

<h3>Beispiel: AES-Schlüssel für Verschlüsselung/Entschlüsselung im GCM-Modus</h3> In diesem Beispiel wird veranschaulicht, wie ein AES-Schlüssel in den Android KeyStore unter alias key1 importiert wird, der nur für die Verschlüsselung/Entschlüsselung im GCM-Modus ohne Abstand verwendet werden darf. Der Schlüssel muss sein Schlüsselmaterial im Key#getEncoded()RAW Format exportieren.

{@code
            SecretKey key = ...; // AES key

            KeyStore keyStore = KeyStore.getInstance("AndroidKeyStore");
            keyStore.load(null);
            keyStore.setEntry(
                    "key1",
                    new KeyStore.SecretKeyEntry(key),
                    new KeyProtection.Builder(KeyProperties.PURPOSE_ENCRYPT | KeyProperties.PURPOSE_DECRYPT)
                            .setBlockMode(KeyProperties.BLOCK_MODE_GCM)
                            .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
                            .build());
            // Key imported, obtain a reference to it.
            SecretKey keyStoreKey = (SecretKey) keyStore.getKey("key1", null);
            // The original key can now be discarded.

            Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
            cipher.init(Cipher.ENCRYPT_MODE, keyStoreKey);
            ...
            }

<h3>Beispiel: HMAC-Schlüssel zum Generieren von MACs mit SHA-512</h3> In diesem Beispiel wird veranschaulicht, wie ein HMAC-Schlüssel unter dem alias key1 importiert wird, der berechtigt ist, MACs mit SHA-512-Digest zu generieren. Der Schlüssel muss sein Schlüsselmaterial im Key#getEncoded()RAW Format exportieren.

{@code
            SecretKey key = ...; // HMAC key of algorithm "HmacSHA512".

            KeyStore keyStore = KeyStore.getInstance("AndroidKeyStore");
            keyStore.load(null);
            keyStore.setEntry(
                    "key1",
                    new KeyStore.SecretKeyEntry(key),
                    new KeyProtection.Builder(KeyProperties.PURPOSE_SIGN).build());
            // Key imported, obtain a reference to it.
            SecretKey keyStoreKey = (SecretKey) keyStore.getKey("key1", null);
            // The original key can now be discarded.

            Mac mac = Mac.getInstance("HmacSHA512");
            mac.init(keyStoreKey);
            ...
            }

<h3>Beispiel: EC-Schlüsselpaar für die Signierung/Überprüfung mithilfe von ECDSA</h3> In diesem Beispiel wird veranschaulicht, wie sie ein EC-Schlüsselpaar unter alias key2 in den Android KeyStore importieren, wobei der private Schlüssel nur für die Signierung mit SHA-256- oder SHA-512-Digests verwendet werden kann. Die Verwendung des öffentlichen Schlüssels ist uneingeschränkt. Sowohl der private als auch der öffentliche Schlüssel müssen ihr Schlüsselmaterial in Key#getEncoded()PKCS#8 bzw X.509 . formatieren.

{@code
            PrivateKey privateKey = ...;   // EC private key
            Certificate[] certChain = ...; // Certificate chain with the first certificate
                                           // containing the corresponding EC public key.

            KeyStore keyStore = KeyStore.getInstance("AndroidKeyStore");
            keyStore.load(null);
            keyStore.setEntry(
                    "key2",
                    new KeyStore.PrivateKeyEntry(privateKey, certChain),
                    new KeyProtection.Builder(KeyProperties.PURPOSE_SIGN)
                            .setDigests(KeyProperties.DIGEST_SHA256, KeyProperties.DIGEST_SHA512)
                            .build());
            // Key pair imported, obtain a reference to it.
            PrivateKey keyStorePrivateKey = (PrivateKey) keyStore.getKey("key2", null);
            PublicKey publicKey = keyStore.getCertificate("key2").getPublicKey();
            // The original private key can now be discarded.

            Signature signature = Signature.getInstance("SHA256withECDSA");
            signature.initSign(keyStorePrivateKey);
            ...
            }

<h3>Beispiel: RSA-Schlüsselpaar für die Signierung/Überprüfung mit PKCS#1 Padding</h3> In diesem Beispiel wird veranschaulicht, wie sie ein RSA-Schlüsselpaar unter Alias key2 mit dem privaten Schlüssel importieren, der autorisiert ist, nur für die Signierung mit dem PKCS#1-Signaturabstandsschema mit SHA-256-Digest zu verwenden und nur, wenn der Benutzer innerhalb der letzten zehn Minuten authentifiziert wurde. Die Verwendung des öffentlichen Schlüssels ist uneingeschränkt (siehe bekannte Probleme). Sowohl der private als auch der öffentliche Schlüssel müssen ihr Schlüsselmaterial in Key#getEncoded()PKCS#8 bzw X.509 . formatieren.

{@code
            PrivateKey privateKey = ...;   // RSA private key
            Certificate[] certChain = ...; // Certificate chain with the first certificate
                                           // containing the corresponding RSA public key.

            KeyStore keyStore = KeyStore.getInstance("AndroidKeyStore");
            keyStore.load(null);
            keyStore.setEntry(
                    "key2",
                    new KeyStore.PrivateKeyEntry(privateKey, certChain),
                    new KeyProtection.Builder(KeyProperties.PURPOSE_SIGN)
                            .setDigests(KeyProperties.DIGEST_SHA256)
                            .setSignaturePaddings(KeyProperties.SIGNATURE_PADDING_RSA_PKCS1)
                            // Only permit this key to be used if the user
                            // authenticated within the last ten minutes.
                            .setUserAuthenticationRequired(true)
                            .setUserAuthenticationValidityDurationSeconds(10 * 60)
                            .build());
            // Key pair imported, obtain a reference to it.
            PrivateKey keyStorePrivateKey = (PrivateKey) keyStore.getKey("key2", null);
            PublicKey publicKey = keyStore.getCertificate("key2").getPublicKey();
            // The original private key can now be discarded.

            Signature signature = Signature.getInstance("SHA256withRSA");
            signature.initSign(keyStorePrivateKey);
            ...
            }

<h3>Beispiel: RSA-Schlüsselpaar für Verschlüsselung/Entschlüsselung mit PKCS#1 Padding</h3> In diesem Beispiel wird veranschaulicht, wie sie ein RSA-Schlüsselpaar unter Alias key2 mit dem privaten Schlüssel importieren, der berechtigt ist, nur für die Entschlüsselung mit dem PKCS#1-Verschlüsselungsabstandsschema zu verwenden. Die Verwendung von öffentlichem Schlüssel ist uneingeschränkt und erlaubt somit verschlüsselungsfreie Verwendung von Abstandsschemas und Digests. Sowohl der private als auch der öffentliche Schlüssel müssen ihr Schlüsselmaterial in Key#getEncoded()PKCS#8 bzw X.509 . formatieren.

{@code
            PrivateKey privateKey = ...;   // RSA private key
            Certificate[] certChain = ...; // Certificate chain with the first certificate
                                           // containing the corresponding RSA public key.

            KeyStore keyStore = KeyStore.getInstance("AndroidKeyStore");
            keyStore.load(null);
            keyStore.setEntry(
                    "key2",
                    new KeyStore.PrivateKeyEntry(privateKey, certChain),
                    new KeyProtection.Builder(KeyProperties.PURPOSE_DECRYPT)
                            .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_RSA_PKCS1)
                            .build());
            // Key pair imported, obtain a reference to it.
            PrivateKey keyStorePrivateKey = (PrivateKey) keyStore.getKey("key2", null);
            PublicKey publicKey = keyStore.getCertificate("key2").getPublicKey();
            // The original private key can now be discarded.

            Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
            cipher.init(Cipher.DECRYPT_MODE, keyStorePrivateKey);
            ...
            }

Java-Dokumentation für android.security.keystore.KeyProtection.

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die vom Android Open Source-Projekt erstellt und freigegeben werden und gemäß den in der Creative Commons 2.5 Attribution License beschriebenen Begriffen verwendet werden.

Eigenschaften

Methoden

Explizite Schnittstellenimplementierungen

Erweiterungsmethoden

Gilt für: