Seguridad en la Plataforma Java 2 JDK 1.2

Esta lecci�n nos muestra los pasos necesarios para usar el API de Seguridad del JDK para generar una firma digital para datos y para verificar que una firma es aut�ntica. Esta lecci�n est� indicada para desarrolladores que deseen incorporar funcionalidades de seguridad en sus programas, incluyendo servicios de criptograf�a.

Esta lecci�n demuestra el uso del API de Seguridad del JDK con respecto a la firma de documentos. Muestra que un programa, ejecutado por un persona que tiene el documento original, podr�a generar claves, generar una firma digital para el documento usando la clave privada, y exportar la clave p�blica y la firma a ficheros.

Luego muestra un ejemplo de otro programa, ejecutado por el receptor del documento, la firma y la clave p�blica, Muestra c�mo el programa podr�a importar la clave p�blica y verificar la autenticidad de la firma. Esta lecci�n tambi�n explica y demuestra las posibles alternativas y m�todos para suministrar e importar claves, incluidas en certificados.

Para m�s informaci�n sobre los conceptos y terminolog�a (firmas digitales, certificados, keystores, etc.) puedes ver la lecci�n API y Herramientas usadas para C�digo Seguro e Intercambio de Ficheros.

En esta lecci�n crearemos dos aplicaciones b�sicas, una para generar firmas digitales y otra para su verificaci�n. Esto va seguido de un explicaci�n y demostraci�n de posibles mejoras.

.�Generar una Firma Digital

El programa GenSig que estamos a punto de crear usar� el API de Seguridad del JDK para generar claves y una firma digital para datos usando una clave privada y para exportar la clave p�blica y la firma a ficheros. La aplicaci�n obtiene el nombre del fichero de datos desde la l�nea de comandos.

Los siguientes pasos crean el programa de ejemplo GenSig.

.�Preparar la Estructura Inicial del Programa

Aqu� est� la estructura b�sica del programa GenSig. Lo debemos situar en un fichero llamado GenSig.java.

import java.io.*;
import java.security.*;

class GenSig {

    public static void main(String[] args) {

        /* Generate a DSA signature */

        if (args.length != 1) {
            System.out.println("Usage: GenSig nameOfFileToSign");
            }
        else try {

        // the rest of the code goes here

        } catch (Exception e) {
            System.err.println("Caught exception " + e.toString());
        }
    }

}

Notas:

  • Los m�todos para firmar datos est�n en el paquete java.security, por eso el programa importa todo el paquete. El programa tambi�n importa el paquete java.io, que contiene los m�todos necesarios para la entrada del fichero de datos a firmar.
  • S�lo se espera un argumento, especificando el fichero de datos a firmar.
  • El c�digo de los pasos posteriores ir� entre los bloques try y catch.

.�Generar las Claves P�blica y Privada

Para poder crear una firma digital, necesitamos una clave privada. (Su correspondiente clave p�blica ser� necesaria para verificar la autenticidad de la firma).

En algunos casos la pareja de claves (privada y p�blica) est�n ya disponibles en ficheros. En este caso el programa puede importar y usar la clave privada para firmar, como se muestra en "Debilidades y Alternativas".

En otros casos el programa necesita generar la pareja de claves. Esto se puede hacer usando la clase KeyPairGenerator.

En este ejemplo generaremos una pareja de claves para el algoritmo Digital Signature Algorithm (DSA). Generaremos las claves con una longitud de 1024-bits.

La generaci�n de la pareja de claves requiere varios pasos.

Crear un Key Pair Generator

El primer paso es obtener el objeto "key-pair generator" para generar las claves para el algoritmo de firma DSA.

Como con todas las clases motores, la forma de obtener un objeto KeyPairGenerator para un tipo particular de algoritmo es llamar al m�todo de factoria est�tico getInstance de la clase KeyPairGenerator. Este m�todo tiene dos formas, las dos tienen un primer argumento String algorithm; y una de ellas tambi�n tiene un segundo argumento String provider.

