nomachine
Member

Online
Activity: 507
Merit: 38
|
 |
October 24, 2023, 03:39:58 PM Last edit: October 24, 2023, 04:17:59 PM by nomachine |
|
Let's say we have a 66 bit private key. Such key must be a multiple of smaller number
Why numbers at all? Let's say we have a Puzzle 65, 64, 63 private keys in bytes: Puzzle 65 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\xa88\xb15\x05\xb2hg' Puzzle 64 b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf7\x05\x1f'\xb0\x91\x12\xd4" Puzzle 63 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00|\xce^\xfd\xac\xcfh\x08' and so on.... Do you see how many leading zeros there are and how small the end is in bytes? b'\x00' * 23 (twenty-three zeroes) + 9 bytes You need to generate the last 9 bytes to get full WIF (from 66 to 71 bits). I went one step further now. To represent hash160 directly in the vector as bytes and std::vector<std::vector<unsigned char>> target_hash160_list = { {0x20, 0xd4, 0x5a, 0x6a, 0x76, 0x25, 0x35, 0x70, 0x0c, 0xe9, 0xe0, 0xb2, 0x16, 0xe3, 0x19, 0x94, 0x33, 0x5d, 0xb8, 0xa5}, {0x73, 0x94, 0x37, 0xbb, 0x3d, 0xd6, 0xd1, 0x98, 0x3e, 0x66, 0x62, 0x9c, 0x5f, 0x08, 0xc7, 0x0e, 0x52, 0x76, 0x93, 0x71}, {0xe0, 0xb8, 0xa2, 0xba, 0xee, 0x1b, 0x77, 0xfc, 0x70, 0x34, 0x55, 0xf3, 0x9d, 0x51, 0x47, 0x74, 0x51, 0xfc, 0x8c, 0xfc}, {0x61, 0xeb, 0x8a, 0x50, 0xc8, 0x6b, 0x05, 0x84, 0xbb, 0x72, 0x7d, 0xd6, 0x5b, 0xed, 0x8d, 0x24, 0x00, 0xd6, 0xd5, 0xaa}, {0xf6, 0xf5, 0x43, 0x1d, 0x25, 0xbb, 0xf7, 0xb1, 0x2e, 0x8a, 0xdd, 0x9a, 0xf5, 0xe3, 0x47, 0x5c, 0x44, 0xa0, 0xa5, 0xb8}, {0xbf, 0x74, 0x13, 0xe8, 0xdf, 0x4e, 0x7a, 0x34, 0xce, 0x9d, 0xc1, 0x3e, 0x2f, 0x26, 0x48, 0x78, 0x3e, 0xc5, 0x4a, 0xdb}, {0xfe, 0x7c, 0x45, 0x12, 0x67, 0x31, 0xf7, 0x38, 0x46, 0x40, 0xb0, 0xb0, 0x04, 0x5f, 0xd4, 0x0b, 0xac, 0x72, 0xe2, 0xa2} };
compare them directly afterwards without any conversion to hex. This works fast as hell. It is SO fast that you can barely see the numbers on the display. Flashing characters on the screen.... But it's not fast enough for Puzzles over 60...Need GPU....
|
bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8
|
|
|
AlanJohnson
Member

Offline
Activity: 126
Merit: 11
|
 |
