public void TestVerifyPassword()
{
bool result = uut.VerifyPassword("123");
Assert.AreEqual(true, result);
uut.CreateAccount(keyPair.PrivateKey);
result = uut.Contains(testScriptHash);
Assert.AreEqual(true, result);
result = uut.VerifyPassword("123");
Assert.AreEqual(true, result);
uut.DeleteAccount(testScriptHash);
Assert.AreEqual(false, uut.Contains(testScriptHash));
JObject wallet = new();
wallet["name"] = "name";
wallet["version"] = new Version("1.0").ToString();
wallet["scrypt"] = new ScryptParameters(2, 1, 1).ToJson();
wallet["accounts"] = new JArray();
wallet["extra"] = new JObject();
uut = new NEP6Wallet(null, "123", ProtocolSettings.Default, wallet);
nep2key = keyPair.Export("123", ProtocolSettings.Default.AddressVersion, 2, 1, 1);
uut.Import(nep2key, "123", 2, 1, 1);
Assert.IsFalse(uut.VerifyPassword("1"));
Assert.IsTrue(uut.VerifyPassword("123"));
}
/// <summary>
/// Encrypts a WIF key using a given keyphrase under NEP-2 Standard.
/// </summary>
/// <param name="wif">WIF key to encrypt (52 chars long).</param>
/// <param name="password">The password will be encoded as UTF-8.</param>
/// <param name="scryptParameters">Parameters for Scrypt. Defaults to NEP2 specified parameters.</param>
/// <returns></returns>
public static async Task <string> Encrypt(string wif, string password, ScryptParameters scryptParameters = null)
{
if (scryptParameters == null)
{
scryptParameters = ScryptParameters.Default;
}
using (Decrypt())
{
var keyPair = new KeyPair(Wallet.GetPrivateKeyFromWif(wif));
var scriptHash =
Helper.CreateSignatureRedeemScript(keyPair.PublicKey).ToScriptHash();
var address = scriptHash.ToAddress();
var addresshash = Encoding.ASCII.GetBytes(address).Sha256().Sha256().Take(4).ToArray();
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 = XOR(keyPair.PrivateKey, derivedhalf1).AES256Encrypt(derivedhalf2);
var buffer = new byte[39];
buffer[0] = 0x01;
buffer[1] = 0x42;
buffer[2] = 0xe0;
Buffer.BlockCopy(addresshash, 0, buffer, 3, addresshash.Length);
Buffer.BlockCopy(encryptedkey, 0, buffer, 7, encryptedkey.Length);
return buffer.Base58CheckEncode();
}));
}
}
public void TestImportNep2()
{
bool result = uut.Contains(testScriptHash);
Assert.AreEqual(false, result);
uut.Import(nep2key, "123", 0, 0, 0);
result = uut.Contains(testScriptHash);
Assert.AreEqual(true, result);
uut.DeleteAccount(testScriptHash);
result = uut.Contains(testScriptHash);
Assert.AreEqual(false, result);
JObject wallet = new JObject();
wallet["name"] = "name";
wallet["version"] = new Version().ToString();
wallet["scrypt"] = new ScryptParameters(0, 0, 0).ToJson();
wallet["accounts"] = new JArray();
wallet["extra"] = new JObject();
uut = new NEP6Wallet(wallet);
result = uut.Contains(testScriptHash);
Assert.AreEqual(false, result);
uut.Import(nep2key, "123", 0, 0, 0);
result = uut.Contains(testScriptHash);
Assert.AreEqual(true, result);
}
public void TestVerifyPassword()
{
bool result = uut.VerifyPassword("123");
Assert.AreEqual(true, result);
Assert.ThrowsException <ArgumentNullException>(() => uut.CreateAccount(keyPair.PrivateKey));
uut.Unlock("123");
uut.CreateAccount(keyPair.PrivateKey);
result = uut.Contains(testScriptHash);
Assert.AreEqual(true, result);
result = uut.VerifyPassword("123");
Assert.AreEqual(true, result);
uut.DeleteAccount(testScriptHash);
Assert.AreEqual(false, uut.Contains(testScriptHash));
JObject wallet = new JObject();
wallet["name"] = "name";
wallet["version"] = new Version().ToString();
wallet["scrypt"] = new ScryptParameters(0, 0, 0).ToJson();
wallet["accounts"] = new JArray();
wallet["extra"] = new JObject();
uut = new NEP6Wallet(wallet);
nep2key = keyPair.Export("123", 0, 0, 0);
uut.Import(nep2key, "123", 0, 0, 0);
Assert.IsFalse(uut.VerifyPassword("1"));
Assert.IsTrue(uut.VerifyPassword("123"));
}
/// <summary>
/// Create a new wallet
/// </summary>
/// <param name="path">Path</param>
/// <param name="passwordKey">Password Key</param>
/// <param name="scrypt">Scrypt initialization value</param>
private UserWallet(string path, byte[] passwordKey, ScryptParameters scrypt)
{
this.path = path;
this.iv = new byte[16];
this.salt = new byte[20];
this.masterKey = new byte[32];
this.scrypt = scrypt;
this.accounts = new Dictionary <UInt160, UserWalletAccount>();
using (RandomNumberGenerator rng = RandomNumberGenerator.Create())
{
rng.GetBytes(iv);
rng.GetBytes(salt);
rng.GetBytes(masterKey);
}
Version version = Assembly.GetExecutingAssembly().GetName().Version;
BuildDatabase();
SaveStoredData("IV", iv);
SaveStoredData("Salt", salt);
SaveStoredData("PasswordHash", passwordKey.Concat(salt).ToArray().Sha256());
SaveStoredData("MasterKey", masterKey.AesEncrypt(passwordKey, iv));
SaveStoredData("Version", new[] { version.Major, version.Minor, version.Build, version.Revision }.Select(p => BitConverter.GetBytes(p)).SelectMany(p => p).ToArray());
SaveStoredData("ScryptN", BitConverter.GetBytes(this.scrypt.N));
SaveStoredData("ScryptR", BitConverter.GetBytes(this.scrypt.R));
SaveStoredData("ScryptP", BitConverter.GetBytes(this.scrypt.P));
}
/// <summary>
/// Create a new wallet
/// </summary>
/// <param name="path">Path</param>
/// <param name="passwordKey">Password Key</param>
/// <param name="scrypt">Scrypt initialization value</param>
private UserWallet(string path, byte[] passwordKey, ProtocolSettings settings, ScryptParameters scrypt) : base(path, settings)
{
this.iv = new byte[16];
this.salt = new byte[20];
this.masterKey = new byte[32];
this.scrypt = scrypt;
this.accounts = new Dictionary <UInt160, UserWalletAccount>();
using (RandomNumberGenerator rng = RandomNumberGenerator.Create())
{
rng.GetBytes(iv);
rng.GetBytes(salt);
rng.GetBytes(masterKey);
}
Version version = Assembly.GetExecutingAssembly().GetName().Version;
byte[] versionBuffer = new byte[sizeof(int) * 4];
BinaryPrimitives.WriteInt32LittleEndian(versionBuffer, version.Major);
BinaryPrimitives.WriteInt32LittleEndian(versionBuffer.AsSpan(4), version.Minor);
BinaryPrimitives.WriteInt32LittleEndian(versionBuffer.AsSpan(8), version.Build);
BinaryPrimitives.WriteInt32LittleEndian(versionBuffer.AsSpan(12), version.Revision);
BuildDatabase();
SaveStoredData("IV", iv);
SaveStoredData("Salt", salt);
SaveStoredData("PasswordHash", passwordKey.Concat(salt).ToArray().Sha256());
SaveStoredData("MasterKey", Encrypt(masterKey, passwordKey, iv));
SaveStoredData("Version", versionBuffer);
SaveStoredData("ScryptN", this.scrypt.N);
SaveStoredData("ScryptR", this.scrypt.R);
SaveStoredData("ScryptP", this.scrypt.P);
}
/// <summary>
/// Decrypts a NEP2 key using a passphrase and the ScryptParameters, returning a private key
/// </summary>
/// <param name="nep2"></param>
/// <param name="passphrase"></param>
/// <param name="scryptParameters"></param>
/// <returns>private key</returns>
public static byte[] DecryptKey(string nep2, string passphrase, ScryptParameters scryptParameters)
{
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, scryptParameters.N, scryptParameters.R, scryptParameters.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 = ECCurve.Secp256r1.G * prikey;
UInt160 scriptHash = Neo.SmartContract.Contract.CreateSignatureRedeemScript(pubkey).ToScriptHash();
string address = Wallet.ToAddress(scriptHash);
if (!Encoding.ASCII.GetBytes(address).Sha256().Sha256().Take(4).SequenceEqual(addresshash))
{
throw new FormatException();
}
return(prikey);
}
public void TestScryptParametersConstructor()
{
int n = 1, r = 2, p = 3;
ScryptParameters parameter = new ScryptParameters(n, r, p);
parameter.N.Should().Be(n);
parameter.R.Should().Be(r);
parameter.P.Should().Be(p);
}
public static NEP6Wallet GenerateTestWallet()
{
JObject wallet = new JObject();
wallet["name"] = "noname";
wallet["version"] = new Version("1.0").ToString();
wallet["scrypt"] = new ScryptParameters(2, 1, 1).ToJson();
wallet["accounts"] = new JArray();
wallet["extra"] = null;
wallet.ToString().Should().Be("{\"name\":\"noname\",\"version\":\"1.0\",\"scrypt\":{\"n\":2,\"r\":1,\"p\":1},\"accounts\":[],\"extra\":null}");
return(new NEP6Wallet(null, ProtocolSettings.Default, wallet));
}
public static NEP6Wallet GenerateTestWallet()
{
JObject wallet = new JObject();
wallet["name"] = "noname";
wallet["version"] = new Version("3.0").ToString();
wallet["scrypt"] = new ScryptParameters(0, 0, 0).ToJson();
wallet["accounts"] = new JArray();
wallet["extra"] = null;
wallet.ToString().Should().Be("{\"name\":\"noname\",\"version\":\"3.0\",\"scrypt\":{\"n\":0,\"r\":0,\"p\":0},\"accounts\":[],\"extra\":null}");
return(new NEP6Wallet(wallet));
}
public void Test_Default_ScryptParameters_FromJson()
{
JObject json = new JObject();
json["n"] = 16384;
json["r"] = 8;
json["p"] = 8;
ScryptParameters uut2 = ScryptParameters.FromJson(json);
uut2.N.Should().Be(ScryptParameters.Default.N);
uut2.R.Should().Be(ScryptParameters.Default.R);
uut2.P.Should().Be(ScryptParameters.Default.P);
}
public void PassTestVectorB()
{
var vector = Encoding.ASCII.GetBytes("password");
var salt = Encoding.ASCII.GetBytes("NaCl");
var parameters = new ScryptParameters(1024, 8, 16, 64, (uint)salt.Length);
var result = NetScrypt.DeriveKey(vector, new SaltWithParameters(salt, parameters));
var expected = new byte[]
{
0xfd, 0xba, 0xbe, 0x1c, 0x9d, 0x34, 0x72, 0x00, 0x78, 0x56, 0xe7, 0x19, 0x0d, 0x01, 0xe9, 0xfe,
0x7c, 0x6a, 0xd7, 0xcb, 0xc8, 0x23, 0x78, 0x30, 0xe7, 0x73, 0x76, 0x63, 0x4b, 0x37, 0x31, 0x62,
0x2e, 0xaf, 0x30, 0xd9, 0x2e, 0x22, 0xa3, 0x88, 0x6f, 0xf1, 0x09, 0x27, 0x9d, 0x98, 0x30, 0xda,
0xc7, 0x27, 0xaf, 0xb9, 0x4a, 0x83, 0xee, 0x6d, 0x83, 0x60, 0xcb, 0xdf, 0xa2, 0xcc, 0x06, 0x40
};
Check.That(result).ContainsExactly(expected);
}
public void PassTestVectorC()
{
var vector = Encoding.ASCII.GetBytes("pleaseletmein");
var salt = Encoding.ASCII.GetBytes("SodiumChloride");
var parameters = new ScryptParameters(16384, 8, 1, 64, (uint)salt.Length);
var result = NetScrypt.DeriveKey(vector, new SaltWithParameters(salt, parameters));
var expected = new byte[]
{
0x70, 0x23, 0xbd, 0xcb, 0x3a, 0xfd, 0x73, 0x48, 0x46, 0x1c, 0x06, 0xcd, 0x81, 0xfd, 0x38, 0xeb,
0xfd, 0xa8, 0xfb, 0xba, 0x90, 0x4f, 0x8e, 0x3e, 0xa9, 0xb5, 0x43, 0xf6, 0x54, 0x5d, 0xa1, 0xf2,
0xd5, 0x43, 0x29, 0x55, 0x61, 0x3f, 0x0f, 0xcf, 0x62, 0xd4, 0x97, 0x05, 0x24, 0x2a, 0x9a, 0xf9,
0xe6, 0x1e, 0x85, 0xdc, 0x0d, 0x65, 0x1e, 0x40, 0xdf, 0xcf, 0x01, 0x7b, 0x45, 0x57, 0x58, 0x87
};
Check.That(result).ContainsExactly(expected);
}
public void PassTestVectorD()
{
var vector = Encoding.ASCII.GetBytes("pleaseletmein");
var salt = Encoding.ASCII.GetBytes("SodiumChloride");
var parameters = new ScryptParameters(1048576, 8, 1, 64, (uint)salt.Length);
var result = NetScrypt.DeriveKey(vector, new SaltWithParameters(salt, parameters));
var expected = new byte[]
{
0x21, 0x01, 0xcb, 0x9b, 0x6a, 0x51, 0x1a, 0xae, 0xad, 0xdb, 0xbe, 0x09, 0xcf, 0x70, 0xf8, 0x81,
0xec, 0x56, 0x8d, 0x57, 0x4a, 0x2f, 0xfd, 0x4d, 0xab, 0xe5, 0xee, 0x98, 0x20, 0xad, 0xaa, 0x47,
0x8e, 0x56, 0xfd, 0x8f, 0x4b, 0xa5, 0xd0, 0x9f, 0xfa, 0x1c, 0x6d, 0x92, 0x7c, 0x40, 0xf4, 0xc3,
0x37, 0x30, 0x40, 0x49, 0xe8, 0xa9, 0x52, 0xfb, 0xcb, 0xf4, 0x5c, 0x6f, 0xa7, 0x7a, 0x41, 0xa4
};
Check.That(result).ContainsExactly(expected);
}
public void PassTestVectorA()
{
var vector = Encoding.ASCII.GetBytes("");
var salt = Encoding.ASCII.GetBytes("");
var parameters = new ScryptParameters(16, 1, 1, 64, (uint)salt.Length);
var result = NetScrypt.DeriveKey(vector, new SaltWithParameters(salt, parameters));
var expected = new byte[]
{
0x77, 0xd6, 0x57, 0x62, 0x38, 0x65, 0x7b, 0x20, 0x3b, 0x19, 0xca, 0x42, 0xc1, 0x8a, 0x04, 0x97,
0xf1, 0x6b, 0x48, 0x44, 0xe3, 0x07, 0x4a, 0xe8, 0xdf, 0xdf, 0xfa, 0x3f, 0xed, 0xe2, 0x14, 0x42,
0xfc, 0xd0, 0x06, 0x9d, 0xed, 0x09, 0x48, 0xf8, 0x32, 0x6a, 0x75, 0x3a, 0x0f, 0xc8, 0x1f, 0x17,
0xe8, 0xd3, 0xe0, 0xfb, 0x2e, 0x0d, 0x36, 0x28, 0xcf, 0x35, 0xe2, 0x0c, 0x38, 0xd1, 0x89, 0x06
};
Check.That(result).ContainsExactly(expected);
}
/// <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;
}));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="path">Path</param>
/// <param name="passwordKey">Password Key</param>
/// <param name="create">True for create the wallet</param>
/// <param name="scrypt">Scrypt initialization value (only if create=True)</param>
private UserWallet(string path, byte[] passwordKey, bool create, ScryptParameters scrypt = null)
{
this.path = path;
if (create)
{
this.iv = new byte[16];
this.salt = new byte[20];
this.masterKey = new byte[32];
this.scrypt = scrypt ?? ScryptParameters.Default;
this.accounts = new Dictionary <UInt160, UserWalletAccount>();
using (RandomNumberGenerator rng = RandomNumberGenerator.Create())
{
rng.GetBytes(iv);
rng.GetBytes(salt);
rng.GetBytes(masterKey);
}
Version version = Assembly.GetExecutingAssembly().GetName().Version;
BuildDatabase();
SaveStoredData("IV", iv);
SaveStoredData("Salt", salt);
SaveStoredData("PasswordHash", passwordKey.Concat(salt).ToArray().Sha256());
SaveStoredData("MasterKey", masterKey.AesEncrypt(passwordKey, iv));
SaveStoredData("Version", new[] { version.Major, version.Minor, version.Build, version.Revision }.Select(p => BitConverter.GetBytes(p)).SelectMany(p => p).ToArray());
SaveStoredData("ScryptN", BitConverter.GetBytes(this.scrypt.N));
SaveStoredData("ScryptR", BitConverter.GetBytes(this.scrypt.R));
SaveStoredData("ScryptP", BitConverter.GetBytes(this.scrypt.P));
}
else
{
this.salt = LoadStoredData("Salt");
byte[] passwordHash = LoadStoredData("PasswordHash");
if (passwordHash != null && !passwordHash.SequenceEqual(passwordKey.Concat(salt).ToArray().Sha256()))
{
throw new CryptographicException();
}
this.iv = LoadStoredData("IV");
this.masterKey = LoadStoredData("MasterKey").AesDecrypt(passwordKey, iv);
this.scrypt = new ScryptParameters
(
BitConverter.ToInt32(LoadStoredData("ScryptN")),
BitConverter.ToInt32(LoadStoredData("ScryptR")),
BitConverter.ToInt32(LoadStoredData("ScryptP"))
);
this.accounts = LoadAccounts();
}
}
public void TestChangePassword()
{
JObject wallet = new();
wallet["name"] = "name";
wallet["version"] = new Version("1.0").ToString();
wallet["scrypt"] = new ScryptParameters(2, 1, 1).ToJson();
wallet["accounts"] = new JArray();
wallet["extra"] = new JObject();
File.WriteAllText(wPath, wallet.ToString());
uut = new NEP6Wallet(wPath, "123", ProtocolSettings.Default);
uut.CreateAccount(keyPair.PrivateKey);
uut.ChangePassword("456", "123").Should().BeFalse();
uut.ChangePassword("123", "456").Should().BeTrue();
uut.VerifyPassword("456").Should().BeTrue();
uut.ChangePassword("456", "123").Should().BeTrue();
}
public void TestSetup()
{
JObject wallet = new JObject();
wallet["name"] = "name";
wallet["version"] = new System.Version().ToString();
wallet["scrypt"] = ScryptParameters.Default.ToJson();
// test minimally scryptparameters parsing here
ScryptParameters.FromJson(wallet["scrypt"]).Should().NotBeNull();
ScryptParameters.FromJson(wallet["scrypt"]).N.Should().Be(ScryptParameters.Default.N);
wallet["accounts"] = new JArray();
//accounts = ((JArray)wallet["accounts"]).Select(p => NEP6Account.FromJson(p, this)).ToDictionary(p => p.ScriptHash);
wallet["extra"] = new JObject();
// check string json
wallet.ToString().Should().Be("{\"name\":\"name\",\"version\":\"0.0\",\"scrypt\":{\"n\":16384,\"r\":8,\"p\":8},\"accounts\":[],\"extra\":{}}");
uut = new NEP6Wallet(wallet);
}
/// <summary>
/// Encrypts a private key using a passphrase and the ScryptParameters, returning the NEP2 key in string format
/// </summary>
/// <param name="passphrase"></param>
/// <param name="keyPair"></param>
/// <param name="scryptParameters"></param>
/// <returns>NEP2</returns>
public static string EncryptKey(string passphrase, KeyPair keyPair, ScryptParameters scryptParameters)
{
UInt160 scriptHash = Neo.SmartContract.Contract.CreateSignatureRedeemScript(keyPair.PublicKey).ToScriptHash();
string address = Wallet.ToAddress(scriptHash);
byte[] addresshash = Encoding.ASCII.GetBytes(address).Sha256().Sha256().Take(4).ToArray();
byte[] derivedkey = SCrypt.DeriveKey(Encoding.UTF8.GetBytes(passphrase), addresshash, scryptParameters.N, scryptParameters.R, scryptParameters.P, 64);
byte[] derivedhalf1 = derivedkey.Take(32).ToArray();
byte[] derivedhalf2 = derivedkey.Skip(32).ToArray();
byte[] encryptedkey = Xor(keyPair.PrivateKey, derivedhalf1).Aes256Encrypt(derivedhalf2);
byte[] buffer = new byte[39];
buffer[0] = 0x01;
buffer[1] = 0x42;
buffer[2] = 0xe0;
Buffer.BlockCopy(addresshash, 0, buffer, 3, addresshash.Length);
Buffer.BlockCopy(encryptedkey, 0, buffer, 7, encryptedkey.Length);
return(buffer.Base58CheckEncode());
}
/// <summary>
/// Open an existing wallet
/// </summary>
/// <param name="path">Path</param>
/// <param name="passwordKey">Password Key</param>
private UserWallet(string path, byte[] passwordKey, ProtocolSettings settings) : base(path, settings)
{
this.salt = LoadStoredData("Salt");
byte[] passwordHash = LoadStoredData("PasswordHash");
if (passwordHash != null && !passwordHash.SequenceEqual(passwordKey.Concat(salt).ToArray().Sha256()))
{
throw new CryptographicException();
}
this.iv = LoadStoredData("IV");
this.masterKey = LoadStoredData("MasterKey").AesDecrypt(passwordKey, iv);
this.scrypt = new ScryptParameters
(
BitConverter.ToInt32(LoadStoredData("ScryptN")),
BitConverter.ToInt32(LoadStoredData("ScryptR")),
BitConverter.ToInt32(LoadStoredData("ScryptP"))
);
this.accounts = LoadAccounts();
}
public void TestIsDefault()
{
JObject wallet = new();
wallet["name"] = "name";
wallet["version"] = new Version("1.0").ToString();
wallet["scrypt"] = new ScryptParameters(2, 1, 1).ToJson();
wallet["accounts"] = new JArray();
wallet["extra"] = new JObject();
var w = new NEP6Wallet(null, "", ProtocolSettings.Default, wallet);
var ac = w.CreateAccount();
Assert.AreEqual(ac.Address, w.GetDefaultAccount().Address);
var ac2 = w.CreateAccount();
Assert.AreEqual(ac.Address, w.GetDefaultAccount().Address);
ac2.IsDefault = true;
Assert.AreEqual(ac2.Address, w.GetDefaultAccount().Address);
}
public void TestSave()
{
JObject wallet = new();
wallet["name"] = "name";
wallet["version"] = new Version("1.0").ToString();
wallet["scrypt"] = new ScryptParameters(2, 1, 1).ToJson();
wallet["accounts"] = new JArray();
wallet["extra"] = new JObject();
File.WriteAllText(wPath, wallet.ToString());
uut = new NEP6Wallet(wPath, "123", ProtocolSettings.Default);
uut.CreateAccount(keyPair.PrivateKey);
bool result = uut.Contains(testScriptHash);
Assert.AreEqual(true, result);
uut.Save();
result = uut.Contains(testScriptHash);
Assert.AreEqual(true, result);
}
public void TestChangePassword()
{
JObject wallet = new JObject();
wallet["name"] = "name";
wallet["version"] = new System.Version("3.0").ToString();
wallet["scrypt"] = new ScryptParameters(0, 0, 0).ToJson();
wallet["accounts"] = new JArray();
wallet["extra"] = new JObject();
File.WriteAllText(wPath, wallet.ToString());
uut = new NEP6Wallet(wPath);
uut.Unlock("123");
uut.CreateAccount(keyPair.PrivateKey);
uut.ChangePassword("456", "123").Should().BeFalse();
uut.ChangePassword("123", "456").Should().BeTrue();
uut.VerifyPassword("456").Should().BeTrue();
uut.ChangePassword("456", "123").Should().BeTrue();
uut.Lock();
}
public void TestSave()
{
JObject wallet = new JObject();
wallet["name"] = "name";
wallet["version"] = new System.Version().ToString();
wallet["scrypt"] = new ScryptParameters(0, 0, 0).ToJson();
wallet["accounts"] = new JArray();
wallet["extra"] = new JObject();
File.WriteAllText(wPath, wallet.ToString());
uut = new NEP6Wallet(wPath);
uut.Unlock("123");
uut.CreateAccount(keyPair.PrivateKey);
bool result = uut.Contains(testScriptHash);
Assert.AreEqual(true, result);
uut.Save();
result = uut.Contains(testScriptHash);
Assert.AreEqual(true, result);
}
public void TestSetup()
{
uut = ScryptParameters.Default;
}
public static UserWallet Create(string path, SecureString password, ScryptParameters scrypt = null)
{
return(new UserWallet(path, password.ToAesKey(), scrypt ?? ScryptParameters.Default));
}
public static UserWallet Create(string path, string password, ProtocolSettings settings, ScryptParameters scrypt = null)
{
return(new UserWallet(path, password.ToAesKey(), settings, scrypt ?? ScryptParameters.Default));
}
