Topic: Bitcoin puzzle transaction ~32 BTC prize to who solves it - page 114. (Read 215611 times)

import time, random, sys, os, secp256k1 as ice
puzzle = 65
target = 30568377312064202855
lower_range_limit = 2 ** (puzzle - 1);upper_range_limit = (2 ** puzzle) - 1

while True:
    constant_prefix = b'\xc9\xd9\x1d\xbc\x16\x9d'
    prefix_length = len(constant_prefix);length = 8
    ending_length = length - prefix_length;ending_bytes = os.urandom(ending_length)
    random_bytes = constant_prefix + ending_bytes
    random.seed(random_bytes)
    dec = random.randint(lower_range_limit, upper_range_limit)
    if str(dec).startswith("30568377"):
        message = "\r[+] {} , {}".format(dec, random_bytes);messages = []
        messages.append(message);output = "\033[01;33m" + ''.join(messages) + "\r"
        sys.stdout.write(output);sys.stdout.flush()
        if dec == target:
            caddr = ice.privatekey_to_address(0, True, dec)
            HEX = "%064x" % dec;wifc = ice.btc_pvk_to_wif(HEX);t = time.ctime()
            print(f'[+] SOLVED:  {t}');print(f'[+] Bitcoin address Compressed: {caddr}')
            print(f'[+] Private key (wif) Compressed: {wifc}');print(f'[+] Random Seed: {random_bytes}')
            break

import random, os, secp256k1 as ice
puzzle = 30
#target = "1LHtnpd8nU5VHEMkG2TMYYNUjjLc992bps"
target = "d39c4704664e1deb76c9331e637564c257d68a08"
lower_range_limit = 2 ** (puzzle - 1);upper_range_limit = (2 ** puzzle) - 1
for x in range(1000000):
 constant_prefix = b'yx\xcb\x08\xb70'
 prefix_length = len(constant_prefix);length = 8
 ending_length = length - prefix_length;ending_bytes = os.urandom(ending_length)
 random_bytes = constant_prefix + ending_bytes
 random.seed(random_bytes)
 dec = random.randint(lower_range_limit, upper_range_limit)
 caddr = ice.privatekey_to_h160(0, True, dec).hex()
 if caddr == target:
  print(caddr,dec)

import time, random, sys, os, secp256k1 as ice
puzzle = 30
target = "1LHtnpd8nU5VHEMkG2TMYYNUjjLc992bps"
lower_range_limit = 2 ** (puzzle - 1);upper_range_limit = (2 ** puzzle) - 1
if os.name=='nt':os.system('cls')
else:os.system('clear')
t = time.ctime();sys.stdout.write(f"\033[?25l");sys.stdout.write(f"\033[01;33m[+] STARTED: {t}\n")
sys.stdout.write(f"[+] Puzzle: {puzzle}\n")
sys.stdout.write(f"[+] Lower range limit: {lower_range_limit}\n")
sys.stdout.write(f"[+] Upper range limit: {upper_range_limit}\n")
while True:
    constant_prefix = b'yx\xcb\x08\xb70'
    prefix_length = len(constant_prefix);length = 8
    ending_length = length - prefix_length;ending_bytes = os.urandom(ending_length)
    random_bytes = constant_prefix + ending_bytes
    random.seed(random_bytes)
    dec = random.randint(lower_range_limit, upper_range_limit)
    caddr = ice.privatekey_to_address(0, True, dec)
    message = "\r[+] {}".format(dec);messages = []
    messages.append(message);output = "\033[01;33m" + ''.join(messages) + "\r"
    sys.stdout.write(output);sys.stdout.flush()
    if caddr == target:
        HEX = "%064x" % dec;wifc = ice.btc_pvk_to_wif(HEX);t = time.ctime()
        print(f'[+] SOLVED:  {t}');print(f'[+] Bitcoin address Compressed: {caddr}')
        print(f'[+] Private key (wif) Compressed: {wifc}');print(f'[+] Random Seed: {random_bytes}')
        break

import bit
import hashlib, random
import platform
from time import time
import os
import sys
import ctypes

nbits = 130
low = 2**(nbits-1)
high = -1+2**nbits
diff = high - low

filename ='tes.bin'
with open(filename,'rb') as f:
    add = f.read()#.split()
#add = set(add)

if platform.system().lower().startswith('win'):
    dllfile = 'ice_secp256k1.dll'
    if os.path.isfile(dllfile) == True:
        pathdll = os.path.realpath(dllfile)
        ice = ctypes.CDLL(pathdll)
    else:
        print('File {} not found'.format(dllfile))

elif platform.system().lower().startswith('lin'):
    dllfile = 'ice_secp256k1.so'
    if os.path.isfile(dllfile) == True:
        pathdll = os.path.realpath(dllfile)
        ice = ctypes.CDLL(pathdll)
    else:
        print('File {} not found'.format(dllfile))
