11676252791

Committed 05 Nov 2024 02:11AM UTC coverage: 55.857% (-0.03%) from 55.891%

Build # 11676252791

Build Type

Pull #3562

github

Committed by

web-flow

Commit Message

Merge 282623f67 into a856982dd

Pull Request Pull Request #3562: A simpler impl for `ByteArrayEqualityComparer` and remove redundant impl

Run Details

5760 of 8884 branches covered (64.84%)

Branch coverage included in aggregate %.

21 of 21 new or added lines in 2 files covered. (100.0%)

47 existing lines in 3 files now uncovered.

21679 of 40240 relevant lines covered (53.87%)

86444.04 hits per line

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

81.88

/src/Neo/Cryptography/Helper.cs

// Copyright (C) 2015-2024 The Neo Project.
//
// Helper.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.IO;
using Neo.Network.P2P.Payloads;
using Neo.Wallets;
using Org.BouncyCastle.Crypto.Digests;
using Org.BouncyCastle.Crypto.Engines;
using Org.BouncyCastle.Crypto.Modes;
using Org.BouncyCastle.Crypto.Parameters;
using System;
using System.Buffers.Binary;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security.Cryptography;
using ECPoint = Neo.Cryptography.ECC.ECPoint;

namespace Neo.Cryptography
{
    /// <summary>
    /// A helper class for cryptography
    /// </summary>
    public static class Helper
    {
        private static readonly bool IsOSX = RuntimeInformation.IsOSPlatform(OSPlatform.OSX);
        /// <summary>
        /// Computes the hash value for the specified byte array using the ripemd160 algorithm.
        /// </summary>
        /// <param name="value">The input to compute the hash code for.</param>
        /// <returns>The computed hash code.</returns>
        public static byte[] RIPEMD160(this byte[] value)
        {
            using var ripemd160 = new RIPEMD160Managed();
            return ripemd160.ComputeHash(value);
        }

        /// <summary>
        /// Computes the hash value for the specified byte array using the ripemd160 algorithm.
        /// </summary>
        /// <param name="value">The input to compute the hash code for.</param>
        /// <returns>The computed hash code.</returns>
        public static byte[] RIPEMD160(this ReadOnlySpan<byte> value)
        {
            byte[] source = value.ToArray();
            return source.RIPEMD160();
        }

        /// <summary>
        /// Computes the hash value for the specified byte array using the murmur algorithm.
        /// </summary>
        /// <param name="value">The input to compute the hash code for.</param>
        /// <param name="seed">The seed used by the murmur algorithm.</param>
        /// <returns>The computed hash code.</returns>
        public static uint Murmur32(this byte[] value, uint seed)
        {
            using Murmur32 murmur = new(seed);
            return BinaryPrimitives.ReadUInt32LittleEndian(murmur.ComputeHash(value));
        }

        /// <summary>
        /// Computes the hash value for the specified byte array using the murmur algorithm.
        /// </summary>
        /// <param name="value">The input to compute the hash code for.</param>
        /// <param name="seed">The seed used by the murmur algorithm.</param>
        /// <returns>The computed hash code.</returns>
        public static uint Murmur32(this ReadOnlySpan<byte> value, uint seed)
        {
            Span<byte> buffer = stackalloc byte[sizeof(uint)];
            using Murmur32 murmur = new(seed);
            murmur.TryComputeHash(value, buffer, out _);
            return BinaryPrimitives.ReadUInt32LittleEndian(buffer);
        }

        /// <summary>
        /// Computes the 128-bit hash value for the specified byte array using the murmur algorithm.
        /// </summary>
        /// <param name="value">The input to compute the hash code for.</param>
        /// <param name="seed">The seed used by the murmur algorithm.</param>
        /// <returns>The computed hash code.</returns>
        public static byte[] Murmur128(this byte[] value, uint seed)
        {
            using Murmur128 murmur = new(seed);
            return murmur.ComputeHash(value);
        }

        /// <summary>
        /// Computes the 128-bit hash value for the specified byte array using the murmur algorithm.
        /// </summary>
        /// <param name="value">The input to compute the hash code for.</param>
        /// <param name="seed">The seed used by the murmur algorithm.</param>
        /// <returns>The computed hash code.</returns>
        public static byte[] Murmur128(this ReadOnlySpan<byte> value, uint seed)
        {
            byte[] buffer = new byte[16];
            using Murmur128 murmur = new(seed);
            murmur.TryComputeHash(value, buffer, out _);
            return buffer;
        }

