/** * Account Constructor. * - generate wallet with new key */ public Account() { this.key = new ECKey(); this.address = this.key.getAddress(); }
/** * Takes the keccak hash (32 bytes) of data and returns the ECDSA signature * * @param messageHash - * @return - * @throws IllegalStateException if this ECKey does not have the private part. */ public ECDSASignature sign(byte[] messageHash) { ECDSASignature sig = doSign(messageHash); // Now we have to work backwards to figure out the recId needed to recover the signature. int recId = -1; byte[] thisKey = this.pub.getEncoded(/* compressed */ false); for (int i = 0; i < 4; i++) { byte[] k = ECKey.recoverPubBytesFromSignature(i, sig, messageHash); if (k != null && Arrays.equals(k, thisKey)) { recId = i; break; } } if (recId == -1) { throw new RuntimeException("Could not construct a recoverable key. This should never happen."); } sig.v = (byte) (recId + 27); return sig; }
/** * Creates an ECKey given the private key only. * * @param privKeyBytes - * @return - */ public static ECKey fromPrivate(byte[] privKeyBytes) { return fromPrivate(new BigInteger(1, privKeyBytes)); }
/** * Compute the key that signed the given signature. * * @param messageHash 32-byte hash of message * @param signatureBase64 Base-64 encoded signature * @return ECKey */ public static ECKey signatureToKey(byte[] messageHash, String signatureBase64) throws SignatureException { final byte[] keyBytes = signatureToKeyBytes(messageHash, signatureBase64); return ECKey.fromPublicOnly(keyBytes); }
@Test public void testVerifySignature2() throws SignatureException { BigInteger r = new BigInteger("c52c114d4f5a3ba904a9b3036e5e118fe0dbb987fe3955da20f2cd8f6c21ab9c", 16); BigInteger s = new BigInteger("6ba4c2874299a55ad947dbc98a25ee895aabf6b625c26c435e84bfd70edf2f69", 16); ECDSASignature sig = ECDSASignature.fromComponents(r.toByteArray(), s.toByteArray(), (byte) 0x1b); byte[] rawtx = Hex.decode("f82804881bc16d674ec8000094cd2a3d9f938e13cd947ec05abc7fe734df8dd8268609184e72a0006480"); byte[] rawHash = HashUtil.sha3(rawtx); byte[] address = Hex.decode("cd2a3d9f938e13cd947ec05abc7fe734df8dd826"); ECKey key = ECKey.signatureToKey(rawHash, sig); assertEquals(key, ECKey.signatureToKey(rawHash, sig.toBase64())); assertEquals(key, ECKey.recoverFromSignature(0, sig, rawHash)); assertArrayEquals(key.getPubKey(), ECKey.recoverPubBytesFromSignature(0, sig, rawHash)); assertArrayEquals(address, key.getAddress()); assertArrayEquals(address, ECKey.signatureToAddress(rawHash, sig)); assertArrayEquals(address, ECKey.signatureToAddress(rawHash, sig.toBase64())); assertArrayEquals(address, ECKey.recoverAddressFromSignature(0, sig, rawHash)); assertTrue(key.verify(rawHash, sig)); }
@Test public void testVerifySignature6() throws SignatureException { // generate ECkey object with privateKey ECKey key = ECKey.fromPrivate(privateKey); // check public key with pubKey assertArrayEquals(pubKey, key.getPubKey()); // generate messageHash with exampleMessage byte[] messageHash = HashUtil.sha3(exampleMessage.getBytes()); // generate ECDSASignature with ECKey, messageHash ECDSASignature signature = key.sign(messageHash); // verify the sign message assertTrue(key.verify(messageHash, signature)); // get public key with messageHash, ECDSASignature ECKey keyFromSig = ECKey.signatureToKey(messageHash, signature); byte[] pubKeyFromSig = keyFromSig.getPubKey(); assertArrayEquals(pubKey, pubKeyFromSig); // verify the sign message assertTrue(keyFromSig.verify(messageHash, signature)); }
@Test public void keyRecovery() { ECKey key = new ECKey(); String message = "Hello World!"; byte[] hash = HashUtil.sha256(message.getBytes()); ECKey.ECDSASignature sig = key.doSign(hash); key = ECKey.fromPublicOnly(key.getPubKeyPoint()); boolean found = false; for (int i = 0; i < 4; i++) { ECKey key2 = ECKey.recoverFromSignature(i, sig, hash); checkNotNull(key2); if (key.equals(key2)) { found = true; break; } } assertTrue(found); }
@Test public void testECKey() { ECKey key = new ECKey(); assertTrue(key.isPubKeyCanonical()); assertNotNull(key.getPubKey()); assertNotNull(key.getPrivKeyBytes()); log.debug(Hex.toHexString(key.getPrivKeyBytes()) + " :Generated privkey"); log.debug(Hex.toHexString(key.getPubKey()) + " :Generated pubkey"); }
private void encryptKeyFileInit(ECKey key, String keyPath, String keyName, String password) throws IOException, InvalidCipherTextException { if (key == null) { key = new ECKey(); this.keyPath = keyPath; this.keyName = keyName; this.address = key.getAddress(); this.publicKey = key.getPubKey(); WALLET_PBKDF2_ALGORITHM); byte[] encData = AESEncrypt.encrypt( key.getPrivKeyBytes(), ByteUtil.parseBytes(kdfPass, 0, 16), iv);
@Test public void testEthereumSign() { ECKey key = ECKey.fromPrivate(privateKey); log.debug("Secret\t: " + Hex.toHexString(key.getPrivKeyBytes())); log.debug("Pubkey\t: " + Hex.toHexString(key.getPubKey())); log.debug("Data\t: " + exampleMessage); byte[] messageHash = HashUtil.sha3(exampleMessage.getBytes()); ECDSASignature signature = key.sign(messageHash); String output = signature.toBase64(); log.debug("Sign\t: " + output + " (Base64, length: " + output.length() + ")"); assertEquals(sigBase64, output); }
@Test public void testVerifySignature_Static() throws SignatureException { byte[] messageHash = Hex.decode("92e0d4290bba01aa0abbb4705360c751af13fdb1131b8f6f1e632c4621adac75"); byte[] signature = Hex.decode("1cca588a8eb84d5bf6741bc6e0ccfbe1fdb05b6c624b5fe72199fa1f2e501f876c5b5f11863323a998b79a0d27714fcc8825cf357903e863396f2e2e281220de31"); // get public key with messageHash, ECDSASignature ECKey.ECDSASignature sig = new ECKey.ECDSASignature(signature); ECKey keyFromSig = ECKey.signatureToKey(messageHash, sig); log.debug("address=" + Hex.toHexString(keyFromSig.getAddress())); byte[] pubKeyFromSig = keyFromSig.getPubKey(); log.debug("pubKey=" + Hex.toHexString(pubKeyFromSig)); assertArrayEquals(pubKeyFromSig, Hex.decode("0493fe448d38c77c212cce10c07ed37984c59bedac51219b70847429153063cfae0d2f42ba394ffe9d5d2d11b0c0f400ac04997c584c0ef6f2041cf20f8c2c446b")); // verify the sign message assertTrue(keyFromSig.verify(messageHash, sig)); }
@Test public void testVerifySignature5() { ECKey key = ECKey.fromPrivate(privateKey); byte[] messageHash = HashUtil.sha3(exampleMessage.getBytes()); ECDSASignature signature = key.sign(messageHash); assertTrue(key.verify(messageHash, signature)); }
@Test public void test3() { BigInteger privKey = new BigInteger("cd244b3015703ddf545595da06ada5516628c5feadbf49dc66049c4b370cc5d8", 16); byte[] addr = ECKey.fromPrivate(privKey).getAddress(); assertEquals("89b44e4d3c81ede05d0f5de8d1a68f754d73d997", Hex.toHexString(addr)); }
/** * Get the public key. * * @return public key */ byte[] getPubKey() throws SignatureException { ECKey.ECDSASignature ecdsaSignature = new ECKey.ECDSASignature(this.signature); ECKey ecKeyPub = ECKey.signatureToKey(this.header.getHashForSigning(), ecdsaSignature); return ecKeyPub.getPubKey(); }
@Test public void testFromPrivateKey() { ECKey key = ECKey.fromPrivate(privateKey); assertTrue(key.isPubKeyCanonical()); assertTrue(key.hasPrivKey()); assertArrayEquals(pubKey, key.getPubKey()); }
@Test public void testIsPubKeyOnly() { ECKey key = ECKey.fromPublicOnly(pubKey); assertTrue(key.isPubKeyCanonical()); assertTrue(key.isPubKeyOnly()); assertArrayEquals(key.getPubKey(), pubKey); }
/** * Verify the signature with public key * * @param data signed data * @param signature signature * @param hashed whether hashed data or not * @param pubKey public key for verifying * @return verification result */ public static boolean verify(byte[] data, byte[] signature, boolean hashed, byte[] pubKey) { ECKey.ECDSASignature ecdsaSignature = new ECKey.ECDSASignature(signature); byte[] hashedData = hashed ? data : HashUtil.sha3(data); ECKey ecKeyPub; try { ecKeyPub = ECKey.signatureToKey(hashedData, ecdsaSignature); } catch (SignatureException e) { logger.debug("Invalid signature" + e.getMessage()); return false; } if (pubKey != null && !Arrays.equals(ecKeyPub.getPubKey(), pubKey)) { logger.debug("Invalid signature"); return false; } return ecKeyPub.verify(hashedData, ecdsaSignature); }
public boolean verify() { ECKey.ECDSASignature ecdsaSignature = new ECKey.ECDSASignature(signature.getBytes()); try { ECKey ecKeyPub = ECKey.signatureToKey(rawForSign.getBytes(), ecdsaSignature); if (ecKeyPub.verify(rawForSign.getBytes(), ecdsaSignature)) { return new Address(ecKeyPub.getAddress()).equals(owner); } else { return false; } } catch (SignatureException e) { throw new InvalidSignatureException(e); } }
private void testProviderRoundTrip(Provider provider) { ECKey key = new ECKey(provider, secureRandom); String message = "The quick brown fox jumps over the lazy dog."; byte[] input = HashUtil.sha3(message.getBytes()); ECDSASignature sig = key.sign(input); assertTrue(sig.validateComponents()); assertTrue(key.verify(input, sig)); }