Bitcoin puzzle transaction ~32 BTC prize to who solves it - page 142.

alek76

member

Activity: 93

Merit: 16

Quote from: citb0in on September 23, 2023, 04:00:52 AM

Quote from: alek76 on September 22, 2023, 03:50:22 PM

I made a new version, while I’m checking how it works... It will be very difficult to find bit 66, even with the best GPUs.
OpenSSL is screwed into the program, with the ability to switch the OpenSSL functions used. Can also check different dlls by dropping them into the directory with the program. I disabled everything unnecessary - SSE, endomorphism, symmetry. Changed the GPU code - removed endomorphism and removed double (quadruples) checks of Ripemd160 (Match GPU - the Y coordinate is calculated in the curve). I'm checking it out, maybe I'll post it soon...

Sounds interesting as long as the source code is available so one can compile the program. Is it available for download ?

Today I checked the GPU code again, since I removed the unnecessary calculations of Ripemd160 (left 1 out of 6) and it works correctly. I needed to make sure again that everything was correct. In this code I also used functions from the Bitcoin client - to add a seed, the Rand_add() function. I'll post it on Github in the near future, because... With my computing resources it will not be possible to find a solution to bit 66. If they find it using my fork, then send me a tips

. Coming soon.
I managed to get this speed on Tesla T4:

Code:

[ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ]
[                                                           ]
[===========================================================]
[                Changes by Alek76 modify 0.03              ]
[===========================================================]
[          Tips: 1NULY7DhzuNvSDtPkFzNo6oRTZQWBqXNE9         ]
[===========================================================]
[    Options added argv [-start] [-bits] and disable SSE    ]
[===========================================================]
[           Used OpenSSL Random number generator            ]
[===========================================================]
OpenSSL 3.0.2 15 Mar 2022 (Library: OpenSSL 3.0.2 15 Mar 2022)
[===========================================================]
[                OpenSSL add all algorithms                 ]
[===========================================================]
[                OpenSSL Used functions level 4             ]
[                                                           ]
[ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ]
                                                             

[i] RAND_add() Seed with CPU performance counter: 1695456415355946 
Difficulty: 1461501637330902918203684832716283019655932542976
Search: 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so [Compressed]
Start Sat Sep 23 08:06:55 2023
Base Key: Randomly changed every 100000 Mkeys
Number of CPU thread: 0
GPU: GPU #0 Tesla T4 (40x64 cores) Grid(320x128)

[i] RAND_add() Seed with CPU performance counter: 1695456415480157 
Bit 66 GPU Base Key 0: 2DAFFE6ACD76ABC1D
Bit 66 GPU Base Key 1: 27AD93FD5D885B767
Bit 66 GPU Base Key 2: 2D67AE2D1731671C5
Bit 66 GPU Base Key 3: 3C77CC7B5C7587A86
Bit 66 GPU Base Key 4: 277448DA9C423D147
Bit 66 GPU Base Key 5: 2F7EDC7B5C2B09F0F
Bit 66 GPU Base Key 6: 3DABCD2B602D43EA8
Bit 66 GPU Base Key 7: 238936C644C88AB7E
Bit 66 GPU Base Key 8: 3A97B3F0171947B59
Bit 66 GPU Base Key 9: 31B6CDD325D6B3FB7
Bit 66 GPU Base Key 40951: 3211CC54F75B5CD00
Bit 66 GPU Base Key 40952: 2327D47C30738E157
Bit 66 GPU Base Key 40953: 2A66575CC34FA37C6
Bit 66 GPU Base Key 40954: 2981DD1BA18306814
Bit 66 GPU Base Key 40955: 3775C5C27150FEA12
Bit 66 GPU Base Key 40956: 37A37E2863197B3DB
Bit 66 GPU Base Key 40957: 3D78C9919D6B6A072
Bit 66 GPU Base Key 40958: 22100282EE8370965
Bit 66 GPU Base Key 40959: 37E28F54F8EC9B7D2

[i] RAND_add() Seed with CPU performance counter: 1695456416086342 
Bit 66 GPU Base Key 0: 33D16FF3A68C0BA73
Bit 66 GPU Base Key 1: 359F2BA0E89868D5E
Bit 66 GPU Base Key 2: 3DDDCE27056C63AD9
Bit 66 GPU Base Key 3: 2EFF53109E165A31F
Bit 66 GPU Base Key 4: 236DC50A204B42078
Bit 66 GPU Base Key 5: 2F128D7562A4DDC32
Bit 66 GPU Base Key 6: 2743F1524E422DF51
Bit 66 GPU Base Key 7: 284ECC8C4DC852018
Bit 66 GPU Base Key 8: 3932B5EC487EACE6A
Bit 66 GPU Base Key 9: 398E4AEE55E284239
Bit 66 GPU Base Key 40951: 3225C10410AF00667
Bit 66 GPU Base Key 40952: 229E0588B78FCDF88
Bit 66 GPU Base Key 40953: 25DAC65EBE4EF6B6B
Bit 66 GPU Base Key 40954: 2C5621F3B0D87CFB8
Bit 66 GPU Base Key 40955: 229EC31EBF4F800D2
Bit 66 GPU Base Key 40956: 31F29B5822AA4E982
Bit 66 GPU Base Key 40957: 27C891A611B7D7A20
Bit 66 GPU Base Key 40958: 2F1351CB9E5A7812F
Bit 66 GPU Base Key 40959: 22D025D76B453D748
[615.93 Mkey/s][GPU 615.93 Mkey/s][Total 2^36.06][Prob 0.0%][50% in 5.21538e+31y][Found 0]

Coming soon... Already available https://github.com/alek76-2/VanitySearch

citb0in

hero member

Activity: 630

Merit: 731

Bitcoin g33k

Quote from: alek76 on September 22, 2023, 03:50:22 PM

