KeyGenParameterSpec Clase

Definición

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

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

Herencia

Object

Object

KeyGenParameterSpec

Atributos

RegisterAttribute

Implementaciones

IJavaObject IJavaPeerable IAlgorithmParameterSpec IDisposable

Comentarios

AlgorithmParameterSpec para inicializar o KeyPairGenerator un KeyGenerator del sistema de almacén de claves de Android. La especificación determina los usos autorizados de la clave, como si se requiere la autenticación de usuario para usar la clave, qué operaciones están autorizadas (por ejemplo, firma, pero no descifrado), con qué parámetros (por ejemplo, solo con un esquema de relleno o resumen determinados) y las fechas de inicio y finalización de la clave. Las autorizaciones de uso de claves expresadas en la especificación solo se aplican a claves secretas y claves privadas: las claves públicas se pueden usar para las operaciones admitidas.

Para generar un par de claves asimétricas o una clave simétrica, cree una instancia de esta clase mediante Builder, inicialice o KeyPairGenerator un KeyGenerator del tipo de clave deseado (por ejemplo, EC o AES - vea KeyProperties.KEY_ALGORITHM constantes) del AndroidKeyStore proveedor con la KeyGenParameterSpec instancia y, a continuación, genere un par de claves o clave mediante KeyGenerator#generateKey() o KeyPairGenerator#generateKeyPair().

El generador devolverá el par de claves generado y también se almacenará en el almacén de claves de Android en el alias especificado en esta especificación. Para obtener el secreto o la clave privada del almacén de claves de Android, use java.security.KeyStore#getKey(String, char[]) KeyStore.getKey(String, null) o java.security.KeyStore#getEntry(String, java.security.KeyStore.ProtectionParameter) KeyStore.getEntry(String, null). Para obtener la clave pública del almacén de claves de Android, use java.security.KeyStore#getCertificate(String) y, a continuación, Certificate#getPublicKey().

Para ayudar a obtener parámetros públicos específicos del algoritmo de pares de claves almacenados en el almacén de claves de Android, las claves privadas generadas implementan java.security.interfaces.ECKey o java.security.interfaces.RSAKey interfaces, mientras que las claves públicas implementan java.security.interfaces.ECPublicKey o java.security.interfaces.RSAPublicKey interfaces.

En el caso de los pares de claves asimétricas, también se generará y almacenará un certificado X.509 en el almacén de claves de Android. Esto se debe a que la java.security.KeyStore abstracción no admite el almacenamiento de pares de claves sin un certificado. El asunto, el número de serie y las fechas de validez del certificado se pueden personalizar en esta especificación. El certificado se puede reemplazar posteriormente por un certificado firmado por una entidad de certificación (CA).

NOTA: Si no se solicita la atestación mediante Builder#setAttestationChallenge(byte[]), el certificado generado puede ser autofirmado. Si una clave privada no está autorizada para firmar el certificado, el certificado se creará con una firma no válida que no comprobará. Este certificado sigue siendo útil porque proporciona acceso a la clave pública. Para generar una firma válida para el certificado, la clave debe estar autorizada para todas las siguientes operaciones: <ul><li>KeyProperties#PURPOSE_SIGN,</li li>><sin necesidad de que el usuario se autentique (consulte Builder#setUserAuthenticationRequired(boolean)),</li><>li signing/origination en este momento en este momento (vea Builder#setKeyValidityStart(Date) y Builder#setKeyValidityForOriginationEnd(Date)),</li<>li>adecuado digest,</li<>>(rsa keys only) padding scheme .<KeyProperties#SIGNATURE_PADDING_RSA_PKCS1/li></ul>

NOTA: No se puede acceder al material clave de las claves simétricas y privadas generadas. Se puede acceder al material clave de las claves públicas.

Las instancias de esta clase son inmutables.

<h3>Problemas conocidos</h3> Un error conocido en Android 6.0 (nivel de API 23) hace que se apliquen autorizaciones relacionadas con la autenticación de usuarios incluso para las claves públicas. Para solucionar este problema, extraiga el material de clave pública que se va a usar fuera del almacén de claves de Android. Por ejemplo:

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