October 24, 2023, 04:30:49 PM |
|
Let's say we have a 66 bit private key. Such key must be a multiple of smaller number
Why numbers at all? Let's say we have a Puzzle 65, 64, 63 private keys in bytes: Puzzle 65 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\xa88\xb15\x05\xb2hg' Puzzle 64 b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf7\x05\x1f'\xb0\x91\x12\xd4" Puzzle 63 b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00|\xce^\xfd\xac\xcfh\x08' and so on.... Do you see how many leading zeros there are and how small the end is in bytes? b'\x00' * 23 (twenty-three zeroes) + 9 bytes You need to generate the last 9 bytes to get full WIF (from 66 to 71 bits). I went one step further now. To represent hash160 directly in the vector as bytes and std::vector<std::vector<unsigned char>> target_hash160_list = { {0x20, 0xd4, 0x5a, 0x6a, 0x76, 0x25, 0x35, 0x70, 0x0c, 0xe9, 0xe0, 0xb2, 0x16, 0xe3, 0x19, 0x94, 0x33, 0x5d, 0xb8, 0xa5}, {0x73, 0x94, 0x37, 0xbb, 0x3d, 0xd6, 0xd1, 0x98, 0x3e, 0x66, 0x62, 0x9c, 0x5f, 0x08, 0xc7, 0x0e, 0x52, 0x76, 0x93, 0x71}, {0xe0, 0xb8, 0xa2, 0xba, 0xee, 0x1b, 0x77, 0xfc, 0x70, 0x34, 0x55, 0xf3, 0x9d, 0x51, 0x47, 0x74, 0x51, 0xfc, 0x8c, 0xfc}, {0x61, 0xeb, 0x8a, 0x50, 0xc8, 0x6b, 0x05, 0x84, 0xbb, 0x72, 0x7d, 0xd6, 0x5b, 0xed, 0x8d, 0x24, 0x00, 0xd6, 0xd5, 0xaa}, {0xf6, 0xf5, 0x43, 0x1d, 0x25, 0xbb, 0xf7, 0xb1, 0x2e, 0x8a, 0xdd, 0x9a, 0xf5, 0xe3, 0x47, 0x5c, 0x44, 0xa0, 0xa5, 0xb8}, {0xbf, 0x74, 0x13, 0xe8, 0xdf, 0x4e, 0x7a, 0x34, 0xce, 0x9d, 0xc1, 0x3e, 0x2f, 0x26, 0x48, 0x78, 0x3e, 0xc5, 0x4a, 0xdb}, {0xfe, 0x7c, 0x45, 0x12, 0x67, 0x31, 0xf7, 0x38, 0x46, 0x40, 0xb0, 0xb0, 0x04, 0x5f, 0xd4, 0x0b, 0xac, 0x72, 0xe2, 0xa2} };
compare them directly afterwards without any conversion to hex. This works fast as hell. It is SO fast that you can barely see the numbers on the display. Flashing characters on the screen.... But it's not fast enough for Puzzles over 60...Need GPU.... I just tried your previous program (for puzzle 15) that is using openssl... It works ok but only for puzzle 15... I edited the code with differend rmd160 hashes and changed the value int puzzle = 15 to a different puzzle but then it counts endlessly and never finds a solution. If i want to try this program for different puzzles what parameters i need to change in the code 
|
|
|
|
nomachine
Member

Online
Activity: 507
Merit: 38
|
 |
October 24, 2023, 05:01:26 PM |
|
If i want to try this program for different puzzles what parameters i need to change in the code  That's the first test script...You have a pm. Let's not bother others with technicalities here. 
|
bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8
|
|
|
WanderingPhilospher
Sr. Member
  
Offline
Activity: 1288
Merit: 253
Shooters Shoot...
|
 |
October 24, 2023, 05:23:48 PM |
|
Let's say we have a 66 bit private key. Such key must be a multiple of smaller number
This works fast as hell. It is SO fast that you can barely see the numbers on the display. Flashing characters on the screen.... But it's not fast enough for Puzzles over 60...Need GPU.... Soooo nomachine, how fast is fast? How fast can your script on your PC solve a 60 bit key? You say it’s fast, just not fast enough to solve puzzles over 60, so how fast is fast?
|
|
|
|
albert0bsd
|
 |
October 24, 2023, 05:54:14 PM |
|
It is SO fast that you can barely see the numbers on the display.
Print ALL the keys on screen is stupid and slow
|
|
|
|
digaran
Copper Member
Hero Member
   
Offline
Activity: 1330
Merit: 900
🖤😏
|
 |
October 24, 2023, 06:14:46 PM |
|
Let's say we have a 66 bit private key. Such key must be a multiple of smaller number
This works fast as hell. It is SO fast that you can barely see the numbers on the display. Flashing characters on the screen.... But it's not fast enough for Puzzles over 60...Need GPU.... Soooo nomachine, how fast is fast? How fast can your script on your PC solve a 60 bit key? You say it’s fast, just not fast enough to solve puzzles over 60, so how fast is fast? Hey hey now, it's not cool talking to a colleague like that, soooo is obvious you are making fun of his speed, lets say the script is so fast that it flashes on the screen very fast, and lets leave it at that. Instead of smearing each other, lets develop an algorithm to show the world *who we are.
Proposal untested : Subtract 2 from target, set as target2, set original key as target1, subtract n/2 from target1 and perform point torsion on it, subtract 1 from target2 then perform point torsion on it, now either sub or add the results together, check to see if you get any results. Yesterday I managed to definitively find the value of last char of unknown keys, but I forgot it after going to get some coffee. 😐 I can't manage testing anything right now cause I resent myself for that. Proposal 2 : normal division not using torsion, halve the target first, set as target2, original point as target1, divide both by starting range = n/2-100, end range = n/2+100, then add/sub results, check for a solution. P2-2 : we need to find a way to get a composite number, even if it's as large as 255bit, remember do everything over scalar first, if our key is : T2 : 000000000000000000000000000000014551231950b75fc4402da1732fc9bebf Key inverse, -n : fffffffffffffffffffffffffffffffd755db9cd5e9140777fa4bd19a06c8282 Now cut off this part from it : fffffffffffffffffffffffffffffff000000000000000000000000000000000 By subtracting from target -n to have : T1 0000000000000000000000000000000d755db9cd5e9140777fa4bd19a06c8282 Set T1 and T2, do the division sub/add, with n/2-100 etc, check the result. I know you will see the distance between them being divided, but try to divide one of the results which has many trailing zeros, divide by power of 2, until you reach to fractions, you will see that there is a possibility to do the same with unknown keys. Try these, I know you can find something, after all you taught me how to do point operations on EC. 😉 You know where to find my test scripts on project development. (Ground breaking etc).lol
*= who are we really? We will deal with this identity crisis later.😂
|
🖤😏
|
|
|
nomachine
Member