Un llamador podr�a as� opcionalmente especificar el nombre de un proporcionador, que garantizar� que la implementaci�n del algoritmo requerida es del proporcionador nombrado. El c�digo de ejemplo de esta lecci�n siempre especifica el proporcionado por defecto SUN incluido junto con el JDK.

Ponemos la siguiente sentencia despu�s de l�nea:

else try {

en el fichero creado en el paso anterior,"Preparar la Estructura Inicial del Programa".

KeyPairGenerator keyGen =
    KeyPairGenerator.getInstance("DSA", "SUN");

Inicializar el Key-Pair Generator

El siguiente paso es inicializar el key-pair generator. Todos los objetos de este tipo comparten conceptos de tama�o de clave y una fuente aleatoria. La clase KeyPairGenerator tiene un m�todo initialize que tiene estos dos tipos de argumentos.

El tama�o de clave para un key generator DSA es la longitud de la clave (en bits), que debemos seleccionar a 1024.

La fuente aleatoria deber� ser un ejemplar de la clase SecureRandom. Este ejemplo pide un ejemplar que usa el algoritmo de generaci�n de n�meros pseudoaleatorios SHA1PRNG, proporcionado por el proporcionador SUN interno. El ejemplo luego pasa el ejemplar de SecureRandom al m�todo de inicializaci�n del key-pair generator.

SecureRandom random =
    SecureRandom.getInstance("SHA1PRNG", "SUN");
keyGen.initialize(1024, random);

Nota: La implementaci�n de SecureRandom intenta aleatorizar completamente el estado interno del propio generador a menos que el llamador siga la llamada al m�todo getInstance con una llamada al m�todo setSeed. Si tenemos un valor de seed espec�fico que queremos utilizar, deber�amos hacer los siguiente antes de llamar a initialize.

random.setSeed(seed);

Generar la Pareja de Claves

El peso final es generar la pareja de claves y almacenarlas en los objetos PrivateKey y PublicKey.

KeyPair pair = keyGen.generateKeyPair();
PrivateKey priv = pair.getPrivate();
PublicKey pub = pair.getPublic();

.�Firmar los Datos

Ahora que ya hemos creado una clave p�blica y una clave privada, estamos listos para firmar los datos. En este ejemplo firmaremos los datos contenidos en un fichero. GenSig obtiene el nombre del fichero desde la l�nea de comandos. Una firma digital se crea o se verifica usando un ejemplar de la clase Signature.

Firmar los datos, generar una firma digital para esos datos se hace con los siguientes pasos.

Obtener el Objeto Signature.

Con esto obtenermos un objeto Signature para generar o verificar firmas usando el algoritmo DSA, el mismo argumento con el que el programa gener� las claves en el paso anterior, "Generar las Claves P�blica y Privada".

Signature dsa = Signature.getInstance("SHA1withDSA", "SUN"); 

Nota: cuando se especifica el nombre del algoritmo de firma, tambi�n deber�amos incluir el nombre del algoritmo de mensaje usado por el algoritmo de la firma. SHA1withDSA es una forma de especificar el algoritmo de firma DSA con el algoritmo de mensaje SHA-1.

Inicializar el Objeto Signature

Antes de que el objeto Signature pueda usarse para firmar o verificar, debe ser inicializado. El m�todo de inicializaci�n para firmas requiere una clave privada. Usamos la clave privada situada dentro del objeto PrivateKey llamado priv en el paso anterior.

dsa.initSign(priv);

Suministrar el Objeto Signature a los Datos a Firmarthe Data to Be Signed

Este programa usa los datos desde un fichero cuyo nombre est� especificado como primer (y �nico) argumento de la l�nea de comandos. El programa leer� los datos en un buffer una vez y los suministrar� al objeto Signature llamando al m�todo update.

FileInputStream fis = new FileInputStream(args[0]);
BufferedInputStream bufin = new BufferedInputStream(fis);
byte[] buffer = new byte[1024];
int len;
while (bufin.available() != 0) {
    len = bufin.read(buffer);
    dsa.update(buffer, 0, len);
};
bufin.close();

Generar la Firma

Una vez que se le han suministrado todos los datos al objeto Signature, podemos generar la firma digital de los datos.

byte[] realSig = dsa.sign();

.�Grabar la Firma y la Clave P�blica en Ficheros

Ahora que ya hemos generado la firma para unos datos, necesitamos grabar los bytes de la firma en un fichero y la clave p�blica en otro para que los podamos enviar (mediante modem, diskette, mail, etc.) a cualquier otra persona.

  • los datos para los que se gener� la firma,
  • La firma, y
  • La clave p�blica

El receptor puede verificar que los datos vienen de nosotros y que no fueron modificados durante el tr�nsito ejecutando el programa VerSig que generaremos m�s adelante en "Verificar una Firma Digital". El programa usa la clave p�blica para verificar que la firma recibida es la firma verdadera para los datos recibidos.

Recuerda que la firma fue situada en un array de bytes llamado realSig. Podemos grabar los bytes de la firma en un fichero llamado sig con esto:.

        /* save the signature in a file */
        FileOutputStream sigfos = new FileOutputStream("sig");
        sigfos.write(realSig);
        sigfos.close();

Recordamos de "Generar las Claves P�blica y Privada" que la clave p�blica se situ� en un objeto llamado pub. Podemos obtener los bytes codificados de la clave llamando al m�todo getEncoded y luego almacenarlos en un fichero. Si, por ejemplo, tu nombre es Susan, podr�as nombrarlo con algo como suepk (por "Sue's public key"), de esta forma.

        /* save the public key in a file */
        byte[] key = pub.getEncoded();
        FileOutputStream keyfos = new FileOutputStream("suepk");
        keyfos.write(key);
        keyfos.close();

.�Compilar y Ejecutar el Programa

Aqu� est� el c�digo fuente completo del programa GenSig.java con algunos comentarios. Compila y ejecuta el programa. Recuerda que necesitamos especificar el nombre de un fichero a firmar.

java GenSig data

Podemos descargar el fichero de ejemplo llamado data o cualquier otro que queramos. El fichero no ser� modificado. Ser� le�do para que se pueda generar su firma.

Despu�s de ejecutar el programa, deberiamos ver los ficheros grabados suepk (clave p�blica) y sig (firma).

.�Verificar una Firma Digital

Si tenemos datos para los que se gener� una firma digital, podemos verificar la autenticidad de la firma. Para hacerlo necestiamos.

  • los datos
  • la firma
  • la clave p�blica correspondiente a la clave privada usada para firmar los datos

En este ejemplo escribiremos un programa VerSig para verificar la firma generada por el programa GenSig. Esto demuestra los pasos requeridos para verificar la autenticidad de una firma.

VerSig importa una clave p�blica y una firma que se sabe que es la firma de un fichero de datos espec�fico y luego verifica la autenticidad de la firma. Los nombres de los ficheros de la clave p�blica, la firma y los datos se especifican en la l�nea de comandos.

Los pasos para crear el programa de ejemplo VerSig para importar los ficheros y verificar la firma son los siguientes:

.�Preparar la Estructura Inicial del Programa

Aqu� est� la estructura b�sica del programa VerSig. Situamos este programa en un fichero llamado VerSig.java.

import java.io.*;
import java.security.*;
import java.security.spec.*;

class VerSig {

    public static void main(String[] args) {

        /* Verify a DSA signature */

        if (args.length != 3) {
            System.out.println("Usage: VerSig publickeyfile signaturefile datafile");
            }
        else try{

        // the rest of the code goes here

        } catch (Exception e) {
            System.err.println("Caught exception " + e.toString());
        }
    }

}

Notas.

  • Los m�todos para verificar datos est�n en el paquete java.security, por eso el programa importa todo este paquete. El programa tambi�n importa el paquete java.io para los metodos necesarios para la entrada de los datos del ficchero firmado, as� como el paquete java.security.spec, que contiene la clase X509EncodedKeySpec.
  • Se esperan tres argumentos, espec�ficando los ficheros de la clave p�blica, la firma y los datos.
  • El c�digo escrito en los pasos siguientes de esta lecci�n se pondr� entre los bloques try y catch.

.�Introducir y Convertir los Bytes Codificados de la Clave P�blica

Ahora, VerSig necesita importar los bytes codificados de la clave p�blica desde el fichero especificado como el primer argumento de la l�nea de comandos y convertirlos en un PublicKey. Se necesita un PublicKey porque es lo que requiere el m�todo Signature initVerify para poder inicializar el objeto Signature para verificaci�n.

Primero, leemos los bytes codificados de la clave p�blica

        FileInputStream keyfis = new FileInputStream(args[0]);
        byte[] encKey = new byte[keyfis.available()];  
        keyfis.read(encKey);

        keyfis.close();

Ahora el array de bytes encKey contiene los bytes codificados de la clave p�blica.

Podemos usar una clase KeyFactory para ejemplarizar una clave p�blica DSA desde sus bytes codificados. La clase KeyFactory proporciona conversi�n entre claves opacas (del tipo Key) y especificaciones de claves, que son representaciones transparentes del material de la clave. Con una clave opaca podemos obtener el nombre del algorimo, el nombre del formato, y los bytes de la clave codificados, pero no el material de la clave, que, por ejemplo, podr�a consistir en la propia clave y los argumentos del algoritmo usado para calcularla. (observa que PublicKey, como desciende de Key, es propiamente una Key.)

Por eso, primero necesitamos una especificaci�n de clave. Podemos obtener una mediante esto, asumiendo que la clave fue codificada para el est�ndard X.509, que es el caso, por ejemplo, si la clave fue generada por el suministrador de key-pair generator DSA interno del proporcionador de SUN.

        X509EncodedKeySpec pubKeySpec = new X509EncodedKeySpec(encKey);

Ahora necesitamos un objeto KeyFactory para hacer la conversi�n. Este objeto debe ser uno que trabaje con claves DS.

        KeyFactory keyFactory = KeyFactory.getInstance("DSA", "SUN");

Finalmente, podemos usar el objeto KeyFactory para generar un PublicKey partiendo de la especificaci�n de la clave.

        PublicKey pubKey = keyFactory.generatePublic(pubKeySpec);

.�Introducir los Bytes de la Firma

Luego, introducimos los bytes de la firma desde el fichero especificado como el segundo argumento de la l�nea de comandos.

        FileInputStream sigfis = new FileInputStream(args[1]);
        byte[] sigToVerify = new byte[sigfis.available()]; 
        sigfis.read(sigToVerify);
        sigfis.close();

Ahora el array de bytes sigToVerify contiene los bytes de la firma.

.�Verificar la Firma

Ya hemos a�adido c�digo al programa VerSig para

  • Introducir los bytes codificados de la clave y convertirlos en un PublicKey llamado pubKey
  • Introducir los bytes de la firma en un array de bytes llamado sigToVerify

Ahora podemos proceder a hacer la verificaci�n.

Inicializar el Objeto Signature para Verificaci�n

Al igual que en la generaci�n de firmas, una firma se verifica usando un ejemplar de la clase Signature. Necesitamos crear un objeto Signature que use el mismo algoritmo de firma que se utiliz� para generar la firma. El algoritmo usado por el programa GenSig fue SHA1withDSA del proporcionador de SUN.

Signature sig = Signature.getInstance("SHA1withDSA", "SUN");

Luego, necesitamos inicializar el objeto Signature. El m�todo de inicializaci�n para verificaci�n requiere la clave p�blica.

sig.initVerify(pubKey);

Suministrar al Objeto Signature los Datos a Verificar

Ahora necesitamos suministrar al objeto Signature los datos para los que se gener� la firma. Esto datos est�n en el fichero cuyo nombre se especific� como el tercer argumento de la l�nea de comandos. Al igual que hicimos durante la firma, leemos los datos en un buffer, y los suministramos al objeto Signature mediante una llamada al m�todo update.

FileInputStream datafis = new FileInputStream(args[2]);
BufferedInputStream bufin = new BufferedInputStream(datafis);

byte[] buffer = new byte[1024];
int len;
while (bufin.available() != 0) {
    len = bufin.read(buffer);
    sig.update(buffer, 0, len);
};

bufin.close();

Verificar la Firma

Una vez que le hemos suministrado todos los datos al objeto Signature, podemos verificar la firma digital de los datos y reportar el resultado. Recordamos que la firma fue leida en un array de bytes llamados sigToVerify.

boolean verifies = sig.verify(sigToVerify);

System.out.println("signature verifies: " + verifies);

El valor verifies ser� true si la firma (sigToVerify) es la firma real de los datos del fichero espec�ficado por la clave privada correspondiente a la clave p�blica pubKey.

.�Compilar y Ejecutar el Programa

Aqu� est� el c�digo fuente completo del programa VerSig.java, con algunos comentarios.

Compilamos y ejecutamos el programa. Recordando que necesitamos especificar tres argumentos en la l�nea de comandos.

  • El nombre del fichero que contiene los bytes codificados de la clave p�blica.
  • El nombre del fichero que contiene los bytes de la firma.
  • El nombre del fichero de datos (por el que se gener� la firma)

Como ya hemos probado la salida del programa GenSig, los nombres de ficheros deber�an ser.

  • suepk
  • sig
  • data

Aqu� est� el ejemplo ejecut�ndose, la parte en negrita indica lo que nosotros tecleamos.

%java VerSig suepk sig data
signature verifies: true

.�Debilidades y Alternativas

Los programas GenSig y VerSig en esta lecci�n ilustran el uso del API de Seguridad del JDK para generar una firma digital para datos y para verificar que una firma es aut�ntica. Sin embargo, el escenario real representado por esto programas, en los que el emisor usa el API de Seguridad del JDK para generar una pareja de claves p�blica/privada, almacena los bytes codificados de la clave p�blica en un fichero y el receptor lee los bytes de la clave, no es necesariamente realista, y tiene un gran defecto potencial.

En muchos casos no se necesita generar las claves, porque ya existen, bien como bytes codificados en ficheros o como entradas en un keystore.

El defecto potencial es que nada garantiza la autenticidad de la clave p�blica que recibe el receptor, y el programa VerSig verifica correctamente la autenticidad de una firma s�lo si la clave p�blica que se le suministra es propiamente aut�ntica.

Estos no son problemas en algunos casos, como cuando un s�lo programa hace las dos cosas: la firma y la verificaci�n.

.�Trabajar con Bytes de Claves Codificados

Algunas veces los bytes codificados de la clave ya existen en ficheros para la pareja de claves para ser usados para la firma y verificaci�n. Si este es el caso el programa GenSig puede importar los bytes codificados de la clave privada y convertirlos en un PrivateKey necesario para firmar, mediante el siguiente c�digo, asumiendo que el nombre del fichero que contiene los bytes de la clave privada est� en el string privkeyfile y que los bytes representan una clave DSA que ha sido codificada usando el est�ndard PKCS #8.

    FileInputStream keyfis = new FileInputStream(privkeyfile);
    byte[] encKey = new byte[keyfis.available()];
    keyfis.read(encKey);
    keyfis.close();

    PKCS8EncodedKeySpec privKeySpec = new PKCS8EncodedKeySpec(encKey);

    KeyFactory keyFactory = KeyFactory.getInstance("DSA");
    PrivateKey privKey = keyFactory.generatePrivate(privKeySpec);

GenSig ya no necesita grabar los bytes de la clave p�blica en un fichero, ya est�n en un uno.

En este caso el emisor env�a al receptor.

  • el fichero existente que contiene los bytes codificados de la clave p�blica (a menos que el receptor ya lo tenga) y
  • el fichero de datos y el fichero de la firma exportado por GenSig.

El programa VerSig no se modifica, ya espera los bytes codificados de la clave p�blica en un fichero.

�Pero qu� pasa con el problema potencial de que un usuario malicioso intercepte los ficheros y los reemplace de forma que el cambio no pueda ser detectado? En algunos casos esto no es un problema, porque la gente ya ha intercambiado las claves p�blicas personalmente o mediante una tercera parte constratada que hace el intercambio cada-a-cara. Despu�s de esto, se pueden hacer m�ltiples y consecutivos intercambios de ficheros remotamente (esto es, entre gente en diferentes localidades), y las claves p�blicas pueden usarse para verificar su autenticidad. Si un usuario malicioso intenta cambiar los datos o la firma, es detectado por VerSig.

Si no es posible el intercambio caro-a-cara, podemos probar otros m�todos de incrementar la confianza del receptor. Por ejemplo, podr�amos enviar nuestra clave p�blica de la forma m�s segura posible antes del intercambio de ficheros y firmas, quizas usando medios menos seguros.

En general, enviar los datos y la firma de forma separada de la clave p�blica reduce en gran medida la posibilidad de un ataque. A menos que se cambien los tres ficheros, y en cierta manera descrita en el siguiente p�rrafo, VerSig detectar�a cualquier intento.

Si los tres ficheros (documento de datos, clave p�blica y firma) fueran interceptados por un usuario malicioso, esa persona podr�a reemplazar el documento con otra cosa, firmarlo con una clave privada y reenviarlo en lugar del documento original, la nueva firma, y la clave p�blica correspondiente a la clave privada usada para generar la nueva firma. Entonces, VerSig reportar�a una verificaci�n correcta y nosotros pensar�amos que el documento viene de su emisor original. Por eso debemos tomar los pasos necesarios para segurarnos de que al menos la clave p�blica recibida est� intacta (VerSig detecta cualquier modificaci�n en los otros ficheros ), o podemos usar certificados para facilitar la autentificaci�n de la clave p�blica, como se describe en la siguiente secci�n.

.�Trabajar con Certificados

En criptograf�a es m�s com�n intercambiar certificados que contienen las claves p�blicas en vez de las propias claves.

Un beneficio es que un certificado est� firmado por una entidad (el emisor) para verificar que la clave p�blica encerrada es la clave p�blica real de otra entidad (el sujeto o propietario). Normalmente una autoridad de certificaci�n (CA) verifica la identidad del sujeto y lo avala como el propietario de la clave p�blica firmando el certificado.

Otro beneficio del uso de certificados es que podemos chequear para segurarnos la validez del certificado recibido verificando su forma digital, usando la clave p�blica del emisor (firmante), que a su vez podr�a estar almacenada en otro certificado cuya firma puede ser verificada usando la clave p�blica del emisor del certificado, que a su vez puede estar almacenada en otro certificado, etc, hasta alcanzar una clave p�blica en la que realmente creamos.

Si no podemos establecer una cadena verdadera (quiz�s porque el certificado del emisor no est� disponible para nosotros), se puede calcular la huella dactilar del certificado. Cada huella dactilar es un n�mero relativamente corto y �nico que identifica relativamente el certificado. (T�cnicamente es un valor de la informaci�n del certificado, usando un mensaje, tambi�n conocido como funci�n picadillo de un camino). Podemos llamar al propietario del certificado y comparar las huellas dactilares del certificado que hemos recibido con los que nos envi�. Si son iguales, los certificados con el mismo.

Ser�a m�s seguro para GenSig crear un certificado que contenga la clave p�blica para que VerSig luego importara el certificado y extrajera la clave p�blica. Sin embargo, el JDK no tiene API para certificados p�blicos que puedan permitirnos crear un certificado desde una clave p�blica, por eso el programa GenSig no puede crear un certificado para la clave p�blica generada.

(Si que hay un API p�blico para extraer una clave p�blica desde un certificado, creo).

Si queremos, podemos usar varias herramientas de seguridad, no APIs, para firmar documentos importantes y trabajar con certificados de un keystore, como se hizo en la lecci�n Intercambiar Ficheros.

Alternativamente podemos usar el API para modificar nuestros programas para que trabajen con una clave privada ya existente y su correspondiente clave p�blica (en un certificado) desde nuestro keystore. Para empezar, modicamos el programa GenSig para extraer la clave privada desde el keystore en vez de generar las claves nuevas. Primero, asumamos lo siguiente.

  • El nombre del keystore est� en el String ksName.
  • El tipo de keystore es "JKS", el tipo propietario creado por Sun Microsystems.
  • El password del keystore est� en el array de caracteres spass.
  • El alias de la entrada del keystore que contiene la clave privada, y el certificado de la clave p�blica est�n en el String alias.
  • El password de la clave privada est� en el array de caractereskpass

Luego podemos extraer la clave privada del keystore mediante esto.

    KeyStore ks = KeyStore.getInstance("JKS");
    FileInputStream ksfis = new FileInputStream(ksName); 
    BufferedInputStream ksbufin = new BufferedInputStream(ksfis);  
    
    ks.load(ksbufin, spass);
    PrivateKey priv = (PrivateKey) ks.getKey(alias, kpass);

Podemos extraer el certificado de la clave p�blica desde el keystore y grabar sus bytes codificados en un fichero llamado suecert, mediante esto.

    java.security.cert.Certificate cert = ks.getCertificate(alias);
    byte[] encodedCert = cert.getEncoded();
    
    /* save the certificate in a file named "suecert" */
    FileOutputStream certfos = new FileOutputStream("suecert");
    certfos.write(encodedCert);
    certfos.close();

Luego enviamos el fichero de datos, la firma y el certificado al receptor. El receptor verifica la autenticidad del certificado primero obteniendo la huella dactilar del certificado, mediante el comando keytool -printcert.

keytool -printcert -file suecert
  Owner: CN=Susan Jones, OU=Purchasing, O=ABC, L=Cupertino, ST=CA, C=US
  Issuer: CN=Susan Jones, OU=Purchasing, O=ABC, L=Cupertino, ST=CA, C=US
  Serial number: 35aaed17
  Valid from: Mon Jul 13 22:31:03 PDT 1998 until.
  Sun Oct 11 22:31:03 PDT 1998
  Certificate fingerprints.
       MD5:  1E:B8:04:59:86:7A:78:6B:40:AC:64:89:2C:0F:DD:13
       SHA1: 1C:79:BD:26:A1:34:C0:0A:30:63:11:6A:F2:B9:67:DF:E5:8D:7B:5E

Luego el receptor verifica las huellas dactilares, quiz�s llamando al emisor y comparandolas con las huellas del certificado recibido o busc�ndolas en un repositorio p�blico.

El programa de verificaci�n del receptor (un VerSig modificado) puede importar el certificado y extraerle la clave p�blica mediante esto, asumiendo que el nombre del fichero del certificado (por ejemplo, suecert) est� en el String certName.

FileInputStream certfis = new FileInputStream(certName);
java.security.cert.CertificateFactory cf =
	java.security.cert.CertificateFactory.getInstance("X.509");
java.security.cert.Certificate cert = cf.generateCertificate(certfis);
PublicKey pub = cert.getPublicKey();

.�Asegurar la Confidencialidad de los Datos

Supongamos que queremos mantener confidenciales los contenidos de los datos para que la gente no pueda ver el contenido durante el tr�nsito (o en nuestra propia m�quina o disco. Para hacer esto, deber�amos encriptar y almacenar y enviar s�lo el resultado de la encriptaci�n (referido como ciphertext). El receptor puede desencriptar el ciphertext para obtener una copia de los datos originales.

APIs para la encriptaci�n y desencriptaci�n, junto con otras implementaciones de algoritmos por defecto, est�n liberadas de forma separada en el Java Cryptography Extension (JCE), y a�ade un paquete al JDK, en concordancia con las regulaciones de control de exportaci�n de los U.S.

COMPARTE ESTE ARTÍCULO

COMPARTIR EN FACEBOOK
COMPARTIR EN TWITTER
COMPARTIR EN LINKEDIN
COMPARTIR EN WHATSAPP
ARTÍCULO ANTERIOR