private void preload()
throws ApduConnectionException, Iso7816FourCardException, IOException, CertificateException,
Asn1Exception, TlvException {
// Nos vamos al raiz antes de nada
selectMasterFile();
// Cargamos el CDF
final CeresCdf cdf = new CeresCdf();
final byte[] cdfBytes = selectFileByLocationAndRead(CDF_LOCATION);
cdf.setDerValue(cdfBytes);
// Leemos los certificados segun las rutas del CDF
final CertificateFactory cf = CertificateFactory.getInstance("X.509"); // $NON-NLS-1$
this.certs = new LinkedHashMap<String, X509Certificate>(cdf.getCertificateCount());
this.aliasByCertAndKeyId = new LinkedHashMap<String, String>(cdf.getCertificateCount());
for (int i = 0; i < cdf.getCertificateCount(); i++) {
final Location l =
new Location(
cdf.getCertificatePath(i).replace("\\", "").trim()); // $NON-NLS-1$ //$NON-NLS-2$
final X509Certificate cert =
(X509Certificate)
cf.generateCertificate(
new ByteArrayInputStream(deflate(selectFileByLocationAndRead(l))));
final String alias = i + " " + cert.getSerialNumber(); // $NON-NLS-1$
this.aliasByCertAndKeyId.put(HexUtils.hexify(cdf.getCertificateId(i), false), alias);
this.certs.put(alias, cert);
}
final CeresPrKdf prkdf = new CeresPrKdf();
final byte[] prkdfValue = selectFileByLocationAndRead(PRKDF_LOCATION);
prkdf.setDerValue(prkdfValue);
this.keys = new LinkedHashMap<String, Byte>();
for (int i = 0; i < prkdf.getKeyCount(); i++) {
final String alias = this.aliasByCertAndKeyId.get(HexUtils.hexify(prkdf.getKeyId(i), false));
if (alias != null) {
this.keys.put(alias, Byte.valueOf(prkdf.getKeyReference(i)));
}
}
// Sincronizamos claves y certificados
hideCertsWithoutKey();
}
/**
* Prueba de generación de claves de canal.
*
* @throws Exception en cualquier error.
*/
@SuppressWarnings("static-method")
@Test
public void testKeysGeneration() throws Exception {
// Calculamos Kifdicc como el XOR de los valores Kifd y Kicc
final byte[] kidficc = HexUtils.xor(kicc, kifd);
Assert.assertEquals(
"820d590bc2c7aea5f12050374fbe381b76e779d6b57395e90167f657bec47475", //$NON-NLS-1$
HexUtils.hexify(kidficc, false).toLowerCase());
final byte[] kenc = generateKenc(kidficc);
System.out.println("Kenc: " + HexUtils.hexify(kenc, false)); // $NON-NLS-1$
final byte[] kmac = generateKmac(kidficc);
System.out.println("Kmac: " + HexUtils.hexify(kmac, false)); // $NON-NLS-1$
}
@Override
public byte[] sign(final byte[] data, final String algorithm, final PrivateKeyReference keyRef)
throws CryptoCardException, BadPinException {
if (data == null) {
throw new CryptoCardException("Los datos a firmar no pueden ser nulos"); // $NON-NLS-1$
}
if (keyRef == null) {
throw new IllegalArgumentException("La clave privada no puede ser nula"); // $NON-NLS-1$
}
if (!(keyRef instanceof CeresPrivateKeyReference)) {
throw new IllegalArgumentException(
"La clave proporcionada debe ser de tipo CeresPrivateKeyReference, pero se ha recibido de tipo "
+ keyRef.getClass().getName() // $NON-NLS-1$
);
}
final CeresPrivateKeyReference ceresPrivateKey = (CeresPrivateKeyReference) keyRef;
// Pedimos el PIN si no se ha pedido antes
if (!this.authenticated) {
try {
verifyPin(this.passwordCallback);
this.authenticated = true;
} catch (final ApduConnectionException e1) {
throw new CryptoCardException("Error en la verificacion de PIN: " + e1, e1); // $NON-NLS-1$
}
}
final byte[] digestInfo;
try {
digestInfo = DigestInfo.encode(algorithm, data, this.cryptoHelper);
} catch (final Exception e) {
throw new CryptoCardException(
"Erros creando el DigestInfo para la firma con el algoritmo " + algorithm + ": " + e,
e //$NON-NLS-1$ //$NON-NLS-2$
);
}
loadData(ceresPrivateKey.getKeyBitSize(), digestInfo);
final ResponseApdu res;
final CommandApdu cmd =
new SignDataApduCommand(
ceresPrivateKey.getKeyReference(), // Referencia
ceresPrivateKey.getKeyBitSize() // Tamano en bits de la clave
);
try {
res = sendArbitraryApdu(cmd);
} catch (final Exception e) {
throw new CryptoCardException("Error firmando los datos: " + e, e); // $NON-NLS-1$
}
if (!res.isOk()) {
throw new CryptoCardException(
"No se han podido firmar los datos. Respuesta: "
+ HexUtils.hexify(res.getBytes(), true)); // $NON-NLS-1$
}
return res.getData();
}
/**
* Genera la clave KENC para encriptar y desencriptar criptogramas.
*
* @param kidficc XOR de los valores Kifd y Kicc.
* @return Clave AES.
* @throws IOException Cuando no puede generarse la clave.
*/
private static byte[] generateKenc(final byte[] kidficc) throws IOException {
// La clave de cifrado Kenc se obtiene como los 16 primeros bytes del hash de la
// concatenacion de kifdicc con el valor "00 00 00 01" (SECURE_CHANNEL_KENC_AUX).
final byte[] kidficcConcat = HexUtils.concatenateByteArrays(kidficc, SECURE_CHANNEL_KENC_AUX);
System.out.println(
"Datos para el hash de Kenc: " + HexUtils.hexify(kidficcConcat, false)); // $NON-NLS-1$
final byte[] keyEnc = new byte[16];
System.arraycopy(
TestKeyGeneration.cryptoHelper.digest(CryptoHelper.DigestAlgorithm.SHA256, kidficcConcat),
0,
keyEnc,
0,
keyEnc.length);
return keyEnc;
}
private void loadData(final int keyBitSize, final byte[] digestInfo) throws CryptoCardException {
final byte[] paddedData;
try {
paddedData = CryptoHelper.addPkcs1PaddingForPrivateKeyOperation(digestInfo, keyBitSize);
} catch (final Exception e1) {
throw new CryptoCardException(
"Error realizando el relleno PKCS#1 de los datos a firmar: " + e1, // $NON-NLS-1$
e1);
}
ResponseApdu res;
// Si la clave es de 1024 la carga se puede hacer en una unica APDU
if (keyBitSize < 2048) {
try {
res = sendArbitraryApdu(new LoadDataApduCommand(paddedData));
} catch (final Exception e) {
throw new CryptoCardException(
"Error enviando los datos a firmar a la tarjeta: " + e, e); // $NON-NLS-1$
}
if (!res.isOk()) {
throw new CryptoCardException(
"No se han podido enviar los datos a firmar a la tarjeta. Respuesta: "
+ HexUtils.hexify(res.getBytes(), true)); // $NON-NLS-1$
}
}
// Pero si es de 2048 hacen falta dos APDU, envolviendo la APDU de carga de datos
else if (keyBitSize == 2048) {
final byte[] envelopedLoadDataApdu =
new byte[] {
(byte) 0x90,
(byte) 0x58,
(byte) 0x00,
(byte) 0x00,
(byte) 0x00,
(byte) 0x01,
(byte) 0x00
};
// La primera APDU carga 0xFF octetos (254)
byte[] data = new byte[255];
System.arraycopy(envelopedLoadDataApdu, 0, data, 0, envelopedLoadDataApdu.length);
System.arraycopy(
paddedData, 0, data, envelopedLoadDataApdu.length, 255 - envelopedLoadDataApdu.length);
try {
res = sendArbitraryApdu(new EnvelopeDataApduCommand(data));
} catch (final Exception e) {
throw new CryptoCardException(
"Error en el segundo envio a la tarjeta de los datos a firmar: " + e, e); // $NON-NLS-1$
}
if (!res.isOk()) {
throw new CryptoCardException(
"No se han podido enviar (segunda tanda) los datos a firmar a la tarjeta. Respuesta: "
+ HexUtils.hexify(res.getBytes(), true) // $NON-NLS-1$
);
}
// La segunda APDU es de 0x08 octetos (8)
data = new byte[8];
System.arraycopy(paddedData, 255 - envelopedLoadDataApdu.length, data, 0, 8);
try {
res = sendArbitraryApdu(new EnvelopeDataApduCommand(data));
} catch (final Exception e) {
throw new CryptoCardException(
"Error en el primer envio a la tarjeta de los datos a firmar: " + e, e); // $NON-NLS-1$
}
if (!res.isOk()) {
throw new CryptoCardException(
"No se han podido enviar (primera tanda) los datos a firmar a la tarjeta. Respuesta: "
+ HexUtils.hexify(res.getBytes(), true) // $NON-NLS-1$
);
}
} else {
throw new IllegalArgumentException(
"Solo se soportan claves de 2048 o menos bits"); //$NON-NLS-1$
}
}