diff options
6 files changed, 610 insertions, 32 deletions
diff --git a/src/main/java/org/uic/barcode/Encoder.java b/src/main/java/org/uic/barcode/Encoder.java index 9afddce..b01ca14 100644 --- a/src/main/java/org/uic/barcode/Encoder.java +++ b/src/main/java/org/uic/barcode/Encoder.java @@ -27,6 +27,7 @@ import org.uic.barcode.staticFrame.ticketLayoutBarcode.TicketLayout; import org.uic.barcode.ticket.EncodingFormatException;
import org.uic.barcode.ticket.UicRailTicketCoder;
import org.uic.barcode.ticket.api.spec.IUicRailTicket;
+import org.uic.barcode.utils.ECKeyEncoder;
/**
@@ -278,6 +279,30 @@ public class Encoder { }
}
+ /**
+ * Sets the level 2 algorithm Is.
+ *
+ * @param level2SigningAlg the level 2 signing algorithm (OID)
+ * @param level2KeyAlg the level 2 key algorithm (OID)
+ * @param publicKey the public key of the level 2 signature
+ * @param publicKeyEncodingFormat "X509", for elliptic curve keys only: "X962_UNCOMPRESSED", "X962_COMPRESSED" constants defined in class ECKeyEncoder.
+ **/
+ public void setLevel2Algs(String level2SigningAlg, String level2KeyAlg, PublicKey publicKey, String publicKeyEncodingFormat) {
+ if (dynamicFrame != null) {
+ if (dynamicFrame.getLevel2Data() == null) {
+ dynamicFrame.setLevel2Data(new SimpleLevel2Data());
+ }
+ if (dynamicFrame.getLevel2Data().getLevel1Data() == null) {
+ dynamicFrame.getLevel2Data().setLevel1Data(new SimpleLevel1Data());
+ }
+ dynamicFrame.getLevel2Data().getLevel1Data().setLevel2SigningAlg(level2SigningAlg);
+ dynamicFrame.getLevel2Data().getLevel1Data().setLevel2KeyAlg(level2KeyAlg);
+ if (publicKey != null) {
+ dynamicFrame.getLevel2Data().getLevel1Data().setLevel2publicKey(ECKeyEncoder.getEncoded(publicKey, publicKeyEncodingFormat));
+ }
+ }
+ }
+
public void setDynamicData(IUicDynamicContent content) throws EncodingFormatException {
if (dynamicFrame != null) {
if (dynamicFrame.getLevel2Data() == null) {
diff --git a/src/main/java/org/uic/barcode/dynamicFrame/api/SimpleDynamicFrame.java b/src/main/java/org/uic/barcode/dynamicFrame/api/SimpleDynamicFrame.java index ae1b4e2..15f169b 100644 --- a/src/main/java/org/uic/barcode/dynamicFrame/api/SimpleDynamicFrame.java +++ b/src/main/java/org/uic/barcode/dynamicFrame/api/SimpleDynamicFrame.java @@ -8,8 +8,6 @@ import java.security.Provider; import java.security.PublicKey;
import java.security.Signature;
import java.security.SignatureException;
-import java.security.spec.InvalidKeySpecException;
-import java.security.spec.X509EncodedKeySpec;
import java.util.Date;
import org.uic.barcode.dynamicContent.api.DynamicContentCoder;
@@ -20,6 +18,7 @@ import org.uic.barcode.dynamicFrame.v1.DynamicFrameCoderV1; import org.uic.barcode.dynamicFrame.v2.DynamicFrameCoderV2;
import org.uic.barcode.ticket.EncodingFormatException;
import org.uic.barcode.utils.AlgorithmNameResolver;
+import org.uic.barcode.utils.ECKeyEncoder;
import org.uic.barcode.utils.SecurityUtils;
@@ -180,15 +179,12 @@ public class SimpleDynamicFrame implements IDynamicFrame { }
KeyFactory keyFactory = KeyFactory.getInstance(keyAlgName,provider);
if (keyFactory != null) {
- X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
- key = keyFactory.generatePublic(keySpec);
+ key = ECKeyEncoder.fromEncoded(keyBytes,level2KeyAlg, provider);
} else {
return Constants.LEVEL2_VALIDATION_KEY_ALG_NOT_IMPLEMENTED;
}
- } catch (InvalidKeySpecException e1) {
- return Constants.LEVEL2_VALIDATION_KEY_ALG_NOT_IMPLEMENTED;
- } catch (NoSuchAlgorithmException e1) {
+ } catch (Exception e1) {
return Constants.LEVEL2_VALIDATION_KEY_ALG_NOT_IMPLEMENTED;
}
diff --git a/src/main/java/org/uic/barcode/utils/ECKeyEncoder.java b/src/main/java/org/uic/barcode/utils/ECKeyEncoder.java new file mode 100644 index 0000000..96038d3 --- /dev/null +++ b/src/main/java/org/uic/barcode/utils/ECKeyEncoder.java @@ -0,0 +1,284 @@ +package org.uic.barcode.utils;
+
+import java.math.BigInteger;
+import java.security.AlgorithmParameters;
+import java.security.KeyFactory;
+import java.security.Provider;
+import java.security.PublicKey;
+import java.security.interfaces.ECPublicKey;
+import java.security.spec.ECGenParameterSpec;
+import java.security.spec.ECParameterSpec;
+import java.security.spec.ECPoint;
+import java.security.spec.ECPublicKeySpec;
+import java.security.spec.EllipticCurve;
+import java.security.spec.X509EncodedKeySpec;
+import java.util.Arrays;
+
+
+public class ECKeyEncoder {
+
+
+ private static final byte X962_UNCOMPRESSED_POINT_INDICATOR = 0x04;
+ private static final byte X962_ODD = 0x02;
+ private static final byte X962_EVEN = 0x03;
+
+ public static final String ENCODING_X509 = "X509";
+ public static final String ENCODING_X962_UNCOMPESSED = "X962_UNCOMPRESSED";
+ public static final String ENCODING_X962_COMPRESSED = "X962_COMPRESSED";
+
+ public static PublicKey fromEncoded (byte[] keyBytes, String oid, Provider provider) {
+
+ PublicKey key = null;
+
+
+ String keyAlgName = null;
+ try {
+ keyAlgName = AlgorithmNameResolver.getName(AlgorithmNameResolver.TYPE_KEY_GENERATOR_ALG, oid,provider);
+ } catch (Exception e1) {
+ throw new IllegalArgumentException("algorithm unknown in: " + provider.getName());
+ }
+
+ if (keyAlgName == null || keyAlgName.length() == 0) {
+ throw new IllegalArgumentException("algorithm unknown in: " + provider.getName());
+ }
+
+ //try standard X.509 encoding first
+
+ try {
+
+ X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
+
+ if (keyAlgName != null && keyAlgName.length() > 0) {
+
+ KeyFactory keyFactory = KeyFactory.getInstance(keyAlgName,provider);
+
+ key = keyFactory.generatePublic(keySpec);
+
+ }
+
+ } catch (Exception e) {
+
+ //try next option
+
+ }
+
+ if (key != null) return key;
+
+ if (keyBytes[0] == X962_UNCOMPRESSED_POINT_INDICATOR) {
+
+
+
+ }
+
+ //maybe a compressed X9.62 eliptic key
+ if (keyBytes[0] == X962_ODD || keyBytes[0] == X962_EVEN) {
+
+
+ try {
+
+ //we need to know the curve!
+ String curveName = EllipticCurveNames.getInstance().getName(oid);
+
+ //get the curve parameters
+ AlgorithmParameters parameters = AlgorithmParameters.getInstance(keyAlgName, provider);
+ parameters.init(new ECGenParameterSpec(curveName));
+ ECParameterSpec ecParameters = parameters.getParameterSpec(ECParameterSpec.class);
+ EllipticCurve curve = ecParameters.getCurve();
+
+ //reconstruct the uncompressed version with the curve
+ byte[] uncompressed = decompressPubkey(keyBytes, curve);
+
+ //decode the uncompressed key
+ return fromUncompressedPoint(uncompressed, ecParameters);
+
+ } catch (Exception e) {
+ key = null;
+ // failed
+ }
+
+
+ }
+
+ //try X962 uncompressed
+ if (keyBytes[0] == X962_UNCOMPRESSED_POINT_INDICATOR) {
+
+ try {
+ //we need to know the curve!
+ String curveName = EllipticCurveNames.getInstance().getName(oid);
+
+ //get the curve parameters
+ AlgorithmParameters parameters = AlgorithmParameters.getInstance(keyAlgName, provider);
+ parameters.init(new ECGenParameterSpec(curveName));
+ ECParameterSpec ecParameters = parameters.getParameterSpec(ECParameterSpec.class);
+
+ //decode the uncompressed key
+ return fromUncompressedPoint(keyBytes, ecParameters);
+
+ } catch(Exception e) {
+ //failed
+ }
+ }
+
+
+ throw new IllegalArgumentException("public key format unknown");
+ }
+
+
+
+ public static byte[] getEncoded(PublicKey key, String encoding){
+
+ if (encoding.equals(ENCODING_X509)) {
+ return key.getEncoded();
+ } else if (encoding.equals(ENCODING_X962_UNCOMPESSED)) {
+
+ if (key instanceof ECPublicKey) {
+
+ return toUncompressedPoint((ECPublicKey) key);
+
+ }
+
+ } else if (encoding.equals(ENCODING_X962_COMPRESSED)) {
+
+ if (key instanceof ECPublicKey) {
+
+ ECPoint point = ((ECPublicKey) key).getW();
+
+ byte[] x = toUnsignedBytes(point.getAffineX());
+
+ BigInteger y = point.getAffineY();
+
+ byte[] compressed = new byte[x.length + 1];
+
+ //compression indicator
+ if (y.testBit(0)) {
+ compressed[0] = 0x03;
+ } else {
+ compressed[0] = 0x02;
+ }
+ System.arraycopy(x, 0, compressed, 1, x.length);
+
+ return compressed;
+ }
+ }
+
+ throw new IllegalArgumentException("unknown encoding");
+
+
+ }
+
+
+ private static ECPublicKey fromUncompressedPoint(
+ final byte[] uncompressedPoint, final ECParameterSpec params)
+ throws Exception {
+
+ int offset = 0;
+ if (uncompressedPoint[offset++] != X962_UNCOMPRESSED_POINT_INDICATOR) {
+ throw new IllegalArgumentException(
+ "Invalid uncompressedPoint encoding, no uncompressed point indicator");
+ }
+
+ int keySizeBytes = (params.getOrder().bitLength() + Byte.SIZE - 1)
+ / Byte.SIZE;
+
+ if (uncompressedPoint.length != 1 + 2 * keySizeBytes) {
+ throw new IllegalArgumentException(
+ "Invalid uncompressedPoint encoding, not the correct size");
+ }
+
+ final BigInteger x = new BigInteger(1, Arrays.copyOfRange(
+ uncompressedPoint, offset, offset + keySizeBytes));
+ offset += keySizeBytes;
+ final BigInteger y = new BigInteger(1, Arrays.copyOfRange(
+ uncompressedPoint, offset, offset + keySizeBytes));
+ final ECPoint w = new ECPoint(x, y);
+ final ECPublicKeySpec ecPublicKeySpec = new ECPublicKeySpec(w, params);
+ final KeyFactory keyFactory = KeyFactory.getInstance("EC");
+ return (ECPublicKey) keyFactory.generatePublic(ecPublicKeySpec);
+ }
+
+ private static byte[] toUncompressedPoint(final ECPublicKey publicKey) {
+
+ int keySizeBytes = (publicKey.getParams().getOrder().bitLength() + Byte.SIZE - 1)
+ / Byte.SIZE;
+
+ final byte[] uncompressedPoint = new byte[1 + 2 * keySizeBytes];
+ int offset = 0;
+ uncompressedPoint[offset++] = 0x04;
+
+ final byte[] x = publicKey.getW().getAffineX().toByteArray();
+ if (x.length <= keySizeBytes) {
+ System.arraycopy(x, 0, uncompressedPoint, offset + keySizeBytes
+ - x.length, x.length);
+ } else if (x.length == keySizeBytes + 1 && x[0] == 0) {
+ System.arraycopy(x, 1, uncompressedPoint, offset, keySizeBytes);
+ } else {
+ throw new IllegalStateException("x value is too large");
+ }
+ offset += keySizeBytes;
+
+ final byte[] y = publicKey.getW().getAffineY().toByteArray();
+ if (y.length <= keySizeBytes) {
+ System.arraycopy(y, 0, uncompressedPoint, offset + keySizeBytes
+ - y.length, y.length);
+ } else if (y.length == keySizeBytes + 1 && y[0] == 0) {
+ System.arraycopy(y, 1, uncompressedPoint, offset, keySizeBytes);
+ } else {
+ throw new IllegalStateException("y value is too large");
+ }
+
+ return uncompressedPoint;
+ }
+
+ static final BigInteger MODULUS =
+ new BigInteger("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F", 16);
+
+ static final BigInteger POW = MODULUS.add(BigInteger.ONE).shiftRight(2);
+
+ // Given a 33-byte compressed public key, this returns a 65-byte uncompressed key.
+ private static byte[] decompressPubkey(byte[] compressedKey, EllipticCurve curve ) {
+
+ // Check array length and type indicator byte
+ if (compressedKey.length != 33 || compressedKey[0] != 2 && compressedKey[0] != 3)
+ throw new IllegalArgumentException();
+
+ final byte[] xCoordBytes = Arrays.copyOfRange(compressedKey, 1, compressedKey.length);
+ final BigInteger xCoord = new BigInteger(1, xCoordBytes); // Range [0, 2^256)
+
+
+ BigInteger temp = xCoord.pow(2).add(curve.getA());
+ temp = temp.multiply(xCoord);
+ temp = temp.add(curve.getB());
+ temp = temp.modPow(POW, MODULUS);
+
+ //temp = sqrtMod(temp.add(curveParamB));
+
+ boolean tempIsOdd = temp.testBit(0);
+ boolean yShouldBeOdd = compressedKey[0] == 3;
+ if (tempIsOdd != yShouldBeOdd)
+ temp = temp.negate().mod(MODULUS);
+ final BigInteger yCoord = temp;
+
+ // Copy the x coordinate into the new
+ // uncompressed key, and change the type byte
+ byte[] result = Arrays.copyOf(compressedKey, 65);
+ result[0] = 0x04;
+
+ // Carefully copy the y coordinate into uncompressed key
+ final byte[] yCoordBytes = yCoord.toByteArray();
+ for (int i = 0; i < 32 && i < yCoordBytes.length; i++)
+ result[result.length - 1 - i] = yCoordBytes[yCoordBytes.length - 1 - i];
+
+ return result;
+ }
+
+ private static byte[] toUnsignedBytes(BigInteger i) {
+ byte[] b = i.abs().toByteArray();
+ //remove top sign bit
+ if (b[0] == 0) {
+ b = Arrays.copyOfRange(b, 1, b.length);
+ }
+ return b;
+ }
+
+
+}
diff --git a/src/main/java/org/uic/barcode/utils/EllipticCurveNames.java b/src/main/java/org/uic/barcode/utils/EllipticCurveNames.java new file mode 100644 index 0000000..41353b1 --- /dev/null +++ b/src/main/java/org/uic/barcode/utils/EllipticCurveNames.java @@ -0,0 +1,67 @@ +package org.uic.barcode.utils;
+
+import java.util.HashMap;
+
+// TODO: Auto-generated Javadoc
+/**
+ * The Class ElipticCurves.
+ */
+public class EllipticCurveNames {
+
+
+ /** The oit to name. */
+ public HashMap<String, String> oitToName = new HashMap<String,String>();
+
+ /** The me. */
+ private static EllipticCurveNames me = null;
+
+
+ /**
+ * Gets the single instance of ElipticCurves.
+ *
+ * @return single instance of ElipticCurves
+ */
+ public static EllipticCurveNames getInstance() {
+
+ if (me == null) {
+ me = new EllipticCurveNames();
+
+ me.oitToName.put("1.3.132.0.15", "sect163r2");
+ me.oitToName.put("1.3.132.0.33", "secp224r1");
+ me.oitToName.put("1.3.132.0.26", "sect233k1");
+ me.oitToName.put("1.3.132.0.27", "sect233r1");
+ me.oitToName.put("1.3.132.0.16", "sect283k1");
+ me.oitToName.put("1.3.132.0.17", "sect283r1");
+ me.oitToName.put("1.3.132.0.34", "secp384r1");
+ me.oitToName.put("1.3.132.0.36", "sect409k1");
+ me.oitToName.put("1.3.132.0.37", "sect409r1");
+ me.oitToName.put("1.3.132.0.35", "secp521r1");
+ me.oitToName.put("1.3.132.0.38", "sect571k1");
+ me.oitToName.put("1.3.132.0.39", "sect571r1");
+ me.oitToName.put("1.3.132.0.10", "secp256k1");
+
+ }
+ return me;
+ }
+
+
+ /**
+ * Adds the oid to name mapping.
+ *
+ * @param oid the oid
+ * @param name the name
+ */
+ public void addOidToNameMapping(String oid, String name) {
+ oitToName.put(oid, name);
+ }
+
+ /**
+ * Gets the name.
+ *
+ * @param oid the oid
+ * @return the name
+ */
+ public String getName(String oid) {
+ return oitToName.get(oid);
+ }
+}
diff --git a/src/main/java/org/uic/barcode/utils/SecurityUtils.java b/src/main/java/org/uic/barcode/utils/SecurityUtils.java index fc6a135..5fdbda7 100644 --- a/src/main/java/org/uic/barcode/utils/SecurityUtils.java +++ b/src/main/java/org/uic/barcode/utils/SecurityUtils.java @@ -24,37 +24,16 @@ public class SecurityUtils { * @return the provider
*/
public static Provider findPublicKeyProvider(String keyAlgorithmOid, byte[] keyBytes) {
-
-
- X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
-
- String name;
- try {
- name = AlgorithmNameResolver.getAlgorithmName(AlgorithmNameResolver.TYPE_KEY_GENERATOR_ALG, keyAlgorithmOid, null);
- } catch (Exception e2) {
- return null;
- }
-
- KeyFactory keyFactory = null;
-
+
Provider[] provs = Security.getProviders();
for (Provider provider : provs) {
try {
- keyFactory = KeyFactory.getInstance(name,provider);
- } catch (NoSuchAlgorithmException e1) {
+ PublicKey key = ECKeyEncoder.fromEncoded(keyBytes, keyAlgorithmOid, provider);
+ if (key != null) return provider;
+ } catch (Exception e1) {
//try next
}
- if (keyFactory != null) {
- try {
- keyFactory.generatePublic(keySpec);
- return provider;
- } catch (Exception e) {
- provider = null;
- //try next
- }
- }
}
-
return null;
}
diff --git a/src/test/java/org/uic/barcode/test/ECKeyEncoderTest.java b/src/test/java/org/uic/barcode/test/ECKeyEncoderTest.java new file mode 100644 index 0000000..df8807e --- /dev/null +++ b/src/test/java/org/uic/barcode/test/ECKeyEncoderTest.java @@ -0,0 +1,227 @@ +package org.uic.barcode.test;
+
+import java.math.BigInteger;
+import java.security.InvalidAlgorithmParameterException;
+import java.security.KeyPairGenerator;
+import java.security.NoSuchAlgorithmException;
+import java.security.NoSuchProviderException;
+import java.security.Provider;
+import java.security.PublicKey;
+import java.security.SecureRandom;
+import java.security.Security;
+import java.security.interfaces.ECPublicKey;
+import java.security.spec.ECGenParameterSpec;
+import java.util.Arrays;
+
+import org.bouncycastle.asn1.sec.SECNamedCurves;
+import org.bouncycastle.asn1.x9.ECNamedCurveTable;
+import org.bouncycastle.asn1.x9.X9ECParameters;
+import org.bouncycastle.crypto.generators.ECKeyPairGenerator;
+import org.bouncycastle.crypto.params.ECDomainParameters;
+import org.bouncycastle.crypto.params.ECKeyGenerationParameters;
+import org.bouncycastle.jce.provider.BouncyCastleProvider;
+import org.bouncycastle.math.ec.ECCurve;
+import org.bouncycastle.math.ec.ECPoint;
+import org.bouncycastle.util.encoders.Hex;
+import org.junit.Before;
+import org.junit.Test;
+import org.uic.barcode.utils.AlgorithmNameResolver;
+import org.uic.barcode.utils.ECKeyEncoder;
+
+public class ECKeyEncoderTest {
+
+ public static Provider provider = null;
+
+ @Before public void initialize() {
+
+ provider = new BouncyCastleProvider();
+ Security.addProvider(provider);
+ }
+
+ @Test public void testEncodeCompressed() throws Exception {
+
+ for (int i = 0; i < 10; i++) {
+
+ String name = "secp256k1";
+
+ AlgorithmNameResolver.addMap(AlgorithmNameResolver.TYPE_KEY_GENERATOR_ALG, "1.3.132.0.10", "EC");
+
+ ECPublicKey key = createECPublicKey(name);
+
+ // some additional encoding tricks
+ byte[] compressedBC = getCompressed(key,name);
+ String compressedHexBC = Hex.toHexString(compressedBC);
+
+ byte[] publicKeyBytes = ECKeyEncoder.getEncoded(key, ECKeyEncoder.ENCODING_X962_COMPRESSED);
+ String compressedHex = Hex.toHexString(publicKeyBytes);
+
+ if (!compressedHexBC.equals(compressedHex)) {
+ assert(compressedHexBC.equals(compressedHex));
+ }
+
+ assert(Arrays.equals(compressedBC, publicKeyBytes));
+
+ assert(compressedHexBC.equals(compressedHex));
+ }
+ }
+
+ @Test public void testDecodeCompressed() throws Exception {
+
+ for (int i = 0; i < 10; i++) {
+
+ String name = "secp256k1";
+
+ AlgorithmNameResolver.addMap(AlgorithmNameResolver.TYPE_KEY_GENERATOR_ALG, "1.3.132.0.10", "EC");
+
+ ECPublicKey key = createECPublicKey(name);
+
+ // some additional encoding tricks
+ byte[] compressedBC = getCompressed(key,name);
+ //String compressedHex = Hex.toHexString(compressedBC);
+
+ PublicKey publicKey = ECKeyEncoder.fromEncoded(compressedBC, "1.3.132.0.10", provider);
+
+ compareKeys((ECPublicKey) publicKey, key);
+
+ }
+ }
+
+ @Test public void testEncodeUnCompressed() throws Exception {
+
+ for (int i = 0; i < 10; i++) {
+
+ String name = "secp256k1";
+
+ AlgorithmNameResolver.addMap(AlgorithmNameResolver.TYPE_KEY_GENERATOR_ALG, "1.3.132.0.10", "EC");
+
+ ECPublicKey key = createECPublicKey(name);
+
+ byte[] uncompressedBC = getUnCompressed(key,name);
+ //String uncompressedHex = Hex.toHexString(uncompressedBC);
+
+ byte[] publicKeyUnComp = ECKeyEncoder.getEncoded(key, ECKeyEncoder.ENCODING_X962_UNCOMPESSED);
+
+ assert(Arrays.equals(uncompressedBC, publicKeyUnComp));
+
+ }
+ }
+
+ @Test public void testDecodeUnCompressed() throws Exception {
+
+ for (int i = 0; i < 10; i++) {
+
+ String name = "secp256k1";
+
+ AlgorithmNameResolver.addMap(AlgorithmNameResolver.TYPE_KEY_GENERATOR_ALG, "1.3.132.0.10", "EC");
+
+ ECPublicKey key = createECPublicKey(name);
+
+ // some additional encoding tricks
+ byte[] compressedBC = getUnCompressed(key,name);
+ //String compressedHex = Hex.toHexString(compressedBC);
+
+ PublicKey publicKey = ECKeyEncoder.fromEncoded(compressedBC, "1.3.132.0.10", provider);
+
+ compareKeys((ECPublicKey) publicKey, key);
+
+ }
+ }
+
+ @Test public void testEncodeX509() throws Exception {
+
+ for (int i = 0; i < 10; i++) {
+
+ String name = "secp256k1";
+
+ AlgorithmNameResolver.addMap(AlgorithmNameResolver.TYPE_KEY_GENERATOR_ALG, "1.3.132.0.10", "EC");
+
+ ECPublicKey key = createECPublicKey(name);
+
+ byte[] publicKeyBcX509 = key.getEncoded();
+
+ byte[] publicKeyBytes = ECKeyEncoder.getEncoded(key, ECKeyEncoder.ENCODING_X509);
+ assert(Arrays.equals(publicKeyBcX509, publicKeyBytes));
+
+ }
+ }
+
+ @Test public void testDecodeX509() throws Exception {
+
+ for (int i = 0; i < 10; i++) {
+
+ String name = "secp256k1";
+
+ AlgorithmNameResolver.addMap(AlgorithmNameResolver.TYPE_KEY_GENERATOR_ALG, "1.3.132.0.10", "EC");
+
+ ECPublicKey key = createECPublicKey(name);
+
+ // some additional encoding tricks
+ byte[] compressedBC = key.getEncoded();
+ //String compressedHex = Hex.toHexString(compressedBC);
+
+ PublicKey publicKey = ECKeyEncoder.fromEncoded(compressedBC, "1.3.132.0.10", provider);
+
+ compareKeys((ECPublicKey) publicKey, key);
+
+ }
+ }
+
+
+
+
+ private ECPublicKey createECPublicKey(String name) throws NoSuchAlgorithmException, NoSuchProviderException, InvalidAlgorithmParameterException {
+ ECKeyPairGenerator gen = new ECKeyPairGenerator();
+ SecureRandom secureRandom = new SecureRandom();
+ X9ECParameters secnamecurves = SECNamedCurves.getByName(name);
+ ECDomainParameters ecParams = new ECDomainParameters(secnamecurves.getCurve(), secnamecurves.getG(),
+ secnamecurves.getN(), secnamecurves.getH());
+ ECKeyGenerationParameters keyGenParam = new ECKeyGenerationParameters(ecParams, secureRandom);
+ gen.init(keyGenParam);
+
+
+ KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC", "BC");
+ ECGenParameterSpec ecGenParameterSpec = new ECGenParameterSpec("secp256k1");
+ kpg.initialize(ecGenParameterSpec);
+ ECPublicKey key = (ECPublicKey) kpg.generateKeyPair().getPublic();
+ return key;
+ }
+
+ private byte[] getCompressed(ECPublicKey key, String name) {
+
+ byte[] x = key.getW().getAffineX().toByteArray();
+ byte[] y = key.getW().getAffineY().toByteArray();
+
+ // assumes that x and y are (unsigned) big endian encoded
+ BigInteger xbi = new BigInteger(1, x);
+ BigInteger ybi = new BigInteger(1, y);
+ X9ECParameters x9 = ECNamedCurveTable.getByName(name);
+ ECCurve curve = x9.getCurve();
+ ECPoint point = curve.createPoint(xbi, ybi);
+
+ return point.getEncoded(true);
+ }
+
+ private byte[] getUnCompressed(ECPublicKey key, String name) {
+
+ byte[] x = key.getW().getAffineX().toByteArray();
+ byte[] y = key.getW().getAffineY().toByteArray();
+
+ // assumes that x and y are (unsigned) big endian encoded
+ BigInteger xbi = new BigInteger(1, x);
+ BigInteger ybi = new BigInteger(1, y);
+ X9ECParameters x9 = ECNamedCurveTable.getByName(name);
+ ECCurve curve = x9.getCurve();
+ ECPoint point = curve.createPoint(xbi, ybi);
+
+ return point.getEncoded(false);
+
+ }
+
+ private void compareKeys(ECPublicKey key1, ECPublicKey key2) {
+
+ assert(key1.getW().getAffineX().equals(key2.getW().getAffineX()) );
+ assert(key1.getW().getAffineY().equals(key2.getW().getAffineY()) );
+
+ }
+
+}
|