Guía de desarrollo

Local Navigation

Acuerdo de claves

El acuerdo de claves permite que dos partes independientes establezcan un canal altamente seguro sobre una red no segura. Los protocolos de acuerdo de claves utilizan generalmente las claves públicas y privadas de ambas partes, junto con los parámetros específicos de los algoritmos, para crear datos secretos. Los datos secretos los crean las dos partes de forma independiente a través del uso de información compartida públicamente y, a continuación, se utilizan como clave de sesión para una comunicación altamente segura. La clave secreta se crea a partir de datos públicos, pero no se envía a través de la red.

La RIM Cryptographic API admite los siguientes esquemas de acuerdos de claves:

El acuerdo de claves ECDH es un esquema de acuerdo de claves común. Requiere el uso de una clave pública y una clave privada. Cada parte de una comunicación altamente segura utiliza su propia clave privada y la clave pública de la otra parte. Cuando cada parte utiliza el algoritmo del acuerdo de claves, se crean los mismos datos secretos.

Ejemplo de código: implementación del acuerdo de claves ECDH

El ejemplo de código siguiente ilustra el acuerdo de claves ECDH. Asume que sendPublicKey() y receivePublicKey() existen y activa el intercambio de claves entre los dos clientes. Cuando uno de los clientes envía un mensaje, el otro lo recibe. Las operaciones se realizan de forma local, y los detalles del intercambio de claves no se muestran. En su aplicación, las claves públicas se intercambian a través de la red, y cada parte debe proteger su clave privada. Los secretos compartidos idénticos los crea cada cliente (llamados aquí cliente1Secreto y cliente2Secreto).

Este ejemplo genera el secreto local en el cliente local. Crea un secreto compartido local que es idéntico al secreto del cliente local. Genera la clave secreta. Crea un secreto compartido local que es idéntico al secreto que se acaba de generar.

//Generate the local secret on the local client.
public void generateLocalSecret() {
    // Create an EC crypto system for key creation
    ECCryptoSystem cryptoSystem = new ECCryptoSystem();
    // Create the first party's public and private keys
    ECKeyPair client1KeyPair = new ECKeyPair( cryptoSystem );
// Create a local shared secret that is identical to the local client's secret.
   // Send the local client public key (client1) to the remote user (client2).
   sendPublicKey( client1KeyPair.getECPublicKey() );
   ECPublicKey client2PublicKey = receivePublicKey();
   // Generate the shared secret for this client.
   byte[] client1Secret = ECDHKeyAgreement.generateSharedSecret(
                          client1KeyPair.getECPrivateKey(),
                          client2PublicKey );
   // Create a shared secret key based on the shared secret
   DESKey secretKey = new DESKey( client1Secret );
   }
// Generate the secret key, a shared key for communication between clients.
public void generateRemoteSecret() {
   // Create an EC crypto system for key creation
   ECCryptoSystem cryptoSystem = new ECCryptoSystem();
   // Create the remote public and private keys
   ECKeyPair client2KeyPair = new ECKeyPair( cryptoSystem );
// Create a local shared secret. It is identical to the secret just generated.
   // Send and receive the keys.
   sendPublicKey( client2KeyPair.getECPublicKey() );
   ECPublicKey client1PublicKey = receivePublicKey();
   // Generate the secret data based on the client1 public
   // key and client2 private key.
   byte[] client2Secret = ECDHKeyAgreement.generateSharedSecret(
            client2KeyPair.getECPrivateKey(),
            client1PublicKey );
   // Create a shared secret key based on this secret data.
   DESKey secretKey = new DESKey( client2Secret );
}

Ejemplo de código: implementación del acuerdo de claves ECMQV

El ejemplo de código siguiente ilustra el acuerdo de claves ECMQV. El código es similar al del ejemplo del acuerdo de claves ECDH, pero este esquema utiliza un conjunto adicional de claves efímeras (temporales) para una mayor seguridad. Las claves efímeras son claves que se almacenan y utilizan sólo durante un tiempo limitado. De este modo, si la seguridad de una clave está en peligro, se crea una clave nueva periódicamente y la clave que está en peligro deja de utilizarse. El ejemplo asume que se invocan sendPublicKey() y receivePublicKey(), y activa el intercambio de claves entre los dos clientes. Cuando uno de los clientes envía algo, el otro lo recibe.

Este ejemplo utiliza cinco claves: la clave efímera pública local, la clave efímera privada local, la clave estática privada local, la clave estática pública remota y la clave efímera pública remota.

// Create a static (regular) key pair and an ephemeral key pair.
public void generateLocalSecret() {
   // Create an EC crypto system for key creation.
   ECCryptoSystem cryptoSystem = new ECCryptoSystem();
   // Create the first client's static and ephemeral key pairs.
   ECKeyPair client1StaticPair = new ECKeyPair( cryptoSystem );
   ECKeyPair client1EphemeralPair = new ECKeyPair( cryptoSystem );
// Send and receive the newly created public and public ephemeral key pair 
// using a predetermined key exchange protocol.
   // Send and receive public keys.
   sendPublicKey( client1StaticPair.getECPublicKey() );
   sendPublicKey( client1EphemeralPair.getECPublicKey() );
   ECPublicKey client2StaticKey = receivePublicKey();
   ECPublicKey client2EphemeralKey = receivePublicKey();
   // Generate the shared secret for this client. This
   // is identical to that generated by client2.
   byte[] client1Secret = ECMQVKeyAgreement.generateSharedSecret(
                 client1StaticPair.getECPrivateKey(),
                 client1EphemeralPair,
                 client2StaticKey,
                 client2EphemeralKey );
   // Create a shared secret key based on this secret data.
   DESKey secretKey = new DESKey( client1Secret );
   }
// Create a shared secret and use it to create a shared secret key.
public void generateRemoteSecret() {
   // Create an EC crypto system for key creation.
   ECCryptoSystem cryptoSystem = new ECCryptoSystem();
   // Create the second client's static and ephemeral key pairs.
   ECKeyPair client2StaticPair =
   new ECKeyPair( cryptoSystem );
   ECKeyPair client2EphemeralPair = new ECKeyPair( cryptoSystem );
   // Send and receive the keys.
   sendPublicKey( client2StaticPair.getECPublicKey() );
   sendPublicKey( client2EphemeralPair.getECPublicKey() );
   ECPublicKey client1StaticKey = receivePublicKey();
   ECPublicKey client1EphemeralKey = receivePublicKey();
   // Generate the shared secret for this client.
   byte[] client2Secret = ECMQVKeyAgreement.generateSharedSecret(
   client2StaticPair.getECPrivateKey(),
   client2EphemeralPair,
   client1StaticKey,
   client1EphemeralKey ); 
   // Create a shared secret key based on this secret data.
   DESKey secretKey = new DESKey( client2Secret );
}
Tema anterior: Almacén de claves

¿Le ha resultado útil esta información? Envíenos sus comentarios.