I made a new version, while I’m checking how it works... It will be very difficult to find bit 66, even with the best GPUs.
OpenSSL is screwed into the program, with the ability to switch the OpenSSL functions used. Can also check different dlls by dropping them into the directory with the program. I disabled everything unnecessary - SSE, endomorphism, symmetry. Changed the GPU code - removed endomorphism and removed double (quadruples) checks of Ripemd160 (Match GPU - the Y coordinate is calculated in the curve). I'm checking it out, maybe I'll post it soon...

Sounds interesting as long as the source code is available so one can compile the program. Is it available for download ?

digaran

copper member

Activity: 1330

Merit: 899

🖤😏

Didn't work, still outputs a single result which is the result of last public keys in my files subtracted, this new method I'm working on is not yet tested, so I can't share it before testing it myself.

I managed to make up a scalar mod n version of my script, but as a py noob, I can't learn so many things in a short period of time. Thanks for the effort though.
Maybe I'm unsuccessful because I'm using mobile instead of laptop? Lol I should find some place else for my coding guidance.

My new script can solve any key in scalar mode of course.

7isce

jr. member

Activity: 61

Merit: 6

You could just use it as

Code:

file1 = open('file1.txt', 'r')
for line in file1.read().splitlines():
    compressed_keys.append(bytes.fromhex(line))
file1.close()

file2 = open('file2.txt', 'r')
for line in file2.read().splitlines():
    compressed_keys.append(bytes.fromhex(line))
file2.close()

Good Luck with your studies Wink

digaran

copper member

Activity: 1330

Merit: 899

🖤😏

Quote from: tetaeridanus on September 22, 2023, 10:12:24 PM

is this puzzle still unsolved to date?

It's not one puzzle, there are 160 in total, some of them are already solved, #66 is not yet solved. #130 also not solved but these 2 are next in line.

Guys anyone here knows python? Of course you do, I'm stuck for days to make this happening, at first I wanted to have such function inside another script but I failed, so I thought of something else, the following script opens 2 text files, reads the keys in both and subtracts them from each other, that's the logic but whatever I did I couldn't get it to take public keys from each line of the files and do the subtraction with them all, it just reads the last line and returns only 1 result obviously, if you could provide a fix, it'd be great.

Code:

# secp256k1 curve parameters
p = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
a = 0
b = 7
Gx = 0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798
Gy = 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8
n = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141

# Point addition and subtraction functions
def point_add(P, Q):
    if P == Q:
        return point_double(P)
    if P is None:
        return Q
    if Q is None:
        return P
    lam = ((Q[1] - P[1]) * pow(Q[0] - P[0], p-2, p)) % p
    x = (lam * lam - P[0] - Q[0]) % p
    y = (lam * (P[0] - x) - P[1]) % p
    return (x, y)

def point_sub(P, Q):
    if Q is None:
        return P
    # instead of using p - Q[1], use -Q[1] % p to correctly compute y coordinate
    Q_neg = (Q[0], (-Q[1]) % p)
    return point_add(P, Q_neg)

# Point doubling function
def point_double(P):
    if P is None:
        return None
    lam = ((3 * P[0] * P[0] + a) * pow(2 * P[1], p-2, p)) % p
    x = (lam * lam - 2 * P[0]) % p
    y = (lam * (P[0] - x) - P[1]) % p
    return (x, y)

def is_valid_point(point):
    # Check that the point is not the point at infinity
    if point is None:
        return False
    
    x, y = point
    # Check that the coordinates are within the allowed range
    if x < 0 or x >= p or y < 0 or y >= p:
        return False
    
    # Check that the point lies on the curve
    return (y*y - x*x*x - a*x - b) % p == 0

def decompress_point(compressed_key):
    if compressed_key.startswith(b'\x02') or compressed_key.startswith(b'\x03'):
        x = int.from_bytes(compressed_key[1:], byteorder='big')
        y_sq = (x * x * x + a*x + b) % p
        y = pow(y_sq, (p+1)//4, p)
        if (y*y) % p == y_sq:
            return (x, y)
        else:
            return None
    else:
        return None

def compress_point(point):
    x, y = point
    prefix = b'\x02' if y % 2 == 0 else b'\x03'
    return prefix + x.to_bytes(32, byteorder='big')

def point_subtraction(compressed_keys):
    P = None
    for compressed_key in compressed_keys:
        Q = decompress_point(compressed_key)
        
        # Check that the point is valid on the curve
        if not is_valid_point(Q):
            return None
        
        if P is None:
            P = Q
        else:
            P = point_sub(P, Q)
        
        # Check that the resulting point is not the point at infinity
        if P is None:
            return None
    
    if is_valid_point(P):
        return compress_point(P)
    else:
        return None

compressed_keys = []
file1 = open('file1.txt', 'r')
for line in file1:
    compressed_keys.append(bytes.fromhex(line.strip()))
file1.close()

file2 = open('file2.txt', 'r')
for line in file2:
    compressed_keys.append(bytes.fromhex(line.strip()))
file2.close()

result = point_subtraction(compressed_keys)

if result:
    file3 = open('result.txt', 'a')
    file3.write(result.hex() + "\n")
    file3.close()
else:
    print("The subtraction result is not a valid point on the curve.")

I know the problem is in line.strip section, just don't know how, btw I asked AI, it started by implementing sha256 for no reason, ended up with giving me some test cases from bitcoin wiki. Go figure!

Note, it's for academic purposes only ( whatever that means anyway ).😉

tetaeridanus

member

Activity: 182

Merit: 33

Peace without Borders

is this puzzle still unsolved to date?

alek76

member

Activity: 93

Merit: 16

Quote from: albert0bsd on September 22, 2023, 03:57:11 PM

Please don't belive that you are the only one who think in that... Roll Eyes

Yes, I checked some SSL libs on linux. Most of them works ok, The useful thing is when you tested some buggy version of it. but you need to check the source code to see where the bug is and use it to generate "weak" keys.

Yes, that's absolutely true. Here I spent a week digging through old versions of OpenSSL from their official source. Weak keys are possible if assembled incorrectly. For example, like in older versions of Bitcoin core bitcoin-0.2.0, where RandAddSeedPerfmon() for Linux does not work, not used function RAND_add().
Downloaded DLLs can be checked by saving them keys to file and checking for duplicates. But this is unlikely all, a very large range. In general, a good Random will not hurt to solve bit 66, since the versions and key generation programs for this puzzle are not known. Perhaps the purpose of its creation will help, but perhaps its purpose is also to test the strength of OpenSSL libraries. Although there are so many external events that it is not possible to re-generate duplicate keys, unless there are broken versions - removing some functions to generate a weak key.
Perhaps someone decided to check old versions and created this puzzle.

albert0bsd

hero member

Activity: 862

Merit: 662

Quote from: alek76 on September 22, 2023, 03:50:22 PM

Has anyone used OpenSSL to generate keys?
Probably not..

Please don't belive that you are the only one who think in that... Roll Eyes

Yes, I checked some SSL libs on linux. Most of them works ok, The useful thing is when you tested some buggy version of it. but you need to check the source code to see where the bug is and use it to generate "weak" keys.

alek76

member

Activity: 93

Merit: 16

Hello everyone, and especially those who still remember me)
I made a new version, while I’m checking how it works... It will be very difficult to find bit 66, even with the best GPUs.
OpenSSL is screwed into the program, with the ability to switch the OpenSSL functions used. Can also check different dlls by dropping them into the directory with the program. I disabled everything unnecessary - SSE, endomorphism, symmetry. Changed the GPU code - removed endomorphism and removed double (quadruples) checks of Ripemd160 (Match GPU - the Y coordinate is calculated in the curve). I'm checking it out, maybe I'll post it soon...

