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))));
}
