public static byte[] GetPrivateKeyFromNEP2(string nep2, string passphrase, int N = 16384, int r = 8, int p = 8)
{
if (nep2 == null)
{
throw new ArgumentNullException(nameof(nep2));
}
if (passphrase == null)
{
throw new ArgumentNullException(nameof(passphrase));
}
byte[] data = nep2.Base58CheckDecode();
if (data.Length != 39 || data[0] != 0x01 || data[1] != 0x42 || data[2] != 0xe0)
{
throw new FormatException();
}
byte[] addresshash = new byte[4];
Buffer.BlockCopy(data, 3, addresshash, 0, 4);
byte[] derivedkey = SCrypt.DeriveKey(Encoding.UTF8.GetBytes(passphrase), addresshash, N, r, p, 64);
byte[] derivedhalf1 = derivedkey.Take(32).ToArray();
byte[] derivedhalf2 = derivedkey.Skip(32).ToArray();
byte[] encryptedkey = new byte[32];
Buffer.BlockCopy(data, 7, encryptedkey, 0, 32);
byte[] prikey = XOR(encryptedkey.AES256Decrypt(derivedhalf2), derivedhalf1);
ECPoint pubkey = Cryptography.ECC.ECCurve.Secp256r1.G * prikey;
UInt160 scriptHash = Contract.CreateSignatureRedeemScript(pubkey).ToScriptHash();
string address = scriptHash.ToAddress();
if (!Encoding.ASCII.GetBytes(address).Sha256().Sha256().Take(4).SequenceEqual(addresshash))
{
throw new FormatException();
}
return(prikey);
}
public void TestAES256Decrypt()
{
byte[] block = new byte[32];
byte[] key = Encoding.ASCII.GetBytes("1234567812345678");
string decryptString = "f69e0923d8247eef417d6a78944a4b39f69e0923d8247eef417d6a78944a4b399ae8fd02b340288a0e7bbff0f0ba54d6";
for (int i = 0; i < 32; i++)
{
block[i] = Convert.ToByte(decryptString.Substring(i * 2, 2), 16);
}
string str = System.Text.Encoding.Default.GetString(block.AES256Decrypt(key));
str.Should().Be("00000000000000000000000000000000");
}
public byte[] GetPrivateKeyFromNEP2(string nep2, string passphrase)
{
// if (nep2 == null)
// throw new ArgumentNullException (nameof (nep2));
// if (passphrase == null)
// throw new ArgumentNullException (nameof (passphrase));
byte[] data = nep2.Base58CheckDecode();
if (data.Length != 39 || data [0] != 0x01 || data [1] != 0x42 || data [2] != 0xe0)
{
throw new FormatException();
}
Debug.Log("nep2 " + nep2);
byte[] addresshash = new byte[4];
Buffer.BlockCopy(data, 3, addresshash, 0, 4);
Debug.Log("in nep2: " + passphrase);
byte[] derivedkey = SCrypt.DeriveKey(Encoding.UTF8.GetBytes(passphrase), addresshash, 16384, 8, 8, 64);
byte[] derivedhalf1 = derivedkey.Take(32).ToArray();
byte[] derivedhalf2 = derivedkey.Skip(32).ToArray();
byte[] encryptedkey = new byte[32];
Buffer.BlockCopy(data, 7, encryptedkey, 0, 32);
byte[] prikey = XOR(encryptedkey.AES256Decrypt(derivedhalf2), derivedhalf1);
Neo.Cryptography.ECC.ECPoint pubkey = Neo.Cryptography.ECC.ECCurve.Secp256r1.G * prikey;
var bytes = pubkey.EncodePoint(true).ToArray();
// byte[] CompressedPublicKey = bytes;
// byte[] PublicKeyHash = Crypto.Default.ToScriptHash (bytes);
string signatureScript = KeyPair.CreateSignatureScript(bytes);
UInt160 signatureHash = Crypto.Default.ToScriptHash(signatureScript.HexToBytes());
byte[] publickey = pubkey.EncodePoint(false).Skip(1).ToArray();
string address = Crypto.Default.ToAddress(signatureHash);
Debug.Log("decrypted private key: " + prikey.ByteToHex());
Debug.Log("decrypted public key: " + publickey.ByteToHex());
Debug.Log("decrypted address: " + address);
return(prikey);
}
/// <summary>
/// Decrypts an encrypted key using a given keyphrase under NEP-2 Standard.
/// </summary>
/// <param name="encryptedKey"></param>
/// <param name="password"></param>
/// <param name="scryptParameters"></param>
/// <returns></returns>
public static async Task <byte[]> Decrypt(string encryptedKey, string password,
ScryptParameters scryptParameters = null)
{
if (encryptedKey == null)
{
throw new ArgumentNullException(nameof(encryptedKey));
}
if (password == null)
{
throw new ArgumentNullException(nameof(password));
}
if (scryptParameters == null)
{
scryptParameters = ScryptParameters.Default;
}
var data = encryptedKey.Base58CheckDecode();
if (data.Length != 39 || data[0] != 0x01 || data[1] != 0x42 || data[2] != 0xe0)
{
throw new FormatException();
}
var addresshash = new byte[4];
Buffer.BlockCopy(data, 3, addresshash, 0, 4);
return(await Task.Run(() =>
{
var derivedkey = SCrypt.DeriveKey(Encoding.UTF8.GetBytes(password), addresshash, scryptParameters.N,
scryptParameters.R, scryptParameters.P, 64);
var derivedhalf1 = derivedkey.Take(32).ToArray();
var derivedhalf2 = derivedkey.Skip(32).ToArray();
var encryptedkey = new byte[32];
Buffer.BlockCopy(data, 7, encryptedkey, 0, 32);
var prikey = XOR(encryptedkey.AES256Decrypt(derivedhalf2), derivedhalf1);
var pubkey = ECCurve.Secp256r1.G *prikey;
var scriptHash = Helper.CreateSignatureRedeemScript(pubkey).ToScriptHash();
var address = scriptHash.ToAddress();
if (!Encoding.ASCII.GetBytes(address).Sha256().Sha256().Take(4).SequenceEqual(addresshash))
{
throw new FormatException();
}
return prikey;
}));
}
public void ReadWallet(string walletName, string walletPassword)
{
byte[] passwordBytes = { };
string password_content = walletPassword;
while (passwordBytes.Length < 32)
{
passwordBytes = System.Text.Encoding.UTF8.GetBytes(password_content);
password_content = passwordBytes.ToHexString();
}
FileStream fsCrypt = new FileStream(walletName + ".aes", FileMode.Open);
byte[] encryptedKey = new byte[fsCrypt.Length];
fsCrypt.Read(encryptedKey, 0, (int)fsCrypt.Length);
walletKey = new KeyPair(encryptedKey.AES256Decrypt(passwordBytes.Take(16).ToArray()));
fsCrypt.Close();
}
public static NeoKeys FromNEP2(string nep2, string passphrase, int N = 16384, int r = 8, int p = 8)
{
Throw.IfNull(nep2, nameof(nep2));
Throw.IfNull(passphrase, nameof(passphrase));
byte[] data = nep2.Base58CheckDecode();
if (data.Length != 39 || data[0] != 0x01 || data[1] != 0x42 || data[2] != 0xe0)
{
throw new FormatException();
}
byte[] addressHash = new byte[4];
Buffer.BlockCopy(data, 3, addressHash, 0, 4);
byte[] datapassphrase = Encoding.UTF8.GetBytes(passphrase);
byte[] derivedkey = SCrypt.DeriveKey(datapassphrase, addressHash, N, r, p, 64);
Array.Clear(datapassphrase, 0, datapassphrase.Length);
byte[] derivedhalf1 = derivedkey.Take(32).ToArray();
byte[] derivedhalf2 = derivedkey.Skip(32).ToArray();
Array.Clear(derivedkey, 0, derivedkey.Length);
byte[] encryptedkey = new byte[32];
Buffer.BlockCopy(data, 7, encryptedkey, 0, 32);
Array.Clear(data, 0, data.Length);
byte[] prikey = XOR(encryptedkey.AES256Decrypt(derivedhalf2), derivedhalf1);
Array.Clear(derivedhalf1, 0, derivedhalf1.Length);
Array.Clear(derivedhalf2, 0, derivedhalf2.Length);
ECPoint pubkey = ECCurve.Secp256r1.G * prikey;
var keys = new NeoKeys(prikey);
var temp = Encoding.ASCII.GetBytes(keys.Address).Sha256().Sha256().Take(4).ToArray();
if (!temp.SequenceEqual(addressHash))
{
throw new FormatException("invalid passphrase when decrypting NEP2");
}
return(keys);
}
