public byte[] GetAddress()
{
if (m_address != null)
{
return(m_address);
}
var pubKey = GetPublicKey();
if (pubKey.Length != 64)
{
pubKey = CryptoUtil.GetPublicKey(pubKey, false);
}
pubKey = ByteUtil.Contact(new byte[] { 0x04 }, pubKey);
var content = Sha3Util.Get256Hash(pubKey);
content = Ripemd160Manager.GetHash(content);
content = ByteUtil.Contact(new[] { ADDRESS_PREFIX, (byte)AddressType.Normal }, content);
var checksum = new byte[4];
Buffer.BlockCopy(Sha3Util.Get256Hash(content), 0, checksum, 0, 4);
m_address = ByteUtil.Contact(content, checksum.ToArray());
return(m_address);
}
public void Verify()
{
string publicKey = "N1X+Fv7soLknpZNtkdW5cRphgzFjqHmOJl9GvVahWxk=";
string message = Sha3Util.Sha3_256("test");
string signature = "bl7EyGwrdDIcHpizHUcDd4Ui34pQRv5VoM69WEPGNveZVOIXJbX3nWhvBvyGXaCxZIuu0THCo5g8PSr2NZJKBg==";
bool result = Iroha.Verify(publicKey, signature, message);
Assert.AreEqual(true, result);
}
public void Sha3_512()
{
string hash1 = "a69f73cca23a9ac5c8b567dc185a756e97c982164fe25859e0d1dcc1475c80a615b2123af1f5f94c11e3e9402c3ac558f500199d95b6d3e301758586281dcd26";
string hash2 = Sha3Util.Sha3_512("");
Assert.AreEqual(hash1, hash2);
string hash3 = "9ece086e9bac491fac5c1d1046ca11d737b92a2b2ebd93f005d7b710110c0a678288166e7fbe796883a4f2e9b3ca9f484f521d0ce464345cc1aec96779149c14";
string hash4 = Sha3Util.Sha3_512("test");
Assert.AreEqual(hash3, hash4);
}
public void Sha3_384()
{
string hash1 = "0c63a75b845e4f7d01107d852e4c2485c51a50aaaa94fc61995e71bbee983a2ac3713831264adb47fb6bd1e058d5f004";
string hash2 = Sha3Util.Sha3_384("");
Assert.AreEqual(hash1, hash2);
string hash3 = "e516dabb23b6e30026863543282780a3ae0dccf05551cf0295178d7ff0f1b41eecb9db3ff219007c4e097260d58621bd";
string hash4 = Sha3Util.Sha3_384("test");
Assert.AreEqual(hash3, hash4);
}
public void Sha3_256()
{
string hash1 = "a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a";
string hash2 = Sha3Util.Sha3_256("");
Assert.AreEqual(hash1, hash2);
string hash3 = "36f028580bb02cc8272a9a020f4200e346e276ae664e45ee80745574e2f5ab80";
string hash4 = Sha3Util.Sha3_256("test");
Assert.AreEqual(hash3, hash4);
}
public void Sign()
{
string publicKey = "N1X+Fv7soLknpZNtkdW5cRphgzFjqHmOJl9GvVahWxk=";
string privateKey = "aFJfbcedA7p6X0b6EdQNovfFtmq4YSGK/+Bw+XBrsnAEBpXRu+Qfw0559lgLwF2QusChGiDEkLAxPqodQH1kbA==";
KeyPair keyPair = new KeyPair(privateKey, publicKey);
string message = Sha3Util.Sha3_256("test");
string signature = "bl7EyGwrdDIcHpizHUcDd4Ui34pQRv5VoM69WEPGNveZVOIXJbX3nWhvBvyGXaCxZIuu0THCo5g8PSr2NZJKBg==";
string result = Iroha.Sign(keyPair, message);
Assert.AreEqual(signature, result);
}
public byte[] GetTransactionHash()
{
return(Sha3Util.Get256Hash(ByteUtil.Contact(
m_fromAccount.GetAddress(),
m_toAccount.GetAddress(),
CryptoUtil.PadToBigEndian(m_value, 128),
CryptoUtil.PadToBigEndian(m_nonce, 64),
CryptoUtil.PadToBigEndian(m_timestamp, 64),
m_data.ToByteArray(),
CryptoUtil.PadToBigEndian(m_chainId, 32),
CryptoUtil.PadToBigEndian(m_gasPrice, 128),
CryptoUtil.PadToBigEndian(m_gasLimit, 128)
)));
}
public static bool IsValidAddress(string address, AddressType type)
{
byte[] addressBytes;
try
{
addressBytes = Base58.Decode(address);
}
catch
{
return(false);
}
if (addressBytes.Length != ADDRESS_LENGTH)
{
return(false);
}
if (addressBytes[0] != ADDRESS_PREFIX)
{
return(false);
}
if (addressBytes[1] != (byte)type)
{
return(false);
}
var content = new byte[22];
Buffer.BlockCopy(addressBytes, 0, content, 0, 22);
var expectChecksum = new byte[4];
Buffer.BlockCopy(addressBytes, 22, expectChecksum, 0, 4);
var actualChecksum = new byte[4];
Buffer.BlockCopy(Sha3Util.Get256Hash(content), 0, actualChecksum, 0, 4);
return(expectChecksum.SequenceEqual(actualChecksum));
}
/**
* Address validation method.
*
* @static
* @param {String/Hash} addr - Account address.
* @param {Number} type - NormalType / ContractType
*
* @return {Boolean} Is address has correct format.
*
* @example
* if ( Account.isValidAddress("n1QZMXSZtW7BUerroSms4axNfyBGyFGkrh5") ) {
* // some code
* };
*/
public static bool IsValidAddress(string address, AddressType?type = null)
{
byte[] addBytes;
try {
addBytes = Base58.Decode(address);
if (addBytes.Length != ADDRESS_LENGTH)
{
return(false);
}
if (Convert.ToUInt32(addBytes[0]) != ADDRESS_PREFIX)
{
return(false);
}
uint typeUint;
if (type.HasValue)
{
typeUint = Convert.ToUInt32(type.Value);
if (typeUint != Convert.ToUInt32(addBytes[1]))
{
return(false);
}
}
else
{
typeUint = Convert.ToUInt32(addBytes[1]);
}
if (typeUint != (uint)AddressType.ContractType && typeUint != (uint)AddressType.NormalType)
{
return(false);
}
var content = addBytes.Slice(0, 22);
var checksum = addBytes.Slice(addBytes.Length - 4);
return(ByteUtil.Compare(Sha3Util.Get256Hash(content).Slice(0, 4), checksum));
}
catch (Exception ex)
{
return(false);
}
}
/**
* Convert transaction to hash by SHA3-256 algorithm.
*
* @return {Hash} hash of Transaction.
*
* @example
* var acc = Account.NewAccount();
*
* var tx = new Transaction({
* chainID: 1,
* from: acc,
* to: "n1SAeQRVn33bamxN4ehWUT7JGdxipwn8b17",
* value: 10,
* nonce: 12,
* gasPrice: 1000000,
* gasLimit: 2000000
* });
* var txHash = tx.hashTransaction();
* //Uint8Array(32) [211, 213, 102, 103, 23, 231, 246, 141, 20, 202, 210, 25, 92, 142, 162, 242, 232, 95, 44, 239, 45, 57, 241, 61, 34, 2, 213, 160, 17, 207, 75, 40]
*/
public byte[] HashTransaction()
{
var data = new Corepb.Data
{
Payload = ByteString.CopyFrom(_payLoadData),
Type = Enum.GetName(typeof(TxPayload), _payLoadType).ToLower()
};
var dataBuffer = data.ToByteArray();
var hash = Sha3Util.Get256Hash(ByteUtil.Merge(
_fromAccount.GetAddress(),
_toAccount.GetAddress(),
CryptoUtils.PadToBigEndian(_value.ToString("x"), 128),
CryptoUtils.PadToBigEndian(_nonce.ToString("x"), 64),
CryptoUtils.PadToBigEndian(_timestamp.ToString("x"), 64),
dataBuffer,
CryptoUtils.PadToBigEndian(_chainId.ToString("x"), 32),
CryptoUtils.PadToBigEndian(_gasPrice.ToString("x"), 128),
CryptoUtils.PadToBigEndian(_gasLimit.ToString("x"), 128))
);
return(hash);
}
/**
* Restore account from key and passphrase.
*
* @param {Key} input - Key Object.
* @param {Password} password - Provided password.
* @param {Boolean} nonStrict - Strict сase sensitivity flag.
*
* @return {@link Account} - Instance of Account restored from key and passphrase.
*/
public Account FromKey(Key input, string password)
{
var json = input;
if (json.version != KEYVERSION3 && json.version != KEYCURRENTVERSION)
{
throw new Exception("Not supported wallet version");
}
byte[] derivedKey = null;
KDFParams kdfparams = new KDFParams();
if (json.crypto.kdf == "scrypt")
{
kdfparams = json.crypto.kdfparams;
//derivedKey = Replicon.Cryptography.SCrypt.SCrypt.DeriveKey(Encoding.UTF8.GetBytes(password), kdfparams.salt.HexToByteArray(), (ulong)kdfparams.n, (uint)kdfparams.r, (uint)kdfparams.p, (uint)kdfparams.dklen);
derivedKey = ScryptUtil.Scrypt(Encoding.UTF8.GetBytes(password), kdfparams.salt.HexToByteArray(), kdfparams.n, kdfparams.r, kdfparams.p, kdfparams.dklen);
}
else if (json.crypto.kdf == "pbkdf2")
{
kdfparams = json.crypto.kdfparams;
if (kdfparams.prf != "hmac-sha256")
{
throw new Exception("Unsupported parameters to PBKDF2");
}
RNGCryptoServiceProvider crypto = new RNGCryptoServiceProvider();
crypto.GetBytes(kdfparams.salt.HexToByteArray());
Rfc2898DeriveBytes pbkdf2 = new Rfc2898DeriveBytes(Encoding.UTF8.GetBytes(password), kdfparams.salt.HexToByteArray(), kdfparams.c);
derivedKey = pbkdf2.GetBytes(kdfparams.dklen);
}
else
{
throw new Exception("Unsupported key derivation scheme");
}
var ciphertext = json.crypto.ciphertext.HexToByteArray();
byte[] mac;
if (json.version == KEYCURRENTVERSION)
{
var _derviedKey = new byte[32];
Array.Copy(derivedKey, 16, _derviedKey, 0, 32);
var iv = json.crypto.cipherparams.iv.HexToByteArray();
var cipher = json.crypto.cipher.HexToByteArray();
var _mac = new byte[_derviedKey.Length + ciphertext.Length + iv.Length + cipher.Length];
Array.Copy(_derviedKey, 0, _mac, 0, _derviedKey.Length);
Array.Copy(ciphertext, 0, _mac, _derviedKey.Length, ciphertext.Length);
Array.Copy(iv, 0, _mac, _derviedKey.Length + ciphertext.Length, iv.Length);
Array.Copy(cipher, 0, _mac, _derviedKey.Length + ciphertext.Length + iv.Length, cipher.Length);
mac = Sha3Util.Get256Hash(_mac);
}
else
{
// KeyVersion3
var _mac = new byte[derivedKey.Slice(16, 32).Length + ciphertext.Length];
mac = Sha3Util.Get256Hash(_mac);
}
if (mac.ToHex() != json.crypto.mac)
{
throw new Exception("Key derivation failed - possibly wrong passphrase");
}
Aes128CTR aes = new Aes128CTR(json.crypto.cipherparams.iv.HexToByteArray());
byte[] src = ciphertext;
byte[] dest = new byte[0];
using (ICryptoTransform decrypt = aes.CreateDecryptor(derivedKey.Slice(0, 16), null))
{
dest = decrypt.TransformFinalBlock(src, 0, src.Length);
}
var _seed = new byte[src.Length + dest.Length];
var seed = new byte[32];
CryptoUtils.Zeros(seed);
Array.Copy(_seed, 0, seed, 32 - _seed.Length, _seed.Length);
SetPrivateKey(seed);
return(this);
}
/**
* Generate key by passphrase and options.
*
* @param {Password} password - Provided password.
* @param {KeyOptions} opts - Key options.
*
* @return {Key} Key Object.
*
* @example var key = account.toKey("passphrase");
*/
public Key ToKey(string password, KeyOptions opts = null)
{
byte[] derivedKey;
if (opts.kdf == KDFEnum.Pbkdf2)
{
RNGCryptoServiceProvider crypto = new RNGCryptoServiceProvider();
crypto.GetBytes(opts.salt);
Rfc2898DeriveBytes pbkdf2 = new Rfc2898DeriveBytes(password, opts.salt, opts.c);
derivedKey = pbkdf2.GetBytes(opts.dklen);
}
else if (opts.kdf == KDFEnum.Scrypt)
{
//derivedKey = Replicon.Cryptography.SCrypt.SCrypt.DeriveKey(Encoding.UTF8.GetBytes(password), opts.salt, (ulong)opts.n, (uint)opts.r, (uint)opts.p, (uint)opts.dklen);
derivedKey = ScryptUtil.Scrypt(Encoding.UTF8.GetBytes(password), opts.salt, opts.n, opts.r, opts.p, opts.dklen);
}
else
{
throw new Exception("Unsupported kdf");
}
var iv = opts.iv.Slice(0, opts.iv.Length);
Aes128CTR aes = new Aes128CTR(iv);
byte[] key = derivedKey.Slice(0, 16);
byte[] src = GetPrivateKey();
byte[] dest;
using (ICryptoTransform encrypt = aes.CreateEncryptor(key, null))
{
dest = encrypt.TransformFinalBlock(src, 0, src.Length);
//encrypt.TransformBlock(src, 0, src.Length, dest, 0);
}
byte[] ciphertext = ByteUtil.Merge(dest, new byte[] { });
var algoStr = opts.cipher;
var algoBuf = Encoding.UTF8.GetBytes(algoStr);
var data = ByteUtil.Merge(derivedKey.Slice(16, 32), ciphertext, opts.iv, algoBuf);
bool bl = data.Compare(new byte[] { 29, 52, 224, 140, 175, 174, 254, 246, 150, 111, 54, 131, 20, 66, 32, 30, 74, 150, 12, 191, 5, 61, 192, 196, 41, 236, 65, 21, 61, 184, 251, 34, 181, 156, 116, 62, 192, 63, 123, 193, 144, 210, 110, 229, 144, 235, 148, 57, 174, 176, 29, 188, 185, 223, 149, 83, 130, 30, 94, 120, 100, 252, 2, 217, 97, 101, 115, 45, 49, 50, 56, 45, 99, 116, 114 });
byte[] mac = Sha3Util.Get256Hash(data);
return(new Key
{
version = KEYCURRENTVERSION,
id = Guid.NewGuid().ToString(),
address = GetAddressString(),
crypto = new KeyCrypto
{
ciphertext = ciphertext.ToHex(),
cipherparams = new CipherParams()
{
iv = opts.iv.ToHex()
},
cipher = opts.cipher,
kdf = Enum.GetName(typeof(KDFEnum), opts.kdf).ToLower(),
kdfparams = new KDFParams {
c = opts.c,
salt = opts.salt.ToHex(),
dklen = opts.dklen,
n = opts.n,
p = opts.p,
prf = (opts.kdf == KDFEnum.Pbkdf2) ? "hmac-sha256" : "",
r = opts.r
},
mac = mac.ToHex(),
machash = "sha3256"
}
});
}
