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

#include "SECP256k1.h"
#include "Int.h"
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

const int numThreads = 4; // You can adjust this number based on your CPU cores

// Function to generate a random private key using BIGNUM
BIGNUM* generateRandomPrivateKey(const BIGNUM* minKey, const BIGNUM* maxKey) {
    BIGNUM* randomPrivateKey = BN_new();
    BN_rand_range(randomPrivateKey, maxKey);

    // Ensure the generated key is within the desired range
    while (BN_cmp(randomPrivateKey, minKey) < 0) {
        BN_rand_range(randomPrivateKey, maxKey);
    }

    return randomPrivateKey;
}

// Function to convert a BIGNUM to Int
Int bignumToBigInt(const BIGNUM* bignum) {
    char* bignumStr = BN_bn2dec(bignum);
    Int bigInt;
    bigInt.SetBase10(bignumStr);
    OPENSSL_free(bignumStr);
    return bigInt;
}

// Function to generate keys and check for a specific address
void generateKeysAndCheckForAddress(BIGNUM* minKey, BIGNUM* maxKey, std::shared_ptr secp256k1, const std::string& targetAddress) {
    while (true) {
        BIGNUM* randomPrivateKey = generateRandomPrivateKey(minKey, maxKey);

        // Convert the BIGNUM private key to an Int
        Int privateKey = bignumToBigInt(randomPrivateKey);

        // Continue with the rest of the address generation and checking logic
        Point publicKey;
        std::string caddr;
        std::string wifc;

        publicKey = secp256k1->ComputePublicKey(&privateKey);
        caddr = secp256k1->GetAddress(0, true, publicKey);
        wifc = secp256k1->GetPrivAddress(true, privateKey);

        // Display the generated address
        std::string message = "\r\033[01;33m[+] " + caddr;
        std::cout << message << "\e[?25l";
        std::cout.flush();

        // Check if the generated address matches the target address
        if (caddr.find(targetAddress) != std::string::npos) {
            time_t currentTime = std::time(nullptr);

            // Format the current time into a human-readable string
            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::cout << "\n\033[32m[+] PUZZLE SOLVED: " << formattedTime << "\033[0m" << std::endl;
            std::cout << "\033[32m[+] WIF: " << wifc << "\033[0m" << 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 << "\nPublic Address Compressed: " << caddr;
                file << "\nPrivatekey (dec): " << privateKey.GetBase10();
                file << "\nPrivatekey Compressed (wif): " << wifc;
                file << "\n----------------------------------------------------------------------------------------------------------------------------------";
                file.close();
            }

            // Free the BIGNUM and break the loop
            BN_free(randomPrivateKey);
            break;
        }

        // Free the BIGNUM
        BN_free(randomPrivateKey);

        // Convert the max key to an Int
        Int maxInt;
        maxInt.SetBase10(BN_bn2dec(maxKey));

        if (privateKey.IsGreater(&maxInt)) {
            break;
        }
    }
}


int main() {
    // Clear the console
    std::system("clear");

    time_t currentTime = std::time(nullptr);
    std::cout << "\033[01;33m[+] " << std::ctime(¤tTime) << "\r";
    std::cout.flush();

    BIGNUM* minKeyBN = BN_new(); // Initialize minKeyBN
    BIGNUM* maxKeyBN = BN_new(); // Initialize maxKeyBN

    // Configuration for the Puzzle
    // Set minKeyBN and maxKeyBN using the provided base 10 values
    BN_dec2bn(&minKeyBN, "62079069358943824031");
    BN_dec2bn(&maxKeyBN, "67079069358943924031");
    std::string targetAddress = "13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so";

    // Initialize SECP256k1
    std::shared_ptr secp256k1 = std::make_shared();
    secp256k1->Init();

    // Create threads for key generation and checking
    std::vector threads;

    for (int i = 0; i < numThreads; ++i) {
        threads.emplace_back(generateKeysAndCheckForAddress, minKeyBN, maxKeyBN, secp256k1, targetAddress);
    }

    // Wait for all threads to finish
    for (std::thread& thread : threads) {
        thread.join();
    }

    // Cleanup BIGNUM variables
    BN_free(minKeyBN);
    BN_free(maxKeyBN);

    return 0;
}

SRC = Base58.cpp IntGroup.cpp main.cpp Random.cpp Timer.cpp \
      Int.cpp IntMod.cpp Point.cpp SECP256K1.cpp \
      hash/ripemd160.cpp hash/sha256.cpp hash/sha512.cpp \
      hash/ripemd160_sse.cpp hash/sha256_sse.cpp Bech32.cpp

