ECDSA with secp256k1 in Java: generate ECC keys, sign, verify
Oracle Java documentation is a little sparse on the topic, but it does look like with the SunJCE, a key generated asEC can be used with either ECDH or ECDSA. (I'm not an Elliptic curve expert, but) Theoretically, I believe that the domain parameters for ECDH and ECDSA have the same form, that is the equation of the curve and a base point G.
ECDSA-secp256k1-example.java
importorg.bouncycastle.util.encoders.Hex; |
importorg.web3j.crypto.*; |
importjava.math.BigInteger; |
publicclassECCExample { |
publicstaticStringcompressPubKey(BigIntegerpubKey) { |
String pubKeyYPrefix = pubKey.testBit(0) ?'03':'02'; |
String pubKeyHex = pubKey.toString(16); |
String pubKeyX = pubKeyHex.substring(0, 64); |
return pubKeyYPrefix + pubKeyX; |
} |
publicstaticvoidmain(String[] args) throwsException { |
//BigInteger privKey = Keys.createEcKeyPair().getPrivateKey(); |
BigInteger privKey =newBigInteger('97ddae0f3a25b92268175400149d65d6887b9cefaf28ea2c078e05cdc15a3c0a', 16); |
BigInteger pubKey =Sign.publicKeyFromPrivate(privKey); |
ECKeyPair keyPair =newECKeyPair(privKey, pubKey); |
System.out.println('Private key: '+ privKey.toString(16)); |
System.out.println('Public key: '+ pubKey.toString(16)); |
System.out.println('Public key (compressed): '+ compressPubKey(pubKey)); |
String msg ='Message for signing'; |
byte[] msgHash =Hash.sha3(msg.getBytes()); |
Sign.SignatureData signature =Sign.signMessage(msgHash, keyPair, false); |
System.out.println('Msg: '+ msg); |
System.out.println('Msg hash: '+Hex.toHexString(msgHash)); |
System.out.printf('Signature: [v = %d, r = %s, s = %s]n', |
signature.getV() -27, |
Hex.toHexString(signature.getR()), |
Hex.toHexString(signature.getS())); |
System.out.println(); |
BigInteger pubKeyRecovered =Sign.signedMessageToKey(msg.getBytes(), signature); |
System.out.println('Recovered public key: '+ pubKeyRecovered.toString(16)); |
boolean validSig = pubKey.equals(pubKeyRecovered); |
System.out.println('Signature valid? '+ validSig); |
} |
} |
pom.xml
<?xml version='1.0' encoding='UTF-8'?> |
<projectxmlns='http://maven.apache.org/POM/4.0.0' |
xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' |
xsi:schemaLocation='http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd'> |
<modelVersion>4.0.0</modelVersion> |
<groupId>bc-examples</groupId> |
<artifactId>bc-examples</artifactId> |
<version>1.0-SNAPSHOT</version> |
<dependencies> |
<dependency> |
<groupId>org.web3j</groupId> |
<artifactId>crypto</artifactId> |
<version>3.3.1</version> |
</dependency> |
</dependencies> |
</project> |
commented Apr 5, 2018
The expected output is as follows: |
commented Sep 16, 2018
java.security package contains ECDSA classes for generating the key pair, signing and verifying signatures. |
Ecc Key Generation In Java 10
Sign up for freeto join this conversation on GitHub. Already have an account? Sign in to comment
As of version 2.6.2 DidiSoft OpenPGP Library for Java fully supports Elliptic Curve cryptography (ECC) in OpenPGP as defined in RFC 6637.
In this chapter we are going to make a short introduction to the new ECC encryption and illustrate how to generate your first ECC OpenPGP key pair.
1. What is Elliptic Curve cryptography?
2. Generating an ECC OpenPGP key pair
3. Industry support
2. Generating an ECC OpenPGP key pair
3. Industry support
What is Elliptic Curve cryptography?
Elliptic Curve cryptography provides asymmetric (public key) cryptography based on mathematic operations with Elliptic Curves over finite fields.
An ECC OpenPGP key consists of a master key which is used for EC DSA signing and an encryption sub key which is used for EC Diffie-Hellman (ECDH) encryption.
Currently the standard for ECC in OpenPGP (RFC 6637) defines three elliptic curves over the finite field of prime numbers introduced by the National Security Agency (NSA) during the 2005 RSA conference: NIST P-256, NIST P-384, NIST-521 (the number shows the finite field of prime numbers with the same size in bits).
Some OpenPGP implementations like GnuPG/gpg has added support for Brainpool curves as well, which we support too as of version 3.1.3.
Comparison with RSA and ElGamal (DH/DSS)
The weakest ECC OpenPGP key pairs (over curve NIST-256) can be compared with a 3072 bit ElGamal or 3072 bit RSA key pair.
Please check section “Security considerations” for more information.
Generating an ECC OpenPGP key pair
Creating an ECC OpenPGP key pair is done with a new set of methods with common name generateEccKeyPair, available in the KeyStore and PGPKeyPair classes.
The supported values for the ECC curve are :
Below is an example that shows how to generate an ECC key pair with no expiration date and default cipher, compression and hashing key preferences.
Industry support
The following software products are known to support ECC in OpenPGP as of the time of this writing:
Symantec PGP Command line 10.2.+
GnuPG 2.1+
Summary
This chapter introduced the new Elliptic Curve (ECC) OpenPGP keys defined in RFC 6637 . As of version 2.6.2 DidiSoft OpenPGP Library for Java fully supports this extension of the OpenPGP standard.
Usage of the new type of OpenPGP keys is transparent once you upgrade to version 2.6.2 or above.
Key generation is done though the methods generateEccKeyPair available in the KeyStore and PGPKeyPair classes.