Online
Activity: 507
Merit: 38
|
 |
October 24, 2023, 06:23:56 PM |
|
so how fast is fast?
For first test is fast  Print ALL the keys on screen is stupid and slow
I agree. but I need to have insight into what the application does exactly in the test phases. soooo is obvious you are making fun of his speed, lets say the script is so fast that it flashes on the screen very fast
Even I joke about my speed.
|
bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8
|
|
|
WanderingPhilospher
Sr. Member
  
Offline
Activity: 1288
Merit: 253
Shooters Shoot...
|
 |
October 24, 2023, 07:25:48 PM |
|
so how fast is fast?
For first test is fast  Print ALL the keys on screen is stupid and slow
I agree. but I need to have insight into what the application does exactly in the test phases. soooo is obvious you are making fun of his speed, lets say the script is so fast that it flashes on the screen very fast
Even I joke about my speed. No, it's a serious question. Maybe you are on to something, maybe not. I wonder how fast it really is? What about 56 bit key or a 52 bit key? Do you not have any benchmarks?
|
|
|
|
WanderingPhilospher
Sr. Member
  
Offline
Activity: 1288
Merit: 253
Shooters Shoot...
|
 |
October 24, 2023, 07:31:19 PM |
|
Proposal untested : Subtract 2 from target, set as target2, set original key as target1, subtract n/2 from target1 and perform point torsion on it, subtract 1 from target2 then perform point torsion on it, now either sub or add the results together, check to see if you get any results. Yesterday I managed to definitively find the value of last char of unknown keys, but I forgot it after going to get some coffee. 😐 I can't manage testing anything right now cause I resent myself for that.
Proposal 2 : normal division not using torsion, halve the target first, set as target2, original point as target1, divide both by starting range = n/2-100, end range = n/2+100, then add/sub results, check for a solution.
P2-2 : we need to find a way to get a composite number, even if it's as large as 255bit, remember do everything over scalar first, if our key is :
I honestly get lost trying to figure out what you are trying to do. If you had worked with smaller keys, whether hex or numbers, and shown an example of what you did on a smaller scale, it would be easier to follow. And no, not just an example of the operations, but an example of the operations performed and the results at each operation, until you reached the outcome you were trying for.
|
|
|
|
patsat
Newbie
Offline
Activity: 3
Merit: 0
|
 |
October 24, 2023, 07:41:21 PM |
|
Ok.
I'm working on Kangaroo Twimi algorithm on hash160. I don't know if it will work, but this is an idea. It uses two EC_POINT objects (K and W) and iteratively moves them around the elliptic curve by adding random steps until they land on the same point. When the Kangaroo and Wallaby points collide, the algorithm returns the discrete logarithm k.
Can you find one bit of the K nonce ?
|
|
|
|
WanderingPhilospher
Sr. Member
  
Offline
Activity: 1288
Merit: 253
Shooters Shoot...
|
 |
October 24, 2023, 07:42:14 PM |
|
^^^^^ This is the best and logical answer on this forum ^^^^^^
Most people here just wasting their time trying to solve things that are unsolvable with current hardware (at least hardware available to them).
Even using blind random cracking - realistically it's not gonna be solved in any sane amount of time.
I can agree, to an extent,This really depends on your hardware and strategy. And a lack of dedicated pool for Kangaroo/awareness is another big reason 130 seems impossible at the moment. I can run a simple keyhunt/bitcrack/vansearch program and cut the 66 bit puzzle down to having a 1 in 2^30 chance, every few minutes with nothing but simple CPUs (think i5/i7 6th. 7th. 8th generation type). With the higher puzzles currently at 130, group ops, is almost the same as brute forcing 66, 67, 68, 69 puzzles. I bounce around all over the place with different strategies. but for now, I am sticking with my 2^30 chances for 66 bit puzzle.
|
|
|
|
nomachine
Member