        /// <summary>
        /// Computes the hash value for the specified byte array using the sha256 algorithm.
        /// </summary>
        /// <param name="value">The input to compute the hash code for.</param>
        /// <returns>The computed hash code.</returns>
        public static byte[] Sha256(this byte[] value)
        {
            using var sha256 = SHA256.Create();
            return sha256.ComputeHash(value);
        }

        /// <summary>
        /// Computes the hash value for the specified region of the specified byte array using the sha256 algorithm.
        /// </summary>
        /// <param name="value">The input to compute the hash code for.</param>
        /// <param name="offset">The offset into the byte array from which to begin using data.</param>
        /// <param name="count">The number of bytes in the array to use as data.</param>
        /// <returns>The computed hash code.</returns>
        public static byte[] Sha256(this byte[] value, int offset, int count)
        {
            using var sha256 = SHA256.Create();
            return sha256.ComputeHash(value, offset, count);
        }

        /// <summary>
        /// Computes the hash value for the specified byte array using the sha256 algorithm.
        /// </summary>
        /// <param name="value">The input to compute the hash code for.</param>
        /// <returns>The computed hash code.</returns>
        public static byte[] Sha256(this ReadOnlySpan<byte> value)
        {
            byte[] buffer = new byte[32];
            using var sha256 = SHA256.Create();
            sha256.TryComputeHash(value, buffer, out _);
            return buffer;
        }

        /// <summary>
        /// Computes the hash value for the specified byte array using the sha256 algorithm.
        /// </summary>
        /// <param name="value">The input to compute the hash code for.</param>
        /// <returns>The computed hash code.</returns>
        public static byte[] Sha256(this Span<byte> value)
        {
            return Sha256((ReadOnlySpan<byte>)value);
        }

        /// <summary>
        /// Computes the hash value for the specified byte array using the keccak256 algorithm.
        /// </summary>
        /// <param name="value">The input to compute the hash code for.</param>
        /// <returns>The computed hash code.</returns>
        public static byte[] Keccak256(this byte[] value)
        {
            KeccakDigest keccak = new(256);
            keccak.BlockUpdate(value, 0, value.Length);
            byte[] result = new byte[keccak.GetDigestSize()];
            keccak.DoFinal(result, 0);
            return result;
        }

        /// <summary>
        /// Computes the hash value for the specified byte array using the keccak256 algorithm.
        /// </summary>
        /// <param name="value">The input to compute the hash code for.</param>
        /// <returns>The computed hash code.</returns>
        public static byte[] Keccak256(this ReadOnlySpan<byte> value)
        {
            return Keccak256(value.ToArray());
        }

        /// <summary>
        /// Computes the hash value for the specified byte array using the keccak256 algorithm.
        /// </summary>
        /// <param name="value">The input to compute the hash code for.</param>
        /// <returns>The computed hash code.</returns>
        public static byte[] Keccak256(this Span<byte> value)
        {
            return Keccak256(value.ToArray());
        }

        public static byte[] AES256Encrypt(this byte[] plainData, byte[] key, byte[] nonce, byte[] associatedData = null)
        {
            if (nonce.Length != 12) throw new ArgumentOutOfRangeException(nameof(nonce));
            var tag = new byte[16];
            var cipherBytes = new byte[plainData.Length];
            if (!IsOSX)
            {
#pragma warning disable SYSLIB0053 // Type or member is obsolete
                using var cipher = new AesGcm(key);
#pragma warning restore SYSLIB0053 // Type or member is obsolete
                cipher.Encrypt(nonce, plainData, cipherBytes, tag, associatedData);
            }
            else
            {
                var cipher = new GcmBlockCipher(new AesEngine());
                var parameters = new AeadParameters(
                    new KeyParameter(key),
                    128, //128 = 16 * 8 => (tag size * 8)
                    nonce,
                    associatedData);
                cipher.Init(true, parameters);
                cipherBytes = new byte[cipher.GetOutputSize(plainData.Length)];
                var length = cipher.ProcessBytes(plainData, 0, plainData.Length, cipherBytes, 0);
                cipher.DoFinal(cipherBytes, length);
            }
            return [.. nonce, .. cipherBytes, .. tag];
        }

