public void SignAndVerifyTransaction()
{
// Generate the key pair
ECKeyPair keyPair = new KeyPairGenerator().Generate();
Transaction tx = new Transaction();
tx.From = Address.FromRawBytes(CryptoHelpers.RandomFill(ADR_LENGTH));
tx.To = Address.FromRawBytes(CryptoHelpers.RandomFill(ADR_LENGTH));
Block block = new Block();
block.AddTransaction(tx);
// Serialize and hash the transaction
Hash hash = tx.GetHash();
// Sign the hash
ECSigner signer = new ECSigner();
ECSignature signature = signer.Sign(keyPair, hash.DumpByteArray());
ECVerifier verifier = new ECVerifier(keyPair);
Assert.True(verifier.Verify(signature, hash.DumpByteArray()));
}
public void VerifySignature_CorrectDataAndSig_ReturnsTrue()
{
ECKeyPair keyPair = new KeyPairGenerator().Generate();
byte[] message = new BigInteger("968236873715988614170569073515315707566766479517").ToByteArray();
ECSigner signer = new ECSigner();
ECSignature signature = signer.Sign(keyPair, message);
ECVerifier verifier = new ECVerifier(keyPair);
Assert.True(verifier.Verify(signature, message));
}
public void SignAndVerifyTransaction()
{
byte[] fromAdress = CryptoHelpers.RandomFill(ADR_LENGTH);
byte[] toAdress = CryptoHelpers.RandomFill(ADR_LENGTH);
// Generate the key pair
ECKeyPair keyPair = new KeyPairGenerator().Generate();
;
Transaction tx = new Transaction();
tx.From = Address.FromRawBytes(fromAdress);
tx.To = Address.FromRawBytes(toAdress);
tx.Sig = new Signature
{
P = ByteString.CopyFrom(keyPair.PublicKey.Q.GetEncoded())
};
// Serialize and hash the transaction
Hash hash = tx.GetHash();
// Sign the hash
ECSigner signer = new ECSigner();
ECSignature signature = signer.Sign(keyPair, hash.DumpByteArray());
// Update the signature
tx.Sig.R = ByteString.CopyFrom(signature.R);
tx.Sig.S = ByteString.CopyFrom(signature.S);
// Serialize as for sending over the network
byte[] serializedTx = tx.Serialize();
/**** broadcast/receive *****/
Transaction dTx = Transaction.Parser.ParseFrom(serializedTx);
// Serialize and hash the transaction
Hash dHash = dTx.GetHash();
byte[] uncompressedPrivKey = tx.Sig.P.ToByteArray();
ECKeyPair recipientKeyPair = ECKeyPair.FromPublicKey(uncompressedPrivKey);
ECVerifier verifier = new ECVerifier(recipientKeyPair);
Assert.True(verifier.Verify(dTx.GetSignature(), dHash.DumpByteArray()));
}
public void VerifySignature_WrongData_ReturnsFalse()
{
ECKeyPair keyPair = new KeyPairGenerator().Generate();
byte[] message = new BigInteger("968236873715988614170569073515315707566766479517").ToByteArray();
ECSigner signer = new ECSigner();
ECSignature signature = signer.Sign(keyPair, message);
// Change the message
message = new BigInteger("9682368737159881417056907351531570756676647951").ToByteArray();
ECVerifier verifier = new ECVerifier(keyPair);
Assert.False(verifier.Verify(signature, message));
}
/// <summary>
/// Mainly for testing purposes, it's used for authentifying a node. Note that
/// is doesn't launch the correponding event.
/// </summary>
/// <param name="handshakeMsg"></param>
internal void AuthentifyWith(Handshake handshakeMsg)
{
if (handshakeMsg == null)
{
FireInvalidAuth(RejectReason.AuthInvalidHandshakeMsg);
return;
}
_lastReceivedHandshake = handshakeMsg;
try
{
if (handshakeMsg.Version != GlobalConfig.ProtocolVersion)
{
FireInvalidAuth(RejectReason.AuthWrongVersion);
return;
}
DistantNodeKeyPair = ECKeyPair.FromPublicKey(handshakeMsg.PublicKey.ToByteArray());
if (DistantNodeKeyPair == null)
{
FireInvalidAuth(RejectReason.AuthInvalidKey);
return;
}
// verify sig
ECVerifier verifier = new ECVerifier(DistantNodeKeyPair);
bool sigValid = verifier.Verify(
new ECSignature(handshakeMsg.R.ToByteArray(), handshakeMsg.S.ToByteArray()),
handshakeMsg.NodeInfo.ToByteArray());
if (!sigValid)
{
FireInvalidAuth(RejectReason.AuthInvalidSig);
return;
}
}
catch (Exception)
{
FireInvalidAuth(RejectReason.AuthInvalidKey);
return;
}
IsAuthentified = true;
}
static void Main(string[] args)
{
ECKeyPair keyPair = KeyPairGenerator.Generate();
//Console.WriteLine(privateKey.ToString() + Environment.NewLine);
// Fake data
byte[] message = new BigInteger("968236873715988614170569073515315707566766479517").ToByteArray();
ECSigner signer = new ECSigner();
ECSignature signature = signer.Sign(keyPair, message);
message = new BigInteger("9682368737159881417056907351531570756676647951").ToByteArray();
ECVerifier verifier = new ECVerifier(keyPair);
bool isGood = verifier.Verify(signature, message);
Console.WriteLine(isGood);
}
public async Task Mine()
{
var chain = await _mock.CreateChain();
// create miner
var keypair = new KeyPairGenerator().Generate();
var minerconfig = _mock.GetMinerConfig(chain.Id, 10, keypair.GetAddress().DumpByteArray());
ChainConfig.Instance.ChainId = chain.Id.DumpHex();
NodeConfig.Instance.NodeAccount = keypair.GetAddressHex();
var txPool = _mock.CreateTxPool();
txPool.Start();
var txs = CreateTx(chain.Id);
foreach (var tx in txs)
{
await txPool.AddTransactionAsync(tx);
}
var manager = _mock.MinerClientManager();
var miner = _mock.GetMiner(minerconfig, txPool, manager);
GrpcLocalConfig.Instance.ClientToSideChain = false;
GrpcLocalConfig.Instance.WaitingIntervalInMillisecond = 10;
NodeConfig.Instance.ECKeyPair = keypair;
miner.Init();
var block = await miner.Mine();
Assert.NotNull(block);
Assert.Equal(GlobalConfig.GenesisBlockHeight + 1, block.Header.Index);
byte[] uncompressedPrivKey = block.Header.P.ToByteArray();
Address addr = Address.FromRawBytes(uncompressedPrivKey);
Assert.Equal(minerconfig.CoinBase, addr);
ECKeyPair recipientKeyPair = ECKeyPair.FromPublicKey(uncompressedPrivKey);
ECVerifier verifier = new ECVerifier(recipientKeyPair);
Assert.True(verifier.Verify(block.Header.GetSignature(), block.Header.GetHash().DumpByteArray()));
}
public bool Verify(Transaction tx)
{
if (tx.P == null)
{
return(false);
}
var pubKey = tx.P.ToByteArray();
var addr = Address.FromRawBytes(pubKey);
if (!addr.Equals(tx.From))
{
return(false);
}
var keyPair = ECKeyPair.FromPublicKey(pubKey);
var verifier = new ECVerifier(keyPair);
return(verifier.Verify(tx.GetSignature(), tx.GetHash().DumpByteArray()));
}
/// <summary>
/// verify signature in tx
/// </summary>
/// <param name="tx"></param>
/// <returns></returns>
public static bool VerifySignature(this Transaction tx)
{
if (tx.Sig == null)
{
return(false);
}
byte[] uncompressedPrivKey = tx.P.ToByteArray();
var addr = Address.FromRawBytes(uncompressedPrivKey);
// Hash addr = uncompressedPrivKey.Take(ECKeyPair.AddressLength).ToArray();
if (!addr.Equals(tx.From))
{
return(false);
}
ECKeyPair recipientKeyPair = ECKeyPair.FromPublicKey(uncompressedPrivKey);
ECVerifier verifier = new ECVerifier(recipientKeyPair);
return(verifier.Verify(tx.GetSignature(), tx.GetHash().DumpByteArray()));
}