Online
Activity: 507
Merit: 38
|
 |
October 24, 2023, 08:12:15 PM Last edit: October 25, 2023, 03:25:13 AM by nomachine |
|
Maybe you are on to something, maybe not.
Maybe maybe not. 
|
bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8
|
|
|
digaran
Copper Member
Hero Member
   
Offline
Activity: 1330
Merit: 900
🖤😏
|
 |
October 24, 2023, 09:50:33 PM |
|
For now digest this and penetrate order of the group n. On line 27, change (result_2 - result_1) % n to +, then compare the results starting with 7, a, 6 etc with both targets. Then Ask me what is scalar torsion, and I will give you another script to work with, remember to work with the results by sub/adding them with different values to find a short cut, I simply subtracted target 2 from n and then removed all leading Fs from it, both targets can be divided by each other, you just need to find the right divisor, also remember to remove # from line 30 and 31 separately to see each target's division results as well. import gmpy2 as mpz from gmpy2 import powmod
# Define the ec_operations function def ec_operations(start_range, end_range, scalar_1, scalar_2, n, divide_1_by_odd=True, divide_1_by_even=True, divide_2_by_odd=True, divide_2_by_even=True): for i in range(start_range + (start_range%2), end_range, 1): # divide scalar 1 by odd or even numbers if i%2 == 0 and not divide_1_by_even: continue elif i%2 == 1 and not divide_1_by_odd: continue try: # calculate inverse modulo of i i_inv = powmod(i, n-2, n)
# multiply the scalar targets by i modulo n result_1 = scalar_2 * i_inv % n result_2 = scalar_1 * i_inv % n
# divide scalar 2 by odd or even numbers if i%2 == 0 and not divide_2_by_even: continue elif i%2 == 1 and not divide_2_by_odd: continue
# subtract the results sub_result = (result_2 - result_1) % n
# print results separately # print(f"{hex(result_1)[2:]}") # print(f"{hex(result_2)[2:]}") print(f"{hex(sub_result)[2:]}")
except ZeroDivisionError: pass
if __name__ == "__main__": # Set the targets and range for the operations scalar_1 = 0x0000000000000000000000000000000b011d90a8cba60d550a2e332b5ef58546 scalar_2 = 0x00000000000000000000000000000003b9914c3de3a292e6b5a42b617140bbfb
n = mpz.mpz("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141")
start_range = 57896044618658097711785492504343953926418782139537452191302581570759080747160 end_range = 57896044618658097711785492504343953926418782139537452191302581570759080747180
ec_operations(start_range, end_range, scalar_1, scalar_2, n) When you are done, go for this one : import gmpy2 as mpz from gmpy2 import powmod
# Define the EllipticCurve class class EllipticCurve: def __init__(self, a, b, p): self.a = mpz.mpz(a) self.b = mpz.mpz(b) self.p = mpz.mpz(p)
def contains(self, point): x, y = point.x, point.y return (y * y) % self.p == (x * x * x + self.a * x + self.b) % self.p
def __str__(self): return f"y^2 = x^3 + {self.a}x + {self.b} mod {self.p}"
# Define the Point class class Point: def __init__(self, x, y, curve): self.x = mpz.mpz(x) self.y = mpz.mpz(y) self.curve = curve
def __eq__(self, other): return self.x == other.x and self.y == other.y and self.curve == other.curve
def __ne__(self, other): return not self == other
def __add__(self, other): if self.curve != other.curve: raise ValueError("Cannot add points on different curves")
# Case when one point is zero if self == Point.infinity(self.curve): return other if other == Point.infinity(self.curve): return self
if self.x == other.x and self.y != other.y: return Point.infinity(self.curve)
p = self.curve.p s = 0 if self == other: s = ((3 * self.x * self.x + self.curve.a) * powmod(2 * self.y, -1, p)) % p else: s = ((other.y - self.y) * powmod(other.x - self.x, -1, p)) % p
x = (s * s - self.x - other.x) % p y = (s * (self.x - x) - self.y) % p
return Point(x, y, self.curve)
def __sub__(self, other): if self.curve != other.curve: raise ValueError("Cannot subtract points on different curves")
# Case when one point is zero if self == Point.infinity(self.curve): return other if other == Point.infinity(self.curve): return self
return self + Point(other.x, (-other.y) % self.curve.p, self.curve)
def __mul__(self, n): if not isinstance(n, int): raise ValueError("Multiplication is defined for integers only")
n = n % (self.curve.p - 1) res = Point.infinity(self.curve) addend = self
while n: if n & 1: res += addend
addend += addend n >>= 1
return res
def __str__(self): return f"({self.x}, {self.y}) on {self.curve}"
@staticmethod def from_hex(s, curve): if len(s) == 66 and s.startswith("02") or s.startswith("03"): compressed = True elif len(s) == 130 and s.startswith("04"): compressed = False else: raise ValueError("Hex string is not a valid compressed or uncompressed point")
if compressed: is_odd = s.startswith("03") x = mpz.mpz(s[2:], 16)
# Calculate y-coordinate from x and parity bit y_square = (x * x * x + curve.a * x + curve.b) % curve.p y = powmod(y_square, (curve.p + 1) // 4, curve.p) if is_odd != (y & 1): y = -y % curve.p
return Point(x, y, curve) else: s_bytes = bytes.fromhex(s) uncompressed = s_bytes[0] == 4 if not uncompressed: raise ValueError("Only uncompressed or compressed points are supported")
num_bytes = len(s_bytes) // 2 x_bytes = s_bytes[1 : num_bytes + 1] y_bytes = s_bytes[num_bytes + 1 :]
x = mpz.mpz(int.from_bytes(x_bytes, byteorder="big")) y = mpz.mpz(int.from_bytes(y_bytes, byteorder="big"))
return Point(x, y, curve)
def to_hex(self, compressed=True): if self.x is None and self.y is None: return "00" elif compressed: prefix = "03" if self.y & 1 else "02" return prefix + hex(self.x)[2:].zfill(64) else: x_hex = hex(self.x)[2:].zfill(64) y_hex = hex(self.y)[2:].zfill(64) return "04" + x_hex + y_hex
@staticmethod def infinity(curve): return Point(-1, -1, curve)
# Define the ec_mul function def ec_mul(point, scalar, base_point): result = Point.infinity(point.curve) addend = point
while scalar: if scalar & 1: result += addend
addend += addend scalar >>= 1
return result
# Define the ec_operations function def ec_operations(start_range, end_range, target_1, target_2, curve, divide_1_by_odd=True, divide_1_by_even=True, divide_2_by_odd=True, divide_2_by_even=True): # Define parameters for secp256k1 curve n = mpz.mpz("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141") G = Point( mpz.mpz("0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"), mpz.mpz("0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8"), curve )
for i in range(start_range + ( start_range%2), end_range, 1): # divide target 1 by odd or even numbers if i%2 == 0 and not divide_1_by_even: continue elif i%2 == 1 and not divide_1_by_odd: continue try: # calculate inverse modulo of i i_inv = powmod(i, n-2, n) # divide the targets by i modulo n result_1 = ec_mul(target_1, i_inv, G) result_2 = ec_mul(target_2, i_inv, G)
# divide target 2 by odd or even numbers if i%2 == 0 and not divide_2_by_even: continue elif i%2 == 1 and not divide_2_by_odd: continue
# subtract the results sub_result = result_2 - result_1
# print the results separately # print(f"{result_1.to_hex()}") # print(f"{result_1.to_hex()}") print(f"{sub_result.to_hex()}") # data = open("result.txt","a") # data.write(str(sub_result.to_hex()) +"\n") # data.close()
except ZeroDivisionError: pass
if __name__ == "__main__": # Set the targets and range for the operations curve = EllipticCurve( mpz.mpz(0), mpz.mpz(7), mpz.mpz("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f") )
target_1 = Point.from_hex("03439acdf494f8ed30baa5f465da96c62625dbf0f474535ad9bedefd3f23663f4d", curve)
target_2 = Point.from_hex("02617125f42749f748bd047f3688f79f8e2a1bf5ef9eca7929bb2daa6fa467b8e1", curve) start_range = 57896044618658097711785492504343953926418782139537452191302581570759080747160 end_range = 57896044618658097711785492504343953926418782139537452191302581570759080747180 ec_operations(start_range, end_range, target_2, target_1, curve) When you are done, repeat the same with unknown points, whatever you do with scalars on first script and whatever results you get, perform them on the points as well, all results will be the same.
|
🖤😏
|
|
|
rosengold
Jr. Member
Offline
Activity: 149
Merit: 7
|
 |
