KeyProtection Classe

Définition

[Android.Runtime.Register("android/security/keystore/KeyProtection", ApiSince=23, DoNotGenerateAcw=true)]
public sealed class KeyProtection : Java.Lang.Object, IDisposable, 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

Héritage

Object

JavaObject

Object

KeyProtection

Attributs

RegisterAttribute

Implémente

IJavaObject IJavaPeerable KeyStore.IProtectionParameter IDisposable

Remarques

Spécification de la façon dont une paire de clés ou de clés est sécurisée lorsqu’elle est importée dans le système Android Keystore. Cette classe spécifie les utilisations autorisées de la clé importée, par exemple si l’authentification de l’utilisateur est requise pour l’utilisation de la clé, quelles opérations la clé est autorisée (par exemple, déchiffrement, mais pas signature) avec les paramètres (par exemple, avec un schéma de remplissage ou un digest particulier) et les dates de début et de fin de la clé. Les autorisations d’utilisation de clé exprimées dans cette classe s’appliquent uniquement aux clés secrètes et aux clés privées . Les clés publiques peuvent être utilisées pour toutes les opérations prises en charge.

Pour importer une clé ou une paire de clés dans le magasin de clés Android, créez une instance de cette classe à l’aide de l’instance Builder et transmettez l’instance avec java.security.KeyStore#setEntry(String, java.security.KeyStore.Entry, ProtectionParameter) KeyStore.setEntry la clé ou la paire de clés importée.

Pour obtenir la clé secrète/symétrique ou privée à partir de l’utilisation java.security.KeyStore#getKey(String, char[]) KeyStore.getKey(String, null) du magasin de clés Android ou java.security.KeyStore#getEntry(String, java.security.KeyStore.ProtectionParameter) KeyStore.getEntry(String, null). Pour obtenir la clé publique à partir de l’utilisation java.security.KeyStore#getCertificate(String) du magasin de clés Android, puis Certificate#getPublicKey().

Pour obtenir des paramètres publics spécifiques à l’algorithme des paires de clés stockées dans le magasin de clés Android, ses clés privées implémentent java.security.interfaces.ECKey ou java.security.interfaces.RSAKey interfaces, tandis que ses clés publiques implémentent java.security.interfaces.ECPublicKey ou java.security.interfaces.RSAPublicKey interfaces.

REMARQUE : Le matériel de clé des clés stocké dans le magasin de clés Android n’est pas accessible.

Les instances de cette classe sont immuables.

<H3>Problèmes< connus/h3> Un bogue connu dans Android 6.0 (niveau d’API 23) entraîne l’application des autorisations liées à l’authentification utilisateur même pour les clés publiques. Pour contourner ce problème, extrayez le matériel de clé publique à utiliser en dehors d’Android Keystore. Par exemple:

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

<Exemple h3>: Clé AES pour le chiffrement/déchiffrement en mode< GCM/h3> Cet exemple montre comment importer une clé AES dans le Magasin de clés Android sous l’alias key1 autorisé à être utilisé uniquement pour le chiffrement/déchiffrement en mode GCM sans remplissage. La clé doit exporter son matériau de clé au Key#getEncoded()RAW format.

{@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);
            ...
            }

<Exemple h3>: clé HMAC pour la génération de macs à l’aide de SHA-512</h3> Cet exemple montre comment importer une clé HMAC dans le Magasin de clés Android sous l’alias key1 autorisé à être utilisé uniquement pour générer des macs à l’aide du digest SHA-512. La clé doit exporter son matériau de clé au Key#getEncoded()RAW format.

{@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);
            ...
            }

<Exemple h3>: Paire de clés EC pour la signature/vérification à l’aide d’ECDSA</h3> Cet exemple montre comment importer une paire de clés EC dans le Magasin de clés Android sous l’alias key2 avec la clé privée autorisée à être utilisée uniquement pour la signature avec les synthèses SHA-256 ou SHA-512. L’utilisation de la clé publique est illimitée. La clé privée et la clé publique doivent exporter leur matériel de clé via Key#getEncoded() et PKCS#8 au X.509 format respectivement.

{@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);
            ...
            }

<Exemple h3>: Paire de clés RSA pour la signature/vérification à l’aide du remplissage< PKCS#1/h3> Cet exemple montre comment importer une paire de clés RSA dans le Magasin de clés Android sous l’alias key2 avec la clé privée autorisée à être utilisée uniquement pour la signature à l’aide du schéma de remplissage de signature PKCS#1 avec sha-256 digest et uniquement si l’utilisateur a été authentifié au cours des dix dernières minutes. L’utilisation de la clé publique est illimitée (voir Problèmes connus). La clé privée et la clé publique doivent exporter leur matériel de clé via Key#getEncoded() et PKCS#8 au X.509 format respectivement.

{@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);
            ...
            }

<Exemple h3>: Paire de clés RSA pour le chiffrement/déchiffrement à l’aide du remplissage< PKCS#1/h3> Cet exemple montre comment importer une paire de clés RSA dans android KeyStore sous l’alias key2 avec la clé privée autorisée à être utilisée uniquement pour le déchiffrement à l’aide du schéma de remplissage de chiffrement PKCS#1. L’utilisation de la clé publique est illimitée, ce qui autorise le chiffrement à l’aide de schémas de remplissage et de synthèses. La clé privée et la clé publique doivent exporter leur matériel de clé via Key#getEncoded() et PKCS#8 au X.509 format respectivement.

{@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 documentation pour android.security.keystore.KeyProtection.

Les parties de cette page sont des modifications basées sur le travail créé et partagé par Android Open Source et utilisées en fonction des termes décrits dans la Creative Commons 2.5 Attribution License.