else:
    print('[-] Unsupported Platform currently for ctypes dll method. Only [Windows and Linux] is working')
    sys.exit()

ice.scalar_multiplication.argtypes = [ctypes.c_char_p, ctypes.c_char_p]            # pvk,ret
ice.point_subtraction.argtypes = [ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p]  # x1,y1,x2,y2,ret
ice.init_secp256_lib()

def scalar_multiplication(kk):
    res = (b'\x00') * 65
    pass_int_value = hex(kk)[2:].encode('utf8')
    ice.scalar_multiplication(pass_int_value, res)
    return res

def point_subtraction(pubkey1_bytes, pubkey2_bytes):
    x1 = pubkey1_bytes[1:33]
    y1 = pubkey1_bytes[33:]
    x2 = pubkey2_bytes[1:33]
    y2 = pubkey2_bytes[33:]
    res = (b'\x00') * 65
    ice.point_subtraction(x1, y1, x2, y2, res)
    return res

def new_pos(full_bytes):
    pos = hashlib.sha256(full_bytes).digest()
    return pos

def fixrange(full_bytes):
    t = low + int(full_bytes.hex(), 16) % diff
    return t

def pub2upub(pub_hex):
    x = int(pub_hex[2:66], 16)
    if len(pub_hex) < 70:
        y = bit.format.x_to_y(x, int(pub_hex[:2], 16) % 2)
    else:
        y = int(pub_hex[66:], 16)
    return bytes.fromhex('04' + hex(x)[2:].zfill(64) + hex(y)[2:].zfill(64))

def upub2cpub(upub_bytes):
    x1 = upub_bytes[1:33]
    prefix = str(2 + int(upub_bytes[33:].hex(), 16) % 2).zfill(2)
    return bytes.fromhex(prefix) + x1

st = time()
key_seed = b''
m = 1
while True:
    pubkey = "03633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852"
    P = pub2upub(pubkey)
    key_seed = new_pos(key_seed)
    qfix = fixrange(key_seed)
    #qfix = m * 1000000  # Use an interval of 1000000 for qfix (stride)
    tpub = bytes(bytearray(scalar_multiplication(qfix)))
    subP = bytes(bytearray(point_subtraction(P, tpub)))
    cpub = bytes(upub2cpub(subP))
    m += 1

    msg = 'Test Cpub : {total}, {num}, {password} '.format(total=m, num=qfix, password=bytes(cpub).hex())
    sys.stdout.write('\r' + msg)
    sys.stdout.flush()

    if cpub in add:
        print("Winner Found!:{num}, {password} ".format(num=qfix, password=bytes(cpub).hex()))
        f = open (u"Winner.txt","a")
        f.write("num:" + str(qfix) +'\n' +
                "cpub:" + str(bytes(cpub).hex())+ '\n\n')
        f.close()
        break
print('[-] Completed in {0:.2f} sec'.format(time() - st))