        public static byte[] AES256Decrypt(this byte[] encryptedData, byte[] key, byte[] associatedData = null)
        {
            ReadOnlySpan<byte> encrypted = encryptedData;
            var nonce = encrypted[..12];
            var cipherBytes = encrypted[12..^16];
            var tag = encrypted[^16..];
            var decryptedData = new byte[cipherBytes.Length];
            if (!IsOSX)
            {
#pragma warning disable SYSLIB0053 // Type or member is obsolete
                using var cipher = new AesGcm(key);
#pragma warning restore SYSLIB0053 // Type or member is obsolete
                cipher.Decrypt(nonce, cipherBytes, tag, decryptedData, associatedData);
            }
            else
            {
                var cipher = new GcmBlockCipher(new AesEngine());
                var parameters = new AeadParameters(
                    new KeyParameter(key),
                    128,  //128 = 16 * 8 => (tag size * 8)
                    nonce.ToArray(),
                    associatedData);
                cipher.Init(false, parameters);
                decryptedData = new byte[cipher.GetOutputSize(cipherBytes.Length)];
                var length = cipher.ProcessBytes(cipherBytes.ToArray(), 0, cipherBytes.Length, decryptedData, 0);
                cipher.DoFinal(decryptedData, length);
            }
            return decryptedData;
        }

        public static byte[] ECDHDeriveKey(KeyPair local, ECPoint remote)
        {
            ReadOnlySpan<byte> pubkey_local = local.PublicKey.EncodePoint(false);
            ReadOnlySpan<byte> pubkey_remote = remote.EncodePoint(false);
            using ECDiffieHellman ecdh1 = ECDiffieHellman.Create(new ECParameters
            {
                Curve = ECCurve.NamedCurves.nistP256,
                D = local.PrivateKey,
                Q = new System.Security.Cryptography.ECPoint
                {
                    X = pubkey_local[1..][..32].ToArray(),
                    Y = pubkey_local[1..][32..].ToArray()
                }
            });
            using ECDiffieHellman ecdh2 = ECDiffieHellman.Create(new ECParameters
            {
                Curve = ECCurve.NamedCurves.nistP256,
                Q = new System.Security.Cryptography.ECPoint
                {
                    X = pubkey_remote[1..][..32].ToArray(),
                    Y = pubkey_remote[1..][32..].ToArray()
                }
            });
            return ecdh1.DeriveKeyMaterial(ecdh2.PublicKey).Sha256();//z = r * P = r* k * G
        }

        internal static bool Test(this BloomFilter filter, Transaction tx)
        {
            if (filter.Check(tx.Hash.ToArray())) return true;
            if (tx.Signers.Any(p => filter.Check(p.Account.ToArray())))
                return true;
            return false;
        }

        /// <summary>
        /// Rotates the specified value left by the specified number of bits.
        /// Similar in behavior to the x86 instruction ROL.
        /// </summary>
        /// <param name="value">The value to rotate.</param>
        /// <param name="offset">The number of bits to rotate by.
        /// Any value outside the range [0..31] is treated as congruent mod 32.</param>
        /// <returns>The rotated value.</returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static uint RotateLeft(uint value, int offset)
            => (value << offset) | (value >> (32 - offset));

        /// <summary>
        /// Rotates the specified value left by the specified number of bits.
        /// Similar in behavior to the x86 instruction ROL.
        /// </summary>
        /// <param name="value">The value to rotate.</param>
        /// <param name="offset">The number of bits to rotate by.
        /// Any value outside the range [0..63] is treated as congruent mod 64.</param>
        /// <returns>The rotated value.</returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ulong RotateLeft(ulong value, int offset)
            => (value << offset) | (value >> (64 - offset));
    }
}

