KeyProtection Classe

Riferimento

Definizione

Spazio dei nomi:: Android.Security.Keystore

Assembly:: Mono.Android.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Specifica del modo in cui una coppia di chiavi o chiavi viene protetta quando viene importata nel sistema dell'archivio chiavi Android.

[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

Ereditarietà: Object

Object
KeyProtection

Attributi: RegisterAttribute

Implementazioni: IJavaObject IJavaPeerable KeyStore.IProtectionParameter IDisposable

Commenti

Specifica del modo in cui una coppia di chiavi o chiavi viene protetta quando viene importata nel sistema dell'archivio chiavi Android. Questa classe specifica gli usi autorizzati della chiave importata, ad esempio se è necessaria l'autenticazione utente per l'uso della chiave, le operazioni per cui la chiave è autorizzata (ad esempio, la decrittografia, ma non la firma) con i parametri (ad esempio, solo con uno schema di riempimento o digest specifico) e le date di inizio e fine della validità della chiave. Le autorizzazioni di utilizzo delle chiavi espresse in questa classe si applicano solo alle chiavi segrete e alle chiavi private. Le chiavi pubbliche possono essere usate per qualsiasi operazione supportata.

Per importare una coppia di chiavi o chiavi nell'archivio chiavi Android, creare un'istanza di questa classe usando Builder e passare l'istanza di java.security.KeyStore#setEntry(String, java.security.KeyStore.Entry, ProtectionParameter) KeyStore.setEntry con la chiave o la coppia di chiavi da importare.

Per ottenere la chiave privata/segreta/simmetrica dall'archivio chiavi Android, usare java.security.KeyStore#getKey(String, char[]) KeyStore.getKey(String, null) o java.security.KeyStore#getEntry(String, java.security.KeyStore.ProtectionParameter) KeyStore.getEntry(String, null). Per ottenere la chiave pubblica dall'archivio chiavi Android, usare java.security.KeyStore#getCertificate(String) e quindi Certificate#getPublicKey().

Per ottenere parametri pubblici specifici dell'algoritmo delle coppie di chiavi archiviate nell'archivio chiavi Android, le relative chiavi private implementano java.security.interfaces.ECKey o java.security.interfaces.RSAKey interfacce, mentre le relative chiavi pubbliche implementano java.security.interfaces.ECPublicKey o java.security.interfaces.RSAPublicKey interfacce.

NOTA: il materiale della chiave delle chiavi archiviato nell'archivio chiavi Android non è accessibile.

Le istanze di questa classe non sono modificabili.

<h3>Problemi< noti/h3> Un bug noto in Android 6.0 (livello API 23) causa l'applicazione delle autorizzazioni correlate all'autenticazione utente anche per le chiavi pubbliche. Per risolvere questo problema, estrarre il materiale della chiave pubblica da usare all'esterno dell'archivio chiavi Android. Ad esempio:

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

<Esempio h3>: chiave AES per la crittografia/decrittografia in modalità< GCM/h3> Questo esempio illustra come importare una chiave AES nell'archivio chiavi Android con alias key1 autorizzato a essere usato solo per la crittografia/decrittografia in modalità GCM senza riempimento. La chiave deve esportare il materiale della chiave tramite Key#getEncoded() in 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>Esempio: chiave HMAC per la generazione di MAC tramite SHA-512</h3> Questo esempio illustra come importare una chiave HMAC nell'archivio chiavi Android con alias key1 autorizzato a essere usato solo per la generazione di MAC usando il digest SHA-512. La chiave deve esportare il materiale della chiave tramite Key#getEncoded() in 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);
            ...
            }

<Esempio h3>: coppia di chiavi EC per la firma/verifica tramite ECDSA</h3> Questo esempio illustra come importare una coppia di chiavi EC nell'archivio chiavi Android con alias key2 con la chiave privata autorizzata per essere usata solo per la firma con digest SHA-256 o SHA-512. L'uso della chiave pubblica non è limitato. Sia la chiave privata che la chiave pubblica devono esportare il materiale della chiave rispettivamente tramite Key#getEncoded() in PKCS#8 e X.509 formato.

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

<Esempio h3>: coppia di chiavi RSA per la firma/verifica tramite padding< PKCS#1/h3> Questo esempio illustra come importare una coppia di chiavi RSA nell'archivio chiavi Android con alias key2 con la chiave privata autorizzata a essere usata solo per la firma usando lo schema di riempimento della firma PKCS#1 con digest SHA-256 e solo se l'utente è stato autenticato negli ultimi dieci minuti. L'uso della chiave pubblica non è limitato (vedere Problemi noti). Sia la chiave privata che la chiave pubblica devono esportare il materiale della chiave rispettivamente tramite Key#getEncoded() in PKCS#8 e X.509 formato.

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

