public static ECKeyPair create(KeyPair keyPair) { BCECPrivateKey privateKey = (BCECPrivateKey) keyPair.getPrivate(); BCECPublicKey publicKey = (BCECPublicKey) keyPair.getPublic(); BigInteger privateKeyValue = privateKey.getD(); // Ethereum does not use encoded public keys like bitcoin - see // https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm for details // Additionally, as the first bit is a constant prefix (0x04) we ignore this value byte[] publicKeyBytes = publicKey.getQ().getEncoded(false); BigInteger publicKeyValue = new BigInteger(1, Arrays.copyOfRange(publicKeyBytes, 1, publicKeyBytes.length)); return new ECKeyPair(privateKeyValue, publicKeyValue); }
public byte[] serializePublicKey() { ByteArrayOutputStream bs = new ByteArrayOutputStream(); BCECPublicKey pub = (BCECPublicKey) publicKey; try { switch (this.keyType) { case ECDSA: //bs.write(this.keyType.getLabel()); //bs.write(Curve.valueOf(pub.getParameters().getCurve()).getLabel()); bs.write(pub.getQ().getEncoded(true)); break; case SM2: bs.write(this.keyType.getLabel()); bs.write(Curve.valueOf(pub.getParameters().getCurve()).getLabel()); bs.write(pub.getQ().getEncoded(true)); break; default: // Should not reach here throw new Exception(ErrorCode.UnknownKeyType); } } catch (Exception e) { // Should not reach here e.printStackTrace(); return null; } return bs.toByteArray(); }
/** * 将ECC公钥对象转换为X509标准的字节流 * * @param pubKey * @return */ public static byte[] convertECPublicKeyToX509(ECPublicKeyParameters pubKey) { ECDomainParameters domainParams = pubKey.getParameters(); ECParameterSpec spec = new ECParameterSpec(domainParams.getCurve(), domainParams.getG(), domainParams.getN(), domainParams.getH()); BCECPublicKey publicKey = new BCECPublicKey(ALGO_NAME_EC, pubKey, spec, BouncyCastleProvider.CONFIGURATION); return publicKey.getEncoded(); }
protected Key engineTranslateKey( Key key) throws InvalidKeyException { if (key instanceof ECPublicKey) { return new BCECPublicKey((ECPublicKey)key, configuration); } else if (key instanceof ECPrivateKey) { return new BCECPrivateKey((ECPrivateKey)key, configuration); } throw new InvalidKeyException("key type unknown"); }
private void writeObject( ObjectOutputStream out) throws IOException { out.defaultWriteObject(); out.writeObject(this.getEncoded()); } }
public byte[] serializePublicKey() { ByteArrayOutputStream bs = new ByteArrayOutputStream(); BCECPublicKey pub = (BCECPublicKey) publicKey; try { switch (this.keyType) { case ECDSA: //bs.write(this.keyType.getLabel()); //bs.write(Curve.valueOf(pub.getParameters().getCurve()).getLabel()); bs.write(pub.getQ().getEncoded(true)); break; case SM2: bs.write(this.keyType.getLabel()); bs.write(Curve.valueOf(pub.getParameters().getCurve()).getLabel()); bs.write(pub.getQ().getEncoded(true)); break; default: // Should not reach here throw new Exception(ErrorCode.UnknownKeyType); } } catch (Exception e) { // Should not reach here e.printStackTrace(); return null; } return bs.toByteArray(); }
public PublicKey generatePublic(SubjectPublicKeyInfo keyInfo) throws IOException { ASN1ObjectIdentifier algOid = keyInfo.getAlgorithm().getAlgorithm(); if (algOid.equals(X9ObjectIdentifiers.id_ecPublicKey)) { return new BCECPublicKey(algorithm, keyInfo, configuration); } else { throw new IOException("algorithm identifier " + algOid + " in key not recognised"); } }
private DERBitString getPublicKeyDetails(BCECPublicKey pub) { try { SubjectPublicKeyInfo info = SubjectPublicKeyInfo.getInstance(ASN1Primitive.fromByteArray(pub.getEncoded())); return info.getPublicKeyData(); } catch (IOException e) { // should never happen return null; } }
ecParam.getH(), ecParam.getSeed()); KeyFactory keyFactory = KeyFactory.getInstance(ECDSA, BouncyCastleProvider.PROVIDER_NAME); ECPublicKeySpec keySpec = new ECPublicKeySpec(((BCECPublicKey) publicKey).getQ(), ecSpec); publicKey = (PublicKey) keyFactory.generatePublic(keySpec);
public static ECPublicKeyParameters convertPublicKeyToParameters(BCECPublicKey ecPubKey) { ECParameterSpec parameterSpec = ecPubKey.getParameters(); ECDomainParameters domainParameters = new ECDomainParameters(parameterSpec.getCurve(), parameterSpec.getG(), parameterSpec.getN(), parameterSpec.getH()); return new ECPublicKeyParameters(ecPubKey.getQ(), domainParameters); }
public static BCECPublicKey getBCECPublicKey(X509Certificate sm2Cert) { ECPublicKey pubKey = (ECPublicKey) sm2Cert.getPublicKey(); ECPoint q = pubKey.getQ(); ECParameterSpec parameterSpec = new ECParameterSpec(SM2Util.CURVE, SM2Util.G_POINT, SM2Util.SM2_ECC_N, SM2Util.SM2_ECC_H); ECPublicKeySpec pubKeySpec = new ECPublicKeySpec(q, parameterSpec); return new BCECPublicKey(pubKey.getAlgorithm(), pubKeySpec, BouncyCastleProvider.CONFIGURATION); }
@Test public void valuesFromGenerator() throws Exception { String dataForSigningStr = "BD6OAA=="; byte[] dataForSigning = Base64.decodeBase64(dataForSigningStr); logger.info("dataForSigning length : " + dataForSigning.length); KeyPair keyPair = KeyCodec.getKeyPair(); BCECPrivateKey priv = (BCECPrivateKey) keyPair.getPrivate(); BCECPublicKey pub = (BCECPublicKey) keyPair.getPublic(); byte[] pubByte = pub.getEncoded(); byte[] privByte = priv.getEncoded(); pub = (BCECPublicKey) KeyCodec.getPubKey(pubByte); priv = (BCECPrivateKey) KeyCodec.getPrivKey(privByte); logger.info("pubByte : " + pubByte.length + " privByte : " + privByte.length); BigInteger[] signatureGen = NamedCurve.signAndFromatToRS(priv, dataForSigning); logger.info("Signature : " + signatureGen); byte[] signatureGenAsn1 = Asn1.getEncoded(signatureGen); logger.info("signatureGenAsn1 length : " + signatureGenAsn1.length + " = " + Base64.encodeBase64URLSafeString(signatureGenAsn1)); byte[] r = signatureGen[0].toByteArray(); byte[] s = signatureGen[1].toByteArray(); logger.info("s length : " + s.length + " r length : " + r.length); String signatureStr = "PAM5wG8-yVfZtE3LhK8WEDCEQCgFIZSK2AxQ0KGBRIzGyzcre6R6SrWlobsW_W_mYGYMJlU-3Y0JOeNTGuNOng=="; byte[] signature = Base64.decodeBase64(signatureStr); logger.info("Signature length : " + signature.length); signatureGen = Asn1.decodeToBigIntegerArray(signatureGenAsn1); assertTrue(NamedCurve.verify(KeyCodec.getKeyAsRawBytes(pub), dataForSigning, signatureGen)); }
/** * 编码压缩EC公钥(基于BouncyCastle)<br> * 见:https://www.cnblogs.com/xinzhao/p/8963724.html * * @param publicKey {@link PublicKey},必须为org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey * @return 压缩得到的X * @since 4.4.4 */ public static byte[] encodeECPublicKey(PublicKey publicKey) { return ((org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey) publicKey).getQ().getEncoded(true); }
ECParameterSpec sc = bcPk.getParameters(); try new ECPublicKeyParameters(bcPk.getQ(), new ECDomainParameters(sc.getCurve(), sc.getG(), sc.getN(), sc.getH(), sc.getSeed()))));
public KeyPair generateKeyPair() { if (!initialised) { initialize(strength, new SecureRandom()); } AsymmetricCipherKeyPair pair = engine.generateKeyPair(); ECPublicKeyParameters pub = (ECPublicKeyParameters)pair.getPublic(); ECPrivateKeyParameters priv = (ECPrivateKeyParameters)pair.getPrivate(); if (ecParams instanceof ECParameterSpec) { ECParameterSpec p = (ECParameterSpec)ecParams; BCECPublicKey pubKey = new BCECPublicKey(algorithm, pub, p, configuration); return new KeyPair(pubKey, new BCECPrivateKey(algorithm, priv, pubKey, p, configuration)); } else if (ecParams == null) { return new KeyPair(new BCECPublicKey(algorithm, pub, configuration), new BCECPrivateKey(algorithm, priv, configuration)); } else { java.security.spec.ECParameterSpec p = (java.security.spec.ECParameterSpec)ecParams; BCECPublicKey pubKey = new BCECPublicKey(algorithm, pub, p, configuration); return new KeyPair(pubKey, new BCECPrivateKey(algorithm, priv, pubKey, p, configuration)); } }
/** * 只获取公钥里的XY分量,64字节 * * @param publicKey * @return */ public static byte[] getRawPublicKey(BCECPublicKey publicKey) { byte[] src65 = publicKey.getQ().getEncoded(false); byte[] rawXY = new byte[CURVE_LEN * 2];//SM2的话这里应该是64字节 System.arraycopy(src65, 1, rawXY, 0, rawXY.length); return rawXY; }
@Override public PublicKey deserializePublicKey(String keyString) { final ECPoint q = ecSpec.getCurve().decodePoint(Base64.getDecoder().decode(keyString)); ECPublicKeyParameters keyParams = new ECPublicKeyParameters( q, new ECDomainParameters(ecSpec.getCurve(), ecSpec.getG(), ecSpec.getN(), ecSpec.getH()) ); return new BCECPublicKey("ECDSA", keyParams, ecSpec, BouncyCastleProvider.CONFIGURATION); }
public static ECKeyPair create(KeyPair keyPair) { BCECPrivateKey privateKey = (BCECPrivateKey) keyPair.getPrivate(); BCECPublicKey publicKey = (BCECPublicKey) keyPair.getPublic(); BigInteger privateKeyValue = privateKey.getD(); // Ethereum does not use encoded public keys like bitcoin - see // https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm for details // Additionally, as the first bit is a constant prefix (0x04) we ignore this value byte[] publicKeyBytes = publicKey.getQ().getEncoded(false); BigInteger publicKeyValue = new BigInteger(1, Arrays.copyOfRange(publicKeyBytes, 1, publicKeyBytes.length)); return new ECKeyPair(privateKeyValue, publicKeyValue); }
return new BCECPublicKey(algorithm, (ECPublicKeySpec)keySpec, configuration); return new BCECPublicKey(algorithm, (java.security.spec.ECPublicKeySpec)keySpec, configuration);
public static ECKeyPair create(KeyPair keyPair) { BCECPrivateKey privateKey = (BCECPrivateKey) keyPair.getPrivate(); BCECPublicKey publicKey = (BCECPublicKey) keyPair.getPublic(); BigInteger privateKeyValue = privateKey.getD(); // Ethereum does not use encoded public keys like bitcoin - see // https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm for details // Additionally, as the first bit is a constant prefix (0x04) we ignore this value byte[] publicKeyBytes = publicKey.getQ().getEncoded(false); BigInteger publicKeyValue = new BigInteger(1, Arrays.copyOfRange(publicKeyBytes, 1, publicKeyBytes.length)); return new ECKeyPair(privateKeyValue, publicKeyValue); }