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.
|
|
|
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.
|
|
|
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
|
|
|
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.
|
|
|
......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.
|
|
|
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.
|
|
|
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](https://bitcointalk.org/Smileys/default/grin.gif) 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... 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. 👽
|
|
|
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](https://bitcointalk.org/Smileys/default/smiley.gif) Congrats! Here you go 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.
|
|
|
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.
|
|
|
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](https://bitcointalk.org/Smileys/default/grin.gif) Here's an example of simple OpenSSL one file code that is incredibly fast: puzzle.cpp #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(¤tTime); 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::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(¤tTime); 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: 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 : /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: 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.
|
|
|
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.
|
|
|
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.
|
|
|
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](https://bitcointalk.org/Smileys/default/smiley.gif) 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.
|
|
|
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](https://bitcointalk.org/Smileys/default/grin.gif) , 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! 🤡
|
|
|
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](https://bitcointalk.org/Smileys/default/grin.gif) , it took about 19 hours. The parameters were completely different, but the principle was the same.
|
|
|
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
|
|
|
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](https://bitcointalk.org/Smileys/default/grin.gif)
|
|
|
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.
|
|
|
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. ./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 ).
|
|
|
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](https://bitcointalk.org/Smileys/default/grin.gif)
|
|
|
|