KeyFactory y SecretKeyFactory
Los key factories se usan para convertir objetos de tipo Key (tipos opacos)
en especificaciones de esos objetos (tipos transparentes), y viceversa.
Su principal aplicación es permitir exportar e importar claves.
Existen dos formas de representar externamente una clave:
1. Por su encoded format
2. Con los parámetros que componen la clave
Ambas formas están implementadas por clases derivadas de KeySpec como
muestra la Figura 2.26.
Si tenemos el encoded format devuelto por getEncoded(), y el formato
devuelto por getFormat() (que puede ser "PKCS#8" o "X.509"), podemos
crear un objeto derivado de EncodedKeySpec usando uno de estos
constructores:
PKCS8EncodedKeySpec(byte[] encodedKey)
X509EncodedKeySpec(byte[] encodedKey)
Si de lo que disponemos es de los parámetros que componen una clave,
también hay clases derivadas de KeySpec que en su constructor reciben estos
parámetros.
Existen dos clases factory que actúan como key factories, es decir, que sirven
para generar claves:
KeyFactory es la clave que
sirve para importar y
exportar claves
asimétricas.
SecretKeyFactory es la
clase que sirve para
importar y exportar claves
secretas.
SecretKeyFactory es un servicio, y como tal, para obtener un algoritmo de un
proveedor usamos:
static SecretKeyFactory <SecretKeyFactory>
getInstance(String algorithm)
Cada proveedor debe documentar las especificaciones que soporta su clave.
Por ejemplo "SunJCE" soporta las especificaciones DESKeySpec y
DESedeKeySpec para el algoritmo "DES".
Esto significa que una clave "DES" (tipo opaco) de "SunJCE" se puede
transformar en los tipos transparentes DESKeySpec y DESedeKeySpec, o
viceversa.
Para exportar una clave (obtener su tipo transparente) usaremos el método:
KeySpec <SecretKeyFactory> getKeySpec(SecretKey key
, Class classSpec)
Donde el parámetro classSpec debería ser, o bien [Link], o bien
[Link]
Por ejemplo, para obtener un DESKeySpec de un SecretKey aleatorio obtenido
de tipo "DES" usando "SunJCE" hacemos:
// Creamos una clave como tipo opaco
SecureRandom sr = new SecureRandom();
KeyGenerator kg =
[Link]("DES","SunJCE"); [Link](sr);
[Link](56);
SecretKey clave = [Link]();
// Obtenemos su correspondiente tipo transparente
SecretKeyFactory skf = [Link]("DES");
DESKeySpec dks = (DESKeySpec) [Link](clave,
[Link]);
Si lo que queremos es importar una clave (obtener el tipo opaco de un tipo
transparente), creamos un objeto de algún tipo derivado de KeySpec, y se lo
pasamos a:
SecretKey <SecretKeyFactory> generateSecret(KeySpec ks)
Por ejemplo, si tenemos un array de 8 bytes con una clave DES podemos hacer:
byte[] buffer; // Array de 64 bits cargado con la clave
DESKeySpec dks = new DESKeySpec(buffer);
SecretKey clave = [Link](dks);