Back to index...

	/*
	* Copyright (c) 2006, 2014, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package sun.security.util;

	import java.io.IOException;

	import java.security.*;
	import java.security.spec.*;

	/**
	* This class implements encoding and decoding of Elliptic Curve parameters
	* as specified in RFC 3279.
	*
	* However, only named curves are currently supported.
	*
	* ASN.1 from RFC 3279 follows. Note that X9.62 (2005) has added some additional
	* options.
	*
	* <pre>
	* EcpkParameters ::= CHOICE {
	* ecParameters ECParameters,
	* namedCurve OBJECT IDENTIFIER,
	* implicitlyCA NULL }
	*
	* ECParameters ::= SEQUENCE {
	* version ECPVer, -- version is always 1
	* fieldID FieldID, -- identifies the finite field over
	* -- which the curve is defined
	* curve Curve, -- coefficients a and b of the
	* -- elliptic curve
	* base ECPoint, -- specifies the base point P
	* -- on the elliptic curve
	* order INTEGER, -- the order n of the base point
	* cofactor INTEGER OPTIONAL -- The integer h = #E(Fq)/n
	* }
	*
	* ECPVer ::= INTEGER {ecpVer1(1)}
	*
	* Curve ::= SEQUENCE {
	* a FieldElement,
	* b FieldElement,
	* seed BIT STRING OPTIONAL }
	*
	* FieldElement ::= OCTET STRING
	*
	* ECPoint ::= OCTET STRING
	* </pre>
	*
	* @since 1.6
	* @author Andreas Sterbenz
	*/
	public final class ECParameters extends AlgorithmParametersSpi {

	// used by ECPublicKeyImpl and ECPrivateKeyImpl
	public static AlgorithmParameters getAlgorithmParameters(ECParameterSpec spec)
	throws InvalidKeyException {
	try {
	AlgorithmParameters params =
	AlgorithmParameters.getInstance("EC", "SunEC");
	params.init(spec);
	return params;
	} catch (GeneralSecurityException e) {
	throw new InvalidKeyException("EC parameters error", e);
	}
	}

	/*
	* The parameters these AlgorithmParameters object represents.
	* Currently, it is always an instance of NamedCurve.
	*/
	private NamedCurve namedCurve;

	// A public constructor is required by AlgorithmParameters class.
	public ECParameters() {
	// empty
	}

	// AlgorithmParameterSpi methods

	protected void engineInit(AlgorithmParameterSpec paramSpec)
	throws InvalidParameterSpecException {

	if (paramSpec == null) {
	throw new InvalidParameterSpecException
	("paramSpec must not be null");
	}

	if (paramSpec instanceof NamedCurve) {
	namedCurve = (NamedCurve)paramSpec;
	return;
	}

	if (paramSpec instanceof ECParameterSpec) {
	namedCurve = CurveDB.lookup((ECParameterSpec)paramSpec);
	} else if (paramSpec instanceof ECGenParameterSpec) {
	String name = ((ECGenParameterSpec)paramSpec).getName();
	namedCurve = CurveDB.lookup(name);
	} else if (paramSpec instanceof ECKeySizeParameterSpec) {
	int keySize = ((ECKeySizeParameterSpec)paramSpec).getKeySize();
	namedCurve = CurveDB.lookup(keySize);
	} else {
	throw new InvalidParameterSpecException
	("Only ECParameterSpec and ECGenParameterSpec supported");
	}

	if (namedCurve == null) {
	throw new InvalidParameterSpecException(
	"Not a supported curve: " + paramSpec);
	}
	}

	protected void engineInit(byte[] params) throws IOException {
	DerValue encodedParams = new DerValue(params);
	if (encodedParams.tag == DerValue.tag_ObjectId) {
	ObjectIdentifier oid = encodedParams.getOID();
	NamedCurve spec = CurveDB.lookup(oid.toString());
	if (spec == null) {
	throw new IOException("Unknown named curve: " + oid);
	}

	namedCurve = spec;
	return;
	}

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

	// The code below is incomplete.
	// It is left as a starting point for a complete parsing implementation.

	/*
	if (encodedParams.tag != DerValue.tag_Sequence) {
	throw new IOException("Unsupported EC parameters, tag: " +
	encodedParams.tag);
	}

	encodedParams.data.reset();

	DerInputStream in = encodedParams.data;

	int version = in.getInteger();
	if (version != 1) {
	throw new IOException("Unsupported EC parameters version: " +
	version);
	}
	ECField field = parseField(in);
	EllipticCurve curve = parseCurve(in, field);
	ECPoint point = parsePoint(in, curve);

	BigInteger order = in.getBigInteger();
	int cofactor = 0;

	if (in.available() != 0) {
	cofactor = in.getInteger();
	}

	// XXX HashAlgorithm optional

	if (encodedParams.data.available() != 0) {
	throw new IOException("encoded params have " +
	encodedParams.data.available() +
	" extra bytes");
	}

	return new ECParameterSpec(curve, point, order, cofactor);
	*/
	}

	protected void engineInit(byte[] params, String decodingMethod)
	throws IOException {
	engineInit(params);
	}

	protected <T extends AlgorithmParameterSpec> T
	engineGetParameterSpec(Class<T> spec)
	throws InvalidParameterSpecException {

	if (spec.isAssignableFrom(ECParameterSpec.class)) {
	return spec.cast(namedCurve);
	}

	if (spec.isAssignableFrom(ECGenParameterSpec.class)) {
	// Ensure the name is the Object ID
	String name = namedCurve.getObjectId();
	return spec.cast(new ECGenParameterSpec(name));
	}

	if (spec.isAssignableFrom(ECKeySizeParameterSpec.class)) {
	int keySize = namedCurve.getCurve().getField().getFieldSize();
	return spec.cast(new ECKeySizeParameterSpec(keySize));
	}

	throw new InvalidParameterSpecException(
	"Only ECParameterSpec and ECGenParameterSpec supported");
	}

	protected byte[] engineGetEncoded() throws IOException {
	return namedCurve.getEncoded();
	}

	protected byte[] engineGetEncoded(String encodingMethod)
	throws IOException {
	return engineGetEncoded();
	}

	protected String engineToString() {
	if (namedCurve == null) {
	return "Not initialized";
	}

	return namedCurve.toString();
	}
	}

Back to index...