using System;

using System.Numerics;

using System.Security.Cryptography;

using System.Linq; // Importar el espacio de nombres System.Linq

using AngouriMath;

using AngouriMath.Extensions;

using AngouriMath.Functions;

using NBitcoin;

​

class Program

{

    static void Main()

    {

        int num = 0;

        int primosEncontrados = 0; // Contador de números primos

        do

        {

            //BigInteger privateKey = GeneratePrivateKey();

            BigInteger privateKey = RanPrivateKey();

            bool esPrimo = IsProbablyPrime(privateKey, 20); // 20 iteraciones para mayor precisión

            if (esPrimo)

            {

                Console.WriteLine($"Clave privada generada: {privateKey}  {esPrimo} {esPrimo} {esPrimo} {esPrimo}");

            }

            else

            {

                Console.WriteLine($"Clave privada generada: {privateKey}  {esPrimo}");

            }

            if (esPrimo) primosEncontrados++; // Incrementar contador si es primo

​

            string hexadecimalValue = privateKey.ToString("X");

            hexadecimalValue = TrimStringTo64Characters(hexadecimalValue);

            string hexadecimal = hexadecimalValue.PadLeft(64, '0').ToLower();

            Console.WriteLine($"hexadecimal: {hexadecimal}");

            var y = MathS.Log(2, privateKey);

            Console.WriteLine($"Rango: {y.EvalNumerical()}");

            var x = MathS.Pow(2, y);

            Console.WriteLine($"PrivateKeyDecimal: {x.EvalNumerical()}");

            Console.WriteLine($"--------------------------------------------------------");

            num++;

        } while (num < 1000);

​

        // Imprimir el número de primos encontrados

        Console.WriteLine($"Primos encontrados: {primosEncontrados}");

    }

​

    static BigInteger GeneratePrivateKey()

    {

        byte[] privateKeyBytes = new byte[32];

        using (RandomNumberGenerator rng = RandomNumberGenerator.Create())

        {

            rng.GetBytes(privateKeyBytes);

        }

        // Convertir a BigInteger asegurándose de que es positivo

        BigInteger privateKey = new BigInteger(privateKeyBytes.Concat(new byte[] { 0 }).ToArray());

        return privateKey;

    }

​

    static bool IsProbablyPrime(BigInteger n, int k)

    {

        if (n <= 1) return false;

        if (n == 2 || n == 3) return true;

        if (n % 2 == 0) return false;

​

        BigInteger d = n - 1;

        int s = 0;

​

        while (d % 2 == 0)

        {

            d /= 2;

            s += 1;

        }

​

        Random rng = new Random();

​

        for (int i = 0; i < k; i++)

        {

            BigInteger a = RandomBigInteger(2, n - 2, rng);

            BigInteger x = BigInteger.ModPow(a, d, n);

​

            if (x == 1 || x == n - 1)

                continue;

​

            bool continueOuterLoop = false;

​

            for (int r = 1; r < s; r++)

            {

                x = BigInteger.ModPow(x, 2, n);

​

                if (x == 1)

                    return false;

​

                if (x == n - 1)

                {

                    continueOuterLoop = true;

                    break;

                }

            }

​

            if (!continueOuterLoop)

                return false;

        }

​

        return true;

    }

​

    static BigInteger RandomBigInteger(BigInteger min, BigInteger max, Random rng)

    {

        byte[] bytes = max.ToByteArray();

        BigInteger result;

​

        do

        {

            rng.NextBytes(bytes);

            bytes[bytes.Length - 1] &= 0x7F; // Fuerza signo positivo

            result = new BigInteger(bytes);

        } while (result < min || result > max);

​

        return result;

    }

​

    static string TrimStringTo64Characters(string input)

    {

        // Si la longitud de la cadena es mayor a 64 caracteres, eliminar los caracteres desde el inicio

        if (input.Length > 64)

        {

            // Eliminar los caracteres desde el inicio hasta que la longitud sea de 64 caracteres

            return input.Substring(input.Length - 64);

        }

​

        // Si la longitud de la cadena es 64 o menos, no modificar

        return input;

    }

​

    static BigInteger RanPrivateKey()

    {

        // Generar un número aleatorio criptográficamente seguro

        byte[] randomNumber = new byte[32]; // 32 bytes = 256 bits

        RandomNumberGenerator.Fill(randomNumber);

​

        BigInteger privateKey = new BigInteger(randomNumber.Concat(new byte[] { 0 }).ToArray());

        return privateKey;

    }

}

​