Bitcoin Forum
June 20, 2024, 03:05:12 AM *
News: Voting for pizza day contest
 
  Home Help Search Login Register More  
  Show Posts
Pages: [1] 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 »
1  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: June 17, 2024, 03:49:52 PM
Now I know it works, kTimesG found it.

I give you all information necessary, and correct information.. He found it.

You are both on the ignore list. This is obviously Digaran again in multiple copies.
2  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: June 17, 2024, 03:36:11 PM
How long it takes?
Well your range was 60-bit wide so something like 2 seconds from boot to finish. Around 5 MB of RAM usage.

What was the point of this exercise?

I just wanna know if it's is real.. and it is!



It works if you give us the right range and the right BTC address.

Start: 3000000000000000
End: 3fffffffffffffff

This is 62bit range.

Address: 18bHfcm8kGoAhBaQXzzVcG5534mdpWK981  is not in 62bit range.



 python3 puzzle_bot.py
  • Version 0.2.230519 Satoshi Quest, developed by AlbertoBSD
  • Endomorphism enabled
  • Threads : 12
  • Search compress only
  • Quiet thread output
  • K factor 4096
  • Mode BSGS sequential
  • Opening file 62.txt
  • Added 1 points from file
  • Bit Range 62
  • -- from : 0x2000000000000000
  • -- to   : 0x4000000000000000
  • N = 0x100000000000
  • Bloom filter for 17179869184 elements : 58890.60 MB
  • Bloom filter for 536870912 elements : 1840.33 MB
  • Bloom filter for 16777216 elements : 57.51 MB
  • Allocating 256.00 MB for 16777216 bP Points
  • Reading bloom filter from file keyhunt_bsgs_4_17179869184.blm .... Done!
  • Reading bloom filter from file keyhunt_bsgs_6_536870912.blm .... Done!
  • Reading bP Table from file keyhunt_bsgs_2_16777216.tbl .... Done!
  • Reading bloom filter from file keyhunt_bsgs_7_16777216.blm .... Done!

End


It takes about 5 seconds to find out whether it is puzzle correct or not.
Try something else.


327EF00CB359064B  is private key for 19KbdoUvvD3CdTy78VNaLEjhzQfn55P89B

not  18bHfcm8kGoAhBaQXzzVcG5534mdpWK981


?

a <= k <= b

1 <= k - a + 1 <= b - a + 1

(k - a + 1)*G = k*G - a*G + G

It doesn't matter if a or b are anywhere between 1 and 2**256, just their difference.



18bHfcm8kGoAhBaQXzzVcG5534mdpWK981 has an outgoing transaction -0.00491785 BTC•-$322.17
19KbdoUvvD3CdTy78VNaLEjhzQfn55P89B has 0

addresses with 0 BTC are not the subject of discussion here.

3  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: June 17, 2024, 03:07:20 PM
How long it takes?
Well your range was 60-bit wide so something like 2 seconds from boot to finish. Around 5 MB of RAM usage.

What was the point of this exercise?


327EF00CB359064B  is private key for 19KbdoUvvD3CdTy78VNaLEjhzQfn55P89B

not  18bHfcm8kGoAhBaQXzzVcG5534mdpWK981

4  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: June 17, 2024, 02:40:31 PM



Two points:

1 - So it only works to 66bit? And about puzzles 67,68,69 .... ?

2 - kTimesG did it!




My script only works for bit values ranging from 66 to 69. I need a Bitcoin address and a range from 66 to 69 bits. He entered the range manually using the option -r 3000000000000000:3fffffffffffffff, but I don't have that option in my bot.
5  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: June 17, 2024, 07:24:01 AM
......anyone would solve 130 in a week.


This doesn't apply to just anyone. If any of us had around 2000 high-end GPUs, we wouldn't be chatting on this forum; we'd be at a Bitcoin rooftop party in Dubai with davincij15 and mmcrypto.  Grin  
6  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: June 16, 2024, 05:24:01 PM
What's great is that we'll soon have massive distributed computing capacity, so if careful planning and optimizations are in place, those numbers are within reach.

This cannot be done alone at home on a PC in the garage. Let's be realistic: it takes at least 5 BTC to invest in an attempt to get 13 BTC. This is not a puzzle; this is a big money gamble.
7  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: June 15, 2024, 07:59:48 PM
What are the tax implications of this in the US, I am assuming it would be not taxable unless you sell because when you find a privkey you technically now own that wallet so when you send it to another of your wallets that would be considered transferring between wallets you own which according to coinbase is not a taxable event and if you sell I am guessing it would be considered as regular income.

