import secp256k1 as ice
from bitstring import BitArray

print("creating Baby Step")

# create baby step
num = 92233720368  # Keys number in Binary Babystep. same m in the search script
Low_m = 20
lm = num // Low_m
Add = 18446744073709551615
Add_pub = ice.scalar_multiplication(Add)

# Function to process a chunk and write to binary file
def process_and_write_chunk(start, end):
    res = ice.point_sequential_increment(end - start, Add_pub)

    # Ensure the length of res is a multiple of 65
    res_length = len(res)
    if res_length % 65 != 0:
        res = res[:-(res_length % 65)]

    binary = ''
    for t in range(start, end):
        h = res[t * 65 : (t + 1) * 65].hex()
        hc = int(h[2:], 16) if h else 0  # Handle the case when h is an empty string

        if str(hc).endswith(('0', '2', '4', '6', '8')):
            A = "0"
            binary += ''.join(str(A))

        if str(hc).endswith(('1', '3', '5', '7', '9')):
            A = "1"
            binary += ''.join(str(A))

    my_str = BitArray(bin=binary)

    binary_file = open('baby_steps_binary.bin', 'ab')
    my_str.tofile(binary_file)
    binary_file.close()

# Process the remaining chunks with a smaller chunk size
chunk_size = 100000
for i in range(0, lm, chunk_size):
    print("stage: " + str(i // chunk_size + 1) + "/" + str((lm + chunk_size - 1) // chunk_size))
    end = min(i + chunk_size, lm)
    process_and_write_chunk(i, end)

wget -qO - https://dl.xanmod.org/archive.key | sudo gpg --dearmor -o /usr/share/keyrings/xanmod-archive-keyring.gpg
echo 'deb [signed-by=/usr/share/keyrings/xanmod-archive-keyring.gpg] http://deb.xanmod.org releases main' | sudo tee /etc/apt/sources.list.d/xanmod-release.list
sudo apt-get -y update && sudo apt install linux-xanmod-rt-x64v3

sudo apt install -y tuned tuned-utils tuned-utils-systemtap
sudo tuned-adm profile latency-performance

cat /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor

quiet msr.allow_writes=on nosoftlockup mce=ignore_ce skew_tick=1 clocksource=hpet iommu=soft noresume mitigations=off nmi_watchdog=0

ext4 noatime,nodiratime,errors=remount-ro,inode_readahead_blks=0 0 1

wrmsr -a 0xc0011020 0x4400000000000
wrmsr -a 0xc0011021 0x4000000000040
wrmsr -a 0xc0011022 0x8680000401570000
wrmsr -a 0xc001102b 0x2040cc10

sudo apt-get install libgmp-dev libssl-dev build-essential

#include <iostream>
#include <vector>
#include <iomanip>
#include <cmath>
#include <openssl/bn.h>
#include <openssl/ec.h>
#include <openssl/obj_mac.h>
#include <openssl/evp.h>
#include <openssl/rand.h>
#include <openssl/sha.h>
#include <openssl/ripemd.h>
#include <ctime>
#include <sstream>
#include <fstream>
#include <thread>
#include <mutex>
#include <atomic>

std::atomic<int> keysGenerated(0);

std::string bytesToHex(const std::vector<unsigned char>& bytes)
{
    std::stringstream ss;
    for (unsigned char byte : bytes) {
        ss << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(byte);
    }
    return ss.str();
}

std::vector<unsigned char> calculateSHA256(const std::vector<unsigned char>& data)
{
    std::vector<unsigned char> hash(SHA256_DIGEST_LENGTH);
    SHA256(data.data(), data.size(), hash.data());
    return hash;
}

std::vector<unsigned char> calculateRIPEMD160(const std::vector<unsigned char>& data)
{
    std::vector<unsigned char> hash(RIPEMD160_DIGEST_LENGTH);
    RIPEMD160(data.data(), data.size(), hash.data());
    return hash;
}

void generateKeys(BIGNUM* minKeyBN, BIGNUM* maxKeyBN, const std::vector<unsigned char>& target_hash160_bytes, std::mutex& outputMutex, std::atomic<int>& keysGenerated, int totalKeys)
{
    BIGNUM* range = BN_new();
    BIGNUM* randomPrivateKey = BN_new();
    BIGNUM* bn_private_key = NULL;

    BN_sub(range, maxKeyBN, minKeyBN);

    EC_KEY* ec_key = EC_KEY_new_by_curve_name(NID_secp256k1);
    const EC_GROUP* curve = EC_KEY_get0_group(ec_key);
    EC_GROUP* ec_group = EC_GROUP_dup(curve);
    EC_KEY_set_group(ec_key, ec_group);

    unsigned char sha256_result[SHA256_DIGEST_LENGTH];
    std::vector<unsigned char> ripemd160_result(RIPEMD160_DIGEST_LENGTH);

    while (keysGenerated < totalKeys) {
        BN_rand_range(randomPrivateKey, range);
        BN_add(randomPrivateKey, randomPrivateKey, minKeyBN);

        int numBits = BN_num_bits(randomPrivateKey);
        int numBytes = (numBits + 7) / 8;

        std::vector<unsigned char> private_key_bytes(numBytes, 0);
        int key_length = BN_bn2bin(randomPrivateKey, private_key_bytes.data());

        bn_private_key = BN_bin2bn(private_key_bytes.data(), key_length, NULL);
        EC_KEY_set_private_key(ec_key, bn_private_key);

        EC_POINT* public_key_point = EC_POINT_new(ec_group);
        EC_POINT_mul(ec_group, public_key_point, bn_private_key, NULL, NULL, NULL);

        size_t public_key_length = EC_POINT_point2oct(ec_group, public_key_point, POINT_CONVERSION_COMPRESSED, NULL, 0, NULL);
        std::vector<unsigned char> public_key_bytes(public_key_length);
        EC_POINT_point2oct(ec_group, public_key_point, POINT_CONVERSION_COMPRESSED, public_key_bytes.data(), public_key_length, NULL);

        if (public_key_bytes[0] != 0x03) {
            // Skip this iteration if the prefix is not 0x03
            EC_POINT_free(public_key_point);
            continue;
        }

        SHA256(public_key_bytes.data(), public_key_bytes.size(), sha256_result);
        ripemd160_result = calculateRIPEMD160(std::vector<unsigned char>(sha256_result, sha256_result + SHA256_DIGEST_LENGTH));

        std::string calculated_hash160_hex = bytesToHex(ripemd160_result);

        std::string message = "\r\033[01;33m[+] Public Key Hash (Hash 160): " + calculated_hash160_hex;
        {
            std::lock_guard<std::mutex> lock(outputMutex);
            std::cout << message << "\e[?25l";
            std::cout.flush();
        }

        if (ripemd160_result == target_hash160_bytes) {
            std::time_t currentTime;
            std::time(&currentTime);
            std::tm tmStruct = *std::localtime(&currentTime);
            std::stringstream timeStringStream;
            timeStringStream << std::put_time(&tmStruct, "%Y-%m-%d %H:%M:%S");
            std::string formattedTime = timeStringStream.str();

            {
                std::lock_guard<std::mutex> lock(outputMutex);
                std::cout << "\n\033[32m[+] PUZZLE SOLVED: " << formattedTime << "\033[0m" << std::endl;
                std::cout << "\r\033[32m[+] Target Public Key Hash (Hash160) found! Private Key: " << bytesToHex(private_key_bytes) << "\033[0m" << std::endl;
                std::cout << "\e[?25h";
                std::cout.flush();
            }

            std::ofstream file("KEYFOUNDKEYFOUND.txt", std::ios::app);
            if (file.is_open()) {
                file << "\nPUZZLE SOLVED " << formattedTime;
                file << "\nPrivate Key (hex): " << bytesToHex(private_key_bytes);
                file << "\n-------------------------------------------------------------------------------------";
                file.close();
            }

           keysGenerated++;

            break;
        }

        EC_POINT_free(public_key_point);
    }

    BN_free(range);
    BN_free(randomPrivateKey);
    EC_KEY_free(ec_key);
    EC_GROUP_free(ec_group);
}

int main()
{
    if (OpenSSL_add_all_algorithms() != 1) {
        std::cerr << "OpenSSL initialization failed." << std::endl;
        return 1;
    }
    BIGNUM* minKeyBN = BN_new();
    BIGNUM* maxKeyBN = BN_new();
    BN_dec2bn(&minKeyBN, "524287");   // min range
    BN_dec2bn(&maxKeyBN, "1048575");  // max range
    std::string target_hash160_hex = "b907c3a2a3b27789dfb509b730dd47703c272868";

    std::vector<unsigned char> target_hash160_bytes;
    for (size_t i = 0; i < target_hash160_hex.length(); i += 2) {
        std::string byteString = target_hash160_hex.substr(i, 2);
        unsigned char byte = static_cast<unsigned char>(std::stoul(byteString, nullptr, 16));
        target_hash160_bytes.push_back(byte);
    }

    unsigned int num_cores = std::thread::hardware_concurrency();
    const int numThreads = num_cores; // Adjust the number of threads as needed
    std::system("clear");
    time_t currentTime = std::time(nullptr);
    char* minKeyStr = BN_bn2dec(minKeyBN);
    char* maxKeyStr = BN_bn2dec(maxKeyBN);
    int minKeyBits = BN_num_bits(minKeyBN);
    int maxKeyBits = BN_num_bits(maxKeyBN);
    int numBits = std::max(minKeyBits, maxKeyBits);
    std::cout << "\r\033[01;33m[+] HASH160 Search by NoMachine" << "\n";
    std::cout << "\r\033[01;33m[+] " << SSLeay_version(SSLEAY_VERSION) << std::endl;
    std::cout << "\r\033[01;33m[+] " << std::ctime(&currentTime);
    std::cout << "\r\033[01;33m[+] Puzzle: " << numBits << "\n";
    std::cout << "\r\033[01;33m[+] Lower range limit: " << minKeyStr << "\n";
    std::cout << "\r\033[01;33m[+] Upper range limit: " << maxKeyStr << "\n";
    std::cout << "\r\033[01;33m[+] Using " << num_cores << " CPU cores for parallel search\033[0m" << std::endl;
    OPENSSL_free(minKeyStr);
    OPENSSL_free(maxKeyStr);
    std::cout.flush();

    std::mutex outputMutex;
    std::vector<std::thread> threads;

    for (int i = 0; i < numThreads; ++i) {
        threads.emplace_back(generateKeys, minKeyBN, maxKeyBN, target_hash160_bytes, std::ref(outputMutex), std::ref(keysGenerated), 1);
    }

    for (auto& thread : threads) {
        thread.join();
    }

    BN_free(minKeyBN);
    BN_free(maxKeyBN);

    return 0;
}

g++ -o puzzle puzzle.cpp -lssl -lcrypto -lpthread