KeyProtection Classe

Referência

Definição

Namespace:: Android.Security.Keystore

Assembly:: Mono.Android.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Especificação de como uma chave ou par de chaves é protegido quando importado para o sistema Android Keystore.

[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

Herança: Object

Object
KeyProtection

Atributos: RegisterAttribute

Implementações: IJavaObject IJavaPeerable KeyStore.IProtectionParameter IDisposable

Comentários

Especificação de como uma chave ou par de chaves é protegido quando importado para o sistema Android Keystore. Essa classe especifica usos autorizados da chave importada, como se a autenticação do 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 de validade da chave. As autorizações de uso de chave expressas nessa classe se aplicam somente a chaves secretas e chaves privadas -- chaves públicas podem ser usadas para quaisquer operações com suporte.

Para importar uma chave ou par de chaves para o armazenamento de chaves do Android, crie uma instância dessa classe usando o Builder e passe a instância para java.security.KeyStore#setEntry(String, java.security.KeyStore.Entry, ProtectionParameter) KeyStore.setEntry com a chave ou par de chaves que está 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 Android Keystore, 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.

NOTA: O material da chave das chaves armazenadas no Android Keystore 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 (API Nível 23) faz com que as autorizações relacionadas à autenticação do usuário sejam aplicadas mesmo para chaves públicas. Para contornar esse problema, extraia o material de chave pública para usar fora do Android Keystore. Por exemplo:

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

<h3>Exemplo: 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 chave via Key#getEncoded() no 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);
            ...
            }

<h3>Exemplo: 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 SHA-512 digest. A chave deve exportar seu material chave via Key#getEncoded() no 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);
            ...
            }

<h3>Exemplo: 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 com a chave privada autorizada a ser usada apenas para assinatura com resumos key2 SHA-256 ou SHA-512. O uso da chave pública é irrestrito. Tanto a chave privada quanto a pública devem exportar seu material de chave via Key#getEncoded() in 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);
            ...
            }

<h3>Exemplo: par de chaves RSA para assinatura/verificação usando PKCS#1 padding</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#1 com 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 pública devem exportar seu material de chave via Key#getEncoded() in 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);
            ...
            }

<h3>Exemplo: par de chaves RSA para criptografia/descriptografia usando PKCS#1 padding</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 de chave pública é irrestrito, permitindo assim a criptografia usando quaisquer esquemas de preenchimento e resumos. Tanto a chave privada quanto a pública devem exportar seu material de chave via Key#getEncoded() in 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);
            ...
            }

Documentação Java para android.security.keystore.KeyProtection.

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

Propriedades

