nomachine
|
 |
July 13, 2024, 07:42:04 AM |
|
I'm wondering if going from GMP to iceland's package, would offer some speed up.
https://github.com/iceland2k14/kangaroo.gitfrom here? # time python3 kangaroo.py -p 03a2efa402fd5268400c77c20e574ba86409ededee7c4020e4b9f0edbee53de0d4 -keyspace 8000000000:ffffffffff - Starting CPU Kangaroo.... Please Wait Version [ 15112021 ]
- Search Mode: Range search Continuous in the given range
- Working on Pubkey: 04a2efa402fd5268400c77c20e574ba86409ededee7c4020e4b9f0edbee53de0d47ba1a987013e7 8aef5295bf842749bdf97e25336a82458bbaba8c00d16a79ea7
- Using [Number of CPU Threads: 11] [DP size: 10] [MaxStep: 2]
- Scanning Range 0x8000000000 : 0x100007fffffffff
- [3074.58 TeraKeys/s][Kang 11264][Count 2^28.20/2^29.07][Elapsed 08s][Dead 2][RAM 29.6MB/45.1MB]
============== KEYFOUND ============== Kangaroo FOUND PrivateKey : 0x000000000000000000000000000000000000000000000000000000e9ae4933d6 ====================================== real 0m8.687s user 1m31.744s sys 0m0.095s It has not been updated for a long time. No, I meant using his secp256k1 library, integrating it into another kangaroo python script. I haven't really looked at his kangaroo library. I understand, it's not a bad idea to try. I tried to see what was in his kangaroo .so file from https://dogbolt.org/Best result is from Retargetable Decompiler(RetDec) the decompiled output contains low-level assembly instructions and it's challenging to fully reconstruct high-level source code from compiled binaries, but you can see roughly what the program accesses and how. I think he packaged the code with Cython a Python compiler.
|
BTC: bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8
|
|
|
kTimesG
|
 |
July 13, 2024, 09:25:33 AM |
|
You can easily get 11M hops/s on single-core CPU
Do a single inverse (10-20x speedup). Use carry-free representation (1-2x speedup). Dump GMP, it does generic arithmetic, not specialized to our needs (> 75% speedup).
With GMP, using MPN (lowest level possible) calls, and naive point addition like the one above, I never topped 700 K/s. In plain C.
Likely it would be even faster than 11-12 M/s with careful choices so that all data resides in CPU cache and the core is strongly assigned (no context switch).
But IMO it's just an exercise. The cost per kangaroo jump, in watts, is not worth it even if the speed would be triple or whatever. You might also get a fried CPU. Serve with potatoes and ketchup.
|
Off the grid, training pigeons to broadcast signed messages.
|
|
|
nomachine
|
 |
July 13, 2024, 09:45:02 AM |
|
You can easily get 11M hops/s on single-core CPU
Do a single inverse (10-20x speedup). Use carry-free representation (1-2x speedup). Dump GMP, it does generic arithmetic, not specialized to our needs (> 75% speedup).
I only know how to do this with OpenSSL's BIGNUM and functions like BN_add, BN_sub, BN_mul, BN_mod, etc., for arithmetic operations. But I don't believe that the speed will be that high. Maybe 5M hops/s on single-core CPU.
|
BTC: bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8
|
|
|
wilspen
Newbie
Offline
Activity: 23
Merit: 0
|
 |
July 13, 2024, 08:30:08 PM |
|
Guys, here's a new puzzle challenge from the channel https://www.youtube.com/watch?v=LkejrZuQadg, this challenge consists of locating the private key of the address 19L9vivFCPJnAVDsjZ76mF2ZiTLKFUXEpV which is in the same range as puzzle 66, but with a dot , according to the creator, next Friday, he will request a transfer, the objective would be to export the public key on the blockchain and test whether it would be possible for someone to intercept the transfer before it is completed through the RBF, thus removing doubts whether The same thing could happen with puzzle 66, so whoever has the BOTs being heated could do this test with this key. hahahaha. Anyway, you already know the day, you just need to be more agile than the process on the blockchain, according to the creator, he will place the transaction at the lowest possible rate, precisely to understand if it would be possible for someone to intercept this transaction and withdraw before him, good luck. Creator: https://www.youtube.com/watch?v=LkejrZuQadgAddress: 19L9vivFCPJnAVDsjZ76mF2ZiTLKFUXEpV Range: 20000000000000000:3ffffffffffffffff
|
|
|
|
Alex_Cyber369
Newbie
Offline
Activity: 1
Merit: 0
|
 |
