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.ECFieldFp; 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; // TODO: Auto-generated Javadoc /** * The Class ECKeyEncoder. */ public class ECKeyEncoder { /** The Constant X962_UNCOMPRESSED_POINT_INDICATOR. */ private static final byte X962_UNCOMPRESSED_POINT_INDICATOR = 0x04; /** The Constant X962_ODD. */ private static final byte X962_ODD = 0x02; /** The Constant X962_EVEN. */ private static final byte X962_EVEN = 0x03; /** The Constant ENCODING_X509. */ public static final String ENCODING_X509 = "X509"; /** The Constant ENCODING_X962_UNCOMPESSED. */ public static final String ENCODING_X962_UNCOMPESSED = "X962_UNCOMPRESSED"; /** The Constant ENCODING_X962_COMPRESSED. */ public static final String ENCODING_X962_COMPRESSED = "X962_COMPRESSED"; /** * From encoded. * * @param keyBytes the encoded key * @param oid the algorithm OID of the key algorithm * @param provider the provider of the security implementation * @return the public key */ 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; //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); AlgorithmParameters parameters = AlgorithmParameters.getInstance(keyAlgName, provider); parameters.init(new ECGenParameterSpec(curveName)); ECParameterSpec ecParameters = parameters.getParameterSpec(ECParameterSpec.class); //reconstruct the uncompressed version with the curve byte[] uncompressed = decompressPubkey(keyBytes, ecParameters); //decode the uncompressed key return fromUncompressedPoint(uncompressed, ecParameters, provider); } 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, provider); } catch(Exception e) { //failed } } throw new IllegalArgumentException("public key format unknown"); } /** * Gets the encoded. * * @param key the public key * @param encoding the encoding ("X509","X962_UNCOMPRESSED","X962_COMPRESSED") * @param provider * @return the encoded key */ 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(); int fieldSize = (((ECPublicKey)key).getParams().getCurve().getField().getFieldSize() + 7) / 8; int keySizeBytes = fieldSize + 1; final byte[] compressed = new byte[keySizeBytes]; byte[] x = toUnsignedBytes(point.getAffineX()); BigInteger y = point.getAffineY(); //compression indicator if (y.testBit(0)) { compressed[0] = 0x03; } else { compressed[0] = 0x02; } System.arraycopy(x, 0, compressed, 1 + fieldSize - x.length, x.length); return compressed; } } throw new IllegalArgumentException("unknown encoding"); } /** * From uncompressed point. * * @param encoded the public key in uncompressed encoding * @param params the elliptic curve parameters * @return the EC public key * @throws Exception the exception */ private static ECPublicKey fromUncompressedPoint( final byte[] encoded, final ECParameterSpec params, Provider provider) throws Exception { int offset = 0; if (encoded[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 (encoded.length != 1 + 2 * keySizeBytes) { throw new IllegalArgumentException("Invalid uncompressedPoint encoding, not the correct size"); } final BigInteger x = new BigInteger(1, Arrays.copyOfRange(encoded, offset, offset + keySizeBytes)); offset += keySizeBytes; final BigInteger y = new BigInteger(1, Arrays.copyOfRange(encoded, offset, offset + keySizeBytes)); final ECPoint w = new ECPoint(x, y); final ECPublicKeySpec ecPublicKeySpec = new ECPublicKeySpec(w, params); final KeyFactory keyFactory = KeyFactory.getInstance("EC",provider); return (ECPublicKey) keyFactory.generatePublic(ecPublicKeySpec); } /** * To uncompressed point. * * @param publicKey the public key * @return the encoded public key */ private static byte[] toUncompressedPoint(final ECPublicKey publicKey) { final byte[] xCoordBytes = toUnsignedBytes(publicKey.getW().getAffineX()); final byte[] yCoordBytes = toUnsignedBytes(publicKey.getW().getAffineY()); int fieldSize = (publicKey.getParams().getCurve().getField().getFieldSize() + 7) / 8; int keySizeBytes = 2 * fieldSize + 1; final byte[] uncompressedPoint = new byte[keySizeBytes]; System.arraycopy(xCoordBytes, 0, uncompressedPoint, 1 + fieldSize - xCoordBytes.length, xCoordBytes.length); System.arraycopy(yCoordBytes, 0, uncompressedPoint, 1 + 2 * fieldSize - yCoordBytes.length, yCoordBytes.length); uncompressedPoint[0] = 0x04; return uncompressedPoint; } /** * Decompress public key. * * @param compressedKey the compressed public key * @param ecParameters the elliptic curve parameters * @return uncompressed encoded public key */ private static byte[] decompressPubkey(byte[] compressedKey, ECParameterSpec ecParameters ) { EllipticCurve curve = ecParameters.getCurve(); // Check array length and type indicator byte if (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) ECFieldFp ecf = (ECFieldFp) curve.getField(); BigInteger modulus = ecf.getP(); BigInteger pow = modulus.add(BigInteger.ONE).shiftRight(2); BigInteger temp = xCoord.pow(2).add(curve.getA()); temp = temp.multiply(xCoord); temp = temp.add(curve.getB()); temp = temp.modPow(pow, modulus); boolean tempIsOdd = temp.testBit(0); boolean yShouldBeOdd = compressedKey[0] == 3; if (tempIsOdd != yShouldBeOdd) { temp = temp.negate().mod(modulus); } final BigInteger yCoord = temp; final byte[] yCoordBytes = toUnsignedBytes(yCoord); int fieldSize = (curve.getField().getFieldSize() + 7) / 8; byte[] result = new byte[2 * fieldSize + 1]; System.arraycopy(compressedKey, 0,result, 1 + fieldSize - compressedKey.length, compressedKey.length); System.arraycopy(yCoordBytes, 0,result, 1 + 2 * fieldSize - yCoordBytes.length, yCoordBytes.length); // set uncompressed key indicator result[0] = 0x04; return result; } /** * To unsigned bytes. * * @param i the i * @return the unsigned bytes of the integer */ 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; } }