Code:

C:\VSearch-1.19 New Build check v0.03\win7 x64>VanitySearch.exe -stop -t 1 -bits 66 -r 5 -level 1 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so

[ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ]
[                                                           ]
[===========================================================]
[                Changes by Alek76 modify 0.03              ]
[===========================================================]
[          Tips: 1NULY7DhzuNvSDtPkFzNo6oRTZQWBqXNE9         ]
[===========================================================]
[    Options added argv [-start] [-bits] and disable SSE    ]
[===========================================================]
[           Used OpenSSL Random number generator            ]
[===========================================================]
[                OpenSSL add all algorithms                 ]
[===========================================================]
[                OpenSSL Used functions level 1             ]
[                                                           ]
[ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ]

Difficulty: 1461501637330902918203684832716283019655932542976
Search: 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so [Compressed]
Start Fri Sep 22 23:00:18 2023
Base Key: Randomly changed every 5 Mkeys
Number of CPU thread: 1

Bit 60 Base Key thId 0: 9F79EEEC674E61F < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 66 CPU Base Key thId 0: 29D1A41009D12513A
[0.89 Mkey/s][GPU 0.00 Mkey/s][Total 2^22.35][Prob 0.0%][50% in 3.60851e+34y][Found 0]
Bit 64 Base Key thId 0: E3643540371FB847 < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 64 Base Key thId 0: 80A2CD8B9A3C23BC < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 66 CPU Base Key thId 0: 3A53B397C7C3998F9
[0.85 Mkey/s][GPU 0.00 Mkey/s][Total 2^23.51][Prob 0.0%][50% in 3.768e+34y][Found 0]
Bit 66 CPU Base Key thId 0: 33A47F5D6B844E5CE
[0.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^24.14][Prob 0.0%][50% in 3.90297e+34y][Found 0]
Bit 66 CPU Base Key thId 0: 23B25CA07BAC32C6F
[0.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^24.58][Prob 0.0%][50% in 3.9043e+34y][Found 0]
Bit 65 Base Key thId 0: 12FF6314297C60ECB < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 66 CPU Base Key thId 0: 25B540E692C67500B
[0.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^24.92][Prob 0.0%][50% in 3.90599e+34y][Found 0]
Bit 65 Base Key thId 0: 14F6F111D9ADFE665 < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 66 CPU Base Key thId 0: 28F5EB0F8DBAF6E80
[0.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^25.19][Prob 0.0%][50% in 3.90512e+34y][Found 0]
Bit 66 CPU Base Key thId 0: 33755278B8367C2C3
[0.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^25.42][Prob 0.0%][50% in 3.89525e+34y][Found 0]
Bit 64 Base Key thId 0: C63FFCFE4B85011C < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 66 CPU Base Key thId 0: 36CA7D64880F6EC8E
[0.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^25.59][Prob 0.0%][50% in 3.89824e+34y][Found 0]
Bit 65 Base Key thId 0: 1602E2E612E2D1D5D < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 64 Base Key thId 0: 9CE5D3E01377163B < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 66 CPU Base Key thId 0: 22729A06418E0AA07
[0.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^25.77][Prob 0.0%][50% in 3.90262e+34y][Found 0]
Bit 65 Base Key thId 0: 1E4BA74256A46FFF2 < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 65 Base Key thId 0: 19A395587DDFF6849 < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 66 CPU Base Key thId 0: 201909FF60F39CB91
[0.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^25.89][Prob 0.0%][50% in 3.90116e+34y][Found 0]

Code:

C:\VSearch-1.19 New Build check v0.03\win7 x64>VanitySearch.exe -stop -t 2 -bits 66 -r 5 -level 4 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so

[ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ]
[                                                           ]
[===========================================================]
[                Changes by Alek76 modify 0.03              ]
[===========================================================]
[          Tips: 1NULY7DhzuNvSDtPkFzNo6oRTZQWBqXNE9         ]
[===========================================================]
[    Options added argv [-start] [-bits] and disable SSE    ]
[===========================================================]
[           Used OpenSSL Random number generator            ]
[===========================================================]
[                OpenSSL add all algorithms                 ]
[===========================================================]
[                OpenSSL RAND_screen() OK                   ]
[===========================================================]
[                OpenSSL Used functions level 4             ]
[                                                           ]
[ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ]


[i] RAND_add() Seed with CPU performance counter: 413322837980
Difficulty: 1461501637330902918203684832716283019655932542976
Search: 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so [Compressed]
Start Fri Sep 22 23:25:51 2023
Base Key: Randomly changed every 5 Mkeys
Number of CPU thread: 2

[i] RAND_add() Seed with CPU performance counter: 413323029166

Bit 64 Base Key thId 1: C3B95A81B85BFE25 < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 66 CPU Base Key thId 1: 20D9401B0A4FFDD06

[i] RAND_add() Seed with CPU performance counter: 413323029845

Bit 64 Base Key thId 0: A5BB18323A7CB6AB < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 66 CPU Base Key thId 0: 295244E678E41E12E
[1.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^22.85][Prob 0.0%][50% in 1.76408e+34y][Found 0]
[i] RAND_add() Seed with CPU performance counter: 413333913173

Bit 66 CPU Base Key thId 0: 29EF09292123E8168

[i] RAND_add() Seed with CPU performance counter: 413333913233

Bit 65 Base Key thId 1: 1FC1E88D8E95BC854 < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 61 Base Key thId 1: 11B4BEA1EE95FF48 < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 66 CPU Base Key thId 1: 27D8A8F52B15BE829
[1.72 Mkey/s][GPU 0.00 Mkey/s][Total 2^23.76][Prob 0.0%][50% in 1.86995e+34y][Found 0]
[i] RAND_add() Seed with CPU performance counter: 413343522509

Bit 66 CPU Base Key thId 0: 396121E3EFFA2A03C

[i] RAND_add() Seed with CPU performance counter: 413343523260

Bit 66 CPU Base Key thId 1: 2D60B4F910B675F54
[1.68 Mkey/s][GPU 0.00 Mkey/s][Total 2^24.31][Prob 0.0%][50% in 1.90682e+34y][Found 0]
[i] RAND_add() Seed with CPU performance counter: 413353124168

[i] RAND_add() Seed with CPU performance counter: 413353124942

Bit 64 Base Key thId 1: B461B1FC1240503B < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 66 CPU Base Key thId 1: 2C1BC11A5C0C595BA

Bit 66 CPU Base Key thId 0: 32DFF58084D0F0B48
[1.67 Mkey/s][GPU 0.00 Mkey/s][Total 2^24.72][Prob 0.0%][50% in 1.92559e+34y][Found 0]
[i] RAND_add() Seed with CPU performance counter: 413362823436

Bit 66 CPU Base Key thId 1: 2664445EC6A550E07

[i] RAND_add() Seed with CPU performance counter: 413362823661

Bit 66 CPU Base Key thId 0: 27E59959139581FB5
[1.62 Mkey/s][GPU 0.00 Mkey/s][Total 2^25.03][Prob 0.0%][50% in 1.98491e+34y][Found 0]
[i] RAND_add() Seed with CPU performance counter: 413372570037

[i] RAND_add() Seed with CPU performance counter: 413372575962

Bit 66 CPU Base Key thId 1: 2DA47EF2D2A90A017

Bit 66 CPU Base Key thId 0: 33A1C28B16D799A69
[1.62 Mkey/s][GPU 0.00 Mkey/s][Total 2^25.29][Prob 0.0%][50% in 1.98281e+34y][Found 0]
[i] RAND_add() Seed with CPU performance counter: 413382240693

[i] RAND_add() Seed with CPU performance counter: 413382241494

Bit 61 Base Key thId 1: 147BF7CC10BC669B < 20000000000000000 or > 3FFFFFFFFFFFFFFFF Rekey true

Bit 66 CPU Base Key thId 1: 2BC45552F10B6FAF2

Bit 66 CPU Base Key thId 0: 3BF647F72F5534012
[1.62 Mkey/s][GPU 0.00 Mkey/s][Total 2^25.40][Prob 0.0%][50% in 1.98292e+34y][Found 0]

Code:

C:\VSearch-1.19 New Build check v0.03\win7 x64>VanitySearch.exe -stop -t 2 -bits 28 -r 5 -level 1 12jbtzBb54r97TCwW3G1gCFoumpckRAPdY

[ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ]
[                                                           ]
[===========================================================]
[                Changes by Alek76 modify 0.03              ]
[===========================================================]
[          Tips: 1NULY7DhzuNvSDtPkFzNo6oRTZQWBqXNE9         ]
[===========================================================]
[    Options added argv [-start] [-bits] and disable SSE    ]
[===========================================================]
[           Used OpenSSL Random number generator            ]
[===========================================================]
[                OpenSSL add all algorithms                 ]
[===========================================================]
[                OpenSSL Used functions level 1             ]
[                                                           ]
[ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ]

Difficulty: 1461501637330902918203684832716283019655932542976
Search: 12jbtzBb54r97TCwW3G1gCFoumpckRAPdY [Compressed]
Start Fri Sep 22 23:32:33 2023
Base Key: Randomly changed every 5 Mkeys
Number of CPU thread: 2

Bit 28 CPU Base Key thId 0: F3DDC63

Bit 28 CPU Base Key thId 1: CFD7541
[1.82 Mkey/s][GPU 0.00 Mkey/s][Total 2^22.86][Prob 0.0%][50% in 1.76379e+34y][Found 0]
Bit 28 CPU Base Key thId 1: D299DE3

