public async Task <bool> Verify(string trHex, string pubKey, SigHash hashType = SigHash.All) { PubKey checkPubKey = new PubKey(pubKey); var tr = new Transaction(trHex); for (var i = 0; i < tr.Inputs.Count; i++) { var input = tr.Inputs[i]; var redeemScript = PayToScriptHashTemplate.Instance.ExtractScriptSigParameters(input.ScriptSig)?.RedeemScript ?? PayToScriptHashTemplate.Instance.ExtractScriptSigParameters(input.WitScript)?.RedeemScript; if (redeemScript != null) { if (PayToMultiSigTemplate.Instance.CheckScriptPubKey(redeemScript)) { var pubkeys = PayToMultiSigTemplate.Instance.ExtractScriptPubKeyParameters(redeemScript).PubKeys; for (int j = 0; j < pubkeys.Length; j++) { if (pubkeys[j] == checkPubKey) { var scriptParams = PayToScriptHashTemplate.Instance.ExtractScriptSigParameters(input.ScriptSig); var hash = Script.SignatureHash(scriptParams.RedeemScript, tr, i, hashType); if (!checkPubKey.Verify(hash, scriptParams.Pushes[j + 1])) { return(false); } } } continue; } } var prevTransaction = await _bitcoinTransactionService.GetTransaction(input.PrevOut.Hash.ToString()); var output = prevTransaction.Outputs[input.PrevOut.N]; if (PayToPubkeyHashTemplate.Instance.CheckScriptPubKey(output.ScriptPubKey)) { if (output.ScriptPubKey.GetDestinationAddress(_rpcParams.Network) == checkPubKey.GetAddress(_rpcParams.Network)) { var hash = Script.SignatureHash(output.ScriptPubKey, tr, i, hashType); var sign = PayToPubkeyHashTemplate.Instance.ExtractScriptSigParameters(input.ScriptSig)?.TransactionSignature?.Signature; if (sign == null) { return(false); } if (!checkPubKey.Verify(hash, sign)) { return(false); } } } } return(true); }
public void testSignAndVerify1_NB() { //Single hash string fullURL = "https://btcpaytest.indiesquare.net/tokens"; byte[] data = Encoding.UTF8.GetBytes(fullURL); byte[] singleHash = null; using (var hash256 = SHA256.Create()) { var bytes = Encoding.UTF8.GetBytes(fullURL); singleHash = hash256.ComputeHash(bytes); } //string sig = _nbKey.SignMessage(fullURL);//Double hashed and base64 but NOT DER //byte[] doubleHashedSig = Convert.FromBase64String(sig); ECDSASignature eCDSA = _nbKey.Sign(new uint256(singleHash)); string sigDERStr = KeyUtils.bytesToHex(eCDSA.ToDER()); // bitpay verify Assert.IsTrue(_ecKey.Verify(singleHash, eCDSA.ToDER())); //NBitcoin verify PubKey pubk = _nbKey.PubKey; Assert.IsTrue(pubk.Verify(new uint256(singleHash), new ECDSASignature(eCDSA.ToDER()))); //Assert.IsTrue(pubk.Verify(doubleHash, new ECDSASignature(doubleHashedSig)));//NOT DER }
/// <summary> /// Verifies if signature of provided header was created using /// private key that corresponds to given public key. /// </summary> public bool VerifySignature(PubKey pubKey, PoABlockHeader header) { if ((header.BlockSignature == null) || header.BlockSignature.IsEmpty()) { this.logger.LogTrace("(-)[NO_SIGNATURE]"); return(false); } if (!ECDSASignature.IsValidDER(header.BlockSignature.Signature)) { this.logger.LogTrace("(-)[INVALID_DER]"); return(false); } ECDSASignature signature = ECDSASignature.FromDER(header.BlockSignature.Signature); if (!signature.IsLowS) { this.logger.LogTrace("(-)[NOT_CANONICAL]"); return(false); } uint256 headerHash = header.GetHash(); bool isValidSignature = pubKey.Verify(headerHash, signature); return(isValidSignature); }
public void testSignAndVerify2() { //data is sha256-ed string fullURL = "https://btcpaytest.indiesquare.net/tokens"; // String hash = KeyUtils.Sha256Hash(fullURL);//Single hash // byte[] dataBytes = KeyUtils.hexToBytes(hash); var hash256 = SHA256.Create(); byte[] data = Encoding.UTF8.GetBytes(fullURL); byte[] hashBytes = hash256.ComputeHash(data);//Single hash //signature string sigStr = "3045022100f1467b7c8348521740a99fe92772e953350421a472da908531af0d0177cc7fee02201391387f27f9ad380d5acae31af35863ac40f2a45aa18c73868e3619d05a2ae6"; byte[] sigBytes = KeyUtils.hexToBytes(sigStr); //Bitpay verify Assert.IsTrue(_ecKey.Verify(hashBytes, sigBytes)); //Nbitcoin verify PubKey pubk = _nbKey.PubKey.Decompress(); Assert.IsTrue(pubk.Verify(new uint256(hashBytes), new ECDSASignature(Encoders.Hex.DecodeData(sigStr)))); }
public static bool CheckBitIDSignature(this PubKey key, string sig, string uri, string body) { body = body ?? string.Empty; if (key == null) { throw new ArgumentNullException(nameof(key)); } if (sig == null) { throw new ArgumentNullException(nameof(sig)); } if (uri == null) { throw new ArgumentNullException(nameof(uri)); } try { if (!Uri.IsWellFormedUriString(uri, UriKind.Absolute)) { return(false); } var hash = new uint256(Hashes.SHA256(Encoding.UTF8.GetBytes(uri + body))); var result = key.Verify(hash, new ECDSASignature(Encoders.Hex.DecodeData(sig))); return(result); } catch { return(false); } }
public void ShouldFailVerifycation() { var vectors = new string[][] { new [] { "Test vector 5", "02DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659", "243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89", "2A298DACAE57395A15D0795DDBFD1DCB564DA82B0F269BC70A74F8220429BA1DFA16AEE06609280A19B67A24E1977E4697712B5FD2943914ECD5F730901B4AB7", "incorrect R residuosity" }, new [] { "Test vector 6", "03FAC2114C2FBB091527EB7C64ECB11F8021CB45E8E7809D3C0938E4B8C0E5F84B", "5E2D58D8B3BCDF1ABADEC7829054F90DDA9805AAB56C77333024B9D0A508B75C", "00DA9B08172A9B6F0466A2DEFD817F2D7AB437E0D253CB5395A963866B3574BED092F9D860F1776A1F7412AD8A1EB50DACCC222BC8C0E26B2056DF2F273EFDEC", "negated message hash" }, new [] { "Test vector 7", "0279BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798", "0000000000000000000000000000000000000000000000000000000000000000", "787A848E71043D280C50470E8E1532B2DD5D20EE912A45DBDD2BD1DFBF187EF68FCE5677CE7A623CB20011225797CE7A8DE1DC6CCD4F754A47DA6C600E59543C", "negated s value" }, new [] { "Test vector 8", "03DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659", "243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89", "2A298DACAE57395A15D0795DDBFD1DCB564DA82B0F269BC70A74F8220429BA1D1E51A22CCEC35599B8F266912281F8365FFC2D035A230434A1A64DC59F7013FD", "negated public key" } }; foreach (var vector in vectors) { var publicKey = new PubKey(Encoders.Hex.DecodeData(vector[1])); var message = uint256.Parse(vector[2]); var expectedSignature = SchnorrSignature.Parse(vector[3]); var reason = vector[4]; Assert.False(publicKey.Verify(message, expectedSignature), reason); } }
public void SingningTest() { var vectors = new string[][] { new [] { "Test vector 1", "0000000000000000000000000000000000000000000000000000000000000001", "0279BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798", "0000000000000000000000000000000000000000000000000000000000000000", "787A848E71043D280C50470E8E1532B2DD5D20EE912A45DBDD2BD1DFBF187EF67031A98831859DC34DFFEEDDA86831842CCD0079E1F92AF177F7F22CC1DCED05" }, new [] { "Test vector 2", "B7E151628AED2A6ABF7158809CF4F3C762E7160F38B4DA56A784D9045190CFEF", "02DFF1D77F2A671C5F36183726DB2341BE58FEAE1DA2DECED843240F7B502BA659", "243F6A8885A308D313198A2E03707344A4093822299F31D0082EFA98EC4E6C89", "2A298DACAE57395A15D0795DDBFD1DCB564DA82B0F269BC70A74F8220429BA1D1E51A22CCEC35599B8F266912281F8365FFC2D035A230434A1A64DC59F7013FD" }, new [] { "Test vector 3", "C90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B14E5C7", "03FAC2114C2FBB091527EB7C64ECB11F8021CB45E8E7809D3C0938E4B8C0E5F84B", "5E2D58D8B3BCDF1ABADEC7829054F90DDA9805AAB56C77333024B9D0A508B75C", "00DA9B08172A9B6F0466A2DEFD817F2D7AB437E0D253CB5395A963866B3574BE00880371D01766935B92D2AB4CD5C8A2A5837EC57FED7660773A05F0DE142380" } }; foreach (var vector in vectors) { var privatekey = new Key(Encoders.Hex.DecodeData(vector[1])); var publicKey = new PubKey(Encoders.Hex.DecodeData(vector[2])); var message = Parseuint256(vector[3]); var expectedSignature = SchnorrSignature.Parse(vector[4]); var signature = privatekey.SignSchnorr(message); Assert.Equal(expectedSignature.ToBytes(), signature.ToBytes()); Assert.True(publicKey.Verify(message, expectedSignature)); Assert.True(privatekey.PubKey.Verify(message, expectedSignature)); } }
/// <summary> /// Checks if block signature is valid. /// TODO: Update this code to reflect changes made to the corresponding method in <see cref="Features.Consensus.Rules.CommonRules.PosBlockSignatureRule"/>. /// </summary> /// <param name="block">The block.</param> /// <returns><c>true</c> if the signature is valid, <c>false</c> otherwise.</returns> private bool CheckBlockSignature(SmartContractPosBlock block) { if (BlockStake.IsProofOfWork(block)) { bool res = block.BlockSignature.IsEmpty(); this.Logger.LogTrace("(-)[POW]:{0}", res); return(res); } if (block.BlockSignature.IsEmpty()) { this.Logger.LogTrace("(-)[EMPTY]:false"); return(false); } TxOut txout = block.Transactions[1].Outputs[1]; if (PayToPubkeyTemplate.Instance.CheckScriptPubKey(txout.ScriptPubKey)) { PubKey pubKey = PayToPubkeyTemplate.Instance.ExtractScriptPubKeyParameters(txout.ScriptPubKey); bool res = pubKey.Verify(block.GetHash(), new ECDSASignature(block.BlockSignature.Signature)); this.Logger.LogTrace("(-)[P2PK]:{0}", res); return(res); } // Block signing key also can be encoded in the nonspendable output. // This allows to not pollute UTXO set with useless outputs e.g. in case of multisig staking. List <Op> ops = txout.ScriptPubKey.ToOps().ToList(); if (!ops.Any()) // script.GetOp(pc, opcode, vchPushValue)) { this.Logger.LogTrace("(-)[NO_OPS]:false"); return(false); } if (ops.ElementAt(0).Code != OpcodeType.OP_RETURN) // OP_RETURN) { this.Logger.LogTrace("(-)[NO_OP_RETURN]:false"); return(false); } if (ops.Count < 2) // script.GetOp(pc, opcode, vchPushValue) { this.Logger.LogTrace("(-)[NO_SECOND_OP]:false"); return(false); } byte[] data = ops.ElementAt(1).PushData; if (!ScriptEvaluationContext.IsCompressedOrUncompressedPubKey(data)) { this.Logger.LogTrace("(-)[NO_PUSH_DATA]:false"); return(false); } bool verifyRes = new PubKey(data).Verify(block.GetHash(), new ECDSASignature(block.BlockSignature.Signature)); return(verifyRes); }
/// <inheritdoc /> public bool CheckStakeSignature(BlockSignature signature, uint256 blockHash, Transaction coinStake) { if (signature.IsEmpty()) { this.logger.LogTrace("(-)[EMPTY]:false"); return(false); } TxOut txout = coinStake.Outputs[1]; if (PayToPubkeyTemplate.Instance.CheckScriptPubKey(txout.ScriptPubKey)) { PubKey pubKey = PayToPubkeyTemplate.Instance.ExtractScriptPubKeyParameters(txout.ScriptPubKey); bool res = pubKey.Verify(blockHash, new ECDSASignature(signature.Signature)); this.logger.LogTrace("(-)[P2PK]:{0}", res); return(res); } // Block signing key also can be encoded in the nonspendable output. // This allows to not pollute UTXO set with useless outputs e.g. in case of multisig staking. List <Op> ops = txout.ScriptPubKey.ToOps().ToList(); if (!ops.Any()) { this.logger.LogTrace("(-)[NO_OPS]:false"); return(false); } if (ops.ElementAt(0).Code != OpcodeType.OP_RETURN) // OP_RETURN) { this.logger.LogTrace("(-)[NO_OP_RETURN]:false"); return(false); } if (ops.Count != 2) { this.logger.LogTrace("(-)[INVALID_OP_COUNT]:false"); return(false); } byte[] data = ops.ElementAt(1).PushData; if (data.Length > MaxPushDataSize) { this.logger.LogTrace("(-)[PUSH_DATA_TOO_LARGE]:false"); return(false); } if (!ScriptEvaluationContext.IsCompressedOrUncompressedPubKey(data)) { this.logger.LogTrace("(-)[NO_PUSH_DATA]:false"); return(false); } bool verifyRes = new PubKey(data).Verify(blockHash, new ECDSASignature(signature.Signature)); return(verifyRes); }
/// <summary> /// Verify a transaction. /// </summary> /// <param name="t"> /// Transaction to verify. /// </param> /// <returns> /// The <see cref="bool"/> sucess of the verification. /// </returns> public static bool Verify(TransactionApi t) { var key = new PubKey(Encoders.Hex.DecodeData(t.SenderPublicKey)); var signature = Encoders.Hex.DecodeData(t.Signature); var bytes = GetBytes(t); return(key.Verify(new uint256(Sha256.ComputeHash(bytes)), signature)); }
public bool CheckSignature(PubKey key) { if (key == null) { throw new ArgumentNullException("key"); } return(key.Verify(Hashes.Hash256(this.payload.GetString()), this.signature.GetString())); }
public void ShouldPassVerifycation() { var publicKey = new PubKey(Encoders.Hex.DecodeData("03DEFDEA4CDB677750A420FEE807EACF21EB9898AE79B9768766E4FAA04A2D4A34")); var message = Parseuint256("4DF3C3F68FCC83B27E9D42C90431A72499F17875C81A599B566C9889B9696703"); var signature = SchnorrSignature.Parse("00000000000000000000003B78CE563F89A0ED9414F5AA28AD0D96D6795F9C6302A8DC32E64E86A333F20EF56EAC9BA30B7246D6D25E22ADB8C6BE1AEB08D49D"); Assert.True(publicKey.Verify(message, signature)); }
/// <summary> /// Verification of a transaction with the second passphrase. /// </summary> /// <param name="t"> /// The <see cref="TransactionApi"/> that is being verified. /// </param> /// <param name="secondPublicKeyHex"> /// User's second Passphrase. /// </param> /// <returns> /// The <see cref="bool"/> reporting the success of the transaction. /// </returns> public static bool SecondVerify(TransactionApi t, string secondPublicKeyHex) { var key = new PubKey(Encoders.Hex.DecodeData(secondPublicKeyHex)); var signature = Encoders.Hex.DecodeData(t.SignSignature); var bytes = GetBytes(t, false); return(key.Verify(new uint256(Sha256.ComputeHash(bytes)), signature)); }
/// <summary> /// Verifies header signature with the key from coinstake kernel. /// </summary> /// <param name="header">The header.</param> /// <exception cref="ConsensusException"> /// Throws exception with error <see cref="ConsensusErrors.BadBlockSignature" /> if check fails. /// </exception> private void CheckHeaderSignatureWithCoinstakeKernel(ProvenBlockHeader header) { Script script = header.Coinstake.Outputs[1].ScriptPubKey; PubKey pubKey = PayToPubkeyTemplate.Instance.ExtractScriptPubKeyParameters(script); var signature = new ECDSASignature(header.Signature.Signature); uint256 headerHash = header.GetHash(); if (!pubKey.Verify(headerHash, signature)) { this.Logger.LogTrace("(-)[BAD_HEADER_SIGNATURE]"); ConsensusErrors.BadBlockSignature.Throw(); } }
/// <summary> /// Verifies header signature with the key from coinstake kernel. /// </summary> /// <param name="header">The header.</param> /// <param name="stakingCoins">The staking coins.</param> /// <exception cref="ConsensusException"> /// Throws exception with error <see cref="ConsensusErrors.BadBlockSignature" /> if check fails. /// </exception> private void CheckHeaderSignatureWithCoinstakeKernel(ProvenBlockHeader header, UnspentOutputs stakingCoins) { OutPoint prevOut = this.GetPreviousOut(header); Script scriptPubKey = stakingCoins.Outputs[prevOut.N].ScriptPubKey; PubKey pubKey = scriptPubKey.GetDestinationPublicKeys(this.PosParent.Network)[0]; var signature = new ECDSASignature(header.Signature.Signature); uint256 headerHash = header.GetHash(); if (pubKey.Verify(headerHash, signature)) { return; } this.Logger.LogTrace("(-)[BAD_HEADER_SIGNATURE]"); ConsensusErrors.BadBlockSignature.Throw(); }
public void testSignAndVerify2_NB() { //Double Hash string fullURL = "https://btcpaytest.indiesquare.net/tokens"; byte[] data = Encoding.UTF8.GetBytes(fullURL); uint256 doubleHash = Hashes.Hash256(data); //Sign ECDSASignature eCDSA = _nbKey.Sign(doubleHash); string sigDERStr = KeyUtils.bytesToHex(eCDSA.ToDER()); // bitpay verify Assert.IsTrue(_ecKey.Verify(doubleHash.ToBytes(), Encoders.Hex.DecodeData(sigDERStr))); //NBitcoin verify PubKey pubk = _nbKey.PubKey; Assert.IsTrue(pubk.Verify(doubleHash, new ECDSASignature(Encoders.Hex.DecodeData(sigDERStr)))); //Assert.IsTrue(pubk.Verify(doubleHash, new ECDSASignature(doubleHashedSig)));//NOT DER }
public static bool VerifySignature(JsonEnvelope envelope) { if (string.IsNullOrEmpty(envelope.Payload)) { throw new BadRequestException("JsonEnvelope must contain non-empty 'payload'"); } if (string.IsNullOrEmpty(envelope.PublicKey)) { throw new BadRequestException("JsonEnvelope must contain non-empty publicKey"); } if (string.IsNullOrEmpty(envelope.Signature)) { throw new BadRequestException("JsonEnvelope must contain non-empty signature"); } var signature = ECDSASignature.FromDER(Encoders.Hex.DecodeData(envelope.Signature)); var pubKey = new PubKey(envelope.PublicKey); return(pubKey.Verify(new uint256(GetSigHash(envelope.Payload, envelope.Encoding)), signature)); }
public bool CheckSignature(PubKey key) { return(key.Verify(Hashes.Hash256(payload.GetString()), signature.GetString())); }
public void key_test1() { BitcoinSecret bsecret1 = Network.Main.CreateBitcoinSecret(strSecret1); BitcoinSecret bsecret2 = Network.Main.CreateBitcoinSecret(strSecret2); BitcoinSecret bsecret1C = Network.Main.CreateBitcoinSecret(strSecret1C); BitcoinSecret bsecret2C = Network.Main.CreateBitcoinSecret(strSecret2C); Assert.Throws <FormatException>(() => Network.Main.CreateBitcoinSecret(strAddressBad)); Key key1 = bsecret1.PrivateKey; Assert.True(key1.IsCompressed == false); Assert.True(bsecret1.Copy(true).PrivateKey.IsCompressed == true); Assert.True(bsecret1.Copy(true).Copy(false).IsCompressed == false); Assert.True(bsecret1.Copy(true).Copy(false).ToString() == bsecret1.ToString()); Key key2 = bsecret2.PrivateKey; Assert.True(key2.IsCompressed == false); Key key1C = bsecret1C.PrivateKey; Assert.True(key1C.IsCompressed == true); Key key2C = bsecret2C.PrivateKey; Assert.True(key1C.IsCompressed == true); PubKey pubkey1 = key1.PubKey; PubKey pubkey2 = key2.PubKey; PubKey pubkey1C = key1C.PubKey; PubKey pubkey2C = key2C.PubKey; Assert.True(addr1.Hash == pubkey1.Hash); Assert.True(addr2.Hash == pubkey2.Hash); Assert.True(addr1C.Hash == pubkey1C.Hash); Assert.True(addr2C.Hash == pubkey2C.Hash); for (int n = 0; n < 16; n++) { string strMsg = String.Format("Very secret message {0}: 11", n); if (n == 10) { //Test one long message strMsg = String.Join(",", Enumerable.Range(0, 2000).Select(i => i.ToString()).ToArray()); } uint256 hashMsg = Hashes.DoubleSHA256(TestUtils.ToBytes(strMsg)); // normal signatures ECDSASignature sign1 = null, sign2 = null, sign1C = null, sign2C = null; List <Task> tasks = new List <Task>(); sign1 = key1.Sign(hashMsg); sign2 = key2.Sign(hashMsg); sign1C = key1C.Sign(hashMsg); sign2C = key2C.Sign(hashMsg); for (int i = 0; i < 30; i++) { Assert.True(pubkey1.Verify(hashMsg, sign1)); Assert.True(pubkey2.Verify(hashMsg, sign2)); Assert.True(pubkey1C.Verify(hashMsg, sign1C)); Assert.True(pubkey2C.Verify(hashMsg, sign2C)); Assert.True(pubkey1.Verify(hashMsg, sign1)); Assert.True(!pubkey1.Verify(hashMsg, sign2)); Assert.True(pubkey1.Verify(hashMsg, sign1C)); Assert.True(!pubkey1.Verify(hashMsg, sign2C)); Assert.True(!pubkey2.Verify(hashMsg, sign1)); Assert.True(pubkey2.Verify(hashMsg, sign2)); Assert.True(!pubkey2.Verify(hashMsg, sign1C)); Assert.True(pubkey2.Verify(hashMsg, sign2C)); Assert.True(pubkey1C.Verify(hashMsg, sign1)); Assert.True(!pubkey1C.Verify(hashMsg, sign2)); Assert.True(pubkey1C.Verify(hashMsg, sign1C)); Assert.True(!pubkey1C.Verify(hashMsg, sign2C)); Assert.True(!pubkey2C.Verify(hashMsg, sign1)); Assert.True(pubkey2C.Verify(hashMsg, sign2)); Assert.True(!pubkey2C.Verify(hashMsg, sign1C)); Assert.True(pubkey2C.Verify(hashMsg, sign2C)); } // compact signatures (with key recovery) byte[] csign1 = null, csign2 = null, csign1C = null, csign2C = null; csign1 = key1.SignCompact(hashMsg); csign2 = key2.SignCompact(hashMsg); csign1C = key1C.SignCompact(hashMsg); csign2C = key2C.SignCompact(hashMsg); PubKey rkey1 = null, rkey2 = null, rkey1C = null, rkey2C = null; rkey1 = PubKey.RecoverCompact(hashMsg, csign1); rkey2 = PubKey.RecoverCompact(hashMsg, csign2); rkey1C = PubKey.RecoverCompact(hashMsg, csign1C); rkey2C = PubKey.RecoverCompact(hashMsg, csign2C); Assert.True(rkey1.ToHex() == pubkey1.ToHex()); Assert.True(rkey2.ToHex() == pubkey2.ToHex()); Assert.True(rkey1C.ToHex() == pubkey1C.ToHex()); Assert.True(rkey2C.ToHex() == pubkey2C.ToHex()); Assert.True(sign1.IsLowR && sign1.ToDER().Length <= 70); Assert.True(sign2.IsLowR && sign2.ToDER().Length <= 70); Assert.True(sign1C.IsLowR && sign1C.ToDER().Length <= 70); Assert.True(sign2C.IsLowR && sign2C.ToDER().Length <= 70); } }
public bool CheckSignature(PubKey key) { if (key == null) throw new ArgumentNullException("key"); return key.Verify(Hashes.Hash256(payload.GetString()), signature.GetString()); }
public bool CheckSignature(PubKey key) { return key.Verify(Hashes.Hash256(payload.GetString()), signature.GetString()); }
public void Verify() { pubkey.Verify(hash, sig); }
public void key_test1() { BitcoinSecret bsecret1 = this.networkMain.CreateBitcoinSecret(strSecret1); BitcoinSecret bsecret2 = this.networkMain.CreateBitcoinSecret(strSecret2); BitcoinSecret bsecret1C = this.networkMain.CreateBitcoinSecret(strSecret1C); BitcoinSecret bsecret2C = this.networkMain.CreateBitcoinSecret(strSecret2C); Assert.Throws <FormatException>(() => this.networkMain.CreateBitcoinSecret(strAddressBad)); Key key1 = bsecret1.PrivateKey; Assert.True(key1.IsCompressed == false); Assert.True(bsecret1.Copy(true).PrivateKey.IsCompressed == true); Assert.True(bsecret1.Copy(true).Copy(false).IsCompressed == false); Assert.True(bsecret1.Copy(true).Copy(false).ToString() == bsecret1.ToString()); Key key2 = bsecret2.PrivateKey; Assert.True(key2.IsCompressed == false); Key key1C = bsecret1C.PrivateKey; Assert.True(key1C.IsCompressed == true); Key key2C = bsecret2C.PrivateKey; Assert.True(key1C.IsCompressed == true); PubKey pubkey1 = key1.PubKey; PubKey pubkey2 = key2.PubKey; PubKey pubkey1C = key1C.PubKey; PubKey pubkey2C = key2C.PubKey; Assert.True(this.addr1.Hash == pubkey1.Hash); Assert.True(this.addr2.Hash == pubkey2.Hash); Assert.True(this.addr1C.Hash == pubkey1C.Hash); Assert.True(this.addr2C.Hash == pubkey2C.Hash); for (int n = 0; n < 16; n++) { string strMsg = String.Format("Very secret message {0}: 11", n); if (n == 10) { //Test one long message strMsg = String.Join(",", Enumerable.Range(0, 2000).Select(i => i.ToString()).ToArray()); } uint256 hashMsg = Hashes.Hash256(TestUtils.ToBytes(strMsg)); // normal signatures ECDSASignature sign1 = null, sign2 = null, sign1C = null, sign2C = null; var tasks = new List <Task>(); tasks.Add(Task.Run(() => sign1 = key1.Sign(hashMsg))); tasks.Add(Task.Run(() => sign2 = key2.Sign(hashMsg))); tasks.Add(Task.Run(() => sign1C = key1C.Sign(hashMsg))); tasks.Add(Task.Run(() => sign2C = key2C.Sign(hashMsg))); Task.WaitAll(tasks.ToArray()); tasks.Clear(); tasks.Add(Task.Run(() => Assert.True(pubkey1.Verify(hashMsg, sign1)))); tasks.Add(Task.Run(() => Assert.True(pubkey2.Verify(hashMsg, sign2)))); tasks.Add(Task.Run(() => Assert.True(pubkey1C.Verify(hashMsg, sign1C)))); tasks.Add(Task.Run(() => Assert.True(pubkey2C.Verify(hashMsg, sign2C)))); Task.WaitAll(tasks.ToArray()); tasks.Clear(); tasks.Add(Task.Run(() => Assert.True(pubkey1.Verify(hashMsg, sign1)))); tasks.Add(Task.Run(() => Assert.True(!pubkey1.Verify(hashMsg, sign2)))); tasks.Add(Task.Run(() => Assert.True(pubkey1.Verify(hashMsg, sign1C)))); tasks.Add(Task.Run(() => Assert.True(!pubkey1.Verify(hashMsg, sign2C)))); tasks.Add(Task.Run(() => Assert.True(!pubkey2.Verify(hashMsg, sign1)))); tasks.Add(Task.Run(() => Assert.True(pubkey2.Verify(hashMsg, sign2)))); tasks.Add(Task.Run(() => Assert.True(!pubkey2.Verify(hashMsg, sign1C)))); tasks.Add(Task.Run(() => Assert.True(pubkey2.Verify(hashMsg, sign2C)))); tasks.Add(Task.Run(() => Assert.True(pubkey1C.Verify(hashMsg, sign1)))); tasks.Add(Task.Run(() => Assert.True(!pubkey1C.Verify(hashMsg, sign2)))); tasks.Add(Task.Run(() => Assert.True(pubkey1C.Verify(hashMsg, sign1C)))); tasks.Add(Task.Run(() => Assert.True(!pubkey1C.Verify(hashMsg, sign2C)))); tasks.Add(Task.Run(() => Assert.True(!pubkey2C.Verify(hashMsg, sign1)))); tasks.Add(Task.Run(() => Assert.True(pubkey2C.Verify(hashMsg, sign2)))); tasks.Add(Task.Run(() => Assert.True(!pubkey2C.Verify(hashMsg, sign1C)))); tasks.Add(Task.Run(() => Assert.True(pubkey2C.Verify(hashMsg, sign2C)))); Task.WaitAll(tasks.ToArray()); tasks.Clear(); // compact signatures (with key recovery) byte[] csign1 = null, csign2 = null, csign1C = null, csign2C = null; tasks.Add(Task.Run(() => csign1 = key1.SignCompact(hashMsg))); tasks.Add(Task.Run(() => csign2 = key2.SignCompact(hashMsg))); tasks.Add(Task.Run(() => csign1C = key1C.SignCompact(hashMsg))); tasks.Add(Task.Run(() => csign2C = key2C.SignCompact(hashMsg))); Task.WaitAll(tasks.ToArray()); tasks.Clear(); PubKey rkey1 = null, rkey2 = null, rkey1C = null, rkey2C = null; tasks.Add(Task.Run(() => rkey1 = PubKey.RecoverCompact(hashMsg, csign1))); tasks.Add(Task.Run(() => rkey2 = PubKey.RecoverCompact(hashMsg, csign2))); tasks.Add(Task.Run(() => rkey1C = PubKey.RecoverCompact(hashMsg, csign1C))); tasks.Add(Task.Run(() => rkey2C = PubKey.RecoverCompact(hashMsg, csign2C))); Task.WaitAll(tasks.ToArray()); tasks.Clear(); Assert.True(rkey1.ToHex() == pubkey1.ToHex()); Assert.True(rkey2.ToHex() == pubkey2.ToHex()); Assert.True(rkey1C.ToHex() == pubkey1C.ToHex()); Assert.True(rkey2C.ToHex() == pubkey2C.ToHex()); } }
public bool VerifySignature(string url, PubKey key) { uint256 hash = new uint256(Hashes.SHA256(Encoding.UTF8.GetBytes(GetMessage(url)))); return(key.Verify(hash, new ECDSASignature(Encoders.Hex.DecodeData(Signature)))); }