bestie1549
Jr. Member
Offline
Activity: 75
Merit: 5
|
|
September 21, 2023, 01:48:00 AM |
|
I really appreciate your advice, yeah i was just wondering if i could try my luck with all the unsolved addresses at once lmao. If anyone can correct me with this: Since Puzzle 64 was found 2022-09-10does that mean it's been a year now 2023-09-20 and still the search for Puzzle 66 on going?! if you do your math well the normal time for scanning the 66 bit range on an average cpu would take nothing less than 500 years now we have pools that are scanning and they're barely 4% gone on the 66 bit range... so this is to tell you that you should expect at least another 1 or 2 more years for the 66 bit range to be defeated successfully but the pubkey ranges might be the appropriate range of choice for you as these gets defeated almost every 4 to 6 months
|
|
|
|
digaran
Copper Member
Hero Member
Offline
Activity: 1330
Merit: 899
🖤😏
|
|
September 21, 2023, 07:46:26 AM |
|
if you do your math well the normal time for scanning the 66 bit range on an average cpu would take nothing less than 500 years
How did you calculate to get 500 years? An average cpu is useless, with a good GPU you could get 1 billion keys per second which would take 2339 years to search the entire 66 bit range, even if we divide that time by half, we get 1169 years with an average GPU. If you run 1000 GPUs each at 1B/s for more than 14 months, you could search half the range of 2^66, if the key is not there, you'd need to keep searching, in total to make sure 66 bit is searched completely, 28 months running 1000 GPUs, nonstop. Also addresses with revealed pubs are not solvable every 4 to 6 month, if you are using kangaroo, it will get more difficult as each key range is 32 times larger than the previous key range, unless you know some tricks to reduce this range, otherwise you should at least multiply the time by 8, so if 125 took 4 months, 130 should take around 32 months. Then even if we double that time, we can expect 135 to take at least 64 months. Note, my calculations are estimates.
|
🖤😏
|
|
|
citb0in
|
|
September 21, 2023, 08:02:14 AM |
|
Since Puzzle 64 was found 2022-09-10 does that mean it's been a year now 2023-09-20 and still the search for Puzzle 66 on going?!
puzzle #64 was found on 2022-09-09 puzzle #65 was found already on 2019-06-07 puzzle #120 was found on 2023-02-27 but the privkey was not revealed yet correct, puzzle #66 is still ongoing ...
|
_______. ______ __ ______ ______ __ ___ .______ ______ ______ __ ______ .______ _______ / | / __ \ | | / __ \ / || |/ / | _ \ / __ \ / __ \ | | / __ \ | _ \ / _____| | (----`| | | | | | | | | | | ,----'| ' / | |_) | | | | | | | | | | | | | | | | |_) | | | __ \ \ | | | | | | | | | | | | | < | ___/ | | | | | | | | | | | | | | | / | | |_ | .----) | | `--' | | `----.| `--' | __| `----.| . \ | | | `--' | | `--' | | `----.__| `--' | | |\ \----.| |__| | |_______/ \______/ |_______| \______/ (__)\______||__|\__\ | _| \______/ \______/ |_______(__)\______/ | _| `._____| \______| | 2% fee anonymous solo bitcoin mining for all at https://solo.CKpool.org | No registration required, no payment schemes, no pool op wallets, no frills, no fuss. |
|
|
|
|
nomachine
Member
Offline
Activity: 462
Merit: 27
|
|
September 21, 2023, 01:49:00 PM |
|
if you do your math well the normal time for scanning the 66 bit range on an average cpu would take nothing less than 500 years
28 months running 1000 GPUs, nonstop. Imagine that electricity bill at the household rate.
|
bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8
|
|
|
digaran
Copper Member
Hero Member
Offline
Activity: 1330
Merit: 899
🖤😏
|
|
September 21, 2023, 10:56:32 PM |
|
if you do your math well the normal time for scanning the 66 bit range on an average cpu would take nothing less than 500 years
28 months running 1000 GPUs, nonstop. Imagine that electricity bill at the household rate. Ok then, lets materialize our imagination, if we want to be fair, we should say the time taken to solve 66 is 14 month and not 28 month. Right? 14 month = 420 days. 420 days = 10080 hours. RTX 3090 rental price = $0.20/hr 1 RTX 3090 rented for 10080 hours = $2016 1000 RTX 3090 rented for 10080 hours = $2016000 We will use a discounted price of $2,000,000 USD. Puzzle 66 contains 6.6 bitcoins, at a price of $30,000. 6.6 * 30,000 = $198000. In the future when bitcoin is at $100,000 * 6.6 = $660,000. Further in the future, bitcoin is at $300,000. tech has advanced, speed of key per second is now 10B/s. So we just need 100 GPUs. 100 * $2016 = $201,600. With discount is $200,000 cost of finding #66, and bitcoin at 300k, now puzzle reward is worth $1,980,000 - 200,000 = $1,780,000 profit. Question, when will we see GPU speed jumping from 1B/s to 10B/s, and bitcoin price at $300,000? Even then what about #67, two times harder than #66 in theory, #68, #69, #70?
It's either profitable to rent GPUs and find them, or will be profitable in the future, in both cases, nothing really changes, nobody is gonna come up with a solution and an algorithm to brute force keys with 10B/s rate in the next 10 years.
|
🖤😏
|
|
|
nomachine
Member
Offline
Activity: 462
Merit: 27
|
|
September 22, 2023, 10:26:41 AM Last edit: September 22, 2023, 06:28:24 PM by nomachine |
|
Script above is the python version of your code written in alien language, I'm on phone so I couldn't test to see if it works, later I will test it on my laptop and fix any issues. Insha'Allah. ( God willing )
Also; Thanks for the update on the code, appreciate it. My scripts ( small part of them ) don't need much speed because they are not supposed to auto solve a key, they are intended as learning tools, I talked about improving performance to make king of information stop whining so much. 🤣
I use GMP even for random number generation..I'm playing around with collisions and cycles now. import sys import os import time import gmpy2 from gmpy2 import mpz from functools import lru_cache import secp256k1 as ice import multiprocessing from multiprocessing import Pool, cpu_count
# Constants MODULO = gmpy2.mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F) ORDER = gmpy2.mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141) GX = gmpy2.mpz(0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798) GY = gmpy2.mpz(0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8)
# Define Point class class Point: def __init__(self, x=0, y=0): self.x = x self.y = y
PG = Point(GX, GY) ZERO_POINT = Point(0, 0)
# Function to multiply a point by 2 @lru_cache(maxsize=None) def multiply_by_2(P, p=MODULO): c = gmpy2.f_mod(3 * P.x * P.x * gmpy2.powmod(2 * P.y, -1, p), p) R = Point() R.x = gmpy2.f_mod(c * c - 2 * P.x, p) R.y = gmpy2.f_mod(c * (P.x - R.x) - P.y, p) return R
# Function to add two points @lru_cache(maxsize=None) def add_points(P, Q, p=MODULO): dx = Q.x - P.x dy = Q.y - P.y c = gmpy2.f_mod(dy * gmpy2.invert(dx, p), p) R = Point() R.x = gmpy2.f_mod(c * c - P.x - Q.x, p) R.y = gmpy2.f_mod(c * (P.x - R.x) - P.y, p) return R
# Function to calculate Y-coordinate from X-coordinate @lru_cache(maxsize=None) def x_to_y(X, y_parity, p=MODULO): Y = gmpy2.mpz(3) tmp = gmpy2.mpz(1)
while Y > 0: if Y % 2 == 1: tmp = gmpy2.f_mod(tmp * X, p) Y >>= 1 X = gmpy2.f_mod(X * X, p)
X = gmpy2.f_mod(tmp + 7, p)
Y = gmpy2.f_div(gmpy2.add(p, 1), 4) tmp = gmpy2.mpz(1)
while Y > 0: if Y % 2 == 1: tmp = gmpy2.f_mod(tmp * X, p) Y >>= 1 X = gmpy2.f_mod(X * X, p)
Y = tmp
if Y % 2 != y_parity: Y = gmpy2.f_mod(-Y, p)
return Y
# Function to compute a table of points def compute_point_table(): points = [PG] for k in range(255): points.append(multiply_by_2(points[k])) return points
POINTS_TABLE = compute_point_table()
# Global event to signal all processes to stop STOP_EVENT = multiprocessing.Event()
# Function to check and compare points for potential solutions def check(P, Pindex, DP_rarity, A, Ak, B, Bk): check_modulo = gmpy2.f_mod(P.x, DP_rarity) if check_modulo != 0: return False
message = f"\r[+] [Pindex]: {mpz(Pindex)}" messages = [] messages.append(message) output = "\033[01;33m" + ''.join(messages) + "\r" sys.stdout.write(output) sys.stdout.flush()
A.append(mpz(P.x)) Ak.append(mpz(Pindex))
collision_index_A = find_collision(Ak) if collision_index_A is not None: return comparator(A, Ak, B, Bk, collision_index_A)
collision_index_B = find_collision(Bk) if collision_index_B is not None: return comparator(A, Ak, B, Bk, collision_index_B)
return False
# Cycle detection function for Ak def find_collision(Ak): seen = set() for i, item in enumerate(Ak): if item in seen: return mpz(i) # Collision detected, return as mpz seen.add(item) return None # No collision detected
# Cycle detection function for Bk def find_collision(Bk): seen = set() for i, item in enumerate(Bk): if item in seen: return mpz(i) # Collision detected, return as mpz seen.add(item) return None # No collision detected
# Function to compare two sets of points and find a common point def comparator(A, Ak, B, Bk, collision_index): global STOP_EVENT result = set(A).intersection(set(B)) if result: sol_kt = A.index(next(iter(result))) sol_kw = B.index(next(iter(result))) difference = Ak[sol_kt] - Bk[sol_kw] HEX = "%064x" % difference wifc = ice.btc_pvk_to_wif("%064x" % mpz(difference)) dec = int(ice.btc_wif_to_pvk_hex(wifc), 16) wifu = ice.btc_pvk_to_wif(HEX, False) # Uncompressed uaddr = ice.privatekey_to_address(0, False, dec) # Uncompressed caddr = ice.privatekey_to_address(0, True, dec) # Compressed HASH160 = ice.privatekey_to_h160(0, True, dec).hex() t = time.ctime() total_time = time.time() - starttime print(f"\033[32m[+] PUZZLE SOLVED: {t}, total time: {total_time:.2f} sec \033[0m") print(f"\033[32m[+] WIF: \033[32m {wifc} \033[0m") with open("KEYFOUNDKEYFOUND.txt", "a") as file: file.write("\n\nPUZZLE SOLVED " + t) file.write(f"\nTotal Time: {total_time:.2f} sec") file.write('\nPrivate Key (dec): ' + str(dec)) file.write('\nPrivate Key (hex): ' + HEX) file.write('\nPrivate Key Compressed: ' + wifc) file.write('\nPrivate Key Uncompressed: ' + wifu) file.write('\nPublic Address Compressed: ' + caddr) file.write('\nPublic Address Uncompressed: ' + uaddr) file.write('\nPublic Key Hash Compressed (Hash 160): ' + HASH160) file.write( "\n-------------------------------------------------------------------------------------------------------------------------------------\n" )
STOP_EVENT.set() # Set the stop event to signal all processes
# Memoization for point multiplication ECMULTIPLY_MEMO = {}
# Function to multiply a point by a scalar def ecmultiply(k, P=PG, p=MODULO): if k == 0: return ZERO_POINT elif k == 1: return P elif k % 2 == 0: if k in ECMULTIPLY_MEMO: return ECMULTIPLY_MEMO[k] else: result = ecmultiply(k // 2, multiply_by_2(P, p), p) ECMULTIPLY_MEMO[k] = result return result else: return add_points(P, ecmultiply((k - 1) // 2, multiply_by_2(P, p), p))
# Recursive function to multiply a point by a scalar def mulk(k, P=PG, p=MODULO): if k == 0: return ZERO_POINT elif k == 1: return P elif k % 2 == 0: return mulk(k // 2, multiply_by_2(P, p), p) else: return add_points(P, mulk((k - 1) // 2, multiply_by_2(P, p), p))
# Generate a list of powers of two for faster access @lru_cache(maxsize=None) def generate_powers_of_two(hop_modulo): return [mpz(1 << pw) for pw in range(hop_modulo)]
# Worker function for point search def search_worker(Nt, Nw, puzzle, tortoise_power, starttime, lower_range_limit, upper_range_limit): global STOP_EVENT
random_state_t = gmpy2.random_state(hash(gmpy2.random_state())) random_state_w = gmpy2.random_state(hash(gmpy2.random_state()))
t = [mpz(lower_range_limit + gmpy2.mpz_random(random_state_t, upper_range_limit - lower_range_limit)) for _ in range(Nt)] T = [mulk(ti) for ti in t] dt = [mpz(0) for _ in range(Nt)] w = [gmpy2.mpz_random(random_state_w, upper_range_limit - lower_range_limit) for _ in range(Nt)] W = [add_points(W0, mulk(wk)) for wk in w] dw = [mpz(0) for _ in range(Nw)]
Hops, Hops_old = 0, 0
oldtime = time.time() starttime = oldtime
while True: for k in range(Nt): Hops += 1 pw = T[k].x % hop_modulo dt[k] = powers_of_two[pw] solved = check(T[k], t[k], DP_rarity, T, t, W, w) if solved: STOP_EVENT.set() raise SystemExit t[k] += dt[k] T[k] = add_points(POINTS_TABLE[pw], T[k])
for k in range(Nw): Hops += 1 pw = W[k].x % hop_modulo dw[k] = powers_of_two[pw] solved = check(W[k], w[k], DP_rarity, W, w, T, t) if solved: STOP_EVENT.set() raise SystemExit w[k] += dw[k] W[k] = add_points(POINTS_TABLE[pw], W[k])
if STOP_EVENT.is_set(): break
# Main script if __name__ == "__main__": os.system("clear") t = time.ctime() sys.stdout.write("\033[01;33m") sys.stdout.write(f"[+] {t}" + "\n") sys.stdout.write(f"[+] Cycle detected, applying Floyd's cycle-finding algorithm..." + "\n") sys.stdout.flush() # Configuration for the puzzle puzzle = 50 compressed_public_key = "03f46f41027bbf44fafd6b059091b900dad41e6845b2241dc3254c7cdd3c5a16c6" # Puzzle 50 lower_range_limit = 2 ** (puzzle - 1) upper_range_limit = (2 ** puzzle) - 1 tortoise_power = puzzle // 8 Nt = Nw = (2 ** tortoise_power // puzzle) * puzzle + 8 DP_rarity = 8 * puzzle hop_modulo = (puzzle // 2) + 8
# Precompute powers of two for faster access powers_of_two = generate_powers_of_two(hop_modulo)
T, t, dt = [], [], [] W, w, dw = [], [], []
if len(compressed_public_key) == 66: X = mpz(compressed_public_key[2:66], 16) Y = x_to_y(X, mpz(compressed_public_key[:2]) - 2) else: print("[error] pubkey len(66/130) invalid!")
print(f"[+] [Puzzle]: {puzzle}") print(f"[+] [Lower range limit]: {lower_range_limit}") print(f"[+] [Upper range limit]: {upper_range_limit}") print("[+] [Xcoordinate]: %064x" % X) print("[+] [Ycoordinate]: %064x" % Y)
W0 = Point(X, Y) starttime = oldtime = time.time()
Hops = 0
process_count = cpu_count() print(f"[+] Using {process_count} CPU cores for parallel search")
# Create a pool of worker processes pool = Pool(process_count) results = pool.starmap( search_worker, [ ( Nt, Nw, puzzle, tortoise_power, starttime, lower_range_limit, upper_range_limit, ) ] * process_count, ) pool.close() pool.join()
|
bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8
|
|
|
alek76
Member
Offline
Activity: 93
Merit: 16
|
|
September 22, 2023, 07:50:22 PM |
|
Hello everyone, and especially those who still remember me) I made a new version, while I’m checking how it works... It will be very difficult to find bit 66, even with the best GPUs. OpenSSL is screwed into the program, with the ability to switch the OpenSSL functions used. Can also check different dlls by dropping them into the directory with the program. I disabled everything unnecessary - SSE, endomorphism, symmetry. Changed the GPU code - removed endomorphism and removed double (quadruples) checks of Ripemd160 (Match GPU - the Y coordinate is calculated in the curve). I'm checking it out, maybe I'll post it soon... C:\VSearch-1.19 New Build check v0.03\win7 x64>VanitySearch.exe -stop -t 1 -bits 66 -r 5 -level 1 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so
[ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ] [ ] [===========================================================] [ Changes by Alek76 modify 0.03 ] [===========================================================] [ Tips: 1NULY7DhzuNvSDtPkFzNo6oRTZQWBqXNE9 ] [===========================================================] [ Options added argv [-start] [-bits] and disable SSE ] [===========================================================] [ Used OpenSSL Random number generator ] [===========================================================] [ OpenSSL add all algorithms ] [===========================================================] [ OpenSSL Used functions level 1 ] [ ] [ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ]
Difficulty: 1461501637330902918203684832716283019655932542976 Search: 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so [Compressed] Start Fri Sep 22 23:00:18 2023 Base Key: Randomly changed every 5 Mkeys Number of CPU thread: 1
Bit 60 Base Key thId 0: 9F79EEEC674E61F < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true
Bit 66 CPU Base Key thId 0: 29D1A41009D12513A [0.89 Mkey/s][GPU 0.00 Mkey/s][Total 2^22.35][Prob 0.0%][50% in 3.60851e+34y][Found 0] Bit 64 Base Key thId 0: E3643540371FB847 < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true
Bit 64 Base Key thId 0: 80A2CD8B9A3C23BC < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true
Bit 66 CPU Base Key thId 0: 3A53B397C7C3998F9 [0.85 Mkey/s][GPU 0.00 Mkey/s][Total 2^23.51][Prob 0.0%][50% in 3.768e+34y][Found 0] Bit 66 CPU Base Key thId 0: 33A47F5D6B844E5CE [0.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^24.14][Prob 0.0%][50% in 3.90297e+34y][Found 0] Bit 66 CPU Base Key thId 0: 23B25CA07BAC32C6F [0.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^24.58][Prob 0.0%][50% in 3.9043e+34y][Found 0] Bit 65 Base Key thId 0: 12FF6314297C60ECB < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true
Bit 66 CPU Base Key thId 0: 25B540E692C67500B [0.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^24.92][Prob 0.0%][50% in 3.90599e+34y][Found 0] Bit 65 Base Key thId 0: 14F6F111D9ADFE665 < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true
Bit 66 CPU Base Key thId 0: 28F5EB0F8DBAF6E80 [0.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^25.19][Prob 0.0%][50% in 3.90512e+34y][Found 0] Bit 66 CPU Base Key thId 0: 33755278B8367C2C3 [0.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^25.42][Prob 0.0%][50% in 3.89525e+34y][Found 0] Bit 64 Base Key thId 0: C63FFCFE4B85011C < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true
Bit 66 CPU Base Key thId 0: 36CA7D64880F6EC8E [0.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^25.59][Prob 0.0%][50% in 3.89824e+34y][Found 0] Bit 65 Base Key thId 0: 1602E2E612E2D1D5D < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true
Bit 64 Base Key thId 0: 9CE5D3E01377163B < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true
Bit 66 CPU Base Key thId 0: 22729A06418E0AA07 [0.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^25.77][Prob 0.0%][50% in 3.90262e+34y][Found 0] Bit 65 Base Key thId 0: 1E4BA74256A46FFF2 < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true
Bit 65 Base Key thId 0: 19A395587DDFF6849 < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true
Bit 66 CPU Base Key thId 0: 201909FF60F39CB91 [0.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^25.89][Prob 0.0%][50% in 3.90116e+34y][Found 0]
C:\VSearch-1.19 New Build check v0.03\win7 x64>VanitySearch.exe -stop -t 2 -bits 66 -r 5 -level 4 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so
[ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ] [ ] [===========================================================] [ Changes by Alek76 modify 0.03 ] [===========================================================] [ Tips: 1NULY7DhzuNvSDtPkFzNo6oRTZQWBqXNE9 ] [===========================================================] [ Options added argv [-start] [-bits] and disable SSE ] [===========================================================] [ Used OpenSSL Random number generator ] [===========================================================] [ OpenSSL add all algorithms ] [===========================================================] [ OpenSSL RAND_screen() OK ] [===========================================================] [ OpenSSL Used functions level 4 ] [ ] [ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ]
[i] RAND_add() Seed with CPU performance counter: 413322837980 Difficulty: 1461501637330902918203684832716283019655932542976 Search: 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so [Compressed] Start Fri Sep 22 23:25:51 2023 Base Key: Randomly changed every 5 Mkeys Number of CPU thread: 2
[i] RAND_add() Seed with CPU performance counter: 413323029166
Bit 64 Base Key thId 1: C3B95A81B85BFE25 < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true
Bit 66 CPU Base Key thId 1: 20D9401B0A4FFDD06
[i] RAND_add() Seed with CPU performance counter: 413323029845
Bit 64 Base Key thId 0: A5BB18323A7CB6AB < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true
Bit 66 CPU Base Key thId 0: 295244E678E41E12E [1.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^22.85][Prob 0.0%][50% in 1.76408e+34y][Found 0] [i] RAND_add() Seed with CPU performance counter: 413333913173
Bit 66 CPU Base Key thId 0: 29EF09292123E8168
[i] RAND_add() Seed with CPU performance counter: 413333913233
Bit 65 Base Key thId 1: 1FC1E88D8E95BC854 < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true
Bit 61 Base Key thId 1: 11B4BEA1EE95FF48 < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true
Bit 66 CPU Base Key thId 1: 27D8A8F52B15BE829 [1.72 Mkey/s][GPU 0.00 Mkey/s][Total 2^23.76][Prob 0.0%][50% in 1.86995e+34y][Found 0] [i] RAND_add() Seed with CPU performance counter: 413343522509
Bit 66 CPU Base Key thId 0: 396121E3EFFA2A03C
[i] RAND_add() Seed with CPU performance counter: 413343523260
Bit 66 CPU Base Key thId 1: 2D60B4F910B675F54 [1.68 Mkey/s][GPU 0.00 Mkey/s][Total 2^24.31][Prob 0.0%][50% in 1.90682e+34y][Found 0] [i] RAND_add() Seed with CPU performance counter: 413353124168
[i] RAND_add() Seed with CPU performance counter: 413353124942
Bit 64 Base Key thId 1: B461B1FC1240503B < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true
Bit 66 CPU Base Key thId 1: 2C1BC11A5C0C595BA
Bit 66 CPU Base Key thId 0: 32DFF58084D0F0B48 [1.67 Mkey/s][GPU 0.00 Mkey/s][Total 2^24.72][Prob 0.0%][50% in 1.92559e+34y][Found 0] [i] RAND_add() Seed with CPU performance counter: 413362823436
Bit 66 CPU Base Key thId 1: 2664445EC6A550E07
[i] RAND_add() Seed with CPU performance counter: 413362823661
Bit 66 CPU Base Key thId 0: 27E59959139581FB5 [1.62 Mkey/s][GPU 0.00 Mkey/s][Total 2^25.03][Prob 0.0%][50% in 1.98491e+34y][Found 0] [i] RAND_add() Seed with CPU performance counter: 413372570037
[i] RAND_add() Seed with CPU performance counter: 413372575962
Bit 66 CPU Base Key thId 1: 2DA47EF2D2A90A017
Bit 66 CPU Base Key thId 0: 33A1C28B16D799A69 [1.62 Mkey/s][GPU 0.00 Mkey/s][Total 2^25.29][Prob 0.0%][50% in 1.98281e+34y][Found 0] [i] RAND_add() Seed with CPU performance counter: 413382240693
[i] RAND_add() Seed with CPU performance counter: 413382241494
Bit 61 Base Key thId 1: 147BF7CC10BC669B < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true
Bit 66 CPU Base Key thId 1: 2BC45552F10B6FAF2
Bit 66 CPU Base Key thId 0: 3BF647F72F5534012 [1.62 Mkey/s][GPU 0.00 Mkey/s][Total 2^25.40][Prob 0.0%][50% in 1.98292e+34y][Found 0]
C:\VSearch-1.19 New Build check v0.03\win7 x64>VanitySearch.exe -stop -t 2 -bits 28 -r 5 -level 1 12jbtzBb54r97TCwW3G1gCFoumpckRAPdY
[ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ] [ ] [===========================================================] [ Changes by Alek76 modify 0.03 ] [===========================================================] [ Tips: 1NULY7DhzuNvSDtPkFzNo6oRTZQWBqXNE9 ] [===========================================================] [ Options added argv [-start] [-bits] and disable SSE ] [===========================================================] [ Used OpenSSL Random number generator ] [===========================================================] [ OpenSSL add all algorithms ] [===========================================================] [ OpenSSL Used functions level 1 ] [ ] [ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ]
Difficulty: 1461501637330902918203684832716283019655932542976 Search: 12jbtzBb54r97TCwW3G1gCFoumpckRAPdY [Compressed] Start Fri Sep 22 23:32:33 2023 Base Key: Randomly changed every 5 Mkeys Number of CPU thread: 2
Bit 28 CPU Base Key thId 0: F3DDC63
Bit 28 CPU Base Key thId 1: CFD7541 [1.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^22.86][Prob 0.0%][50% in 1.76379e+34y][Found 0] Bit 28 CPU Base Key thId 1: D299DE3
Bit 28 CPU Base Key thId 0: BAC1B81 [1.73 Mkey/s][GPU 0.00 Mkey/s][Total 2^23.78][Prob 0.0%][50% in 1.85735e+34y][Found 0] Bit 28 CPU Base Key thId 1: CC24254
Bit 26 Base Key thId 0: 2165974 < 8000000 or > FFFFFFF Rekey true
Bit 28 CPU Base Key thId 0: CC18276 [1.69 Mkey/s][GPU 0.00 Mkey/s][Total 2^24.33][Prob 0.0%][50% in 1.8972e+34y][Found 0] Bit 27 Base Key thId 1: 4B1D339 < 8000000 or > FFFFFFF Rekey true
Bit 28 CPU Base Key thId 1: D517B81
Bit 26 Base Key thId 0: 24181FC < 8000000 or > FFFFFFF Rekey true
Bit 26 Base Key thId 0: 2639DB4 < 8000000 or > FFFFFFF Rekey true
Bit 27 Base Key thId 0: 5992E85 < 8000000 or > FFFFFFF Rekey true
Bit 26 Base Key thId 0: 3AE84E6 < 8000000 or > FFFFFFF Rekey true
Bit 28 CPU Base Key thId 0: DF7A263 [1.68 Mkey/s][GPU 0.00 Mkey/s][Total 2^24.73][Prob 0.0%][50% in 1.91598e+34y][Found 0] Bit 27 Base Key thId 1: 596F852 < 8000000 or > FFFFFFF Rekey true
Bit 27 Base Key thId 1: 5005795 < 8000000 or > FFFFFFF Rekey true
Bit 28 CPU Base Key thId 1: C626164
Bit 28 CPU Base Key thId 0: D72E1A1 [1.63 Mkey/s][GPU 0.00 Mkey/s][Total 2^24.90][Prob 0.0%][50% in 1.97098e+34y][Found 0]
Addr :12jbtzBb54r97TCwW3G1gCFoumpckRAPdY Check:12jbtzBb54r97TCwW3G1gCFoumpckRAPdY
!!! Result.txt Found key: D916CE8 !!! Result.txt Found key: D916CE8 !!! Result.txt Found key: D916CE8 !!! Result.txt Found key: D916CE8 !!! Result.txt Found key: D916CE8
Has anyone used OpenSSL to generate keys? Probably not..
|
|
|
|
albert0bsd
|
|
September 22, 2023, 07:57:11 PM |
|
Has anyone used OpenSSL to generate keys? Probably not..
Please don't belive that you are the only one who think in that... Yes, I checked some SSL libs on linux. Most of them works ok, The useful thing is when you tested some buggy version of it. but you need to check the source code to see where the bug is and use it to generate "weak" keys.
|
Donations: bc1qjyhcjacmpc9pg8wes82lktyrjcwk4sdvqtm7ky I am available for hiring. Avatar and Signature available for rent.
|
|
|
alek76
Member
Offline
Activity: 93
Merit: 16
|
|
September 22, 2023, 08:25:54 PM Last edit: September 22, 2023, 10:29:19 PM by alek76 |
|
Please don't belive that you are the only one who think in that... Yes, I checked some SSL libs on linux. Most of them works ok, The useful thing is when you tested some buggy version of it. but you need to check the source code to see where the bug is and use it to generate "weak" keys. Yes, that's absolutely true. Here I spent a week digging through old versions of OpenSSL from their official source. Weak keys are possible if assembled incorrectly. For example, like in older versions of Bitcoin core bitcoin-0.2.0, where RandAddSeedPerfmon() for Linux does not work, not used function RAND_add(). Downloaded DLLs can be checked by saving them keys to file and checking for duplicates. But this is unlikely all, a very large range. In general, a good Random will not hurt to solve bit 66, since the versions and key generation programs for this puzzle are not known. Perhaps the purpose of its creation will help, but perhaps its purpose is also to test the strength of OpenSSL libraries. Although there are so many external events that it is not possible to re-generate duplicate keys, unless there are broken versions - removing some functions to generate a weak key. Perhaps someone decided to check old versions and created this puzzle.
|
|
|
|
tetaeridanus
Member
Offline
Activity: 182
Merit: 33
Peace without Borders
|
|
September 23, 2023, 02:12:24 AM |
|
is this puzzle still unsolved to date?
|
Haram'da huzur arayana, Huzur haram olur.
|
|
|
digaran
Copper Member
Hero Member
Offline
Activity: 1330
Merit: 899
🖤😏
|
|
September 23, 2023, 02:31:31 AM |
|
is this puzzle still unsolved to date?
It's not one puzzle, there are 160 in total, some of them are already solved, #66 is not yet solved. #130 also not solved but these 2 are next in line.
Guys anyone here knows python? Of course you do, I'm stuck for days to make this happening, at first I wanted to have such function inside another script but I failed, so I thought of something else, the following script opens 2 text files, reads the keys in both and subtracts them from each other, that's the logic but whatever I did I couldn't get it to take public keys from each line of the files and do the subtraction with them all, it just reads the last line and returns only 1 result obviously, if you could provide a fix, it'd be great. # 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.") I know the problem is in line.strip section, just don't know how, btw I asked AI, it started by implementing sha256 for no reason, ended up with giving me some test cases from bitcoin wiki. Go figure! Note, it's for academic purposes only ( whatever that means anyway ).😉
|
🖤😏
|
|
|
7isce
Jr. Member
Offline
Activity: 61
Merit: 6
|
|
September 23, 2023, 05:17:08 AM |
|
You could just use it as 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()
Good Luck with your studies
|
|
|
|
digaran
Copper Member
Hero Member
Offline
Activity: 1330
Merit: 899
🖤😏
|
|
September 23, 2023, 06:44:06 AM |
|
Didn't work, still outputs a single result which is the result of last public keys in my files subtracted, this new method I'm working on is not yet tested, so I can't share it before testing it myself.
I managed to make up a scalar mod n version of my script, but as a py noob, I can't learn so many things in a short period of time. Thanks for the effort though. Maybe I'm unsuccessful because I'm using mobile instead of laptop? Lol I should find some place else for my coding guidance.
My new script can solve any key in scalar mode of course.
|
🖤😏
|
|
|
citb0in
|
|
September 23, 2023, 08:00:52 AM |
|
I made a new version, while I’m checking how it works... It will be very difficult to find bit 66, even with the best GPUs. OpenSSL is screwed into the program, with the ability to switch the OpenSSL functions used. Can also check different dlls by dropping them into the directory with the program. I disabled everything unnecessary - SSE, endomorphism, symmetry. Changed the GPU code - removed endomorphism and removed double (quadruples) checks of Ripemd160 (Match GPU - the Y coordinate is calculated in the curve). I'm checking it out, maybe I'll post it soon...
Sounds interesting as long as the source code is available so one can compile the program. Is it available for download ?
|
_______. ______ __ ______ ______ __ ___ .______ ______ ______ __ ______ .______ _______ / | / __ \ | | / __ \ / || |/ / | _ \ / __ \ / __ \ | | / __ \ | _ \ / _____| | (----`| | | | | | | | | | | ,----'| ' / | |_) | | | | | | | | | | | | | | | | |_) | | | __ \ \ | | | | | | | | | | | | | < | ___/ | | | | | | | | | | | | | | | / | | |_ | .----) | | `--' | | `----.| `--' | __| `----.| . \ | | | `--' | | `--' | | `----.__| `--' | | |\ \----.| |__| | |_______/ \______/ |_______| \______/ (__)\______||__|\__\ | _| \______/ \______/ |_______(__)\______/ | _| `._____| \______| | 2% fee anonymous solo bitcoin mining for all at https://solo.CKpool.org | No registration required, no payment schemes, no pool op wallets, no frills, no fuss. |
|
|
|
|
alek76
Member
Offline
Activity: 93
Merit: 16
|
|
September 23, 2023, 08:34:39 AM Last edit: September 23, 2023, 02:19:46 PM by alek76 |
|
I made a new version, while I’m checking how it works... It will be very difficult to find bit 66, even with the best GPUs. OpenSSL is screwed into the program, with the ability to switch the OpenSSL functions used. Can also check different dlls by dropping them into the directory with the program. I disabled everything unnecessary - SSE, endomorphism, symmetry. Changed the GPU code - removed endomorphism and removed double (quadruples) checks of Ripemd160 (Match GPU - the Y coordinate is calculated in the curve). I'm checking it out, maybe I'll post it soon...
Sounds interesting as long as the source code is available so one can compile the program. Is it available for download ? Today I checked the GPU code again, since I removed the unnecessary calculations of Ripemd160 (left 1 out of 6) and it works correctly. I needed to make sure again that everything was correct. In this code I also used functions from the Bitcoin client - to add a seed, the Rand_add() function. I'll post it on Github in the near future, because... With my computing resources it will not be possible to find a solution to bit 66. If they find it using my fork, then send me a tips . Coming soon. I managed to get this speed on Tesla T4: [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]
Coming soon... Already available https://github.com/alek76-2/VanitySearch
|
|
|
|
digaran
Copper Member
Hero Member
Offline
Activity: 1330
Merit: 899
🖤😏
|
|
September 23, 2023, 11:14:27 AM |
|
Coming soon.
Once upon a time, there existed a WanderingPhilospher who also was a brute force developer, he used to be my mentor, he taught a lot of useful stuff to me. Will you be my new mentor? Lol
Do you have anything useful and fast that could do public key calculations to solve for private key? I have some ideas which I need to test extensively to make sure it could be used to solve DLP, God willing after a successful test run, I might bother you to develop something new!
|
🖤😏
|
|
|
alek76
Member
Offline
Activity: 93
Merit: 16
|
Coming soon.
Once upon a time, there existed a WanderingPhilospher who also was a brute force developer, he used to be my mentor, he taught a lot of useful stuff to me. Will you be my new mentor? Lol
Do you have anything useful and fast that could do public key calculations to solve for private key? I have some ideas which I need to test extensively to make sure it could be used to solve DLP, God willing after a successful test run, I might bother you to develop something new! Not funny at all! I already have a version with random divide of the public key. I talked to WanderingPhilospher a couple of years ago, I remember well when I remade the starting keys for Kangaroo. And probably everyone forgot that I was the first to post the GPU code for Kangaroo and this was before the release date of Kangaroo from Jean-Luc Pons. here is the link: https://bitcointalk.org/index.php?topic=5218972.msg54089243#msg54089243At that time, I pushed this topic very hard, and soon a version from Jean-Luc Pons appeared. Thank him very much. As promised, I published the fork code on Github https://github.com/alek76-2/VanitySearchEnjoy it, and if you find solution 66 with this version, don’t forget about me
|
|
|
|
mcdouglasx
Member
Offline
Activity: 318
Merit: 88
New ideas will be criticized and then admired.
|
|
September 23, 2023, 02:21:00 PM Last edit: September 23, 2023, 04:26:27 PM by mcdouglasx |
|
is this puzzle still unsolved to date?
It's not one puzzle, there are 160 in total, some of them are already solved, #66 is not yet solved. #130 also not solved but these 2 are next in line.
Guys anyone here knows python? Of course you do, I'm stuck for days to make this happening, at first I wanted to have such function inside another script but I failed, so I thought of something else, the following script opens 2 text files, reads the keys in both and subtracts them from each other, that's the logic but whatever I did I couldn't get it to take public keys from each line of the files and do the subtraction with them all, it just reads the last line and returns only 1 result obviously, if you could provide a fix, it'd be great. # 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.") I know the problem is in line.strip section, just don't know how, btw I asked AI, it started by implementing sha256 for no reason, ended up with giving me some test cases from bitcoin wiki. Go figure! Note, it's for academic purposes only ( whatever that means anyway ).😉 This code reads line by line from a file. file= open("data-base_line_by_line.txt", "r") lines = file.readlines() for index, line in enumerate(lines): target = str(line.strip()) print(target) edit: if you just want to subtract (lines in file1) - (lines in file2) use this: 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()
|
BTC bc1qxs47ttydl8tmdv8vtygp7dy76lvayz3r6rdahu
|
|
|
Kostelooscoin
Member
Offline
Activity: 206
Merit: 16
|
|
September 23, 2023, 06:19:53 PM |
|
this python script generates about 144M private keys with the X and Y keys, which takes a long time to generate, so I'd like to know if it would be possible to speed up the process by keeping the calculation method used in the script, even if it's just a matter of generating the private keys while keeping the calculation method? addressgeneration.pyfrom 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 KeysFileGeneration.pyimport 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)
|
|
|
|
alek76
Member
Offline
Activity: 93
Merit: 16
|
|
September 24, 2023, 01:44:29 AM Last edit: September 24, 2023, 02:09:35 AM by alek76 |
|
this python script generates about 144M private keys with the X and Y keys, which takes a long time to generate, so I'd like to know if it would be possible to speed up the process by keeping the calculation method used in the script, even if it's just a matter of generating the private keys while keeping the calculation method?
144M private keys are a drop in the ocean of keys. What's the point of generating public keys from private keys (it takes a long time). You need to add and multiply and divide public keys (XY coordinates). The process can of course be speeded up if you use C++. Not a single Python script has yet found complex solutions to a puzzle. You have some unique creative designs from Jean Luc Pons, this is the highest level of programming skill and experience. Everything else can only be modified, new algorithms and new functions can be added to the C++ code. Look in the wrong direction... It's better to find the correct divisor for the unknown private key. Correct - this means the remainder of the division is zero!!! This is a good task, then there will be a result.
|
|
|
|
|