Bitcoin puzzle transaction ~32 BTC prize to who solves it

[Cricktor]

it’s not very obvious to me what you’re talking about, but I noticed transfers of 1000 satoshi to some wallets. (?)

Puzzle addresses which are multiples of 5 have a spending transaction which exposes the public key. That's the main difference compared to puzzles which are not multiples of 5.

An exposed public key allows other more efficient attacks like Kangaroo to find the private key. That's why #75, #80, #85, ... #130 are all already solved while determined solvers still grind on #71 where the public key is not exposed. No better (actually working!) method has been proposed than brute-force search in the key space range of such a puzzle without known public key.

If the public key of #71 were to be exposed by a silly public withdrawal of a retarded solver, bots would solve it within seconds and try to steal the funds via full-RBF replacement of the withdrawal transaction waiting in mempools for confirmation.


Can you stop violating rule #32 of Unofficial list of (official) Bitcointalk.org rules, guidelines, FAQ!

[0x6667d]

it’s not very obvious to me what you’re talking about, but I noticed transfers of 1000 satoshi to some wallets. (?)

Puzzle addresses which are multiples of 5 have a spending transaction which exposes the public key. That's the main difference compared to puzzles which are not multiples of 5.

An exposed public key allows other more efficient attacks like Kangaroo to find the private key. That's why #75, #80, #85, ... #130 are all already solved while determined solvers still grind on #71 where the public key is not exposed. No better (actually working!) method has been proposed than brute-force search in the key space range of such a puzzle without known public key.

If the public key of #71 were to be exposed by a silly public withdrawal of a retarded solver, bots would solve it within seconds and try to steal the funds via full-RBF replacement of the withdrawal transaction waiting in mempools for confirmation.


Can you stop violating rule #32 of Unofficial list of (official) Bitcointalk.org rules, guidelines, FAQ!

Thx a lot!
Oh, I'm sorry. I will definitely read these rules

[Anas35]

Hey guys, instead of wasting your eye sight on long and useless base58 WIFs which literally represent 0s in hexadecimal, let me share a little secret regarding public keys.

Here is how you can find half of your public key, it's not straight forward method but I bet many of you didn't know about it.

First we need to extract 1 and half of our public key then we can subtract our p which is 1 from it's 1.5 to get it's 0.5 half. Though we could just divide it by 2 without all this trouble, this is a hint to make you dive deeper in to this vast ocean of numbers and equations.

Target  pub:

Code:

03219b4f9cef6c60007659c79c45b0533b3cc9d916ce29dbff133b40caa2e96db8

Target priv:

Code:

0x800000000000

Our multiplier inverse or not doesn't matter, +n will give you +n result and vice versa.

Scalar : aka n/2+1 half n +1 or 1 and half of n.

Code:

7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a2

If you multiply our target pub with scalar above, you will get this :
Pub2 :

Code:

02161c6cbee1483deaf6f9b395c817eb019228cda5afac5857295ba10959dffc96

Priv :

Code:

0xc00000000000

Now if we subtract target from pub2, we will get :

Pub3, half of target :

Code:

0313d1ffc481509beee68f17d8ff41c2590f4c85f15268605087eda8bab4e218da

Priv :

Code:

0x400000000000

We didn't even use division, *chop chop and good luck diving.😅


* = hurry! Get to work.

 I rather be use the target public key is then (using ecdsa arithmetic) reduced subseqentially until hitting one of the rendezvous point. Given G is the generator point, and  R=x*G the rendezvous point (which private key is known).

and BSGS.

u just like a teacher on class math in 4th grade lmao.


----------

There's i got brute the WIF and it's manually not any application or program i use.

I just use called MATH.

i just make key range more better for fast scan at the lower and upper range.

Puzzle 130 addresses 1Fo65aKq8s8iquMt6weF1rku1moWVEd5Ua


   2baf7cf4d51574f5deee49961d9609ac6 # 1FHMVBF6Z5ebm5LJKRpkZs8RjNJXUMyUVV # KwDiBf89QgGbjEhKnhXJuH85q VZKQivFjnRMPNnqDyFoSqrSaKfd
   2baf78fec51be4f59eaf6966bd9709ac6 # 1FXUvZnrcqRnJV1Cvre2ribDz6yKqQugjR # KwDiBf89QgGbjEhKnhXJuH85q VMiSmxd4F8urBwimS72wrJD2XYS
   2baf78fac5b3e4f6feaf6962bd9709ac6 # 1FqZVS2u9iqcycye9BmtVEcCGM6wCYXHM2 # KwDiBf89QgGbjEhKnhXJuH85q VMfnuJPyuPyvjexRvRbBdvgeEZd
   2baf78fac5b3e4f6feaf6942bd9709ac6 # 1Fe7X3dKymfuae7xLDZ9Hk5dn9W5pf4SE8 # KwDiBf89QgGbjEhKnhXJuH85q VMfnuJPyuPyvjAC4AFCc3v8Pooi
   2baf78fac5b3e4f6feaf69c2bf1709ac6 # 1FnUH4z8cgLuWBLFFWvXBDdQ1VfFc4SM1k # KwDiBf89QgGbjEhKnhXJuH85q VMfnuJPyuPyvm9FrvdFhuoEb9k1
   2baf78fac5b3e4f6feaf69f2bf9a8a46c # 1FfUFwHRS4cEESP3JDBMQMaZxLCZTN8tY  # KwDiBf89QgGbjEhKnhXJuH85q VMfnuJPyuPyvmtQXdpe3Zfy6UtD
   2baf78fac5b3e4d018100000000000000 # 1F2nhqcHQRKwjjokgkKkcSpLH4uucuQZSV # KwDiBf89QgGbjEhKnhXJuH85q VMfnuJPuxaPiBGv4PL2aFAnuFR8
   3baf70fac037e51011500040000000000 # 1FpLqZyycLiaLWQ6Lbe5zcXuypbX6F7q4C # KwDiBf89QgGbjEhKnhXJuH8Ma WVpmffaLXxzgafdFBXKhAAvtpYn
   3baf7efac999e3c95c4ea7660b9946c94 # 1Fcmac1xrLNMMr286BsFnWN35pFNgZeWWb # KwDiBf89QgGbjEhKnhXJuH8Ma XCqFfLS8nKhgd7RpHR2XZB5AKhx
   3baf7efac999e3cddc6ba764fb9b66cb4 # 1FqfgJmp8AKvDkAKbUcncgMA7kmDn9dJ2v # KwDiBf89QgGbjEhKnhXJuH8Ma XCqFfLS9Eo6LP4p7NDXN5sx82Js
   3bbff6cba4bd242d6ceb2777fb9866ca4 # 1FfPWje1WcZ47fAKuGBijKsqhvF8bHzf3f # KwDiBf89QgGbjEhKnhXJuH8Me C7XhwLTtDcX5XKNNEHm7o8DUj98
   3bbff6cb95bca56cdee22756fb970bcaa # 1F2UYUqkShEp8aa9CCE6mKN3yLHbKpEPud # KwDiBf89QgGbjEhKnhXJuH8Me C7XfgWcWBrqsVyALfRFgYf7PCe9

i just hunt the pub and address by privK variation with 16 bit per each line of HEX.

just reminder, if you BSGS the full range this 130 Puzzle, it takes 13.8 billion years lmao.

Hey,

I would like to meet you on WhatsApp.  If you can please inbox me  I have a pattern but really confuses me in the recovery but with your help we definitely can find the right solution.

Thanks
Anaz

[pbies]

All these puzzle pvks could be generated this way:

(Python 3 script)

Code:

#!/usr/bin/env python3

from multiprocessing import Pool, cpu_count
from tqdm import tqdm
import sys, base58, random

from hdwallet import HDWallet
from hdwallet.cryptocurrencies import Bitcoin as BTC
from hdwallet.hds import BIP32HD

_hdwallet = HDWallet(cryptocurrency=BTC, hd=BIP32HD)

def pvk_to_wif2(key_hex: str) -> str:
	return base58.b58encode_check(b'\x80' + bytes.fromhex(key_hex)).decode()

def go(key_hex: str):
	_hdwallet.from_private_key(private_key=key_hex)
	wif = pvk_to_wif2(key_hex)
	out = (
		f"{key_hex}\n"
		f"{wif}\n"
		f"{_hdwallet.wif()}\n"
		f"{_hdwallet.address('P2PKH')}\n"
		f"{_hdwallet.address('P2SH')}\n"
		f"{_hdwallet.address('P2TR')}\n"
		f"{_hdwallet.address('P2WPKH')}\n"
		f"{_hdwallet.address('P2WPKH-In-P2SH')}\n"
		f"{_hdwallet.address('P2WSH')}\n"
		f"{_hdwallet.address('P2WSH-In-P2SH')}\n"
		f"\n"
	)
	return out

