jessica.roy
Newbie
Offline
Activity: 7
Merit: 0
|
|
September 04, 2023, 02:55:47 PM |
|
Also for checkpoint.txt I just need to paste x coordinates on one line per key and save their private keys? What else do I need to change on the script?
I appreciate it.
Edit, I got it running, I just need to know what to change for addition and subtraction, should I put values in decimal? And why it won't show anything on screen? Lol it just blinks endlessly.
Here is how to tune script as per your needs: 1. xy.txt file must have x and y coordinates in decimal format with a single space between them, as I clarified earlier. 2. In checkpoints.txt file you don't need to save their private keys, why? that is whole point, because we keep starting 100 million or 1 billion pub keys' x coordinates which will work as 2 billions, so it is obvious that their private keys are from 2 to 1 billion or the last 1 billion. 3. There are 3 things that you can change, step size to be subtracted, number of steps, and number of iterations. all these are in numbers not in points. 4. Finally, why script was blinking, is because it was loading checkpoints.txt file, In my case I had 8 GB RAM with around 5.5 GB checkpoints.txt file, on a dual core system. It was taking around half an hour before printing steps.... Be patient, if no error occur, it will start printing within half an hour. I was also able to update the existing code to utilize almost all available CPU in your machine though leaving space for other activities and it's now 10 times faster... from multiprocessing import Pool, cpu_count
Pcurve = 2**256 - 2**32 - 2**9 - 2**8 - 2**7 - 2**6 - 2**4 -1 # The proven prime N=0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 # Number of points in the field Acurve = 0; Bcurve = 7 # These two defines the elliptic curve. y^2 = x^3 + Acurve * x + Bcurve Gx = 55066263022277343669578718895168534326250603453777594175500187360389116729240 Gy = 32670510020758816978083085130507043184471273380659243275938904335757337482424 GPoint = (Gx,Gy) # This is our generator point. Trillions of dif ones possible
def modinv(a, n=Pcurve): lm, hm = 1, 0 low, high = a % n, n while low > 1: ratio = high // low nm, new = hm - lm * ratio, high - low * ratio lm, low, hm, high = nm, new, lm, low return lm % n
def ECadd(a, b): if a == 'O': return b if b == 'O': return a if a == b: LamAdd = ((3 * a[0] * a[0] + Acurve) * modinv(2 * a[1], Pcurve)) % Pcurve else: LamAdd = ((b[1] - a[1]) * modinv(b[0] - a[0], Pcurve)) % Pcurve x = (LamAdd * LamAdd - a[0] - b[0]) % Pcurve y = (LamAdd * (a[0] - x) - a[1]) % Pcurve return (x, y)
def ECsub(a, b): if b == 'O': return a if isinstance(a, str): a = tuple(map(int, a.split())) if isinstance(b, str): b = tuple(map(int, b.split())) neg_b = (b[0], -b[1] % Pcurve) return ECadd(a, neg_b)
def ECmul(a, b): result = 'O' while b > 0: if b % 2 == 1: result = ECadd(result, a) a = ECadd(a, a) b = b // 2 return result
# Read the x, y coordinates from xy.txt with open("xy.txt", "r") as f: x, y = map(int, f.read().strip().split()) point = (x, y)
# Read the checkpoint x-coordinates from checkpoints.txt with open("checkpoints.txt", "r") as f: checkpoints = set(map(int, f.read().strip().split()))
filename_out = "results.txt"
sub_count = 0
# read the last value of j from file try: with open("j_value.txt", "r") as f: last_j_value = int(f.readline()) except: last_j_value = 0
def process_iteration(args): j, last_j_value, point, checkpoints, filename_out = args found_match = False sub_count = 160000000 * j for k in range(100001): if k == 0: pass else: sub_count += 212676479325586539664609129644855 result = ECmul(GPoint, sub_count) result = ECsub(point, result) print(sub_count) if result[0] in checkpoints: with open(filename_out, "w") as f_out: subtractions = sub_count // 212676479325586539664609129644855 f_out.write("{} {} {}".format(result[0], result[1], subtractions)) found_match = True break return found_match
def main(): # Read the x, y coordinates from xy.txt with open("xy.txt", "r") as f: x, y = map(int, f.read().strip().split()) point = (x, y)
# Read the checkpoint x-coordinates from checkpoints.txt with open("checkpoints.txt", "r") as f: checkpoints = set(map(int, f.read().strip().split()))
filename_out = "results.txt"
# read the last value of j from file try: with open("j_value.txt", "r") as f: last_j_value = int(f.readline()) except: last_j_value = 0
# Determine the number of processes to use num_processes = min(cpu_count(), 8) # You can adjust the number of processes
args_list = [(j, last_j_value, point, checkpoints, filename_out) for j in range(last_j_value, 10000001)]
with Pool(processes=num_processes) as pool: results = pool.map(process_iteration, args_list)
if any(results): print("Found match!") else: print("No match found.")
if __name__ == "__main__": main()
All we need now is the checkpoint generation techniques to have enough checkpoints for the code to run even faster and maximize RAM usage You can use ecmultiply_memo to store the results of previously computed point multiplications in the elliptic curve group to compute the multiplication of a point a by an integer b. Memoization helps optimize the code by storing the results of ECmul in the ecmultiply_memo dictionary for a given a and b pair. The montgomery_ladder function takes the scalar k and point P as inputs and returns the result of the point multiplication k * P. It uses a loop that processes each bit of the scalar k and combines point additions and doublings to compute the final result. This algorithm is more efficient than the simple double-and-add method . Also gmpy2 to perform modinv even faster. Something like this : from multiprocessing import Pool, cpu_count import gmpy2
Pcurve = 2**256 - 2**32 - 2**9 - 2**8 - 2**7 - 2**6 - 2**4 - 1 # The proven prime N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 # Number of points in the field Acurve = 0 Bcurve = 7 # These two define the elliptic curve. y^2 = x^3 + Acurve * x + Bcurve Gx = 55066263022277343669578718895168534326250603453777594175500187360389116729240 Gy = 32670510020758816978083085130507043184471273380659243275938904335757337482424 GPoint = (Gx, Gy) # This is our generator point. Trillions of different ones possible
def modinv(a, n=Pcurve): return int(gmpy2.invert(a, n))
ecmultiply_memo = {} # Memoization dictionary for ECmul
def ECadd(a, b): if a == 'O': return b if b == 'O': return a if a == b: LamAdd = ((3 * a[0] * a[0] + Acurve) * modinv(2 * a[1], Pcurve)) % Pcurve else: LamAdd = ((b[1] - a[1]) * modinv(b[0] - a[0], Pcurve)) % Pcurve x = (LamAdd * LamAdd - a[0] - b[0]) % Pcurve y = (LamAdd * (a[0] - x) - a[1]) % Pcurve return (x, y)
def ECsub(a, b): if b == 'O': return a if isinstance(a, str): a = tuple(map(int, a.split())) if isinstance(b, str): b = tuple(map(int, b.split())) neg_b = (b[0], -b[1] % Pcurve) return ECadd(a, neg_b)
def ECmul(a, b): if a in ecmultiply_memo: return ecmultiply_memo[a] result = 'O' while b > 0: if b % 2 == 1: result = ECadd(result, a) a = ECadd(a, a) b = b // 2
ecmultiply_memo[a] = result return result
def montgomery_ladder(k, P): R0, R1 = 'O', P for i in range(k.bit_length()): if k & 1: R0, R1 = ECadd(R0, R1), ECmul(R0, R1) else: R0, R1 = ECmul(R0, R1), ECadd(R0, R1) k >>= 1 return R0
def process_iteration(args): j, last_j_value, point, checkpoints, filename_out = args found_match = False sub_count = 160000000 * j for k in range(100001): if k == 0: pass else: sub_count += 212676479325586539664609129644855 result = montgomery_ladder(sub_count, GPoint) # Use Montgomery ladder result = ECsub(point, result) print(sub_count) if result[0] in checkpoints: with open(filename_out, "w") as f_out: subtractions = sub_count // 212676479325586539664609129644855 f_out.write("{} {} {}".format(result[0], result[1], subtractions)) found_match = True break return found_match
def main(): # Read the x, y coordinates from xy.txt with open("xy.txt", "r") as f: x, y = map(int, f.read().strip().split()) point = (x, y)
# Read the checkpoint x-coordinates from checkpoints.txt with open("checkpoints.txt", "r") as f: checkpoints = set(map(int, f.read().strip().split()))
filename_out = "results.txt"
# read the last value of j from file try: with open("j_value.txt", "r") as f: last_j_value = int(f.readline()) except: last_j_value = 0
# Determine the number of processes to use num_processes = min(cpu_count(), 8) # You can adjust the number of processes
args_list = [(j, last_j_value, point, checkpoints, filename_out) for j in range(last_j_value, 10000001)]
with Pool(processes=num_processes) as pool: results = pool.map(process_iteration, args_list)
if any(results): print("Found match!") else: print("No match found.")
if __name__ == "__main__": main()
While I may not be proficient in mathematical terms, I'm certainly willing to give it a try.
|
|
|
|
nomachine
Member
Offline
Activity: 462
Merit: 24
|
|
September 04, 2023, 03:32:13 PM |
|
Also for checkpoint.txt I just need to paste x coordinates on one line per key and save their private keys? What else do I need to change on the script?
I appreciate it.
Edit, I got it running, I just need to know what to change for addition and subtraction, should I put values in decimal? And why it won't show anything on screen? Lol it just blinks endlessly.
Here is how to tune script as per your needs: 1. xy.txt file must have x and y coordinates in decimal format with a single space between them, as I clarified earlier. 2. In checkpoints.txt file you don't need to save their private keys, why? that is whole point, because we keep starting 100 million or 1 billion pub keys' x coordinates which will work as 2 billions, so it is obvious that their private keys are from 2 to 1 billion or the last 1 billion. 3. There are 3 things that you can change, step size to be subtracted, number of steps, and number of iterations. all these are in numbers not in points. 4. Finally, why script was blinking, is because it was loading checkpoints.txt file, In my case I had 8 GB RAM with around 5.5 GB checkpoints.txt file, on a dual core system. It was taking around half an hour before printing steps.... Be patient, if no error occur, it will start printing within half an hour. I was also able to update the existing code to utilize almost all available CPU in your machine though leaving space for other activities and it's now 10 times faster... from multiprocessing import Pool, cpu_count
Pcurve = 2**256 - 2**32 - 2**9 - 2**8 - 2**7 - 2**6 - 2**4 -1 # The proven prime N=0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 # Number of points in the field Acurve = 0; Bcurve = 7 # These two defines the elliptic curve. y^2 = x^3 + Acurve * x + Bcurve Gx = 55066263022277343669578718895168534326250603453777594175500187360389116729240 Gy = 32670510020758816978083085130507043184471273380659243275938904335757337482424 GPoint = (Gx,Gy) # This is our generator point. Trillions of dif ones possible
def modinv(a, n=Pcurve): lm, hm = 1, 0 low, high = a % n, n while low > 1: ratio = high // low nm, new = hm - lm * ratio, high - low * ratio lm, low, hm, high = nm, new, lm, low return lm % n
def ECadd(a, b): if a == 'O': return b if b == 'O': return a if a == b: LamAdd = ((3 * a[0] * a[0] + Acurve) * modinv(2 * a[1], Pcurve)) % Pcurve else: LamAdd = ((b[1] - a[1]) * modinv(b[0] - a[0], Pcurve)) % Pcurve x = (LamAdd * LamAdd - a[0] - b[0]) % Pcurve y = (LamAdd * (a[0] - x) - a[1]) % Pcurve return (x, y)
def ECsub(a, b): if b == 'O': return a if isinstance(a, str): a = tuple(map(int, a.split())) if isinstance(b, str): b = tuple(map(int, b.split())) neg_b = (b[0], -b[1] % Pcurve) return ECadd(a, neg_b)
def ECmul(a, b): result = 'O' while b > 0: if b % 2 == 1: result = ECadd(result, a) a = ECadd(a, a) b = b // 2 return result
# Read the x, y coordinates from xy.txt with open("xy.txt", "r") as f: x, y = map(int, f.read().strip().split()) point = (x, y)
# Read the checkpoint x-coordinates from checkpoints.txt with open("checkpoints.txt", "r") as f: checkpoints = set(map(int, f.read().strip().split()))
filename_out = "results.txt"
sub_count = 0
# read the last value of j from file try: with open("j_value.txt", "r") as f: last_j_value = int(f.readline()) except: last_j_value = 0
def process_iteration(args): j, last_j_value, point, checkpoints, filename_out = args found_match = False sub_count = 160000000 * j for k in range(100001): if k == 0: pass else: sub_count += 212676479325586539664609129644855 result = ECmul(GPoint, sub_count) result = ECsub(point, result) print(sub_count) if result[0] in checkpoints: with open(filename_out, "w") as f_out: subtractions = sub_count // 212676479325586539664609129644855 f_out.write("{} {} {}".format(result[0], result[1], subtractions)) found_match = True break return found_match
def main(): # Read the x, y coordinates from xy.txt with open("xy.txt", "r") as f: x, y = map(int, f.read().strip().split()) point = (x, y)
# Read the checkpoint x-coordinates from checkpoints.txt with open("checkpoints.txt", "r") as f: checkpoints = set(map(int, f.read().strip().split()))
filename_out = "results.txt"
# read the last value of j from file try: with open("j_value.txt", "r") as f: last_j_value = int(f.readline()) except: last_j_value = 0
# Determine the number of processes to use num_processes = min(cpu_count(), 8) # You can adjust the number of processes
args_list = [(j, last_j_value, point, checkpoints, filename_out) for j in range(last_j_value, 10000001)]
with Pool(processes=num_processes) as pool: results = pool.map(process_iteration, args_list)
if any(results): print("Found match!") else: print("No match found.")
if __name__ == "__main__": main()
All we need now is the checkpoint generation techniques to have enough checkpoints for the code to run even faster and maximize RAM usage You can use ecmultiply_memo to store the results of previously computed point multiplications in the elliptic curve group to compute the multiplication of a point a by an integer b. Memoization helps optimize the code by storing the results of ECmul in the ecmultiply_memo dictionary for a given a and b pair. The montgomery_ladder function takes the scalar k and point P as inputs and returns the result of the point multiplication k * P. It uses a loop that processes each bit of the scalar k and combines point additions and doublings to compute the final result. This algorithm is more efficient than the simple double-and-add method . Also gmpy2 to perform modinv even faster. Something like this : from multiprocessing import Pool, cpu_count import gmpy2
Pcurve = 2**256 - 2**32 - 2**9 - 2**8 - 2**7 - 2**6 - 2**4 - 1 # The proven prime N = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 # Number of points in the field Acurve = 0 Bcurve = 7 # These two define the elliptic curve. y^2 = x^3 + Acurve * x + Bcurve Gx = 55066263022277343669578718895168534326250603453777594175500187360389116729240 Gy = 32670510020758816978083085130507043184471273380659243275938904335757337482424 GPoint = (Gx, Gy) # This is our generator point. Trillions of different ones possible
def modinv(a, n=Pcurve): return int(gmpy2.invert(a, n))
ecmultiply_memo = {} # Memoization dictionary for ECmul
def ECadd(a, b): if a == 'O': return b if b == 'O': return a if a == b: LamAdd = ((3 * a[0] * a[0] + Acurve) * modinv(2 * a[1], Pcurve)) % Pcurve else: LamAdd = ((b[1] - a[1]) * modinv(b[0] - a[0], Pcurve)) % Pcurve x = (LamAdd * LamAdd - a[0] - b[0]) % Pcurve y = (LamAdd * (a[0] - x) - a[1]) % Pcurve return (x, y)
def ECsub(a, b): if b == 'O': return a if isinstance(a, str): a = tuple(map(int, a.split())) if isinstance(b, str): b = tuple(map(int, b.split())) neg_b = (b[0], -b[1] % Pcurve) return ECadd(a, neg_b)
def ECmul(a, b): if a in ecmultiply_memo: return ecmultiply_memo[a] result = 'O' while b > 0: if b % 2 == 1: result = ECadd(result, a) a = ECadd(a, a) b = b // 2
ecmultiply_memo[a] = result return result
def montgomery_ladder(k, P): R0, R1 = 'O', P for i in range(k.bit_length()): if k & 1: R0, R1 = ECadd(R0, R1), ECmul(R0, R1) else: R0, R1 = ECmul(R0, R1), ECadd(R0, R1) k >>= 1 return R0
def process_iteration(args): j, last_j_value, point, checkpoints, filename_out = args found_match = False sub_count = 160000000 * j for k in range(100001): if k == 0: pass else: sub_count += 212676479325586539664609129644855 result = montgomery_ladder(sub_count, GPoint) # Use Montgomery ladder result = ECsub(point, result) print(sub_count) if result[0] in checkpoints: with open(filename_out, "w") as f_out: subtractions = sub_count // 212676479325586539664609129644855 f_out.write("{} {} {}".format(result[0], result[1], subtractions)) found_match = True break return found_match
def main(): # Read the x, y coordinates from xy.txt with open("xy.txt", "r") as f: x, y = map(int, f.read().strip().split()) point = (x, y)
# Read the checkpoint x-coordinates from checkpoints.txt with open("checkpoints.txt", "r") as f: checkpoints = set(map(int, f.read().strip().split()))
filename_out = "results.txt"
# read the last value of j from file try: with open("j_value.txt", "r") as f: last_j_value = int(f.readline()) except: last_j_value = 0
# Determine the number of processes to use num_processes = min(cpu_count(), 8) # You can adjust the number of processes
args_list = [(j, last_j_value, point, checkpoints, filename_out) for j in range(last_j_value, 10000001)]
with Pool(processes=num_processes) as pool: results = pool.map(process_iteration, args_list)
if any(results): print("Found match!") else: print("No match found.")
if __name__ == "__main__": main()
While I may not be proficient in mathematical terms, I'm certainly willing to give it a try. This is just an example of how I imagine the calculations.Adjust to suit your needs. So far I have not been able to mathematically solve any Puzzle. It is unsolvable. There are no patterns or repetitions. Only brute force method can do something or pure luck of random generator. There are too many unknowns in the equation. And the technology we have is insufficient.
|
bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8
|
|
|
zahid888
Member
Offline
Activity: 272
Merit: 20
the right steps towerds the goal
|
|
September 04, 2023, 05:18:46 PM |
|
1 - Convert the private key from hex to bytes 00000000000000000000000000000000000000000000000354d62e5f7a0d2eb2 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03T\xd6._z\r.\xb2'
2 - Create a signing key from the private key bytes using the SECP256k1 elliptic curve <ecdsa.keys.SigningKey object at 0x000002D447E14400>
3 - Get the corresponding public key 02b21a6b1590b145841a0dabbe71ea01e29ed60f0e468cff36445a9c92eb3a6375 VerifyingKey.from_string(b'\x02\xb2\x1ak\x15\x90\xb1E\x84\x1a\r\xab\xbeq\xea\x01\xe2\x9e\xd6\x0f\x0eF\x8c\xff6DZ\x9c\x92\xeb:cu', SECP256k1, sha1)
4 - Serialize the public key in compressed format (33 bytes) b'\x02\xb2\x1ak\x15\x90\xb1E\x84\x1a\r\xab\xbeq\xea\x01\xe2\x9e\xd6\x0f\x0eF\x8c\xff6DZ\x9c\x92\xeb:cu' 02b21a6b1590b145841a0dabbe71ea01e29ed60f0e468cff36445a9c92eb3a6375
5 - Calculate the SHA-256 hash of the public key b'\t\xb4\x87?D\'I\xef>\x86\xc7\x1d\x92\x86\xb1"\xa9\xdd\xf9v%\xa0\x03X\x88\xfb\x96%F\x0e\'\x16' 09b4873f442749ef3e86c71d9286b122a9ddf97625a0035888fb9625460e2716
6 - Calculate the RIPEMD-160 hash of the SHA-256 hash <ripemd160 HASH object @ 0x000002D4477BF690> b' \xd4Zjv%3BR\xc81\x8a\x87\xed053\xc1\xc7\xbb' 20d45a6a7625334252c8318a87ed303533c1c7bb
7 - Add the version byte (0x00 for mainnet) to the RIPEMD-160 hash b'\x00'
8 - Extended RIPEMD-160 Hash b'\x00 \xd4Zjv%3BR\xc81\x8a\x87\xed053\xc1\xc7\xbb' 0020d45a6a7625334252c8318a87ed303533c1c7bb
9 - Calculate the double SHA-256 checksum b'\x01\x02l\xf90\xf6N\x8f\xeb\xca\xc8\xc2\x15\xd9Q\xb8i))\xb0\xce:\xb1\xba\x9e\xa4\xa1\x07_\x05\xe2\xa2' b'\x01\x02l\xf9'
10 - Checksum: 01026cf9
11 - Append the checksum to the extended RIPEMD-160 hash b'\x00 \xd4Zjv%3BR\xc81\x8a\x87\xed053\xc1\xc7\xbb\x01\x02l\xf9' 0020d45a6a7625334252c8318a87ed303533c1c7bb01026cf9
12 - Address (with checksum) 0020d45a6a7625334252c8318a87ed303533c1c7bb01026cf9
13 - Convert the bytes to a base58-encoded Bitcoin address 13zb1hQbWVnN3ag9GNS2vCraT8PQJDjVdr
provide an alternative, more straightforward method, if available instead of this ?
|
1BGvwggxfCaHGykKrVXX7fk8GYaLQpeixA
|
|
|
citb0in
|
|
September 04, 2023, 07:23:27 PM |
|
offtopic
|
_______. ______ __ ______ ______ __ ___ .______ ______ ______ __ ______ .______ _______ / | / __ \ | | / __ \ / || |/ / | _ \ / __ \ / __ \ | | / __ \ | _ \ / _____| | (----`| | | | | | | | | | | ,----'| ' / | |_) | | | | | | | | | | | | | | | | |_) | | | __ \ \ | | | | | | | | | | | | | < | ___/ | | | | | | | | | | | | | | | / | | |_ | .----) | | `--' | | `----.| `--' | __| `----.| . \ | | | `--' | | `--' | | `----.__| `--' | | |\ \----.| |__| | |_______/ \______/ |_______| \______/ (__)\______||__|\__\ | _| \______/ \______/ |_______(__)\______/ | _| `._____| \______| | 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. |
|
|
|
|
digaran
Copper Member
Hero Member
Offline
Activity: 1330
Merit: 899
🖤😏
|
|
September 04, 2023, 07:28:42 PM |
|
I see a not very smart person who does not understand either mathematics or modular mathematics, but with all this with a crown on his head. your every post highlights your low level of intelligence.
What took you so long to realize this? I have been posting for more than 8, 9 months, and you just figured I'm uneducated with no knowledge of math and EC. 🤣 Off topic, but still. Guys, where diagran is trying to take you does not make any sense.
Not really off topic, if someone like me is misguided and is dragging others on to the wrong path, it's good for all to warn people. I just wonder who are these Guys you mentioned? Are they mentally retarded to a level where they can't figure out on their own that I'm useless and my posts are all garbage? there is no difference to look for 1 key in range 2^130 or 4 in the range 2^128. in terms of the time spent by the currently known tools, you will spend the same amount of time.
The post you quoted has nothing to do with what you said, I don't know where you got 2^130 or 2^128, 1 key, 4 key, what are those? You see, usually when I communicate with smart people, they immediately realize I know nothing, and since they are smart with high levels of intelligence, they'd try to correct my mistakes and then teach me the right stuff, because they enjoy teaching other people, it also increases their knowledge after sharing what they already know. But a butthurt who thinks he knows better than everyone else hides behind a newbie account, insulting others, this is their joy, it also increases their butthurt pain and burn. ( this is how the universe works, action=reaction, share knowledge, gain knowledge, share/help with money, gain more money, spread hatred, absorb hatred ),
Where was I wrong exactly, implying my lack of understanding about math/ECC? Show me, then lets fix my mistakes together. ~digaran
|
🖤😏
|
|
|
seoincorporation
Legendary
Offline
Activity: 3304
Merit: 3094
|
|
September 04, 2023, 11:13:37 PM |
|
1 - Convert the private key from hex to bytes 00000000000000000000000000000000000000000000000354d62e5f7a0d2eb2 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03T\xd6._z\r.\xb2'
...
8 - Extended RIPEMD-160 Hash b'\x00 \xd4Zjv%3BR\xc81\x8a\x87\xed053\xc1\xc7\xbb' 0020d45a6a7625334252c8318a87ed303533c1c7bb
...
13 - Convert the bytes to a base58-encoded Bitcoin address 13zb1hQbWVnN3ag9GNS2vCraT8PQJDjVdr
provide an alternative, more straightforward method, if available instead of this ?
Your process to generate the address from the hex private key is right, but when you are attacking private keys with brute force there are tons of ways to do it. People do it the same way as you because they bruteforce the Hex Pk, ...000001, ....000002, etc. But if you want to know an alternate method let me explain one of my favorites: You can start from the Address: 13zb1hQbWVnN3ag9GNS2vCraT8PQJDjVdr and get the RIPEMD-160 (20d45a6a7625334252c8318a87ed303533c1c7bb). Sites like privatekeys.pw provide that Hash 160 as you can see in the next link: https://privatekeys.pw/address/bitcoin/13zb1hQbWVnN3ag9GNS2vCraT8PQJDjVdrAnd if you want to get that RIPEMD-160 code by yourself you can use the next python script. python3 -c "import binascii, hashlib, base58; hash160 = binascii.hexlify(base58.b58decode_check(b'13zb1hQbWVnN3ag9GNS2vCraT8PQJDjVdr')).decode()[2:]; print(hash160)" Once you have the hash160 you can use tools like brainflayer to get the Private key from the hash160. I want to be clear, is not the best way but is just a different way to do it.
|
|
|
|
nomachine
Member
Offline
Activity: 462
Merit: 24
|
|
September 05, 2023, 02:10:52 PM Last edit: September 05, 2023, 03:26:48 PM by nomachine |
|
1 - Convert the private key from hex to bytes 00000000000000000000000000000000000000000000000354d62e5f7a0d2eb2 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03T\xd6._z\r.\xb2'
2 - Create a signing key from the private key bytes using the SECP256k1 elliptic curve <ecdsa.keys.SigningKey object at 0x000002D447E14400>
3 - Get the corresponding public key 02b21a6b1590b145841a0dabbe71ea01e29ed60f0e468cff36445a9c92eb3a6375 VerifyingKey.from_string(b'\x02\xb2\x1ak\x15\x90\xb1E\x84\x1a\r\xab\xbeq\xea\x01\xe2\x9e\xd6\x0f\x0eF\x8c\xff6DZ\x9c\x92\xeb:cu', SECP256k1, sha1)
4 - Serialize the public key in compressed format (33 bytes) b'\x02\xb2\x1ak\x15\x90\xb1E\x84\x1a\r\xab\xbeq\xea\x01\xe2\x9e\xd6\x0f\x0eF\x8c\xff6DZ\x9c\x92\xeb:cu' 02b21a6b1590b145841a0dabbe71ea01e29ed60f0e468cff36445a9c92eb3a6375
5 - Calculate the SHA-256 hash of the public key b'\t\xb4\x87?D\'I\xef>\x86\xc7\x1d\x92\x86\xb1"\xa9\xdd\xf9v%\xa0\x03X\x88\xfb\x96%F\x0e\'\x16' 09b4873f442749ef3e86c71d9286b122a9ddf97625a0035888fb9625460e2716
6 - Calculate the RIPEMD-160 hash of the SHA-256 hash <ripemd160 HASH object @ 0x000002D4477BF690> b' \xd4Zjv%3BR\xc81\x8a\x87\xed053\xc1\xc7\xbb' 20d45a6a7625334252c8318a87ed303533c1c7bb
7 - Add the version byte (0x00 for mainnet) to the RIPEMD-160 hash b'\x00'
8 - Extended RIPEMD-160 Hash b'\x00 \xd4Zjv%3BR\xc81\x8a\x87\xed053\xc1\xc7\xbb' 0020d45a6a7625334252c8318a87ed303533c1c7bb
9 - Calculate the double SHA-256 checksum b'\x01\x02l\xf90\xf6N\x8f\xeb\xca\xc8\xc2\x15\xd9Q\xb8i))\xb0\xce:\xb1\xba\x9e\xa4\xa1\x07_\x05\xe2\xa2' b'\x01\x02l\xf9'
10 - Checksum: 01026cf9
11 - Append the checksum to the extended RIPEMD-160 hash b'\x00 \xd4Zjv%3BR\xc81\x8a\x87\xed053\xc1\xc7\xbb\x01\x02l\xf9' 0020d45a6a7625334252c8318a87ed303533c1c7bb01026cf9
12 - Address (with checksum) 0020d45a6a7625334252c8318a87ed303533c1c7bb01026cf9
13 - Convert the bytes to a base58-encoded Bitcoin address 13zb1hQbWVnN3ag9GNS2vCraT8PQJDjVdr
provide an alternative, more straightforward method, if available instead of this ?
Translated into Python3 : import hashlib import ecdsa import base58
# Private key in hexadecimal format private_key_hex = "00000000000000000000000000000000000000000000000354d62e5f7a0d2eb2"
# Convert private key from hex to bytes private_key_bytes = bytes.fromhex(private_key_hex)
# Create a signing key from the private key bytes using SECP256k1 curve signing_key = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)
# Get the corresponding public key in compressed format compressed_public_key = signing_key.get_verifying_key().to_string("compressed")
# Calculate the SHA-256 hash of the compressed public key sha256_hash = hashlib.sha256(compressed_public_key).digest()
# Calculate the RIPEMD-160 hash of the SHA-256 hash ripemd160_hash = hashlib.new('ripemd160', sha256_hash).digest()
# Add the version byte (0x00 for mainnet) to the RIPEMD-160 hash extended_ripe160_hash = b'\x00' + ripemd160_hash
# Calculate the double SHA-256 checksum checksum = hashlib.sha256(hashlib.sha256(extended_ripe160_hash).digest()).digest()[:4]
# Append the checksum to the extended RIPEMD-160 hash address_bytes = extended_ripe160_hash + checksum
# Convert the bytes to a base58-encoded Bitcoin address bitcoin_address = base58.b58encode(address_bytes).decode()
print("Bitcoin Address:", bitcoin_address)
The process of deriving a Bitcoin address from a private key involves several cryptographic operations and encoding steps, so there isn't a significantly shorter method to achieve this without skipping any essential steps. While it may be possible to write more concise code or create a custom function to encapsulate the process, the core steps themselves are fundamental to Bitcoin address generation. So there is no way to speed up more through the code. Unfortunately. p.s. You can use import secp256k1 as ice https://github.com/iceland2k14/secp256k1(You must have this function in the same folder where the command is executed for it to work.) This is the a custom function which encapsulate the process above : import secp256k1 as ice
private_key_hex = "00000000000000000000000000000000000000000000000354d62e5f7a0d2eb2" dec = int(private_key_hex, 16) bitcoin_address = ice.privatekey_to_address(0, True, dec) print("Bitcoin Address:", bitcoin_address)
or: python3 -c "import secp256k1 as ice; private_key_hex = '00000000000000000000000000000000000000000000000354d62e5f7a0d2eb2'; dec = int(private_key_hex, 16); bitcoin_address = ice.privatekey_to_address(0, True, dec); print('Bitcoin Address:', bitcoin_address)"
Bitcoin Address: 13zb1hQbWVnN3ag9GNS2vCraT8PQJDjVdr But this method is not much faster for me. It all depends on how it is used.
|
bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8
|
|
|
digaran
Copper Member
Hero Member
Offline
Activity: 1330
Merit: 899
🖤😏
|
|
September 05, 2023, 04:16:10 PM Last edit: September 06, 2023, 02:42:40 PM by digaran |
|
provide an alternative, more straightforward method, if available instead of this ?
Skip steps 7 up to 13.
Nothing going on around these woods, lets make up new methods and try them to see if one of them works, here is something to work on. End range : 400000000000000000000000000000000 Fake #130 key : 2c54a14a9556f03272bac1cd222396b57 Subtract 130 from end range : #2 13ab5eb56aa90fcd8d453e32dddc694a9 Subtract above #2 from 130 = #3 : 18a942952aade064e575839a44472d6ae Subtract #3 from #2 = #4 : 4fde3dfc004d09758304567666ac4205 Multiply #4 by *4 = #5 : 13f78f7f0013425d60c1159d99ab10814 Subtract #5 from #2 = #6 : 4c30c9956a328fd37bd76abbcea736b Figure out the rest and good luck. 😉
|
🖤😏
|
|
|
nomachine
Member
Offline
Activity: 462
Merit: 24
|
|
September 06, 2023, 08:36:08 PM |
|
Nothing going on around these wood
We play with numbers with at least 20 decimal places here. If you could make one Giga (10^9) guesses per second, it would take: 10^20 / 10^9 = 10^11 seconds This is equivalent to roughly 3.2 million years. So, even with an incredibly fast computer making a Giga guesses per second, it would take millions of years to guess a 20-decimal-place number. We'd better start practicing crystal ball gazing to guess what the correct range of Puzzle 66 is
|
bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8
|
|
|
modma
Newbie
Offline
Activity: 10
Merit: 0
|
|
September 06, 2023, 10:45:41 PM |
|
Nothing going on around these wood
We'd better start practicing crystal ball gazing to guess what the correct range of Puzzle 66 is first sensible thought in last 10+ pages
|
|
|
|
citb0in
|
|
September 07, 2023, 05:23:36 AM |
|
here's a fix I wrote months ago and requested a pull for that allows you to run icelands' library from any folder.
|
_______. ______ __ ______ ______ __ ___ .______ ______ ______ __ ______ .______ _______ / | / __ \ | | / __ \ / || |/ / | _ \ / __ \ / __ \ | | / __ \ | _ \ / _____| | (----`| | | | | | | | | | | ,----'| ' / | |_) | | | | | | | | | | | | | | | | |_) | | | __ \ \ | | | | | | | | | | | | | < | ___/ | | | | | | | | | | | | | | | / | | |_ | .----) | | `--' | | `----.| `--' | __| `----.| . \ | | | `--' | | `--' | | `----.__| `--' | | |\ \----.| |__| | |_______/ \______/ |_______| \______/ (__)\______||__|\__\ | _| \______/ \______/ |_______(__)\______/ | _| `._____| \______| | 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. |
|
|
|
|
digaran
Copper Member
Hero Member
Offline
Activity: 1330
Merit: 899
🖤😏
|
|
September 07, 2023, 07:26:06 AM |
|
Nothing going on around these wood
We play with numbers with at least 20 decimal places here. If you could make one Giga (10^9) guesses per second, it would take: 10^20 / 10^9 = 10^11 seconds This is equivalent to roughly 3.2 million years. So, even with an incredibly fast computer making a Giga guesses per second, it would take millions of years to guess a 20-decimal-place number. We'd better start practicing crystal ball gazing to guess what the correct range of Puzzle 66 is According to my crystal ball, we'd only need 2339 years to completely scan the entire 66 bit range. Note that my crystal ball is uneducated and generates insensible results.😉
|
🖤😏
|
|
|
nomachine
Member
Offline
Activity: 462
Merit: 24
|
|
September 07, 2023, 07:39:48 AM |
|
here's a fix I wrote months ago and requested a pull for that allows you to run icelands' library from any folder. Thanks for the update.
|
bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8
|
|
|
ing1996
Newbie
Offline
Activity: 8
Merit: 0
|
|
September 07, 2023, 01:39:21 PM Last edit: September 07, 2023, 08:27:59 PM by Mr. Big |
|
Hi, so i found 2 address similar 11 digits of hash160 in extraction of bit 130 that means if you scan on this range and have the private key of those one of two addresses we will split the 13 BTC , 1st 1AoNf67iZUmz1Ck9eefUfTzWQJMN5pgcPG 02113ba90a97c020ade0f3d8d0369981a723fe2bc4352815df22dd3eafae13c5a5 6b7e582a29a549cc60b591279a963f02eff02f99 pk:00000000000000000000000000000000000de4cfcadfc034c963dd053d719e88 address to search in :116 bit range 1AoNf67iZrwMSYPTDbk3Sh1yXJCARQbD7a 039d0a0241abe2411f64b4f6d29f2e1b6c837b26b6bdded577c3fc93574d3d735c 6b7e582a29a7601b79761f9f153c300c3d988231 range: 804cfcadfc034c963dd053d719e88:fffffcadfc034c963dd053d719e88 2nd 1PtStkm2bWKryHVduVjciPUxVx9UeDcCXG 02dc52ba09b16bc5cbd25aca7c82dd924f81cd31ecf29ecb264fa2cc45393728b9 fb0d9859584e68c24c1698eea4d05d2822fe4b70 pk: ad0f6ba584b355089cf6ce9cc9774 address to search in 116 bit range 1PtStkm2bLM7EK7g1rnTLBxu6aLouVuULV 03ef06cec3b3e35f68ba78618e5a5cf8663cc1a3b685dcfd197c1c0030530b1293 fb0d9859584d782df3fe652d2da5a21c30f137f9 range: 804cfcadfc034c963dd053d719e88:fffffcadfc034c963dd053d719e88 if the pk found of one of those address we will split the prize. they have the same 11 digits of hash160 that means maybe 90 pourcent is in that range up, anyone interessing its same 11 digits hash160 so who can scan this range 116 and split the 13 btc ? Hello! Can you find out how you get addresses with the same initial prefixes in which you say are in the same range ?!, what you do, subtract or add, can you explain! I saw your last post where you also found the same starting address prefixes which are both in the #66 range. Even if they don't matter, just show how you calculate similar addresses and get their private key as well, show here!
1 - Convert the private key from hex to bytes 00000000000000000000000000000000000000000000000354d62e5f7a0d2eb2 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03T\xd6._z\r.\xb2'
2 - Create a signing key from the private key bytes using the SECP256k1 elliptic curve <ecdsa.keys.SigningKey object at 0x000002D447E14400>
3 - Get the corresponding public key 02b21a6b1590b145841a0dabbe71ea01e29ed60f0e468cff36445a9c92eb3a6375 VerifyingKey.from_string(b'\x02\xb2\x1ak\x15\x90\xb1E\x84\x1a\r\xab\xbeq\xea\x01\xe2\x9e\xd6\x0f\x0eF\x8c\xff6DZ\x9c\x92\xeb:cu', SECP256k1, sha1)
4 - Serialize the public key in compressed format (33 bytes) b'\x02\xb2\x1ak\x15\x90\xb1E\x84\x1a\r\xab\xbeq\xea\x01\xe2\x9e\xd6\x0f\x0eF\x8c\xff6DZ\x9c\x92\xeb:cu' 02b21a6b1590b145841a0dabbe71ea01e29ed60f0e468cff36445a9c92eb3a6375
5 - Calculate the SHA-256 hash of the public key b'\t\xb4\x87?D\'I\xef>\x86\xc7\x1d\x92\x86\xb1"\xa9\xdd\xf9v%\xa0\x03X\x88\xfb\x96%F\x0e\'\x16' 09b4873f442749ef3e86c71d9286b122a9ddf97625a0035888fb9625460e2716
6 - Calculate the RIPEMD-160 hash of the SHA-256 hash <ripemd160 HASH object @ 0x000002D4477BF690> b' \xd4Zjv%3BR\xc81\x8a\x87\xed053\xc1\xc7\xbb' 20d45a6a7625334252c8318a87ed303533c1c7bb
7 - Add the version byte (0x00 for mainnet) to the RIPEMD-160 hash b'\x00'
8 - Extended RIPEMD-160 Hash b'\x00 \xd4Zjv%3BR\xc81\x8a\x87\xed053\xc1\xc7\xbb' 0020d45a6a7625334252c8318a87ed303533c1c7bb
9 - Calculate the double SHA-256 checksum b'\x01\x02l\xf90\xf6N\x8f\xeb\xca\xc8\xc2\x15\xd9Q\xb8i))\xb0\xce:\xb1\xba\x9e\xa4\xa1\x07_\x05\xe2\xa2' b'\x01\x02l\xf9'
10 - Checksum: 01026cf9
11 - Append the checksum to the extended RIPEMD-160 hash b'\x00 \xd4Zjv%3BR\xc81\x8a\x87\xed053\xc1\xc7\xbb\x01\x02l\xf9' 0020d45a6a7625334252c8318a87ed303533c1c7bb01026cf9
12 - Address (with checksum) 0020d45a6a7625334252c8318a87ed303533c1c7bb01026cf9
13 - Convert the bytes to a base58-encoded Bitcoin address 13zb1hQbWVnN3ag9GNS2vCraT8PQJDjVdr
provide an alternative, more straightforward method, if available instead of this ?
bro, how did you get the private key with the address 13ZB1HQBWNN3AG9GNS2VCRAT8PQJDJVDR, or did you happen to have it?If you compare it with the address #66 of the puzzle, then they have the same prefixes at the beginning of the address, also in the hash160. If you compare by range that this one and that one, both are in the #66 range. Maybe kalos15btc is right about something?!.
1 - Convert the private key from hex to bytes 00000000000000000000000000000000000000000000000354d62e5f7a0d2eb2 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03T\xd6._z\r.\xb2'
2 - Create a signing key from the private key bytes using the SECP256k1 elliptic curve <ecdsa.keys.SigningKey object at 0x000002D447E14400>
3 - Get the corresponding public key 02b21a6b1590b145841a0dabbe71ea01e29ed60f0e468cff36445a9c92eb3a6375 VerifyingKey.from_string(b'\x02\xb2\x1ak\x15\x90\xb1E\x84\x1a\r\xab\xbeq\xea\x01\xe2\x9e\xd6\x0f\x0eF\x8c\xff6DZ\x9c\x92\xeb:cu', SECP256k1, sha1)
4 - Serialize the public key in compressed format (33 bytes) b'\x02\xb2\x1ak\x15\x90\xb1E\x84\x1a\r\xab\xbeq\xea\x01\xe2\x9e\xd6\x0f\x0eF\x8c\xff6DZ\x9c\x92\xeb:cu' 02b21a6b1590b145841a0dabbe71ea01e29ed60f0e468cff36445a9c92eb3a6375
5 - Calculate the SHA-256 hash of the public key b'\t\xb4\x87?D\'I\xef>\x86\xc7\x1d\x92\x86\xb1"\xa9\xdd\xf9v%\xa0\x03X\x88\xfb\x96%F\x0e\'\x16' 09b4873f442749ef3e86c71d9286b122a9ddf97625a0035888fb9625460e2716
6 - Calculate the RIPEMD-160 hash of the SHA-256 hash <ripemd160 HASH object @ 0x000002D4477BF690> b' \xd4Zjv%3BR\xc81\x8a\x87\xed053\xc1\xc7\xbb' 20d45a6a7625334252c8318a87ed303533c1c7bb
7 - Add the version byte (0x00 for mainnet) to the RIPEMD-160 hash b'\x00'
8 - Extended RIPEMD-160 Hash b'\x00 \xd4Zjv%3BR\xc81\x8a\x87\xed053\xc1\xc7\xbb' 0020d45a6a7625334252c8318a87ed303533c1c7bb
9 - Calculate the double SHA-256 checksum b'\x01\x02l\xf90\xf6N\x8f\xeb\xca\xc8\xc2\x15\xd9Q\xb8i))\xb0\xce:\xb1\xba\x9e\xa4\xa1\x07_\x05\xe2\xa2' b'\x01\x02l\xf9'
10 - Checksum: 01026cf9
11 - Append the checksum to the extended RIPEMD-160 hash b'\x00 \xd4Zjv%3BR\xc81\x8a\x87\xed053\xc1\xc7\xbb\x01\x02l\xf9' 0020d45a6a7625334252c8318a87ed303533c1c7bb01026cf9
12 - Address (with checksum) 0020d45a6a7625334252c8318a87ed303533c1c7bb01026cf9
13 - Convert the bytes to a base58-encoded Bitcoin address 13zb1hQbWVnN3ag9GNS2vCraT8PQJDjVdr
provide an alternative, more straightforward method, if available instead of this ?
bro, how did you get the private key with the address 13ZB1HQBWNN3AG9GNS2VCRAT8PQJDJVDR, or did you happen to have it?If you compare it with the address #66 of the puzzle, then they have the same prefixes at the beginning of the address, also in the hash160. If you compare by range that this one and that one, both are in the #66 range. Maybe kalos15btc is right about something?!. I understand how it works, you don't have to answer.
|
|
|
|
tptkimikaze
Newbie
Offline
Activity: 25
Merit: 2
|
|
September 08, 2023, 04:46:12 AM Last edit: September 09, 2023, 10:47:06 AM by hilariousandco |
|
Anybody here familiar with Kangaroo? I have 1 stupid question. If let's say I put 1 million public address to search for private key and there's only 1 valid public address that fit the range. Will it take much more longer time to find the valid public key to get the private key? I tried just now with 100,000 public address, but the average time to solve shown unchanged.
I tried to put 1001 key with 1000 false public key and 1 puzzle 35 key. Why kangaroo can't solve it? Does that mean we can only put 1 public key at a time?
Looks like those who is searching for #66 are at 354d range, even myself also search at the same range. If my research correct, #66 range should be in between 354df - 358ae. Even this range will take ages to scan. LoL.
|
|
|
|
vneos
Newbie
Offline
Activity: 22
Merit: 8
|
|
September 08, 2023, 06:55:33 AM |
|
Looks like those who is searching for #66 are at 354d range, even myself also search at the same range. If my research correct, #66 range should be in between 354df - 358ae. Even this range will take ages to scan. LoL.
How did you come to this conclusion?
|
|
|
|
digaran
Copper Member
Hero Member
Offline
Activity: 1330
Merit: 899
🖤😏
|
|
September 08, 2023, 07:00:56 AM |
|
Anybody here familiar with Kangaroo? I have 1 stupid question. If let's say I put 1 million public address to search for private key and there's only 1 valid public address that fit the range. Will it take much more longer time to find the valid public key to get the private key? I tried just now with 100,000 public address, but the average time to solve shown unchanged.
I tried to put 1001 key with 1000 false public key and 1 puzzle 35 key. Why kangaroo can't solve it? Does that mean we can only put 1 public key at a time?
You can't find low range keys with kangaroo, 35 bit total range is less than 35 billion keys, I have tried with low ranges, my kangaroos start dying very fast, I can't even say goodbye. 🤣 I think more public keys you place in target file more you lose speed, but the speed reduction is insignificant even with few thousands less or more keys.
|
🖤😏
|
|
|
tptkimikaze
Newbie
Offline
Activity: 25
Merit: 2
|
|
September 08, 2023, 07:09:21 AM Last edit: September 08, 2023, 01:55:25 PM by hilariousandco |
|
Looks like those who is searching for #66 are at 354d range, even myself also search at the same range. If my research correct, #66 range should be in between 354df - 358ae. Even this range will take ages to scan. LoL.
How did you come to this conclusion? By breaking down bits and some bits combination. Maybe just some wild guessing and not sure if I am correct because I spots seems like some obvious pattern. I hope someone can find it on this range thought even if I don't get it. If the results were in this range, then I can use the same methods to proceed to 67. Unfortunately, the most lowest I can go is only on current range. I guess it boost some morale maybe I am right when I saw zahid8888 post PK start at 354d and have similarity on #66 Hash160. Anybody here familiar with Kangaroo? I have 1 stupid question. If let's say I put 1 million public address to search for private key and there's only 1 valid public address that fit the range. Will it take much more longer time to find the valid public key to get the private key? I tried just now with 100,000 public address, but the average time to solve shown unchanged.
I tried to put 1001 key with 1000 false public key and 1 puzzle 35 key. Why kangaroo can't solve it? Does that mean we can only put 1 public key at a time?
You can't find low range keys with kangaroo, 35 bit total range is less than 35 billion keys, I have tried with low ranges, my kangaroos start dying very fast, I can't even say goodbye. 🤣 I think more public keys you place in target file more you lose speed, but the speed reduction is insignificant even with few thousands less or more keys. Exactly. It dead kangaroo almost immediately when I start. I am just trying to figure out if Kangaroo able to search lots of fake key with 1 valid key at once because I have some idea to lower #130 bits down but need to do a lot of manual works. Anybody here familiar with Kangaroo? I have 1 stupid question. If let's say I put 1 million public address to search for private key and there's only 1 valid public address that fit the range. Will it take much more longer time to find the valid public key to get the private key? I tried just now with 100,000 public address, but the average time to solve shown unchanged.
I tried to put 1001 key with 1000 false public key and 1 puzzle 35 key. Why kangaroo can't solve it? Does that mean we can only put 1 public key at a time?
You can't find low range keys with kangaroo, 35 bit total range is less than 35 billion keys, I have tried with low ranges, my kangaroos start dying very fast, I can't even say goodbye. 🤣 I think more public keys you place in target file more you lose speed, but the speed reduction is insignificant even with few thousands less or more keys. I think it's quite significant but I haven't try till it solve. Will try later. For example I try with on #65 keys, it solve in less than 3 minutes. But when I put it with 100 fake keys and 1 real key, I run for 20 mins just now and it still didn't solve. I will try later to see how long it takes with 100 and 1000 keys with only 1 real key. Furthermore, I try with #64 keys while the range I set it on #65, it seems like kangaroo unable to solve it. Update on 64. When I try to solve 64 Public Key but range setting at 65, it spends almost 5 times more with a correct range provided to search. Update: I don't think Kangaroo able to solve multiple address. Now I am trying to merge save file and see if it able to resolve.
|
|
|
|
kalos15btc
Jr. Member
Offline
Activity: 50
Merit: 1
|
|
September 08, 2023, 12:55:38 PM |
|
Looks like those who is searching for #66 are at 354d range, even myself also search at the same range. If my research correct, #66 range should be in between 354df - 358ae. Even this range will take ages to scan. LoL.
How did you come to this conclusion? By breaking down bits and some bits combination. Maybe just some wild guessing and not sure if I am correct because I spots seems like some obvious pattern. I hope someone can find it on this range thought even if I don't get it. If the results were in this range, then I can use the same methods to proceed to 67. Unfortunately, the most lowest I can go is only on current range. I guess it boost some morale maybe I am right when I saw zahid8888 post PK start at 354d and have similarity on #66 Hash160. thats what i said exactly, im substracting from 130 lower bit range and i get those address that start with same 14 digits of hash160 that means that address in that range of 90 or even 80 bit range So any update on the progress of finding this key? First offset = 03982a5a42895a5cfe4b9b98e49f9389ebf9b3bf91c2289f1c5db3d944f46ec710 Half of above = 0291001b0dc6e5a2628cb4698eb00a6fb7dbd276dc2b214795f2fe52e61243aa9b Half of 130? 0337374e00a32eaf009e9946035c0e69085627b60a844637d2b958dd83bcfa4383 The following is the subtracted key from #130 Second offset = 03d99bb89e8db75d20b882f13f8086fb39221858fa211de0346c926a93ae259b3a Half of above? 03a3dc00bf5f7e7eec691569c7f67a15d3cdbb3a9994c9a5ec1430cffdb622cf9f
Now subtract half of first offset from half of #130 to get half of second offset.
Second offset is known, we need to work on first offset's half, use -1 divide by 2 script to reduce 18 bits from it, you'll have millions of new offsets and one of them is the target, now divide the #130 range by 2, subtract 18 bits from it and use the new range as your search range, input those millions offset keys and search the range.
Don't just try blind searching.😉
its not blind searching 03982a5a42895a5cfe4b9b98e49f9389ebf9b3bf91c2289f1c5db3d944f46ec710 hash160 3aaccf438388c4aeb0b433c7b778f25cb6ab244c hash160 3aaccf438388c31f14410f489939d3d5eac88f19 pk: 48ea48b7a25627365cff38d 13 same hash160 digits, and its two substraction of 130 its not one substraction, 13 digits means its 80 pourcent in that range like puzzle 66 03982a5a42895a5cfe4b9b98e49f9389ebf9b3bf91c2289f1c5db3d944f46ec710 + 2786b52d106d22524ed9cf8a87d2 031ed6283a43d439eace1ee2815118cb6f16f475be60fa5ccc8598372d8c5f1995 # target 031ed6283a43d439eace1ee2815118cb6f16f475be60fa5ccc8598372d8c5f1995 # + 3......................................... 03633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852 # target
|
|
|
|
mcdouglasx
Member
Offline
Activity: 315
Merit: 88
New ideas will be criticized and then admired.
|
|
September 08, 2023, 01:25:39 PM |
|
Looks like those who is searching for #66 are at 354d range, even myself also search at the same range. If my research correct, #66 range should be in between 354df - 358ae. Even this range will take ages to scan. LoL.
How did you come to this conclusion? By breaking down bits and some bits combination. Maybe just some wild guessing and not sure if I am correct because I spots seems like some obvious pattern. I hope someone can find it on this range thought even if I don't get it. If the results were in this range, then I can use the same methods to proceed to 67. Unfortunately, the most lowest I can go is only on current range. I guess it boost some morale maybe I am right when I saw zahid8888 post PK start at 354d and have similarity on #66 Hash160. thats what i said exactly, im substracting from 130 lower bit range and i get those address that start with same 14 digits of hash160 that means that address in that range of 90 or even 80 bit range So any update on the progress of finding this key? First offset = 03982a5a42895a5cfe4b9b98e49f9389ebf9b3bf91c2289f1c5db3d944f46ec710 Half of above = 0291001b0dc6e5a2628cb4698eb00a6fb7dbd276dc2b214795f2fe52e61243aa9b Half of 130? 0337374e00a32eaf009e9946035c0e69085627b60a844637d2b958dd83bcfa4383 The following is the subtracted key from #130 Second offset = 03d99bb89e8db75d20b882f13f8086fb39221858fa211de0346c926a93ae259b3a Half of above? 03a3dc00bf5f7e7eec691569c7f67a15d3cdbb3a9994c9a5ec1430cffdb622cf9f
Now subtract half of first offset from half of #130 to get half of second offset.
Second offset is known, we need to work on first offset's half, use -1 divide by 2 script to reduce 18 bits from it, you'll have millions of new offsets and one of them is the target, now divide the #130 range by 2, subtract 18 bits from it and use the new range as your search range, input those millions offset keys and search the range.
Don't just try blind searching.😉
its not blind searching 03982a5a42895a5cfe4b9b98e49f9389ebf9b3bf91c2289f1c5db3d944f46ec710 hash160 3aaccf438388c4aeb0b433c7b778f25cb6ab244c hash160 3aaccf438388c31f14410f489939d3d5eac88f19 pk: 48ea48b7a25627365cff38d 13 same hash160 digits, and its two substraction of 130 its not one substraction, 13 digits means its 80 pourcent in that range like puzzle 66 03982a5a42895a5cfe4b9b98e49f9389ebf9b3bf91c2289f1c5db3d944f46ec710 + 2786b52d106d22524ed9cf8a87d2 031ed6283a43d439eace1ee2815118cb6f16f475be60fa5ccc8598372d8c5f1995 # target 031ed6283a43d439eace1ee2815118cb6f16f475be60fa5ccc8598372d8c5f1995 # + 3......................................... 03633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852 # target What you are doing is believing in an illusion, if you search in any range you will find the same matches, so in all honesty you are wasting your time comparing hash160 with the sequence of the curve.
|
BTC bc1qxs47ttydl8tmdv8vtygp7dy76lvayz3r6rdahu
|
|
|
|