Project overview
This project is a live, distributed implementation of Pollard's Kangaroo algorithm applied to the secp256k1 elliptic curve. Its primary purpose is to provide a real-time, continuously updated stream of the algorithm’s progress, making the internal state — including current points and discovered public keys — openly accessible to observers, researchers, or collaborators.
The kangaroo algorithm is a powerful method for solving the discrete logarithm problem (DLP) in a finite group — particularly useful when the search space is constrained to a known interval. In the case of elliptic curves, we aim to find a private scalar k such that:
Q = k × G
Where:
- G is the base point on the secp256k1 curve,
- k is the unknown private key (in a bounded interval),
- Q is the known public point.
The kangaroo approach uses two "kangaroos" — a tame kangaroo that walks from a known starting point and a wild kangaroo that walks from the target point Q. Both follow deterministic pseudo-random jumps based on the curve, and the algorithm terminates when their paths collide, revealing k.
This project broadcasts the live coordinates and steps of these “kangaroos” in real time. It emphasizes transparency, reproducibility, and educational value, offering insight into the mathematical beauty and operational dynamics of one of the most elegant algorithms in discrete logarithm computation.
What is Kangaroos and Why Does it Matter?
This project is not just a technical experiment — it’s a living, breathing demonstration of modern mathematical methods at scale. Pollard’s Kangaroo algorithm is more than just a clever way to find secrets on elliptic curves — it’s a benchmark for understanding the practical behavior of discrete logarithm solvers, especially under real-world constraints.
By offering an open stream of intermediate computations, this project allows:
- Students to witness an advanced cryptographic algorithm in motion — not in theory, but in code and coordinates.
- Researchers to benchmark their hypotheses about jump patterns, collisions, or performance under different curve conditions.
- Enthusiasts to better understand the boundaries of what's computationally feasible — and where math becomes magic.
In short, this is a mathematical observatory — a rare chance to peek into the inner mechanics of an algorithm normally hidden behind academic proofs and private notebooks.
Project solution
This project implements the Pollard’s Kangaroo Algorithm (also known as the Lambda method) to solve the Elliptic Curve Discrete Logarithm Problem (ECDLP) over the secp256k1 curve, within a known interval [a, b].
The goal is to find a private scalar k such that:
Q = k × G,
where k ∈ [a, b],
G is the curve generator,
and Q is the known public point.
How the Algorithm Works
Pollard’s Kangaroo uses two simulated “kangaroos” — tame and wild — each performing jumps across the elliptic curve group:
The tame kangaroo starts at a known point:
T_0 = b × G,
and its walk generates points:
T_{i+1} = T_i + d_i × G
The wild kangaroo starts from the unknown point:
W_0 = Q,
and walks as:
W_{j+1} = W_j + d_j × G
Each d_i is a pseudo-random jump distance selected from a small, fixed set D = {d_1, ..., d_r}, typically based on the current point through a hash-like index function:
d = f(P) mod r,
where P is the current curve point.
When the tame and wild kangaroos land on the same point (i.e., T_i = W_j), we can reconstruct the private key:
T_i = b × G + ∑ d_k × G
W_j = Q + ∑ d_l × G
⟹ k = b + ∑ d_k − ∑ d_l
4M+
Curve Points Emitted Per Second
1.5M
Average Jumps to Collision (2²⁰ space)
168GB+
Raw Math Stream Per Hour
98.7%
Resource Utilization Efficiency
The Curious Case of the Mathematical Kangaroo
Ever wondered what happens when abstract algebra meets marsupial-level determination? This FAQ tackles your most burning (and slightly nerdy) questions about our secp256k1 journey, with just enough seriousness to not get kicked by the kangaroo.
No, unless you consider mining for mathematical beauty a profitable venture. This project doesn’t touch coins—it touches elliptic curve points with mathematical precision.
Technically yes, just like you can technically win the lottery while being struck by lightning. We're exploring structured randomness, not promoting miracles.
Imagine trying to find a kangaroo in a desert by watching its hops. Now multiply that by 10⁹ hops per second. Welcome to probabilistic search, not overkill—just ambition.
You could try using a toaster, but we recommend at least an NVIDIA A100. CUDA C doesn’t run on bread.
Not unless your work involves proving how hard cryptography is. This project won’t break Bitcoin, but it will break your assumptions about the elegance of mathematical search algorithms.