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

000000000000000000000000000000014551231950b75fc4402da1732fc9bebf

8000000000000000000000000000000000000000000000000000000000000000

bool kangarooTwimi(const EC_GROUP* group, const BIGNUM* order, BIGNUM* x, BIGNUM* result) {
    BIGNUM* k = BN_new();
    BIGNUM* k1 = BN_new();
    BIGNUM* k2 = BN_new();
    BIGNUM* x1 = BN_new();
    BIGNUM* x2 = BN_new();

    // Set k to a random value
    BN_rand_range(k, order);

    EC_POINT* G = EC_POINT_new(group);
    EC_POINT* kG = EC_POINT_new(group);
    EC_POINT* xG = EC_POINT_new(group); // Create an EC_POINT for x

    EC_POINT_mul(group, G, k, NULL, NULL, NULL); // G = k * G

    while (true) {
        EC_POINT_mul(group, kG, NULL, G, k, NULL); // kG = k * G

        // Use EC_POINT_mul to compute xG = x * G
        EC_POINT_mul(group, xG, NULL, NULL, x, NULL);

        // Extract affine coordinates
        EC_POINT_get_affine_coordinates_GFp(group, kG, k1, NULL, NULL);
        EC_POINT_get_affine_coordinates_GFp(group, xG, x1, NULL, NULL);

        if (BN_cmp(k1, x1) == 0) {
            BN_copy(result, k);
            BN_free(k);
            BN_free(k1);
            BN_free(k2);
            BN_free(x1);
            BN_free(x2);
            EC_POINT_free(G);
            EC_POINT_free(kG);
            EC_POINT_free(xG);
            return true;
        }

        BN_add(k, k, BN_value_one());
    }
}

x=2000000000000000
t=1185429467683753

A0=x-t
>>814570532316247

A1=t/5
>>237085893536750.6
A2=A0/5
>>162914106463249.4

A3=t-A1
>>948343574147002.4
A4= A0-A2
>>651656425852997.6


A5=A4-A1
>>785429467683753

A6=A3-A2
>>414570532316247

#---------------------------

t=A5
>>785429467683753
A0=A6
>>414570532316247

A1=t/5
>>157085893536750.6
A2=A0/5
>>82914106463249.4

A3=t-A1
>>628343574147002.4
A4= A0-A2
>>331656425852997.6


A5=A3-A2
>>545429467683753

A6=A4-A1
>>414570532316247

import sys
import os
import time
import secrets
import random
import binascii
import base58
import hashlib
import ecdsa
import multiprocessing
from multiprocessing import cpu_count

def generate_private_key_WIF(start, miss):
    return start + "".join(
        secrets.choice(
            "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
        ) 
        for _ in range(miss)
    ) 

def check_private_key(start, miss, target_binary): 
    while not STOP_EVENT.is_set():  
        private_key_WIF_str = generate_private_key_WIF(start, miss)
        if start[0] == '5':
            private_key_WIF = private_key_WIF_str
            first_encode = base58.b58decode(private_key_WIF)
            private_key_full = binascii.hexlify(first_encode)
            private_key = private_key_full[2:-8]
        if start[0] in ['L', 'K']:
            private_key_WIF = private_key_WIF_str
            first_encode = base58.b58decode(private_key_WIF)
            private_key_full = binascii.hexlify(first_encode)
            private_key = private_key_full[2:-10]
        private_key_hex = private_key.decode("utf-8")
        dec = int(private_key_hex[0:64], 16)
        dec_bytes = dec.to_bytes((dec.bit_length() + 7) // 8, 'big')
        private_key_bytes = b'\x00' * 32
        private_key_bytes = private_key_bytes[:-len(dec_bytes)] + dec_bytes
        signing_key = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)
        compressed_public_key = signing_key.get_verifying_key().to_string("compressed")
        sha256_hash = hashlib.sha256(compressed_public_key).digest()
        ripemd160_hash = hashlib.new('ripemd160', sha256_hash).digest()
        extended_private_key = b'\x80' + private_key_bytes + b'\x01'
        checksum = hashlib.sha256(hashlib.sha256(extended_private_key).digest()).digest()[:4]
        private_key_with_checksum = extended_private_key + checksum
        wif_compressed = base58.b58encode(private_key_with_checksum).decode()
        message = "\r[+] {} ".format(private_key_WIF_str) 
        messages = []
        messages.append(message)
        output = "\033[01;33m" + ''.join(messages) + "\r"
        sys.stdout.write(output)
        sys.stdout.flush()
        if ripemd160_hash == target_binary:
            t = time.ctime()
            sys.stdout.write(f"\n\033[01;33m[+] BINGO!!! {t}\n")   
            with open('winner.txt', 'a') as file:
                t = time.ctime()
                file.write('\n\nMatch Found: ' + t)
                file.write('\nPrivatekey (dec): ' + str(dec))
                file.write('\nPrivatekey (hex): ' + hex(dec)[2:])
                file.write('\nPrivatekey (wif): ' + wif_compressed)
                
            STOP_EVENT.set()  
            return  

if __name__ == '__main__':
    start = "KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qZM21gaY8W"
    miss = 52 - (len(start)) 
    # Define the target as bytes
    target_hex = "52e763a7ddc1aa4fa811578c491c1bc7fd570137"
    target_binary = bytes.fromhex(target_hex)
    os.system("clear")
    t = time.ctime()
    sys.stdout.write(f"\033[01;33m[+] {t}\n")
    sys.stdout.write(f"\033[01;33m[+] Ending characters missing: {miss}\n")
    sys.stdout.write(f"\033[01;33m[+] Public Key Hash (Hash 160): {target_hex}\n")
    sys.stdout.flush()

    # Create a global STOP_EVENT
    STOP_EVENT = multiprocessing.Event()

    # Create a pool of worker processes
    num_processes = multiprocessing.cpu_count()
    pool = multiprocessing.Pool(processes=num_processes)

    # Start the worker processes with different starting points
    for i in range(num_processes):
        pool.apply_async(check_private_key, args=(start, miss, target_binary))

    # Close the pool and wait for all processes to complete
    pool.close()
    pool.join()

var walletKey = new NBitcoin.Key();

var bytes = new BigInteger(2683).ToByteArray();
Array.Resize(ref bytes, 32);
Array.Reverse(bytes);

new Key(bytes)
    .GetAddress(ScriptPubKeyType.Legacy, Network.Main)
    .ToString();

0000000000000000000000000000000000000000000000000000000000000a7b
1DBaumZxUkM4qMQRt2LVWyFJq5kDtSZQot

var hex = "0000000000000000000000000000000000000000000000000000000000000a7b";
var privateKey = new ExtKey(hex);

// these all give me: "1JThwYZMjCqbpi3QPNAToGdbSLWoUdhdJi"

privateKey.GetPublicKey()
          .GetAddress(ScriptPubKeyType.Legacy, Network.Main)
          .ToString();

privateKey.PrivateKey
          .GetAddress(ScriptPubKeyType.Legacy, Network.Main)
          .ToString();

privateKey.PrivateKey
          .PubKey
          .GetAddress(ScriptPubKeyType.Legacy, Network.Main)
          .ToString();

privateKey.PrivateKey
          .GetScriptPubKey(ScriptPubKeyType.Legacy)
          .GetDestinationAddress(Network.Main)
          .ToString();

privateKey.PrivateKey
          .GetWif(Network.Main)
          .GetAddress(ScriptPubKeyType.Legacy)
          .ToString();