<h3>Ejemplo: par de claves EC de NIST P-256 para la firma o comprobación mediante ECDSA</h3> En este ejemplo se muestra cómo generar una clave NIST P-256 (también conocida como secp256r1 aka prime256v1) par de claves EC en el sistema Android KeyStore en el alias key1 en el que la clave privada está autorizada para usarse solo para firmar mediante SHA-256, Resumen SHA-384 o SHA-512 y solo si el usuario se ha autenticado en los últimos cinco minutos. El uso de la clave pública no está restringido (consulte Problemas conocidos).

{@code
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(
                    KeyProperties.KEY_ALGORITHM_EC, "AndroidKeyStore");
            keyPairGenerator.initialize(
                    new KeyGenParameterSpec.Builder(
                            "key1",
                            KeyProperties.PURPOSE_SIGN)
                            .setAlgorithmParameterSpec(new ECGenParameterSpec("secp256r1"))
                            .setDigests(KeyProperties.DIGEST_SHA256,
                                    KeyProperties.DIGEST_SHA384,
                                    KeyProperties.DIGEST_SHA512)
                            // Only permit the private key to be used if the user authenticated
                            // within the last five minutes.
                            .setUserAuthenticationRequired(true)
                            .setUserAuthenticationValidityDurationSeconds(5 * 60)
                            .build());
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            Signature signature = Signature.getInstance("SHA256withECDSA");
            signature.initSign(keyPair.getPrivate());
            ...

            // The key pair can also be obtained from the Android Keystore any time as follows:
            KeyStore keyStore = KeyStore.getInstance("AndroidKeyStore");
            keyStore.load(null);
            PrivateKey privateKey = (PrivateKey) keyStore.getKey("key1", null);
            PublicKey publicKey = keyStore.getCertificate("key1").getPublicKey();
            }

<h3>Ejemplo: par de claves RSA para la firma y comprobación mediante RSA-PSS</h3> En este ejemplo se muestra cómo generar un par de claves RSA en el sistema Android KeyStore bajo alias key1 autorizado para usarse solo para firmar mediante el esquema de relleno de firmas de RSA-PSS con resúmenes SHA-256 o SHA-512. El uso de la clave pública no está restringido.

{@code
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(
                    KeyProperties.KEY_ALGORITHM_RSA, "AndroidKeyStore");
            keyPairGenerator.initialize(
                    new KeyGenParameterSpec.Builder(
                            "key1",
                            KeyProperties.PURPOSE_SIGN)
                            .setDigests(KeyProperties.DIGEST_SHA256, KeyProperties.DIGEST_SHA512)
                            .setSignaturePaddings(KeyProperties.SIGNATURE_PADDING_RSA_PSS)
                            .build());
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            Signature signature = Signature.getInstance("SHA256withRSA/PSS");
            signature.initSign(keyPair.getPrivate());
            ...

            // The key pair can also be obtained from the Android Keystore any time as follows:
            KeyStore keyStore = KeyStore.getInstance("AndroidKeyStore");
            keyStore.load(null);
            PrivateKey privateKey = (PrivateKey) keyStore.getKey("key1", null);
            PublicKey publicKey = keyStore.getCertificate("key1").getPublicKey();
            }

<Ejemplo de h3>: par de claves RSA para cifrado y descifrado mediante RSA OAEP</h3> Este ejemplo muestra cómo generar un par de claves RSA en el sistema Android KeyStore en alias key1 donde la clave privada está autorizada para usarse solo para el descifrado mediante el esquema de relleno de cifrado OAEP RSA con resúmenes SHA-256 o SHA-512. El uso de la clave pública no está restringido.

{@code
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(
                    KeyProperties.KEY_ALGORITHM_RSA, "AndroidKeyStore");
            keyPairGenerator.initialize(
                    new KeyGenParameterSpec.Builder(
                            "key1",
                            KeyProperties.PURPOSE_DECRYPT)
                            .setDigests(KeyProperties.DIGEST_SHA256, KeyProperties.DIGEST_SHA512)
                            .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_RSA_OAEP)
                            .build());
            KeyPair keyPair = keyPairGenerator.generateKeyPair();
            Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");
            cipher.init(Cipher.DECRYPT_MODE, keyPair.getPrivate());
            ...

            // The key pair can also be obtained from the Android Keystore any time as follows:
            KeyStore keyStore = KeyStore.getInstance("AndroidKeyStore");
            keyStore.load(null);
            PrivateKey privateKey = (PrivateKey) keyStore.getKey("key1", null);
            PublicKey publicKey = keyStore.getCertificate("key1").getPublicKey();
            }

