Coin Cracker: CUDA/Rust secp256k1 interval ECDLP solver Hi all,
I would like to share the project I've been working on last couple of weeks.
Coin Cracker Open source:
https://github.com/lleoha/coin-cracker Coin Cracker is an experimental CUDA/Rust solver for secp256k1 DLP in a known interval.
Given a compressed secp256k1 public key and a private-key interval, it searches the interval and prints the recovered private key when found.
Important warning: No warranty. Use at your own risk. I am not responsible for damage, loss, misuse, or illegal activity.
Only run this against keys and ranges you are authorized to test.
Method Coin Cracker uses a Gaudry-Schost-style walk for interval DLP.
It does NOT use equivalence classes. I decided to keep it this way because the implementation is simpler and raw GPU throughput is higher. In my tests, using the negation-map equivalence class reduces the
number of required jumps, but also reduces raw jumps/s enough that the benefit mostly cancels out.
The current method uses custom tame/wild interval shapes and a six-set sampling pattern inspired by RetiredCoder's Kang-1 / SOTAv2 work and its "k" parameter is
k=1.565 + overhead.
Credits to RetiredCoder:
https://github.com/RetiredC/Kang-1 https://github.com/RetiredC/RCKangaroo Implementation - Rust host code
- CUDA kernel
- CMake builds the cubin during cargo build
- The cubin is embedded into the final Rust binary
- Distinguished-point collision detection is currently done on the host
- Deterministic runs are supported with --seed
- Progress and metrics are logged to stderr
- The recovered key is printed to stdout
Performance On my test GPU, I see about:
~2.7 G jumps/s (on RTX 5060)
~10.1 G/s jumps/s (on RTX 5090)
For comparison, on the same GPU, RCKangaroo reports around:
~1.9 G jumps/s (on RTX 5060)
~8.9 G jumps/s (on RTX 5090)
This is raw kernel throughput, not a claim that the method is always better in total solve time. DP overhead, interval size, number of walks, CPU speed, and parameters still matter.
Example Example command for Bitcoin Puzzle #70 range:
coin-cracker \
--dp-bits 16 \
--public-key 0290e6900a58d33393bc1097b5aed31f2e4e7cbd3e5466af958665bc0121248483 \
--begin 200000000000000000 \
--range-bits 69
On success, stdout contains only the recovered private key.
Build requirements - Rust toolchain
- NVIDIA GPU
- CUDA Toolkit
- CMake 4.2 or newer
Build:
Notes The project is still experimental. The code is close to usable, but I expect there are still many things to improve, especially around DP overhead, tuning, benchmarking, and documentation.
Contributions are welcome. If you see a correctness issue, performance improvement, cleanup, or better explanation of the algorithm, please open an issue or submit a pull request.
