BigInteger bigX = new BigInteger(1, x); BigInteger bigY = new BigInteger(1, y); ECPoint p = new ECPoint(bigX, bigY); ECPublicKeySpec publicKeySpec = new ECPublicKeySpec(p, ecCurveSpec); KeyFactory keyFactory = KeyFactory.getInstance("ECDSA"); return keyFactory.generatePublic(publicKeySpec); } catch (Exception ex) { throw new GeneralSecurityException(ex);
final BigInteger x = new BigInteger(1, Base64.getUrlDecoder().decode(json.getString("x"))); final BigInteger y = new BigInteger(1, Base64.getUrlDecoder().decode(json.getString("y"))); publicKey = KeyFactory.getInstance("EC").generatePublic(new ECPublicKeySpec(new ECPoint(x, y), parameters.getParameterSpec(ECParameterSpec.class))); final BigInteger x = new BigInteger(1, Base64.getUrlDecoder().decode(json.getString("x"))); final BigInteger y = new BigInteger(1, Base64.getUrlDecoder().decode(json.getString("y"))); final BigInteger d = new BigInteger(1, Base64.getUrlDecoder().decode(json.getString("d"))); privateKey = KeyFactory.getInstance("EC").generatePrivate(new ECPrivateKeySpec(d, parameters.getParameterSpec(ECParameterSpec.class)));
kpg.initialize(ecGenParameterSpec); ECPublicKey key = (ECPublicKey) kpg.generateKeyPair().getPublic(); byte[] x = key.getW().getAffineX().toByteArray(); byte[] y = key.getW().getAffineY().toByteArray(); KeyFactory eckf = KeyFactory.getInstance("EC"); ECPoint point = new ECPoint(new BigInteger(1, x), new BigInteger(1, y)); ECNamedCurveParameterSpec parameterSpec = ECNamedCurveTable.getParameterSpec(name); ECParameterSpec spec = new ECNamedCurveSpec(name, parameterSpec.getCurve(), parameterSpec.getG(), parameterSpec.getN(), parameterSpec.getH(), parameterSpec.getSeed()); ECPublicKey ecPublicKey = (ECPublicKey) eckf.generatePublic(new ECPublicKeySpec(point, spec)); System.out.println(ecPublicKey.getClass().getName());
if ((version.compareTo(BigInteger.ONE) != 0)) { throw new IOException("Unexpected version number in EC private key: " + version); BigInteger s = new BigInteger(1, privateBytes); byte[] publicBytesSlice = new byte[publicBytes.length - 1]; System.arraycopy(publicBytes, 1, publicBytesSlice, 0, publicBytesSlice.length); ECPoint w = ECDSAKeyAlgorithm.decodePoint(publicBytesSlice, ecParameterSpec.getCurve()); ECPrivateKeySpec privSpec = new ECPrivateKeySpec(s, ecParameterSpec); ECPublicKeySpec pubSpec = new ECPublicKeySpec(w, ecParameterSpec); KeyFactory factory = KeyFactory.getInstance("EC"); PublicKey ecPublicKey = factory.generatePublic(pubSpec); PrivateKey ecPrivateKey = factory.generatePrivate(privSpec); return new KeyPair(ecPublicKey, ecPrivateKey); } catch (GeneralSecurityException ex) {
@Override public void computeK(byte[] f) throws GeneralSecurityException { KeyFactory keyFactory = SecurityUtils.getKeyFactory("EC"); ECPublicKeySpec keySpec = new ECPublicKeySpec(getDecoded(f, ecParameterSpec.getCurve()), ecParameterSpec); PublicKey yourPubKey = keyFactory.generatePublic(keySpec); agreement.doPhase(yourPubKey, true); setK(new BigInteger(1, agreement.generateSecret())); }
EllipticCurve curve = new EllipticCurve(field, ecSpec.getCurve().getA().toBigInteger(), ecSpec.getCurve().getB().toBigInteger()); ECPoint pointG = new ECPoint(ecSpec.getG().getXCoord().toBigInteger(), ecSpec.getG().getYCoord().toBigInteger()); ECParameterSpec spec = new ECParameterSpec(curve, pointG, ecSpec.getN(), ecSpec.getH().intValue()); KeyPairGenerator g = KeyPairGenerator.getInstance(KEY_PAIR_GENERATOR_TYPE); g.initialize(spec, new SecureRandom()); KeyPair keysPair = g.generateKeyPair(); ECPrivateKeySpec ecPrivSpec = new ECPrivateKeySpec(((ECPrivateKey) keysPair.getPrivate()).getS(), spec); ECPublicKeySpec ecPublicSpec = new ECPublicKeySpec(((ECPublicKey) keysPair.getPublic()).getW(), spec); KeyFactory kf = KeyFactory.getInstance(KEY_FACTORY_TYPE); PrivateKey privateKey = kf.generatePrivate(ecPrivSpec); PublicKey publicKey = kf.generatePublic(ecPublicSpec); BigInteger serialNumber = BigInteger.valueOf(randomNumber >= 0 ? randomNumber : randomNumber * -1); Date notBefore = new Date(System.currentTimeMillis() - 1000L * 60 * 60 * 24 * 30); Date notAfter = new Date(System.currentTimeMillis() + (1000L * 60 * 60 * 24 * 365 * 10));
Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider()); ECNamedCurveParameterSpec spec = ECNamedCurveTable.getParameterSpec("secp192r1"); ECPrivateKeySpec ecPrivateKeySpec = new ECPrivateKeySpec(new BigInteger(1, privateKeyBytes), spec); ECNamedCurveSpec params = new ECNamedCurveSpec("secp192r1", spec.getCurve(), spec.getG(), spec.getN()); java.security.spec.ECPoint w = new java.security.spec.ECPoint(new BigInteger(1, Arrays.copyOfRange(publicKeyBytes, 0, 24)), new BigInteger(1, Arrays.copyOfRange(publicKeyBytes, 24, 48))); PublicKey publicKey = factory.generatePublic(new java.security.spec.ECPublicKeySpec(w, params));
new ECFieldFp(new BigInteger("883423532389192164791648750360308885314476597252960362792450860609699839")), // q new BigInteger("7fffffffffffffffffffffff7fffffffffff8000000000007ffffffffffc", 16), // a new BigInteger("6b016c3bdcf18941d0d654921475ca71a9db2fb27d1d37796185c2942c0a", 16)); // b ECParameterSpec spec = new ECParameterSpec( curve, 1); // h ECPrivateKeySpec priKey = new ECPrivateKeySpec( new BigInteger("876300101507107567501066130761671078357010671067781776716671676178726717"), // d spec); ECPublicKeySpec pubKey = new ECPublicKeySpec( ECPointUtil.decodePoint(curve, Hex.decode("025b6dc53bc61a2548ffb0f671472de6c9521a9d2d2534e65abfcbd5fe0c70")), // Q spec);
@Override KeyPair generateKeyPair(TypesReader tr) throws GeneralSecurityException, IOException { String curveName = tr.readString(); if (!curveName.equals(this.curveName)) { throw new IOException("Incorrect curve name: " + curveName); } byte[] groupBytes = tr.readByteString(); BigInteger privateKey = tr.readMPINT(); ECPoint group = decodePoint(groupBytes, ecParameterSpec.getCurve()); if (null == group) { throw new IOException("Invalid ECDSA group"); } KeySpec keySpec = new ECPublicKeySpec(group, ecParameterSpec); ECPrivateKeySpec privateKeySpec = new ECPrivateKeySpec(privateKey, ecParameterSpec); KeyFactory kf = KeyFactory.getInstance("EC"); return new KeyPair(kf.generatePublic(keySpec), kf.generatePrivate(privateKeySpec)); } }
ECPoint g = spec.getGenerator(); ECPoint w = ECUtil.scalarMult(g, s, curve); ECPublicKeySpec ecks = new ECPublicKeySpec(w, ecpriv.getParams()); KeyFactory eckf = KeyFactory.getInstance("EC"); ECPublicKey ecpub = (ECPublicKey) eckf.generatePublic(ecks); return SigUtil.fromJavaKey(ecpub, type); BigInteger exp = ((RSAKeyGenParameterSpec)type.getParams()).getPublicExponent(); RSAPublicKeySpec rsaks = new RSAPublicKeySpec(rsapriv.getModulus(), exp); KeyFactory rsakf = KeyFactory.getInstance("RSA"); RSAPublicKey rsapub = (RSAPublicKey) rsakf.generatePublic(rsaks); return SigUtil.fromJavaKey(rsapub, type);
// generate bogus keypair(!) with named-curve params KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC"); ECGenParameterSpec gps = new ECGenParameterSpec ("secp256r1"); // NIST P-256 kpg.initialize(gps); KeyPair apair = kpg.generateKeyPair(); ECPublicKey apub = (ECPublicKey)apair.getPublic(); ECParameterSpec aspec = apub.getParams(); // could serialize aspec for later use (in compatible JRE) // // for test only reuse bogus pubkey, for real substitute values ECPoint apoint = apub.getW(); BigInteger x = apoint.getAffineX(), y = apoint.getAffineY(); // construct point plus params to pubkey ECPoint bpoint = new ECPoint (x,y); ECPublicKeySpec bpubs = new ECPublicKeySpec (bpoint, aspec); KeyFactory kfa = KeyFactory.getInstance ("EC"); ECPublicKey bpub = (ECPublicKey) kfa.generatePublic(bpubs); // // for test sign with original key, verify with reconstructed key Signature sig = Signature.getInstance ("SHA256withECDSA"); byte [] data = "test".getBytes(); sig.initSign(apair.getPrivate()); sig.update (data); byte[] dsig = sig.sign(); sig.initVerify(bpub); sig.update(data); System.out.println (sig.verify(dsig));
/** * Called by the server. Extracts the client's public key from the encoded * point and then runs the specified key agreement algorithm (ECDH) to * generate the premaster secret. * * @param encodedPoint * the client's public key (encoded) * @return the premaster secret */ public SecretKey getSecret(byte[] encodedPoint) { SecretKey secretKey = null; try { // extract public key ECParameterSpec params = publicKey.getParams(); ECPoint point = decodePoint(encodedPoint, params.getCurve()); KeyFactory keyFactory = KeyFactory.getInstance(KEYPAIR_GENERATOR_ALGORITHM); ECPublicKeySpec keySpec = new ECPublicKeySpec(point, params); PublicKey peerPublicKey = keyFactory.generatePublic(keySpec); secretKey = getSecret(peerPublicKey); } catch (Exception e) { LOGGER.log(Level.SEVERE,"Could not generate the premaster secret.",e); } return secretKey; }
private static PublicKey toPublicKey(KeyFactory kf, ECPoint point, ECParameterSpec keySpec) { try { return kf.generatePublic(new ECPublicKeySpec(point, keySpec)); } catch (InvalidKeySpecException e) { throw new JwtException("Failed to generate EC public key", e); } }
public ECPublicKey publicKey(BigInteger x, BigInteger y, ECParameterSpec spec) throws JoseException { ECPoint w = new ECPoint(x, y); ECPublicKeySpec ecPublicKeySpec = new ECPublicKeySpec(w, spec); try { PublicKey publicKey = getKeyFactory().generatePublic(ecPublicKeySpec); return (ECPublicKey) publicKey; } catch (InvalidKeySpecException e) { throw new JoseException("Invalid key spec: " + e, e); } }
return (T) new ECPublicKeySpec(ecKey.getW(), ecKey.getParams()); } else if (key instanceof PublicKey && ECPublicKeySpec.class.isAssignableFrom(keySpec)) { final byte[] encoded = key.getEncoded(); return (T) new ECPublicKeySpec(ecKey.getW(), ecKey.getParams()); } else if (key instanceof ECPrivateKey && ECPrivateKeySpec.class.isAssignableFrom(keySpec)) { ECPrivateKey ecKey = (ECPrivateKey) key; return (T) new ECPrivateKeySpec(ecKey.getS(), ecKey.getParams()); } else if (key instanceof PrivateKey && ECPrivateKeySpec.class.isAssignableFrom(keySpec)) { final byte[] encoded = key.getEncoded(); return (T) new ECPrivateKeySpec(ecKey.getS(), ecKey.getParams()); } else if (key instanceof PrivateKey && PKCS8EncodedKeySpec.class.isAssignableFrom(keySpec)) {
@Override public ECPublicKey clonePublicKey(ECPublicKey key) throws GeneralSecurityException { if (!SecurityUtils.isECCSupported()) { throw new NoSuchProviderException("ECC not supported"); } if (key == null) { return null; } ECParameterSpec params = key.getParams(); if (params == null) { throw new InvalidKeyException("Missing parameters in key"); } return generatePublicKey(new ECPublicKeySpec(key.getW(), params)); }
ECParameterSpec ecParameters = ...; BigInteger x = ...; BigInteger y = ...; ECPoint ecPoint = new ECPoint(x, y); ECPublicKeySpec keySpec = new ECPublicKeySpec(ecPoint, ecParameters);
ECCurves curve = ECCurves.fromCurveParameters(prvSpec.getParams()); if (curve == null) { throw new StreamCorruptedException("Unknown curve"); ECPublicKeySpec pubSpec = new ECPublicKeySpec(w, prvSpec.getParams()); return new SimpleImmutableEntry<>(pubSpec, prvSpec);
final BigInteger x = new BigInteger(1, Base64.getUrlDecoder().decode(json.getString("x"))); final BigInteger y = new BigInteger(1, Base64.getUrlDecoder().decode(json.getString("y"))); publicKey = KeyFactory.getInstance("EC").generatePublic(new ECPublicKeySpec(new ECPoint(x, y), parameters.getParameterSpec(ECParameterSpec.class))); final BigInteger x = new BigInteger(1, Base64.getUrlDecoder().decode(json.getString("x"))); final BigInteger y = new BigInteger(1, Base64.getUrlDecoder().decode(json.getString("y"))); final BigInteger d = new BigInteger(1, Base64.getUrlDecoder().decode(json.getString("d"))); privateKey = KeyFactory.getInstance("EC").generatePrivate(new ECPrivateKeySpec(d, parameters.getParameterSpec(ECParameterSpec.class)));