KeyProtection Classe

Definição

[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

Herança

Object

JavaObject

Object

KeyProtection

Atributos

RegisterAttribute

Implementações

IJavaObject IJavaPeerable KeyStore.IProtectionParameter IDisposable

Comentários

Especificação de como um par de chaves ou chave é protegido quando importado para o sistema Android Keystore. Essa classe especifica os usos autorizados da chave importada, como se a autenticação de usuário é necessária para usar a chave, para quais operações a chave está autorizada (por exemplo, descriptografia, mas não assinatura) com quais parâmetros (por exemplo, apenas com um esquema de preenchimento ou resumo específico) e as datas de início e término da validade da chave. As autorizações de uso de chave expressas nessa classe se aplicam somente a chaves secretas e chaves privadas. As chaves públicas podem ser usadas para qualquer operação com suporte.

Para importar uma chave ou par de chaves para o Repositório de Chaves do Android, crie uma instância dessa classe usando a Builder instância e passe a instância java.security.KeyStore#setEntry(String, java.security.KeyStore.Entry, ProtectionParameter) KeyStore.setEntry com a chave ou o par de chaves sendo importado.

Para obter a chave secreta/simétrica ou privada do Android Keystore use java.security.KeyStore#getKey(String, char[]) KeyStore.getKey(String, null) ou java.security.KeyStore#getEntry(String, java.security.KeyStore.ProtectionParameter) KeyStore.getEntry(String, null). Para obter a chave pública do android Keystore use java.security.KeyStore#getCertificate(String) e, em seguida Certificate#getPublicKey(), .

Para ajudar a obter parâmetros públicos específicos do algoritmo de pares de chaves armazenados no Repositório de Chaves do Android, suas chaves privadas implementam java.security.interfaces.ECKey ou java.security.interfaces.RSAKey interfaces, enquanto suas chaves públicas implementam java.security.interfaces.ECPublicKey ou java.security.interfaces.RSAPublicKey interfaces.

OBSERVAÇÃO: O material de chave das chaves armazenadas no Repositório de Chaves do Android não está acessível.

As instâncias dessa classe são imutáveis.

<h3>Problemas conhecidos</h3> Um bug conhecido no Android 6.0 (Nível de API 23) faz com que as autorizações relacionadas à autenticação do usuário sejam impostas mesmo para chaves públicas. Para contornar esse problema, extraia o material de chave pública a ser usado fora do Android Keystore. Por exemplo:

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

<Exemplo de h3>: chave AES para criptografia/descriptografia no modo< GCM/h3> Este exemplo ilustra como importar uma chave AES para o Android KeyStore sob alias key1 autorizado a ser usado apenas para criptografia/descriptografia no modo GCM sem preenchimento. A chave deve exportar seu material de chave por meio Key#getEncoded() do RAW formato.

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

<Exemplo de h3>: chave HMAC para gerar MACs usando SHA-512</h3> Este exemplo ilustra como importar uma chave HMAC para o Android KeyStore sob alias key1 autorizado a ser usado apenas para gerar MACs usando o resumo SHA-512. A chave deve exportar seu material de chave por meio Key#getEncoded() do RAW formato.

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

<Exemplo de h3>: par de chaves EC para assinatura/verificação usando ECDSA</h3> Este exemplo ilustra como importar um par de chaves EC para o Android KeyStore sob alias key2 com a chave privada autorizada a ser usada apenas para assinatura com resumos SHA-256 ou SHA-512. O uso da chave pública é irrestrito. Tanto a chave privada quanto a chave pública devem exportar seu material de chave por meio Key#getEncoded()PKCS#8 e X.509 formato, respectivamente.

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

<Exemplo h3>: par de chaves RSA para assinatura/verificação usando pkcs#1 preenchimento</h3> Este exemplo ilustra como importar um par de chaves RSA para o Android KeyStore sob alias key2 com a chave privada autorizada a ser usada apenas para assinatura usando o esquema de preenchimento de assinatura PKCS nº 1 com o resumo SHA-256 e somente se o usuário tiver sido autenticado nos últimos dez minutos. O uso da chave pública é irrestrito (consulte Problemas Conhecidos). Tanto a chave privada quanto a chave pública devem exportar seu material de chave por meio Key#getEncoded()PKCS#8 e X.509 formato, respectivamente.

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

<Exemplo h3>: par de chaves RSA para criptografia/descriptografia usando pkcs#1 preenchimento</h3> Este exemplo ilustra como importar um par de chaves RSA para o Android KeyStore sob alias key2 com a chave privada autorizada a ser usada apenas para descriptografia usando o esquema de preenchimento de criptografia PKCS#1. O uso da chave pública é irrestrito, permitindo a criptografia usando esquemas de preenchimento e resumos. Tanto a chave privada quanto a chave pública devem exportar seu material de chave por meio Key#getEncoded()PKCS#8 e X.509 formato, respectivamente.

{@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 documentação para android.security.keystore.KeyProtection.

Partes desta página são modificações baseadas no trabalho criado e compartilhado pelo Project Open Source do Open Source e usadas de acordo com os termos descritos na Creative Commons 2.5.