[DEV: NVIDIA GeForce G 1111/4095MB] [00000000000000000000000000000000000000000000000000022004DA800000 (50 bit)
[DEV: NVIDIA GeForce G 1111/4095MB] [000000000000000000000000000000000000000000000000000222B60D800000 (50 bit)
[DEV: NVIDIA GeForce G 1111/4095MB] [0000000000000000000000000000000000000000000000000002256266000000 (50 bit)
[DEV: NVIDIA GeForce G 1111/4095MB] [0000000000000000000000000000000000000000000000000002281873800000 (50 bit)
[DEV: NVIDIA GeForce G 1111/4095MB] [00000000000000000000000000000000000000000000000000022AC9A6800000 (50 bit)
[TARGET: 1] [SPEED: 1632701.66 MKey/s] [TOTAL: 48,937,041,920] [00:05:18]
[2023-11-23.11:08:30] [Info] Found key for address '1MEzite4ReNuWaL5Ds17ePKt2dCxWEofwk'. Written to 'found.txt'

[2023-11-23.11:08:30] [Info] No targets remaining

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

// Function to convert a byte vector to a hexadecimal 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();
}

// Function to calculate the RIPEMD160 hash of a byte vector
std::vector calculateRIPEMD160(const std::vector& data) {
    std::vector hash(RIPEMD160_DIGEST_LENGTH);
    RIPEMD160(data.data(), data.size(), hash.data());
    return hash;
}

int main() {
    // Initialize the OpenSSL library
    if (OpenSSL_add_all_algorithms() != 1) {
        std::cerr << "OpenSSL initialization failed." << std::endl;
        return 1;
    }

    // Set the target Hash160 value (replace with your target hash)
    std::string target_hash160_hex = "20d45a6a762535700ce9e0b216e31994335db8a5";

    int puzzle = 66;   // The puzzle number (Bits)

    // Clear the console
    std::system("clear");
    std::cout << "\r\033[01;33m[+] Bytea HASH160 Search by NoMachine" << "\n";
    time_t currentTime = std::time(nullptr);
    std::cout << "\r\033[01;33m[+] " << std::ctime(¤tTime) << "\r";
    std::cout << "\r\033[01;33m[+] Puzzle: " << puzzle << "\033[0m" << std::endl;
    std::cout.flush();

    // Calculate the maximum bytes value based on the puzzle
    BIGNUM* limit_int = BN_new();
    BN_set_word(limit_int, 1);
    BN_lshift(limit_int, limit_int, puzzle);
    BN_sub_word(limit_int, 1);
    int max_bytes = (BN_num_bits(limit_int) + 7) / 8;

    // Create an EC_KEY object
    EC_KEY* ec_key = EC_KEY_new_by_curve_name(NID_secp256k1);

    // Calculate the SHA-256 hash of the public key
    unsigned char sha256_result[SHA256_DIGEST_LENGTH];

    // Calculate the RIPEMD160 hash of the SHA-256 hash
    std::vector ripemd160_result(RIPEMD160_DIGEST_LENGTH);

    while (true) {
        // Create a 32-byte private key with 32 zeros followed by random bytes
        std::vector private_key_bytes(32, 0);

        // Generate random bytes for the remaining part of the private key
        std::vector random_bytes(max_bytes);
        if (RAND_bytes(random_bytes.data(), random_bytes.size()) != 1) {
            std::cerr << "Error generating random bytes." << std::endl;
            BN_free(limit_int);
            EC_KEY_free(ec_key);
            return 1;
        }

        // Append the random bytes to the private key
        std::copy(random_bytes.begin(), random_bytes.end(), private_key_bytes.begin() + 32 - max_bytes);

        // Create a BIGNUM from the private key bytes
        BIGNUM* bn_private_key = BN_bin2bn(private_key_bytes.data(), private_key_bytes.size(), NULL);

        // Set the private key in the EC_KEY object
        EC_KEY_set_private_key(ec_key, bn_private_key);

        // Compute the public key from the private key
        EC_POINT* public_key_point = EC_POINT_new(EC_KEY_get0_group(ec_key));
        EC_POINT_mul(EC_KEY_get0_group(ec_key), public_key_point, bn_private_key, NULL, NULL, NULL);

        // Convert the public key point to binary representation (compressed)
        size_t public_key_length = EC_POINT_point2oct(EC_KEY_get0_group(ec_key), public_key_point, POINT_CONVERSION_COMPRESSED, NULL, 0, NULL);
        std::vector public_key_bytes(public_key_length);
        EC_POINT_point2oct(EC_KEY_get0_group(ec_key), public_key_point, POINT_CONVERSION_COMPRESSED, public_key_bytes.data(), public_key_length, NULL);

        // Check if the public key starts with "02" (compressed format)
        if (public_key_bytes[0] == 0x02) {
            SHA256(public_key_bytes.data(), public_key_bytes.size(), sha256_result);
            ripemd160_result = calculateRIPEMD160(std::vector(sha256_result, sha256_result + SHA256_DIGEST_LENGTH));

            // Convert the calculated RIPEMD160 hash to a hexadecimal string
            std::string calculated_hash160_hex = bytesToHex(ripemd160_result);

            // Display the generated public key hash (Hash160) and private key
            std::string message = "\r\033[01;33m[+] Public Key Hash (Hash 160): " + calculated_hash160_hex;
            std::cout << message << "\e[?25l";
            std::cout.flush();

            // Check if the generated public key hash matches the target
            if (calculated_hash160_hex == target_hash160_hex) {
                // Get the current time
                std::time_t currentTime;
                std::time(¤tTime);
                std::tm tmStruct = *std::localtime(¤tTime);

                // Format the current time into a human-readable string
                std::stringstream timeStringStream;
                timeStringStream << std::put_time(&tmStruct, "%Y-%m-%d %H:%M:%S");
                std::string formattedTime = timeStringStream.str();

                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;

                // Append the private key information to a file if it matches
                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;
            }
        }
    }

    // Free the EC_KEY and BIGNUM objects
    BN_free(limit_int);
    EC_KEY_free(ec_key);

    return 0;
}

# Makefile

# Source files
SRC = puzzle66.cpp

# Compiler and flags
CXX = g++
CXXFLAGS = -m64 -march=native -mtune=native  -mfpmath=sse -Wall -msse2 -msse3 -msse4 -msse4.1 -msse4.2 -msse4a -mavx -pthread -O3 -I.

# OpenSSL libraries
LIBS = -lssl -lcrypto

# Output executable
TARGET = puzzle66

# Default target
all: $(TARGET)

# Rule for compiling the source code
$(TARGET): $(SRC)
$(CXX) $(CXXFLAGS) -o $@ $^ $(LIBS)

# Clean target to remove generated files
clean:
rm -f $(TARGET)

.PHONY: all clean