public static byte[] AesCtrDecrypt(byte[] input, byte[] iv, byte[] key)
{
KeyStoreCrypto keyStoreCrypto = new KeyStoreCrypto();
byte[] decryptedMessage = keyStoreCrypto.GenerateAesCtrDeCipher(iv, key, input);
return(decryptedMessage);
}
public static byte[] AesCtrEncrypt(byte[] message, byte[] iv, byte[] key)
{
KeyStoreCrypto keyStoreCrypto = new KeyStoreCrypto();
byte[] encryptedMessage = keyStoreCrypto.GenerateAesCtrCipher(iv, key, message);
return(encryptedMessage);
}
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 override byte[] DecryptKeyStore(string password, KeyStore <Pbkdf2Params> keyStore)
{
if (password == null)
{
throw new ArgumentNullException(nameof(password));
}
if (keyStore == null)
{
throw new ArgumentNullException(nameof(keyStore));
}
return(KeyStoreCrypto.DecryptPbkdf2Sha256(password, keyStore.Crypto.Mac.HexToByteArray(),
keyStore.Crypto.CipherParams.Iv.HexToByteArray(),
keyStore.Crypto.CipherText.HexToByteArray(),
keyStore.Crypto.Kdfparams.Count,
keyStore.Crypto.Kdfparams.Salt.HexToByteArray(),
keyStore.Crypto.Kdfparams.Dklen));
}
protected override byte[] GenerateDerivedKey(string password, byte[] salt, ScryptParams kdfParams)
{
return(KeyStoreCrypto.GenerateDerivedScryptKey(KeyStoreCrypto.GetPasswordAsBytes(password), salt,
kdfParams.N, kdfParams.R,
kdfParams.P, kdfParams.Dklen));
}
public KeyStoreScryptService(IRandomBytesGenerator randomBytesGenerator, KeyStoreCrypto keyStoreCrypto) : base(
randomBytesGenerator, keyStoreCrypto)
{
}
protected override byte[] GenerateDerivedKey(string pasword, byte[] salt, Pbkdf2Params kdfParams)
{
return(KeyStoreCrypto.GeneratePbkdf2Sha256DerivedKey(pasword, salt, kdfParams.Count, kdfParams.Dklen));
}
protected KeyStoreServiceBase(IRandomBytesGenerator randomBytesGenerator)
{
RandomBytesGenerator = randomBytesGenerator;
KeyStoreCrypto = new KeyStoreCrypto();
}
protected KeyStoreServiceBase(IRandomBytesGenerator randomBytesGenerator, KeyStoreCrypto keyStoreCrypto)
{
RandomBytesGenerator = randomBytesGenerator;
KeyStoreCrypto = keyStoreCrypto;
}
/// <summary>
/// return address starts with '0x'.
/// </summary>
/// <param name="publickey"></param>
/// <returns></returns>
public static string PublicKeyToAddress(byte[] publickey)
{
byte[] hash = new KeyStoreCrypto().CalculateKeccakHash(publickey.Slice(1, publickey.Length));
byte[] address = hash.Slice(12, hash.Length);
return(address.ToHexString());
}