<Esempio h3>: coppia di chiavi RSA per la crittografia/decrittografia tramite padding</h3> PKCS#1 Questo esempio illustra come importare una coppia di chiavi RSA nell'archivio chiavi Android con alias key2 con la chiave privata autorizzata a essere usata solo per la decrittografia usando lo schema di riempimento della crittografia PKCS#1. L'uso della chiave pubblica non è limitato, consentendo così la crittografia usando eventuali schemi di riempimento e digest. Sia la chiave privata che la chiave pubblica devono esportare il materiale della chiave rispettivamente tramite Key#getEncoded() in PKCS#8 e X.509 formato.

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

Documentazione java per android.security.keystore.KeyProtection.

Le parti di questa pagina sono modifiche basate sul lavoro creato e condiviso dal progetto Open Source Android e usato in base ai termini descritti nella licenza Creative Commons 2.5 Attribuzione.

Proprietà

Class	Restituisce la classe di runtime di questo `Object`oggetto . (Ereditato da Object)
Handle	Handle per l'istanza di Android sottostante. (Ereditato da Object)
IsDigestsSpecified	Restituisce `true` se è stato specificato il set di algoritmi digest con cui è possibile utilizzare la chiave.
IsInvalidatedByBiometricEnrollment	Restituisce `true` se la chiave viene invalidata in modo irreversibile quando viene registrata una nuova biometria o viene rimossa tutta la biometria registrata.
IsRandomizedEncryptionRequired	Restituisce `true` se la crittografia che utilizza questa chiave deve essere sufficientemente casuale per produrre testo crittografato diverso per lo stesso testo non crittografato ogni volta.
IsUnlockedDeviceRequired	Restituisce `true` se la schermata deve essere sbloccata per utilizzare questa chiave per la decrittografia o la firma.
IsUserAuthenticationRequired	Restituisce `true` se la chiave è autorizzata a essere utilizzata solo se l'utente è stato autenticato.
IsUserAuthenticationValidWhileOnBody	Restituisce `true` se la chiave verrà annullata quando il dispositivo viene rimosso dal corpo dell'utente.
IsUserConfirmationRequired	Restituisce `true` se la chiave è autorizzata a essere utilizzata solo per i messaggi confermati dall'utente.
IsUserPresenceRequired	Restituisce `true` se la chiave è autorizzata a essere utilizzata solo se è stato eseguito un test di presenza dell'utente tra le `Signature.initSign()` chiamate e `Signature.sign()` .
JniIdentityHashCode	Specifica del modo in cui una coppia di chiavi o chiavi viene protetta quando viene importata nel sistema dell'archivio chiavi Android. (Ereditato da Object)
JniPeerMembers	Specifica del modo in cui una coppia di chiavi o chiavi viene protetta quando viene importata nel sistema dell'archivio chiavi Android.
KeyValidityForConsumptionEnd	Ottiene l'istante di tempo dopo il quale la chiave non è valida per la decrittografia e la verifica.
KeyValidityForOriginationEnd	Ottiene l'istante di tempo dopo il quale la chiave non è valida per la crittografia e la firma.
KeyValidityStart	Ottiene l'istante temporale prima del quale la chiave non è ancora valida.
MaxUsageCount	Restituisce il numero massimo di volte in cui è consentita l'utilizzo della chiave di utilizzo limitato o `KeyProperties#UNRESTRICTED_USAGE_COUNT` se non è prevista alcuna restrizione sul numero di volte in cui è possibile usare la chiave.
PeerReference	Specifica del modo in cui una coppia di chiavi o chiavi viene protetta quando viene importata nel sistema dell'archivio chiavi Android. (Ereditato da Object)
Purposes	Ottiene il set di scopi (e.
ThresholdClass	Questa API supporta l'infrastruttura Mono per Android e non deve essere usata direttamente dal codice. (Ereditato da Object)
ThresholdType	Questa API supporta l'infrastruttura Mono per Android e non deve essere usata direttamente dal codice. (Ereditato da Object)
UserAuthenticationType	Specifica del modo in cui una coppia di chiavi o chiavi viene protetta quando viene importata nel sistema dell'archivio chiavi Android.
UserAuthenticationValidityDurationSeconds	Ottiene l'intervallo di tempo (secondi) per il quale questa chiave è autorizzata a essere utilizzata dopo che l'utente è stato autenticato correttamente.

Metodi

Clone()	Crea e restituisce una copia di questo oggetto. (Ereditato da Object)
Dispose()	Specifica del modo in cui una coppia di chiavi o chiavi viene protetta quando viene importata nel sistema dell'archivio chiavi Android. (Ereditato da Object)
Dispose(Boolean)	Specifica del modo in cui una coppia di chiavi o chiavi viene protetta quando viene importata nel sistema dell'archivio chiavi Android. (Ereditato da Object)
Equals(Object)	Indica se un altro oggetto è "uguale a" questo. (Ereditato da Object)
GetBlockModes()	Ottiene il set di modalità di blocco (e.
GetDigests()	Ottiene il set di algoritmi digest (e.
GetEncryptionPaddings()	Ottiene il set di schemi di spaziatura interna (e.
GetHashCode()	Restituisce un valore del codice hash per l'oggetto. (Ereditato da Object)
GetSignaturePaddings()	Ottiene il set di schemi di spaziatura interna (e.
JavaFinalize()	Chiamato dal Garbage Collector su un oggetto quando Garbage Collection determina che non sono presenti altri riferimenti all'oggetto . (Ereditato da Object)
Notify()	Riattiva un singolo thread in attesa del monitor dell'oggetto. (Ereditato da Object)
NotifyAll()	Riattiva tutti i thread in attesa del monitor dell'oggetto. (Ereditato da Object)
SetHandle(IntPtr, JniHandleOwnership)	Imposta la proprietà Handle. (Ereditato da Object)
ToArray<T>()	Specifica del modo in cui una coppia di chiavi o chiavi viene protetta quando viene importata nel sistema dell'archivio chiavi Android. (Ereditato da Object)
ToString()	Restituisce una rappresentazione di stringa dell'oggetto. (Ereditato da Object)
UnregisterFromRuntime()	Specifica del modo in cui una coppia di chiavi o chiavi viene protetta quando viene importata nel sistema dell'archivio chiavi Android. (Ereditato da Object)
Wait()	Fa sì che il thread corrente attenda finché non viene risvegliato, in genere ricevendo <>una notifica</em> o <em>interrotto</em>. (Ereditato da Object)
Wait(Int64, Int32)	Fa sì che il thread corrente attenda finché non viene risvegliato, in genere ricevendo>< una notifica</em> o <em>interrotto</em> o fino a quando non è trascorsa una determinata quantità di tempo reale. (Ereditato da Object)
Wait(Int64)	Fa sì che il thread corrente attenda finché non viene risvegliato, in genere ricevendo>< una notifica</em> o <em>interrotto</em> o fino a quando non è trascorsa una determinata quantità di tempo reale. (Ereditato da Object)

Implementazioni dell'interfaccia esplicita

IJavaPeerable.Disposed()	Specifica del modo in cui una coppia di chiavi o chiavi viene protetta quando viene importata nel sistema dell'archivio chiavi Android. (Ereditato da Object)
IJavaPeerable.DisposeUnlessReferenced()	Specifica del modo in cui una coppia di chiavi o chiavi viene protetta quando viene importata nel sistema dell'archivio chiavi Android. (Ereditato da Object)
IJavaPeerable.Finalized()	Specifica del modo in cui una coppia di chiavi o chiavi viene protetta quando viene importata nel sistema dell'archivio chiavi Android. (Ereditato da Object)
IJavaPeerable.JniManagedPeerState	Specifica del modo in cui una coppia di chiavi o chiavi viene protetta quando viene importata nel sistema dell'archivio chiavi Android. (Ereditato da Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Specifica del modo in cui una coppia di chiavi o chiavi viene protetta quando viene importata nel sistema dell'archivio chiavi Android. (Ereditato da Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Specifica del modo in cui una coppia di chiavi o chiavi viene protetta quando viene importata nel sistema dell'archivio chiavi Android. (Ereditato da Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	Specifica del modo in cui una coppia di chiavi o chiavi viene protetta quando viene importata nel sistema dell'archivio chiavi Android. (Ereditato da Object)

Metodi di estensione

JavaCast<TResult>(IJavaObject)	Esegue una conversione del tipo di tipo controllato dal runtime Android.
JavaCast<TResult>(IJavaObject)	Specifica del modo in cui una coppia di chiavi o chiavi viene protetta quando viene importata nel sistema dell'archivio chiavi Android.
GetJniTypeName(IJavaPeerable)	Specifica del modo in cui una coppia di chiavi o chiavi viene protetta quando viene importata nel sistema dell'archivio chiavi Android.

Si applica a

Condividi tramite