Bit 28 CPU Base Key thId 0: BAC1B81
[1.73 Mkey/s][GPU 0.00 Mkey/s][Total 2^23.78][Prob 0.0%][50% in 1.85735e+34y][Found 0]
Bit 28 CPU Base Key thId 1: CC24254

Bit 26 Base Key thId 0: 2165974 < 8000000 or > FFFFFFF Rekey true

Bit 28 CPU Base Key thId 0: CC18276
[1.69 Mkey/s][GPU 0.00 Mkey/s][Total 2^24.33][Prob 0.0%][50% in 1.8972e+34y][Found 0]
Bit 27 Base Key thId 1: 4B1D339 < 8000000 or > FFFFFFF Rekey true

Bit 28 CPU Base Key thId 1: D517B81

Bit 26 Base Key thId 0: 24181FC < 8000000 or > FFFFFFF Rekey true

Bit 26 Base Key thId 0: 2639DB4 < 8000000 or > FFFFFFF Rekey true

Bit 27 Base Key thId 0: 5992E85 < 8000000 or > FFFFFFF Rekey true

Bit 26 Base Key thId 0: 3AE84E6 < 8000000 or > FFFFFFF Rekey true

Bit 28 CPU Base Key thId 0: DF7A263
[1.68 Mkey/s][GPU 0.00 Mkey/s][Total 2^24.73][Prob 0.0%][50% in 1.91598e+34y][Found 0]
Bit 27 Base Key thId 1: 596F852 < 8000000 or > FFFFFFF Rekey true

Bit 27 Base Key thId 1: 5005795 < 8000000 or > FFFFFFF Rekey true

Bit 28 CPU Base Key thId 1: C626164

Bit 28 CPU Base Key thId 0: D72E1A1
[1.63 Mkey/s][GPU 0.00 Mkey/s][Total 2^24.90][Prob 0.0%][50% in 1.97098e+34y][Found 0]

  Addr :12jbtzBb54r97TCwW3G1gCFoumpckRAPdY
  Check:12jbtzBb54r97TCwW3G1gCFoumpckRAPdY

!!! Result.txt Found key: D916CE8
!!! Result.txt Found key: D916CE8
!!! Result.txt Found key: D916CE8
!!! Result.txt Found key: D916CE8
!!! Result.txt Found key: D916CE8

Has anyone used OpenSSL to generate keys?
Probably not..

nomachine

member

Activity: 462

Merit: 24

Quote from: digaran on September 19, 2023, 03:04:47 PM

Script above is the python version of your code written in alien language, I'm on phone so I couldn't test to see if it works, later I will test it on my laptop and fix any issues. Insha'Allah. ( God willing )

Also;
Thanks for the update on the code, appreciate it. My scripts ( small part of them ) don't need much speed because they are not supposed to auto solve a key, they are intended as learning tools, I talked about improving performance to make king of information stop whining so much. 🤣

I use GMP even for random number generation..I'm playing around with collisions and cycles now. Grin

Code:

import sys
import os
import time
import gmpy2
from gmpy2 import mpz
from functools import lru_cache
import secp256k1 as ice
import multiprocessing
from multiprocessing import Pool, cpu_count

# Constants
MODULO = gmpy2.mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F)
ORDER = gmpy2.mpz(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141)
GX = gmpy2.mpz(0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798)
GY = gmpy2.mpz(0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8)

# Define Point class
class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

PG = Point(GX, GY)
ZERO_POINT = Point(0, 0)

# Function to multiply a point by 2
@lru_cache(maxsize=None)
def multiply_by_2(P, p=MODULO):
    c = gmpy2.f_mod(3 * P.x * P.x * gmpy2.powmod(2 * P.y, -1, p), p)
    R = Point()
    R.x = gmpy2.f_mod(c * c - 2 * P.x, p)
    R.y = gmpy2.f_mod(c * (P.x - R.x) - P.y, p)
    return R

# Function to add two points
@lru_cache(maxsize=None)
def add_points(P, Q, p=MODULO):
    dx = Q.x - P.x
    dy = Q.y - P.y
    c = gmpy2.f_mod(dy * gmpy2.invert(dx, p), p)
    R = Point()
    R.x = gmpy2.f_mod(c * c - P.x - Q.x, p)
    R.y = gmpy2.f_mod(c * (P.x - R.x) - P.y, p)
    return R

# Function to calculate Y-coordinate from X-coordinate
@lru_cache(maxsize=None)
def x_to_y(X, y_parity, p=MODULO):
    Y = gmpy2.mpz(3)
    tmp = gmpy2.mpz(1)

    while Y > 0:
        if Y % 2 == 1:
            tmp = gmpy2.f_mod(tmp * X, p)
        Y >>= 1
        X = gmpy2.f_mod(X * X, p)

    X = gmpy2.f_mod(tmp + 7, p)

    Y = gmpy2.f_div(gmpy2.add(p, 1), 4)
    tmp = gmpy2.mpz(1)

    while Y > 0:
        if Y % 2 == 1:
            tmp = gmpy2.f_mod(tmp * X, p)
        Y >>= 1
        X = gmpy2.f_mod(X * X, p)

    Y = tmp

    if Y % 2 != y_parity:
        Y = gmpy2.f_mod(-Y, p)

    return Y

# Function to compute a table of points
def compute_point_table():
    points = [PG]
    for k in range(255):
        points.append(multiply_by_2(points[k]))
    return points

POINTS_TABLE = compute_point_table()

# Global event to signal all processes to stop
STOP_EVENT = multiprocessing.Event()

