11622351556

Committed 01 Nov 2024 01:01AM UTC coverage: 55.932% (+0.005%) from 55.927%

Build # 11622351556

Build Type

Pull #3559

github

Committed by

web-flow

Commit Message

Merge c7e5b8693 into a42bc8d14

Pull Request Pull Request #3559: use `Xxhash3` for StorageKey.GetHashCode

Run Details

5800 of 8940 branches covered (64.88%)

Branch coverage included in aggregate %.

10 of 19 new or added lines in 4 files covered. (52.63%)

39 existing lines in 3 files now uncovered.

21780 of 40370 relevant lines covered (53.95%)

86033.19 hits per line

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

82.58

/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.IO.Hashing;
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 32-bit hash value for the specified byte array using the xxhash3 algorithm.
        /// </summary>
        /// <param name="value">The input to compute the hash code for.</param>
        /// <param name="seed">The seed used by the xxhash3 algorithm.</param>
        /// <returns>The computed hash code.</returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static uint XxHash3_32(this ReadOnlySpan<byte> value, uint seed = 0)
        {
            return (uint)XxHash3.HashToUInt64(value, seed);
        }

        /// <summary>
        /// Computes the 32-bit hash value for the specified byte array using the xxhash3 algorithm.
        /// </summary>
        /// <param name="value">The input to compute the hash code for.</param>
        /// <param name="seed">The seed used by the xxhash3 algorithm.</param>
        /// <returns>The computed hash code.</returns>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static uint XxHash3_32(this byte[] value, uint seed = 0)
        {
            return XxHash3_32(value.AsSpan(), seed);
        }

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

neo-project / neo / 11622351556

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