October 25, 2023, 02:10:47 PM |
|
#include <iostream> #include <vector>...
- Bytea HASH160 Search by NoMachine
- Sat Oct 21 10:39:23 2023
- Puzzle: 15
- Public Key Hash (Hash 160): fe7c45126731f7384640b0b0045fd40bac72e2a2
- PUZZLE SOLVED: 2023-10-21 10:39:24
- Target Public Key Hash (Hash160) found! Private Key: 00000000000000000000000000000000000000000
Hi @nomachine how to make it work sequential instead of random ?
|
|
|
|
k3ntINA
Newbie
Offline
Activity: 26
Merit: 0
|
 |
October 25, 2023, 03:19:02 PM |
|
Hi friends, after a few months of trying I have found what is definitely the key to this puzzle. I am not a professional programmer or math teacher. I am a graphic designer and through the drawing of figures and maps, I reached a place where the relationship of these numbers and how they support each other through the 4 main mathematical operations (* + - /) is clearly visible. Numbers have a strange order and order in chaos! I don't know what to call it In this order, you can see outputs that are a few numbers of private keys, mostly the first 3 digits My shape and drawing is animated and with each key it has its own shape, but with all its changes, the connection and order of the numbers is not lost. I have a triangle which, by changing its size and moving in the range and even rotating from 0 to 360 degrees, displays the three sides of a single number or the sum of the other two sides. We all know that the shapes are some kind of mathematical formulas, and this means that there is an algorithm, only a formula has not been written for it. My friends, I need a programmer to program my shapes and actions so that the key is fully calculated. Because the keys are related to each other from any direction, angle and distance. It was not without reason that the creator revealed the public keys in 5 steps. Anyway, after a few years of heavy problems, I have now reached a point where I need to trust someone again. Now there is a possibility that this trust will destroy my life like in the past, but there is no other way. Friends, I only work with an experienced programmer. Someone who has a portfolio on GitHub. Because there is nothing that can be told to a few people. The next thing is that this algorithm is definitely correct, and the programmer and I should collect a maximum of 20 bits so that the rights of those who are trying and working on this puzzle are not lost and they can reach the keys in their own way. All this money is not for us. My email is amir.k3nt@gmail.comI used Google translation, so I apologize if there is a mistake.
|
|
|
|
WanderingPhilospher
Sr. Member
  
