public bool IsCertificateSignatureValid()
{
var signer = new EthereumMessageSigner();
var recoveredAddress = signer.EcRecover(ImmunityCertificate.GetHashCertificate(), Signature.ToHex());
return(recoveredAddress.IsTheSameAddress(ImmunityCertificate.SignerAddress));
}
public async void ShouldDoFullValidation()
{
var owner = new Nethereum.Web3.Accounts.Account("0xb1939d6c8c73d6aa5ad97873c2f99a2dfc2b4c356acfd5338caff20392d7960d");
var signer = new Nethereum.Web3.Accounts.Account("0xa83369462189d7cc3d2aed78614d0df89f4d9651770fef9fc64b05acf7464a7f");
var guardian = new Nethereum.Web3.Accounts.Account("0xa0f2dd3adc8b79603f92736ac50843f1c5344514505b042369efdab105e9442b");
var immunityCertificate = new ImmunityCertificate();
immunityCertificate.OwnerAddress = owner.Address;
immunityCertificate.SignerAddress = signer.Address;
immunityCertificate.TestKitId = "TestKit1";
immunityCertificate.PhotoId = "QmbtqAxAnEqumx9k8wx8yxyANpC5vVwvQsdSWUQof9NP2o".DecodeBase58();
immunityCertificate.TestCentreId = "100";
immunityCertificate.Guardians = new System.Collections.Generic.List <string> {
guardian.Address
};
immunityCertificate.SetExpiryDate(DateTime.Now.AddDays(1000));
var signature = new EthereumMessageSigner().Sign(immunityCertificate.GetHashCertificate(), new EthECKey(signer.PrivateKey));
var signedCertificate = new SignedImmunityCertificate(immunityCertificate, signature);
var web3 = _ethereumClientIntegrationFixture.GetWeb3();
//admin deployer
var account = AccountFactory.GetAccount();
//simple deployment
//var web3 = new Nethereum.Web3.Web3(new Nethereum.Web3.Accounts.Account("0xb5b1870957d373ef0eeffecc6e4812c0fd08f554b37b233526acc331bf1544f7"), "https://ropsten.infura.io/v3/7238211010344719ad14a89db874158c");
var tokenService = await Covid19CertificationService.DeployContractAndGetServiceAsync(web3, new Covid19CertificationDeployment());
var address = tokenService.ContractHandler.ContractAddress;
//Add Test Centre
var receiptAddTestCentre = await tokenService.UpsertTestCentreRequestAndWaitForReceiptAsync(new TestCentre()
{
TestCentreId = "100", Invalid = false
});
//Add Test Centre Owner
var receiptAddTestCentreOwner = await tokenService.UpsertTestCentreOwnerRequestAndWaitForReceiptAsync("100".ToUTF8Bytes(), account.Address, true);
//Add Test Centre Certificate Signer
var receiptAddTestCentreSigner = await tokenService.UpsertTestCentreCertSignerRequestAndWaitForReceiptAsync(new TestCentreCertSigner()
{
TestCentreId = "100", SignerAddress = signer.Address, Invalid = false, ExpiryDate = 0
});
var challenge = "testtest";
var challengeSigner = new EthereumMessageSigner();
var signatureOwner = challengeSigner.EncodeUTF8AndSign(challenge, new EthECKey(owner.PrivateKey));
var certificateText = signedCertificate.GenerateFullCertificate();
Assert.True(await tokenService.FullVerificationCertificateChallengeWithSignatureQueryAsync(signedCertificate, challenge, signatureOwner.HexToByteArray(), DateTimeOffset.Now.ToUnixTimeSeconds()));
var signatureGuardian = challengeSigner.EncodeUTF8AndSign(challenge, new EthECKey(guardian.PrivateKey));
Assert.True(await tokenService.FullVerificationCertificateChallengeWithSignatureQueryAsync(signedCertificate, challenge, signatureGuardian.HexToByteArray(), DateTimeOffset.Now.ToUnixTimeSeconds()));
}
public void ShouldCreateAFullCertificate()
{
var immunityCertificate = new ImmunityCertificate();
immunityCertificate.OwnerAddress = "0x12890d2cce102216644c59daE5baed380d84830c";
immunityCertificate.SignerAddress = "0x12890d2cce102216644c59daE5baed380d84830c";
immunityCertificate.TestKitId = "TestKit1";
immunityCertificate.PhotoId = "QmbtqAxAnEqumx9k8wx8yxyANpC5vVwvQsdSWUQof9NP2o".DecodeBase58();
immunityCertificate.TestCentreId = "100";
immunityCertificate.Guardians = new System.Collections.Generic.List <string> {
"0x12890d2cce102216644c59daE5baed380d84830c"
};
immunityCertificate.ExpiryDate = 10000;
var signature = new EthereumMessageSigner().Sign(immunityCertificate.GetHashCertificate(), new EthECKey("0xb5b1870957d373ef0eeffecc6e4812c0fd08f554b37b233526acc331bf1544f7"));
var signedCertificate = new SignedImmunityCertificate(immunityCertificate, signature);
Assert.True(signedCertificate.IsCertificateSignatureValid());
var fullCertificate = signedCertificate.GenerateFullCertificate();
Assert.Equal("0x12890d2cce102216644c59daE5baed380d84830c,0x12890d2cce102216644c59daE5baed380d84830c,100,QmbtqAxAnEqumx9k8wx8yxyANpC5vVwvQsdSWUQof9NP2o,10000,TestKit1,0x12890d2cce102216644c59daE5baed380d84830c,a557275c55368d1ce2a2c7a0009de2bc8945eada0a6590b1b61de83c10b1a6507e5abbf3291e4527c180d3917f96f4b2fed3b26f69918130eba1dc25c79d69361b", fullCertificate);
var signedCertificate2 = new SignedImmunityCertificate(fullCertificate);
Assert.True(signedCertificate2.IsCertificateSignatureValid());
Assert.Equal("0x12890d2cce102216644c59daE5baed380d84830c,0x12890d2cce102216644c59daE5baed380d84830c,100,QmbtqAxAnEqumx9k8wx8yxyANpC5vVwvQsdSWUQof9NP2o,10000,TestKit1,0x12890d2cce102216644c59daE5baed380d84830c,a557275c55368d1ce2a2c7a0009de2bc8945eada0a6590b1b61de83c10b1a6507e5abbf3291e4527c180d3917f96f4b2fed3b26f69918130eba1dc25c79d69361b", signedCertificate2.GenerateFullCertificate());
}
public bool VerifySignature(string message, string signature, string pubKey)
{
var signer = new EthereumMessageSigner();
var account = signer.EncodeUTF8AndEcRecover(message, signature);
return(string.Equals(account, pubKey, System.StringComparison.InvariantCultureIgnoreCase));
}
static async Task SigningMessage()
{
try
{
// Setup
var url = "http://127.0.0.1:8502";
var privateKey = "0x82E41304BB1E81A848BFC705CB06FEDB0554A9906744EB225820A3CF3CF40A79";
var account = new Account(privateKey);
var web3 = new Web3(account, url);
// An already-deployed SimpleStorage.sol contract on Rinkeby:
var contractAddress = "0xcf5636b4c062262b52e00455b04b1c89d3c04d11";
var service = new StorageService(web3, contractAddress);
//Signing
var msg1 = "wee test message 18/09/2017 02:55PM";
var signer1 = new EthereumMessageSigner();
var ethKey = new EthECKey(privateKey);
var signature1 = signer1.EncodeUTF8AndSign(msg1, ethKey);
Console.WriteLine($"Signature: {signature1}");
Console.WriteLine($"Public address from Key: {ethKey.GetPublicAddress()}");
//get accounts addresses
var accounts = await web3.Eth.Accounts.SendRequestAsync();
Console.WriteLine($"Public address from eth Accounts: {accounts[0]}");
//Recover signature
var addressRec1 = signer1.EncodeUTF8AndEcRecover(msg1, signature1);
Console.WriteLine($"Recovered address from signature: {addressRec1}");
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
public async void ShouldInValidateChallengeNotValidCertificateSignature()
{
var incorrectowner = new Nethereum.Web3.Accounts.Account("0xb1939d6c8c73d6aa5ad97873c2f99a2dfc2b4c356acfd5338caff20392d7960d");
var signer = new Nethereum.Web3.Accounts.Account("0xa83369462189d7cc3d2aed78614d0df89f4d9651770fef9fc64b05acf7464a7f");
//var guardian = new Nethereum.Web3.Accounts.Account("0xa0f2dd3adc8b79603f92736ac50843f1c5344514505b042369efdab105e9442b");
var immunityCertificate = new ImmunityCertificate();
immunityCertificate.OwnerAddress = signer.Address; //owner is the signer so the ow
immunityCertificate.SignerAddress = signer.Address;
immunityCertificate.TestKitId = "TestKit1";
immunityCertificate.PhotoId = "QmbtqAxAnEqumx9k8wx8yxyANpC5vVwvQsdSWUQof9NP2o".DecodeBase58();
immunityCertificate.TestCentreId = "100";
// no guardians
// immunityCertificate.Guardians = new System.Collections.Generic.List<string> { guardian.Address };
immunityCertificate.SetExpiryDate(DateTime.Now.AddDays(1000));
var signature = new EthereumMessageSigner().Sign(immunityCertificate.GetHashCertificate(), new EthECKey(signer.PrivateKey));
var signedCertificate = new SignedImmunityCertificate(immunityCertificate, signature);
var web3 = _ethereumClientIntegrationFixture.GetWeb3();
var tokenService = await Covid19CertificationService.DeployContractAndGetServiceAsync(web3, new Covid19CertificationDeployment());
var challenge = "testtest";
var challengeSigner = new EthereumMessageSigner();
var signatureOwner = challengeSigner.EncodeUTF8AndSign(challenge, new EthECKey(incorrectowner.PrivateKey));
Assert.False(await tokenService.VerifyCertificateChallengeSignatureQueryAsync(signedCertificate, challenge, signatureOwner.HexToByteArray()));
}
public void ShouldValidateSignature()
{
var domain = "login.xyz";
var address = "0xb8a316ea8a9e48ebd25b73c71bc0f22f5c337d1f";
var statement = "Sign-In With Ethereum Example Statement";
var uri = "https://login.xyz";
var version = "1";
var chainId = "1";
var nonce = "uolthxpe";
var issuedAt = "2021-11-25T02:36:37.013Z";
var signature = "0x6eabbdf0861ca83b6cf98381dcbc3db16dffce9a0449dc8b359718d13b0093c3285b6dea7e84ad1aa4871b63899319a988ddf39df3080bcdc60f68dd0942e8221c";
var message =
"login.xyz wants you to sign in with your Ethereum account:\n0xb8a316ea8a9e48ebd25b73c71bc0f22f5c337d1f\n\nSign-In With Ethereum Example Statement\n\nURI: https://login.xyz\nVersion: 1\nChain ID: 1\nNonce: uolthxpe\nIssued At: 2021-11-25T02:36:37.013Z";
var siweMessage = new SiweMessage();
siweMessage.Domain = domain;
siweMessage.Address = address;
siweMessage.Statement = statement;
siweMessage.Uri = uri;
siweMessage.Version = version;
siweMessage.ChainId = chainId;
siweMessage.Nonce = nonce;
siweMessage.IssuedAt = issuedAt;
siweMessage.Signature = signature;
var builtMessage = SiweMessageStringBuilder.BuildMessage(siweMessage);
Assert.Equal(message, builtMessage);
var messageSigner = new EthereumMessageSigner();
var accountRecovered = messageSigner.EncodeUTF8AndEcRecover(builtMessage, signature);
Assert.True(accountRecovered.IsTheSameAddress(address));
}
public bool VerifyMessage(string aMessage, string aSignature, out string aAddress)
{
bool lResult = false;
if (!FAddresses.Any())
{
GetAddress(0);
GetAddress(1);
}
string lOutputAddress;
try
{
var lSigner = new EthereumMessageSigner();
lOutputAddress = lSigner.EncodeUTF8AndEcRecover(aMessage, aSignature);
}
catch
{
lOutputAddress = null;
}
if (lOutputAddress != null)
{
lResult = FAddresses.Keys.Any(lAddress => string.Equals(lAddress.ToLowerInvariant(), lOutputAddress.ToLowerInvariant(), StringComparison.OrdinalIgnoreCase));
}
aAddress = lOutputAddress;
return(lResult);
}
internal static string GetAddressSignature(string privateKey, ECurrency currency, Environment environment)
{
if (string.IsNullOrWhiteSpace(privateKey))
{
throw new ArgumentNullException(nameof(privateKey));
}
string timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString();
string signature = null;
if (currency == ECurrency.BTC)
{
BitcoinSecret secret = new BitcoinSecret(privateKey, environment.Network);
signature = secret.PrivateKey.SignMessage(timestamp);
}
else if (currency.IsGluwaCoinCurrency())
{
var signer = new EthereumMessageSigner();
signature = signer.EncodeUTF8AndSign(timestamp, new EthECKey(privateKey));
}
else
{
throw new ArgumentOutOfRangeException($"Unsupported currency: {currency}");
}
string signatureToEncode = $"{timestamp}.{signature}";
byte[] signatureByte = Encoding.UTF8.GetBytes(signatureToEncode);
string encodedData = Convert.ToBase64String(signatureByte);
return(encodedData);
}
public void ShouldBuildANewMessageWithANewNonceAndValidateAfterSigning_UsingInMemoryNonceManagement()
{
var domain = "login.xyz";
var address = "0x12890d2cce102216644c59daE5baed380d84830c";
var statement = "Sign-In With Ethereum Example Statement";
var uri = "https://login.xyz";
var chainId = "1";
var siweMessage = new SiweMessage();
siweMessage.Domain = domain;
siweMessage.Address = address;
siweMessage.Statement = statement;
siweMessage.Uri = uri;
siweMessage.ChainId = chainId;
siweMessage.SetExpirationTime(DateTime.Now.ToUniversalTime().AddHours(1));
var service = new SiweMessageService(new InMemoryStorageSessionNonceManagement());
var message = service.BuildMessageToSign(siweMessage);
var messageSigner = new EthereumMessageSigner();
var signature = messageSigner.EncodeUTF8AndSign(message,
new EthECKey("0xb5b1870957d373ef0eeffecc6e4812c0fd08f554b37b233526acc331bf1544f7"));
siweMessage.Signature = signature;
Assert.True(service.HasMessageDateStartedAndNotExpired(siweMessage));
Assert.True(service.IsMessageSessionNonceValid(siweMessage));
Assert.True(service.IsMessageSignatureValid(siweMessage));
Assert.True(service.IsValidMessage(siweMessage));
}
// Recover public address from signature and message
public string RecoverPersonalSignature(string message, string signature)
{
EthereumMessageSigner signer = new EthereumMessageSigner();
string publicAddress = signer.EncodeUTF8AndEcRecover(message, signature);
return(publicAddress);
}
public static string GetSignatureHexString(this Buyer.Po po, string privateKeyHex)
{
privateKeyHex = privateKeyHex.EnsureHexPrefix();
var hashEncoded = new ABIEncode().GetSha3ABIEncoded(new ABIValue(new TupleType(), po));
var signature = new EthereumMessageSigner().Sign(hashEncoded, privateKeyHex);
return(signature);
}
public Task <string> SignMessageAsync(string message)
{
Ensure.ArgumentCondition(!string.IsNullOrEmpty(message), "message cannot be null", nameof(message));
var signer = new EthereumMessageSigner();
var signedMessage = signer.EncodeUTF8AndSign(message, new EthECKey(((Web3.Accounts.Account)Account).PrivateKey));
return(Task.FromResult(signedMessage));
}
protected async Task SignMessage()
{
var signer1 = new EthereumMessageSigner();
var key = new EthECKey(PrivateKey);
var signature1 = signer1.EncodeUTF8AndSign(Message, key);
SignedMessage = signature1;
AccountAddress = key.GetPublicAddress();
}
private async Task <string> RelayTransaction(
Relay relay,
TransactionInput transaction,
string hubAddress)
{
var nonce = await _relayHubManager
.GetNonceAsync(hubAddress, transaction.From)
.ConfigureAwait(false);
var hash = GetTransactionHash(
transaction.From,
transaction.To,
transaction.Data,
relay.Fee,
transaction.GasPrice.Value,
transaction.Gas.Value,
nonce,
hubAddress,
relay.Address);
var signer = new EthereumMessageSigner();
var signature = signer.Sign(hash.HexToByteArray(), _privateKey);
var approvalDataSig = signer.Sign(
GetApprovalData(
transaction,
relay.Fee,
transaction.GasPrice.Value,
transaction.Gas.Value,
nonce,
hubAddress,
relay.Address),
_privateKey);
var transactionCount = await _ethApiContractService.Transactions.GetTransactionCount
.SendRequestAsync(relay.Address)
.ConfigureAwait(false);
var relayMaxNonce = transactionCount.Value + new BigInteger(_options.AllowedRelayNonceGap);
var txHash = await SendViaRelay(
relay.Url,
transaction,
relay.Fee,
transaction.GasPrice.Value,
transaction.Gas.Value,
nonce,
hubAddress,
relay.Address,
signature,
approvalDataSig,
relayMaxNonce)
.ConfigureAwait(false);
return(txHash);
}
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 ShouldVerifyMEWSignatureEncodingMessageAsUTF8()
{
var address = "0xe651c5051ce42241765bbb24655a791ff0ec8d13";
var msg = "wee test message 18/09/2017 02:55PM";
var sig = "0xf5ac62a395216a84bd595069f1bb79f1ee08a15f07bb9d9349b3b185e69b20c60061dbe5cdbe7b4ed8d8fea707972f03c21dda80d99efde3d96b42c91b2703211b";
var signer = new EthereumMessageSigner();
var addressRec = signer.EncodeUTF8AndEcRecover(msg, sig);
Assert.Equal(address.ToLower(), addressRec.ToLower());
}
public void ShouldSignAndVerifyEncodingMessageAsUTF8()
{
var address = "0x12890d2cce102216644c59dae5baed380d84830c";
var msg = "wee test message 18/09/2017 02:55PM";
var privateKey = "0xb5b1870957d373ef0eeffecc6e4812c0fd08f554b37b233526acc331bf1544f7";
var signer = new EthereumMessageSigner();
var signature = signer.EncodeUTF8AndSign(msg, new EthECKey(privateKey));
var addressRec = signer.EncodeUTF8AndEcRecover(msg, signature);
Assert.Equal(address.ToLower(), addressRec.ToLower());
}
public Signature Sign(Model model)
{
var signer = new EthereumMessageSigner();
var hash = SoliditySHA3(model);
if (logger.IsEnabled(LogLevel.Debug))
{
logger.LogDebug("signing model {0} , {1} bytes", model, hash.ToHex().EnsureHexPrefix());
}
return(Signature.Of(signer.HashAndSign(hash, new EthECKey(privateKey))));
}
public bool IsMessageSignatureValid(SiweMessage siweMessage)
{
var builtMessage = SiweMessageStringBuilder.BuildMessage(siweMessage);
var messageSigner = new EthereumMessageSigner();
var accountRecovered = messageSigner.EncodeUTF8AndEcRecover(builtMessage, siweMessage.Signature);
if (accountRecovered.IsTheSameAddress(siweMessage.Address))
{
return(true);
}
return(false);
}
public void test5()
{
var signature =
"0x7c87377d7a148ee69ec5ed9be2c87033639b6970acf9a8e165e81cf3dce4516d2bdcc6957eb435447ef9eaa34f541a81f999f0b967bfbfcca1850f58f4cdf5fe1c";
var text = "0x492d0fd814940d1375225a7e10905585b72b0a8c;-7440852294285764000;636706243532255384";
var hasher = new Sha3Keccack();
var hash = hasher.CalculateHash(text);
var signer = new EthereumMessageSigner();
var account = signer.EncodeUTF8AndEcRecover(text, signature);
Assert.Equal("0x492d0fd814940d1375225a7e10905585b72b0a8c".ToLower(), account.EnsureHexPrefix().ToLower());
}
private string getTimestampSignature(string privateKey)
{
var signer = new EthereumMessageSigner();
string Timestamp = new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds().ToString();
string signature = signer.EncodeUTF8AndSign(Timestamp, new EthECKey(privateKey));
string gluwaSignature = $"{Timestamp}.{signature}";
byte[] gluwaSignatureByte = Encoding.UTF8.GetBytes(gluwaSignature);
string encodedData = System.Convert.ToBase64String(gluwaSignatureByte);
return(encodedData);
}
public RecoverModel EcRecover(Address sender, Signature signature, Hash hash)
{
var ethereumSigner = new EthereumMessageSigner();
var signer = Address.Of(ethereumSigner.EcRecover(hash.GetBytes(), signature));
logger.LogDebug("Hash {0} , Signature {1}, Signer {2}, Sender {3}", hash, signature, signer, sender);
return(new RecoverModel {
Signer = signer,
Hash = hash,
Valid = signer == sender
});
}
public string RecoveryBouncy()
{
EthECKey.SignRecoverable = false;
var signature =
"0x0976a177078198a261faf206287b8bb93ebb233347ab09a57c8691733f5772f67f398084b30fc6379ffee2cc72d510fd0f8a7ac2ee0162b95dc5d61146b40ffa1c";
var text = "test";
var hasher = new Sha3Keccack();
var hash = hasher.CalculateHash(text);
var signer = new EthereumMessageSigner();
var account = signer.EcRecover(hash.HexToByteArray(), signature);
return(account);
}
public async void SigningTestSimple()
{
// The message itself, this is what is being signed
var msg = "test message 1234567890";
//var privateKey = "0xb5b1870957d373ef0eeffecc6e4812c0fd08f554b37b233526acc331bf1544f7";
var web3 = new Web3(new Account(_privateKey), _blockchainUrl);
// SIGN. Doesnt need web3, done offline.
// In: Message, Signer Private Key
// Out: Signature (65 bytes)
Log("--- SIGN with Nethereum ---");
var signer = new EthereumMessageSigner();
var signature = signer.HashAndSign(msg, _privateKey);
Log($"signature: {signature} is for message: {msg}");
Log("");
// RECOVER with Nethereum
// In: Message, Signature
// Out: Signer Address
Log("--- RECOVER with Nethereum ---");
var signerAddressRecoveredNethereum = signer.HashAndEcRecover(msg, signature);
Log($"Actual Signer address using C# HashAndEcRecover: {signerAddressRecoveredNethereum}");
Log($"Expected Signer address: {web3.TransactionManager.Account.Address}"); // since web3 created using same private key as was used to sign
Log("");
// RECOVER with Solidity
// In: Message, Signature
// Out: Signer Address
Log("--- RECOVER with Solidity ---");
Log($"Deploying contract SignatureChecker...");
var signatureCheckerDeployment = new SignatureCheckerDeployment();
var signatureCheckerService = await SignatureCheckerService.DeployContractAndGetServiceAsync(web3, signatureCheckerDeployment);
Log($"SignatureChecker contract address is: {signatureCheckerService.ContractHandler.ContractAddress}");
var bytesForSignature = signature.HexToByteArray();
var signerAddressRecoveredSolidity = await signatureCheckerService.GetSignerAddressFromMessageAndSignatureQueryAsync(msg, bytesForSignature);
Log($"Actual Signer Address Recovered using Solidity: {signerAddressRecoveredSolidity}");
signerAddressRecoveredSolidity.Should().Be(signerAddressRecoveredNethereum.ToLowerInvariant());
// See Solidity code Channels\Channels.Contracts\Contracts\SignatureChecker.sol:
// // this recreates the message that was signed on the client
// bytes32 messageAsClient = prefixed(keccak256(abi.encodePacked(message)));
}
public AuthenticationService(EthereumMessageSigner ethereumMessageSigner,
IClock clock,
IUserRepository userRepository,
MailService mailService,
MailTokenService mailTokenService,
IMemoryCache memoryCache)
{
_ethereumMessageSigner = ethereumMessageSigner;
_clock = clock;
_userRepository = userRepository;
_mailService = mailService;
_mailTokenService = mailTokenService;
_memoryCache = memoryCache;
_jwtSecurityTokenHandler = new JwtSecurityTokenHandler();
}
public string SignMessage(string aMessage, string aPublicAddress)
{
if (!FAddresses.Any())
{
GetAddress(0);
GetAddress(1);
}
if (!FAddresses.TryGetValue(aPublicAddress.ToLowerInvariant(), out long lIndex))
{
throw new ArgumentException("No private key found for provided address");
}
var lPrivateKey = GetPrivateKey(lIndex);
var lSigner = new EthereumMessageSigner();
return(lSigner.EncodeUTF8AndSign(aMessage, new EthECKey(lPrivateKey)));
}
/*hashing message and then signing it.
* debo llamar esto desde el controlador, cierto luis?
*/
public void HashAndSign()
{
if (Fmsg != null)
{
string FprivateKey = FCryptoCurrencyAdvocacy.GetPrivateKey(1);
var LSigner = new EthereumMessageSigner();
var LSignature = LSigner.HashAndSign(Fmsg, FprivateKey);
//example "0xb5b1870957d373ef0eeffecc6e4812c0fd08f554b37b233526acc331bf1544f7");
HashMsgRecover(LSigner);
}
else
{
throw new ArgumentNullException("Fmsg");
}
}
public void ShouldRecoverUsingShortcutHashes()
{
var signature = "0x0976a177078198a261faf206287b8bb93ebb233347ab09a57c8691733f5772f67f398084b30fc6379ffee2cc72d510fd0f8a7ac2ee0162b95dc5d61146b40ffa1c";
var text = "test";
var signer = new EthereumMessageSigner();
var account = signer.HashAndEcRecover(text, signature);
Assert.Equal("0x12890d2cce102216644c59dae5baed380d84830c", account.EnsureHexPrefix().ToLower());
signature = signer.HashAndSign(text,
"0xb5b1870957d373ef0eeffecc6e4812c0fd08f554b37b233526acc331bf1544f7");
account = signer.HashAndEcRecover(text, signature);
Assert.Equal("0x12890d2cce102216644c59dae5baed380d84830c".ToLower(), account.EnsureHexPrefix().ToLower());
}
/*
* When receiving a signature that has been made with a hashed
* file it’s necessary to start by hashing the file we want to verify and then recover the address that signed it.
*/
public void HashMsgRecover(EthereumMessageSigner LSigner)
{
if (LSigner != null)
{
//that code, will be refactor.. mmm
string FprivateKey = FCryptoCurrencyAdvocacy.GetPrivateKey(1);
var LSignature = LSigner.HashAndSign(Fmsg, FprivateKey);
//recover message
var addressRec2 = LSigner.HashAndEcRecover(Fmsg, LSignature);
}
else
{
throw new ArgumentNullException("Lsigner");
}
}
