java.security.spec.ECGenParameterSpec java code examples

Refine search

Common ways to obtain ECGenParameterSpec

private void myMethod () {
 ECGenParameterSpec e =String name;new ECGenParameterSpec(name)
Smart code suggestions by Codota
}

static KeyPair createSecp256k1KeyPair(SecureRandom random) throws NoSuchProviderException,
    NoSuchAlgorithmException, InvalidAlgorithmParameterException {
  KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("ECDSA", "BC");
  ECGenParameterSpec ecGenParameterSpec = new ECGenParameterSpec("secp256k1");
  if (random != null) {
    keyPairGenerator.initialize(ecGenParameterSpec, random);
  } else {
    keyPairGenerator.initialize(ecGenParameterSpec);
  }
  return keyPairGenerator.generateKeyPair();
}

String hexPubKeyXY = "01f82bfb2f0a3e988adc3d053d8e6ff878154306e402d871b7d6000823a1397f";
  String hexX = hexPubKeyXY.substring(0, 32);
  String hexY = hexPubKeyXY.substring(32);
  ECPoint point = new ECPoint(new BigInteger(hexX, 16), new BigInteger(hexY, 16));
  AlgorithmParameters parameters = AlgorithmParameters.getInstance("EC", "SunEC");
  parameters.init(new ECGenParameterSpec("secp128r1"));
  ECParameterSpec ecParameters = parameters.getParameterSpec(ECParameterSpec.class);
  ECPublicKeySpec pubKeySpec = new ECPublicKeySpec(point, ecParameters);
  PublicKey key = KeyFactory.getInstance("EC", "SunEC").generatePublic(pubKeySpec);

KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC", "BC");
kpg.initialize(new ECGenParameterSpec(name));
ECPublicKey key = (ECPublicKey) kpg.generateKeyPair().getPublic();
byte[] x = key.getW().getAffineX().toByteArray();
byte[] y = key.getW().getAffineY().toByteArray();
BigInteger xbi = new BigInteger(1, x);
BigInteger ybi = new BigInteger(1, y);
X9ECParameters x9 = ECNamedCurveTable.getByName(name);

 import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.ECGenParameterSpec;

public class ECCKeyGeneration {

  public static void main(String[] args)  {
    try {
      KeyPairGenerator kpg;
      kpg = KeyPairGenerator.getInstance("EC","SunEC");
      ECGenParameterSpec ecsp;
      ecsp = new ECGenParameterSpec("secp192r1");
      kpg.initialize(ecsp);

      KeyPair kp = kpg.genKeyPair();
      PrivateKey privKey = kp.getPrivate();
      PublicKey pubKey = kp.getPublic();

      System.out.println(privKey.toString());
      System.out.println(pubKey.toString());
    } catch (Exception ex) {
      System.out.println(ex);
    }
  }
}

KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC", provider);
ECGenParameterSpec gps = new ECGenParameterSpec(CURVE_TO_SPEC_NAME.get(crv));
kpg.initialize(gps);
KeyPair apair = kpg.generateKeyPair();
ECPublicKey apub = (ECPublicKey) apair.getPublic();
ECParameterSpec aspec = apub.getParams();
ECPoint ecPoint = new ECPoint(new BigInteger(1, x), new BigInteger(1, y));
  realKeyPair = new KeyPair(getECPublicKey(ecPoint, aspec, provider),
      getECPrivateKey(d, aspec, provider));
} else {
  realKeyPair = new KeyPair(getECPublicKey(ecPoint, aspec, provider), null);

/**
 * Parses a DER encoded EC key to an {@link ECPrivateKeySpec} using a minimal {@link DerParser}
 *
 * @param keyBytes the private key raw bytes
 * @return {@link ECPrivateKeySpec}
 * @throws IOException if the DER encoded key can't be parsed
 */
private static ECPrivateKeySpec parseEcDer(byte[] keyBytes) throws IOException,
    GeneralSecurityException {
  DerParser parser = new DerParser(keyBytes);
  DerParser.Asn1Object sequence = parser.readAsn1Object();
  parser = sequence.getParser();
  parser.readAsn1Object().getInteger(); // version
  String keyHex = parser.readAsn1Object().getString();
  BigInteger privateKeyInt = new BigInteger(keyHex, 16);
  KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("EC");
  AlgorithmParameterSpec prime256v1ParamSpec = new ECGenParameterSpec("secp256r1");
  keyPairGenerator.initialize(prime256v1ParamSpec);
  ECParameterSpec parameterSpec = ((ECKey) keyPairGenerator.generateKeyPair().getPrivate()).getParams();
  return new ECPrivateKeySpec(privateKeyInt, parameterSpec);
}

  throw new InvalidParameterSpecException("EC curve name not recognized: " + ecGenParameterSpec.getName());
curveName = ecGenParameterSpec.getName();
ECParameterSpec baseSpec = EC5Util.convertToSpec(params);
ecParameterSpec = new ECNamedCurveSpec(curveName,
  baseSpec.getCurve(), baseSpec.getGenerator(), baseSpec.getOrder(), BigInteger.valueOf(baseSpec.getCofactor()));

public ECPublicKey convertUncompressedPointToECKey(final byte[] uncompressedPoint, int curve) {
  AlgorithmParameters parameters = null;
  try {
    parameters = AlgorithmParameters.getInstance("EC");
    parameters.init(new ECGenParameterSpec(convertCoseCurveToSunCurveName(curve)));
    ECParameterSpec params = parameters.getParameterSpec(ECParameterSpec.class);
    int offset = 0;
    if (uncompressedPoint[offset++] != 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);
  } catch (NoSuchAlgorithmException | InvalidKeySpecException | InvalidParameterSpecException e) {
    throw new Fido2RPRuntimeException(e.getMessage());
  }
}

 KeyPairGenerator eckpg = KeyPairGenerator.getInstance("EC");
ECGenParameterSpec p256 = new ECGenParameterSpec("secp256r1");
eckpg.initialize(p256);
KeyPair doubleUseKeyPair = eckpg.generateKeyPair();
KeyAgreement ecdh = KeyAgreement.getInstance("ECDH");
ecdh.init(doubleUseKeyPair.getPrivate());
// ...

Signature ecdsa = Signature.getInstance("SHA256withECDSA");
ecdsa.initSign(doubleUseKeyPair.getPrivate());
// ...

System.out.println(eckpg.getProvider());
System.out.println(ecdh.getProvider());
System.out.println(ecdsa.getProvider());

private SupportedGroup(int code, int type, String p, String a, String b, String x, String y,
    String n, int h) {
  this(code);
  BigInteger bip = bi(p);
  ECField field;
  switch(type) {
  case(PRIME):
    field = new ECFieldFp(bip);
    break;
  case(BINARY):
    field = new ECFieldF2m(bip.bitLength() - 1, bip);
    break;
  default:
    throw new RuntimeException("Cannot handle supported groups of type " + type);
  }
  EllipticCurve curve = new EllipticCurve(field, bi(a), bi(b));
  ECPoint g = new ECPoint(bi(x), bi(y));
  this.params = new ECParameterSpec(curve, g, bi(n), h);
  try {
    KeyPairGenerator gen = KeyPairGenerator.getInstance(KEYPAIR_GENERATOR_ALGORITHM);
    gen.initialize(new ECGenParameterSpec(name()));
    usable = true;
  } catch (GeneralSecurityException e) {
    LOGGER.log(Level.FINE, "Group [{0}] is not supported by JRE", name());
  }
}

public static KeyPair generateECKeypair(ASN1ObjectIdentifier curveId, SecureRandom random)
  throws NoSuchAlgorithmException, NoSuchProviderException, InvalidAlgorithmParameterException {
 Args.notNull(curveId, "curveId");
 ECGenParameterSpec spec = new ECGenParameterSpec(curveId.getId());
 KeyPairGenerator kpGen = getKeyPairGenerator("EC");
 synchronized (kpGen) {
  if (random == null) {
   kpGen.initialize(spec);
  } else {
   kpGen.initialize(spec, random);
  }
  return kpGen.generateKeyPair();
 }
}

/**
 * 生成用于非对称加密的公钥和私钥<br>
 * 密钥对生成算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyPairGenerator
 * 
 * @param algorithm 非对称加密算法
 * @param keySize 密钥模（modulus ）长度
 * @param seed 种子
 * @return {@link KeyPair}
 */
public static KeyPair generateKeyPair(String algorithm, int keySize, byte[] seed) {
  // SM2算法需要单独定义其曲线生成
  if ("SM2".equalsIgnoreCase(algorithm)) {
    final ECGenParameterSpec sm2p256v1 = new ECGenParameterSpec(SM2_DEFAULT_CURVE);
    return generateKeyPair(algorithm, keySize, seed, sm2p256v1);
  }
  return generateKeyPair(algorithm, keySize, seed, (AlgorithmParameterSpec[]) null);
}

  public String toString() {
    return spec.getName();
  }
}

ECPoint pubPoint = new ECPoint(new BigInteger(1, x),new BigInteger(1, y));
     AlgorithmParameters parameters = AlgorithmParameters.getInstance("EC", "SunEC");
     parameters.init(new ECGenParameterSpec("secp256r1"));
     ECParameterSpec ecParameters = parameters.getParameterSpec(ECParameterSpec.class);
     ECPublicKeySpec pubSpec = new ECPublicKeySpec(pubPoint, ecParameters);
     KeyFactory kf = KeyFactory.getInstance("EC");
     return (ECPublicKey)kf.generatePublic(pubSpec);