I will go to Malta if i hit #130. All I need is a suitcase with a lock. Grin

I think this puzzle thing has stalled, the creator should release all the remaining public keys if he really wants to test the robustness of bitcoin, here only sha256 and ripemd-160 are being tested at this point

He can give out all public keys from 130 to 160, and nothing will happen.

This clearly illustrates how ridiculous these numbers are.

Let's consider how many Kangaroo hops are needed to hit 130...

Code:
from math import log2, sqrt

# Given puzzle number
puzzle = 130

# Calculate the expected hops
expected_hops = 2.2 * sqrt(2 ** (puzzle - 1))  # 2.2 * sqrt(2^(puzzle-1))
expected_hops_log2 = log2(expected_hops)

# Print the result
print(f"[+] [Expected Hops: 2^{expected_hops_log2:.2f} ({int(expected_hops)})]")

Expected Hops: 2^65.64 (57392798431464251392)

I  would need approximately 95,654,664,052,440,418 hops per second to generate 57,392,798,431,464,251,392 hops
in 10 minutes. There's no SHA-256 and RIPEMD-160 hashing for Kangaroo, just plain point addition as fast as possible.

Gray Alien technology is required. 👽
8  Bitcoin / Development & Technical Discussion / Re: Pollard Rho Kangaroo Algorithm for 256 bits on: June 15, 2024, 12:55:25 PM
not a bad working code! Are you thinking on implementing multi threading? I know this is not comparable with GPU but its not bad at all Smiley Congrats!

Here you go


Code:
import time
import os
import sys
import random
import gmpy2
import multiprocessing
from math import log2, sqrt, log
from multiprocessing import Pool, cpu_count

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

modulo = gmpy2.mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F)
Gx = gmpy2.mpz(0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798)
Gy = gmpy2.mpz(0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8)
PG = (Gx, Gy)

Z = (0, 0)  # zero-point, infinite in real x, y - plane

def add(P, Q, p=modulo):
    Px, Py = P
    Qx, Qy = Q
    if P == Z:
        return Q
    elif Q == Z:
        return P
    elif Px == Qx and (Py != Qy or Py == 0):
        return Z
    elif Px == Qx:
        m = (3 * Px * Px) * gmpy2.invert(2 * Py, p) % p
    else:
        m = (Qy - Py) * gmpy2.invert(Qx - Px, p) % p
    
    x = (m * m - Px - Qx) % p
    y = (m * (Px - x) - Py) % p
    return (x, y)


def mul2(P, p=modulo):
    Px, Py = P
    if P == Z:
        return Z
    m = gmpy2.f_mod(3 * Px * Px * gmpy2.invert(2 * Py, p), p)
    x = gmpy2.f_mod(m * m - 2 * Px, p)
    y = gmpy2.f_mod(m * (Px - x) - Py, p)
    return (x, y)

