static void Main()
{
//var privKey = EthECKey.GenerateKey();
var privKey = new EthECKey("97ddae0f3a25b92268175400149d65d6887b9cefaf28ea2c078e05cdc15a3c0a");
byte[] pubKeyCompressed = new ECKey(privKey.GetPrivateKeyAsBytes(), true).GetPubKey(true);
Console.WriteLine("Private key: {0}", privKey.GetPrivateKey().Substring(4));
Console.WriteLine("Public key: {0}", privKey.GetPubKey().ToHex().Substring(2));
Console.WriteLine("Public key (compressed): {0}", pubKeyCompressed.ToHex());
Console.WriteLine();
string msg = "Message for signing";
byte[] msgBytes = Encoding.UTF8.GetBytes(msg);
byte[] msgHash = new Sha3Keccack().CalculateHash(msgBytes);
var signature = privKey.SignAndCalculateV(msgHash);
Console.WriteLine("Msg: {0}", msg);
Console.WriteLine("Msg hash: {0}", msgHash.ToHex());
Console.WriteLine("Signature: [v = {0}, r = {1}, s = {2}]",
signature.V[0] - 27, signature.R.ToHex(), signature.S.ToHex());
Console.WriteLine();
var pubKeyRecovered = EthECKey.RecoverFromSignature(signature, msgHash);
Console.WriteLine("Recovered pubKey: {0}", pubKeyRecovered.GetPubKey().ToHex().Substring(2));
bool validSig = pubKeyRecovered.Verify(msgHash, signature);
Console.WriteLine("Signature valid? {0}", validSig);
}
/// <summary>
/// Returns HoardID that signed this transaction
/// </summary>
/// <param name="signatureStr"></param>
/// <param name="rlpEncodedTransaction"></param>
/// <returns>Signer of this transaction</returns>
public static HoardID RecoverHoardIdFromTransaction(string signatureStr, byte[] rlpEncodedTransaction)
{
if (string.IsNullOrEmpty(signatureStr))
{
return(null);
}
var signature = EthECDSASignatureFactory.ExtractECDSASignature(signatureStr);
var rawHash = new Nethereum.Util.Sha3Keccack().CalculateHash(rlpEncodedTransaction);
return(new HoardID(EthECKey.RecoverFromSignature(signature, rawHash).GetPublicAddress()));
}
public static bool verify(string dataStr, string signStr)
{
try
{
var sign = EthECDSASignatureFactory.ExtractECDSASignature(signStr);
var dataHash = new Sha3Keccack().CalculateHash(Encoding.UTF8.GetBytes(dataStr));
var pubKey = EthECKey.RecoverFromSignature(sign, dataHash);
return(pubKey.Verify(dataHash, sign));
}catch
{
return(false);
}
}
public string FullRoundRec()
{
EthECKey.SignRecoverable = true;
var key = EthECKey.GenerateKey();
var address = key.GetPublicAddress();
var signature = key.SignAndCalculateV(message);
var recAdress = EthECKey.RecoverFromSignature(signature, message).GetPublicAddress();
if (!address.IsTheSameAddress(recAdress))
{
Debug.WriteLine(key.GetPrivateKey());
}
return(recAdress);
}
public string Recover(string message, byte[] signature, bool preFixed)
{
var bytes = Encoding.ASCII.GetBytes(message);
if (!preFixed)
{
bytes = this.HashMessage(bytes);
}
var ecdaSignature = EthECDSASignatureFactory.ExtractECDSASignature(signature.ToHex());
return(Bech32.Encode("io",
Hash.Hash160B(EthECKey.RecoverFromSignature(ecdaSignature, bytes).GetPubKey().Slice(1))));
}
public bool IsValid()
{
if (FromAddress == null)
{
return(true);
}
if (Signature == null)
{
throw new Exception("No singature in this promise.");
}
byte[] hashBytes = Encoding.UTF8.GetBytes(CalculateHash());
EthECKey pubKeyRecovered = EthECKey.RecoverFromSignature(Signature, hashBytes);
return(pubKeyRecovered.Verify(hashBytes, Signature));
}
private static void Main(string[] args)
{
string input = File.ReadAllText("../../../Input.json");
EthereumSignature inputSignature = JsonConvert.DeserializeObject <EthereumSignature>(input);
byte[] messageBytes = Utils.GetBytes(inputSignature.Message);
byte[] messageHash = new Sha3Keccack().CalculateHash(messageBytes);
int recId = inputSignature.V.HexToByteArray()[0];
EthECDSASignature signature = EthECDSASignatureFactory.FromComponents(
inputSignature.R.HexToByteArray(),
inputSignature.S.HexToByteArray());
EthECKey publicKey = EthECKey.RecoverFromSignature(signature, recId, messageHash);
Console.WriteLine("Public address: {0}", publicKey.GetPublicAddress());
}
public async void ShouldRecoverRawTransactionFromRPCTransactionAndAccountSender()
{
var web3 = _ethereumClientIntegrationFixture.GetWeb3();
var toAddress = "0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe";
var transactionManager = web3.TransactionManager;
var fromAddress = transactionManager?.Account?.Address;
//Sending transaction
var transactionInput = EtherTransferTransactionInputBuilder.CreateTransactionInput(fromAddress, toAddress, 1.11m, 2);
//Raw transaction signed
var rawTransaction = await transactionManager.SignTransactionAsync(transactionInput).ConfigureAwait(false);
var txnHash = await web3.Eth.Transactions.SendRawTransaction.SendRequestAsync(rawTransaction).ConfigureAwait(false);
//Getting the transaction from the chain
var transactionRpc = await web3.Eth.Transactions.GetTransactionByHash.SendRequestAsync(txnHash).ConfigureAwait(false);
//Using the transanction from RPC to build a txn for signing / signed
var transaction = TransactionFactory.CreateLegacyTransaction(transactionRpc.To, transactionRpc.Gas, transactionRpc.GasPrice, transactionRpc.Value, transactionRpc.Input, transactionRpc.Nonce,
transactionRpc.R, transactionRpc.S, transactionRpc.V);
//Get the raw signed rlp recovered
var rawTransactionRecovered = transaction.GetRLPEncoded().ToHex();
//Get the account sender recovered
var accountSenderRecovered = string.Empty;
if (transaction is LegacyTransactionChainId)
{
var txnChainId = transaction as LegacyTransactionChainId;
accountSenderRecovered = EthECKey.RecoverFromSignature(transaction.Signature, transaction.RawHash, txnChainId.GetChainIdAsBigInteger()).GetPublicAddress();
}
else
{
accountSenderRecovered = EthECKey.RecoverFromSignature(transaction.Signature, transaction.RawHash).GetPublicAddress();
}
Assert.Equal(rawTransaction, rawTransactionRecovered);
Assert.Equal(web3.TransactionManager.Account.Address, accountSenderRecovered);
}
public static void Verify()
{
string input = File.ReadAllText("../../Output.json");
EthereumSignature inputSignature = JsonConvert.DeserializeObject <EthereumSignature>(input);
string message = inputSignature.Msg;
byte[] messageBytes = Utils.GetBytes(message);
byte[] messageHash = new Sha3Keccack().CalculateHash(messageBytes);
byte[] rawSignature = inputSignature.Sig.HexToByteArray();
byte[] r = ArrayUtils.SubArray(rawSignature, 0, 32);
byte[] s = ArrayUtils.SubArray(rawSignature, 32, 32);
int recId = rawSignature[rawSignature.Length - 1];
EthECDSASignature signature = EthECDSASignatureFactory.FromComponents(r, s);
EthECKey publicKey = EthECKey.RecoverFromSignature(signature, recId, messageHash);
bool valid = publicKey.GetPublicAddress() == inputSignature.Address;
Console.WriteLine("{0}", valid ? "Valid" : "Invalid");
}
static void Main(string[] args)
{
KeyVaultClient kvc = new KeyVaultClient(new KeyVaultClient.AuthenticationCallback(GetToken));
var signer = new AzureKeyVaultExternalSigner(kvc, URI);
var publicKey = signer.GetPublicKeyAsync().Result;
System.Console.WriteLine(publicKey.ToHex());
var msgHash = new Util.Sha3Keccack().CalculateHash("Hello").HexToByteArray();
var ethExternalSigner = new EthECKeyExternalSigner(signer);
var signature = ethExternalSigner.SignAndCalculateVAsync(msgHash).Result;
var publicKeyRecovered = EthECKey.RecoverFromSignature(signature, msgHash);
System.Console.WriteLine(publicKeyRecovered.GetPubKey().ToHex());
var transfer = new TransferFunction();
transfer.To = "0x1996a57077877D38e18A1BE44A55100D77b8fA1D";
transfer.FromAddress = publicKeyRecovered.GetPublicAddress();
transfer.Value = 1;
transfer.Nonce = 1;
transfer.GasPrice = 100;
transfer.Gas = 1000;
var rpcClient = new RpcClient(new Uri("http://localhost:8545"));
var transactionInput = transfer.CreateTransactionInput("0x12890d2cce102216644c59daE5baed380d84830c");
var externalAccount = new ExternalAccount(ethExternalSigner, 1);
externalAccount.InitialiseAsync().Wait();
externalAccount.InitialiseDefaultTransactionManager(rpcClient);
var signature2 = externalAccount.TransactionManager.SignTransactionAsync(transactionInput).Result;
var transactionSigner = new TransactionSigner();
var publicKeyRecovered2 = transactionSigner.GetPublicKey(signature2, 1);
System.Console.WriteLine(publicKeyRecovered2.ToHex());
System.Console.ReadLine();
}
static void Main(string[] args)
{
//var credential = new DefaultAzureCredential(
// new DefaultAzureCredentialOptions
// {
// //VisualStudioTenantId = TENANT_ID,
// //VisualStudioCodeTenantId = TENANT_ID,
// });
var credential = new ClientSecretCredential(TENANT_ID, APP_ID, APP_PASSWORD);
var signer = new AzureKeyVaultExternalSigner(KEY_NAME, URI, credential);
var address = signer.GetAddressAsync().Result;
System.Console.WriteLine(address);
var msgHash = new Util.Sha3Keccack().CalculateHash("Hello").HexToByteArray();
var signature = signer.SignAsync(msgHash).Result;
var publicKeyRecovered = EthECKey.RecoverFromSignature(signature, msgHash);
System.Console.WriteLine(publicKeyRecovered.GetPubKey().ToHex());
var transfer = new TransferFunction();
transfer.To = "0x1996a57077877D38e18A1BE44A55100D77b8fA1D";
transfer.FromAddress = publicKeyRecovered.GetPublicAddress();
transfer.Value = 1;
transfer.Nonce = 1;
transfer.GasPrice = 100;
transfer.Gas = 1000;
var rpcClient = new RpcClient(new Uri("http://localhost:8545"));
var transactionInput = transfer.CreateTransactionInput("0x12890d2cce102216644c59daE5baed380d84830c");
var externalAccount = new ExternalAccount(signer, 1);
externalAccount.InitialiseAsync().Wait();
externalAccount.InitialiseDefaultTransactionManager(rpcClient);
var signature2 = externalAccount.TransactionManager.SignTransactionAsync(transactionInput).Result;
var publicKeyRecovered2 = TransactionVerificationAndRecovery.GetPublicKey(signature2);
var transactionFromSignature = TransactionFactory.CreateTransaction(signature2);
System.Console.WriteLine("Recovered public key");
System.Console.WriteLine(publicKeyRecovered2.ToHex());
System.Console.WriteLine("Recovered transaction Type");
System.Console.WriteLine(transactionFromSignature.TransactionType.ToString());
System.Console.WriteLine("Signing EIP1559");
var transferEip1559 = new TransferFunction();
transferEip1559.To = "0x1996a57077877D38e18A1BE44A55100D77b8fA1D";
transferEip1559.FromAddress = publicKeyRecovered.GetPublicAddress();
transferEip1559.Value = 1;
transferEip1559.Nonce = 1;
transferEip1559.MaxFeePerGas = 1000;
transferEip1559.MaxPriorityFeePerGas = 999;
transferEip1559.Gas = 1000;
var transactionInputEip1559 = transferEip1559.CreateTransactionInput("0x12890d2cce102216644c59daE5baed380d84830c");
var signature3 = externalAccount.TransactionManager.SignTransactionAsync(transactionInputEip1559).Result;
var publicKeyRecovered3 = TransactionVerificationAndRecovery.GetPublicKey(signature3);
var transactionFromSignatureEIP1559 = TransactionFactory.CreateTransaction(signature3);
System.Console.WriteLine("Recovered public key");
System.Console.WriteLine(publicKeyRecovered3.ToHex());
System.Console.WriteLine("Recovered transaction Type");
System.Console.WriteLine(transactionFromSignatureEIP1559.TransactionType.ToString());
System.Console.ReadLine();
}
public static EthECKey GetRecoveredKey(this RLPSigner signer)
{
return(EthECKey.RecoverFromSignature(signer.Signature, signer.RawHash));
}