public void init(int key_size) throws Exception {
 String name=null;
 if(key_size==256) name="secp256r1";
 else if(key_size==384) name="secp384r1";
 else if(key_size==521) name="secp521r1";
 else throw new JSchException("unsupported key size: "+key_size);
 for(int i = 0; i<1000; i++) {
  KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC");
  ECGenParameterSpec ecsp = new ECGenParameterSpec(name);
  kpg.initialize(ecsp);
  KeyPair kp = kpg.genKeyPair();
  prvKey = (ECPrivateKey)kp.getPrivate();
  pubKey = (ECPublicKey)kp.getPublic();
  params=pubKey.getParams();
  d=((ECPrivateKey)prvKey).getS().toByteArray();
  ECPoint w = pubKey.getW();
  r = w.getAffineX().toByteArray();
  s = w.getAffineY().toByteArray();
  if(r.length!=s.length) continue;
  if(key_size==256 && r.length==32) break;
  if(key_size==384 && r.length==48) break;
  if(key_size==521 && r.length==66) break;
 }
 if(d.length<r.length){
  d=insert0(d);
 }
}
public byte[] getD(){return d;}

ECPoint g = EC5Util.convertPoint(curve, p.getGenerator(), false);
param = new ECKeyGenerationParameters(new ECDomainParameters(curve, g, p.getOrder(), BigInteger.valueOf(p.getCofactor())), random);
  curveName = ((ECGenParameterSpec)params).getName();

private SupportedGroup(int code, int type, String p, String a, String b, String x, String y,
    String n, int h) {
  this(code);
  BigInteger bip = bi(p);
  ECField field;
  switch(type) {
  case(PRIME):
    field = new ECFieldFp(bip);
    break;
  case(BINARY):
    field = new ECFieldF2m(bip.bitLength() - 1, bip);
    break;
  default:
    throw new RuntimeException("Cannot handle supported groups of type " + type);
  }
  EllipticCurve curve = new EllipticCurve(field, bi(a), bi(b));
  ECPoint g = new ECPoint(bi(x), bi(y));
  this.params = new ECParameterSpec(curve, g, bi(n), h);
  try {
    KeyPairGenerator gen = KeyPairGenerator.getInstance(KEYPAIR_GENERATOR_ALGORITHM);
    gen.initialize(new ECGenParameterSpec(name()));
    usable = true;
  } catch (GeneralSecurityException e) {
    LOGGER.log(Level.FINE, "Group [{0}] is not supported by JRE", name());
  }
}

/**
 * 生成用于非对称加密的公钥和私钥<br>
 * 密钥对生成算法见：https://docs.oracle.com/javase/7/docs/technotes/guides/security/StandardNames.html#KeyPairGenerator
 * 
 * @param algorithm 非对称加密算法
 * @param keySize 密钥模（modulus ）长度
 * @param seed 种子
 * @return {@link KeyPair}
 */
public static KeyPair generateKeyPair(String algorithm, int keySize, byte[] seed) {
  // SM2算法需要单独定义其曲线生成
  if ("SM2".equalsIgnoreCase(algorithm)) {
    final ECGenParameterSpec sm2p256v1 = new ECGenParameterSpec(SM2_DEFAULT_CURVE);
    return generateKeyPair(algorithm, keySize, seed, sm2p256v1);
  }
  return generateKeyPair(algorithm, keySize, seed, (AlgorithmParameterSpec[]) null);
}

  public String toString() {
    return spec.getName();
  }
}

@Override
public KeyPair generate() {
  // obtain an EC key pair generator for the specified named curve
  KeyPairGenerator generator;
  try {
    generator = java.security.KeyPairGenerator.getInstance(EC_KEY_GEN_ALGORITHM);
    ECGenParameterSpec ecName = new ECGenParameterSpec(namedCurve);
    generator.initialize(ecName);
  } catch (NoSuchAlgorithmException | InvalidAlgorithmParameterException e) {
    throw new KeyGeneratorException("Unable to generate EC public/private key pair using named curve: " + namedCurve, e);
  }
  return generator.generateKeyPair();
}

Javadoc

The parameter specification used to generate elliptic curve domain parameters.

Most used methods

<init>
Creates a new ECGenParameterSpec with the specified standard or predefined name of the to-be-generat
getName
Returns the name (standard or predefined) of the to-be-generated elliptic curve domain parameter.

Popular in Java

Reactive rest calls using spring rest template
findViewById (Activity)
getApplicationContext (Context)
requestLocationUpdates (LocationManager)
VirtualMachine (com.sun.tools.attach)
A Java virtual machine. A VirtualMachine represents a Java virtual machine to which this Java vir
Rectangle (java.awt)
A Rectangle specifies an area in a coordinate space that is enclosed by the Rectangle object's top-
Date (java.util)
A specific moment in time, with millisecond precision. Values typically come from System#currentTime
CountDownLatch (java.util.concurrent)
A synchronization aid that allows one or more threads to wait until a set of operations being perfor
Servlet (javax.servlet)
Defines methods that all servlets must implement.A servlet is a small Java program that runs within
JFileChooser (javax.swing)

How to useECGenParameterSpec in java.security.spec

Best Java code snippets using java.security.spec.ECGenParameterSpec (Showing top 20 results out of 621)

Refine search

How to use
ECGenParameterSpec
in
java.security.spec