gt:         ECCurve curve = this.engineGetQ().getCurve();
context: package org.bouncycastle.jcajce.provider.asymmetric.ec;
  
  import java.io.IOException;
  import java.io.ObjectInputStream;
  import java.io.ObjectOutputStream;
  import java.math.BigInteger;
  import java.security.interfaces.ECPublicKey;
  import java.security.spec.ECParameterSpec;
  import java.security.spec.ECPoint;
  import java.security.spec.ECPublicKeySpec;
  import java.security.spec.EllipticCurve;
  
  import org.bouncycastle.asn1.ASN1Encodable;
  import org.bouncycastle.asn1.ASN1ObjectIdentifier;
  import org.bouncycastle.asn1.ASN1OctetString;
  import org.bouncycastle.asn1.ASN1Primitive;
  import org.bouncycastle.asn1.DERBitString;
  import org.bouncycastle.asn1.DERNull;
  import org.bouncycastle.asn1.DEROctetString;
  import org.bouncycastle.asn1.x509.AlgorithmIdentifier;
  import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo;
  import org.bouncycastle.asn1.x9.X962Parameters;
  import org.bouncycastle.asn1.x9.X9ECParameters;
  import org.bouncycastle.asn1.x9.X9ECPoint;
  import org.bouncycastle.asn1.x9.X9IntegerConverter;
  import org.bouncycastle.asn1.x9.X9ObjectIdentifiers;
  import org.bouncycastle.crypto.params.ECDomainParameters;
  import org.bouncycastle.crypto.params.ECPublicKeyParameters;
  import org.bouncycastle.jcajce.provider.asymmetric.util.KeyUtil;
  import org.bouncycastle.jcajce.provider.config.ProviderConfiguration;
  import org.bouncycastle.jce.interfaces.ECPointEncoder;
  import org.bouncycastle.jce.provider.BouncyCastleProvider;
  import org.bouncycastle.jce.spec.ECNamedCurveSpec;
  import org.bouncycastle.math.ec.ECCurve;
  
  public class BCECPublicKey
      implements ECPublicKey, org.bouncycastle.jce.interfaces.ECPublicKey, ECPointEncoder
  {
      static final long serialVersionUID = 2422789860422731812L;
  
      private String    algorithm = "EC";
      private boolean   withCompression;
  
      private transient org.bouncycastle.math.ec.ECPoint q;
      private transient ECParameterSpec         ecSpec;
      private transient ProviderConfiguration   configuration;
  
      public BCECPublicKey(
          String algorithm,
          BCECPublicKey key)
      {
          this.algorithm = algorithm;
          this.q = key.q;
          this.ecSpec = key.ecSpec;
          this.withCompression = key.withCompression;
          this.configuration = key.configuration;
      }
      
      public BCECPublicKey(
          String algorithm,
          ECPublicKeySpec spec,
          ProviderConfiguration configuration)
      {
          this.algorithm = algorithm;
          this.ecSpec = spec.getParams();
          this.q = EC5Util.convertPoint(ecSpec, spec.getW(), false);
          this.configuration = configuration;
      }
  
      public BCECPublicKey(
          String algorithm,
          org.bouncycastle.jce.spec.ECPublicKeySpec spec,
          ProviderConfiguration configuration)
      {
          this.algorithm = algorithm;
          this.q = spec.getQ();
  
          if (spec.getParams() != null) // can be null if implictlyCa
          {
              ECCurve curve = spec.getParams().getCurve();
              EllipticCurve ellipticCurve = EC5Util.convertCurve(curve, spec.getParams().getSeed());
  
              this.ecSpec = EC5Util.convertSpec(ellipticCurve, spec.getParams());
          }
          else
          {
              if (q.getCurve() == null)
              {
                  org.bouncycastle.jce.spec.ECParameterSpec s = configuration.getEcImplicitlyCa();
  
                  q = s.getCurve().createPoint(q.getX().toBigInteger(), q.getY().toBigInteger(), false);
              }               
              this.ecSpec = null;
          }
  
          this.configuration = configuration;
      }
      
      public BCECPublicKey(
          String algorithm,
          ECPublicKeyParameters params,
          ECParameterSpec spec,
          ProviderConfiguration configuration)
      {
          ECDomainParameters      dp = params.getParameters();
  
          this.algorithm = algorithm;
          this.q = params.getQ();
  
          if (spec == null)
          {
              EllipticCurve ellipticCurve = EC5Util.convertCurve(dp.getCurve(), dp.getSeed());
  
              this.ecSpec = createSpec(ellipticCurve, dp);
          }
          else
          {
              this.ecSpec = spec;
          }
  
          this.configuration = configuration;
      }
  
      public BCECPublicKey(
          String algorithm,
          ECPublicKeyParameters params,
          org.bouncycastle.jce.spec.ECParameterSpec spec,
          ProviderConfiguration configuration)
      {
          ECDomainParameters      dp = params.getParameters();
  
          this.algorithm = algorithm;
          this.q = params.getQ();
  
          if (spec == null)
          {
              EllipticCurve ellipticCurve = EC5Util.convertCurve(dp.getCurve(), dp.getSeed());
  
              this.ecSpec = createSpec(ellipticCurve, dp);
          }
          else
          {
              EllipticCurve ellipticCurve = EC5Util.convertCurve(spec.getCurve(), spec.getSeed());
  
              this.ecSpec = EC5Util.convertSpec(ellipticCurve, spec);
          }
  
          this.configuration = configuration;
      }
  
      /*
       * called for implicitCA
       */
      public BCECPublicKey(
          String algorithm,
          ECPublicKeyParameters params,
          ProviderConfiguration configuration)
      {
          this.algorithm = algorithm;
          this.q = params.getQ();
          this.ecSpec = null;
          this.configuration = configuration;
      }
  
      public BCECPublicKey(
          ECPublicKey key,
          ProviderConfiguration configuration)
      {
          this.algorithm = key.getAlgorithm();
          this.ecSpec = key.getParams();
          this.q = EC5Util.convertPoint(this.ecSpec, key.getW(), false);
      }
  
      BCECPublicKey(
          String algorithm,
          SubjectPublicKeyInfo info,
          ProviderConfiguration configuration)
      {
          this.algorithm = algorithm;
          this.configuration = configuration;
          populateFromPubKeyInfo(info);
      }
  
      private ECParameterSpec createSpec(EllipticCurve ellipticCurve, ECDomainParameters dp)
      {
          return new ECParameterSpec(
                  ellipticCurve,
                  new ECPoint(
                          dp.getG().getX().toBigInteger(),
                          dp.getG().getY().toBigInteger()),
                          dp.getN(),
                          dp.getH().intValue());
      }
  
      private void populateFromPubKeyInfo(SubjectPublicKeyInfo info)
      {
          X962Parameters params = new X962Parameters((ASN1Primitive)info.getAlgorithm().getParameters());
          ECCurve                 curve;
          EllipticCurve           ellipticCurve;
  
          if (params.isNamedCurve())
          {
              ASN1ObjectIdentifier oid = (ASN1ObjectIdentifier)params.getParameters();
              X9ECParameters ecP = ECUtil.getNamedCurveByOid(oid);
  
              curve = ecP.getCurve();
              ellipticCurve = EC5Util.convertCurve(curve, ecP.getSeed());
  
              ecSpec = new ECNamedCurveSpec(
                      ECUtil.getCurveName(oid),
                      ellipticCurve,
                      new ECPoint(
                              ecP.getG().getX().toBigInteger(),
                              ecP.getG().getY().toBigInteger()),
                      ecP.getN(),
                      ecP.getH());
          }
          else if (params.isImplicitlyCA())
          {
              ecSpec = null;
              curve = configuration.getEcImplicitlyCa().getCurve();
          }
          else
          {
              X9ECParameters          ecP = X9ECParameters.getInstance(params.getParameters());
  
              curve = ecP.getCurve();
              ellipticCurve = EC5Util.convertCurve(curve, ecP.getSeed());
  
              this.ecSpec = new ECParameterSpec(
                      ellipticCurve,
                      new ECPoint(
                              ecP.getG().getX().toBigInteger(),
                              ecP.getG().getY().toBigInteger()),
                      ecP.getN(),
                      ecP.getH().intValue());
          }
  
          DERBitString    bits = info.getPublicKeyData();
          byte[]          data = bits.getBytes();
          ASN1OctetString key = new DEROctetString(data);
  
          //
          // extra octet string - one of our old certs...
          //
          if (data[0] == 0x04 && data[1] == data.length - 2
              && (data[2] == 0x02 || data[2] == 0x03))
          {
              int qLength = new X9IntegerConverter().getByteLength(curve);
  
              if (qLength >= data.length - 3)
              {
                  try
                  {
                      key = (ASN1OctetString) ASN1Primitive.fromByteArray(data);
                  }
                  catch (IOException ex)
                  {
                      throw new IllegalArgumentException("error recovering public key");
                  }
              }
          }
          X9ECPoint derQ = new X9ECPoint(curve, key);
  
          this.q = derQ.getPoint();
      }
  
      public String getAlgorithm()
      {
          return algorithm;
      }
  
      public String getFormat()
      {
          return "X.509";
      }
  
      public byte[] getEncoded()
      {
          ASN1Encodable        params;
          SubjectPublicKeyInfo info;
  
          if (ecSpec instanceof ECNamedCurveSpec)
          {
              ASN1ObjectIdentifier curveOid = ECUtil.getNamedCurveOid(((ECNamedCurveSpec)ecSpec).getName());
              if (curveOid == null)
              {
                  curveOid = new ASN1ObjectIdentifier(((ECNamedCurveSpec)ecSpec).getName());
              }
              params = new X962Parameters(curveOid);
          }
          else if (ecSpec == null)
          {
              params = new X962Parameters(DERNull.INSTANCE);
          }
          else
          {
              ECCurve curve = EC5Util.convertCurve(ecSpec.getCurve());
  
              X9ECParameters ecP = new X9ECParameters(
                  curve,
                  EC5Util.convertPoint(curve, ecSpec.getGenerator(), withCompression),
                  ecSpec.getOrder(),
                  BigInteger.valueOf(ecSpec.getCofactor()),
                  ecSpec.getCurve().getSeed());
  
              params = new X962Parameters(ecP);
          }
  
  