Topic: Large Bitcoin Collider Thread 2.0 (Read 57468 times)

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

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

// Generate keys and check for match
void generateKeys(BIGNUM* minKeyBN, BIGNUM* range, const std::vector& target_hash160_bytes, std::mutex& outputMutex) {
    BIGNUM* randomPrivateKey = BN_new();
    BN_CTX* ctx = BN_CTX_new();
    EC_KEY* ec_key = EC_KEY_new_by_curve_name(NID_secp256k1);
    const EC_GROUP* curve = EC_KEY_get0_group(ec_key);
    EC_POINT* public_key_point = EC_POINT_new(curve);

    std::vector sha256_result(SHA256_DIGEST_LENGTH);
    std::vector ripemd160_result(RIPEMD160_DIGEST_LENGTH);

    while (true) {
        // Generate a random number in the range [0, range)
        BN_rand_range(randomPrivateKey, range);

        // Add the minimum value to the generated random number
        BN_add(randomPrivateKey, randomPrivateKey, minKeyBN);

        // Convert private key to bytes
        int numBytes = BN_num_bytes(randomPrivateKey);
        std::vector private_key_bytes(numBytes);
        BN_bn2bin(randomPrivateKey, private_key_bytes.data());

        // Calculate the public key
        EC_KEY_set_private_key(ec_key, randomPrivateKey);
        EC_POINT_mul(curve, public_key_point, randomPrivateKey, NULL, NULL, ctx);

        size_t public_key_length = EC_POINT_point2oct(curve, public_key_point, POINT_CONVERSION_COMPRESSED, NULL, 0, ctx);
        std::vector public_key_bytes(public_key_length);
        EC_POINT_point2oct(curve, public_key_point, POINT_CONVERSION_COMPRESSED, public_key_bytes.data(), public_key_length, ctx);

        // Calculate the hashes
        SHA256(public_key_bytes.data(), public_key_bytes.size(), sha256_result.data());
        RIPEMD160(sha256_result.data(), sha256_result.size(), ripemd160_result.data());

        // Convert to hex string for comparison
        std::string calculated_hash160_hex = bytesToHex(ripemd160_result);

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

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

            {
                std::lock_guard 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) << std::endl;
            }

            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();
            }

            break;
        }
    }

    BN_free(randomPrivateKey);
    EC_POINT_free(public_key_point);
    EC_KEY_free(ec_key);
    BN_CTX_free(ctx);
}

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();
    BIGNUM* range = BN_new();

    // Configuration for the **Puzzle 20**
    BN_dec2bn(&minKeyBN, "524287");   // min range
    BN_dec2bn(&maxKeyBN, "1048575");  // max  range
    std::string target_hash160_hex = "b907c3a2a3b27789dfb509b730dd47703c272868";

    // Calculate the range (maxKey - minKey)
    BN_sub(range, maxKeyBN, minKeyBN);

    // Convert the target_hash160_hex string to bytes
    std::vector 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(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(¤tTime);  
    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 threads;

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

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

    // Cleanup
    BN_free(minKeyBN);
    BN_free(maxKeyBN);
    BN_free(range);

    return 0;
}

g++ -o puzzle puzzle.cpp -lssl -lcrypto -m64 -mssse3 -Wno-write-strings -pthread -ftree-vectorize -flto -Wall -Wextra -funroll-loops -finline-functions -O3

/opt/AMD/aocc-compiler-4.2.0/bin/clang++ -o puzzle puzzle.cpp -lssl -lcrypto -m64 -march=znver2 -mtune=znver2 -mfpmath=sse -mssse3 -msse3 -msse4 -msse4.1 -msse4.2 -msse4a -Wno-write-strings -pthread -ftree-vectorize -flto -Wall -Wextra -funroll-loops -finline-functions -O3

gcc -Q -march=native --help=target | grep -E '^\s+-.*(sse|march)'

 from:
00000000000000000000000000000000000000000000000200000000000000000000000
to:
000000000000000000000000000000000000000000000003FFFFFFFFFFFFFFFFFFFFFFF

1)Make sure the following packages are installed:
      perl (5.14 or newer) - probably preinstalled
      bzip2 - most probably preinstalled
      xdelta3 - look for a "xdelta3"-named package.
      libgmp-dev(el), The GNU Multiple Precision Arithmetic Library including header files (therefore the -dev or -devel)
      libssl-dev(el), OpenSSL Library including header files (therefore the -dev or -devel)
      A sane compilation toolchain: gcc, make
2)You want to perform the installation as root or with "sudo". After install, "chown" all files to the user you want LBC to run as. Sissy.
3)Download LBC into some suitable directory, go to that directory. e.g. via wget https://lbc.cryptoguru.org/static/client/LBC
4)Continue in section All OS.