[quote author=nikolayspb link=topic=1306983.msg65408692#msg65408692 date=1747968135]
[quote author=Nodemath link=topic=1306983.msg65405281#msg65405281 date=1747884772]
[quote author=Nodemath link=topic=1306983.msg65394991#msg65394991 date=1747633333]
import time
import hashlib
from coincurve import PrivateKey
from Crypto.Hash import RIPEMD160
import psutil
import os
import signal
import sys
import multiprocessing as mp
from bloom_filter2 import BloomFilter
from google.colab import drive
# Mount Google Drive
drive.mount('/content/drive')
# Config
File_NAME = "Puzzle 71.013.000.csv"
DRIVE_FOLDER = "/content/drive/MyDrive/Puzzle71"
file_path = f"{DRIVE_FOLDER}/{File_NAME}"
SCAN_RANGE = 100_000
TARGET_PREFIX = "f6f543"
BLOOM_CAPACITY = 1_000_000
BLOOM_ERROR_RATE = 0.001
# Load known H160 hashes into Bloom filter
KNOWN_H160S = [
"f6f5431d25bbf7b12e8add9af5e3475c44a0a5b8",
]
bloom = BloomFilter(max_elements=BLOOM_CAPACITY, error_rate=BLOOM_ERROR_RATE)
for h in KNOWN_H160S:
bloom.add(h)
# Read decimal numbers from CSV
with open(file_path, 'r') as f:
lines = [line.strip() for line in f if line.strip()]
if lines[0].lower().startswith('value'):
lines = lines[1:]
Decimal_numbers = [int(line) for line in lines]
def privatekey_to_h160(priv_key_int):
try:
priv = PrivateKey.from_int(priv_key_int)
pubkey = priv.public_key.format(compressed=True)
sha256 = hashlib.sha256(pubkey).digest()
ripemd160 = RIPEMD160.new(sha256).digest()
return ripemd160.hex()
except Exception:
return None
def optimize_performance():
try:
p = psutil.Process()
if hasattr(p, "cpu_affinity"):
p.cpu_affinity(list(range(os.cpu_count())))
if hasattr(psutil, "REALTIME_PRIORITY_CLASS"):
p.nice(psutil.REALTIME_PRIORITY_CLASS)
else:
p.nice(-20)
except Exception as e:
print(f"[!] Optimization warning: {e}")
def signal_handler(sig, frame):
print("\n[!] Interrupted. Exiting.")
sys.exit(0)
def check_key(k):
h160 = privatekey_to_h160(k)
if h160 and (h160.startswith(TARGET_PREFIX) or h160 in bloom):
return ('match', k, h160)
return ('progress', k, h160)
def process_decimal(decimal):
start = max(1, decimal - SCAN_RANGE)
end = decimal + SCAN_RANGE
keys = list(range(start, end + 1))
processed = 0
start_time = time.time()
last_key = None
last_h160 = None
ctx = mp.get_context("fork")
with ctx.Pool(processes=os.cpu_count()) as pool:
result_iter = pool.imap_unordered(check_key, keys, chunksize=1000)
for result in result_iter:
if result[0] == 'match':
_, key, h160 = result
print(f"\n**PREFIX MATCH FOUND!** Private key {hex(key)} produces Hash160: {h160}\n")
elif result[0] == 'progress':
_, key, h160 = result
processed += 1
last_key = key
last_h160 = h160
elapsed = time.time() - start_time
speed = processed / elapsed if elapsed > 0 else 0
print(f"\nHash160 of the last processed key {hex(last_key)} -> {last_h160}")
print(f"[✓] Completed Decimal: {Decimal} - Processed {processed} keys in {elapsed:.2f}s (Speed: {speed:.2f} keys/sec)")
def main():
signal.signal(signal.SIGINT, signal_handler)
optimize_performance()
print(f"\nLoaded {len(Decimal_numbers)} Decimal numbers.")
print(f"Scanning ±{SCAN_RANGE} around each.\nTarget prefix: {TARGET_PREFIX}")
print(f"Bloom filter contains {len(KNOWN_H160S)} known H160 hashes.\n")
for decimal in decimal_numbers:
process_decimal(decimal)
if __name__ == '__main__':
main()
Help me out to use rotor cuda gpu modules able run on colab
Private key to hash 160
[/quote]
Who ever help me with this code able to run on gpu
I definitely give u 1 BTC
NEED ACHIEVE ATLEAST 250M Keys/sec
[/quote]
Below is the complete CUDA C implementation and Google Colab setup instructions, fully translated into English, so you can run it on Colab’s GPU (e.g. Tesla T4) and achieve well over 200 MH/s.
```cuda
// gpu_scan_secp256k1.cu
//
// GPU-based brute-forcer for secp256k1 → SHA256 → RIPEMD-160
// Looks for private keys whose RIPEMD-160(pubkey) begins with a given hex prefix.
// Designed to run on Google Colab GPUs (Tesla T4, V100, etc.)
//
// Compile with:
// nvcc -O3 -arch=sm_70 gpu_scan_secp256k1.cu -o gpu_scan
#include <cstdio>
#include <cstdint>
#include <cstring>
#include <openssl/sha.h>
#include <openssl/ripemd.h>
#include <secp256k1.h>
#define TARGET_PREFIX "f6f543" // hex prefix to match
#define PREFIX_BYTES (sizeof(TARGET_PREFIX)-1)
// Check if the first bytes of the 20-byte H160 match our target
__device__ inline bool check_prefix(const unsigned char *h160) {
// Convert TARGET_PREFIX into raw bytes {0xf6,0xf5,0x43}
static const unsigned char target[PREFIX_BYTES/2] = {0xf6, 0xf5, 0x43};
for (int i = 0; i < PREFIX_BYTES/2; i++) {
if (h160[i] != target[i]) return false;
}
return true;
}
// Compute RIPEMD-160(SHA256(pubkey33)) from a compressed public key
__device__
void pubkey_to_h160(const unsigned char *pub33, unsigned char out[20]) {
unsigned char sha_digest[32];
SHA256_CTX sha_ctx;
SHA256_Init(&sha_ctx);
SHA256_Update(&sha_ctx, pub33, 33);
SHA256_Final(sha_digest, &sha_ctx);
RIPEMD160_CTX ripemd_ctx;
RIPEMD160_Init(&ripemd_ctx);
RIPEMD160_Update(&ripemd_ctx, sha_digest, 32);
RIPEMD160_Final(out, &ripemd_ctx);
}
// Each thread processes one private key: priv = base + threadIndex
__global__
void kernel_scan(uint64_t base, uint64_t total_keys) {
uint64_t idx = blockIdx.x * blockDim.x + threadIdx.x;
if (idx >= total_keys) return;
uint64_t priv = base + idx;
// Build a 32-byte big-endian seckey
unsigned char seckey[32] = {0};
for (int i = 0; i < 8; i++) {
seckey[31 - i] = (priv >> (8*i)) & 0xFF;
}
// Generate public key on secp256k1 curve
secp256k1_pubkey pub;
secp256k1_ec_pubkey_create(nullptr, &pub, seckey);
// Serialize compressed (33 bytes)
unsigned char pub33[33];
size_t outlen = 33;
secp256k1_ec_pubkey_serialize(nullptr, pub33, &outlen, &pub, SECP256K1_EC_COMPRESSED);
// Compute RIPEMD-160(SHA256(pub33))
unsigned char h160[20];
pubkey_to_h160(pub33, h160);
// Check prefix
if (check_prefix(h160)) {
// Print matching private key and first 3 bytes of hash
printf("[MATCH] priv=0x%016llx h160=%.2x%.2x%.2x...\n",
(unsigned long long)priv,
h160[0], h160[1], h160[2]);
}
}
int main(int argc, char** argv) {
if (argc != 4) {
printf("Usage: gpu_scan <start_decimal> <num_keys> <threads_per_block>\n");
return 1;
}
uint64_t start = strtoull(argv[1], nullptr, 0);
uint64_t num_keys = strtoull(argv[2], nullptr, 0);
int threadsPerBlock = atoi(argv[3]);
// Initialize libsecp256k1 context once on the host
secp256k1_context* ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN);
// (We pass nullptr into the kernel; libsecp256k1 allows this as context is unused on device.)
uint64_t numBlocks = (num_keys + threadsPerBlock - 1) / threadsPerBlock;
printf("Launching %llu blocks × %d threads = %llu keys…\n",
(unsigned long long)numBlocks,
threadsPerBlock,
(unsigned long long)num_keys);
// Measure time with CUDA events
cudaEvent_t t_start, t_end;
cudaEventCreate(&t_start);
cudaEventCreate(&t_end);
cudaEventRecord(t_start);
// Launch the kernel
kernel_scan<<<numBlocks, threadsPerBlock>>>(start, num_keys);
cudaDeviceSynchronize();
cudaEventRecord(t_end);
cudaEventSynchronize(t_end);
float ms = 0.0f;
cudaEventElapsedTime(&ms, t_start, t_end);
double seconds = ms / 1000.0;
double mhps = (double)num_keys / seconds / 1e6;
printf("\nScanned %llu keys in %.2f s → %.2f MH/s\n",
(unsigned long long)num_keys,
seconds,
mhps);
secp256k1_context_destroy(ctx);
return 0;
}
```
### How to run this in Google Colab
1. **Install dependencies and build libsecp256k1**
```bash
!apt-get update && apt-get install -y libssl-dev
!git clone https://github.com/bitcoin-core/secp256k1.git
%cd secp256k1
!./autogen.sh
!./configure --enable-module-ecdh --enable-module-recovery --enable-experimental --with-bignum=no
!make -j$(nproc)
%cd ..
```
2. **Upload the CUDA source**
Either use Colab’s file browser to upload `gpu_scan_secp256k1.cu`, or embed it with:
```bash
%%bash
cat > gpu_scan_secp256k1.cu << 'EOF'
[paste the full CUDA code here]
EOF
```
3. **Compile with NVCC**
```bash
!nvcc gpu_scan_secp256k1.cu -o gpu_scan \
-I./secp256k1/include -L./secp256k1/.libs -lsecp256k1 \
-lssl -lcrypto -O3 -arch=sm_70
```
4. **Run the GPU scanner**
```bash
# Usage: ./gpu_scan <start_decimal> <num_keys> <threadsPerBlock>
# For your ±SCAN_RANGE window:
start_decimal=1000000000000 # replace with your base decimal
total_keys=$((2*100000+1)) # e.g. SCAN_RANGE=100000
threads_per_block=256
!./gpu_scan $start_decimal $total_keys $threads_per_block
```
> **Expected performance on Tesla T4 (Colab GPU): \~600–800 MH/s**, comfortably above 200 MH/s.
[/quote]
This code doesn’t actually use the GPU properly — it essentially works like a regular CPU program pretending to be CUDA magic. Let’s break this down atom by atom:
💣 What's wrong here:
1. libsecp256k1 runs on the CPU
cpp
Копировать
Редактировать
secp256k1_ec_pubkey_create(nullptr, &pub, seckey);
→ nullptr is passed instead of a context because secp256k1_context isn't available on the GPU.
This means: the function call simply doesn't happen inside the GPU kernel. And even if it could — it would be invalid.
2. OpenSSL (SHA256 and RIPEMD160) are CPU-only
cpp
Копировать
Редактировать
SHA256_Init(&sha_ctx);
RIPEMD160_Init(&ripemd_ctx);
→ These functions don't compile under CUDA. If you put them inside a __device__ function, you're tricking nvcc. Most likely:
the code won't compile,
or it compiles but runs entirely on the CPU.
3. What actually runs on the GPU? Basically… nothing.
→ The CUDA kernel:
cpp
Копировать
Редактировать
__global__ void kernel_scan(...) { ... }
calls CPU-only functions (which is impossible on GPU), so what really happens is:
either nothing runs at all,
or everything silently runs on the CPU,
or the compiler fakes compilation but the kernel doesn’t execute meaningfully.
📉 Result:
Even if you compile this with nvcc, and it appears to "work" — all the logic is CPU-based, and kernel_scan is just a wrapper, doing nothing GPU-related.
🔧 How to build real CUDA magic:
Use a secp256k1 implementation that works on CUDA — there are some forks out there (with hacks).
Replace OpenSSL with CUDA-native SHA256/RIPEMD160, such as:
cuSHA256 (available as ready-to-use kernels),
your own implementation of H160 (a bit painful, but doable).
Keep everything inside the GPU — generate private keys, compute public keys, hash them — all directly on device.
на инг
What exact speed do you want to achieve from Colab?
P.S Bitcoin isn’t just code — it’s faith that in this chaos of the digital universe, there’s meaning. The world stands on trust, just like we cling to the last pixels of light in eternal darkness. If you believe in me, support with even a satoshi — it’s like sparking a tiny flame into the abyss.
For those who aren’t afraid to dive into the glitch:
1BsEVzowVsyvAs8vTVeG4o6Xi3bg315795
Let’s fuel this digital legend together — even 1 satoshi is already an act of a messiah. 🚀🖤