this is simply a prototype
import cupy as cp
import numpy as np
import time
from Crypto.Hash import RIPEMD160, SHA256
from ecdsa import SECP256k1, SigningKey
import concurrent.futures
TARGET_HASH160 = bytes.fromhex("f6f5431d25bbf7b12e8add9af5e3475c44a0a5b8")
TARGET_PREFIX = TARGET_HASH160[:3]
THREADS = 256
BATCH_SIZE = 2**24
sha256_kernel = cp.RawKernel(r'''
extern "C" __global__
void sha256_partial(const unsigned long long* privkeys, unsigned char* out_prefixes, unsigned char* matches, int N) {
int idx = blockDim.x * blockIdx.x + threadIdx.x;
if (idx >= N) return;
unsigned long long key = privkeys[idx];
unsigned char data[8];
#pragma unroll
for (int i = 0; i < 8; ++i)
data[7 - i] = (key >> (i *
) & 0xFF;
unsigned int h[8] = {
0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
};
unsigned int k[4] = {
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5
};
unsigned int w[64] = {0};
#pragma unroll
for (int i = 0; i < 8; ++i)
w
= ((unsigned int)data) << 24;
unsigned int a = h[0], b = h[1], c = h[2], d = h[3];
unsigned int e = h[4], f = h[5], g = h[6], hh = h[7];
for (int i = 0; i < 4; ++i) {
unsigned int S1 = __funnelshift_r(e, e, 6) ^ __funnelshift_r(e, e, 11) ^ __funnelshift_r(e, e, 25);
unsigned int ch = (e & f) ^ (~e & g);
unsigned int temp1 = hh + S1 + ch + k + w;
unsigned int S0 = __funnelshift_r(a, a, 2) ^ __funnelshift_r(a, a, 13) ^ __funnelshift_r(a, a, 22);
unsigned int maj = (a & b) ^ (a & c) ^ (b & c);
unsigned int temp2 = S0 + maj;
hh = g;
g = f;
f = e;
e = d + temp1;
d = c;
c = b;
b = a;
a = temp1 + temp2;
}
h[0] += a;
unsigned char b0 = (h[0] >> 24) & 0xFF;
unsigned char b1 = (h[0] >> 16) & 0xFF;
unsigned char b2 = (h[0] >> & 0xFF;
out_prefixes[idx * 3 + 0] = b0;
out_prefixes[idx * 3 + 1] = b1;
out_prefixes[idx * 3 + 2] = b2;
if (b0 == 0xf6 && b1 == 0xf5 && b2 == 0x43)
matches[idx] = 1;
else
matches[idx] = 0;
}
''', 'sha256_partial')
def hash160(pubkey_bytes):
sha = SHA256.new(pubkey_bytes).digest()
h160 = RIPEMD160.new(sha).digest()
return h160
def verify_candidate(candidate):
pubkey = compressed_public_key_from_privkey(candidate)
h160 = hash160(pubkey)
if h160 == TARGET_HASH160:
return candidate, pubkey.hex(), h160.hex()
return None
def compressed_public_key_from_privkey(privkey_int):
priv_bytes = int(privkey_int).to_bytes(32, 'big')
sk = SigningKey.from_string(priv_bytes, curve=SECP256k1)
vk = sk.get_verifying_key()
x = vk.pubkey.point.x()
prefix = b'\x03' if (vk.pubkey.point.y() & 1) else b'\x02'
return prefix + x.to_bytes(32, 'big')
print("🔁 Starting search with GPU prefilter (3 bytes)...")
try:
total_keys = 0
total_candidates = 0
while True:
t0 = time.time()
privkeys = cp.random.randint(0, 2**64, size=BATCH_SIZE, dtype=cp.uint64)
out = cp.zeros((BATCH_SIZE * 3,), dtype=cp.uint8)
matches = cp.zeros(BATCH_SIZE, dtype=cp.uint8)
blocks = (BATCH_SIZE + THREADS - 1)/ THREADS
sha256_kernel((blocks,), (THREADS,), (privkeys, out, matches, BATCH_SIZE))
matches_cpu = matches.get()
privkeys_cpu = privkeys.get()
candidates = [privkeys_cpu for i in range(BATCH_SIZE) if matches_cpu == 1]
total_keys += BATCH_SIZE
total_candidates += len(candidates)
with concurrent.futures.ProcessPoolExecutor(max_workers=8) as executor:
futures = [executor.submit(verify_candidate, c) for c in candidates]
for future in concurrent.futures.as_completed(futures):
result = future.result()
if result is not None:
candidate, pub_hex, h160_hex = result
print(f"\n🎯 MATCH found! Private key: {hex(candidate)}")
print(f" PublicKey: {pub_hex}")
print(f" Hash160: {h160_hex}")
exit()
elapsed = time.time() - t0
print(f"🔹 Processed: {BATCH_SIZE} | Candidates: {len(candidates)} | Speed: {int(BATCH_SIZE elapsed):,} keys/s")
except KeyboardInterrupt:
print("⛔ Process interrupted.")
