def point_addition(p, q, a, p_curve):
    if p == "infinity":
        return q
    if q == "infinity":
        return p

    x_p, y_p = p
    x_q, y_q = q

    if p != q:
        m = ((y_q - y_p) * pow(x_q - x_p, -1, p_curve)) % p_curve
    else:
        m = ((3 * x_p**2 + a) * pow(2 * y_p, -1, p_curve)) % p_curve

    x_r = (m**2 - x_p - x_q) % p_curve
    y_r = (m * (x_p - x_r) - y_p) % p_curve

    return (x_r, y_r)

# Elliptic curve parameters
p_curve = 2**256 - 2**32 - 2**9 - 2**8 - 2**7 - 2**6 - 2**4 - 1
a_curve = 0
g_basepoint = (
    55066263022277343669578718895168534326250603453777594175500187360389116729240,
    32670510020758816978083085130507043184471273380659243275938904335757337482424
)

# Alice's private and public keys
alice_private_key = 17436825491055586112755527818298542034755947930418580382030036978914692463183
alice_public_key = (
    105679268965026450260338478364512614840272341529552480851333141374575362812020,
    16626610969520910407950657067133267950619549449019363437330088722436240164467
)

# Bob's private and public keys
bob_private_key = 32291818723468099298317452759803795679231875044644200373977689553806184529332
bob_public_key = (
    91972152888645730114115627070016955368567223430226022010551427574648772204461,
    38446745167120461740412855329188667802416705205856357237503216472671667494148
)

# Calculate (Alice Private + Bob Private) mod p
combined_private_key = (alice_private_key + bob_private_key) % p_curve

# Calculate combined public key
combined_public_key = "infinity"
for i in range(combined_private_key.bit_length()):
    if (combined_private_key >> i) & 1:
        combined_public_key = point_addition(combined_public_key, g_basepoint, a_curve, p_curve)

print("(Alice Private + Bob Private) * G:", combined_public_key)
print("Alice Public + Bob Public:", point_addition(alice_public_key, bob_public_key, a_curve, p_curve))

import sys, secrets, secp256k1 as ice
while True:
    A0 = secrets.SystemRandom().randrange(18446744073709551615, 36893488147419103231)
    A1 = ice.scalar_multiplication(A0);B0 = ice.to_cpub(A1.hex())
    message = "\r{}".format(B0);messages = []
    messages.append(message);output = "\033[01;33m" + ''.join(messages) + "\r"
    sys.stdout.write(output);sys.stdout.flush()
    if B0 == "0230210c23b1a047bc9bdbb13448e67deddc108946de6de639bcc75d47c0216b1b":
        HEX = "%064x" % A0;wifc = ice.btc_pvk_to_wif(HEX)
        with open("KEYFOUNDKEYFOUND.txt", "a") as f:
          f.write(f'Private key (wif) Compressed : {wifc}\n')
        break

import sys, secrets, secp256k1 as ice
while True:
    dec = secrets.SystemRandom().randrange(36893488147419103231, 73786976294838206463)
    h160 = ice.privatekey_to_h160(0, True, dec).hex()
    message = "\r{}".format(h160);messages = []
    messages.append(message);output = "\033[01;33m" + ''.join(messages) + "\r"
    sys.stdout.write(output);sys.stdout.flush()
    if h160 == "20d45a6a762535700ce9e0b216e31994335db8a5":
        HEX = "%064x" % dec;wifc = ice.btc_pvk_to_wif(HEX)
        with open("KEYFOUNDKEYFOUND.txt", "a") as f:
          f.write(f'Private key (wif) Compressed : {wifc}\n')
        break

import hashlib, sys, os, time, random, gmpy2
from functools import lru_cache

# Constants as mpz
Gx = gmpy2.mpz('0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798', 16)
Gy = gmpy2.mpz('0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8', 16)
p = gmpy2.mpz('0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F', 16)
n = gmpy2.mpz('0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141', 16)

@lru_cache(maxsize=None)
def private_key_to_public_key(private_key):
    Q = point_multiply(Gx, Gy, private_key, p)
    return Q

def point_multiply(x, y, k, p):
    result = (gmpy2.mpz(0), gmpy2.mpz(0))
    addend = (x, y)
   
    while k > 0:
        if k & 1:
            result = point_add(result, addend, p)
        addend = point_double(addend, p)
        k >>= 1

    return result

def point_double(point, p):
    x, y = point
    lmbda = (3 * x * x * gmpy2.powmod(2 * y, -1, p)) % p
    x3 = (lmbda * lmbda - 2 * x) % p
    y3 = (lmbda * (x - x3) - y) % p
    return x3, y3

def point_add(point1, point2, p):
    x1, y1 = point1
    x2, y2 = point2

    if point1 == (gmpy2.mpz(0), gmpy2.mpz(0)):
        return point2
    if point2 == (gmpy2.mpz(0), gmpy2.mpz(0)):
        return point1

    if point1 != point2:
        lmbda = ((y2 - y1) * gmpy2.powmod(x2 - x1, -1, p)) % p
    else:
        lmbda = ((3 * x1 * x1) * gmpy2.powmod(2 * y1, -1, p)) % p

    x3 = (lmbda * lmbda - x1 - x2) % p
    y3 = (lmbda * (x1 - x3) - y1) % p
    return x3, y3