Offline
Activity: 1288
Merit: 253
Shooters Shoot...
|
 |
October 25, 2023, 03:35:09 PM |
|
Hi friends, after a few months of trying I have found what is definitely the key to this puzzle. I am not a professional programmer or math teacher. I am a graphic designer and through the drawing of figures and maps, I reached a place where the relationship of these numbers and how they support each other through the 4 main mathematical operations (* + - /) is clearly visible. Numbers have a strange order and order in chaos! I don't know what to call it In this order, you can see outputs that are a few numbers of private keys, mostly the first 3 digits My shape and drawing is animated and with each key it has its own shape, but with all its changes, the connection and order of the numbers is not lost. I have a triangle which, by changing its size and moving in the range and even rotating from 0 to 360 degrees, displays the three sides of a single number or the sum of the other two sides. We all know that the shapes are some kind of mathematical formulas, and this means that there is an algorithm, only a formula has not been written for it. My friends, I need a programmer to program my shapes and actions so that the key is fully calculated. Because the keys are related to each other from any direction, angle and distance. It was not without reason that the creator revealed the public keys in 5 steps. Anyway, after a few years of heavy problems, I have now reached a point where I need to trust someone again. Now there is a possibility that this trust will destroy my life like in the past, but there is no other way. Friends, I only work with an experienced programmer. Someone who has a portfolio on GitHub. Because there is nothing that can be told to a few people. The next thing is that this algorithm is definitely correct, and the programmer and I should collect a maximum of 20 bits so that the rights of those who are trying and working on this puzzle are not lost and they can reach the keys in their own way. All this money is not for us. My email is amir.k3nt@gmail.comI used Google translation, so I apologize if there is a mistake. What are the 3 first digits? If your shapes/drawings are correct, we would know within a day or two. Then you would probably have lots of people trying to help code your idea for #67, #68, etc. If you send me the first 3 digits of #66, and I find the key; I would split it with you 50/50. I can guarantee you, 1000% I have ranges ran for every first 3 digit combination; so I would only have to check so many keys vs starting from scratch.
|
|
|
|
rosengold
Jr. Member
Offline
Activity: 149
Merit: 7
|
 |