<Ejemplo h3>: clave AES para cifrado y descifrado en modo< GCM/h3> En el ejemplo siguiente se muestra cómo generar una clave AES en el sistema Android KeyStore bajo alias key2 autorizado para usarse solo para el cifrado o descifrado en modo GCM sin relleno.

{@code
            KeyGenerator keyGenerator = KeyGenerator.getInstance(
                    KeyProperties.KEY_ALGORITHM_AES, "AndroidKeyStore");
            keyGenerator.init(
                    new KeyGenParameterSpec.Builder("key2",
                            KeyProperties.PURPOSE_ENCRYPT | KeyProperties.PURPOSE_DECRYPT)
                            .setBlockModes(KeyProperties.BLOCK_MODE_GCM)
                            .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
                            .build());
            SecretKey key = keyGenerator.generateKey();

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

            // The key can also be obtained from the Android Keystore any time as follows:
            KeyStore keyStore = KeyStore.getInstance("AndroidKeyStore");
            keyStore.load(null);
            key = (SecretKey) keyStore.getKey("key2", null);
            }

<h3>Ejemplo: clave HMAC para generar un MAC mediante SHA-256</h3> En este ejemplo se muestra cómo generar una clave HMAC en el sistema Android KeyStore bajo alias key2 autorizado para usarse solo para generar un HMAC mediante SHA-256.

{@code
            KeyGenerator keyGenerator = KeyGenerator.getInstance(
                    KeyProperties.KEY_ALGORITHM_HMAC_SHA256, "AndroidKeyStore");
            keyGenerator.init(
                    new KeyGenParameterSpec.Builder("key2", KeyProperties.PURPOSE_SIGN).build());
            SecretKey key = keyGenerator.generateKey();
            Mac mac = Mac.getInstance("HmacSHA256");
            mac.init(key);
            ...

            // The key can also be obtained from the Android Keystore any time as follows:
            KeyStore keyStore = KeyStore.getInstance("AndroidKeyStore");
            keyStore.load(null);
            key = (SecretKey) keyStore.getKey("key2", null);
            }

<h3 id="example:ecdh">Example: EC key for ECDH key agreement</h3> This examples how to generate an eliptic curve key pair, used to establish a shared secret with another party using ECDH key agreement.

{@code
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(
                    KeyProperties.KEY_ALGORITHM_EC, "AndroidKeyStore");
            keyPairGenerator.initialize(
                    new KeyGenParameterSpec.Builder(
                        "eckeypair",
                        KeyProperties.PURPOSE_AGREE_KEY)
                        .setAlgorithmParameterSpec(new ECGenParameterSpec("secp256r1"))
                        .build());
            KeyPair myKeyPair = keyPairGenerator.generateKeyPair();

            // Exchange public keys with server. A new ephemeral key MUST be used for every message.
            PublicKey serverEphemeralPublicKey; // Ephemeral key received from server.

            // Create a shared secret based on our private key and the other party's public key.
            KeyAgreement keyAgreement = KeyAgreement.getInstance("ECDH", "AndroidKeyStore");
            keyAgreement.init(myKeyPair.getPrivate());
            keyAgreement.doPhase(serverEphemeralPublicKey, true);
            byte[] sharedSecret = keyAgreement.generateSecret();

            // sharedSecret cannot safely be used as a key yet. We must run it through a key derivation
            // function with some other data: "salt" and "info". Salt is an optional random value,
            // omitted in this example. It's good practice to include both public keys and any other
            // key negotiation data in info. Here we use the public keys and a label that indicates
            // messages encrypted with this key are coming from the server.
            byte[] salt = {};
            ByteArrayOutputStream info = new ByteArrayOutputStream();
            info.write("ECDH secp256r1 AES-256-GCM-SIV\0".getBytes(StandardCharsets.UTF_8));
            info.write(myKeyPair.getPublic().getEncoded());
            info.write(serverEphemeralPublicKey.getEncoded());

            // This example uses the Tink library and the HKDF key derivation function.
            AesGcmSiv key = new AesGcmSiv(Hkdf.computeHkdf(
                    "HMACSHA256", sharedSecret, salt, info.toByteArray(), 32));
            byte[] associatedData = {};
            return key.decrypt(ciphertext, associatedData);
            }

Java documentación para android.security.keystore.KeyGenParameterSpec.

Las partes de esta página son modificaciones basadas en el trabajo creado y compartido por el Android y se usan según los términos descritos en creative Creative Commons 2.5 Attribution License.