[Add] RandomNumberFactory Class

src/Neo.Extensions/BigIntegerExtensions.cs

@@ -160,6 +160,12 @@ public static BigInteger Sqrt(this BigInteger value)
             return z;
         }
 
+        internal static BigInteger GetLowPart(this BigInteger value, int bitCount)
+        {
+            var mask = (BigInteger.One << bitCount) - 1;
+            return value & mask;
+        }
+
         /// <summary>
         /// Gets the number of bits required for shortest two's complement representation of the current instance without the sign bit.
         /// Note: This method is imprecise and might not work as expected with integers larger than 256 bits if less than .NET5.

src/Neo.Extensions/Factories/RandomNumberFactory.cs

@@ -0,0 +1,291 @@
+// Copyright (C) 2015-2025 The Neo Project.
+//
+// RandomNumberFactory.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 System;
+using System.Buffers.Binary;
+using System.Numerics;
+using System.Security.Cryptography;
+
+namespace Neo.Extensions.Factories
+{
+    public static class RandomNumberFactory
+    {
+        public static sbyte NextSByte() =>
+            NextSByte(0, sbyte.MaxValue);
+
+        public static sbyte NextSByte(sbyte maxValue)
+        {
+            if (maxValue < 0)
+                throw new ArgumentOutOfRangeException(nameof(maxValue));
+
+            return NextSByte(0, maxValue);
+        }
+
+        public static sbyte NextSByte(sbyte minValue, sbyte maxValue)
+        {
+            if (minValue == maxValue) return maxValue;
+
+            if (minValue > maxValue)
+                throw new ArgumentOutOfRangeException(nameof(minValue));
+
+            return (sbyte)(NextUInt32((uint)(maxValue - minValue)) + minValue);
+        }
+
+        public static byte NextByte() =>
+            NextByte(0, byte.MaxValue);
+
+        public static byte NextByte(byte maxValue) =>
+            NextByte(0, maxValue);
+
+        public static byte NextByte(byte minValue, byte maxValue)
+        {
+            if (minValue == maxValue) return maxValue;
+
+            if (minValue > maxValue)
+                throw new ArgumentOutOfRangeException(nameof(minValue));
+
+            return (byte)(NextUInt32((uint)(maxValue - minValue)) + minValue);
+        }
+
+        public static short NextInt16() =>
+            NextInt16(0, short.MaxValue);
+
+        public static short NextInt16(short maxValue)
+        {
+            if (maxValue < 0)
+                throw new ArgumentOutOfRangeException(nameof(maxValue));
+
+            return NextInt16(0, maxValue);
+        }
+
+        public static short NextInt16(short minValue, short maxValue)
+        {
+            if (minValue == maxValue) return maxValue;
+
+            if (minValue > maxValue)
+                throw new ArgumentOutOfRangeException(nameof(minValue));
+
+            return (short)(NextUInt32((uint)(maxValue - minValue)) + minValue);
+        }
+
+        public static ushort NextUInt16() =>
+            NextUInt16(0, ushort.MaxValue);
+
+        public static ushort NextUInt16(ushort maxValue) =>
+            NextUInt16(0, maxValue);
+
+        public static ushort NextUInt16(ushort minValue, ushort maxValue)
+        {
+            if (minValue == maxValue) return maxValue;
+
+            if (minValue > maxValue)
+                throw new ArgumentOutOfRangeException(nameof(minValue));
+
+            return (ushort)(NextUInt32((uint)(maxValue - minValue)) + minValue);
+        }
+
+        public static int NextInt32() =>
+            NextInt32(0, int.MaxValue);
+
+        public static int NextInt32(int maxValue)
+        {
+            if (maxValue < 0)
+                throw new ArgumentOutOfRangeException(nameof(maxValue));
+
+            return NextInt32(0, maxValue);
+        }
+
+        public static int NextInt32(int minValue, int maxValue)
+        {
+            if (minValue == maxValue) return maxValue;
+
+            if (minValue > maxValue)
+                throw new ArgumentOutOfRangeException(nameof(minValue));
+
+            return (int)NextUInt32((uint)(maxValue - minValue)) + minValue;
+        }
+
+        public static uint NextUInt32()
+        {
+            Span<byte> longBytes = stackalloc byte[4];
+            RandomNumberGenerator.Fill(longBytes);
+            return BinaryPrimitives.ReadUInt32LittleEndian(longBytes);
+        }
+
+        public static uint NextUInt32(uint maxValue)
+        {
+            var randomProduct = (ulong)maxValue * NextUInt32();
+            var lowPart = (uint)randomProduct;
+
+            if (lowPart < maxValue)
+            {
+                var remainder = (0u - maxValue) % maxValue;
+
+                while (lowPart < remainder)
+                {
+                    randomProduct = (ulong)maxValue * NextUInt32();
+                    lowPart = (uint)randomProduct;
+                }
+            }
+
+            return (uint)(randomProduct >> 32);
+        }
+
+        public static uint NextUInt32(uint minValue, uint maxValue)
+        {
+            if (minValue == maxValue) return maxValue;
+
+            if (minValue > maxValue)
+                throw new ArgumentOutOfRangeException(nameof(minValue));
+
+            return NextUInt32(maxValue - minValue) + minValue;
+        }
+
+        public static long NextInt64() =>
+            NextInt64(0L, long.MaxValue);
+
+        public static long NextInt64(long maxValue)
+        {
+            return NextInt64(0L, maxValue);
+        }
+
+        public static long NextInt64(long minValue, long maxValue)
+        {
+            if (minValue == maxValue) return maxValue;
+
+            if (minValue > maxValue)
+                throw new ArgumentOutOfRangeException(nameof(minValue));
+
+            return (long)NextUInt64((ulong)(maxValue - minValue)) + minValue;
+        }
+
+        public static ulong NextUInt64()
+        {
+            Span<byte> longBytes = stackalloc byte[8];
+            RandomNumberGenerator.Fill(longBytes);
+            return BinaryPrimitives.ReadUInt64LittleEndian(longBytes);
+        }
+
+        public static ulong NextUInt64(ulong maxValue)
+        {
+            var randomProduct = BigMul(maxValue, NextUInt64(), out var lowPart);
+
+            if (lowPart < maxValue)
+            {
+                var remainder = (0ul - maxValue) % maxValue;
+
+                while (lowPart < remainder)
+                {
+                    randomProduct = BigMul(maxValue, NextUInt64(), out lowPart);
+                }
+            }
+
+            return randomProduct;
+        }
+
+        public static ulong NextUInt64(ulong minValue, ulong maxValue)
+        {
+            if (minValue == maxValue) return maxValue;
+
+            if (minValue > maxValue)
+                throw new ArgumentOutOfRangeException(nameof(minValue));
+
+            return NextUInt64(maxValue - minValue) + minValue;
+        }
+
+        public static BigInteger NextBigInteger(BigInteger minValue, BigInteger maxValue)
+        {
+            if (minValue == maxValue) return maxValue;
+
+            if (minValue > maxValue)
+                throw new ArgumentOutOfRangeException(nameof(minValue));
+
+            return NextBigInteger(maxValue - minValue) + minValue;
+        }
+
+        public static BigInteger NextBigInteger(BigInteger maxValue)
+        {
+            if (maxValue.Sign < 0)
+                throw new ArgumentOutOfRangeException(nameof(maxValue));
+
+            var maxValueBits = maxValue.GetByteCount() * 8;
+            var maxValueSize = BigInteger.Pow(2, maxValueBits);
+
+            var randomProduct = maxValue * NextBigInteger(maxValueBits);
+            var randomProductBits = randomProduct.GetByteCount() * 8;
+
+            var lowPart = randomProduct.GetLowPart(maxValueBits);
+
+            if (lowPart < maxValue)
+            {
+                var remainder = (maxValueSize - maxValue) % maxValue;
+
+                while (lowPart < remainder)
+                {
+                    randomProduct = maxValue * NextBigInteger(maxValueBits);
+                    randomProductBits = randomProduct.GetByteCount() * 8;
+                    lowPart = randomProduct.GetLowPart(maxValueBits);
+                }
+            }
+
+            var result = randomProduct >> (randomProductBits - maxValueBits);
+
+            // Since BigInteger doesn't have a max value or bit size
+            // anything over 'maxValue' return zero
+            if (result >= maxValue)
+                return BigInteger.Zero;
+
+            return result;
+        }
+
+        public static BigInteger NextBigInteger(int sizeInBits)
+        {
+            if (sizeInBits < 0)
+                throw new ArgumentException("sizeInBits must be non-negative.");
+
+            if (sizeInBits == 0)
+                return BigInteger.Zero;
+
+            Span<byte> b = stackalloc byte[sizeInBits / 8 + 1];
+            RandomNumberGenerator.Fill(b);
+
+            if (sizeInBits % 8 == 0)
+                b[^1] = 0;
+            else
+                b[^1] &= (byte)((1 << sizeInBits % 8) - 1);
+
+            return new BigInteger(b);
+        }
+
+        private static ulong BigMul(ulong a, ulong b, out ulong low)
+        {
+            // Adaptation of algorithm for multiplication
+            // of 32-bit unsigned integers described
+            // in Hacker's Delight by Henry S. Warren, Jr. (ISBN 0-201-91465-4), Chapter 8
+            // Basically, it's an optimized version of FOIL method applied to
+            // low and high dwords of each operand
+
+            // Use 32-bit uints to optimize the fallback for 32-bit platforms.
+            var al = (uint)a;
+            var ah = (uint)(a >> 32);
+            var bl = (uint)b;
+            var bh = (uint)(b >> 32);
+
+            var mull = ((ulong)al) * bl;
+            var t = ((ulong)ah) * bl + (mull >> 32);
+            var tl = ((ulong)al) * bh + (uint)t;
+
+            low = (tl << 32) | (uint)mull;
+
+            return ((ulong)ah) * bh + (t >> 32) + (tl >> 32);
+        }
+    }
+}

src/Neo/Cryptography/ECC/ECFieldElement.cs

@@ -12,6 +12,7 @@
 #nullable enable
 
 using Neo.Extensions;
+using Neo.Extensions.Factories;
 using System;
 using System.Numerics;
 
@@ -121,11 +122,10 @@ public override int GetHashCode()
             BigInteger U, V;
             do
             {
-                Random rand = new();
-                BigInteger P;
+                var P = BigInteger.Zero;
                 do
                 {
-                    P = rand.NextBigInteger((int)_curve.Q.GetBitLength());
+                    P = RandomNumberFactory.NextBigInteger((int)_curve.Q.GetBitLength());
                 }
                 while (P >= _curve.Q || BigInteger.ModPow(P * P - fourQ, legendreExponent, _curve.Q) != qMinusOne);
                 var result = FastLucasSequence(_curve.Q, P, Q, k);