/*
    * GordianKnot: Security Suite
    * Copyright 2012-2026. Tony Washer
    *
    * Licensed under the Apache License, Version 2.0 (the "License"); you may not
    * use this file except in compliance with the License.  You may obtain a copy
    * of the License at
    *
    *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
   * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
   * License for the specific language governing permissions and limitations under
   * the License.
   */
  package io.github.tonywasher.joceanus.gordianknot.impl.bc;
  
  import io.github.tonywasher.joceanus.gordianknot.api.agree.GordianAgreementSpec;
  import io.github.tonywasher.joceanus.gordianknot.api.base.GordianException;
  import io.github.tonywasher.joceanus.gordianknot.api.encrypt.GordianEncryptorSpec;
  import io.github.tonywasher.joceanus.gordianknot.api.keypair.GordianElliptic;
  import io.github.tonywasher.joceanus.gordianknot.api.keypair.GordianKeyPair;
  import io.github.tonywasher.joceanus.gordianknot.api.keypair.GordianKeyPairSpec;
  import io.github.tonywasher.joceanus.gordianknot.api.sign.GordianSignParams;
  import io.github.tonywasher.joceanus.gordianknot.api.sign.GordianSignatureSpec;
  import io.github.tonywasher.joceanus.gordianknot.impl.bc.BouncyKeyPair.BouncyPrivateKey;
  import io.github.tonywasher.joceanus.gordianknot.impl.bc.BouncyKeyPair.BouncyPublicKey;
  import io.github.tonywasher.joceanus.gordianknot.impl.bc.BouncySignature.BouncyDERCoder;
  import io.github.tonywasher.joceanus.gordianknot.impl.bc.BouncySignature.BouncyDigestSignature;
  import io.github.tonywasher.joceanus.gordianknot.impl.core.agree.GordianCoreAgreementFactory;
  import io.github.tonywasher.joceanus.gordianknot.impl.core.base.GordianBaseFactory;
  import io.github.tonywasher.joceanus.gordianknot.impl.core.encrypt.GordianCoreEncryptor;
  import io.github.tonywasher.joceanus.gordianknot.impl.core.exc.GordianCryptoException;
  import io.github.tonywasher.joceanus.gordianknot.impl.core.exc.GordianIOException;
  import io.github.tonywasher.joceanus.gordianknot.impl.core.exc.GordianLogicException;
  import io.github.tonywasher.joceanus.gordianknot.impl.core.keypair.GordianKeyPairValidity;
  import io.github.tonywasher.joceanus.gordianknot.impl.ext.engines.GordianEllipticEncryptor;
  import org.bouncycastle.asn1.ASN1ObjectIdentifier;
  import org.bouncycastle.asn1.pkcs.PrivateKeyInfo;
  import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo;
  import org.bouncycastle.asn1.x9.ECNamedCurveTable;
  import org.bouncycastle.asn1.x9.X9ECParameters;
  import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
  import org.bouncycastle.crypto.DSA;
  import org.bouncycastle.crypto.DerivationFunction;
  import org.bouncycastle.crypto.InvalidCipherTextException;
  import org.bouncycastle.crypto.SecretWithEncapsulation;
  import org.bouncycastle.crypto.agreement.ECDHCBasicAgreement;
  import org.bouncycastle.crypto.agreement.ECDHCUnifiedAgreement;
  import org.bouncycastle.crypto.agreement.ECMQVBasicAgreement;
  import org.bouncycastle.crypto.generators.ECKeyPairGenerator;
  import org.bouncycastle.crypto.kems.ECIESKEMExtractor;
  import org.bouncycastle.crypto.kems.ECIESKEMGenerator;
  import org.bouncycastle.crypto.params.AsymmetricKeyParameter;
  import org.bouncycastle.crypto.params.ECDHUPrivateParameters;
  import org.bouncycastle.crypto.params.ECDHUPublicParameters;
  import org.bouncycastle.crypto.params.ECKeyGenerationParameters;
  import org.bouncycastle.crypto.params.ECNamedDomainParameters;
  import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
  import org.bouncycastle.crypto.params.ECPublicKeyParameters;
  import org.bouncycastle.crypto.params.MQVPrivateParameters;
  import org.bouncycastle.crypto.params.MQVPublicParameters;
  import org.bouncycastle.crypto.params.ParametersWithRandom;
  import org.bouncycastle.crypto.util.PrivateKeyFactory;
  import org.bouncycastle.crypto.util.PrivateKeyInfoFactory;
  import org.bouncycastle.crypto.util.PublicKeyFactory;
  import org.bouncycastle.crypto.util.SubjectPublicKeyInfoFactory;
  import org.bouncycastle.jcajce.provider.asymmetric.util.ECUtil;
  import org.bouncycastle.util.BigIntegers;
  
  import javax.security.auth.DestroyFailedException;
  import java.io.IOException;
  import java.math.BigInteger;
  import java.security.spec.PKCS8EncodedKeySpec;
  import java.security.spec.X509EncodedKeySpec;
  
  /**
   * EllipticCurve KeyPair classes.
   */
  public final class BouncyEllipticKeyPair {
      /**
       * Private constructor.
       */
      private BouncyEllipticKeyPair() {
      }
  
      /**
       * Bouncy Elliptic PublicKey.
       */
      public static class BouncyECPublicKey
              extends BouncyPublicKey<ECPublicKeyParameters> {
          /**
           * Constructor.
           *
           * @param pKeySpec   the keySpec
           * @param pPublicKey the public key
           */
          BouncyECPublicKey(final GordianKeyPairSpec pKeySpec,
                           final ECPublicKeyParameters pPublicKey) {
             super(pKeySpec, pPublicKey);
         }
 
         @Override
         protected boolean matchKey(final AsymmetricKeyParameter pThat) {
             /* Access keys */
             final ECPublicKeyParameters myThis = getPublicKey();
             final ECPublicKeyParameters myThat = (ECPublicKeyParameters) pThat;
 
             /* Compare keys */
             return compareKeys(myThis, myThat);
         }
 
         /**
          * Is the private key valid for this public key?
          *
          * @param pPrivate the private key
          * @return true/false
          */
         public boolean validPrivate(final BouncyECPrivateKey pPrivate) {
             final ECPrivateKeyParameters myPrivate = pPrivate.getPrivateKey();
             return getPublicKey().getParameters().equals(myPrivate.getParameters());
         }
 
         /**
          * CompareKeys.
          *
          * @param pFirst  the first key
          * @param pSecond the second key
          * @return true/false
          */
         private static boolean compareKeys(final ECPublicKeyParameters pFirst,
                                            final ECPublicKeyParameters pSecond) {
             return pFirst.getQ().equals(pSecond.getQ())
                     && pFirst.getParameters().equals(pSecond.getParameters());
         }
     }
 
     /**
      * Bouncy Elliptic PrivateKey.
      */
     public static class BouncyECPrivateKey
             extends BouncyPrivateKey<ECPrivateKeyParameters> {
         /**
          * Constructor.
          *
          * @param pKeySpec    the keySpec
          * @param pPrivateKey the private key
          */
         BouncyECPrivateKey(final GordianKeyPairSpec pKeySpec,
                            final ECPrivateKeyParameters pPrivateKey) {
             super(pKeySpec, pPrivateKey);
         }
 
         @Override
         protected boolean matchKey(final AsymmetricKeyParameter pThat) {
             /* Access keys */
             final ECPrivateKeyParameters myThis = getPrivateKey();
             final ECPrivateKeyParameters myThat = (ECPrivateKeyParameters) pThat;
 
             /* Compare keys */
             return compareKeys(myThis, myThat);
         }
 
         /**
          * CompareKeys.
          *
          * @param pFirst  the first key
          * @param pSecond the second key
          * @return true/false
          */
         private static boolean compareKeys(final ECPrivateKeyParameters pFirst,
                                            final ECPrivateKeyParameters pSecond) {
             return pFirst.getD().equals(pSecond.getD())
                     && pFirst.getParameters().equals(pSecond.getParameters());
         }
     }
 
     /**
      * BouncyCastle Elliptic KeyPair generator.
      */
     public static class BouncyECKeyPairGenerator
             extends BouncyKeyPairGenerator {
         /**
          * Generator.
          */
         private final ECKeyPairGenerator theGenerator;
 
         /**
          * Constructor.
          *
          * @param pFactory the Security Factory
          * @param pKeySpec the keySpec
          * @throws GordianException on error
          */
         BouncyECKeyPairGenerator(final GordianBaseFactory pFactory,
                                  final GordianKeyPairSpec pKeySpec) throws GordianException {
             /* Initialise underlying class */
             super(pFactory, pKeySpec);
 
             /* Create the generator */
             theGenerator = newGenerator();
 
             /* Lookup the parameters */
             final GordianElliptic myElliptic = pKeySpec.getElliptic();
             final String myCurve = myElliptic.getCurveName();
             final X9ECParameters x9 = myElliptic.hasCustomCurve()
                     ? ECUtil.getNamedCurveByName(myCurve)
                     : ECNamedCurveTable.getByName(myCurve);
             if (x9 == null) {
                 throw new GordianLogicException("Invalid KeySpec - " + pKeySpec);
             }
 
             /* Initialise the generator */
             final ASN1ObjectIdentifier myOid = ECUtil.getNamedCurveOid(myCurve);
             final ECNamedDomainParameters myDomain = new ECNamedDomainParameters(myOid, x9.getCurve(), x9.getG(), x9.getN(), x9.getH(), x9.getSeed());
             final ECKeyGenerationParameters myParams = new ECKeyGenerationParameters(myDomain, getRandom());
             theGenerator.init(myParams);
         }
 
         /**
          * Create the generator.
          *
          * @return the generator
          */
         ECKeyPairGenerator newGenerator() {
             return new ECKeyPairGenerator();
         }
 
         @Override
         public BouncyKeyPair generateKeyPair() {
             /* Generate and return the keyPair */
             final AsymmetricCipherKeyPair myPair = theGenerator.generateKeyPair();
             final BouncyECPublicKey myPublic = new BouncyECPublicKey(getKeySpec(), (ECPublicKeyParameters) myPair.getPublic());
             final BouncyECPrivateKey myPrivate = new BouncyECPrivateKey(getKeySpec(), (ECPrivateKeyParameters) myPair.getPrivate());
             return new BouncyKeyPair(myPublic, myPrivate);
         }
 
         @Override
         public PKCS8EncodedKeySpec getPKCS8Encoding(final GordianKeyPair pKeyPair) throws GordianException {
             /* Protect against exceptions */
             try {
                 /* Check the keyPair type and keySpecs */
                 BouncyKeyPair.checkKeyPair(pKeyPair, getKeySpec());
 
                 /* build and return the encoding */
                 final BouncyECPrivateKey myPrivateKey = (BouncyECPrivateKey) getPrivateKey(pKeyPair);
                 final ECPrivateKeyParameters myParms = myPrivateKey.getPrivateKey();
                 final PrivateKeyInfo myInfo = PrivateKeyInfoFactory.createPrivateKeyInfo(myParms);
                 return new PKCS8EncodedKeySpec(myInfo.getEncoded());
 
             } catch (IOException e) {
                 throw new GordianCryptoException(ERROR_PARSE, e);
             }
         }
 
         @Override
         public BouncyKeyPair deriveKeyPair(final X509EncodedKeySpec pPublicKey,
                                            final PKCS8EncodedKeySpec pPrivateKey) throws GordianException {
             /* Protect against exceptions */
             try {
                 /* Check the keySpecs */
                 checkKeySpec(pPrivateKey);
 
                 /* derive keyPair */
                 final BouncyECPublicKey myPublic = derivePublicKey(pPublicKey);
                 final PrivateKeyInfo myInfo = PrivateKeyInfo.getInstance(pPrivateKey.getEncoded());
                 final ECPrivateKeyParameters myParms = (ECPrivateKeyParameters) PrivateKeyFactory.createKey(myInfo);
                 final BouncyECPrivateKey myPrivate = new BouncyECPrivateKey(getKeySpec(), myParms);
                 final BouncyKeyPair myPair = new BouncyKeyPair(myPublic, myPrivate);
 
                 /* Check that we have a matching pair */
                 GordianKeyPairValidity.checkValidity(getFactory(), myPair);
 
                 /* Return the keyPair */
                 return myPair;
 
             } catch (IOException e) {
                 throw new GordianCryptoException(ERROR_PARSE, e);
             }
         }
 
         @Override
         public X509EncodedKeySpec getX509Encoding(final GordianKeyPair pKeyPair) throws GordianException {
             /* Protect against exceptions */
             try {
                 /* Check the keyPair type and keySpecs */
                 BouncyKeyPair.checkKeyPair(pKeyPair, getKeySpec());
 
                 /* build and return the encoding */
                 final BouncyECPublicKey myPublicKey = (BouncyECPublicKey) getPublicKey(pKeyPair);
                 final ECPublicKeyParameters myParms = myPublicKey.getPublicKey();
                 final SubjectPublicKeyInfo myInfo = SubjectPublicKeyInfoFactory.createSubjectPublicKeyInfo(myParms);
                 return new X509EncodedKeySpec(myInfo.getEncoded());
 
             } catch (IOException e) {
                 throw new GordianCryptoException(ERROR_PARSE, e);
             }
         }
 
         @Override
         public BouncyKeyPair derivePublicOnlyKeyPair(final X509EncodedKeySpec pEncodedKey) throws GordianException {
             final BouncyECPublicKey myPublic = derivePublicKey(pEncodedKey);
             return new BouncyKeyPair(myPublic);
         }
 
         /**
          * Derive public key from encoded.
          *
          * @param pEncodedKey the encoded key
          * @return the public key
          * @throws GordianException on error
          */
         private BouncyECPublicKey derivePublicKey(final X509EncodedKeySpec pEncodedKey) throws GordianException {
             /* Protect against exceptions */
             try {
                 /* Check the keySpecs */
                 checkKeySpec(pEncodedKey);
 
                 /* derive publicKey */
                 final SubjectPublicKeyInfo myInfo = SubjectPublicKeyInfo.getInstance(pEncodedKey.getEncoded());
                 final ECPublicKeyParameters myParms = (ECPublicKeyParameters) PublicKeyFactory.createKey(myInfo);
                 return new BouncyECPublicKey(getKeySpec(), myParms);
 
             } catch (IOException e) {
                 throw new GordianCryptoException(ERROR_PARSE, e);
             }
         }
     }
 
     /**
      * EC signer.
      */
     public static class BouncyECSignature
             extends BouncyDigestSignature {
         /**
          * The Signer.
          */
         private final DSA theSigner;
 
         /**
          * The Coder.
          */
         private final BouncyDERCoder theCoder;
 
         /**
          * Constructor.
          *
          * @param pFactory the factory
          * @param pSpec    the signatureSpec.
          * @throws GordianException on error
          */
         BouncyECSignature(final GordianBaseFactory pFactory,
                           final GordianSignatureSpec pSpec) throws GordianException {
             /* Initialise underlying class */
             super(pFactory, pSpec);
 
             /* Create the signer and Coder */
             theSigner = BouncySignature.getDSASigner(pFactory, pSpec);
             theCoder = new BouncyDERCoder();
         }
 
         @Override
         public void initForSigning(final GordianSignParams pParams) throws GordianException {
             /* Initialise detail */
             super.initForSigning(pParams);
             final BouncyKeyPair myPair = getKeyPair();
             BouncyKeyPair.checkKeyPair(myPair);
 
             /* Initialise and set the signer */
             final BouncyECPrivateKey myPrivate = (BouncyECPrivateKey) myPair.getPrivateKey();
             final ParametersWithRandom myParms = new ParametersWithRandom(myPrivate.getPrivateKey(), getRandom());
             theSigner.init(true, myParms);
         }
 
         @Override
         public void initForVerify(final GordianSignParams pParams) throws GordianException {
             /* Initialise detail */
             super.initForVerify(pParams);
             final BouncyKeyPair myPair = getKeyPair();
             BouncyKeyPair.checkKeyPair(myPair);
 
             /* Initialise and set the signer */
             final BouncyECPublicKey myPublic = (BouncyECPublicKey) myPair.getPublicKey();
             theSigner.init(false, myPublic.getPublicKey());
         }
 
         @Override
         public byte[] sign() throws GordianException {
             /* Check that we are in signing mode */
             checkMode(GordianSignatureMode.SIGN);
 
             /* Sign the message */
             final BigInteger[] myValues = theSigner.generateSignature(getDigest());
             return theCoder.dsaEncode(myValues[0], myValues[1]);
         }
 
         @Override
         public boolean verify(final byte[] pSignature) throws GordianException {
             /* Check that we are in verify mode */
             checkMode(GordianSignatureMode.VERIFY);
 
             /* Verify the message */
             final BigInteger[] myValues = theCoder.dsaDecode(pSignature);
             return theSigner.verifySignature(getDigest(), myValues[0], myValues[1]);
         }
     }
 
     /**
      * EC Agreement Engine.
      */
     public static class BouncyECIESAgreementEngine
             extends BouncyAgreementBase {
         /**
          * Key Length.
          */
         private static final int KEYLEN = 32;
 
         /**
          * Derivation function.
          */
         private final DerivationFunction theDerivation;
 
         /**
          * Constructor.
          *
          * @param pFactory the security factory
          * @param pSpec    the agreementSpec
          * @throws GordianException on error
          */
         BouncyECIESAgreementEngine(final GordianCoreAgreementFactory pFactory,
                                    final GordianAgreementSpec pSpec) throws GordianException {
             /* Initialize underlying class */
             super(pFactory, pSpec);
 
             /* Initialise the derivation function */
             theDerivation = newDerivationFunction();
         }
 
         @Override
         public void buildClientHello() throws GordianException {
             /* Protect against exceptions */
             try {
                 /* Create encapsulation */
                 final BouncyECPublicKey myPublic = (BouncyECPublicKey) getPublicKey(getServerKeyPair());
                 final ECIESKEMGenerator myGenerator = new ECIESKEMGenerator(KEYLEN, theDerivation, getRandom());
                 final SecretWithEncapsulation myResult = myGenerator.generateEncapsulated(myPublic.getPublicKey());
 
                 /* Store the encapsulation */
                 setEncapsulated(myResult.getEncapsulation());
 
                 /* Store secret and create initVector */
                 storeSecret(myResult.getSecret());
                 myResult.destroy();
 
             } catch (DestroyFailedException e) {
                 throw new GordianIOException("Failed to destroy secret", e);
             }
         }
 
         @Override
         public void processClientHello() throws GordianException {
             /* Create encapsulation */
             final BouncyECPrivateKey myPrivate = (BouncyECPrivateKey) getPrivateKey(getServerKeyPair());
             final ECIESKEMExtractor myExtractor = new ECIESKEMExtractor(myPrivate.getPrivateKey(), KEYLEN, theDerivation);
 
             /* Parse encapsulated message and store secret */
             final byte[] myMessage = getEncapsulated();
             storeSecret(myExtractor.extractSecret(myMessage));
         }
     }
 
     /**
      * EC Anonymous Agreement Engine.
      */
     public static class BouncyECAnonAgreementEngine
             extends BouncyAgreementBase {
         /**
          * The agreement.
          */
         private final ECDHCBasicAgreement theAgreement;
 
         /**
          * Constructor.
          *
          * @param pFactory the security factory
          * @param pSpec    the agreementSpec
          * @throws GordianException on error
          */
         BouncyECAnonAgreementEngine(final GordianCoreAgreementFactory pFactory,
                                     final GordianAgreementSpec pSpec) throws GordianException {
             /* Initialize underlying class */
             super(pFactory, pSpec);
 
             /* Create the agreement */
             theAgreement = new ECDHCBasicAgreement();
         }
 
         @Override
         public void buildClientHello() throws GordianException {
             /* Access keys */
             final BouncyECPublicKey myPublic = (BouncyECPublicKey) getPublicKey(getServerKeyPair());
             final BouncyECPrivateKey myPrivate = (BouncyECPrivateKey) getPrivateKey(getClientEphemeral());
 
             /* Derive the secret */
             theAgreement.init(myPrivate.getPrivateKey());
             final BigInteger mySecretInt = theAgreement.calculateAgreement(myPublic.getPublicKey());
             final byte[] mySecret = BigIntegers.asUnsignedByteArray(theAgreement.getFieldSize(), mySecretInt);
 
             /* Store secret */
             storeSecret(mySecret);
         }
 
         @Override
         public void processClientHello() throws GordianException {
             /* Access keys */
             final BouncyECPublicKey myPublic = (BouncyECPublicKey) getPublicKey(getClientEphemeral());
             final BouncyECPrivateKey myPrivate = (BouncyECPrivateKey) getPrivateKey(getServerKeyPair());
 
             /* Derive the secret */
             theAgreement.init(myPrivate.getPrivateKey());
             final BigInteger mySecretInt = theAgreement.calculateAgreement(myPublic.getPublicKey());
             final byte[] mySecret = BigIntegers.asUnsignedByteArray(theAgreement.getFieldSize(), mySecretInt);
 
             /* Store secret */
             storeSecret(mySecret);
         }
     }
 
     /**
      * EC Basic Agreement Engine.
      */
     public static class BouncyECBasicAgreementEngine
             extends BouncyAgreementBase {
         /**
          * The agreement.
          */
         private final ECDHCBasicAgreement theAgreement;
 
         /**
          * Constructor.
          *
          * @param pFactory the security factory
          * @param pSpec    the agreementSpec
          * @throws GordianException on error
          */
         BouncyECBasicAgreementEngine(final GordianCoreAgreementFactory pFactory,
                                      final GordianAgreementSpec pSpec) throws GordianException {
             /* Initialize underlying class */
             super(pFactory, pSpec);
 
             /* Create the agreement */
             theAgreement = new ECDHCBasicAgreement();
         }
 
         @Override
         public void processClientHello() throws GordianException {
             /* Access keys */
             final BouncyECPublicKey myPublic = (BouncyECPublicKey) getPublicKey(getClientKeyPair());
             final BouncyECPrivateKey myPrivate = (BouncyECPrivateKey) getPrivateKey(getServerKeyPair());
 
             /* Derive the secret */
             theAgreement.init(myPrivate.getPrivateKey());
             final BigInteger mySecretInt = theAgreement.calculateAgreement(myPublic.getPublicKey());
             final byte[] mySecret = BigIntegers.asUnsignedByteArray(theAgreement.getFieldSize(), mySecretInt);
 
             /* Store secret */
             storeSecret(mySecret);
         }
 
         @Override
         public void processServerHello() throws GordianException {
             /* Access keys */
             final BouncyECPublicKey myPublic = (BouncyECPublicKey) getPublicKey(getServerKeyPair());
             final BouncyECPrivateKey myPrivate = (BouncyECPrivateKey) getPrivateKey(getClientKeyPair());
 
             /* Derive the secret */
             theAgreement.init(myPrivate.getPrivateKey());
             final BigInteger mySecretInt = theAgreement.calculateAgreement(myPublic.getPublicKey());
             final byte[] mySecret = BigIntegers.asUnsignedByteArray(theAgreement.getFieldSize(), mySecretInt);
 
             /* Store secret */
             storeSecret(mySecret);
         }
     }
 
     /**
      * EC Unified Agreement Engine.
      */
     public static class BouncyECUnifiedAgreementEngine
             extends BouncyAgreementBase {
         /**
          * The agreement.
          */
         private final ECDHCUnifiedAgreement theAgreement;
 
         /**
          * Constructor.
          *
          * @param pFactory the security factory
          * @param pSpec    the agreementSpec
          * @throws GordianException on error
          */
         BouncyECUnifiedAgreementEngine(final GordianCoreAgreementFactory pFactory,
                                        final GordianAgreementSpec pSpec) throws GordianException {
             /* Initialize underlying class */
             super(pFactory, pSpec);
 
             /* Create the agreement */
             theAgreement = new ECDHCUnifiedAgreement();
         }
 
         @Override
         public void processClientHello() throws GordianException {
             /* Access keys */
             final BouncyECPublicKey myClientPublic = (BouncyECPublicKey) getPublicKey(getClientKeyPair());
             final BouncyECPublicKey myClientEphPublic = (BouncyECPublicKey) getPublicKey(getClientEphemeral());
             final BouncyECPrivateKey myPrivate = (BouncyECPrivateKey) getPrivateKey(getServerKeyPair());
             final BouncyECPublicKey myEphPublic = (BouncyECPublicKey) getPublicKey(getServerEphemeral());
             final BouncyECPrivateKey myEphPrivate = (BouncyECPrivateKey) getPrivateKey(getServerEphemeral());
 
             /* Derive the secret */
             final ECDHUPrivateParameters myPrivParams
                     = new ECDHUPrivateParameters(myPrivate.getPrivateKey(), myEphPrivate.getPrivateKey(), myEphPublic.getPublicKey());
             theAgreement.init(myPrivParams);
             final ECDHUPublicParameters myPubParams
                     = new ECDHUPublicParameters(myClientPublic.getPublicKey(), myClientEphPublic.getPublicKey());
             storeSecret(theAgreement.calculateAgreement(myPubParams));
         }
 
         @Override
         public void processServerHello() throws GordianException {
             /* Access keys */
             final BouncyECPublicKey myServerPublic = (BouncyECPublicKey) getPublicKey(getServerKeyPair());
             final BouncyECPublicKey myServerEphPublic = (BouncyECPublicKey) getPublicKey(getServerEphemeral());
             final BouncyECPrivateKey myPrivate = (BouncyECPrivateKey) getPrivateKey(getClientKeyPair());
             final BouncyECPublicKey myEphPublic = (BouncyECPublicKey) getPublicKey(getClientEphemeral());
             final BouncyECPrivateKey myEphPrivate = (BouncyECPrivateKey) getPrivateKey(getClientEphemeral());
 
             /* Derive the secret */
             final ECDHUPrivateParameters myPrivParams
                     = new ECDHUPrivateParameters(myPrivate.getPrivateKey(), myEphPrivate.getPrivateKey(), myEphPublic.getPublicKey());
             theAgreement.init(myPrivParams);
             final ECDHUPublicParameters myPubParams
                     = new ECDHUPublicParameters(myServerPublic.getPublicKey(), myServerEphPublic.getPublicKey());
             storeSecret(theAgreement.calculateAgreement(myPubParams));
         }
     }
 
     /**
      * EC MQV Agreement Engine.
      */
     public static class BouncyECMQVAgreementEngine
             extends BouncyAgreementBase {
         /**
          * The agreement.
          */
         private final ECMQVBasicAgreement theAgreement;
 
         /**
          * Constructor.
          *
          * @param pFactory the security factory
          * @param pSpec    the agreementSpec
          * @throws GordianException on error
          */
         BouncyECMQVAgreementEngine(final GordianCoreAgreementFactory pFactory,
                                    final GordianAgreementSpec pSpec) throws GordianException {
             /* Initialize underlying class */
             super(pFactory, pSpec);
 
             /* Create the agreement */
             theAgreement = new ECMQVBasicAgreement();
         }
 
         @Override
         public void processClientHello() throws GordianException {
             /* Access keys */
             final BouncyECPublicKey myClientPublic = (BouncyECPublicKey) getPublicKey(getClientKeyPair());
             final BouncyECPublicKey myClientEphPublic = (BouncyECPublicKey) getPublicKey(getClientEphemeral());
             final BouncyECPrivateKey myPrivate = (BouncyECPrivateKey) getPrivateKey(getServerKeyPair());
             final BouncyECPublicKey myEphPublic = (BouncyECPublicKey) getPublicKey(getServerEphemeral());
             final BouncyECPrivateKey myEphPrivate = (BouncyECPrivateKey) getPrivateKey(getServerEphemeral());
 
             /* Derive the secret */
             final MQVPrivateParameters myPrivParams
                     = new MQVPrivateParameters(myPrivate.getPrivateKey(), myEphPrivate.getPrivateKey(), myEphPublic.getPublicKey());
             theAgreement.init(myPrivParams);
             final MQVPublicParameters myPubParams
                     = new MQVPublicParameters(myClientPublic.getPublicKey(), myClientEphPublic.getPublicKey());
             storeSecret(BigIntegers.asUnsignedByteArray(theAgreement.getFieldSize(), theAgreement.calculateAgreement(myPubParams)));
         }
 
         @Override
         public void processServerHello() throws GordianException {
             /* Access keys */
             final BouncyECPublicKey myServerPublic = (BouncyECPublicKey) getPublicKey(getServerKeyPair());
             final BouncyECPublicKey myServerEphPublic = (BouncyECPublicKey) getPublicKey(getServerEphemeral());
             final BouncyECPrivateKey myPrivate = (BouncyECPrivateKey) getPrivateKey(getClientKeyPair());
             final BouncyECPublicKey myEphPublic = (BouncyECPublicKey) getPublicKey(getClientEphemeral());
             final BouncyECPrivateKey myEphPrivate = (BouncyECPrivateKey) getPrivateKey(getClientEphemeral());
 
             /* Derive the secret */
             final MQVPrivateParameters myPrivParams
                     = new MQVPrivateParameters(myPrivate.getPrivateKey(), myEphPrivate.getPrivateKey(), myEphPublic.getPublicKey());
             theAgreement.init(myPrivParams);
             final MQVPublicParameters myPubParams
                     = new MQVPublicParameters(myServerPublic.getPublicKey(), myServerEphPublic.getPublicKey());
             storeSecret(BigIntegers.asUnsignedByteArray(theAgreement.getFieldSize(), theAgreement.calculateAgreement(myPubParams)));
         }
     }
 
     /**
      * EC Encryptor.
      */
     public static class BouncyECEncryptor
             extends GordianCoreEncryptor {
         /**
          * The underlying encryptor.
          */
         private final GordianEllipticEncryptor theEncryptor;
 
         /**
          * Constructor.
          *
          * @param pFactory the factory
          * @param pSpec    the encryptorSpec
          */
         BouncyECEncryptor(final GordianBaseFactory pFactory,
                           final GordianEncryptorSpec pSpec) {
             /* Initialise underlying cipher */
             super(pFactory, pSpec);
             theEncryptor = new GordianEllipticEncryptor();
         }
 
         @Override
         protected BouncyPublicKey<?> getPublicKey() {
             return (BouncyPublicKey<?>) super.getPublicKey();
         }
 
         @Override
         protected BouncyPrivateKey<?> getPrivateKey() {
             return (BouncyPrivateKey<?>) super.getPrivateKey();
         }
 
         @Override
         public void initForEncrypt(final GordianKeyPair pKeyPair) throws GordianException {
             /* Initialize underlying cipher */
             BouncyKeyPair.checkKeyPair(pKeyPair);
             super.initForEncrypt(pKeyPair);
 
             /* Initialize for encryption */
             final ECPublicKeyParameters myParms = (ECPublicKeyParameters) getPublicKey().getPublicKey();
             theEncryptor.initForEncrypt(myParms, getRandom());
         }
 
         @Override
         public void initForDecrypt(final GordianKeyPair pKeyPair) throws GordianException {
             /* Initialize underlying cipher */
             BouncyKeyPair.checkKeyPair(pKeyPair);
             super.initForDecrypt(pKeyPair);
 
             /* Initialize for decryption */
             final ECPrivateKeyParameters myParms = (ECPrivateKeyParameters) getPrivateKey().getPrivateKey();
             theEncryptor.initForDecrypt(myParms);
         }
 
         @Override
         public byte[] encrypt(final byte[] pBytes) throws GordianException {
             try {
                 /* Check that we are in encryption mode */
                 checkMode(GordianEncryptMode.ENCRYPT);
 
                 /* Encrypt the message */
                 return theEncryptor.encrypt(pBytes);
             } catch (InvalidCipherTextException e) {
                 throw new GordianCryptoException("Failed to process data", e);
             }
         }
 
         @Override
         public byte[] decrypt(final byte[] pBytes) throws GordianException {
             try {
                 /* Check that we are in decryption mode */
                 checkMode(GordianEncryptMode.DECRYPT);
 
                 /* Decrypt the message */
                 return theEncryptor.decrypt(pBytes);
             } catch (InvalidCipherTextException e) {
                 throw new GordianCryptoException("Failed to process data", e);
             }
         }
     }
 }