Seguridad en la Plataforma Java 2 JDK 1.2
Generar y Verificar Firmas
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.