October 25, 2023, 03:46:47 PM |
|
Hi friends, after a few months of trying I have found what is definitely the key to this puzzle. I am not a professional programmer or math teacher. I am a graphic designer and through the drawing of figures and maps, I reached a place where the relationship of these numbers and how they support each other through the 4 main mathematical operations (* + - /) is clearly visible. Numbers have a strange order and order in chaos! I don't know what to call it In this order, you can see outputs that are a few numbers of private keys, mostly the first 3 digits My shape and drawing is animated and with each key it has its own shape, but with all its changes, the connection and order of the numbers is not lost. I have a triangle which, by changing its size and moving in the range and even rotating from 0 to 360 degrees, displays the three sides of a single number or the sum of the other two sides. We all know that the shapes are some kind of mathematical formulas, and this means that there is an algorithm, only a formula has not been written for it. My friends, I need a programmer to program my shapes and actions so that the key is fully calculated. Because the keys are related to each other from any direction, angle and distance. It was not without reason that the creator revealed the public keys in 5 steps. Anyway, after a few years of heavy problems, I have now reached a point where I need to trust someone again. Now there is a possibility that this trust will destroy my life like in the past, but there is no other way. Friends, I only work with an experienced programmer. Someone who has a portfolio on GitHub. Because there is nothing that can be told to a few people. The next thing is that this algorithm is definitely correct, and the programmer and I should collect a maximum of 20 bits so that the rights of those who are trying and working on this puzzle are not lost and they can reach the keys in their own way. All this money is not for us. My email is amir.k3nt@gmail.comI used Google translation, so I apologize if there is a mistake. Interesting, I have built my own searcher to find it, If you share the correct first 3 characters of #66 I'm ready to share 50/50 with you, I have all CUDA scripts to find it in about 5 days using some vast.ai instances.
|
|
|
|
nomachine
Member

Online
Activity: 507
Merit: 38
|
 |