Class	Retorna a classe de tempo de execução deste `Object`. (Herdado de Object)
Handle	O identificador para a instância subjacente do Android. (Herdado de Object)
IsDigestsSpecified	Retorna `true` se o conjunto de algoritmos de resumo com o qual a chave pode ser usada tiver sido especificado.
IsInvalidatedByBiometricEnrollment	Retorna `true` se a chave for invalidada irreversivelmente quando uma nova biometria for registrada ou toda a biometria registrada for removida.
IsRandomizedEncryptionRequired	Retorna `true` se a criptografia usando essa chave deve ser suficientemente aleatória para produzir textos cifrados diferentes para o mesmo texto sem formatação sempre.
IsUnlockedDeviceRequired	Retorna `true` se a tela precisar ser desbloqueada para que essa chave seja usada para descriptografia ou assinatura.
IsUserAuthenticationRequired	Retorna `true` se a chave estiver autorizada a ser usada somente se o usuário tiver sido autenticado.
IsUserAuthenticationValidWhileOnBody	Retorna `true` se a chave será desautorizada quando o dispositivo for removido do corpo do usuário.
IsUserConfirmationRequired	Retorna `true` se a chave estiver autorizada a ser usada apenas para mensagens confirmadas pelo usuário.
IsUserPresenceRequired	Retorna `true` se a chave estiver autorizada a ser usada somente se um teste de presença do usuário tiver sido executado entre as `Signature.initSign()` chamadas e `Signature.sign()` .
JniIdentityHashCode	Especificação de como uma chave ou par de chaves é protegido quando importado para o sistema Android Keystore. (Herdado de Object)
JniPeerMembers	Especificação de como uma chave ou par de chaves é protegido quando importado para o sistema Android Keystore.
KeyValidityForConsumptionEnd	Obtém o instante de tempo após o qual a chave não é mais válida para descriptografia e verificação.
KeyValidityForOriginationEnd	Obtém o instante de tempo após o qual a chave não é mais válida para criptografia e assinatura.
KeyValidityStart	Obtém o instante de tempo antes do qual a chave ainda não é válida.
MaxUsageCount	Retorna o número máximo de vezes que a chave de uso limitado pode ser usada ou `KeyProperties#UNRESTRICTED_USAGE_COUNT` se não houver restrição sobre o número de vezes que a chave pode ser usada.
PeerReference	Especificação de como uma chave ou par de chaves é protegido quando importado para o sistema Android Keystore. (Herdado de Object)
Purposes	Obtém o conjunto de finalidades (e.
ThresholdClass	Esta API suporta a infraestrutura Mono para Android e não se destina a ser usada diretamente do seu código. (Herdado de Object)
ThresholdType	Esta API suporta a infraestrutura Mono para Android e não se destina a ser usada diretamente do seu código. (Herdado de Object)
UserAuthenticationType	Especificação de como uma chave ou par de chaves é protegido quando importado para o sistema Android Keystore.
UserAuthenticationValidityDurationSeconds	Obtém a duração do tempo (segundos) para o qual essa chave está autorizada a ser usada depois que o usuário é autenticado com êxito.

Métodos

Clone()	Cria e retorna uma cópia desse objeto. (Herdado de Object)
Dispose()	Especificação de como uma chave ou par de chaves é protegido quando importado para o sistema Android Keystore. (Herdado de Object)
Dispose(Boolean)	Especificação de como uma chave ou par de chaves é protegido quando importado para o sistema Android Keystore. (Herdado de Object)
Equals(Object)	Indica se algum outro objeto é "igual" a este. (Herdado de Object)
GetBlockModes()	Obtém o conjunto de modos de bloco (e.
GetDigests()	Obtém o conjunto de algoritmos de resumo (e.
GetEncryptionPaddings()	Obtém o conjunto de esquemas de preenchimento (e.
GetHashCode()	Retorna um valor de código hash para o objeto. (Herdado de Object)
GetSignaturePaddings()	Obtém o conjunto de esquemas de preenchimento (e.
JavaFinalize()	Chamado pelo coletor de lixo em um objeto quando a coleta de lixo determina que não há mais referências ao objeto. (Herdado de Object)
Notify()	Ativa um único thread que está aguardando no monitor deste objeto. (Herdado de Object)
NotifyAll()	Ativa todos os threads que estão aguardando no monitor deste objeto. (Herdado de Object)
SetHandle(IntPtr, JniHandleOwnership)	Define a propriedade Handle. (Herdado de Object)
ToArray<T>()	Especificação de como uma chave ou par de chaves é protegido quando importado para o sistema Android Keystore. (Herdado de Object)
ToString()	Retorna uma representação de cadeia de caracteres do objeto. (Herdado de Object)
UnregisterFromRuntime()	Especificação de como uma chave ou par de chaves é protegido quando importado para o sistema Android Keystore. (Herdado de Object)
Wait()	Faz com que o thread atual aguarde até que ele seja ativado, normalmente sendo <em notificado</em> ou <em>interrompido</em>>. (Herdado de Object)
Wait(Int64)	Faz com que o thread atual aguarde até que ele seja despertado, normalmente sendo <em>notificado</em> ou <em interrompido</em>, ou até que>uma certa quantidade de tempo real tenha decorrido. (Herdado de Object)
Wait(Int64, Int32)	Faz com que o thread atual aguarde até que ele seja despertado, normalmente sendo <em>notificado</em> ou <em interrompido</em>, ou até que>uma certa quantidade de tempo real tenha decorrido. (Herdado de Object)

Implantações explícitas de interface

IJavaPeerable.Disposed()	Especificação de como uma chave ou par de chaves é protegido quando importado para o sistema Android Keystore. (Herdado de Object)
IJavaPeerable.DisposeUnlessReferenced()	Especificação de como uma chave ou par de chaves é protegido quando importado para o sistema Android Keystore. (Herdado de Object)
IJavaPeerable.Finalized()	Especificação de como uma chave ou par de chaves é protegido quando importado para o sistema Android Keystore. (Herdado de Object)
IJavaPeerable.JniManagedPeerState	Especificação de como uma chave ou par de chaves é protegido quando importado para o sistema Android Keystore. (Herdado de Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Especificação de como uma chave ou par de chaves é protegido quando importado para o sistema Android Keystore. (Herdado de Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Especificação de como uma chave ou par de chaves é protegido quando importado para o sistema Android Keystore. (Herdado de Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	Especificação de como uma chave ou par de chaves é protegido quando importado para o sistema Android Keystore. (Herdado de Object)

Métodos de Extensão

JavaCast<TResult>(IJavaObject)	Executa uma conversão de tipo verificada em tempo de execução do Android.
JavaCast<TResult>(IJavaObject)	Especificação de como uma chave ou par de chaves é protegido quando importado para o sistema Android Keystore.
GetJniTypeName(IJavaPeerable)	Especificação de como uma chave ou par de chaves é protegido quando importado para o sistema Android Keystore.

Aplica-se a

Compartilhar via