11313431618

Committed 13 Oct 2024 10:03AM UTC coverage: 55.911% (+0.001%) from 55.91%

Build # 11313431618

Build Type

Pull #3532

github

Committed by

web-flow

Commit Message

Merge 6ce463312 into a32693924

Pull Request Pull Request #3532: fix: concurrency conflict because of Memory Order

Run Details

5774 of 8906 branches covered (64.83%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

3 existing lines in 1 file now uncovered.

21710 of 40251 relevant lines covered (53.94%)

86520.83 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.55

/src/Neo/Wallets/NEP6/NEP6Wallet.cs

// Copyright (C) 2015-2024 The Neo Project.
//
// NEP6Wallet.cs file belongs to the neo project and is free
// software distributed under the MIT software license, see the
// accompanying file LICENSE in the main directory of the
// repository or http://www.opensource.org/licenses/mit-license.php
// for more details.
//
// Redistribution and use in source and binary forms with or without
// modifications are permitted.

using Neo.Extensions;
using Neo.Json;
using Neo.SmartContract;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.Threading;
using System.Threading.Tasks;

namespace Neo.Wallets.NEP6
{
    /// <summary>
    /// An implementation of the NEP-6 wallet standard.
    /// </summary>
    /// <remarks>https://github.com/neo-project/proposals/blob/master/nep-6.mediawiki</remarks>
    public class NEP6Wallet : Wallet
    {
        private SecureString password;
        private string name;
        private Version version;
        private readonly Dictionary<UInt160, NEP6Account> accounts;
        private readonly JToken extra;

        /// <summary>
        /// The parameters of the SCrypt algorithm used for encrypting and decrypting the private keys in the wallet.
        /// </summary>
        public readonly ScryptParameters Scrypt;

        public override string Name => name;

        /// <summary>
        /// The version of the wallet standard. It is currently fixed at 1.0 and will be used for functional upgrades in the future.
        /// </summary>
        public override Version Version => version;

        /// <summary>
        /// Loads or creates a wallet at the specified path.
        /// </summary>
        /// <param name="path">The path of the wallet file.</param>
        /// <param name="password">The password of the wallet.</param>
        /// <param name="settings">The <see cref="ProtocolSettings"/> to be used by the wallet.</param>
        /// <param name="name">The name of the wallet. If the wallet is loaded from an existing file, this parameter is ignored.</param>
        public NEP6Wallet(string path, string password, ProtocolSettings settings, string name = null) : base(path, settings)
        {
            this.password = password.ToSecureString();
            if (File.Exists(path))
            {
                var wallet = (JObject)JToken.Parse(File.ReadAllBytes(path));
                LoadFromJson(wallet, out Scrypt, out accounts, out extra);
            }
            else
            {
                this.name = name;
                version = Version.Parse("1.0");
                Scrypt = ScryptParameters.Default;
                accounts = new Dictionary<UInt160, NEP6Account>();
                extra = JToken.Null;
            }
        }

        /// <summary>
        /// Loads the wallet with the specified JSON string.
        /// </summary>
        /// <param name="path">The path of the wallet.</param>
        /// <param name="password">The password of the wallet.</param>
        /// <param name="settings">The <see cref="ProtocolSettings"/> to be used by the wallet.</param>
        /// <param name="json">The JSON object representing the wallet.</param>
        public NEP6Wallet(string path, string password, ProtocolSettings settings, JObject json) : base(path, settings)
        {
            this.password = password.ToSecureString();
            LoadFromJson(json, out Scrypt, out accounts, out extra);
        }

        private void LoadFromJson(JObject wallet, out ScryptParameters scrypt, out Dictionary<UInt160, NEP6Account> accounts, out JToken extra)
        {
            version = Version.Parse(wallet["version"].AsString());
            name = wallet["name"]?.AsString();
            scrypt = ScryptParameters.FromJson((JObject)wallet["scrypt"]);
            accounts = ((JArray)wallet["accounts"]).Select(p => NEP6Account.FromJson((JObject)p, this)).ToDictionary(p => p.ScriptHash);
            extra = wallet["extra"];
            Thread.MemoryBarrier();
            if (!VerifyPasswordInternal(password.GetClearText()))
                throw new InvalidOperationException("Wrong password.");
        }

        private void AddAccount(NEP6Account account)
        {
            lock (accounts)
            {
                if (accounts.TryGetValue(account.ScriptHash, out NEP6Account account_old))
                {
                    account.Label = account_old.Label;
                    account.IsDefault = account_old.IsDefault;
                    account.Lock = account_old.Lock;
                    if (account.Contract == null)
                    {
                        account.Contract = account_old.Contract;
                    }
                    else
                    {
                        NEP6Contract contract_old = (NEP6Contract)account_old.Contract;
                        if (contract_old != null)
                        {
                            NEP6Contract contract = (NEP6Contract)account.Contract;
                            contract.ParameterNames = contract_old.ParameterNames;
                            contract.Deployed = contract_old.Deployed;
                        }
                    }
                    account.Extra = account_old.Extra;
                }
                accounts[account.ScriptHash] = account;
            }
        }

        public override bool Contains(UInt160 scriptHash)
        {
            lock (accounts)
            {
                return accounts.ContainsKey(scriptHash);
            }
        }

        public override WalletAccount CreateAccount(byte[] privateKey)
        {
            if (privateKey is null) throw new ArgumentNullException(nameof(privateKey));
            KeyPair key = new(privateKey);
            if (key.PublicKey.IsInfinity) throw new ArgumentException(null, nameof(privateKey));
            NEP6Contract contract = new()
            {
                Script = Contract.CreateSignatureRedeemScript(key.PublicKey),
                ParameterList = new[] { ContractParameterType.Signature },
                ParameterNames = new[] { "signature" },
                Deployed = false
            };
            NEP6Account account = new(this, contract.ScriptHash, key, password.GetClearText())
            {
                Contract = contract
            };
            AddAccount(account);
            return account;
        }

        public override WalletAccount CreateAccount(Contract contract, KeyPair key = null)
        {
            if (contract is not NEP6Contract nep6contract)
            {
                nep6contract = new NEP6Contract
                {
                    Script = contract.Script,
                    ParameterList = contract.ParameterList,
                    ParameterNames = contract.ParameterList.Select((p, i) => $"parameter{i}").ToArray(),
                    Deployed = false
                };
            }
            NEP6Account account;
            if (key == null)
                account = new NEP6Account(this, nep6contract.ScriptHash);
            else
                account = new NEP6Account(this, nep6contract.ScriptHash, key, password.GetClearText());
            account.Contract = nep6contract;
            AddAccount(account);
            return account;
        }

        public override WalletAccount CreateAccount(UInt160 scriptHash)
        {
            NEP6Account account = new(this, scriptHash);
            AddAccount(account);
            return account;
        }

        /// <summary>
        /// Decrypts the specified NEP-2 string with the password of the wallet.
        /// </summary>
        /// <param name="nep2key">The NEP-2 string to decrypt.</param>
        /// <returns>The decrypted private key.</returns>
        internal KeyPair DecryptKey(string nep2key)
        {
            return new KeyPair(GetPrivateKeyFromNEP2(nep2key, password.GetClearText(), ProtocolSettings.AddressVersion, Scrypt.N, Scrypt.R, Scrypt.P));
        }

        public override void Delete()
        {
            if (File.Exists(Path)) File.Delete(Path);
        }

        public override bool DeleteAccount(UInt160 scriptHash)
        {
            lock (accounts)
            {
                return accounts.Remove(scriptHash);
            }
        }

        public override WalletAccount GetAccount(UInt160 scriptHash)
        {
            lock (accounts)
            {
                accounts.TryGetValue(scriptHash, out NEP6Account account);
                return account;
            }
        }

        public override IEnumerable<WalletAccount> GetAccounts()
        {
            lock (accounts)
            {
                foreach (NEP6Account account in accounts.Values)
                    yield return account;
            }
        }

        public override WalletAccount Import(X509Certificate2 cert)
        {
            if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
            {
                throw new PlatformNotSupportedException("Importing certificates is not supported on macOS.");
            }
            KeyPair key;
            using (ECDsa ecdsa = cert.GetECDsaPrivateKey())
            {
                key = new KeyPair(ecdsa.ExportParameters(true).D);
            }
            NEP6Contract contract = new()
            {
                Script = Contract.CreateSignatureRedeemScript(key.PublicKey),
                ParameterList = new[] { ContractParameterType.Signature },
                ParameterNames = new[] { "signature" },
                Deployed = false
            };
            NEP6Account account = new(this, contract.ScriptHash, key, password.GetClearText())
            {
                Contract = contract
            };
            AddAccount(account);
            return account;
        }

        public override WalletAccount Import(string wif)
        {
            KeyPair key = new(GetPrivateKeyFromWIF(wif));
            NEP6Contract contract = new()
            {
                Script = Contract.CreateSignatureRedeemScript(key.PublicKey),
                ParameterList = new[] { ContractParameterType.Signature },
                ParameterNames = new[] { "signature" },
                Deployed = false
            };
            NEP6Account account = new(this, contract.ScriptHash, key, password.GetClearText())
            {
                Contract = contract
            };
            AddAccount(account);
            return account;
        }

        public override WalletAccount Import(string nep2, string passphrase, int N = 16384, int r = 8, int p = 8)
        {
            KeyPair key = new(GetPrivateKeyFromNEP2(nep2, passphrase, ProtocolSettings.AddressVersion, N, r, p));
            NEP6Contract contract = new()
            {
                Script = Contract.CreateSignatureRedeemScript(key.PublicKey),
                ParameterList = new[] { ContractParameterType.Signature },
                ParameterNames = new[] { "signature" },
                Deployed = false
            };
            NEP6Account account;
            if (Scrypt.N == 16384 && Scrypt.R == 8 && Scrypt.P == 8)
                account = new NEP6Account(this, contract.ScriptHash, nep2);
            else
                account = new NEP6Account(this, contract.ScriptHash, key, passphrase);
            account.Contract = contract;
            AddAccount(account);
            return account;
        }

        /// <summary>
        /// Exports the wallet as JSON
        /// </summary>
        public JObject ToJson()
        {
            return new()
            {
                ["name"] = name,
                ["version"] = version.ToString(),
                ["scrypt"] = Scrypt.ToJson(),
                ["accounts"] = accounts.Values.Select(p => p.ToJson()).ToArray(),
                ["extra"] = extra
            };
        }

        public override void Save()
        {
            File.WriteAllText(Path, ToJson().ToString());
        }

        public override bool VerifyPassword(string password)
        {
            return this.password.GetClearText() == password;
        }

        private bool VerifyPasswordInternal(string password)
        {
            lock (accounts)
            {
                NEP6Account account = accounts.Values.FirstOrDefault(p => !p.Decrypted);
                if (account == null)
                {
                    account = accounts.Values.FirstOrDefault(p => p.HasKey);
                }
                if (account == null) return true;
                if (account.Decrypted)
                {
                    return account.VerifyPassword(password);
                }
                else
                {
                    try
                    {
                        account.GetKey(password);
                        return true;
                    }
                    catch (FormatException)
                    {
                        return false;
                    }
                }
            }
        }

        public override bool ChangePassword(string oldPassword, string newPassword)
        {
            bool succeed = true;
            lock (accounts)
            {
                Parallel.ForEach(accounts.Values, (account, state) =>
                {
                    if (!account.ChangePasswordPrepare(oldPassword, newPassword))
                    {
                        state.Stop();
                        succeed = false;
                    }
                });
            }
            if (succeed)
            {
                foreach (NEP6Account account in accounts.Values)
                    account.ChangePasswordCommit();
                password = newPassword.ToSecureString();
            }
            else
            {
                foreach (NEP6Account account in accounts.Values)
                    account.ChangePasswordRollback();
            }
            return succeed;
        }
    }
}

1	// Copyright (C) 2015-2024 The Neo Project.
2	//
3	// NEP6Wallet.cs file belongs to the neo project and is free
4	// software distributed under the MIT software license, see the
5	// accompanying file LICENSE in the main directory of the
6	// repository or http://www.opensource.org/licenses/mit-license.php
7	// for more details.
8	//
9	// Redistribution and use in source and binary forms with or without
10	// modifications are permitted.
11
12	using Neo.Extensions;
13	using Neo.Json;
14	using Neo.SmartContract;
15	using System;
16	using System.Collections.Generic;
17	using System.IO;
18	using System.Linq;
19	using System.Runtime.InteropServices;
20	using System.Security;
21	using System.Security.Cryptography;
22	using System.Security.Cryptography.X509Certificates;
23	using System.Threading;
24	using System.Threading.Tasks;
25
26	namespace Neo.Wallets.NEP6
27	{
28	/// <summary>
29	/// An implementation of the NEP-6 wallet standard.
30	/// </summary>
31	/// <remarks>https://github.com/neo-project/proposals/blob/master/nep-6.mediawiki</remarks>
32	public class NEP6Wallet : Wallet
33	{
34	private SecureString password;
35	private string name;
36	private Version version;
37	private readonly Dictionary<UInt160, NEP6Account> accounts;
38	private readonly JToken extra;
39
40	/// <summary>
41	/// The parameters of the SCrypt algorithm used for encrypting and decrypting the private keys in the wallet.
42	/// </summary>
43	public readonly ScryptParameters Scrypt;
44
45	public override string Name => name;	6✔
46
47	/// <summary>
48	/// The version of the wallet standard. It is currently fixed at 1.0 and will be used for functional upgrades in the future.
49	/// </summary>
50	public override Version Version => version;	5✔
51
52	/// <summary>
53	/// Loads or creates a wallet at the specified path.
54	/// </summary>
55	/// <param name="path">The path of the wallet file.</param>
56	/// <param name="password">The password of the wallet.</param>
57	/// <param name="settings">The <see cref="ProtocolSettings"/> to be used by the wallet.</param>
58	/// <param name="name">The name of the wallet. If the wallet is loaded from an existing file, this parameter is ignored.</param>
59	public NEP6Wallet(string path, string password, ProtocolSettings settings, string name = null) : base(path, settings)	21✔
60	{	21✔
61	this.password = password.ToSecureString();	21✔
62	if (File.Exists(path))	21✔
63	{	16✔
64	var wallet = (JObject)JToken.Parse(File.ReadAllBytes(path));	16✔
65	LoadFromJson(wallet, out Scrypt, out accounts, out extra);	16✔
66	}	14✔
67	else
68	{	5✔
69	this.name = name;	5✔
70	version = Version.Parse("1.0");	5✔
71	Scrypt = ScryptParameters.Default;	5✔
72	accounts = new Dictionary<UInt160, NEP6Account>();	5✔
73	extra = JToken.Null;	5✔
74	}	5✔
75	}	19✔
76
77	/// <summary>
78	/// Loads the wallet with the specified JSON string.
79	/// </summary>
80	/// <param name="path">The path of the wallet.</param>
81	/// <param name="password">The password of the wallet.</param>
82	/// <param name="settings">The <see cref="ProtocolSettings"/> to be used by the wallet.</param>
83	/// <param name="json">The JSON object representing the wallet.</param>
84	public NEP6Wallet(string path, string password, ProtocolSettings settings, JObject json) : base(path, settings)	154✔
85	{	154✔
86	this.password = password.ToSecureString();	154✔
87	LoadFromJson(json, out Scrypt, out accounts, out extra);	154✔
88	}	154✔
89
90	private void LoadFromJson(JObject wallet, out ScryptParameters scrypt, out Dictionary<UInt160, NEP6Account> accounts, out JToken extra)
91	{	170✔
92	version = Version.Parse(wallet["version"].AsString());	170✔
93	name = wallet["name"]?.AsString();	169✔
94	scrypt = ScryptParameters.FromJson((JObject)wallet["scrypt"]);	169✔
95	accounts = ((JArray)wallet["accounts"]).Select(p => NEP6Account.FromJson((JObject)p, this)).ToDictionary(p => p.ScriptHash);	193✔
96	extra = wallet["extra"];	169✔
97	Thread.MemoryBarrier();	169✔
98	if (!VerifyPasswordInternal(password.GetClearText()))	169✔
99	throw new InvalidOperationException("Wrong password.");	1✔
100	}	168✔
101
102	private void AddAccount(NEP6Account account)
103	{	163✔
104	lock (accounts)	163✔
105	{	163✔
106	if (accounts.TryGetValue(account.ScriptHash, out NEP6Account account_old))	163✔
107	{	3✔
108	account.Label = account_old.Label;	3✔
109	account.IsDefault = account_old.IsDefault;	3✔
110	account.Lock = account_old.Lock;	3✔
111	if (account.Contract == null)	3✔
112	{	1✔
113	account.Contract = account_old.Contract;	1✔
114	}	1✔
115	else
116	{	2✔
117	NEP6Contract contract_old = (NEP6Contract)account_old.Contract;	2✔
118	if (contract_old != null)	2✔
119	{	1✔
120	NEP6Contract contract = (NEP6Contract)account.Contract;	1✔
121	contract.ParameterNames = contract_old.ParameterNames;	1✔
122	contract.Deployed = contract_old.Deployed;	1✔
123	}	1✔
124	}	2✔
125	account.Extra = account_old.Extra;	3✔
126	}	3✔
127	accounts[account.ScriptHash] = account;	163✔
128	}	163✔
129	}	163✔
130
131	public override bool Contains(UInt160 scriptHash)
132	{	28✔
133	lock (accounts)	28✔
134	{	28✔
135	return accounts.ContainsKey(scriptHash);	28✔
136	}
137	}	28✔
138
139	public override WalletAccount CreateAccount(byte[] privateKey)
140	{	47✔
141	if (privateKey is null) throw new ArgumentNullException(nameof(privateKey));	48✔
142	KeyPair key = new(privateKey);	46✔
143	if (key.PublicKey.IsInfinity) throw new ArgumentException(null, nameof(privateKey));	47✔
144	NEP6Contract contract = new()	45✔
145	{	45✔
146	Script = Contract.CreateSignatureRedeemScript(key.PublicKey),	45✔
147	ParameterList = new[] { ContractParameterType.Signature },	45✔
148	ParameterNames = new[] { "signature" },	45✔
149	Deployed = false	45✔
150	};	45✔
151	NEP6Account account = new(this, contract.ScriptHash, key, password.GetClearText())	45✔
152	{	45✔
153	Contract = contract	45✔
154	};	45✔
155	AddAccount(account);	45✔
156	return account;	45✔
157	}	45✔
158
159	public override WalletAccount CreateAccount(Contract contract, KeyPair key = null)
160	{	19✔
161	if (contract is not NEP6Contract nep6contract)	19✔
162	{	18✔
163	nep6contract = new NEP6Contract	18✔
164	{	18✔
165	Script = contract.Script,	18✔
166	ParameterList = contract.ParameterList,	18✔
167	ParameterNames = contract.ParameterList.Select((p, i) => $"parameter{i}").ToArray(),	114✔
168	Deployed = false	18✔
169	};	18✔
170	}	18✔
171	NEP6Account account;
172	if (key == null)	19✔
173	account = new NEP6Account(this, nep6contract.ScriptHash);	1✔
174	else
175	account = new NEP6Account(this, nep6contract.ScriptHash, key, password.GetClearText());	18✔
176	account.Contract = nep6contract;	19✔
177	AddAccount(account);	19✔
178	return account;	19✔
179	}	19✔
180
181	public override WalletAccount CreateAccount(UInt160 scriptHash)
182	{	5✔
183	NEP6Account account = new(this, scriptHash);	5✔
184	AddAccount(account);	5✔
185	return account;	5✔
186	}	5✔
187
188	/// <summary>
189	/// Decrypts the specified NEP-2 string with the password of the wallet.
190	/// </summary>
191	/// <param name="nep2key">The NEP-2 string to decrypt.</param>
192	/// <returns>The decrypted private key.</returns>
193	internal KeyPair DecryptKey(string nep2key)
194	{	2✔
195	return new KeyPair(GetPrivateKeyFromNEP2(nep2key, password.GetClearText(), ProtocolSettings.AddressVersion, Scrypt.N, Scrypt.R, Scrypt.P));	2✔
196	}	2✔
197
198	public override void Delete()
199	{	2✔
200	if (File.Exists(Path)) File.Delete(Path);	4✔
201	}	2✔
202
203	public override bool DeleteAccount(UInt160 scriptHash)
204	{	4✔
205	lock (accounts)	4✔
206	{	4✔
207	return accounts.Remove(scriptHash);	4✔
208	}
209	}	4✔
210
211	public override WalletAccount GetAccount(UInt160 scriptHash)
212	{	259✔
213	lock (accounts)	259✔
214	{	259✔
215	accounts.TryGetValue(scriptHash, out NEP6Account account);	259✔
216	return account;	259✔
217	}
218	}	259✔
219
220	public override IEnumerable<WalletAccount> GetAccounts()
221	{	18✔
222	lock (accounts)	18✔
223	{	18✔
224	foreach (NEP6Account account in accounts.Values)	97✔
225	yield return account;	24✔
226	}	13✔
227	}	13✔
228
229	public override WalletAccount Import(X509Certificate2 cert)
230	{	1✔
231	if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))	1!
UNCOV 232	{	×
233	throw new PlatformNotSupportedException("Importing certificates is not supported on macOS.");	×
234	}
235	KeyPair key;
236	using (ECDsa ecdsa = cert.GetECDsaPrivateKey())	1✔
237	{	1✔
238	key = new KeyPair(ecdsa.ExportParameters(true).D);	1✔
239	}	1✔
240	NEP6Contract contract = new()	1✔
241	{	1✔
242	Script = Contract.CreateSignatureRedeemScript(key.PublicKey),	1✔
243	ParameterList = new[] { ContractParameterType.Signature },	1✔
244	ParameterNames = new[] { "signature" },	1✔
245	Deployed = false	1✔
246	};	1✔
247	NEP6Account account = new(this, contract.ScriptHash, key, password.GetClearText())	1✔
248	{	1✔
249	Contract = contract	1✔
250	};	1✔
251	AddAccount(account);	1✔
252	return account;	1✔
253	}	1✔
254
255	public override WalletAccount Import(string wif)
256	{	90✔
257	KeyPair key = new(GetPrivateKeyFromWIF(wif));	90✔
258	NEP6Contract contract = new()	90✔
259	{	90✔
260	Script = Contract.CreateSignatureRedeemScript(key.PublicKey),	90✔
261	ParameterList = new[] { ContractParameterType.Signature },	90✔
262	ParameterNames = new[] { "signature" },	90✔
263	Deployed = false	90✔
264	};	90✔
265	NEP6Account account = new(this, contract.ScriptHash, key, password.GetClearText())	90✔
266	{	90✔
267	Contract = contract	90✔
268	};	90✔
269	AddAccount(account);	90✔
270	return account;	90✔
271	}	90✔
272
273	public override WalletAccount Import(string nep2, string passphrase, int N = 16384, int r = 8, int p = 8)
274	{	3✔
275	KeyPair key = new(GetPrivateKeyFromNEP2(nep2, passphrase, ProtocolSettings.AddressVersion, N, r, p));	3✔
276	NEP6Contract contract = new()	3✔
277	{	3✔
278	Script = Contract.CreateSignatureRedeemScript(key.PublicKey),	3✔
279	ParameterList = new[] { ContractParameterType.Signature },	3✔
280	ParameterNames = new[] { "signature" },	3✔
281	Deployed = false	3✔
282	};	3✔
283	NEP6Account account;
284	if (Scrypt.N == 16384 && Scrypt.R == 8 && Scrypt.P == 8)	3!
UNCOV 285	account = new NEP6Account(this, contract.ScriptHash, nep2);	×
286	else
287	account = new NEP6Account(this, contract.ScriptHash, key, passphrase);	3✔
288	account.Contract = contract;	3✔
289	AddAccount(account);	3✔
290	return account;	3✔
291	}	3✔
292
293	/// <summary>
294	/// Exports the wallet as JSON
295	/// </summary>
296	public JObject ToJson()
297	{	7✔
298	return new()	7✔
299	{	7✔
300	["name"] = name,	7✔
301	["version"] = version.ToString(),	7✔
302	["scrypt"] = Scrypt.ToJson(),	7✔
303	["accounts"] = accounts.Values.Select(p => p.ToJson()).ToArray(),	6✔
304	["extra"] = extra	7✔
305	};	7✔
306	}	7✔
307
308	public override void Save()
309	{	6✔
310	File.WriteAllText(Path, ToJson().ToString());	6✔
311	}	6✔
312
313	public override bool VerifyPassword(string password)
314	{	5✔
315	return this.password.GetClearText() == password;	5✔
316	}	5✔
317
318	private bool VerifyPasswordInternal(string password)
319	{	169✔
320	lock (accounts)	169✔
321	{	169✔
322	NEP6Account account = accounts.Values.FirstOrDefault(p => !p.Decrypted);	181✔
323	if (account == null)	169✔
324	{	157✔
325	account = accounts.Values.FirstOrDefault(p => p.HasKey);	157✔
326	}	157✔
327	if (account == null) return true;	326✔
328	if (account.Decrypted)	12!
UNCOV 329	{	×
330	return account.VerifyPassword(password);	×
331	}
332	else
333	{	12✔
334	try
335	{	12✔
336	account.GetKey(password);	12✔
337	return true;	11✔
338	}
339	catch (FormatException)	1✔
340	{	1✔
341	return false;	1✔
342	}
343	}
344	}
345	}	169✔
346
347	public override bool ChangePassword(string oldPassword, string newPassword)
348	{	3✔
349	bool succeed = true;	3✔
350	lock (accounts)	3✔
351	{	3✔
352	Parallel.ForEach(accounts.Values, (account, state) =>	3✔
353	{	3✔
354	if (!account.ChangePasswordPrepare(oldPassword, newPassword))	3✔
355	{	1✔
356	state.Stop();	1✔
357	succeed = false;	1✔
358	}	1✔
359	});	6✔
360	}	3✔
361	if (succeed)	3✔
362	{	2✔
363	foreach (NEP6Account account in accounts.Values)	10✔
364	account.ChangePasswordCommit();	2✔
365	password = newPassword.ToSecureString();	2✔
366	}	2✔
367	else
368	{	1✔
369	foreach (NEP6Account account in accounts.Values)	5✔
370	account.ChangePasswordRollback();	1✔
371	}	1✔
372	return succeed;	3✔
373	}	3✔
374	}
375	}

neo-project / neo / 11313431618

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous