public bool Verify(byte[] signature, byte[] securedInput, object key) { try { if (key is PubKey publicKey) { uint256 hash = Hashes.Hash256(securedInput); var valid = PubKey.RecoverCompact(hash, signature); return(publicKey.Hash == valid.Hash); } if (key is BitcoinPubKeyAddress publicKeyAddress) { uint256 hash = Hashes.Hash256(securedInput); var valid = PubKey.RecoverCompact(hash, signature); return(publicKeyAddress.Hash == valid.Hash); } throw new ArgumentException("EcdsaUsingSECP256K1Sha algorithm expects key to be of either PubKey type."); } catch (CryptographicException e) { return(false); } }
public bool VerifySignature(byte[] data, byte[] signature, string address) { var hashkeyid = new uint256(data); var recoverAddress = PubKey.RecoverCompact(hashkeyid, signature); return(recoverAddress.GetAddress(ScriptPubKeyType.Legacy, network).ToString() == address); }
public PubKey RecoverPayeePubKey(uint256 hash) { if (hash == null) { throw new ArgumentNullException(nameof(hash)); } return(PubKey.RecoverCompact(hash, new CompactSignature(RecoveryId, _Signature))); }
public PubKey RecoverPayeePubKey(uint256 hash) { if (hash == null) { throw new ArgumentNullException(nameof(hash)); } var nbitcoinFormat = new byte[65]; nbitcoinFormat[0] = (byte)(27 + RecoveryId); Array.Copy(_OriginalFormat, 0, nbitcoinFormat, 1, 32); Array.Copy(_OriginalFormat, 32, nbitcoinFormat, 33, 32); return(PubKey.RecoverCompact(hash, nbitcoinFormat).Compress()); }
/// <summary> /// Verify the Dogecoin message signed by some dogecoin private key /// </summary> /// <param name="message">input original message</param> /// <param name="signature">signature made by some dogecoin address</param> /// <param name="address">Dogecoin address</param> /// <returns></returns> public static async Task <(bool, string)> VerifyDogeMessage(string message, string signature, string address, bool messageIsAlreadyHash = false) { if (string.IsNullOrEmpty(message) || string.IsNullOrEmpty(signature) || string.IsNullOrEmpty(address)) { return(false, "Input parameters cannot be empty or null."); } try { var add = BitcoinAddress.Create(address, DogeTransactionHelpers.Network); //var vadd = (add as IPubkeyHashUsable); var split = signature.Split('@'); if (split.Length > 1) { var sg = Convert.FromBase64String(split[1]); var recoveryId = Convert.ToInt32(split[0]); var sgs = new CompactSignature(recoveryId, sg); Console.WriteLine("Signature loaded."); PubKey recoveredPubKey = null; if (!messageIsAlreadyHash) { uint256 hash = NBitcoin.Crypto.Hashes.DoubleSHA256(Encoding.UTF8.GetBytes(message)); recoveredPubKey = PubKey.RecoverCompact(hash, sgs); } else { recoveredPubKey = PubKey.RecoverCompact(uint256.Parse(message), sgs); } var pk = recoveredPubKey.GetAddress(ScriptPubKeyType.Legacy, DogeTransactionHelpers.Network); if (pk.ToString() == add.ToString()) { return(true, "Verified."); } } } catch { return(false, "Wrong input. Cannot verify the message signature."); } return(false, "Not verified."); }
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 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); } }