July 14, 2024, 04:54:23 AM |
|
Guys, here's a new puzzle challenge from the channel https://www.youtube.com/watch?v=LkejrZuQadg, this challenge consists of locating the private key of the address 19L9vivFCPJnAVDsjZ76mF2ZiTLKFUXEpV which is in the same range as puzzle 66, but with a dot , according to the creator, next Friday, he will request a transfer, the objective would be to export the public key on the blockchain and test whether it would be possible for someone to intercept the transfer before it is completed through the RBF, thus removing doubts whether The same thing could happen with puzzle 66, so whoever has the BOTs being heated could do this test with this key. hahahaha. Anyway, you already know the day, you just need to be more agile than the process on the blockchain, according to the creator, he will place the transaction at the lowest possible rate, precisely to understand if it would be possible for someone to intercept this transaction and withdraw before him, good luck. Creator: https://www.youtube.com/watch?v=LkejrZuQadgAddress: 19L9vivFCPJnAVDsjZ76mF2ZiTLKFUXEpV Range: 20000000000000000:3ffffffffffffffff That's cool , i'm waiting for this
|
|
|
|
Gord0nFreeman
Newbie
Offline
Activity: 22
Merit: 1
|
 |
July 14, 2024, 12:12:58 PM |
|
Hello everyone! I found the key to puzzle 66, but now I have another problem: how to withdraw the funds so that no one can intercept them with a bot? Please repost this message so the creator sees it! Maybe someone can tweet this so that the owners of large pools can respond, whether they can add the transaction to the next block when it is found, without broadcasting it to the network? Pls, HELP ME!!!!!
|
|
|
|
nomachine
|
 |
