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