/// <summary>
/// Signs using a predefined typed data schema and converts and encodes the provide the message value
/// </summary>
public string SignTypedDataV4 <T, TDomain>(T message, TypedData <TDomain> typedData, EthECKey key) where TDomain : IDomain
{
var encodedData = EncodeTypedData(message, typedData);
var signature = key.SignAndCalculateV(Sha3Keccack.Current.CalculateHash(encodedData));
return(EthECDSASignature.CreateStringSignature(signature));
}
/// <summary>
/// Encodes data according to EIP-712, hashes it and signs with <paramref name="key"/>.
/// Matches the signature produced by eth_signTypedData_v4
/// </summary>
public string SignTypedDataV4(TypedData typedData, EthECKey key)
{
var encodedData = EncodeTypedData(typedData);
var signature = key.SignAndCalculateV(Sha3Keccack.Current.CalculateHash(encodedData));
return(EthECDSASignature.CreateStringSignature(signature));
}
/// <summary>
/// 异步请求发送RPC交易
/// </summary>
/// <typeparam name="TResult">返回结果</typeparam>
/// <param name="txData">交易数据（rlp）</param>
/// <param name="txSignature">交易签名</param>
/// <returns>返回交易结果</returns>
protected async Task <TResult> SendRequestAysnc <TResult>(byte[][] txData, EthECDSASignature txSignature)
{
var rlpSignedEncoded = RLPEncoder.EncodeSigned(new SignedData(txData, txSignature), 10).ToHex();
var request = new RpcRequest(this._requestId, JsonRPCAPIConfig.SendRawTransaction, new object[] { this._requestObjectId, rlpSignedEncoded });
var response = await _rpcClient.SendRequestAsync <TResult>(request);
return(response);
}
/// <summary>
/// 请求发送RPC交易
/// </summary>
/// <typeparam name="TResult">返回结果</typeparam>
/// <param name="txData">交易数据（rlp）</param>
/// <param name="txSignature">交易签名</param>
/// <returns>返回交易结果</returns>
protected TResult SendRequest <TResult>(byte[][] txData, EthECDSASignature txSignature) where TResult : class, new()
{
var rlpSignedEncoded = RLPEncoder.EncodeSigned(new SignedData(txData, txSignature), 10).ToHex();
var request = new RpcRequestMessage(this._requestId, JsonRPCAPIConfig.SendRawTransaction, new object[] { this._requestObjectId, rlpSignedEncoded });
var result = HttpUtils.RpcPost <TResult>(this._url, request);
return(result);
}
public static string ToString(EthECDSASignature signature)
{
byte[] result = new byte[65];
byte[] rands = signature.To64ByteArray();
Array.Copy(rands, result, rands.Length);
result[result.Length - 1] = (byte)EthECKey.GetRecIdFromV(signature.V);
return(result.ToHex(true));
}
public static bool VerifySignature(string publicKey, byte[] signedData, byte[] dataHash)
{
var eth = new EthECKey(publicKey.HexToByteArray(), false);
var result = eth.Verify(dataHash, EthECDSASignature.FromDER(signedData));
return(result);
}
public SignedData(byte[][] data, EthECDSASignature signature)
{
Data = data;
if (signature != null)
{
R = signature.R;
S = signature.S;
V = signature.V;
}
}
public EthECDSASignature Sign(string contract, string makerAddress, string makerToken,
string takerToken, string makerAmount, string takerAmount, string expires, string nonce)
{
var plainData = new Object[]
{
contract,
takerToken,
BigInteger.Parse(takerAmount),
makerToken,
BigInteger.Parse(makerAmount),
BigInteger.Parse(expires),
BigInteger.Parse(nonce)
};
var prms = new[] {
new Parameter("address", 1),
new Parameter("address", 1),
new Parameter("uint256", 1),
new Parameter("address", 1),
new Parameter("uint256", 1),
new Parameter("uint256", 1),
new Parameter("uint256", 1)
};
var data = SolidityPack(plainData, prms);
var keystoreCrypto = new KeyStoreCrypto();
//for etherDelta its SHA256, for IDEX just change with SHA3
var hashed = keystoreCrypto.CalculateSha256Hash(data);
var signer = new EthereumMessageSigner();
var newHash = signer.HashPrefixedMessage(hashed);
var signatureRaw = signer.SignAndCalculateV(newHash, _userDataProvider.PrivateKey);
var signature = EthECDSASignature.CreateStringSignature(signatureRaw);
var probe = signer.EcRecover(hashed, signature);
var ethEcdsa = MessageSigner.ExtractEcdsaSignature(signature);
if (probe == makerAddress)
{
return(ethEcdsa);
}
//depending on usage, but it would be better to throw exc here if fails
return(null);
//throw new Exception("Signing failed");
}
public void SignPromise(EthECKey signingKey)
{
if (UserKeys.GetPublicKeyString(signingKey) != FromAddress)
{
throw new Exception("You cannot sign someone else's transaction.");
}
string promiseHash = CalculateHash();
byte[] msgBytes = Encoding.UTF8.GetBytes(promiseHash);
byte[] msgHash = new Sha3Keccack().CalculateHash(msgBytes);
Signature = signingKey.SignAndCalculateV(msgHash);
}
private byte[] Sign(byte[] hash, string privateKey)
{
var key = new EthECKey(privateKey.HexToByteArray(), true);
EthECDSASignature signature = key.SignAndCalculateV(hash);
//ToByteArrayUnsigned
var r = signature.R.ToHex();
var s = signature.S.ToHex();
var v = new[] { signature.V }.ToHex();
var arr = (r + s + v).HexToByteArray();
return(arr);
}
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());
}
/*
* deposit
* van
* crouch
* super
* viable
* electric
* bamboo
* nephew
* hold
* whip
* nation
* ankle
* wonder
* bottom
* win
* bomb
* dog
* search
* globe
* shrug
* primary
* spy
* limb
* knock
*/
public static async Task TestMessageSigning()
{
using (var trezorManager = await TrezorFactory.GetWindowsConnectedLedgerManagerAsync(GetPin))
{
await trezorManager.InitializeAsync();
var signer = new TrezorExternalSigner(trezorManager, 0);
var address = await signer.GetAddressAsync();
var messageSignature = await signer.SignAsync(Encoding.UTF8.GetBytes("Hello"));
var nethereumMessageSigner = new Nethereum.Signer.EthereumMessageSigner();
var nethereumMessageSignature = nethereumMessageSigner.EncodeUTF8AndSign("Hello", new EthECKey(
"0x2e14c29aaecd1b7c681154d41f50c4bb8b6e4299a431960ed9e860e39cae6d29"));
System.Console.WriteLine("Trezor: " + EthECDSASignature.CreateStringSignature(messageSignature));
System.Console.WriteLine("Nethereum: " + nethereumMessageSignature);
}
}
public static string GetSignature(byte[] output)
{
using (var memory = new MemoryStream(output))
{
using (var reader = new BinaryReader(memory))
{
byte[] sigV = reader.ReadBytes(1);
byte[] sigR = reader.ReadBytes(32);
byte[] sigS = reader.ReadBytes(32);
var signature = new EthECDSASignature(
new Org.BouncyCastle.Math.BigInteger(sigR),
new Org.BouncyCastle.Math.BigInteger(sigS),
sigV);
return(EthECDSASignature.CreateStringSignature(signature));
}
}
}
/// <summary>
/// Sign structured data
/// </summary>
/// <typeparam name="T">Structured data datatype</typeparam>
/// <param name="structure">Structured data to sign</param>
/// <param name="domain">EIP-712 domain</param>
/// <param name="privateKey">Ethereum private key</param>
/// <returns><see cref="EthereumSignature"/></returns>
/// <exception cref="ArgumentNullException">Any of the arguments is equal to <c>null</c></exception>
public static EthereumSignature Sign <T>(T structure, EIP712Domain domain, string privateKey) where T : class
{
if (structure == null)
{
throw new ArgumentNullException(nameof(structure));
}
if (domain == null)
{
throw new ArgumentNullException(nameof(domain));
}
if (privateKey == null)
{
throw new ArgumentNullException(nameof(privateKey));
}
EthECDSASignature sig = _signer.SignAndCalculateV(Hash(structure, domain), privateKey);
// Returning custom type since we do not want force lib users to install additional package (i.e. Nethereum)
return(new EthereumSignature(Util.PadBytes(sig.R, 32), Util.PadBytes(sig.S, 32), sig.V));
}
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");
}
private static void Main(string[] args)
{
//EthECKey privateKey = EthECKey.GenerateKey();
EthECKey privateKey = new EthECKey("97ddae0f3a25b92268175400149d65d6887b9cefaf28ea2c078e05cdc15a3c0a");
string message = "exercise-cryptography";
byte[] messageBytes = Utils.GetBytes(message);
byte[] messageHash = new Sha3Keccack().CalculateHash(messageBytes);
EthECDSASignature signature = privateKey.SignAndCalculateV(messageHash);
EthereumSignature result = new EthereumSignature
{
Signature = EncryptionUtils.ToString(signature),
V = string.Format("0x{0:X2}", EthECKey.GetRecIdFromV(signature.V)),
R = signature.R.ToHex(true),
S = signature.S.ToHex(true)
};
string output = JsonUtils.Serialize(result);
File.WriteAllText("../../../Output.json", output);
Console.WriteLine(output);
}
public static void Sign()
{
string[] input = File.ReadAllLines("../../Input.txt");
string inputKey = input[0];
string inputMessage = input[1];
EthECKey privateKey = new EthECKey(inputKey);
byte[] messageBytes = Utils.GetBytes(inputMessage);
byte[] messageHash = new Sha3Keccack().CalculateHash(messageBytes);
EthECDSASignature ethECDSASignature = privateKey.SignAndCalculateV(messageHash);
EthereumSignature signature = new EthereumSignature
{
Address = privateKey.GetPublicAddress(),
Msg = inputMessage,
Sig = EncryptionUtils.ToString(ethECDSASignature),
Version = "1"
};
string output = JsonUtils.Serialize(signature);
File.WriteAllText("../../Output.json", output);
Console.WriteLine(output);
}
public void SetSignature(EthECDSASignature signature)
{
SimpleRlpSigner.SetSignature(signature);
}
public override bool VerifyMessage(byte[] data, byte[] signature, byte[] publicKey)
{
return(new EthECKey(publicKey, false)
.Verify(data, EthECDSASignature.FromDER(signature)));
}
public override bool VerifyHash(byte[] hash, byte[] signature)
{
return(GetEcKey()
.Verify(hash, EthECDSASignature.FromDER(signature)));
}
public override bool VerifyMessage(byte[] data, byte[] signature)
{
return(GetEcKey()
.Verify(data, EthECDSASignature.FromDER(signature)));
}