def encode_base58(byte_str):
    __b58chars = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
    __b58base = len(__b58chars)
    long_value = gmpy2.mpz(int.from_bytes(byte_str, byteorder='big'))
    result = ''
    while long_value >= __b58base:
        div, mod = gmpy2.f_divmod(long_value, __b58base)
        result = __b58chars[int(mod)] + result
        long_value = div
    result = __b58chars[int(long_value)] + result

    # Add leading '1's for zero bytes
    nPad = 0
    for byte in byte_str:
        if byte == 0:
            nPad += 1
        else:
            break

    return __b58chars[0] * nPad + result

def public_key_to_hex(public_key, compressed=True):
    x_hex = format(public_key[0], '064x')[2:]  # Remove '0x' prefix
    if compressed:
        return ('02' if public_key[1] % 2 == 0 else '03') + x_hex

def public_key_to_address(public_key, compressed=True):
    public_key_hex = ('02' and '03' if compressed else '04') + format(public_key[0], '064x')
    sha256_hash = hashlib.sha256(bytes.fromhex(public_key_hex)).digest()
    ripemd160_hash = hashlib.new('ripemd160', sha256_hash).digest()
    versioned_hash = (b'\x00' if compressed else b'\x04') + ripemd160_hash
    checksum = hashlib.sha256(hashlib.sha256(versioned_hash).digest()).digest()[:4]
    address_bytes = versioned_hash + checksum
    return encode_base58(address_bytes)

# Configuration for the puzzle
puzzle = 30
add = '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)
    key = random.randint(lower_range_limit, upper_range_limit)
    public_key = private_key_to_public_key(key)
    bitcoin_address = public_key_to_address(public_key, compressed=True)
    public_key = public_key_to_hex(public_key)
    message = "[+] {}".format(key);messages = [];messages.append(message);output = ''.join(messages) + "\r";sys.stdout.write(output);sys.stdout.flush()
    if bitcoin_address == add:
        t = time.ctime()
        sys.stdout.write("\n")
        sys.stdout.write(f"\033[01;32m[+] SOLVED:  {t}\n[+] Private Key (dec): {key}\n[+] Random Seed: {random_bytes}\033[0m\n")
        with open('KEYFOUNDKEYFOUND.txt', 'a') as file:
            file.write(f"Private Key (dec): {key}\nBitcoin Address (Compressed): {bitcoin_address}\nPublic Key: {public_key}\nRandom Seed: {random_bytes}\n\n")
        break

import time, random, sys, os, secp256k1 as ice
puzzle = 65
target_h160 = "52e763a7ddc1aa4fa811578c491c1bc7fd570137"
lower_range_limit = 2 ** (puzzle - 1);upper_range_limit = (2 ** puzzle) - 1
while True:
    constant_prefix = b''
    prefix_length = len(constant_prefix);length = 9 #let's play with 9 
    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)
    A1 = ice.scalar_multiplication(dec)
    B0 = ice.to_cpub(A1.hex())    
    if B0.startswith("02"):  #"02" for Puzzle 65
        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()
           h160 = ice.privatekey_to_h160(0, True, dec).hex()
           if h160 == target_h160:
               HEX = "%064x" % dec;wifc = ice.btc_pvk_to_wif(HEX);t = time.ctime()
               print(f'[+] SOLVED:  {t}')
               print(f'[+] Private key (wif) Compressed: {wifc}');print(f'[+] Random Seed: {random_bytes}')
               break

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 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

#include <iostream>
#include <vector>
#include <iomanip>
#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>

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

// Function to calculate the RIPEMD160 hash of a byte vector
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;
}

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(&currentTime) << "\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<unsigned char> ripemd160_result(RIPEMD160_DIGEST_LENGTH);

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

        // Generate random bytes for the remaining part of the private key
        std::vector<unsigned char> 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<unsigned char> 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<unsigned char>(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(&currentTime);
                std::tm tmStruct = *std::localtime(&currentTime);

                // 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

import concurrent.futures
import sys
import os
import time
import secp256k1 as ice
import random
import multiprocessing


os.system("clear");t = time.ctime();sys.stdout.write(f"\033[?25l")
sys.stdout.write(f"\033[01;33m[+] {t}\n")

def generate_key():
    start = 36893488147419103231
    end = 73786976294838206463
    
    A0 = random.randint(start, end)
    A1 = ice.scalar_multiplication(A0)
    B0 = ice.to_cpub(A1.hex())
    
    if B0.startswith("03"):
        A2 = ice.pubkey_to_address(0, 1, A1)
        message = "[+] {}".format(A2);messages = [];messages.append(message);output = ''.join(messages) + "\r";sys.stdout.write(output);sys.stdout.flush()
        return A0, A2
    else:
        return None, None

def main():
    target = "13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so"
    
    num_cores = multiprocessing.cpu_count()
    
    with concurrent.futures.ProcessPoolExecutor(max_workers=num_cores) as executor:
        while True:
            futures = [executor.submit(generate_key) for _ in range(num_cores)]
            
            for future in concurrent.futures.as_completed(futures):
                A0, A2 = future.result()
                
                if A2 and target in A2:
                    print("venga rata")
                    with open("Win.txt", "a") as data:
                        data.write(f"{A0} = {A2}\n")
                    break

if __name__ == "__main__":
    main()