def gen():
	for i in range(0,256):
		j=2**i
		r=random.randint(j,j*2)
		yield hex(r)[2:].zfill(64)

def main():
	o = open('output.txt', 'w')

	for s in tqdm(range(0, 2049)):
		random.seed(s)
		with Pool(cpu_count()) as pool:
			for res in pool.imap_unordered(go, gen()):
				o.write("".join(res))

	print('\a', end='', file=sys.stderr)

if __name__ == '__main__':
	main()

[skedarve]

The truth is that I have a pattern and im willing to share it with someone who has a Voucher and can implement it in CUDA.

[snaz3d]

The truth is that I have a pattern and im willing to share it with someone who has a Voucher and can implement it in CUDA.

If there was one you wouldn't need a GPU implementation

[optioncmdPR]

                                       I think its time jump outside of the brute force box .
We can start here:


   Advanced Quadrilatic Axioconvergence Vector-point Enumerator
 - boundary limited scalar producer for elliptic curve point discovery -

 direction of vector slope set:
(u,v,w,z)
is purely a rule for how you move through the
quadrilateral (4‑square rooted integer)lattice:

(a,b,c,d)\rightarrow(a+u,\;b+v,\;c+w,\;d+z)
Every step produces a new 4‑tuple ,which produces a new scalar:

The scalar value itself is the EC private key that derives the pubkey,
of which is then  HASH160 'd
The vectors are the direction of the path you blaze in scalar space


5 use  examples of direction vectors, each chosen for a different
search behavior:


1.
Speedy Dense Local Walk (slow scalar drift) ( think asian shuffle)
These keep you in a tight scalar band and explore it thoroughly.
(1,1,1,1)
(2,1,0,1)
(3,2,1,0)
(1,0,0,0)  pure 1‑D walk
Behavior:
Small changes in (a,b,c,d)
Scalar k= a^2 + b^2 + c^2 + d^2
grows slowly
Good for narrow band search (e.g.,2130)

2.
Wide Scatter Walk (fast scalar drift)
These jump through scalar space aggressively.
(10_000,7,3,1)
(500_000,1000,10,1)
(2_000_000,1,1,1)
(100_000,100_000,100_000,100_000)
Behavior:
Large jumps in the 4‑square sum
Covers huge scalar ranges quickly
Good for broad exploration or randomized coverage

3.
Orthogonal/ Mixed Sign Vectors (cycle‑resistant)
These reduce repetition and avoid short loops.
(1,1,2,3)
(5,7,11,13)
(17,19,23,29)
(3,5,7,11)
Behavior:
Mixed signs prevent monotonic drift
Coprime components reduce periodicity
Excellent for long unique paths

4.
Pseudo‑Random Deterministic Vectors
Seeded from a passphrase, timestamp, etc

(27472219626,12597847844,6088408955,4465381162)←yourexample
(918273645,564738291,1029384756,675849302)
(123456789,987654321,192837465,564738291)
Behavior:
Looks random but fully reproducible
..for deterministic walks

5.Multi‑Ray (thread) SwarmVectors for parallel search.
Launches several rays from the same starting point.

(1,1,1,1)
(2,1,3,5)
(5,3,2,1)
(7,3,11,5)
(13,2,7,3)
(17,19,23,29)
(101,103,107,109)
(10000,7,3,1)


Behavior:
Each ray explores a different region
Maximizes coverage
Ideal for parallel CPU/GPU search


None of these vectors have any relationship to the target HASH160.
They only determine which scalars you will test.
The target HASH160 simply tells you when you hit the  correct scalar for it.
But hey, thats the ultimate goal anyway.

Code:

from ecdsa import SigningKey, VerifyingKey, SECP256k1
from ecdsa.util import number_to_string
from hashlib import sha256, new as hashlib_new
from binascii import unhexlify, hexlify

# helpers

def hash160(b: bytes) -> bytes:
    h = hashlib_new('ripemd160')
    h.update(sha256(b).digest())
    return h.digest()

def priv_to_pub_compressed(priv_int: int) -> bytes:
    sk = SigningKey.from_secret_exponent(priv_int, curve=SECP256k1)
    vk = sk.verifying_key
    x = vk.pubkey.point.x()
    y = vk.pubkey.point.y()
    prefix = b'\x02' if y % 2 == 0 else b'\x03'
    return prefix + number_to_string(x, SECP256k1.order)