OBJDIR = obj

OBJET = $(addprefix $(OBJDIR)/, \
        Base58.o IntGroup.o main.o Random.o Int.o Timer.o \
        IntMod.o Point.o SECP256K1.o \
        hash/ripemd160.o hash/sha256.o hash/sha512.o \
        hash/ripemd160_sse.o hash/sha256_sse.o Bech32.o)

CXX = g++
CXXFLAGS = -m64 -mssse3 -Wno-write-strings -O2 -I.

LFLAGS = -lpthread -lssl -lcrypto

$(OBJDIR)/%.o : %.cpp
	$(CXX) $(CXXFLAGS) -o $@ -c $<



VanitySearch: $(OBJET)
	@echo Making Lottery...
	$(CXX) $(OBJET) $(LFLAGS) -o LOTTO.bin && chmod +x LOTTO.bin

$(OBJET): | $(OBJDIR) $(OBJDIR)/hash

$(OBJDIR):
	mkdir -p $(OBJDIR)

$(OBJDIR)/hash: $(OBJDIR)
	cd $(OBJDIR) &&	mkdir -p hash

clean:
	@echo Cleaning...
	@rm -f obj/*.o
	@rm -f obj/hash/*.o

from ecdsa import SigningKey, SECP256k1
import sha3
from binascii import unhexlify
import hashlib
from base58 import b58encode
import bech32
from cashaddress import convert
import datetime

def PrivateKeyComputation(p1: int, p2: int, p3: int, base: int, n: int):
    order = (2 ** 6) * 3 * 149 * 631 * p1 * p2 * p3
    prod = p1 * p2 * p3
    g = pow(base, prod, order + 1)
    privateSet = [None] * n

    for i in range(n):
        if i == 0:
            privateSet[0] = hex(g)
        else:
            k = (g * int(privateSet[i - 1], 16)) % (order + 1)
            privateSet[i] = hex(k)

    return privateSet

def CosetPrivateKeyComputation(p1: int, p2: int, p3: int, base: int, n: int):
    print("Coset PrivateKey Computation started at", datetime.datetime.now())
    prod = p1 * p2 * p3
    h = (2 ** 6) * 3 * 149 * 631
    order = h * prod
    g = pow(base, prod, order + 1)
    privateSet = [None] * n * 8

    for i in range(n):
        if i == 0:
            privateSet[0] = hex(g)
        else:
            k = (g * int(privateSet[i - 1], 16)) % (order + 1)
            privateSet[i] = hex(k)

    pows = [h, h*p1, h*p2, h*p3, h*p1*p2, h*p1*p3, h*p2*p3]

    for j in range(len(pows)):
        g = pow(base, pows[j], order + 1)
        for i in range(n):
            value = (g * int(privateSet[i], 16)) % (order + 1)
            privateSet[(j+1)*h+i] = hex(value)
    print("Coset PrivateKey Computation finished at", datetime.datetime.now())
    return privateSet

def CosetKeysFile(n: int, privateSet):
    print("Writing on txt file started at", datetime.datetime.now())
    f = open("secp256k1_keys.txt", "r+")
    f.seek(0)
    f.write('\t\tPrivateKey  \t\t\t\t\t\t\t\t\t\t  PublicKey-x \t\t\t\t\t\t\t\t\t\t   PublicKey-y  \n')

    for i in range(8*n):
        k = int(privateSet[i], 16).to_bytes(32, "big")
        k = SigningKey.from_string(k, curve=SECP256k1)
        K = k.get_verifying_key().to_string()

        f.write(str(i) + ')\t' + privateSet[i] + '\t' + K.hex()[0:64] + '\t' + K.hex()[64:128] + '\n')

    f.truncate()
    f.close()
    print("Writing on txt file finished at", datetime.datetime.now())

def UncompressedPublicKeyComputation(x, y):
    publicKey = '04' + str(x) + str(y)
    return publicKey

def CompressedPublicKeyComputation(x, y):
    if int(y, 16) % 2 == 0:
        publicKey = '02' + str(x)
    else:
        publicKey = '03' + str(x)

    return publicKey

def checksum_computation(string: str) -> hex:
    cs = hashlib.sha256(hashlib.sha256(unhexlify(string)).digest()).hexdigest()
    checksum = cs[:8]
    return checksum

def BitcoinClassicAddressComputation(publicKey):
    public_key_bytes = unhexlify(publicKey)

    sha256 = hashlib.sha256()
    sha256.update(public_key_bytes)
    hash_temp = sha256.digest()

    ripemd160 = hashlib.new('Ripemd160')
    ripemd160.update(hash_temp)
    hash2_temp = ripemd160.hexdigest()

    hash3_temp = '00' + hash2_temp

    checksum = checksum_computation(hash3_temp)

    hash_final = hash3_temp + str(checksum)
    hash_final_bytes = unhexlify(hash_final)
    address = b58encode(hash_final_bytes).decode("utf-8")
    return address

import AddressGeneration

p1 = 107361793816595537
p2 = 174723607534414371449
p3 = 341948486974166000522343609283189
base = 7
h = (2 ** 6) * 3 * 149 * 631


privateSet = AddressGeneration.CosetPrivateKeyComputation(p1, p2, p3, base, h)
PublicSet = AddressGeneration.CosetKeysFile(h, privateSet)

file= open("data-base_line_by_line.txt", "r")
lines = file.readlines()
for index, line in enumerate(lines):
    
    target = str(line.strip())
    print(target)

import itertools
import secp256k1 as ice



with open('file1.txt', 'r') as f1, open('file2.txt', 'r') as f2:
    

    for line1, line2 in zip(f1, f2):
        
        x=  ice.pub2upub(str(line1.strip()))

        x2= ice.pub2upub(str(line2.strip()))

        res = ice.point_subtraction(x, x2).hex()
        
        result= ice.to_cpub(res)

        file3 = open('result.txt', 'a')
        file3.write(result + "\n")
        file3.close()

[ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ]
[                                                           ]
[===========================================================]
[                Changes by Alek76 modify 0.03              ]
[===========================================================]
[          Tips: 1NULY7DhzuNvSDtPkFzNo6oRTZQWBqXNE9         ]
[===========================================================]
[    Options added argv [-start] [-bits] and disable SSE    ]
[===========================================================]
[           Used OpenSSL Random number generator            ]
[===========================================================]
OpenSSL 3.0.2 15 Mar 2022 (Library: OpenSSL 3.0.2 15 Mar 2022)
[===========================================================]
[                OpenSSL add all algorithms                 ]
[===========================================================]
[                OpenSSL Used functions level 4             ]
[                                                           ]
[ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ]
                                                             

[i] RAND_add() Seed with CPU performance counter: 1695456415355946 
Difficulty: 1461501637330902918203684832716283019655932542976
Search: 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so [Compressed]
Start Sat Sep 23 08:06:55 2023
Base Key: Randomly changed every 100000 Mkeys
Number of CPU thread: 0
GPU: GPU #0 Tesla T4 (40x64 cores) Grid(320x128)

[i] RAND_add() Seed with CPU performance counter: 1695456415480157 
Bit 66 GPU Base Key 0: 2DAFFE6ACD76ABC1D
Bit 66 GPU Base Key 1: 27AD93FD5D885B767
Bit 66 GPU Base Key 2: 2D67AE2D1731671C5
Bit 66 GPU Base Key 3: 3C77CC7B5C7587A86
Bit 66 GPU Base Key 4: 277448DA9C423D147
Bit 66 GPU Base Key 5: 2F7EDC7B5C2B09F0F
Bit 66 GPU Base Key 6: 3DABCD2B602D43EA8
Bit 66 GPU Base Key 7: 238936C644C88AB7E
Bit 66 GPU Base Key 8: 3A97B3F0171947B59
Bit 66 GPU Base Key 9: 31B6CDD325D6B3FB7
Bit 66 GPU Base Key 40951: 3211CC54F75B5CD00
Bit 66 GPU Base Key 40952: 2327D47C30738E157
Bit 66 GPU Base Key 40953: 2A66575CC34FA37C6
Bit 66 GPU Base Key 40954: 2981DD1BA18306814
Bit 66 GPU Base Key 40955: 3775C5C27150FEA12
Bit 66 GPU Base Key 40956: 37A37E2863197B3DB
Bit 66 GPU Base Key 40957: 3D78C9919D6B6A072
Bit 66 GPU Base Key 40958: 22100282EE8370965
Bit 66 GPU Base Key 40959: 37E28F54F8EC9B7D2

[i] RAND_add() Seed with CPU performance counter: 1695456416086342 
Bit 66 GPU Base Key 0: 33D16FF3A68C0BA73
Bit 66 GPU Base Key 1: 359F2BA0E89868D5E
Bit 66 GPU Base Key 2: 3DDDCE27056C63AD9
Bit 66 GPU Base Key 3: 2EFF53109E165A31F
Bit 66 GPU Base Key 4: 236DC50A204B42078
Bit 66 GPU Base Key 5: 2F128D7562A4DDC32
Bit 66 GPU Base Key 6: 2743F1524E422DF51
Bit 66 GPU Base Key 7: 284ECC8C4DC852018
Bit 66 GPU Base Key 8: 3932B5EC487EACE6A
Bit 66 GPU Base Key 9: 398E4AEE55E284239
Bit 66 GPU Base Key 40951: 3225C10410AF00667
Bit 66 GPU Base Key 40952: 229E0588B78FCDF88
Bit 66 GPU Base Key 40953: 25DAC65EBE4EF6B6B
Bit 66 GPU Base Key 40954: 2C5621F3B0D87CFB8
Bit 66 GPU Base Key 40955: 229EC31EBF4F800D2
Bit 66 GPU Base Key 40956: 31F29B5822AA4E982
Bit 66 GPU Base Key 40957: 27C891A611B7D7A20
Bit 66 GPU Base Key 40958: 2F1351CB9E5A7812F
Bit 66 GPU Base Key 40959: 22D025D76B453D748
[615.93 Mkey/s][GPU 615.93 Mkey/s][Total 2^36.06][Prob 0.0%][50% in 5.21538e+31y][Found 0]

file1 = open('file1.txt', 'r')
for line in file1.read().splitlines():
    compressed_keys.append(bytes.fromhex(line))
file1.close()

file2 = open('file2.txt', 'r')
for line in file2.read().splitlines():
    compressed_keys.append(bytes.fromhex(line))
file2.close()

# secp256k1 curve parameters
p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
a = 0
b = 7
Gx = 0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
Gy = 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8
n = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141

# Point addition and subtraction functions
def point_add(P, Q):
    if P == Q:
        return point_double(P)
    if P is None:
        return Q
    if Q is None:
        return P
    lam = ((Q[1] - P[1]) * pow(Q[0] - P[0], p-2, p)) % p
    x = (lam * lam - P[0] - Q[0]) % p
    y = (lam * (P[0] - x) - P[1]) % p
    return (x, y)

def point_sub(P, Q):
    if Q is None:
        return P
    # instead of using p - Q[1], use -Q[1] % p to correctly compute y coordinate
    Q_neg = (Q[0], (-Q[1]) % p)
    return point_add(P, Q_neg)

# Point doubling function
def point_double(P):
    if P is None:
        return None
    lam = ((3 * P[0] * P[0] + a) * pow(2 * P[1], p-2, p)) % p
    x = (lam * lam - 2 * P[0]) % p
    y = (lam * (P[0] - x) - P[1]) % p
    return (x, y)

def is_valid_point(point):
    # Check that the point is not the point at infinity
    if point is None:
        return False
    
    x, y = point
    # Check that the coordinates are within the allowed range
    if x < 0 or x >= p or y < 0 or y >= p:
        return False
    
    # Check that the point lies on the curve
    return (y*y - x*x*x - a*x - b) % p == 0

def decompress_point(compressed_key):
    if compressed_key.startswith(b'\x02') or compressed_key.startswith(b'\x03'):
        x = int.from_bytes(compressed_key[1:], byteorder='big')
        y_sq = (x * x * x + a*x + b) % p
        y = pow(y_sq, (p+1)//4, p)
        if (y*y) % p == y_sq:
            return (x, y)
        else:
            return None
    else:
        return None

def compress_point(point):
    x, y = point
    prefix = b'\x02' if y % 2 == 0 else b'\x03'
    return prefix + x.to_bytes(32, byteorder='big')

def point_subtraction(compressed_keys):
    P = None
    for compressed_key in compressed_keys:
        Q = decompress_point(compressed_key)
        
        # Check that the point is valid on the curve
        if not is_valid_point(Q):
            return None
        
        if P is None:
            P = Q
        else:
            P = point_sub(P, Q)
        
        # Check that the resulting point is not the point at infinity
        if P is None:
            return None
    
    if is_valid_point(P):
        return compress_point(P)
    else:
        return None

compressed_keys = []
file1 = open('file1.txt', 'r')
for line in file1:
    compressed_keys.append(bytes.fromhex(line.strip()))
file1.close()

file2 = open('file2.txt', 'r')
for line in file2:
    compressed_keys.append(bytes.fromhex(line.strip()))
file2.close()

result = point_subtraction(compressed_keys)

if result:
    file3 = open('result.txt', 'a')
    file3.write(result.hex() + "\n")
    file3.close()
else:
    print("The subtraction result is not a valid point on the curve.")