def mulk(k, P=PG, p=modulo):
    if k == 0:
        return Z
    elif k == 1:
        return P
    elif k % 2 == 0:
        return mulk(k // 2, mul2(P, p), p)
    else:
        return add(P, mulk((k - 1) // 2, mul2(P, p), p), p)

def X2Y(X, y_parity, p=modulo):
    X_cubed = gmpy2.powmod(X, 3, p)
    X_squared = gmpy2.powmod(X, 2, p)
    tmp = gmpy2.f_mod(X_cubed + 7, p)
    Y = gmpy2.powmod(tmp, gmpy2.f_div(gmpy2.add(p, 1), 4), p)
    if y_parity == 1:
        Y = gmpy2.f_mod(-Y, p)
    return Y

def comparator(A, Ak, B, Bk):
    result = set(A).intersection(set(B))
    if result:
        sol_kt = A.index(next(iter(result)))
        sol_kw = B.index(next(iter(result)))
        HEX = "%064x" % abs(Ak[sol_kt] - Bk[sol_kw])
        dec = int(HEX, 16)
        total_time = time.time() - starttime
        print('\n[+] total time: %.2f sec' % (total_time))
        t = time.ctime()
        print(f"\033[32m[+] PUZZLE SOLVED: {t} \033[0m")
        print(f"\033[32m[+] Private key (dec) : {dec} \033[0m")
        dash_line = '-' * 140
        with open("KEYFOUNDKEYFOUND.txt", "a") as file:
            file.write(f"\n{dash_line}")
            file.write("\n\nSOLVED " + t)
            file.write(f"\nTotal Time: {total_time:.2f} sec")
            file.write(f"\nRandom seed: {seed}")
            file.write("\nPrivate Key (decimal): " + str(dec))
            file.write("\nPrivate Key (hex): " + HEX)
            file.write(f"\n{dash_line}")
        file.close()
        return True
    else:
        return False

def check(P, Pindex, DP_rarity, A, Ak, B, Bk):
    modulo_val = P[0] % DP_rarity
    if modulo_val == 0:
        A.append(gmpy2.mpz(P[0]))
        Ak.append(gmpy2.mpz(Pindex))
        return comparator(A, Ak, B, Bk)
    else:
        return False

# Generate a list of powers of two for faster access
def generate_powers_of_two(hop_modulo):
    return [gmpy2.mpz(1 << pw) for pw in range(hop_modulo)]

def search(thread_id, P, W0, DP_rarity, Nw, Nt, hop_modulo, upper_range_limit, lower_range_limit, result_queue, powers_of_two):
    t = [gmpy2.mpz(lower_range_limit + gmpy2.mpz(random.randint(0, upper_range_limit - lower_range_limit))) for _ in range(Nt)]
    T = [mulk(ti) for ti in t]
    dt = [gmpy2.mpz(0) for _ in range(Nt)]
    w = [gmpy2.mpz(random.randint(0, upper_range_limit - lower_range_limit)) for _ in range(Nw)]
    W = [add(W0, mulk(wk)) for wk in w]
    dw = [gmpy2.mpz(0) for _ in range(Nw)]
    Hops, Hops_old = 0, 0
    t0 = time.time()  
    # Memoization dictionary
    memo = {}
    solution_found = False  # Flag to control the loop
    while not solution_found:
        for k in range(Nt):
            Hops += 1
            pw = T[k][0] % hop_modulo
            if pw not in memo:
                memo[pw] = powers_of_two[pw]
            dt[k] = memo[pw]
            if check(T[k], t[k], DP_rarity, T, t, W, w):
                result_queue.put((thread_id, T[k], t[k], W[k], w[k]))
                solution_found = True  # Set flag to exit loop
                break  # Exit the for-loop
            t[k] += dt[k]
            T[k] = add(P[int(pw)], T[k])
        if solution_found:  # Break the while-loop if solution is found
            break
        for k in range(Nw):
            Hops += 1
            pw = W[k][0] % hop_modulo
            if pw not in memo:
                memo[pw] = powers_of_two[pw]
            dw[k] = memo[pw]
            if check(W[k], w[k], DP_rarity, W, w, T, t):
                result_queue.put((thread_id, T[k], t[k], W[k], w[k]))
                solution_found = True  # Set flag to exit loop
                break  # Exit the for-loop
            w[k] += dw[k]
            W[k] = add(P[int(pw)], W[k])
        if solution_found:  # Break the while-loop if solution is found
            break
        t1 = time.time()
        elapsed_time = t1 - starttime
        if t1 - t0 > 1 and thread_id == 0:
            hops_per_second = (Hops - Hops_old) / (t1 - t0) * cores
            hours, rem = divmod(elapsed_time, 3600)
            minutes, seconds = divmod(rem, 60)
            elapsed_time_str = f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}"
            p_2 = f'{log2(Hops*cores):.2f}'
            print(f'[+] [Hops: 2^{p_2} <-> {hops_per_second:.0f} h/s] [{elapsed_time_str}]', end='\r', flush=True)
            t0 = t1
            Hops_old = Hops
    print('\r[+] Hops:', Hops* cores)
    print('[+] Average time to solve: %.2f sec' % ((time.time()-starttime)))

def main():
    result_queue = multiprocessing.Queue()
    processes = [
        multiprocessing.Process(target=search, args=(i, P, W0, DP_rarity, Nw, Nt, hop_modulo, upper_range_limit, lower_range_limit, result_queue, powers_of_two)) for i in range(cores)
    ]
    for p in processes:
        p.start()
    result = result_queue.get()
    for p in processes:
        p.terminate()

# Configuration for the puzzle
cores = cpu_count()
puzzle = 40
compressed_public_key = "03a2efa402fd5268400c77c20e574ba86409ededee7c4020e4b9f0edbee53de0d4"
kangaroo_power = 3  
lower_range_limit = 2 ** (puzzle - 1)
upper_range_limit = (2**puzzle) - 1

DP_rarity = 1 << int(((puzzle -  2*kangaroo_power)/2 - 2))
hop_modulo = ((puzzle - 1) // 2) + kangaroo_power
Nt = Nw = 2**kangaroo_power

# Precompute powers of two for faster access
powers_of_two = generate_powers_of_two(hop_modulo)

T, t, dt = [], [], []
W, w, dw = [], [], []
A, Ak, B, Bk = [], [], [], []
print('[+] [Tame and Wild herds are prepared]')

if len(compressed_public_key) == 66:
    X = gmpy2.mpz(compressed_public_key[2:66], 16)
    Y = X2Y(X, gmpy2.mpz(compressed_public_key[:2]) - 2)
else:
    print("[error] pubkey len(66/130) invalid!")

W0 = (X,Y)
starttime = oldtime = time.time()

Hops = 0

P = [PG]
for k in range(255):
    P.append(mul2(P[k]))  
print('[+] [P-table prepared]')

print(f"[+] [Using {cores} CPU cores for parallel search]")
print(f"[+] [Puzzle: {puzzle}]")
print(f"[+] [Lower range limit: {lower_range_limit}]")
print(f"[+] [Upper range limit: {upper_range_limit}]")
print(f"[+] [Expected Hops: 2^{log2(2.2 * sqrt(1 << (puzzle-1))):.2f} ({int(2.2 * sqrt(1 << (puzzle-1)))})]")

#Random seed Config
seed = os.urandom(9).hex()
print(f"[+] [Random seed: {seed}]")
random.seed(seed)


if __name__ == '__main__':
    main()


  • KANGAROO: Sat Jun 15 21:22:34 2024
  • [Tame and Wild herds are prepared]
  • [P-table prepared]
  • [Using 12 CPU cores for parallel search]
  • [Puzzle: 40]
  • [Lower range limit: 549755813888]
  • [Upper range limit: 1099511627775]
  • [Expected Hops: 2^20.64 (1631201)]
  • [Random seed: 0932dc777428d6f3b9]
  • [Hops: 2^22.21 <-> 2443414 h/s] [00:00:02]
  • total time: 2.18 sec
  • PUZZLE SOLVED: Sat Jun 15 21:22:36 2024
  • Private key (dec) : 1003651412950
  • Hops: 5254560
  • Average time to solve: 2.18 sec



But I won't give you false hope that this script can solve anything above 50 soon. It's simply beyond the reach of python's capabilities.

You have to program in C++ yourself if the current scripts do not meet your needs.
9  Bitcoin / Project Development / Re: Large Bitcoin Collider Thread 2.0 on: June 15, 2024, 07:45:15 AM
1. it is stupid to search for 66 and other lower puzzles, because when you begin to spend them,  guys with kangaroo stuff will steal you key and likely overwrite your transaction.

2. The speed is ridiculous. keyhunt on ryzen7 is searching at speed of 4040394398072471407 keys per second (puzzle 130) no GPU

When evaluating the performance of advanced algorithms such as BSGS (Baby-Step Giant-Step) or the Kangaroo algorithm against straightforward brute force techniques, it's crucial to recognize their fundamentally different operational principles.

Brute force is typically evaluated by the raw number of keys tested per second.

In contrast, advanced algorithms like BSGS and Kangaroo are assessed based on their effective search steps or jumps within the problem space, utilizing mathematical optimizations to minimize operations.

Therefore, direct comparisons based solely on keys tested per second are not appropriate because advanced algorithms employ vastly more efficient search strategies.

Even when comparing the speeds of BSGS vs Kangaroo, such comparisons cannot be straightforward due to variations in implementation details and constraints such as memory usage and characteristics of the search domain.
10  Bitcoin / Project Development / Re: Large Bitcoin Collider Thread 2.0 on: June 15, 2024, 04:12:46 AM
I also did develop my tool, "Colisionador" (collider in spanish), as I do not trust the founds are being sent to the cloud.

I did program it on C, trying to make if super efficient and fast.
I keep the source code closed at the moment, but just ask if you would like to collaborate.
You can run the binaries released it if you want: ...
I can only expressly warn everyone not to download ready-made binaries from unknown sources and run them on their computer.


I especially don't see a reason for it to be closed source because supposedly everything was done in OpenSSL - even a toddler could do it. Because this is the level of these scripts. For beginners. Grin

Here's an example of simple OpenSSL one file code that is incredibly fast:

puzzle.cpp
Code:
#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>
#include <thread>
#include <mutex>

// Convert bytes to hex 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();
}

// Generate keys and check for match
void generateKeys(BIGNUM* minKeyBN, BIGNUM* range, const std::vector<unsigned char>& 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<unsigned char> sha256_result(SHA256_DIGEST_LENGTH);
    std::vector<unsigned char> 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<unsigned char> 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<unsigned char> 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<std::mutex> 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(&currentTime);
            std::tm tmStruct = *std::localtime(&currentTime);
            std::stringstream timeStringStream;
            timeStringStream << std::put_time(&tmStruct, "%Y-%m-%d %H:%M:%S");
            std::string formattedTime = timeStringStream.str();

            {
                std::lock_guard<std::mutex> 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<unsigned char> 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<unsigned char>(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(&currentTime);  
    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<std::thread> 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;
}

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

Or with clang if you have AMD Ryzen :
Code:
/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


You can list the available flags by running the following command:
Code:
gcc -Q -march=native --help=target | grep -E '^\s+-.*(sse|march)'
You can experiment with these flags for cryptographic workloads, achieving a boost of 15-20% depending on the architecture and specific flags.

and then execute with:
./puzzle

  • HASH160 Search by NoMachine
  • OpenSSL 1.1.1w  11 Sep 2023
  • Sat Jun 15 05:54:19 2024
  • Puzzle: 20
  • Lower range limit: 524287
  • Upper range limit: 1048575
  • Using 12 CPU cores for parallel search
  • Public Key Hash (Hash 160): b907c3a2a3b27789dfb509b730dd47703c272868
  • PUZZLE SOLVED: 2024-06-15 05:54:22
  • Target Public Key Hash (Hash160) found! Private Key: 0d2c55
  • Public Key Hash (Hash 160): b907c3a2a3b27789dfb509b730dd47703c272868
  • PUZZLE SOLVED: 2024-06-15 05:54:25
  • Target Public Key Hash (Hash160) found! Private Key: 0d2c55
  • Public Key Hash (Hash 160): b907c3a2a3b27789dfb509b730dd47703c272868


This method can effectively solve puzzles from Puzzle 1 to Puzzle 40 within a reasonable time frame. However, solving beyond that range is impractical using straightforward brute force techniques. This approach is useful for understanding how code is compiled and functions in the context of cryptography and learning.

For puzzles requiring more than 40 bits of complexity, more advanced algorithms like BSGS (Baby-Step Giant-Step) or the Kangaroo algorithm are necessary. Additionally, implementation in C++ or Rust is recommended over Python for these cases.
11  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: June 14, 2024, 05:25:55 PM
If so, why still people discussing about it anyway?

The reasons people continue to engage in these activities are varied. They range from the intellectual challenge and community interaction to potential rewards and pure enjoyment. It’s much like any hobby where the journey and engagement often matter as much as, if not more than, the destination, including for those with mental health issues.

Why they didn't crack public key from puzzle 64?
because it doesn't work and people panic here
the bot won't steal anything from you because when the 66 address is solved in a hundred years, only skeletons will remain of the bots XD

So you claim that RBF does not work?
To experimentally prove that Replace-by-Fee (RBF) works for Bitcoin (BTC) you can follow these steps:

Ensure you have access to a Bitcoin wallet that supports RBF.

Acquire a small amount of Bitcoin for the experiment.

Using the same Bitcoin wallet, create a new transaction with a higher fee that replaces the original one. This involves using the RBF feature to broadcast the same transaction with a higher fee.
12  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: June 14, 2024, 01:11:59 PM
If so, why still people discussing about it anyway?

The reasons people continue to engage in these activities are varied. They range from the intellectual challenge and community interaction to potential rewards and pure enjoyment. It’s much like any hobby where the journey and engagement often matter as much as, if not more than, the destination, including for those with mental health issues.
13  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: June 14, 2024, 03:07:03 AM
I think that the miners will know that this is the puzzle address and will confirm the bitcoins of the first transaction
because it will automatically mean that he is the real solver of 66 puzzle address
I won't speculate, let's be surprised if the bot steals bitcoins from the right solver, then see if that solver comes here to complain
nah, because of RBF - most of the prizes for lets say remaining sub 100 bit addresses will simply go to miners Smiley

You could also negotiate a deal with a major miner, perhaps a 50%/50% split. Getting 50% is better than nothing in the bot war.
14  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: June 13, 2024, 03:37:24 PM

I cannot physically measure the benefits of this collaborative puzzle-solving. Who cares if it's 100, 500, or 1500 Mk/s? It's the same slow hashing shit, even with all possible fixes. Without something groundbreaking, it's a dead end.

They will work on it for at least two years, and eventually, someone will collect all the prizes using a bot script. It is likely that only resellers of cloud and GPU hosting will benefit.

And if some genius discovers something groundbreaking, do you think they will publicly open-source it? I'm not sure about their safety after that..Which comes to the next point... being slow is what makes them (agencies with three letters) secure. They don't want it to be fast.
There's no hashing for kangaroo, just plain point addition as fast as possible. Which translates to 256-bit arithmetic mambo-jambo.

Believe it or not, I used Pollard's Rho algorithm to crack a Windows XP CD for the first time.

Running it on a P3-450  Grin , it took about 19 hours.

The parameters were completely different, but the principle was the same.

Amazing, and now you are doing setup to steal someones prize with RBF fee bump... ?

Steal a prize with RBF fee bump? Nah, I’m just making sure transaction gets there faster than a kid on Halloween running to the house giving out full-sized candy bars! 🤡
15  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: June 13, 2024, 02:35:11 PM

I cannot physically measure the benefits of this collaborative puzzle-solving. Who cares if it's 100, 500, or 1500 Mk/s? It's the same slow hashing shit, even with all possible fixes. Without something groundbreaking, it's a dead end.

They will work on it for at least two years, and eventually, someone will collect all the prizes using a bot script. It is likely that only resellers of cloud and GPU hosting will benefit.

And if some genius discovers something groundbreaking, do you think they will publicly open-source it? I'm not sure about their safety after that..Which comes to the next point... being slow is what makes them (agencies with three letters) secure. They don't want it to be fast.
There's no hashing for kangaroo, just plain point addition as fast as possible. Which translates to 256-bit arithmetic mambo-jambo.

Believe it or not, I used Pollard's Rho algorithm to crack a Windows XP CD for the first time.

Running it on a P3-450  Grin , it took about 19 hours.

The parameters were completely different, but the principle was the same.
16  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: June 13, 2024, 12:42:42 PM
Keyhunt does not take long to load, it takes a long time because you do not save the files.
If you add the -S command, your next run will take a very short time.

I did take that into account.

Even with the -S parameter it takes more than one minute to load in with my machine.

In my particular case almost 2 minutes to initialize Keyhunt, 20 seconds for BSGS-CUDA.



It depends on how big the .BLM file is. If it is too big, it can take a long time. I think 16GB is enough for #66
17  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: June 13, 2024, 09:53:38 AM
The 10 minutes is the average time and this is a pretty stupid circumstance. At this stage, the transaction has entered the mempool and remains 'Pending,' waiting for confirmation.

It only takes a matter of seconds to obtain the private key, after which you can replace the still-unconfirmed transaction in the mempool.

By using Replace-by-Fee (RBF), you can bump the transaction fee and forward the coins of #66 to any other address. RBF is a feature in Bitcoin that allows you to increase the transaction fee on an unconfirmed transaction, making it more attractive for miners to prioritize.

In summary, the logs for RBF transactions can be stored indefinitely or for a limited time, depending on the system's configuration and policies. If there are no logs - we can look into the glass ball what happened.. Grin
18  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: June 13, 2024, 08:13:48 AM
How to Participate:
We are using Kangaroo2 software for collaborative puzzle solving.
Let's decipher BTC Puzzle 130 together and share the grand reward!
Good joke, so your business model is to find idiots that mine DP for you. Using software that doesn't even support puzzle 130 anyway. With zero innovations, fixes, or changes to the code, probably because you have zero idea how to even read it. Just adding a "2" at the end. It's also, most likely, not even forked by you.

I cannot physically measure the benefits of this collaborative puzzle-solving. Who cares if it's 100, 500, or 1500 Mk/s? It's the same slow hashing shit, even with all possible fixes. Without something groundbreaking, it's a dead end.

They will work on it for at least two years, and eventually, someone will collect all the prizes using a bot script. It is likely that only resellers of cloud and GPU hosting will benefit.

And if some genius discovers something groundbreaking, do you think they will publicly open-source it? I'm not sure about their safety after that..Which comes to the next point... being slow is what makes them (agencies with three letters) secure. They don't want it to be fast.
19  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: June 10, 2024, 07:23:44 AM
anybody knows, whats the best parameters settings for 50GB Ram and 12 core cpu in keyhunt bsgs mode?

Your K value should be around 3072 but if your working on puzzles 130 and above I would recommend using Etarkangaroo or another modified kangaroo because they find privkeys much faster with bigger ranges compared to bsgs.
The best way I think you could use bsgs would be to search in-between kangaroo jumps.

Yes, I have about ~4 Ekeys/s on PC with 64GB RAM.

Code:
./keyhunt -m bsgs -f 65.txt -b 65 -e -t 12 -l compress -q -S -k 4096 

But it's a blast to solve Puzzle 65, 66, 67, 68.  It takes about 60 seconds once we identify the public key from the blockchain.  

Here i tested my toddler bot script on Puzzle 65 = address -> 18ZMbwUFLMHoZBbfpCjUJQTCMCbktshgpe


root@puzzle ~/Test # time python3 toddler_puzzle_bot.py
  • Version 0.2.230519 Satoshi Quest, developed by AlbertoBSD
  • Endomorphism enabled
  • Threads : 12
  • Search compress only
  • Quiet thread output
  • K factor 4096
  • Mode BSGS sequential
  • Opening file 65.txt
  • Added 1 points from file
  • Bit Range 65
  • -- from : 0x10000000000000000
  • -- to   : 0x20000000000000000
  • N = 0x100000000000
  • Bloom filter for 17179869184 elements : 58890.60 MB
  • Bloom filter for 536870912 elements : 1840.33 MB
  • Bloom filter for 16777216 elements : 57.51 MB
  • Allocating 256.00 MB for 16777216 bP Points
  • Reading bloom filter from file keyhunt_bsgs_4_17179869184.blm .... Done!
  • Reading bloom filter from file keyhunt_bsgs_6_536870912.blm .... Done!
  • Reading bP Table from file keyhunt_bsgs_2_16777216.tbl .... Done!
  • Reading bloom filter from file keyhunt_bsgs_7_16777216.blm .... Done!
  • Thread Key found privkey 1a838b13505b26867   
  • Publickey 0230210c23b1a047bc9bdbb13448e67deddc108946de6de639bcc75d47c0216b1b
All points were found
Private Key: 1a838b13505b26867
WIF Key: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qZM21gaY8WN2CdwnTG57
Starting Electrum ....
starting daemon (PID 41802)
true
Keypair imported: 18ZMbwUFLMHoZBbfpCjUJQTCMCbktshgpe
Transaction IDs: []
Daemon stopped
Electrum daemon stopped successfully.

real   2m46.311s
user   1m55.133s
sys   0m59.598s


and the time required to import the key into Electrum and start the redirection of transactions (if they exist ).  
20  Bitcoin / Bitcoin Discussion / Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it on: June 09, 2024, 05:57:32 AM
I'm not dismissing his work, it just seems very convoluted so it's understandably hard to follow. But still some script kiddie copy pastes such a project, runs make, and than brags about him asking for cryptography programmers to join his Kangaroo2 project, lol.

When a project like Kangaroo is developed, it's crucial to recognize that the initial version is just a starting point.

When creating a CUDA kernel from scratch, one quickly realizes that there are numerous aspects to optimize.

No single person can foresee all potential improvements or solutions. When developers work together, knowledge exchange happens organically.

A project that relies on a single developer is fragile; it risks stagnation or abandonment if that individual becomes unavailable. By coming together and pooling our knowledge and resources, we can transform a good project into a great one, and a great project into a groundbreaking one.

This particular project, aimed at brute-force cryptography, raises significant ethical concerns.

The question here is, who has the balls to stand behind a project like this and build it into a groundbreaking one? Grin
Pages: [1] 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 »
Powered by MySQL Powered by PHP Powered by SMF 1.1.19 | SMF © 2006-2009, Simple Machines Valid XHTML 1.0! Valid CSS!