1	// Copyright (C) 2015-2024 The Neo Project.
2	//
3	// Helper.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.IO;
13	using Neo.Network.P2P.Payloads;
14	using Neo.Wallets;
15	using Org.BouncyCastle.Crypto.Digests;
16	using Org.BouncyCastle.Crypto.Engines;
17	using Org.BouncyCastle.Crypto.Modes;
18	using Org.BouncyCastle.Crypto.Parameters;
19	using System;
20	using System.Buffers.Binary;
21	using System.Linq;
22	using System.Runtime.CompilerServices;
23	using System.Runtime.InteropServices;
24	using System.Security.Cryptography;
25	using ECPoint = Neo.Cryptography.ECC.ECPoint;
26
27	namespace Neo.Cryptography
28	{
29	/// <summary>
30	/// A helper class for cryptography
31	/// </summary>
32	public static class Helper
33	{
34	private static readonly bool IsOSX = RuntimeInformation.IsOSPlatform(OSPlatform.OSX);	1✔
35	/// <summary>
36	/// Computes the hash value for the specified byte array using the ripemd160 algorithm.
37	/// </summary>
38	/// <param name="value">The input to compute the hash code for.</param>
39	/// <returns>The computed hash code.</returns>
40	public static byte[] RIPEMD160(this byte[] value)
41	{	3,497✔
42	using var ripemd160 = new RIPEMD160Managed();	3,497✔
43	return ripemd160.ComputeHash(value);	3,497✔
44	}	3,497✔
45
46	/// <summary>
47	/// Computes the hash value for the specified byte array using the ripemd160 algorithm.
48	/// </summary>
49	/// <param name="value">The input to compute the hash code for.</param>
50	/// <returns>The computed hash code.</returns>
51	public static byte[] RIPEMD160(this ReadOnlySpan<byte> value)
52	{	1✔
53	byte[] source = value.ToArray();	1✔
54	return source.RIPEMD160();	1✔
55	}	1✔
56
57	/// <summary>
58	/// Computes the hash value for the specified byte array using the murmur algorithm.
59	/// </summary>
60	/// <param name="value">The input to compute the hash code for.</param>
61	/// <param name="seed">The seed used by the murmur algorithm.</param>
62	/// <returns>The computed hash code.</returns>
63	public static uint Murmur32(this byte[] value, uint seed)
64	{	65✔
65	using Murmur32 murmur = new(seed);	65✔
66	return BinaryPrimitives.ReadUInt32LittleEndian(murmur.ComputeHash(value));	65✔
67	}	65✔
68
69	/// <summary>
70	/// Computes the hash value for the specified byte array using the murmur algorithm.
71	/// </summary>
72	/// <param name="value">The input to compute the hash code for.</param>
73	/// <param name="seed">The seed used by the murmur algorithm.</param>
74	/// <returns>The computed hash code.</returns>
75	public static uint Murmur32(this ReadOnlySpan<byte> value, uint seed)
76	{	143,950✔
77	Span<byte> buffer = stackalloc byte[sizeof(uint)];	143,950✔
78	using Murmur32 murmur = new(seed);	143,950✔
79	murmur.TryComputeHash(value, buffer, out _);	143,950✔
80	return BinaryPrimitives.ReadUInt32LittleEndian(buffer);	143,950✔
81	}	143,950✔
82
83	/// <summary>
84	/// Computes the 128-bit hash value for the specified byte array using the murmur algorithm.
85	/// </summary>
86	/// <param name="value">The input to compute the hash code for.</param>
87	/// <param name="seed">The seed used by the murmur algorithm.</param>
88	/// <returns>The computed hash code.</returns>
89	public static byte[] Murmur128(this byte[] value, uint seed)
90	{	25✔
91	using Murmur128 murmur = new(seed);	25✔
92	return murmur.ComputeHash(value);	25✔
93	}	25✔
94
95	/// <summary>
96	/// Computes the 128-bit hash value for the specified byte array using the murmur algorithm.
97	/// </summary>
98	/// <param name="value">The input to compute the hash code for.</param>
99	/// <param name="seed">The seed used by the murmur algorithm.</param>
100	/// <returns>The computed hash code.</returns>
101	public static byte[] Murmur128(this ReadOnlySpan<byte> value, uint seed)
102	{	1✔
103	byte[] buffer = new byte[16];	1✔
104	using Murmur128 murmur = new(seed);	1✔
105	murmur.TryComputeHash(value, buffer, out _);	1✔
106	return buffer;	1✔
107	}	1✔
108
109	/// <summary>
110	/// Computes the hash value for the specified byte array using the sha256 algorithm.
111	/// </summary>
112	/// <param name="value">The input to compute the hash code for.</param>
113	/// <returns>The computed hash code.</returns>
114	public static byte[] Sha256(this byte[] value)
115	{	7,032✔
116	using var sha256 = SHA256.Create();	7,032✔
117	return sha256.ComputeHash(value);	7,032✔
118	}	7,032✔
119
120	/// <summary>
121	/// Computes the hash value for the specified region of the specified byte array using the sha256 algorithm.
122	/// </summary>
123	/// <param name="value">The input to compute the hash code for.</param>
124	/// <param name="offset">The offset into the byte array from which to begin using data.</param>
125	/// <param name="count">The number of bytes in the array to use as data.</param>
126	/// <returns>The computed hash code.</returns>
127	public static byte[] Sha256(this byte[] value, int offset, int count)
128	{	232✔
129	using var sha256 = SHA256.Create();	232✔
130	return sha256.ComputeHash(value, offset, count);	232✔
131	}	232✔
132
133	/// <summary>
134	/// Computes the hash value for the specified byte array using the sha256 algorithm.
135	/// </summary>
136	/// <param name="value">The input to compute the hash code for.</param>
137	/// <returns>The computed hash code.</returns>
138	public static byte[] Sha256(this ReadOnlySpan<byte> value)
139	{	7,611✔
140	byte[] buffer = new byte[32];	7,611✔
141	using var sha256 = SHA256.Create();	7,611✔
142	sha256.TryComputeHash(value, buffer, out _);	7,611✔
143	return buffer;	7,611✔
144	}	7,611✔
145
146	/// <summary>
147	/// Computes the hash value for the specified byte array using the sha256 algorithm.
148	/// </summary>
149	/// <param name="value">The input to compute the hash code for.</param>
150	/// <returns>The computed hash code.</returns>
151	public static byte[] Sha256(this Span<byte> value)
152	{	1✔
153	return Sha256((ReadOnlySpan<byte>)value);	1✔
154	}	1✔
155
156	/// <summary>
157	/// Computes the hash value for the specified byte array using the keccak256 algorithm.
158	/// </summary>
159	/// <param name="value">The input to compute the hash code for.</param>
160	/// <returns>The computed hash code.</returns>
161	public static byte[] Keccak256(this byte[] value)
162	{	24✔
163	KeccakDigest keccak = new(256);	24✔
164	keccak.BlockUpdate(value, 0, value.Length);	24✔
165	byte[] result = new byte[keccak.GetDigestSize()];	24✔
166	keccak.DoFinal(result, 0);	24✔
167	return result;	24✔
168	}	24✔
169
170	/// <summary>
171	/// Computes the hash value for the specified byte array using the keccak256 algorithm.
172	/// </summary>
173	/// <param name="value">The input to compute the hash code for.</param>
174	/// <returns>The computed hash code.</returns>
175	public static byte[] Keccak256(this ReadOnlySpan<byte> value)
176	{	10✔
177	return Keccak256(value.ToArray());	10✔
178	}	10✔
179
180	/// <summary>
181	/// Computes the hash value for the specified byte array using the keccak256 algorithm.
182	/// </summary>
183	/// <param name="value">The input to compute the hash code for.</param>
184	/// <returns>The computed hash code.</returns>
185	public static byte[] Keccak256(this Span<byte> value)
186	{	1✔
187	return Keccak256(value.ToArray());	1✔
188	}	1✔
189
190	public static byte[] AES256Encrypt(this byte[] plainData, byte[] key, byte[] nonce, byte[] associatedData = null)
191	{	2✔
192	if (nonce.Length != 12) throw new ArgumentOutOfRangeException(nameof(nonce));	2!
193	var tag = new byte[16];	2✔
194	var cipherBytes = new byte[plainData.Length];	2✔
195	if (!IsOSX)	2!
196	{	2✔
197	#pragma warning disable SYSLIB0053 // Type or member is obsolete
198	using var cipher = new AesGcm(key);	2✔
199	#pragma warning restore SYSLIB0053 // Type or member is obsolete
200	cipher.Encrypt(nonce, plainData, cipherBytes, tag, associatedData);	2✔
201	}	2✔
202	else
UNCOV 203	{	×
UNCOV 204	var cipher = new GcmBlockCipher(new AesEngine());	×
UNCOV 205	var parameters = new AeadParameters(	×
UNCOV 206	new KeyParameter(key),	×
207	128, //128 = 16 * 8 => (tag size * 8)	×
208	nonce,	×
209	associatedData);	×
210	cipher.Init(true, parameters);	×
211	cipherBytes = new byte[cipher.GetOutputSize(plainData.Length)];	×
212	var length = cipher.ProcessBytes(plainData, 0, plainData.Length, cipherBytes, 0);	×
213	cipher.DoFinal(cipherBytes, length);	×
214	}	×
215	return [.. nonce, .. cipherBytes, .. tag];	2✔
216	}	2✔
217
218	public static byte[] AES256Decrypt(this byte[] encryptedData, byte[] key, byte[] associatedData = null)
219	{	3✔
220	ReadOnlySpan<byte> encrypted = encryptedData;	3✔
221	var nonce = encrypted[..12];	3✔
222	var cipherBytes = encrypted[12..^16];	3✔
223	var tag = encrypted[^16..];	3✔
224	var decryptedData = new byte[cipherBytes.Length];	3✔
225	if (!IsOSX)	3!
226	{	3✔
227	#pragma warning disable SYSLIB0053 // Type or member is obsolete
228	using var cipher = new AesGcm(key);	3✔
229	#pragma warning restore SYSLIB0053 // Type or member is obsolete
230	cipher.Decrypt(nonce, cipherBytes, tag, decryptedData, associatedData);	3✔
231	}	3✔
232	else
UNCOV 233	{	×
UNCOV 234	var cipher = new GcmBlockCipher(new AesEngine());	×
UNCOV 235	var parameters = new AeadParameters(	×
UNCOV 236	new KeyParameter(key),	×
UNCOV 237	128, //128 = 16 * 8 => (tag size * 8)	×
UNCOV 238	nonce.ToArray(),	×
UNCOV 239	associatedData);	×
UNCOV 240	cipher.Init(false, parameters);	×
UNCOV 241	decryptedData = new byte[cipher.GetOutputSize(cipherBytes.Length)];	×
UNCOV 242	var length = cipher.ProcessBytes(cipherBytes.ToArray(), 0, cipherBytes.Length, decryptedData, 0);	×
UNCOV 243	cipher.DoFinal(decryptedData, length);	×
UNCOV 244	}	×
245	return decryptedData;	3✔
246	}	3✔
247
248	public static byte[] ECDHDeriveKey(KeyPair local, ECPoint remote)
249	{	2✔
250	ReadOnlySpan<byte> pubkey_local = local.PublicKey.EncodePoint(false);	2✔
251	ReadOnlySpan<byte> pubkey_remote = remote.EncodePoint(false);	2✔
252	using ECDiffieHellman ecdh1 = ECDiffieHellman.Create(new ECParameters	2✔
253	{	2✔
254	Curve = ECCurve.NamedCurves.nistP256,	2✔
255	D = local.PrivateKey,	2✔
256	Q = new System.Security.Cryptography.ECPoint	2✔
257	{	2✔
258	X = pubkey_local[1..][..32].ToArray(),	2✔
259	Y = pubkey_local[1..][32..].ToArray()	2✔
260	}	2✔
261	});	2✔
262	using ECDiffieHellman ecdh2 = ECDiffieHellman.Create(new ECParameters	2✔
263	{	2✔
264	Curve = ECCurve.NamedCurves.nistP256,	2✔
265	Q = new System.Security.Cryptography.ECPoint	2✔
266	{	2✔
267	X = pubkey_remote[1..][..32].ToArray(),	2✔
268	Y = pubkey_remote[1..][32..].ToArray()	2✔
269	}	2✔
270	});	2✔
271	return ecdh1.DeriveKeyMaterial(ecdh2.PublicKey).Sha256();//z = r * P = r* k * G	2✔
272	}	2✔
273
274	internal static bool Test(this BloomFilter filter, Transaction tx)
275	{	3✔
276	if (filter.Check(tx.Hash.ToArray())) return true;	4✔
277	if (tx.Signers.Any(p => filter.Check(p.Account.ToArray())))	4✔
278	return true;	1✔
279	return false;	1✔
280	}	3✔
281
282	/// <summary>
283	/// Rotates the specified value left by the specified number of bits.
284	/// Similar in behavior to the x86 instruction ROL.
285	/// </summary>
286	/// <param name="value">The value to rotate.</param>
287	/// <param name="offset">The number of bits to rotate by.
288	/// Any value outside the range [0..31] is treated as congruent mod 32.</param>
289	/// <returns>The rotated value.</returns>
290	[MethodImpl(MethodImplOptions.AggressiveInlining)]
291	public static uint RotateLeft(uint value, int offset)
292	=> (value << offset) \| (value >> (32 - offset));	784,640✔
293
294	/// <summary>
295	/// Rotates the specified value left by the specified number of bits.
296	/// Similar in behavior to the x86 instruction ROL.
297	/// </summary>
298	/// <param name="value">The value to rotate.</param>
299	/// <param name="offset">The number of bits to rotate by.
300	/// Any value outside the range [0..63] is treated as congruent mod 64.</param>
301	/// <returns>The rotated value.</returns>
302	[MethodImpl(MethodImplOptions.AggressiveInlining)]
303	public static ulong RotateLeft(ulong value, int offset)
304	=> (value << offset) \| (value >> (64 - offset));	94✔
305	}
306	}

neo-project / neo / 11676252791

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