July 14, 2024, 02:07:37 PM Last edit: July 14, 2024, 02:36:08 PM by nomachine |
|
I'm wondering if going from GMP to iceland's package, would offer some speed up.
Here you go, all mathematics go through Iceland's package: import time, random import secp256k1 as ice
modulo = ice.N Gx = 0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798 Gy = 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8 PG = Gx, Gy Z = ice.Zero
def to_bytes(point): x_bytes = point[0].to_bytes(32, byteorder='big') y_bytes = point[1].to_bytes(32, byteorder='big') return b'\x04' + x_bytes + y_bytes
def from_bytes(point_bytes): x = int.from_bytes(point_bytes[1:33], byteorder='big') y = int.from_bytes(point_bytes[33:65], byteorder='big') return x, y
def add(P, Q, p=modulo): if P == Z: return Q if Q == Z: return P Px, Py = P; Qx, Qy = Q if Px == Qx and (Py != Qy or Py == 0): return Z P_bytes = to_bytes(P) Q_bytes = to_bytes(Q) result_bytes = ice.point_addition(P_bytes, Q_bytes) result = from_bytes(result_bytes) return result
def mul2(P, p=modulo): if P == Z: return Z P_bytes = to_bytes(P) result_bytes = ice.point_doubling(P_bytes) result = from_bytes(result_bytes) return result
def mulk(k, P=PG, p=modulo): result = Z addend = P while k > 0: if k & 1: result = add(result, addend, p) addend = mul2(addend, p) k >>= 1 return result
def X2Y(X, y_parity, p=modulo): X_hex = '%064x' % X is_even = (y_parity == 0) Y_bytes = ice.get_x_to_y(X_hex, is_even) Y = int.from_bytes(Y_bytes, byteorder='big') if Y >= p: Y = p - Y return Y
def comparator(P, Pindex, DP_rarity, t, W, w, T): if P[0] % DP_rarity == 0: T.append(P[0]) t.append(Pindex) common_elements = set(T).intersection(W) if common_elements: match = common_elements.pop() tT = t[T.index(match)] wW = w[W.index(match)] HEX = '%064x' % abs(tT - wW) dec = int(HEX, 16) total_time = time.time() - starttime print(f"\n[+] total time: {total_time:.2f} sec") print_status(time.ctime(), 'PUZZLE SOLVED') print(f"\033[32m[+] Private key (hex) : {HEX} \033[0m") log_solution(total_time, dec, HEX) return True return False
def search(P, W0, DP_rarity, Nw, Nt, hop_modulo, upper, lower): t = [lower + random.randint(0, upper - lower) for _ in range(Nt)] T = [mulk(ti) for ti in t] w = [random.randint(0, upper - lower) for _ in range(Nw)] W = [add(W0, mulk(wi)) for wi in w] Hops, Hops_old = 0, 0 t0 = time.time() solved = False while not solved: for k in range(Nt + Nw): Hops += 1 if k < Nt: pw = T[k][0] % hop_modulo solved = comparator(T[k], t[k], DP_rarity, T, t, W, w) if solved: break t[k] += 1 << pw T[k] = add(P[pw], T[k]) else: k -= Nw pw = W[k][0] % hop_modulo solved = comparator(W[k], w[k], DP_rarity, W, w, T, t) if solved: break w[k] += 1 << pw W[k] = add(P[pw], W[k]) t1 = time.time() elapsed_time = t1 - starttime if (t1 - t0) > 1: hops_per_second = (Hops - Hops_old) / (t1 - t0) hours, rem = divmod(elapsed_time, 3600) minutes, seconds = divmod(rem, 60) elapsed_time_str = f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}" print(f'[+] [Hops: {hops_per_second:.0f} h/s] [{elapsed_time_str}]', end='\r', flush=True) t0 = t1 Hops_old = Hops print('\r[+] Hops:', Hops) print('[+] Average time to solve: %.2f sec' % ((time.time() - starttime)))
def print_status(t, message): print(f"\033[?25l\033[01;33m[+]\033[32m KANGAROO: \033[01;33m{t}\033[0m {message}")
def print_puzzle_info(puzzle, lower, upper, X, Y): print(f"[+] [Puzzle]: {puzzle}") print(f"[+] [Lower range limit]: {hex(lower)}") print(f"[+] [Upper range limit]: {hex(upper)}") print(f"[+] [EC Point Coordinate X]: {hex(X)}") print(f"[+] [EC Point Coordinate Y]: {hex(Y)}")
def log_solution(total_time, dec, HEX): t = time.ctime() 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("\nPrivate Key (decimal): " + str(dec)) file.write("\nPrivate Key (hex): " + HEX) file.write(f"\n{dash_line}")
t = time.ctime() print_status(t, "")
puzzle = 40 compressed_public_key = "03a2efa402fd5268400c77c20e574ba86409ededee7c4020e4b9f0edbee53de0d4" kangaroo_power = 5 lower = 2 ** (puzzle - 1) upper = (2 ** puzzle) - 1
DP_rarity = 1 << ((puzzle - 2 * kangaroo_power) // 2 - 2) hop_modulo = (puzzle - 1) // 2 + kangaroo_power
Nt = 2 ** kangaroo_power Nw = 2 ** kangaroo_power
if len(compressed_public_key) == 66: X = int(compressed_public_key[2:66], 16) y_parity = int(compressed_public_key[:2]) - 2 Y = X2Y(X, y_parity) else: print("[error] pubkey len(66/130) invalid!")
W0 = (X, Y) starttime = time.time() print_puzzle_info(puzzle, lower, upper, X, Y)
t, W, w, T = [], [], [], []
random.seed()
P = [PG] for k in range(255): P.append(mul2(P[k]))
solved = search(P, W0, DP_rarity, Nw, Nt, hop_modulo, upper, lower) - KANGAROO: Sun Jul 14 16:01:51 2024
- [Puzzle]: 40
- [Lower range limit]: 0x8000000000
- [Upper range limit]: 0xffffffffff
- [EC Point Coordinate X]: 0xa2efa402fd5268400c77c20e574ba86409ededee7c4020e4b9f0edbee53de0d4
- [EC Point Coordinate Y]: 0x7ba1a987013e78aef5295bf842749bdf97e25336a82458bbaba8c00d16a79ea7
- [Hops: 229969 h/s] [00:00:01]
- total time: 1.47 sec
- KANGAROO: Sun Jul 14 16:01:53 2024 PUZZLE SOLVED
- Private key (hex) : 000000000000000000000000000000000000000000000000000000e9ae4933d6
- Hops: 335150
- Average time to solve: 1.47 sec
I can bet that you can make a .so file that works 20 times faster point_addition & point_doubling than this. 
|
BTC: bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8
|
|
|
kTimesG
|
 |
July 14, 2024, 03:41:48 PM |
|
- [Hops: 229969 h/s] [00:00:01]
- total time: 1.47 sec
- KANGAROO: Sun Jul 14 16:01:53 2024 PUZZLE SOLVED
- Private key (hex) : 000000000000000000000000000000000000000000000000000000e9ae4933d6
- Hops: 335150
- Average time to solve: 1.47 sec
I can bet that you can make a .so file that works 20 times faster point_addition & point_doubling than this.  I bet that no matter how well you think an .so file based on this algorithm runs, it will never reach even 1 million jumps/s. Let's idealize this a little to prove my statement, and still be grounded in reality check. We have one processor, let's pretend it runs at 5 Ghz. Let's pretend it solely does point addition, and ignore any other overhead like having to read or write data to system memory, having to propagate carries, etc etc A single point addition according to your program requires: m = (y1 - y2) / (x1 - x2) x3 = m**2 - x1 - x2 y3 = m(x2 - x3) - y2 So, 1 inverse, 2 multiplications, 1 squaring, 6 additions, all mod P, on 256-bit numbers. Let's assume one single 64-bit basic operation (add, multiply) takes one cycle (hint: it doesn't). 1 addition mod P ~= 4 or 8 adds = 4 cycles 1 squaring mod P = 16 multiplications for product, 8 + 2 more muls for reduce, and 41 adds 1 multiplication mod P = 42 multiplications + 41 additions 1 inverse = a shitload of cycles, let's simplify to ~30 multiplications mod P Total estimate for a single point addition: 1 inv = 30 mul 30 mul + 2 mul + 1 sqr + 6 add = 1344 64-bit muls + 1312 adds + 26 mul + 41 adds + 48 adds ~= 2771 cycles 5 Ghz / 2771 = 1.804.402 operations / s And this is a very very idealistic upper bound, without considering ANY of the additional real-life instructions needed to run an point addition. On what planet do you think that sticking to this algorithm can run at "20x speed"?
|
Off the grid, training pigeons to broadcast signed messages.
|
|
|
nomachine
|
 |
July 14, 2024, 04:02:29 PM Last edit: July 14, 2024, 04:27:17 PM by nomachine |
|
- [Hops: 229969 h/s] [00:00:01]
- total time: 1.47 sec
- KANGAROO: Sun Jul 14 16:01:53 2024 PUZZLE SOLVED
- Private key (hex) : 000000000000000000000000000000000000000000000000000000e9ae4933d6
- Hops: 335150
- Average time to solve: 1.47 sec
I can bet that you can make a .so file that works 20 times faster point_addition & point_doubling than this.  .... result_bytes = ice.point_addition(P_bytes, Q_bytes) You have to ask the iceland how it works. Since the source is closed.
|
BTC: bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8
|
|
|
nomachine
|
 |
July 14, 2024, 04:35:41 PM Last edit: July 14, 2024, 04:51:33 PM by nomachine |
|
- [Hops: 229969 h/s] [00:00:01]
- total time: 1.47 sec
- KANGAROO: Sun Jul 14 16:01:53 2024 PUZZLE SOLVED
- Private key (hex) : 000000000000000000000000000000000000000000000000000000e9ae4933d6
- Hops: 335150
- Average time to solve: 1.47 sec
I can bet that you can make a .so file that works 20 times faster point_addition & point_doubling than this.  A single point addition according to your program requires: m = (y1 - y2) / (x1 - x2) x3 = m**2 - x1 - x2 y3 = m(x2 - x3) - y2 result_bytes = ice.point_addition(P_bytes, Q_bytes) You have to ask the iceland how it works. Since the source is closed. But this is irrelevant. I was pointing out the flaw in the high-level strategy: while (condition) add_point(P, Q) which is a serial one-by-one element addition. If you really aim for higher speed you need to rethink what you are doing, not pretend that some black-box "addPoints(a, b)" can do wonders for you. The black-box does whatever the formula to add 2 points does, and has no knowledge of your context (adding many points). Here's a clue: z = p[0].x - jp[0].x for (i = 1 .. n) { d = p[i ].x - jp[i ].x z *= d q[i ] = z } t = inv(z) for (i = n - 1 ... 0) { xd = i > 0 ? t * q[i-1] : t t *= q[i ] // finish addition.. } This trades 3(N-1) multiplications with a single inversion Depending on size of N you can get a speedup up to the factor of around cost(1 inversion) / cost(3 multiplications). You are going off-topic and pretending to be too smart without need, just like Digaran. This is my answer, @WanderingPhilosopher: What would happen if we switched the same script from GMP to Iceland? I don't intend to talk with you at all. You just raise the pressure without ever showing a script. All I see here is static noise with no concrete script shown. I'm off now.
|
BTC: bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8
|
|
|
WanderingPhilospher
Sr. Member
  
Offline
Activity: 1372
Merit: 268
Shooters Shoot...
|
 |
July 14, 2024, 05:22:33 PM |
|
Can you crack and post the PVK of that signed address??
-----BEGIN BITCOIN SIGNED MESSAGE----- I also own this address -----BEGIN SIGNATURE----- 13zb1hQbWVuYdZoAkztVrNrm65aReL2pYD H8SlTYJ7a/Mp5cra9VzqgDFMGRQUYfA5NLrSCb0GkwbeEDqx8vKWGYWX3YmiqIU8nl6THdprDK/k34y1GQrFFDk= -----END BITCOIN SIGNED MESSAGE-----
It took 5 minutes in my laptop and less of 1 minute in main computer the advantage is that no one knows exactly when the 66 puzzle will be solved, it could be a day, a month, a year or 100 years I think that no one will monitor the 66 puzzle address for that long
That is cheap to do that, Actually I am doing it. I finally got back around to try to come up with a python solution, I think I got it. Bitcoin Address: 13zb1hQbWVuYdZoAkztVrNrm65aReL2pYD Message : I finally got this to work with python Signature : H6DZ+QYaSIb+EafHdwIC9uJrM3B6ZovzsvkpIIkNIij8QdORG03/ccbyodreXNp5YlyclvkiSA8lu9XThd8ZauU=
|
|
|
|
Akito S. M. Hosana
Jr. Member
Offline
Activity: 350
Merit: 8
|
 |
July 14, 2024, 05:26:15 PM |
|
Hello everyone! I found the key to puzzle 66, but now I have another problem: how to withdraw the funds so that no one can intercept them with a bot? Please repost this message so the creator sees it! Maybe someone can tweet this so that the owners of large pools can respond, whether they can add the transaction to the next block when it is found, without broadcasting it to the network? Pls, HELP ME!!!!!
Find a major miner here who is willing to purchase the private key from you. Conduct this transaction in a public setting to guarantee transparency and prevent possible fraud.Good luck... You just raise the pressure without any script ever being shown..
I don't sell false hopes. Well, it sounds like you're blazing through benchmarks faster than a cheetah on roller skates! If your software were a superhero, it'd be 'Benchmark Man'—faster than a speeding script! Best of luck cracking #120 
|
|
|
|
Gord0nFreeman
Newbie
Offline
Activity: 22
Merit: 1
|
 |
July 14, 2024, 06:12:16 PM |
|
Hello everyone! I found the key to puzzle 66, but now I have another problem: how to withdraw the funds so that no one can intercept them with a bot? Please repost this message so the creator sees it! Maybe someone can tweet this so that the owners of large pools can respond, whether they can add the transaction to the next block when it is found, without broadcasting it to the network? Pls, HELP ME!!!!!
Find a major miner here who is willing to purchase the private key from you. Conduct this transaction in a public setting to guarantee transparency and prevent possible fraud.Good luck... I need some advice on how to publicly conduct a transaction. How can I safely hand over the key and ensure I get paid at the right moment? Any ideas on this?
|
|
|
|
fractal1337
Newbie
Offline
Activity: 2
Merit: 0
|
 |
July 14, 2024, 07:36:07 PM |
|
Hello everyone! I found the key to puzzle 66, but now I have another problem: how to withdraw the funds so that no one can intercept them with a bot? Please repost this message so the creator sees it! Maybe someone can tweet this so that the owners of large pools can respond, whether they can add the transaction to the next block when it is found, without broadcasting it to the network? Pls, HELP ME!!!!!
Find a major miner here who is willing to purchase the private key from you. Conduct this transaction in a public setting to guarantee transparency and prevent possible fraud.Good luck... I need some advice on how to publicly conduct a transaction. How can I safely hand over the key and ensure I get paid at the right moment? Any ideas on this? I'll tell you how to securely withdraw the funds from the 66bit address. Send me a private message.
|
|
|
|
jacky19790729
Jr. Member
Offline
Activity: 82
Merit: 8
|
 |
July 14, 2024, 07:39:48 PM |
|
I finally got back around to try to come up with a python solution, I think I got it. Bitcoin Address: 13zb1hQbWVuYdZoAkztVrNrm65aReL2pYD Message : I finally got this to work with python Signature : H6DZ+QYaSIb+EafHdwIC9uJrM3B6ZovzsvkpIIkNIij8QdORG03/ccbyodreXNp5YlyclvkiSA8lu9XThd8ZauU=
I get r s z from this Message and Signature r = 0xa0d9f9061a4886fe11a7c7770202f6e26b33707a668bf3b2f92920890d2228fc s = 0x41d3911b4dff71c6f2a1dade5cda79625c9c96f922480f25bbd5d385df196ae5 z = 0xac6ff2c56216ace1660a6c04052774769ed7bc40542e1bc3408253eadb7223b8 Recovered Bitcoin public key: 03f3fb41f466d9893e5af7dfd788211b0503eb38d49615a19aa22b419ed4ff308d Bitcoin Address: 13zb1hQbWVuYdZoAkztVrNrm65aReL2pYD then use Kangaroo find private key 0000000000000000000000000000000000000000000000020000000000000000 0000000000000000000000000000000000000000000000040000000000000000 03f3fb41f466d9893e5af7dfd788211b0503eb38d49615a19aa22b419ed4ff308d
|
|
|
|
zahid888
Member

Offline
Activity: 329
Merit: 24
the right steps towerds the goal
|
 |
July 14, 2024, 07:50:01 PM |
|
Hello everyone! I found the key to puzzle 66, but now I have another problem: how to withdraw the funds so that no one can intercept them with a bot? Please repost this message so the creator sees it! Maybe someone can tweet this so that the owners of large pools can respond, whether they can add the transaction to the next block when it is found, without broadcasting it to the network? Pls, HELP ME!!!!!
Find a major miner here who is willing to purchase the private key from you. Conduct this transaction in a public setting to guarantee transparency and prevent possible fraud.Good luck... I need some advice on how to publicly conduct a transaction. How can I safely hand over the key and ensure I get paid at the right moment? Any ideas on this? You should first mix the private key and a secret message together, then post the SHA-256 hash of that combination here. For example, if your private key in hex format is '36b0f7381163cd38c' and your secret message is 'helloitsme123xyz', you should post the SHA-256 hash of the concatenated string here immediately. Next, you need to find a miner. There are many people here who have claimed to be miners, so if any of them can assist, please help this person. All dealings between you and the miner should be conducted in this forum. I think 5 bitcoins for you and the rest for the miner should be sufficient. As soon as the miner receives the correct private key, they should post here confirming that they have received the correct private key. If the miner tries to deceive and claims the private key is incorrect, your posted hash will verify whether you are right or wrong. These are my thoughts, but you can take opinions from others on how to complete this task honestly. Just ensure that all discussions take place exclusively within this forum. Avoid any miner who is not willing to communicate here. I'm providing you with a simple script. Completely disconnect your PC from the internet, run this script, and then upload the hash immediately. Do not perform this task on any online site. Codeimport hashlib
# input private key + strong secret message secret_key = input('Enter your secret key: ')
hash_hex = hashlib.sha256(secret_key.encode()).hexdigest()
# Post this hash right now print(f'The SHA-256 hash of the secret key is: {hash_hex}')
|
1BGvwggxfCaHGykKrVXX7fk8GYaLQpeixA
|
|
|
Gord0nFreeman
Newbie
Offline
Activity: 22
Merit: 1
|
 |
July 14, 2024, 07:55:55 PM |
|
Hello everyone! I found the key to puzzle 66, but now I have another problem: how to withdraw the funds so that no one can intercept them with a bot? Please repost this message so the creator sees it! Maybe someone can tweet this so that the owners of large pools can respond, whether they can add the transaction to the next block when it is found, without broadcasting it to the network? Pls, HELP ME!!!!!
Find a major miner here who is willing to purchase the private key from you. Conduct this transaction in a public setting to guarantee transparency and prevent possible fraud.Good luck... I need some advice on how to publicly conduct a transaction. How can I safely hand over the key and ensure I get paid at the right moment? Any ideas on this? You should first mix the private key and a secret message together, then post the SHA-256 hash of that combination here. For example, if your private key in hex format is '36b0f7381163cd38c' and your secret message is 'helloitsme123xyz', you should post the SHA-256 hash of the concatenated string here immediately. This sounds very unsafety...
|
|
|
|
madogss
Newbie
Offline
Activity: 53
Merit: 0
|
 |
July 14, 2024, 08:11:39 PM |
|
Gord0nFreeman if your worried about bots you can wait until Saturday, there is a person testing whether a bot could really steal puzzle 66 wilspen linked a video to the guy and talked about it. if anyone could point some bots at that then we could see a live test on friday of whether bots can steal a 66bit privkey with a public key or not.
Also what specs do you have software and hardware to solve 66 was it luck or a ton of computing power?
|
|
|
|
WanderingPhilospher
Sr. Member
  
Offline
Activity: 1372
Merit: 268
Shooters Shoot...
|
 |
July 14, 2024, 08:36:59 PM |
|
I finally got back around to try to come up with a python solution, I think I got it. Bitcoin Address: 13zb1hQbWVuYdZoAkztVrNrm65aReL2pYD Message : I finally got this to work with python Signature : H6DZ+QYaSIb+EafHdwIC9uJrM3B6ZovzsvkpIIkNIij8QdORG03/ccbyodreXNp5YlyclvkiSA8lu9XThd8ZauU=
I get r s z from this Message and Signature r = 0xa0d9f9061a4886fe11a7c7770202f6e26b33707a668bf3b2f92920890d2228fc s = 0x41d3911b4dff71c6f2a1dade5cda79625c9c96f922480f25bbd5d385df196ae5 z = 0xac6ff2c56216ace1660a6c04052774769ed7bc40542e1bc3408253eadb7223b8 Recovered Bitcoin public key: 03f3fb41f466d9893e5af7dfd788211b0503eb38d49615a19aa22b419ed4ff308d Bitcoin Address: 13zb1hQbWVuYdZoAkztVrNrm65aReL2pYD then use Kangaroo find private key 0000000000000000000000000000000000000000000000020000000000000000 0000000000000000000000000000000000000000000000040000000000000000 03f3fb41f466d9893e5af7dfd788211b0503eb38d49615a19aa22b419ed4ff308d Yeah, I was trying to create a python script to extract all the info. Finally got back around to my to-do list lol.
|
|
|
|
|
|