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;
}
}
