diff options
Diffstat (limited to 'OpenKeychain/src/main/java/org/spongycastle/openpgp/operator/jcajce/NfcSyncPublicKeyDataDecryptorFactoryBuilder.java')
| -rw-r--r-- | OpenKeychain/src/main/java/org/spongycastle/openpgp/operator/jcajce/NfcSyncPublicKeyDataDecryptorFactoryBuilder.java | 275 |
1 files changed, 275 insertions, 0 deletions
diff --git a/OpenKeychain/src/main/java/org/spongycastle/openpgp/operator/jcajce/NfcSyncPublicKeyDataDecryptorFactoryBuilder.java b/OpenKeychain/src/main/java/org/spongycastle/openpgp/operator/jcajce/NfcSyncPublicKeyDataDecryptorFactoryBuilder.java new file mode 100644 index 000000000..ffa154876 --- /dev/null +++ b/OpenKeychain/src/main/java/org/spongycastle/openpgp/operator/jcajce/NfcSyncPublicKeyDataDecryptorFactoryBuilder.java @@ -0,0 +1,275 @@ +/** + * Copyright (c) 2013-2014 Philipp Jakubeit, Signe Rüsch, Dominik Schürmann + * + * Licensed under the Bouncy Castle License (MIT license). See LICENSE file for details. + */ + +package org.spongycastle.openpgp.operator.jcajce; + +import org.spongycastle.bcpg.PublicKeyAlgorithmTags; +import org.spongycastle.jcajce.util.DefaultJcaJceHelper; +import org.spongycastle.jcajce.util.NamedJcaJceHelper; +import org.spongycastle.jcajce.util.ProviderJcaJceHelper; +import org.spongycastle.openpgp.PGPException; +import org.spongycastle.openpgp.PGPPublicKey; +import org.spongycastle.openpgp.operator.PGPDataDecryptor; +import org.spongycastle.openpgp.operator.PublicKeyDataDecryptorFactory; + +import java.security.Provider; + +/** + * This class is based on JcePublicKeyDataDecryptorFactoryBuilder + * + */ +public class NfcSyncPublicKeyDataDecryptorFactoryBuilder +{ + private OperatorHelper helper = new OperatorHelper(new DefaultJcaJceHelper()); + private OperatorHelper contentHelper = new OperatorHelper(new DefaultJcaJceHelper()); + private JcaPGPKeyConverter keyConverter = new JcaPGPKeyConverter(); +// private JcaPGPDigestCalculatorProviderBuilder digestCalculatorProviderBuilder = new JcaPGPDigestCalculatorProviderBuilder(); +// private JcaKeyFingerprintCalculator fingerprintCalculator = new JcaKeyFingerprintCalculator(); + + public static class NfcInteractionNeeded extends RuntimeException + { + public byte[] encryptedSessionKey; + + public NfcInteractionNeeded(byte[] encryptedSessionKey) + { + super("NFC interaction required!"); + this.encryptedSessionKey = encryptedSessionKey; + } + } + + public NfcSyncPublicKeyDataDecryptorFactoryBuilder() + { + } + + /** + * Set the provider object to use for creating cryptographic primitives in the resulting factory the builder produces. + * + * @param provider provider object for cryptographic primitives. + * @return the current builder. + */ + public NfcSyncPublicKeyDataDecryptorFactoryBuilder setProvider(Provider provider) + { + this.helper = new OperatorHelper(new ProviderJcaJceHelper(provider)); + keyConverter.setProvider(provider); + this.contentHelper = helper; + + return this; + } + + /** + * Set the provider name to use for creating cryptographic primitives in the resulting factory the builder produces. + * + * @param providerName the name of the provider to reference for cryptographic primitives. + * @return the current builder. + */ + public NfcSyncPublicKeyDataDecryptorFactoryBuilder setProvider(String providerName) + { + this.helper = new OperatorHelper(new NamedJcaJceHelper(providerName)); + keyConverter.setProvider(providerName); + this.contentHelper = helper; + + return this; + } + + public NfcSyncPublicKeyDataDecryptorFactoryBuilder setContentProvider(Provider provider) + { + this.contentHelper = new OperatorHelper(new ProviderJcaJceHelper(provider)); + + return this; + } + + public NfcSyncPublicKeyDataDecryptorFactoryBuilder setContentProvider(String providerName) + { + this.contentHelper = new OperatorHelper(new NamedJcaJceHelper(providerName)); + + return this; + } + + public PublicKeyDataDecryptorFactory build(final byte[] nfcDecrypted) { + return new PublicKeyDataDecryptorFactory() + { + public byte[] recoverSessionData(int keyAlgorithm, byte[][] secKeyData) + throws PGPException + { + if (keyAlgorithm == PublicKeyAlgorithmTags.ECDH) + { + throw new PGPException("ECDH not supported!"); + } + + return decryptSessionData(keyAlgorithm, secKeyData, nfcDecrypted); + } + + public PGPDataDecryptor createDataDecryptor(boolean withIntegrityPacket, int encAlgorithm, byte[] key) + throws PGPException + { + return contentHelper.createDataDecryptor(withIntegrityPacket, encAlgorithm, key); + } + }; + } + +// public PublicKeyDataDecryptorFactory build(final PrivateKey privKey) +// { +// return new PublicKeyDataDecryptorFactory() +// { +// public byte[] recoverSessionData(int keyAlgorithm, byte[][] secKeyData) +// throws PGPException +// { +// if (keyAlgorithm == PublicKeyAlgorithmTags.ECDH) +// { +// throw new PGPException("ECDH requires use of PGPPrivateKey for decryption"); +// } +// return decryptSessionData(keyAlgorithm, privKey, secKeyData); +// } +// +// public PGPDataDecryptor createDataDecryptor(boolean withIntegrityPacket, int encAlgorithm, byte[] key) +// throws PGPException +// { +// return contentHelper.createDataDecryptor(withIntegrityPacket, encAlgorithm, key); +// } +// }; +// } + +// public PublicKeyDataDecryptorFactory build(final PGPPrivateKey privKey, final byte[] nfcDecrypted) +// { +// return new PublicKeyDataDecryptorFactory() +// { +// public byte[] recoverSessionData(int keyAlgorithm, byte[][] secKeyData) +// throws PGPException +// { +// if (keyAlgorithm == PublicKeyAlgorithmTags.ECDH) +// { +// return decryptSessionData(privKey.getPrivateKeyDataPacket(), privKey.getPublicKeyPacket(), secKeyData); +// } +// +// return decryptSessionData(keyAlgorithm, keyConverter.getPrivateKey(privKey), secKeyData, nfcDecrypted); +// } +// +// public PGPDataDecryptor createDataDecryptor(boolean withIntegrityPacket, int encAlgorithm, byte[] key) +// throws PGPException +// { +// return contentHelper.createDataDecryptor(withIntegrityPacket, encAlgorithm, key); +// } +// }; +// } + +// private byte[] decryptSessionData(BCPGKey privateKeyPacket, PublicKeyPacket pubKeyData, byte[][] secKeyData) +// throws PGPException +// { +// ECDHPublicBCPGKey ecKey = (ECDHPublicBCPGKey)pubKeyData.getKey(); +// X9ECParameters x9Params = NISTNamedCurves.getByOID(ecKey.getCurveOID()); +// +// byte[] enc = secKeyData[0]; +// +// int pLen = ((((enc[0] & 0xff) << 8) + (enc[1] & 0xff)) + 7) / 8; +// byte[] pEnc = new byte[pLen]; +// +// System.arraycopy(enc, 2, pEnc, 0, pLen); +// +// byte[] keyEnc = new byte[enc[pLen + 2]]; +// +// System.arraycopy(enc, 2 + pLen + 1, keyEnc, 0, keyEnc.length); +// +// Cipher c = helper.createKeyWrapper(ecKey.getSymmetricKeyAlgorithm()); +// +// ECPoint S = x9Params.getCurve().decodePoint(pEnc).multiply(((ECSecretBCPGKey)privateKeyPacket).getX()).normalize(); +// +// RFC6637KDFCalculator rfc6637KDFCalculator = new RFC6637KDFCalculator(digestCalculatorProviderBuilder.build().get(ecKey.getHashAlgorithm()), ecKey.getSymmetricKeyAlgorithm()); +// Key key = new SecretKeySpec(rfc6637KDFCalculator.createKey(ecKey.getCurveOID(), S, fingerprintCalculator.calculateFingerprint(pubKeyData)), "AESWrap"); +// +// try +// { +// c.init(Cipher.UNWRAP_MODE, key); +// +// Key paddedSessionKey = c.unwrap(keyEnc, "Session", Cipher.SECRET_KEY); +// +// return PGPPad.unpadSessionData(paddedSessionKey.getEncoded()); +// } +// catch (InvalidKeyException e) +// { +// throw new PGPException("error setting asymmetric cipher", e); +// } +// catch (NoSuchAlgorithmException e) +// { +// throw new PGPException("error setting asymmetric cipher", e); +// } +// } + + private byte[] decryptSessionData(int keyAlgorithm, byte[][] secKeyData, byte[] nfcDecrypted) + throws PGPException + { +// Cipher c1 = helper.createPublicKeyCipher(keyAlgorithm); +// +// try +// { +// c1.init(Cipher.DECRYPT_MODE, privKey); +// } +// catch (InvalidKeyException e) +// { +// throw new PGPException("error setting asymmetric cipher", e); +// } + + if (keyAlgorithm == PGPPublicKey.RSA_ENCRYPT + || keyAlgorithm == PGPPublicKey.RSA_GENERAL) + { + byte[] bi = secKeyData[0]; // encoded MPI + + if (nfcDecrypted != null) { + // we already have the decrypted bytes from a previous execution, return this! + return nfcDecrypted; + } else { + // catch this when decryptSessionData() is executed and divert digest to card, + // when doing the operation again reuse nfcDecrypted + throw new NfcInteractionNeeded(bi); + } + +// c1.update(bi, 2, bi.length - 2); + } + else + { + throw new PGPException("ElGamal not supported!"); + +// ElGamalKey k = (ElGamalKey)privKey; +// int size = (k.getParameters().getP().bitLength() + 7) / 8; +// byte[] tmp = new byte[size]; +// +// byte[] bi = secKeyData[0]; // encoded MPI +// if (bi.length - 2 > size) // leading Zero? Shouldn't happen but... +// { +// c1.update(bi, 3, bi.length - 3); +// } +// else +// { +// System.arraycopy(bi, 2, tmp, tmp.length - (bi.length - 2), bi.length - 2); +// c1.update(tmp); +// } +// +// bi = secKeyData[1]; // encoded MPI +// for (int i = 0; i != tmp.length; i++) +// { +// tmp[i] = 0; +// } +// +// if (bi.length - 2 > size) // leading Zero? Shouldn't happen but... +// { +// c1.update(bi, 3, bi.length - 3); +// } +// else +// { +// System.arraycopy(bi, 2, tmp, tmp.length - (bi.length - 2), bi.length - 2); +// c1.update(tmp); +// } + } + +// try +// { +// return c1.doFinal(); +// } +// catch (Exception e) +// { +// throw new PGPException("exception decrypting session data", e); +// } + } +} |