October 25, 2023, 04:35:53 PM Last edit: October 25, 2023, 05:29:05 PM by nomachine |
|
#include <iostream> #include <vector>...
- Bytea HASH160 Search by NoMachine
- Sat Oct 21 10:39:23 2023
- Puzzle: 15
- Public Key Hash (Hash 160): fe7c45126731f7384640b0b0045fd40bac72e2a2
- PUZZLE SOLVED: 2023-10-21 10:39:24
- Target Public Key Hash (Hash160) found! Private Key: 00000000000000000000000000000000000000000
Hi @nomachine how to make it work sequential instead of random ? here you go, buddy #include <iostream> #include <vector> #include <iomanip> #include <openssl/bn.h> #include <openssl/ec.h> #include <openssl/obj_mac.h> #include <openssl/sha.h> #include <openssl/evp.h> #include <openssl/ripemd.h> #include <ctime> #include <sstream> #include <fstream>
// Function to convert a byte vector to a hexadecimal string std::string bytesToHex(const std::vector<unsigned char>& bytes) { std::stringstream ss; for (unsigned char byte : bytes) { ss << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(byte); } return ss.str(); }
// Function to calculate the RIPEMD160 hash of a byte vector std::vector<unsigned char> calculateRIPEMD160(const std::vector<unsigned char>& data) { std::vector<unsigned char> hash(RIPEMD160_DIGEST_LENGTH); RIPEMD160(data.data(), data.size(), hash.data()); return hash; }
int main() { // Initialize the OpenSSL library if (OpenSSL_add_all_algorithms() != 1) { std::cerr << "OpenSSL initialization failed." << std::endl; return 1; }
// Define the range std::string start_range_hex = "000000000000000000000000000000000000000000000001ffffffffffffffff"; std::string end_range_hex = "000000000000000000000000000000000000000000000003ffffffffffffffff"; // Set the target Hash160 value (replace with your target hash) std::string target_hash160_hex = "20d45a6a762535700ce9e0b216e31994335db8a5";
// Create an EC_KEY object EC_KEY* ec_key = EC_KEY_new_by_curve_name(NID_secp256k1);
// Calculate the SHA-256 hash of the public key unsigned char sha256_result[SHA256_DIGEST_LENGTH];
// Calculate the RIPEMD160 hash of the SHA-256 hash std::vector<unsigned char> ripemd160_result(RIPEMD160_DIGEST_LENGTH);
BIGNUM* start_range = BN_new(); BIGNUM* end_range = BN_new(); BN_hex2bn(&start_range, start_range_hex.c_str()); BN_hex2bn(&end_range, end_range_hex.c_str());
while (BN_cmp(start_range, end_range) <= 0) { // Create a BIGNUM from the current value in the range BIGNUM* bn_private_key = BN_dup(start_range);
// Set the private key in the EC_KEY object EC_KEY_set_private_key(ec_key, bn_private_key);
// Compute the public key from the private key EC_POINT* public_key_point = EC_POINT_new(EC_KEY_get0_group(ec_key)); EC_POINT_mul(EC_KEY_get0_group(ec_key), public_key_point, bn_private_key, NULL, NULL, NULL);
// Convert the public key point to binary representation (compressed) size_t public_key_length = EC_POINT_point2oct(EC_KEY_get0_group(ec_key), public_key_point, POINT_CONVERSION_COMPRESSED, NULL, 0, NULL); std::vector<unsigned char> public_key_bytes(public_key_length); EC_POINT_point2oct(EC_KEY_get0_group(ec_key), public_key_point, POINT_CONVERSION_COMPRESSED, public_key_bytes.data(), public_key_length, NULL);
SHA256(public_key_bytes.data(), public_key_bytes.size(), sha256_result); ripemd160_result = calculateRIPEMD160(std::vector<unsigned char>(sha256_result, sha256_result + SHA256_DIGEST_LENGTH));
// Convert the calculated RIPEMD160 hash to a hexadecimal string std::string calculated_hash160_hex = bytesToHex(ripemd160_result);
// Display the generated public key hash (Hash160) and private key std::string message = "\r\033[01;33m[+] Public Key Hash (Hash 160): " + calculated_hash160_hex; std::cout << message << "\e[?25l"; std::cout.flush();
// Check if the generated public key hash matches the target if (calculated_hash160_hex == target_hash160_hex) { // Get the current time std::time_t currentTime; std::time(¤tTime); std::tm tmStruct = *std::localtime(¤tTime);
// Format the current time into a human-readable string std::stringstream timeStringStream; timeStringStream << std::put_time(&tmStruct, "%Y-%m-%d %H:%M:%S"); std::string formattedTime = timeStringStream.str();
std::cout << "\n\033[32m[+] PUZZLE SOLVED: " << formattedTime << "\033[0m" << std::endl; std::cout << "\r\033[32m[+] Target Public Key Hash (Hash160) found! Private Key: " << BN_bn2hex(bn_private_key) << std::endl;
// Append the private key information to a file if it matches std::ofstream file("KEYFOUNDKEYFOUND.txt", std::ios::app); if (file.is_open()) { file << "\nPUZZLE SOLVED " << formattedTime; file << "\nPrivate Key (hex): " << BN_bn2hex(bn_private_key); file << "\n--------------------------------------------------------------------------------------------------------------------------------------------"; file.close(); }
BN_free(bn_private_key); break; }
// Increment the current value in the range BN_add_word(start_range, 1); }
// Free the EC_KEY and BIGNUM objects BN_free(start_range); BN_free(end_range); EC_KEY_free(ec_key);
return 0; }
g++ -m64 -march=native -pthread -O3 -I. -o puzzle66 puzzle.cpp -lssl -lcrypto -ldl
|
bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8
|
|
|
digaran
Copper Member
Hero Member
   
Offline
Activity: 1330
Merit: 900
🖤😏
|
 |
October 25, 2023, 04:58:40 PM |
|
By any chance, are you from middle east? If yes you can explain yourself here : https://bitcointalk.org/index.php?topic=620798.0Or you could find your local language and seek help from a homie.😉 Also note that, the puzzle designer doesn't know how to solve these puzzles, and he didn't leave any clues, because there are no clues. Ps, I like it the way you attribute trustworthiness to having a github page.😂
|
🖤😏
|
|
|
nomachine
Member

Online
Activity: 507
Merit: 38
|
 |
October 25, 2023, 05:45:29 PM Last edit: October 25, 2023, 06:22:34 PM by nomachine |
|
puzzle designer doesn't know how to solve these puzzles, and he didn't leave any clues, because there are no clues.
It's hard to believe he manually write each puzzle after extracting 256 keys from HD wallet... He masked them (one by one) with leading 000...0001 to set difficulty. it is done with some script, with errors = ZERO So his script knows precisely how to solve the second part. Or to put it another way, he knows how to solve these puzzles. 
|
bc1qdwnxr7s08xwelpjy3cc52rrxg63xsmagv50fa8
|
|
|
|