# Function to check and compare points for potential solutions
def check(P, Pindex, DP_rarity, A, Ak, B, Bk):
    check_modulo = gmpy2.f_mod(P.x, DP_rarity)
    
    if check_modulo != 0:
        return False

    message = f"\r[+] [Pindex]: {mpz(Pindex)}"
    messages = []
    messages.append(message)
    output = "\033[01;33m" + ''.join(messages) + "\r"
    sys.stdout.write(output)
    sys.stdout.flush()

    A.append(mpz(P.x))
    Ak.append(mpz(Pindex))

    collision_index_A = find_collision(Ak)
    if collision_index_A is not None:
        return comparator(A, Ak, B, Bk, collision_index_A)

    collision_index_B = find_collision(Bk)
    if collision_index_B is not None:
        return comparator(A, Ak, B, Bk, collision_index_B)

    return False

# Cycle detection function for Ak
def find_collision(Ak):
    seen = set()
    for i, item in enumerate(Ak):
        if item in seen:
            return mpz(i)  # Collision detected, return as mpz
        seen.add(item)
    return None  # No collision detected

# Cycle detection function for Bk
def find_collision(Bk):
    seen = set()
    for i, item in enumerate(Bk):
        if item in seen:
            return mpz(i)  # Collision detected, return as mpz
        seen.add(item)
    return None  # No collision detected

# Function to compare two sets of points and find a common point
def comparator(A, Ak, B, Bk, collision_index):
    global STOP_EVENT
    result = set(A).intersection(set(B))
    if result:
        sol_kt = A.index(next(iter(result)))
        sol_kw = B.index(next(iter(result)))
        difference = Ak[sol_kt] - Bk[sol_kw]
        HEX = "%064x" % difference
        wifc = ice.btc_pvk_to_wif("%064x" % mpz(difference))
        dec = int(ice.btc_wif_to_pvk_hex(wifc), 16)
        wifu = ice.btc_pvk_to_wif(HEX, False)  # Uncompressed
        uaddr = ice.privatekey_to_address(0, False, dec)  # Uncompressed
        caddr = ice.privatekey_to_address(0, True, dec)  # Compressed
        HASH160 = ice.privatekey_to_h160(0, True, dec).hex()
        t = time.ctime()
        total_time = time.time() - starttime
        print(f"\033[32m[+] PUZZLE SOLVED: {t}, total time: {total_time:.2f} sec \033[0m")
        print(f"\033[32m[+] WIF: \033[32m {wifc} \033[0m")
        with open("KEYFOUNDKEYFOUND.txt", "a") as file:
            file.write("\n\nPUZZLE SOLVED " + t)
            file.write(f"\nTotal Time: {total_time:.2f} sec")
            file.write('\nPrivate Key (dec): ' + str(dec))
            file.write('\nPrivate Key (hex): ' + HEX)
            file.write('\nPrivate Key Compressed: ' + wifc)
            file.write('\nPrivate Key Uncompressed: ' + wifu)
            file.write('\nPublic Address Compressed: ' + caddr)
            file.write('\nPublic Address Uncompressed: ' + uaddr)
            file.write('\nPublic Key Hash Compressed (Hash 160): ' + HASH160)
            file.write(
                "\n-------------------------------------------------------------------------------------------------------------------------------------\n"
            )

        STOP_EVENT.set()  # Set the stop event to signal all processes

# Memoization for point multiplication
ECMULTIPLY_MEMO = {}