def decompress_pubkey(comp: bytes):
    prefix = comp[0]
    x = int.from_bytes(comp[1:], "big")
    curve = SECP256k1.curve
    p = curve.p()

    y_sq = (x * x * x + 7) % p
    y = pow(y_sq, (p + 1) // 4, p)
    if (y % 2) != (prefix % 2):
        y = (-y) % p

    return curve.point(x, y)

def compress_point(P):
    x = P.x()
    y = P.y()
    prefix = b'\x02' if y % 2 == 0 else b'\x03'
    return prefix + number_to_string(x, SECP256k1.order)

def halve_pubkey(comp: bytes) -> bytes:
    P = decompress_pubkey(comp)
    n = SECP256k1.order
    inv2 = (n + 1) // 2
    halfP = P * inv2
    return compress_point(halfP)

#quadrilatics logic

def four_square_scalar(a, b, c, d, order):
    return (a*a + b*b + c*c + d*d) % order

def walk_four_square_ray(
    a0, b0, c0, d0,
    u, v, w, z,
    steps,
    target_hash160_hex=None,
    low_bound=None,
    high_bound=None,
):
    order = SECP256k1.order
    target_hash = None
    if target_hash160_hex:
        target_hash = unhexlify(target_hash160_hex.strip())

    a, b, c, d = a0, b0, c0, d0

    print("\nAdvanced Quadrilatic Axioconvergence Vector-point Enumerator")
    print(f"Start (a,b,c,d) = ({a0}, {b0}, {c0}, {d0})")
    print(f"Direction (u,v,w,z) = ({u}, {v}, {w}, {z})")
    print(f"Steps: {steps}")
    if target_hash is not None:
        print(f"Target HASH160: {target_hash160_hex}")
    if low_bound is not None or high_bound is not None:
        print(f"Scalar band filter: [{low_bound}, {high_bound}]")

    for i in range(steps):
        k = four_square_scalar(a, b, c, d, order)
        if k == 0:
            a += u; b += v; c += w; d += z
            continue

        if low_bound is not None and k < low_bound:
            a += u; b += v; c += w; d += z
            continue
        if high_bound is not None and k > high_bound:
            a += u; b += v; c += w; d += z
            continue

        pub = priv_to_pub_compressed(k)
        h = hash160(pub)

        # Show first few steps for sanity
        if i < 5:
            print(f"\nStep {i}")
            print(f"  (a,b,c,d) = ({a}, {b}, {c}, {d})")
            print(f"  scalar k  = {k}")
            print(f"  pub       = {hexlify(pub).decode()}")
            print(f"  HASH160   = {hexlify(h).decode()}")

        if target_hash is not None and h == target_hash:
            print("\n success ")
            print(f"Step: {i}")
            print(f"(a,b,c,d) = ({a}, {b}, {c}, {d})")
            print(f"scalar k   = {k}")
            print(f"pub        = {hexlify(pub).decode()}")
            print (f"HASH160 = {hexlify (h).decode ()}")
            return  # stop on first match

        a += u; b += v; c += w; d += z

    print("\nWalk is a complete failure ")

#main prompt engine

def read_tuple(prompt, count, default=None):
    s = input(prompt).strip()
    if s == "":
        if default is None:
            raise ValueError("No value provided for required tuple")
        return default
    parts = [p.strip() for p in s.split(",")]
    if len(parts) != count:
        raise ValueError(f"Expected {count} comma-separated values")
    return tuple(int(p) for p in parts)

def read_int(prompt, default=None):
    s = input(prompt).strip()
    if s == "":
        return default
    return int(s)

def main():
    print(" START ")

    print("\nEnter starting 4-square coordinates (a0, b0, c0, d0).")
    a0, b0, c0, d0 = read_tuple(
        "a0,b0,c0,d0 (comma sep, default 0,0,0,0): ",
        4,
        default=(0,0,0,0)
    )

    print("\nEnter direction vector (u, v, w, z).")
    u, v, w, z = read_tuple(
        "u,v,w,z (comma-separated, default 1,0,0,0): ",
        4,
        default=(1,0,0,0)
    )

    steps = read_int("\nNumber of steps (default 10): ", 10)

    target_hex = input("\nTarget HASH160 hex (optional, blank for none): ").strip()
    if target_hex == "":
        target_hex = None

    low_s = input("Low scalar bound (optional, blank for none): ").strip()
    high_s = input("High scalar bound (optional, blank for none): ").strip()
    low_bound = int(low_s) if low_s else None
    high_bound = int(high_s) if high_s else None

    walk_four_square_ray(
        a0, b0, c0, d0,
        u, v, w, z,
        steps,
        target_hash160_hex=target_hex,
        low_bound=low_bound,
        high_bound=high_bound,
    )

    print("\n end ")

if __name__ == "__main__":
    main()

[kTimesG]

  Advanced Quadrilatic Axioconvergence Vector-point Enumerator
 - boundary limited scalar producer for elliptic curve point discovery -

You've got too much free time.

[skedarve]

  Advanced Quadrilatic Axioconvergence Vector-point Enumerator
 - boundary limited scalar producer for elliptic curve point discovery -

You've got too much free time.

What do you think of my research? I dont know if you were able to see it, since I had to delete it.

[optioncmdPR]

  Advanced Quadrilatic Axioconvergence Vector-point Enumerator
 - boundary limited scalar producer for elliptic curve point discovery -

You've got too much free time.

guilty as charged, sir.

[skedarve]

  Advanced Quadrilatic Axioconvergence Vector-point Enumerator
 - boundary limited scalar producer for elliptic curve point discovery -

You've got too much free time.

guilty as charged, sir.

Im use  : 1x GPU T4

Iniciando búsqueda continua. Presiona Ctrl+C para detener.
Rango: 0x4002160ebffffffe - 0xffffffffffffffff
Claves por lanzamiento: 8388608000000
Reportes cada 60 segundos.

[ 174.8 s] Procesadas: 8388608000000 | Vel: 4.80e+10 keys/s | Candidatas acum: 0 | Última clave: 0x40021dafdffffffd
[ 355.7 s] Procesadas: 16777216000000 | Vel: 4.72e+10 keys/s | Candidatas acum: 0 | Última clave: 0x40022550fffffffd
[ 536.7 s] Procesadas: 25165824000000 | Vel: 4.69e+10 keys/s | Candidatas acum: 0 | Última clave: 0x40022cf21ffffffd
[ 718.2 s] Procesadas: 33554432000000 | Vel: 4.67e+10 keys/s | Candidatas acum: 0 | Última clave: 0x400234933ffffffd
[ 900.3 s] Procesadas: 41943040000000 | Vel: 4.66e+10 keys/s | Candidatas acum: 0 | Última clave: 0x40023c345ffffffd
[1081.7 s] Procesadas: 50331648000000 | Vel: 4.65e+10 keys/s | Candidatas acum: 0 | Última clave: 0x400243d57ffffffd
[1263.1 s] Procesadas: 58720256000000 | Vel: 4.65e+10 keys/s | Candidatas acum: 0 | Última clave: 0x40024b769ffffffd
[1444.2 s] Procesadas: 67108864000000 | Vel: 4.65e+10 keys/s | Candidatas acum: 0 | Última clave: 0x40025317bffffffd

[optioncmdPR]

  I don't want to engage in polemics with some forum members who believe that the only way to solve problems is brute force. Given the current state of computing power, this approach would take millennia or entail financial costs exceeding the prize. Essentially, they are suggesting to wait for technological progress or embark on a thousand-year journey. Any other approaches seem to offend them (apparently, they have already started down this path) and they react hysterically to such a position. Moreover, they promote this vision aggressively and tactlessly, insulting other opinions and approaches, much like an aggressive LGBT community. I think even monkey could solve it with a powerful GPU and the right program.
  Continuing to develop alternative approaches to problem-solving, I'm sharing one line of thought on how the task could be solved. Below is a list of private keys with their prime multipliers.
 1 -> 1
3 -> 3
7 -> 7
8 -> 2, 2, 2
21 -> 3, 7
49 -> 7, 7
76 -> 2, 2, 19
224 -> 2, 2, 2, 2, 2, 7
467 -> 467
514 -> 2, 257
1155 -> 3, 5, 7, 11
2683 -> 2683
5216 -> 2, 2, 2, 2, 2, 163
10544 -> 2, 2, 2, 2, 659
26867 -> 67, 401
51510 -> 2, 3, 5, 17, 101
95823 -> 3, 3, 3, 3, 7, 13, 13
198669 -> 3, 47, 1409
357535 -> 5, 23, 3109
863317 -> 7, 13, 53, 179
1811764 -> 2, 2, 19, 31, 769
3007503 -> 3, 3, 3, 23, 29, 167
5598802 -> 2, 11, 254491
14428676 -> 2, 2, 19, 189851
33185509 -> 7, 4740787
54538862 -> 2, 7, 7, 556519
111949941 -> 3, 43, 867829
227634408 -> 2, 2, 2, 3, 3, 3, 1053863
400708894 -> 2, 83, 2413909
1033162084 -> 2, 2, 47, 5495543
2102388551 -> 19, 19, 43, 167, 811
3093472814 -> 2, 23, 3001, 22409
7137437912 -> 2, 2, 2, 11, 751, 107999
14133072157 -> 19, 41, 131, 138493
20112871792 -> 2, 2, 2, 2, 13, 96696499
42387769980 -> 2, 2, 3, 3, 5, 235487611
100251560595 -> 3, 5, 6683437373
146971536592 -> 2, 2, 2, 2, 60037, 153001
323724968937 -> 3, 3, 138319, 260047
1003651412950 -> 2, 5, 5, 20073028259
1458252205147 -> 23, 63402269789
2895374552463 -> 3, 3, 59, 5452682773
7409811047825 -> 5, 5, 587, 2903, 173933
15404761757071 -> 2783789, 5533739
19996463086597 -> 157, 193, 7477, 88261
51408670348612 -> 2, 2, 5839, 2201090527
119666659114170 -> 2, 3, 3, 3, 5, 7, 17, 89, 41847781
191206974700443 -> 3, 13, 4902742941037
409118905032525 -> 3, 3, 5, 5, 23, 197, 1663, 241313
611140496167764 -> 2, 2, 3, 3, 12211, 1390232159
2058769515153876 -> 2, 2, 3, 7, 43, 53, 197, 2477, 22039
4216495639600700 -> 2, 2, 5, 5, 53, 795565215019
6763683971478124 -> 2, 2, 14359547, 117755873
9974455244496707 -> 7019, 76123, 18668011
30045390491869460 -> 2, 2, 5, 19, 79066817083867
44218742292676575 -> 3, 3, 5, 5, 13, 15117518732539
138245758910846492 -> 2, 2, 23, 1002377, 1499107913
199976667976342049 -> 13, 167, 2511323, 36678953
525070384258266191 -> 307, 307, 5571097669559
1135041350219496382 -> 2, 13, 31, 71, 269, 587, 3637, 34537
1425787542618654982 -> 2, 13, 54837982408409807
3908372542507822062 -> 2, 3, 43, 62922991, 240750329
8993229949524469768 -> 2, 2, 2, 7, 251, 2383, 268491108091
17799667357578236628 -> 2, 2, 3, 19, 3761, 408229, 50847529
30568377312064202855 -> 5, 67, 5639, 16181749866767
46346217550346335726 -> 2, 13, 17, 104855695815263203
132656943602386256302 -> 2, 23, 3881, 743067920652377
219898266213316039825 -> 5, 5, 7, 1973, 4986139, 127729817
297274491920375905804 -> 2, 2, 11, 139, 48606032034070619
970436974005023690481 -> 3, 59, 1931, 255473, 11113907731

As you can see from the list, these keys do not correspond to the generation of secure RSA keys, which typically have two or three small prime factors and one large factor exceeding the value of sqrt(private key).

For example, puzzle #68 is cryptographically weak (I think whoever created the puzzles intentionally made them vulnerable, or they follow certain patterns which consequently made them insecure.):
219898266213316039825 -> 5, 5, 7, 1973, 4986139, 127729817
since its greatest prime divisor < sqrt(private key).

That is, we would first find the largest possible value for the Greatest Prime Divisor (GPD) that is < 2^34. Then, using the Miller-Rabin Primality Test, we would check each prime number in descending order within the range where:
2^67 < Private Key = GPD * number < 2^68
and consequently,
2^67 / GPD < number < 2^68 / GPD.

But given approach will not wrok if private key is a prime number as puzzle number 12, or GPD of a key is GPD>sqrt(private key).

Currently, I have a simple program written in Python that checks 5000 prime numbers per second. I think if it were optimized for a GPU, it could solve the vulnerable keys among the subsequent ones in a few hours.

I feel that your research is meaningless, as the private key of Bitcoin has nothing to do with the RSA encryption you mentioned.
The private key of Bitcoin does not need to meet the requirements of RSA keys at all.

  Why are so sure that the keys were generated using anything related to bitcoin at all?

[kTimesG]

Why are so sure that the keys were generated using anything related to bitcoin at all?

Private keys are scalar numbers.

The creator stated that the private keys are consecutive keys from a deterministic wallet, masked accordingly. Basically, random numbers, unless you know the master seed.

A deterministic wallet is something that is related to Bitcoin.

And yeah, breaking the seed is harder then finding all the 256 private keys, combined.

[pbies]

I've made two scripts in python with prime numbers to eventually hit all puzzle:

Generate primes:

Code:

#!/usr/bin/env python3

from multiprocessing import Pool, cpu_count
from tqdm import tqdm
import sys

MAX_B = 1_000_000_000
CHUNK_SIZE = 1_000_000

def worker(args):
	start_x, end_x = args
	out = []

	for x in range(start_x, end_x):
		a = (x * 6) - 1
		b = (x * 6) + 1

		if a % 5 != 0:
			out.append(f"{a}\n")

		if b % 5 != 0:
			out.append(f"{b}\n")

		if b > MAX_B:
			break

	return "".join(out)

def generate_ranges():
	max_x = (MAX_B // 6) + 2
	for start in range(2, max_x, CHUNK_SIZE):
		end = min(start + CHUNK_SIZE, max_x)
		yield (start, end)

def main():
	with Pool(cpu_count()) as pool, open("primes02.txt", "w") as o:
		total_chunks = ((MAX_B // 6) + 2 + CHUNK_SIZE - 1) // CHUNK_SIZE

		for result in tqdm(
			pool.imap_unordered(worker, generate_ranges(), chunksize=1),
			total=total_chunks
		):
			o.write(result)

	print('\a', end='', file=sys.stderr)

if __name__ == '__main__':
	main()

Search with these primes:

Code:

#!/usr/bin/env python3

from multiprocessing import Pool, cpu_count
from tqdm import tqdm
import sys, base58, random
import itertools, math, time
from itertools import combinations

from hdwallet import HDWallet
from hdwallet.cryptocurrencies import Bitcoin as BTC
from hdwallet.hds import BIP32HD
from hdwallet.seeds import BIP39Seed

_hdwallet = HDWallet(cryptocurrency=BTC, hd=BIP32HD)

class Timer:
	def __enter__(self):
		self.start = time.perf_counter()
	def __exit__(self, type, value, traceback):
		self.end = time.perf_counter()
		print(f"This took: {self.end - self.start: .5f} seconds")

def pvk_to_wif2(key_hex):
	return base58.b58encode_check(b'\x80' + bytes.fromhex(key_hex)).decode()

targets=set()

def go(key_hex):
	_hdwallet.from_private_key(key_hex)
	t=_hdwallet.address('P2PKH')
	if t in targets:
		wif1 = pvk_to_wif2(key_hex)
		wif2 = _hdwallet.wif()
		line = f'{key_hex} {wif1} {wif2} {t}\n'
		with open('found.txt', 'a') as o:
			o.write(line)
			o.flush()

primes=set()

def gen():
	global primes
	for r in range(1, 6):
		i=itertools.product(primes, repeat=r)
		for j in i:
			k=math.prod(j)
			if k>=0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140:
				continue
			yield hex(k)[2:].zfill(64)

def main():
	global primes, targets
	print('Loading targets...', flush=True)
	targets=set(open('input.txt','r').read().splitlines())
	print('Loading primes...', flush=True)
	with Timer():
		primes_src=set(open('primes02.txt','r').read().splitlines())
	print('Converting primes...', flush=True)
	with Timer():
		primes = set( int(x) for x in primes_src )

	print('Starting search...', flush=True)
	tmp=0
	for r in range(1, 6):
		tmp+=len(primes)**r
	t=tqdm(total=tmp)
	with Pool(cpu_count()) as pool:
		for res in pool.imap_unordered(go, gen()):
			t.update()

	print('\a', end='', file=sys.stderr)

if __name__ == '__main__':
	main()

In input.txt file you need unhit puzzle addresses:

Code:

1PWo3JeB9jrGwfHDNpdGK54CRas7fsVzXU
1JTK7s9YVYywfm5XUH7RNhHJH1LshCaRFR
12VVRNPi4SJqUTsp6FmqDqY5sGosDtysn4
1FWGcVDK3JGzCC3WtkYetULPszMaK2Jksv
1DJh2eHFYQfACPmrvpyWc8MSTYKh7w9eRF
1Bxk4CQdqL9p22JEtDfdXMsng1XacifUtE
15qF6X51huDjqTmF9BJgxXdt1xcj46Jmhb
1ARk8HWJMn8js8tQmGUJeQHjSE7KRkn2t8
15qsCm78whspNQFydGJQk5rexzxTQopnHZ
13zYrYhhJxp6Ui1VV7pqa5WDhNWM45ARAC
14MdEb4eFcT3MVG5sPFG4jGLuHJSnt1Dk2
1CMq3SvFcVEcpLMuuH8PUcNiqsK1oicG2D
1K3x5L6G57Y494fDqBfrojD28UJv4s5JcK
1PxH3K1Shdjb7gSEoTX7UPDZ6SH4qGPrvq
16AbnZjZZipwHMkYKBSfswGWKDmXHjEpSf
19QciEHbGVNY4hrhfKXmcBBCrJSBZ6TaVt
1EzVHtmbN4fs4MiNk3ppEnKKhsmXYJ4s74
1AE8NzzgKE7Yhz7BWtAcAAxiFMbPo82NB5
17Q7tuG2JwFFU9rXVj3uZqRtioH3mx2Jad
1K6xGMUbs6ZTXBnhw1pippqwK6wjBWtNpL
15ANYzzCp5BFHcCnVFzXqyibpzgPLWaD8b
18ywPwj39nGjqBrQJSzZVq2izR12MDpDr8
1CaBVPrwUxbQYYswu32w7Mj4HR4maNoJSX
1JWnE6p6UN7ZJBN7TtcbNDoRcjFtuDWoNL
1CKCVdbDJasYmhswB6HKZHEAnNaDpK7W4n
1PXv28YxmYMaB8zxrKeZBW8dt2HK7RkRPX
1AcAmB6jmtU6AiEcXkmiNE9TNVPsj9DULf
1EQJvpsmhazYCcKX5Au6AZmZKRnzarMVZu
18KsfuHuzQaBTNLASyj15hy4LuqPUo1FNB
15EJFC5ZTs9nhsdvSUeBXjLAuYq3SWaxTc
1HB1iKUqeffnVsvQsbpC6dNi1XKbyNuqao
1GvgAXVCbA8FBjXfWiAms4ytFeJcKsoyhL
1824ZJQ7nKJ9QFTRBqn7z7dHV5EGpzUpH3
18A7NA9FTsnJxWgkoFfPAFbQzuQxpRtCos
1NeGn21dUDDeqFQ63xb2SpgUuXuBLA4WT4
174SNxfqpdMGYy5YQcfLbSTK3MRNZEePoy
1MnJ6hdhvK37VLmqcdEwqC3iFxyWH2PHUV
1KNRfGWw7Q9Rmwsc6NT5zsdvEb9M2Wkj5Z
1PJZPzvGX19a7twf5HyD2VvNiPdHLzm9F6
1GuBBhf61rnvRe4K8zu8vdQB3kHzwFqSy7
1GDSuiThEV64c166LUFC9uDcVdGjqkxKyh
1Me3ASYt5JCTAK2XaC32RMeH34PdprrfDx
1CdufMQL892A69KXgv6UNBD17ywWqYpKut
1BkkGsX9ZM6iwL3zbqs7HWBV7SvosR6m8N
1AWCLZAjKbV1P7AHvaPNCKiB7ZWVDMxFiz
1G6EFyBRU86sThN3SSt3GrHu1sA7w7nzi4
1MZ2L1gFrCtkkn6DnTT2e4PFUTHw9gNwaj
1Hz3uv3nNZzBVMXLGadCucgjiCs5W9vaGz
16zRPnT8znwq42q7XeMkZUhb1bKqgRogyy
1KrU4dHE5WrW8rhWDsTRjR21r8t3dsrS3R
17uDfp5r4n441xkgLFmhNoSW1KWp6xVLD
13A3JrvXmvg5w9XGvyyR4JEJqiLz8ZySY3
16RGFo6hjq9ym6Pj7N5H7L1NR1rVPJyw2v
1UDHPdovvR985NrWSkdWQDEQ1xuRiTALq
15nf31J46iLuK1ZkTnqHo7WgN5cARFK3RA
1Ab4vzG6wEQBDNQM1B2bvUz4fqXXdFk2WT
1Fz63c775VV9fNyj25d9Xfw3YHE6sKCxbt
1QKBaU6WAeycb3DbKbLBkX7vJiaS8r42Xo
1CD91Vm97mLQvXhrnoMChhJx4TP9MaQkJo
15MnK2jXPqTMURX4xC3h4mAZxyCcaWWEDD
13N66gCzWWHEZBxhVxG18P8wyjEWF9Yoi1
1NevxKDYuDcCh1ZMMi6ftmWwGrZKC6j7Ux
19GpszRNUej5yYqxXoLnbZWKew3KdVLkXg
1M7ipcdYHey2Y5RZM34MBbpugghmjaV89P
18aNhurEAJsw6BAgtANpexk5ob1aGTwSeL
1FwZXt6EpRT7Fkndzv6K4b4DFoT4trbMrV
1CXvTzR6qv8wJ7eprzUKeWxyGcHwDYP1i2
1MUJSJYtGPVGkBCTqGspnxyHahpt5Te8jy
13Q84TNNvgcL3HJiqQPvyBb9m4hxjS3jkV
1LuUHyrQr8PKSvbcY1v1PiuGuqFjWpDumN
18192XpzzdDi2K11QVHR7td2HcPS6Qs5vg
1NgVmsCCJaKLzGyKLFJfVequnFW9ZvnMLN
1AoeP37TmHdFh8uN72fu9AqgtLrUwcv2wJ
1FTpAbQa4h8trvhQXjXnmNhqdiGBd1oraE
14JHoRAdmJg3XR4RjMDh6Wed6ft6hzbQe9
19z6waranEf8CcP8FqNgdwUe1QRxvUNKBG
14u4nA5sugaswb6SZgn5av2vuChdMnD9E5
1NBC8uXJy1GiJ6drkiZa1WuKn51ps7EPTv

[skedarve]

I've made two scripts in python with prime numbers to eventually hit all puzzle:

Generate primes:

Code:

#!/usr/bin/env python3

from multiprocessing import Pool, cpu_count
from tqdm import tqdm
import sys

MAX_B = 1_000_000_000
CHUNK_SIZE = 1_000_000

def worker(args):
	start_x, end_x = args
	out = []

	for x in range(start_x, end_x):
		a = (x * 6) - 1
		b = (x * 6) + 1

		if a % 5 != 0:
			out.append(f"{a}\n")

		if b % 5 != 0:
			out.append(f"{b}\n")

		if b > MAX_B:
			break

	return "".join(out)

def generate_ranges():
	max_x = (MAX_B // 6) + 2
	for start in range(2, max_x, CHUNK_SIZE):
		end = min(start + CHUNK_SIZE, max_x)
		yield (start, end)

def main():
	with Pool(cpu_count()) as pool, open("primes02.txt", "w") as o:
		total_chunks = ((MAX_B // 6) + 2 + CHUNK_SIZE - 1) // CHUNK_SIZE

		for result in tqdm(
			pool.imap_unordered(worker, generate_ranges(), chunksize=1),
			total=total_chunks
		):
			o.write(result)

	print('\a', end='', file=sys.stderr)

if __name__ == '__main__':
	main()

Search with these primes:

Code:

#!/usr/bin/env python3

from multiprocessing import Pool, cpu_count
from tqdm import tqdm
import sys, base58, random
import itertools, math, time
from itertools import combinations

from hdwallet import HDWallet
from hdwallet.cryptocurrencies import Bitcoin as BTC
from hdwallet.hds import BIP32HD
from hdwallet.seeds import BIP39Seed

_hdwallet = HDWallet(cryptocurrency=BTC, hd=BIP32HD)

class Timer:
	def __enter__(self):
		self.start = time.perf_counter()
	def __exit__(self, type, value, traceback):
		self.end = time.perf_counter()
		print(f"This took: {self.end - self.start: .5f} seconds")

def pvk_to_wif2(key_hex):
	return base58.b58encode_check(b'\x80' + bytes.fromhex(key_hex)).decode()

targets=set()

def go(key_hex):
	_hdwallet.from_private_key(key_hex)
	t=_hdwallet.address('P2PKH')
	if t in targets:
		wif1 = pvk_to_wif2(key_hex)
		wif2 = _hdwallet.wif()
		line = f'{key_hex} {wif1} {wif2} {t}\n'
		with open('found.txt', 'a') as o:
			o.write(line)
			o.flush()

primes=set()

def gen():
	global primes
	for r in range(1, 6):
		i=itertools.product(primes, repeat=r)
		for j in i:
			k=math.prod(j)
			if k>=0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140:
				continue
			yield hex(k)[2:].zfill(64)

def main():
	global primes, targets
	print('Loading targets...', flush=True)
	targets=set(open('input.txt','r').read().splitlines())
	print('Loading primes...', flush=True)
	with Timer():
		primes_src=set(open('primes02.txt','r').read().splitlines())
	print('Converting primes...', flush=True)
	with Timer():
		primes = set( int(x) for x in primes_src )

	print('Starting search...', flush=True)
	tmp=0
	for r in range(1, 6):
		tmp+=len(primes)**r
	t=tqdm(total=tmp)
	with Pool(cpu_count()) as pool:
		for res in pool.imap_unordered(go, gen()):
			t.update()

	print('\a', end='', file=sys.stderr)

if __name__ == '__main__':
	main()

In input.txt file you need unhit puzzle addresses:

Code:

1PWo3JeB9jrGwfHDNpdGK54CRas7fsVzXU
1JTK7s9YVYywfm5XUH7RNhHJH1LshCaRFR
12VVRNPi4SJqUTsp6FmqDqY5sGosDtysn4
1FWGcVDK3JGzCC3WtkYetULPszMaK2Jksv
1DJh2eHFYQfACPmrvpyWc8MSTYKh7w9eRF
1Bxk4CQdqL9p22JEtDfdXMsng1XacifUtE
15qF6X51huDjqTmF9BJgxXdt1xcj46Jmhb
1ARk8HWJMn8js8tQmGUJeQHjSE7KRkn2t8
15qsCm78whspNQFydGJQk5rexzxTQopnHZ
13zYrYhhJxp6Ui1VV7pqa5WDhNWM45ARAC
14MdEb4eFcT3MVG5sPFG4jGLuHJSnt1Dk2
1CMq3SvFcVEcpLMuuH8PUcNiqsK1oicG2D
1K3x5L6G57Y494fDqBfrojD28UJv4s5JcK
1PxH3K1Shdjb7gSEoTX7UPDZ6SH4qGPrvq
16AbnZjZZipwHMkYKBSfswGWKDmXHjEpSf
19QciEHbGVNY4hrhfKXmcBBCrJSBZ6TaVt
1EzVHtmbN4fs4MiNk3ppEnKKhsmXYJ4s74
1AE8NzzgKE7Yhz7BWtAcAAxiFMbPo82NB5
17Q7tuG2JwFFU9rXVj3uZqRtioH3mx2Jad
1K6xGMUbs6ZTXBnhw1pippqwK6wjBWtNpL
15ANYzzCp5BFHcCnVFzXqyibpzgPLWaD8b
18ywPwj39nGjqBrQJSzZVq2izR12MDpDr8
1CaBVPrwUxbQYYswu32w7Mj4HR4maNoJSX
1JWnE6p6UN7ZJBN7TtcbNDoRcjFtuDWoNL
1CKCVdbDJasYmhswB6HKZHEAnNaDpK7W4n
1PXv28YxmYMaB8zxrKeZBW8dt2HK7RkRPX
1AcAmB6jmtU6AiEcXkmiNE9TNVPsj9DULf
1EQJvpsmhazYCcKX5Au6AZmZKRnzarMVZu
18KsfuHuzQaBTNLASyj15hy4LuqPUo1FNB
15EJFC5ZTs9nhsdvSUeBXjLAuYq3SWaxTc
1HB1iKUqeffnVsvQsbpC6dNi1XKbyNuqao
1GvgAXVCbA8FBjXfWiAms4ytFeJcKsoyhL
1824ZJQ7nKJ9QFTRBqn7z7dHV5EGpzUpH3
18A7NA9FTsnJxWgkoFfPAFbQzuQxpRtCos
1NeGn21dUDDeqFQ63xb2SpgUuXuBLA4WT4
174SNxfqpdMGYy5YQcfLbSTK3MRNZEePoy
1MnJ6hdhvK37VLmqcdEwqC3iFxyWH2PHUV
1KNRfGWw7Q9Rmwsc6NT5zsdvEb9M2Wkj5Z
1PJZPzvGX19a7twf5HyD2VvNiPdHLzm9F6
1GuBBhf61rnvRe4K8zu8vdQB3kHzwFqSy7
1GDSuiThEV64c166LUFC9uDcVdGjqkxKyh
1Me3ASYt5JCTAK2XaC32RMeH34PdprrfDx
1CdufMQL892A69KXgv6UNBD17ywWqYpKut
1BkkGsX9ZM6iwL3zbqs7HWBV7SvosR6m8N
1AWCLZAjKbV1P7AHvaPNCKiB7ZWVDMxFiz
1G6EFyBRU86sThN3SSt3GrHu1sA7w7nzi4
1MZ2L1gFrCtkkn6DnTT2e4PFUTHw9gNwaj
1Hz3uv3nNZzBVMXLGadCucgjiCs5W9vaGz
16zRPnT8znwq42q7XeMkZUhb1bKqgRogyy
1KrU4dHE5WrW8rhWDsTRjR21r8t3dsrS3R
17uDfp5r4n441xkgLFmhNoSW1KWp6xVLD
13A3JrvXmvg5w9XGvyyR4JEJqiLz8ZySY3
16RGFo6hjq9ym6Pj7N5H7L1NR1rVPJyw2v
1UDHPdovvR985NrWSkdWQDEQ1xuRiTALq
15nf31J46iLuK1ZkTnqHo7WgN5cARFK3RA
1Ab4vzG6wEQBDNQM1B2bvUz4fqXXdFk2WT
1Fz63c775VV9fNyj25d9Xfw3YHE6sKCxbt
1QKBaU6WAeycb3DbKbLBkX7vJiaS8r42Xo
1CD91Vm97mLQvXhrnoMChhJx4TP9MaQkJo
15MnK2jXPqTMURX4xC3h4mAZxyCcaWWEDD
13N66gCzWWHEZBxhVxG18P8wyjEWF9Yoi1
1NevxKDYuDcCh1ZMMi6ftmWwGrZKC6j7Ux
19GpszRNUej5yYqxXoLnbZWKew3KdVLkXg
1M7ipcdYHey2Y5RZM34MBbpugghmjaV89P
18aNhurEAJsw6BAgtANpexk5ob1aGTwSeL
1FwZXt6EpRT7Fkndzv6K4b4DFoT4trbMrV
1CXvTzR6qv8wJ7eprzUKeWxyGcHwDYP1i2
1MUJSJYtGPVGkBCTqGspnxyHahpt5Te8jy
13Q84TNNvgcL3HJiqQPvyBb9m4hxjS3jkV
1LuUHyrQr8PKSvbcY1v1PiuGuqFjWpDumN
18192XpzzdDi2K11QVHR7td2HcPS6Qs5vg
1NgVmsCCJaKLzGyKLFJfVequnFW9ZvnMLN
1AoeP37TmHdFh8uN72fu9AqgtLrUwcv2wJ
1FTpAbQa4h8trvhQXjXnmNhqdiGBd1oraE
14JHoRAdmJg3XR4RjMDh6Wed6ft6hzbQe9
19z6waranEf8CcP8FqNgdwUe1QRxvUNKBG
14u4nA5sugaswb6SZgn5av2vuChdMnD9E5
1NBC8uXJy1GiJ6drkiZa1WuKn51ps7EPTv

That was my research that I deleted; I think you copied it, but oh well.


The publication of the solved keys in the file bitcoin-puzzle-solved- provided 18 keys from puzzles #65 to #130. The analysis of these keys revealed deterministic patterns that allow for the construction of extremely selective modular filters. This report details the discovery process, the validation of the filters, and their implementation in a GPU attack that can solve puzzle #71 in a matter of days with sufficient hardware.

2. Starting Data: Private Keys from Puzzles #65 to #130
The 18 known keys (in hexadecimal) are:

Puzzle   Private Key (hex)
65   1a838b13505b26867
66   2832ed74f2b5e35ee
67   730fc235c1942c1ae
68   bebb3940cd0fc1491
69   101d83275fb2bc7e0c
70   349b84b6431a6c4ef1
75   4c5ce114686a1336e07
80   ea1a5c66dcc11b5ad180
85   11720c4f018d51b8cebba8
90   2ce00bb2136a445c71e85bf
95   527a792b183c7f64a0e8b1f4
100   af55fc59c335c8ec67ed24826
105   16f14fc2054cd87ee6396b33df3
110   35c0d7234df7deb0f20cf7062444
115   60f4d11574f5deee49961d9609ac6
120   b10f22572c497a836ea187f2e1fc23
125   1c533b6bb7f0804e09960225e44877ac
130   33e7665705359f04f28b88cf897c603c9
These 18 samples are the basis of the entire analysis.

3. First Biases: Modulo 910
Calculating the residues of the 18 keys modulo 910 revealed three constraints:

No residue ends in 0, 6, or 8 (last decimal digit).

No residue is congruent with 3 (modulo 7).

No residue is congruent with 3 or 6 (modulo 13).

Combining these three conditions using the Chinese Remainder Theorem yields a set of 462 allowed residues modulo 910. The probability that 18 random keys would satisfy this is less than 0.2%. This is a deliberate rule set by the creator.

4. Systematic Sweep of Moduli
A script was developed that, for each modulus m between 2 and 2000, calculated the residues of the 18 keys and measured the reduction. It was required that all 18 keys have their residue within the observed subset. Only a few moduli passed this test. Three stood out for their extremely high reduction:

Modulus   Size   Observed Residues
467   16   [10, 12, 31, 83, 202, 213, 226, 280, 283, 291, 292, 296, 378, 391, 438, 444]
491   16   [16, 25, 30, 102, 141, 162, 196, 228, 241, 284, 375, 392, 429, 462, 473, 490]
489   17   [34, 62, 99, 126, 136, 224, 245, 256, 268, 274, 280, 327, 388, 420, 438, 457, 459]
The probability that 18 random numbers in ranges of that size would fit into such small subsets is infinitesimal (on the order of 10⁻⁸⁰). These biases are real and deliberate.

5. Additional Filters from the Euclid Family
Numbers of the form M = k × pₙ# + 1 were explored, where pₙ# is the primorial (product of the first n primes). Many moduli (mostly primes) were found that also produce very small residue sets. Below is the complete list of the 27 moduli discovered, along with the size of their residue sets:

Modulus   Size   Approximate Fraction
910   462   0.508
467   16   0.0343
491   16   0.0326
489   17   0.0348
23   10   0.435
29   13   0.448
59   13   0.220
61   14   0.230
67   15   0.224
73   15   0.205
83   16   0.193
89   16   0.180
103   17   0.165
109   13   0.119
151   17   0.113
157   15   0.0955
173   17   0.0983
181   17   0.0939
199   17   0.0854
239   17   0.0711
241   16   0.0664
421   17   0.0404
601   17   0.0283
631   17   0.0269
1471   17   0.0116
2311   18   0.00779
200560490131   18   9.0×10⁻¹¹
The residue sets were obtained directly from the 18 keys, meaning all known keys pass all these filters.

6. Nibble Filter (bits 0-15)
Analyzing the 4 least significant bits of the 18 keys, it was observed that they never take the values {2, 5, 10, 11, 13}. Extending the analysis to the following nibbles (bits 4-7, 8-11, 12-15) revealed:

Nibble 1 (bits 4-7): forbidden values {1, 3, 5, 7, 13}

Nibble 2 (bits 8-11): forbidden value {1}

Nibble 3 (bits 12-15): forbidden value {15}

These filters are independent and are applied with simple bit comparisons. The probability that a key passes all four is:

(11/16)² × (15/16)² = 27225/65536 ≈ 0.4155

Speedup factor: 1 / 0.4155 ≈ 2.41×.

7. Cross-Validation
It was verified that all 18 known keys pass all the modular and nibble filters. It was also checked that puzzles prior to #65 (1-64) do not satisfy these filters, indicating that the creator changed their generation method starting from #65. This is irrelevant for #71, which belongs to the same group.

Furthermore, an extraordinary coincidence was discovered: the hash160 of the puzzle #71 address (f6f5431d25bbf7b12e8add9af5e3475c44a0a5b8) is also an Ethereum address with funds. The probability of a random hash160 matching an existing ETH address is less than 2⁻¹⁶⁰. This demonstrates that the creator deliberately chooses keys with special properties, reinforcing the hypothesis that the patterns are not coincidental.

8. Joint Probability and Expected Number of Candidates
The 27 moduli are coprime with each other, so the probability that a random key passes all of them is the product of the individual fractions:

P_total ≈ 10⁻²⁵

The total number of keys in the range of puzzle #71 is 2⁷⁰ ≈ 1.18 × 10²¹. Therefore, the expected number of keys that pass all filters across the entire range is:

N_expected = 1.18 × 10²¹ × 10⁻²⁵ = 1.18 × 10⁻⁴

[pbies]

I've made two scripts in python with prime numbers to eventually hit all puzzle:

Generate primes:

Code:

#!/usr/bin/env python3

from multiprocessing import Pool, cpu_count
from tqdm import tqdm
import sys

MAX_B = 1_000_000_000
CHUNK_SIZE = 1_000_000

def worker(args):
	start_x, end_x = args
	out = []

	for x in range(start_x, end_x):
		a = (x * 6) - 1
		b = (x * 6) + 1

		if a % 5 != 0:
			out.append(f"{a}\n")

		if b % 5 != 0:
			out.append(f"{b}\n")

		if b > MAX_B:
			break

	return "".join(out)

def generate_ranges():
	max_x = (MAX_B // 6) + 2
	for start in range(2, max_x, CHUNK_SIZE):
		end = min(start + CHUNK_SIZE, max_x)
		yield (start, end)

def main():
	with Pool(cpu_count()) as pool, open("primes02.txt", "w") as o:
		total_chunks = ((MAX_B // 6) + 2 + CHUNK_SIZE - 1) // CHUNK_SIZE

		for result in tqdm(
			pool.imap_unordered(worker, generate_ranges(), chunksize=1),
			total=total_chunks
		):
			o.write(result)

	print('\a', end='', file=sys.stderr)

if __name__ == '__main__':
	main()

Search with these primes:

Code:

#!/usr/bin/env python3

from multiprocessing import Pool, cpu_count
from tqdm import tqdm
import sys, base58, random
import itertools, math, time
from itertools import combinations

from hdwallet import HDWallet
from hdwallet.cryptocurrencies import Bitcoin as BTC
from hdwallet.hds import BIP32HD
from hdwallet.seeds import BIP39Seed

_hdwallet = HDWallet(cryptocurrency=BTC, hd=BIP32HD)

class Timer:
	def __enter__(self):
		self.start = time.perf_counter()
	def __exit__(self, type, value, traceback):
		self.end = time.perf_counter()
		print(f"This took: {self.end - self.start: .5f} seconds")

def pvk_to_wif2(key_hex):
	return base58.b58encode_check(b'\x80' + bytes.fromhex(key_hex)).decode()

targets=set()

def go(key_hex):
	_hdwallet.from_private_key(key_hex)
	t=_hdwallet.address('P2PKH')
	if t in targets:
		wif1 = pvk_to_wif2(key_hex)
		wif2 = _hdwallet.wif()
		line = f'{key_hex} {wif1} {wif2} {t}\n'
		with open('found.txt', 'a') as o:
			o.write(line)
			o.flush()

primes=set()

def gen():
	global primes
	for r in range(1, 6):
		i=itertools.product(primes, repeat=r)
		for j in i:
			k=math.prod(j)
			if k>=0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140:
				continue
			yield hex(k)[2:].zfill(64)

def main():
	global primes, targets
	print('Loading targets...', flush=True)
	targets=set(open('input.txt','r').read().splitlines())
	print('Loading primes...', flush=True)
	with Timer():
		primes_src=set(open('primes02.txt','r').read().splitlines())
	print('Converting primes...', flush=True)
	with Timer():
		primes = set( int(x) for x in primes_src )

	print('Starting search...', flush=True)
	tmp=0
	for r in range(1, 6):
		tmp+=len(primes)**r
	t=tqdm(total=tmp)
	with Pool(cpu_count()) as pool:
		for res in pool.imap_unordered(go, gen()):
			t.update()

	print('\a', end='', file=sys.stderr)

if __name__ == '__main__':
	main()

In input.txt file you need unhit puzzle addresses:

Code:

1PWo3JeB9jrGwfHDNpdGK54CRas7fsVzXU
1JTK7s9YVYywfm5XUH7RNhHJH1LshCaRFR
12VVRNPi4SJqUTsp6FmqDqY5sGosDtysn4
1FWGcVDK3JGzCC3WtkYetULPszMaK2Jksv
1DJh2eHFYQfACPmrvpyWc8MSTYKh7w9eRF
1Bxk4CQdqL9p22JEtDfdXMsng1XacifUtE
15qF6X51huDjqTmF9BJgxXdt1xcj46Jmhb
1ARk8HWJMn8js8tQmGUJeQHjSE7KRkn2t8
15qsCm78whspNQFydGJQk5rexzxTQopnHZ
13zYrYhhJxp6Ui1VV7pqa5WDhNWM45ARAC
14MdEb4eFcT3MVG5sPFG4jGLuHJSnt1Dk2
1CMq3SvFcVEcpLMuuH8PUcNiqsK1oicG2D
1K3x5L6G57Y494fDqBfrojD28UJv4s5JcK
1PxH3K1Shdjb7gSEoTX7UPDZ6SH4qGPrvq
16AbnZjZZipwHMkYKBSfswGWKDmXHjEpSf
19QciEHbGVNY4hrhfKXmcBBCrJSBZ6TaVt
1EzVHtmbN4fs4MiNk3ppEnKKhsmXYJ4s74
1AE8NzzgKE7Yhz7BWtAcAAxiFMbPo82NB5
17Q7tuG2JwFFU9rXVj3uZqRtioH3mx2Jad
1K6xGMUbs6ZTXBnhw1pippqwK6wjBWtNpL
15ANYzzCp5BFHcCnVFzXqyibpzgPLWaD8b
18ywPwj39nGjqBrQJSzZVq2izR12MDpDr8
1CaBVPrwUxbQYYswu32w7Mj4HR4maNoJSX
1JWnE6p6UN7ZJBN7TtcbNDoRcjFtuDWoNL
1CKCVdbDJasYmhswB6HKZHEAnNaDpK7W4n
1PXv28YxmYMaB8zxrKeZBW8dt2HK7RkRPX
1AcAmB6jmtU6AiEcXkmiNE9TNVPsj9DULf
1EQJvpsmhazYCcKX5Au6AZmZKRnzarMVZu
18KsfuHuzQaBTNLASyj15hy4LuqPUo1FNB
15EJFC5ZTs9nhsdvSUeBXjLAuYq3SWaxTc
1HB1iKUqeffnVsvQsbpC6dNi1XKbyNuqao
1GvgAXVCbA8FBjXfWiAms4ytFeJcKsoyhL
1824ZJQ7nKJ9QFTRBqn7z7dHV5EGpzUpH3
18A7NA9FTsnJxWgkoFfPAFbQzuQxpRtCos
1NeGn21dUDDeqFQ63xb2SpgUuXuBLA4WT4
174SNxfqpdMGYy5YQcfLbSTK3MRNZEePoy
1MnJ6hdhvK37VLmqcdEwqC3iFxyWH2PHUV
1KNRfGWw7Q9Rmwsc6NT5zsdvEb9M2Wkj5Z
1PJZPzvGX19a7twf5HyD2VvNiPdHLzm9F6
1GuBBhf61rnvRe4K8zu8vdQB3kHzwFqSy7
1GDSuiThEV64c166LUFC9uDcVdGjqkxKyh
1Me3ASYt5JCTAK2XaC32RMeH34PdprrfDx
1CdufMQL892A69KXgv6UNBD17ywWqYpKut
1BkkGsX9ZM6iwL3zbqs7HWBV7SvosR6m8N
1AWCLZAjKbV1P7AHvaPNCKiB7ZWVDMxFiz
1G6EFyBRU86sThN3SSt3GrHu1sA7w7nzi4
1MZ2L1gFrCtkkn6DnTT2e4PFUTHw9gNwaj
1Hz3uv3nNZzBVMXLGadCucgjiCs5W9vaGz
16zRPnT8znwq42q7XeMkZUhb1bKqgRogyy
1KrU4dHE5WrW8rhWDsTRjR21r8t3dsrS3R
17uDfp5r4n441xkgLFmhNoSW1KWp6xVLD
13A3JrvXmvg5w9XGvyyR4JEJqiLz8ZySY3
16RGFo6hjq9ym6Pj7N5H7L1NR1rVPJyw2v
1UDHPdovvR985NrWSkdWQDEQ1xuRiTALq
15nf31J46iLuK1ZkTnqHo7WgN5cARFK3RA
1Ab4vzG6wEQBDNQM1B2bvUz4fqXXdFk2WT
1Fz63c775VV9fNyj25d9Xfw3YHE6sKCxbt
1QKBaU6WAeycb3DbKbLBkX7vJiaS8r42Xo
1CD91Vm97mLQvXhrnoMChhJx4TP9MaQkJo
15MnK2jXPqTMURX4xC3h4mAZxyCcaWWEDD
13N66gCzWWHEZBxhVxG18P8wyjEWF9Yoi1
1NevxKDYuDcCh1ZMMi6ftmWwGrZKC6j7Ux
19GpszRNUej5yYqxXoLnbZWKew3KdVLkXg
1M7ipcdYHey2Y5RZM34MBbpugghmjaV89P
18aNhurEAJsw6BAgtANpexk5ob1aGTwSeL
1FwZXt6EpRT7Fkndzv6K4b4DFoT4trbMrV
1CXvTzR6qv8wJ7eprzUKeWxyGcHwDYP1i2
1MUJSJYtGPVGkBCTqGspnxyHahpt5Te8jy
13Q84TNNvgcL3HJiqQPvyBb9m4hxjS3jkV
1LuUHyrQr8PKSvbcY1v1PiuGuqFjWpDumN
18192XpzzdDi2K11QVHR7td2HcPS6Qs5vg
1NgVmsCCJaKLzGyKLFJfVequnFW9ZvnMLN
1AoeP37TmHdFh8uN72fu9AqgtLrUwcv2wJ
1FTpAbQa4h8trvhQXjXnmNhqdiGBd1oraE
14JHoRAdmJg3XR4RjMDh6Wed6ft6hzbQe9
19z6waranEf8CcP8FqNgdwUe1QRxvUNKBG
14u4nA5sugaswb6SZgn5av2vuChdMnD9E5
1NBC8uXJy1GiJ6drkiZa1WuKn51ps7EPTv

That was my research that I deleted; I think you copied it, but oh well.


The publication of the solved keys in the file bitcoin-puzzle-solved- provided 18 keys from puzzles #65 to #130. The analysis of these keys revealed deterministic patterns that allow for the construction of extremely selective modular filters. This report details the discovery process, the validation of the filters, and their implementation in a GPU attack that can solve puzzle #71 in a matter of days with sufficient hardware.

2. Starting Data: Private Keys from Puzzles #65 to #130
The 18 known keys (in hexadecimal) are:

Puzzle   Private Key (hex)
65   1a838b13505b26867
66   2832ed74f2b5e35ee
67   730fc235c1942c1ae
68   bebb3940cd0fc1491
69   101d83275fb2bc7e0c
70   349b84b6431a6c4ef1
75   4c5ce114686a1336e07
80   ea1a5c66dcc11b5ad180
85   11720c4f018d51b8cebba8
90   2ce00bb2136a445c71e85bf
95   527a792b183c7f64a0e8b1f4
100   af55fc59c335c8ec67ed24826
105   16f14fc2054cd87ee6396b33df3
110   35c0d7234df7deb0f20cf7062444
115   60f4d11574f5deee49961d9609ac6
120   b10f22572c497a836ea187f2e1fc23
125   1c533b6bb7f0804e09960225e44877ac
130   33e7665705359f04f28b88cf897c603c9
These 18 samples are the basis of the entire analysis.

3. First Biases: Modulo 910
Calculating the residues of the 18 keys modulo 910 revealed three constraints:

No residue ends in 0, 6, or 8 (last decimal digit).

No residue is congruent with 3 (modulo 7).

No residue is congruent with 3 or 6 (modulo 13).

Combining these three conditions using the Chinese Remainder Theorem yields a set of 462 allowed residues modulo 910. The probability that 18 random keys would satisfy this is less than 0.2%. This is a deliberate rule set by the creator.

4. Systematic Sweep of Moduli
A script was developed that, for each modulus m between 2 and 2000, calculated the residues of the 18 keys and measured the reduction. It was required that all 18 keys have their residue within the observed subset. Only a few moduli passed this test. Three stood out for their extremely high reduction:

Modulus   Size   Observed Residues
467   16   [10, 12, 31, 83, 202, 213, 226, 280, 283, 291, 292, 296, 378, 391, 438, 444]
491   16   [16, 25, 30, 102, 141, 162, 196, 228, 241, 284, 375, 392, 429, 462, 473, 490]
489   17   [34, 62, 99, 126, 136, 224, 245, 256, 268, 274, 280, 327, 388, 420, 438, 457, 459]
The probability that 18 random numbers in ranges of that size would fit into such small subsets is infinitesimal (on the order of 10⁻⁸⁰). These biases are real and deliberate.

5. Additional Filters from the Euclid Family
Numbers of the form M = k × pₙ# + 1 were explored, where pₙ# is the primorial (product of the first n primes). Many moduli (mostly primes) were found that also produce very small residue sets. Below is the complete list of the 27 moduli discovered, along with the size of their residue sets:

Modulus   Size   Approximate Fraction
910   462   0.508
467   16   0.0343
491   16   0.0326
489   17   0.0348
23   10   0.435
29   13   0.448
59   13   0.220
61   14   0.230
67   15   0.224
73   15   0.205
83   16   0.193
89   16   0.180
103   17   0.165
109   13   0.119
151   17   0.113
157   15   0.0955
173   17   0.0983
181   17   0.0939
199   17   0.0854
239   17   0.0711
241   16   0.0664
421   17   0.0404
601   17   0.0283
631   17   0.0269
1471   17   0.0116
2311   18   0.00779
200560490131   18   9.0×10⁻¹¹
The residue sets were obtained directly from the 18 keys, meaning all known keys pass all these filters.

6. Nibble Filter (bits 0-15)
Analyzing the 4 least significant bits of the 18 keys, it was observed that they never take the values {2, 5, 10, 11, 13}. Extending the analysis to the following nibbles (bits 4-7, 8-11, 12-15) revealed:

Nibble 1 (bits 4-7): forbidden values {1, 3, 5, 7, 13}

Nibble 2 (bits 8-11): forbidden value {1}

Nibble 3 (bits 12-15): forbidden value {15}

These filters are independent and are applied with simple bit comparisons. The probability that a key passes all four is:

(11/16)² × (15/16)² = 27225/65536 ≈ 0.4155

Speedup factor: 1 / 0.4155 ≈ 2.41×.

7. Cross-Validation
It was verified that all 18 known keys pass all the modular and nibble filters. It was also checked that puzzles prior to #65 (1-64) do not satisfy these filters, indicating that the creator changed their generation method starting from #65. This is irrelevant for #71, which belongs to the same group.

Furthermore, an extraordinary coincidence was discovered: the hash160 of the puzzle #71 address (f6f5431d25bbf7b12e8add9af5e3475c44a0a5b8) is also an Ethereum address with funds. The probability of a random hash160 matching an existing ETH address is less than 2⁻¹⁶⁰. This demonstrates that the creator deliberately chooses keys with special properties, reinforcing the hypothesis that the patterns are not coincidental.

8. Joint Probability and Expected Number of Candidates
The 27 moduli are coprime with each other, so the probability that a random key passes all of them is the product of the individual fractions:

P_total ≈ 10⁻²⁵

The total number of keys in the range of puzzle #71 is 2⁷⁰ ≈ 1.18 × 10²¹. Therefore, the expected number of keys that pass all filters across the entire range is:

N_expected = 1.18 × 10²¹ × 10⁻²⁵ = 1.18 × 10⁻⁴

Stop talking bs. You are lying.,

I didn't copied anything from anyone. I work on my own. Stop making false accusations.

This is first warning for you.

[brainless]

Bitcoin is decentralized
But market price indicate some people's controlling these whole Blockchain
May I saying correct ?