29 import java.math.BigInteger;

    80     public ECParameters() {

    81         // empty

    82     }

    83 

    84     // Used by SunPKCS11 and SunJSSE.

    85     public static ECPoint decodePoint(byte[] data, EllipticCurve curve)

    86             throws IOException {

    87         if ((data.length == 0) || (data[0] != 4)) {

    88             throw new IOException("Only uncompressed point format supported");

    89         }

    90         // Per ANSI X9.62, an encoded point is a 1 byte type followed by

    91         // ceiling(log base 2 field-size / 8) bytes of x and the same of y.

    92         int n = (data.length - 1) / 2;

    93         if (n != ((curve.getField().getFieldSize() + 7 ) >> 3)) {

    94             throw new IOException("Point does not match field size");

    95         }

    96         byte[] xb = new byte[n];

    97         byte[] yb = new byte[n];

    98         System.arraycopy(data, 1, xb, 0, n);

    99         System.arraycopy(data, n + 1, yb, 0, n);

   100         return new ECPoint(new BigInteger(1, xb), new BigInteger(1, yb));

   101     }

   102 

   103     // Used by SunPKCS11 and SunJSSE.

   104     public static byte[] encodePoint(ECPoint point, EllipticCurve curve) {

   105         // get field size in bytes (rounding up)

   106         int n = (curve.getField().getFieldSize() + 7) >> 3;

   107         byte[] xb = trimZeroes(point.getAffineX().toByteArray());

   108         byte[] yb = trimZeroes(point.getAffineY().toByteArray());

   109         if ((xb.length > n) || (yb.length > n)) {

   110             throw new RuntimeException

   111                 ("Point coordinates do not match field size");

   112         }

   113         byte[] b = new byte[1 + (n << 1)];

   114         b[0] = 4; // uncompressed

   115         System.arraycopy(xb, 0, b, n - xb.length + 1, xb.length);

   116         System.arraycopy(yb, 0, b, b.length - yb.length, yb.length);

   117         return b;

   118     }

   119 

   120     // Copied from the SunPKCS11 code - should be moved to a common location.

   121     // trim leading (most significant) zeroes from the result

   122     static byte[] trimZeroes(byte[] b) {

   123         int i = 0;

   124         while ((i < b.length - 1) && (b[i] == 0)) {

   125             i++;

   126         }

   127         if (i == 0) {

   128             return b;

   129         }

   130         byte[] t = new byte[b.length - i];

   131         System.arraycopy(b, i, t, 0, t.length);

   132         return t;

   133     }

   134 

   135     // Convert the given ECParameterSpec object to a NamedCurve object.

   136     // If params does not represent a known named curve, return null.

   137     // Used by SunPKCS11.

   138     public static NamedCurve getNamedCurve(ECParameterSpec params) {

   139         if ((params instanceof NamedCurve) || (params == null)) {

   140             return (NamedCurve)params;

   141         }

   142         // This is a hack to allow SunJSSE to work with 3rd party crypto

   143         // providers for ECC and not just SunPKCS11.

   144         // This can go away once we decide how to expose curve names in the

   145         // public API.

   146         // Note that it assumes that the 3rd party provider encodes named

   147         // curves using the short form, not explicitly. If it did that, then

   148         // the SunJSSE TLS ECC extensions are wrong, which could lead to

   149         // interoperability problems.

   150         int fieldSize = params.getCurve().getField().getFieldSize();

   151         for (ECParameterSpec namedCurve : NamedCurve.knownECParameterSpecs()) {

   152             // ECParameterSpec does not define equals, so check all the

   153             // components ourselves.

   154             // Quick field size check first

   155             if (namedCurve.getCurve().getField().getFieldSize() != fieldSize) {

   156                 continue;

   157             }

   158             if (namedCurve.getCurve().equals(params.getCurve()) == false) {

   159                 continue;

   160             }

   161             if (namedCurve.getGenerator().equals(params.getGenerator()) == false) {

   162                 continue;

   163             }

   164             if (namedCurve.getOrder().equals(params.getOrder()) == false) {

   165                 continue;

   166             }

   167             if (namedCurve.getCofactor() != params.getCofactor()) {

   168                 continue;

   169             }

   170             // everything matches our named curve, return it

   171             return (NamedCurve)namedCurve;

   172         }

   173         // no match found

   174         return null;

   175     }

   176 

   177     // Used by SunJSSE.

   178     public static String getCurveName(ECParameterSpec params) {

   179         NamedCurve curve = getNamedCurve(params);

   180         return (curve == null) ? null : curve.getObjectIdentifier().toString();

   181     }

   182 

   183     // Used by SunPKCS11.

   184     public static byte[] encodeParameters(ECParameterSpec params) {

   185         NamedCurve curve = getNamedCurve(params);

   186         if (curve == null) {

   187             throw new RuntimeException("Not a known named curve: " + params);

   188         }

   189         return curve.getEncoded();

   190     }

   191 

   192     // Used by SunPKCS11.

   193     public static ECParameterSpec decodeParameters(byte[] params) throws IOException {

   194         DerValue encodedParams = new DerValue(params);

   195         if (encodedParams.tag == DerValue.tag_ObjectId) {

   196             ObjectIdentifier oid = encodedParams.getOID();

   197             ECParameterSpec spec = NamedCurve.getECParameterSpec(oid);

   198             if (spec == null) {

   199                 throw new IOException("Unknown named curve: " + oid);

   200             }

   201             return spec;

   202         }

   203 

   204         throw new IOException("Only named ECParameters supported");

   205 

   206         // The code below is incomplete.

   207         // It is left as a starting point for a complete parsing implementation.

   208 

   209 /*

   210         if (encodedParams.tag != DerValue.tag_Sequence) {

   211             throw new IOException("Unsupported EC parameters, tag: " + encodedParams.tag);

   212         }

   213 

   214         encodedParams.data.reset();

   215 

   216         DerInputStream in = encodedParams.data;

   217 

   218         int version = in.getInteger();

   219         if (version != 1) {

   220             throw new IOException("Unsupported EC parameters version: " + version);

   221         }

   222         ECField field = parseField(in);

   223         EllipticCurve curve = parseCurve(in, field);

   224         ECPoint point = parsePoint(in, curve);

   225 

   226         BigInteger order = in.getBigInteger();

   227         int cofactor = 0;

   228 

   229         if (in.available() != 0) {

   230             cofactor = in.getInteger();

   231         }

   232 

   233         // XXX HashAlgorithm optional

   234 

   235         if (encodedParams.data.available() != 0) {

   236             throw new IOException("encoded params have " +

   237                                   encodedParams.data.available() +

   238                                   " extra bytes");

   239         }

   240 

   241         return new ECParameterSpec(curve, point, order, cofactor);

   242 */

   243     }

   244 

   245 /*

   246     private static final ObjectIdentifier fieldTypePrime =

   247         ObjectIdentifier.newInternal(new int[] {1, 2, 840, 10045, 1, 1});

   248 

   249     private static final ObjectIdentifier fieldTypeChar2 =

   250         ObjectIdentifier.newInternal(new int[] {1, 2, 840, 10045, 1, 2});

   251 

   252     private static ECField parseField(DerInputStream in) throws IOException {

   253         DerValue v = in.getDerValue();

   254         ObjectIdentifier oid = v.data.getOID();

   255         if (oid.equals(fieldTypePrime) == false) {

   256             throw new IOException("Only prime fields supported: " + oid);

   257         }

   258         BigInteger fieldSize = v.data.getBigInteger();

   259         return new ECFieldFp(fieldSize);

   260     }

   261 

   262     private static EllipticCurve parseCurve(DerInputStream in, ECField field)

   263             throws IOException {

   264         DerValue v = in.getDerValue();

   265         byte[] ab = v.data.getOctetString();

   266         byte[] bb = v.data.getOctetString();

   267         return new EllipticCurve(field, new BigInteger(1, ab), new BigInteger(1, bb));

   268     }

   269 

   270     private static ECPoint parsePoint(DerInputStream in, EllipticCurve curve)

   271             throws IOException {

   272         byte[] data = in.getOctetString();

   273         return decodePoint(data, curve);

   274     }

   275 */

   276 

   291 

   292     // The parameters these AlgorithmParameters object represents.

   293     // Currently, it is always an instance of NamedCurve.

   294     private ECParameterSpec paramSpec;