/** * Verifies the given R/S pair (signature) against a hash using the public key. * * @param sigHash - * @param signature - * @return - */ public boolean verify(byte[] sigHash, ECDSASignature signature) { return ECKey.verify(sigHash, signature, getPubKey()); }
/** * Verifies the given ASN.1 encoded ECDSA signature against a hash using the public key. * * @param data Hash of the data to verify. * @param signature signature. * @param pub The public key bytes to use. * @return - */ public static boolean verify(byte[] data, byte[] signature, byte[] pub) { return verify(data, ECDSASignature.decodeFromDER(signature), pub); }
/** * Verify the signature with hashed data. * * @param hashedData hashed Data * @param signature signature * @return verification result */ boolean verifyHashedData(byte[] hashedData, byte[] signature) { ECKey.ECDSASignature sig = new ECKey.ECDSASignature(signature); return key.verify(hashedData, sig); }
/** * Verifies the given ASN.1 encoded ECDSA signature against a hash using the public key. * * @param data Hash of the data to verify. * @param signature signature. * @return - */ public boolean verify(byte[] data, byte[] signature) { return ECKey.verify(data, signature, getPubKey()); }
/** * Verify the signature with plain data. * * @param data plain data for signed * @param signature signature * @return verification result */ public boolean verify(byte[] data, byte[] signature) { ECKey.ECDSASignature sig = new ECKey.ECDSASignature(signature); return key.verify(HashUtil.sha3(data), sig); }
/** * 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() { if (!this.verifyData()) { return false; } ECKey.ECDSASignature ecdsaSignature = new ECKey.ECDSASignature(this.signature); byte[] hashedHeader = this.header.getHashForSigning(); ECKey ecKeyPub; try { ecKeyPub = ECKey.signatureToKey(hashedHeader, ecdsaSignature); } catch (SignatureException e) { throw new InvalidSignatureException(e); } return ecKeyPub.verify(hashedHeader, ecdsaSignature); }
@Test public void testVerifySignature1() { ECKey key = ECKey.fromPublicOnly(pubKey); BigInteger r = new BigInteger("95350169487015575001444507567851457309689354890536757640816472151471942911739"); BigInteger s = new BigInteger("53263359985948886716508128220321578640585687230908938312863706887350789467339"); ECDSASignature sig = ECDSASignature.fromComponents(r.toByteArray(), s.toByteArray(), (byte) 28); assertTrue(key.verify(HashUtil.sha3(exampleMessage.getBytes()), sig)); }
@Test // result is a point at infinity public void testVerifySignature4() throws SignatureException { byte[] hash = Hex.decode("6ee854b88dbf19846c58fd2beac582adcf28cfdd2b3a8427ac29d7b70153d35c"); BigInteger r = new BigInteger("95350169487015575001444507567851457309689354890536757640816472151471942911739"); BigInteger s = new BigInteger("53263359985948886716508128220321578640585687230908938312863706887350789467339"); ECDSASignature sig = ECDSASignature.fromComponents(r.toByteArray(), s.toByteArray(), (byte) 28); ECKey key = ECKey.signatureToKey(hash, sig); assertTrue(key.verify(hash, sig)); }
/** * Verify a transaction.(data format & signing) * * @return true(success), false(fail) */ public boolean verify() { if (!this.verifyData()) { return false; } ECKey.ECDSASignature ecdsaSignature = new ECKey.ECDSASignature(this.signature); byte[] hashedHeader = this.header.getHashForSigning(); ECKey ecKeyPub; try { ecKeyPub = ECKey.signatureToKey(hashedHeader, ecdsaSignature); } catch (SignatureException e) { throw new InvalidSignatureException(e); } return ecKeyPub.verify(hashedHeader, ecdsaSignature); }
@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)); }
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)); }
@Test public void testSignVerify() { ECKey key = ECKey.fromPrivate(privateKey); String message = "This is an example of a signed message."; byte[] input = HashUtil.sha3(message.getBytes()); ECDSASignature sig = key.sign(input); assertTrue(sig.validateComponents()); assertTrue(key.verify(input, 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 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 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)); }