# Function to multiply a point by a scalar
def ecmultiply(k, P=PG, p=MODULO):
    if k == 0:
        return ZERO_POINT
    elif k == 1:
        return P
    elif k % 2 == 0:
        if k in ECMULTIPLY_MEMO:
            return ECMULTIPLY_MEMO[k]
        else:
            result = ecmultiply(k // 2, multiply_by_2(P, p), p)
            ECMULTIPLY_MEMO[k] = result
            return result
    else:
        return add_points(P, ecmultiply((k - 1) // 2, multiply_by_2(P, p), p))

# Recursive function to multiply a point by a scalar
def mulk(k, P=PG, p=MODULO):
    if k == 0:
        return ZERO_POINT
    elif k == 1:
        return P
    elif k % 2 == 0:
        return mulk(k // 2, multiply_by_2(P, p), p)
    else:
        return add_points(P, mulk((k - 1) // 2, multiply_by_2(P, p), p))

# Generate a list of powers of two for faster access
@lru_cache(maxsize=None)
def generate_powers_of_two(hop_modulo):
    return [mpz(1 << pw) for pw in range(hop_modulo)]

# Worker function for point search
def search_worker(Nt, Nw, puzzle, tortoise_power, starttime, lower_range_limit, upper_range_limit):
    global STOP_EVENT

    random_state_t = gmpy2.random_state(hash(gmpy2.random_state()))
    random_state_w = gmpy2.random_state(hash(gmpy2.random_state()))

    t = [mpz(lower_range_limit + gmpy2.mpz_random(random_state_t, upper_range_limit - lower_range_limit)) for _ in range(Nt)]
    T = [mulk(ti) for ti in t]
    dt = [mpz(0) for _ in range(Nt)]
    
    w = [gmpy2.mpz_random(random_state_w, upper_range_limit - lower_range_limit) for _ in range(Nt)]
    W = [add_points(W0, mulk(wk)) for wk in w]
    dw = [mpz(0) for _ in range(Nw)]

    Hops, Hops_old = 0, 0

    oldtime = time.time()
    starttime = oldtime

    while True:
        for k in range(Nt):
            Hops += 1
            pw = T[k].x % hop_modulo
            dt[k] = powers_of_two[pw]
            solved = check(T[k], t[k], DP_rarity, T, t, W, w)
            if solved:
                STOP_EVENT.set()
                raise SystemExit
            t[k] += dt[k]
            T[k] = add_points(POINTS_TABLE[pw], T[k])

        for k in range(Nw):
            Hops += 1
            pw = W[k].x % hop_modulo
            dw[k] = powers_of_two[pw]
            solved = check(W[k], w[k], DP_rarity, W, w, T, t)
            if solved:
                STOP_EVENT.set()
                raise SystemExit
            w[k] += dw[k]
            W[k] = add_points(POINTS_TABLE[pw], W[k])

        if STOP_EVENT.is_set():
            break


# Main script
if __name__ == "__main__":
    os.system("clear")
    t = time.ctime()
    sys.stdout.write("\033[01;33m")
    sys.stdout.write(f"[+] {t}" + "\n")
    sys.stdout.write(f"[+] Cycle detected, applying Floyd's cycle-finding algorithm..." + "\n")
    sys.stdout.flush()
    # Configuration for the puzzle
    puzzle = 50
    compressed_public_key = "03f46f41027bbf44fafd6b059091b900dad41e6845b2241dc3254c7cdd3c5a16c6"  # Puzzle 50
    lower_range_limit = 2 ** (puzzle - 1)
    upper_range_limit = (2 ** puzzle) - 1
    tortoise_power = puzzle // 8
    Nt = Nw = (2 ** tortoise_power // puzzle) * puzzle + 8
    DP_rarity = 8 * puzzle
    hop_modulo = (puzzle // 2) + 8

    # Precompute powers of two for faster access
    powers_of_two = generate_powers_of_two(hop_modulo)

    T, t, dt = [], [], []
    W, w, dw = [], [], []

    if len(compressed_public_key) == 66:
        X = mpz(compressed_public_key[2:66], 16)
        Y = x_to_y(X, mpz(compressed_public_key[:2]) - 2)
    else:
        print("[error] pubkey len(66/130) invalid!")

    print(f"[+] [Puzzle]: {puzzle}")
    print(f"[+] [Lower range limit]: {lower_range_limit}")
    print(f"[+] [Upper range limit]: {upper_range_limit}")
    print("[+] [Xcoordinate]: %064x" % X)
    print("[+] [Ycoordinate]: %064x" % Y)

    W0 = Point(X, Y)
    starttime = oldtime = time.time()

    Hops = 0

    process_count = cpu_count()
    print(f"[+] Using {process_count} CPU cores for parallel search")

    # Create a pool of worker processes
    pool = Pool(process_count)
    results = pool.starmap(
        search_worker,
        [
            (
                Nt,
                Nw,
                puzzle,
                tortoise_power,
                starttime,
                lower_range_limit,
                upper_range_limit,
            )
        ]
        * process_count,
    )
    pool.close()
    pool.join()

digaran

copper member

Activity: 1330

Merit: 899

🖤😏

Quote from: nomachine on September 21, 2023, 09:49:00 AM

Quote from: digaran on September 21, 2023, 03:46:26 AM

Quote from: bestie1549 on September 20, 2023, 09:48:00 PM

if you do your math well
the normal time for scanning the 66 bit range on an average cpu would take nothing less than 500 years

28 months running 1000 GPUs, nonstop.

Imagine that electricity bill at the household rate. Grin

Ok then, lets materialize our imagination, if we want to be fair, we should say the time taken to solve 66 is 14 month and not 28 month. Right?

14 month = 420 days.
420 days = 10080 hours.
RTX 3090 rental price = $0.20/hr
1 RTX 3090 rented for 10080 hours = $2016
1000 RTX 3090 rented for 10080 hours = $2016000
We will use a discounted price of $2,000,000 USD.

Puzzle 66 contains 6.6 bitcoins, at a price of $30,000. 6.6 * 30,000 = $198000.

In the future when bitcoin is at $100,000 * 6.6 = $660,000.
Further in the future, bitcoin is at $300,000. tech has advanced, speed of key per second is now 10B/s. So we just need 100 GPUs.
100 * $2016 = $201,600. With discount is $200,000 cost of finding #66, and bitcoin at 300k, now puzzle reward is worth $1,980,000 - 200,000 = $1,780,000 profit.

Question, when will we see GPU speed jumping from 1B/s to 10B/s, and bitcoin price at $300,000?
Even then what about #67, two times harder than #66 in theory, #68, #69, #70?

It's either profitable to rent GPUs and find them, or will be profitable in the future, in both cases, nothing really changes, nobody is gonna come up with a solution and an algorithm to brute force keys with 10B/s rate in the next 10 years.

nomachine

member

Activity: 462

Merit: 24

Quote from: digaran on September 21, 2023, 03:46:26 AM

Quote from: bestie1549 on September 20, 2023, 09:48:00 PM

if you do your math well
the normal time for scanning the 66 bit range on an average cpu would take nothing less than 500 years

28 months running 1000 GPUs, nonstop.

Imagine that electricity bill at the household rate. Grin

citb0in

hero member

Activity: 630

Merit: 731

Bitcoin g33k

Quote from: BarryWood on September 20, 2023, 07:47:18 PM

Since Puzzle 64 was found 2022-09-10
does that mean it's been a year now 2023-09-20 and still the search for Puzzle 66 on going?!

puzzle #64 was found on 2022-09-09
puzzle #65 was found already on 2019-06-07
puzzle #120 was found on 2023-02-27 but the privkey was not revealed yet

correct, puzzle #66 is still ongoing ...

digaran

copper member

Activity: 1330

Merit: 899

🖤😏

Quote from: bestie1549 on September 20, 2023, 09:48:00 PM

if you do your math well
the normal time for scanning the 66 bit range on an average cpu would take nothing less than 500 years

How did you calculate to get 500 years? An average cpu is useless, with a good GPU you could get 1 billion keys per second which would take 2339 years to search the entire 66 bit range, even if we divide that time by half, we get 1169 years with an average GPU. If you run 1000 GPUs each at 1B/s for more than 14 months, you could search half the range of 2^66, if the key is not there, you'd need to keep searching, in total to make sure 66 bit is searched completely, 28 months running 1000 GPUs, nonstop.

Also addresses with revealed pubs are not solvable every 4 to 6 month, if you are using kangaroo, it will get more difficult as each key range is 32 times larger than the previous key range, unless you know some tricks to reduce this range, otherwise you should at least multiply the time by 8, so if 125 took 4 months, 130 should take around 32 months. Then even if we double that time, we can expect 135 to take at least 64 months.

Note, my calculations are estimates.

bestie1549

jr. member

Activity: 75

Merit: 5

Quote from: BarryWood on September 20, 2023, 07:47:18 PM

Quote from: digaran on September 20, 2023, 12:45:26 PM

Quote from: BarryWood on September 20, 2023, 05:25:22 AM

I really appreciate your advice, yeah i was just wondering if i could try my luck with all the unsolved addresses at once lmao.

If anyone can correct me with this:
Since Puzzle 64 was found 2022-09-10
does that mean it's been a year now 2023-09-20 and still the search for Puzzle 66 on going?!

if you do your math well
the normal time for scanning the 66 bit range on an average cpu would take nothing less than 500 years
now we have pools that are scanning and they're barely 4% gone on the 66 bit range...
so this is to tell you that you should expect at least another 1 or 2 more years for the 66 bit range to be defeated successfully
but the pubkey ranges might be the appropriate range of choice for you as these gets defeated almost every 4 to 6 months

BarryWood

newbie

Activity: 4

Merit: 0

Quote from: digaran on September 20, 2023, 12:45:26 PM

Quote from: BarryWood on September 20, 2023, 05:25:22 AM

I really appreciate your advice, yeah i was just wondering if i could try my luck with all the unsolved addresses at once lmao.

If anyone can correct me with this:
Since Puzzle 64 was found 2022-09-10
does that mean it's been a year now 2023-09-20 and still the search for Puzzle 66 on going?!

digaran

copper member

Activity: 1330

Merit: 899

🖤😏

Quote from: BarryWood on September 20, 2023, 05:25:22 AM

Question please: I took the unsolved address from a text file in keyhunt i think there's about 80 addresses in there,
and tried to pass them to cubitcrack using -i to read from the file but it always gives me an error, but if the files has just few address cubitcrack works!
any idea how to fix that or work around it?

I never used any of those tools, but if you are searching for puzzle 66 in 66 bit range, you only need puzzle 66 address, unless you are trying to search a larger range which is pointless and a waste of your time and resources.

I have said this many times, brute forcing for addresses with no good hardware is futile. If you want to test your "luck" try buying a lottery ticket with closed eyes, just pick randomly, you'd have billion times more chance to win than finding a key using a gaming pc.

Last year, I was like you, I spent 4 months trying to find addresses, but then I realized there is a shortcut which is elliptic curve and math, you should skip this stage and mutate into the higher stages, learn how to do EC operations, division, subtraction etc.

If someone had told me this back then, I would be 4, 5 months ahead. Not that changes anything, but my time would not be wasted.

BarryWood

newbie

Activity: 4

Merit: 0

Quote from: digaran on September 19, 2023, 09:52:28 AM

Quote from: BarryWood on September 19, 2023, 08:09:26 AM

Oh hey Barry (west allen ) lol. Welcome to the jungle club of pointless puzzle hunters.
in the flash, not the fastest tho probably not the brightest too lol

Now I have questions, what hardware do you have? just an old gaming computer i5 4 cores, 16 gb ram and 1060 6gb which surprisingly still run all the games!
What have you learned about elliptic curve cryptography? i know absolutely nothing about it, i always see people here talking about it and doing some math i couldn't get.

Thank you for the tips, I think it's not just a challenge made by one person but a security test from some big entity whom are already deep in bitcoin or willing to go deeper!
Also this challenge made me worried Huh

about my own wallets if some lucky gpu "boi" scanning the whole addresses trying to get lucky.
But then knowing i've been trying to get lucky myself for the past month with just "puzzle" 66 and it's very hard gave me q relief Cheesy

knowing it's super difficult!

i always get about $200 in electricity bill, the past month using keyhunt and bitcrack every night keeping the computer on the bill came with $400

Question please: I took the unsolved address from a text file in keyhunt i think there's about 80 addresses in there,
and tried to pass them to cubitcrack using -i to read from the file but it always gives me an error, but if the files has just few address cubitcrack works!
any idea how to fix that or work around it?

digaran

copper member

Activity: 1330

Merit: 899

🖤😏

Quote from: s.john on September 19, 2023, 11:11:40 PM

I think the puzzle creator should reveal the public keys for all the keys bigger than 120bit except 124, 134, 144, 154, this will make the challenge reflect the true strength of bitcoin security.

I'm not sure if a gold hoarding dragon is interested to risk more than what is already at risk. Lol.
But seriously if he wants to keep the coins there forever and not touch them, it would be better to move them to exposed public keys, because address brute force is practically pointless, unless he intends to wait and see what happens to technology 40 years from now, so practically unexposed keys above 80 bits serving no purpose, while as you said it, moving those coins to public keys would increase the incentive for new bloods joining this challenge.

I'm guessing he has either left the community "again" like in 2010 ( edit: this part was unfair, recently he increased the prize, I regret saying this part ), or he doesn't care about anything other than his fortune, as per usual.

We only live once, if we don't jump we'll never find out, that's why they call it leap of faith. You only find out after jumping.😉

s.john

jr. member

Activity: 38

Merit: 8

I think the puzzle creator should reveal the public keys for all the keys bigger than 120bit except 124, 134, 144, 154, this will make the challenge reflect the true strength of bitcoin security.

Topic: Bitcoin puzzle transaction ~32 BTC prize to who solves it - page 142. (Read 215539 times)