Guía de desarrollo

Local Navigation

Firmas

Las firmas se suelen utilizar únicamente con esquemas de claves públicas y privadas. Las firmas constituyen un método para comprobar la autenticación del origen de los datos y de la identidad. Teniendo en cuenta que una entidad es la única que conoce la clave privada, ésta puede utilizarse para probar ante otros usuarios que esa entidad en exclusiva es la que ha firmado la información.

Una firma puede contener uno o más valores matemáticos, en función del algoritmo de firma que utilice, por lo que es necesario un esquema de codificación.

La RIM Cryptographic API utiliza la interfaz net.rim.device.api.crypto.SignatureSigner para todas las funciones de firma. Un firmante SignatureSigner combina el mensaje que se va a firmar y la clave privada del firmante con el fin de obtener los valores matemáticos que constituirán la firma. A continuación, un codificador SignatureEncoder codifica estos valores matemáticos en una matriz de bytes para la transmisión o el almacenamiento.

Firmantes de RSA

La firma RSA utiliza las clases PKCS1SignatureSigner, PSSSignatureSigner o X931SignatureSigner. Para las firmas RSA, los mensajes debe codificarlos un formateador. Los formateadores se utilizan de forma similar a las clases que implementan la interfaz SignatureSigner.

Ejemplo de código

El siguiente ejemplo de código crea el mensaje que se va a firmar. Crea el par de claves de RSA, el compendio y el valor de sal. (El valor de sal está formado por datos aleatorios que se adjuntan a la clave para que ésta sea más compleja de descifrar.) El ejemplo de código crea un firmante RSASignatureSigner y pasa un algoritmo de compendio y un formateador de firma PSS. El ejemplo podría pasar el firmante a un flujo, pero en lugar de ello, utiliza el firmante directamente. Por último, codifica la firma mediante X.509.

// Create the message to be signed.
String message = "Hello World.";
// Create the necessary RSA key pair for signing and verifying.
RSACryptoSystem cryptoSystem = new RSACryptoSystem();
RSAKeyPair keyPair = new RSAKeyPair( cryptoSystem );
// Create the digest and the salt value.
SHA1Digest digest = new SHA1Digest();
byte[] salt = RandomSource.getBytes( digest.getDigestLength() );
// Create the RSASignatureSigner passing in a digest algorithm
// and PSS signature formatter.
PSSSignatureSigner signer =
             new PSSSignatureSigner( keyPair.getRSAPrivateKey(), digest, salt );
// For this example, simply use the signature signer directly,
// even though you could pass it into a stream as before.
signer.update( message.getBytes() );
// Encode the signature using X509.
EncodedSignature encSignature = SignatureEncoder.encode( signer, "X509" );

El ejemplo siguiente muestra cómo decodificar y comprobar la firma (asumiendo que existen tanto la firma codificada como el par de claves RSA). Comienza decodificando la firma codificada. Proporciona al verificador la cadena del mensaje. Comprueba que la firma es correcta y, a continuación, la imprime.

// Decode the encoded signature.
DecodedSignature decodedSignature = SignatureDecoder.decode(
encSignature.getEncodedSignature(), "X509" );
SignatureVerifier verifier = decodedSignature.getVerifier(
                                  keyPair.getPublicKey() );
// Give the verifier the message string.
verifier.update( message.getBytes() );
// Check that the signature verifies, and then print it.
if( verifier.verify() == true ) {
   System.out.println( "Signature verifies." );
}
else {
   System.out.println( "Signature does not verify." );
}
Tema siguiente: Implementar firmas

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