fecell
Jr. Member

Activity: 205
Merit: 2
|
 |
November 10, 2026, 08:24:01 AM |
|
Soon I will publish code that clearly demonstrates the kangaroo algorithm.
Baby-Step Giant-Step (BSGS):Solves g^x = h in a cyclic group of order n, or x in an interval of length N. Precompute baby steps g^j for j = 0..m-1 in a hash table. Compute giant steps h * (g^-m)^i and look for a match. Time O(sqrt(N)), memory O(sqrt(N)). Deterministic; works for any generic group. Pollard's Kangaroo (Lambda) Algorithm:Solves g^x = h when x is known to lie in an interval [a,b]. Uses a tame kangaroo starting at g^b and a wild kangaroo starting at h. Both jump by pseudorandom exponents; a collision reveals x. Expected time O(sqrt(b-a)), memory O(1). Probabilistic; needs a bounded interval. Key difference: BSGS is deterministic and memory-heavy; Kangaroo is probabilistic, constant-memory, and interval-based. MITM Algorithm:Large and small circle reduce range constantly till solution not found. (not public available, get all free RAM/VRAM, tested only with known PK, so far, MITM has not been used to solve any truly complex puzzle, need powerful hardware)
|
|
|
|
|
fecell
Jr. Member

Activity: 205
Merit: 2
|
 |
November 10, 2026, 08:41:36 AM |
|
==========* FOUND!========= [Launch 58] Total:93, 415, 538, 688 koys | Rate: 377.25 M keys/s | Elapsed: 4.3s Device Name: NVIDIA GeForce GTX 1650 Ti FOUND VERIFIED SOLUTION: PRIVATE KEY: 1,003,651,412,950 SEARCH TIME: 00:00:02 probes_done: 536870912 (0.0977% of sweep)

|
|
|
|
|
demonarcher360
Newbie

Activity: 12
Merit: 0
|
 |
November 10, 2026, 11:46:23 AM |
|
Soon I will publish code that clearly demonstrates the kangaroo algorithm.
Baby-Step Giant-Step (BSGS):Solves g^x = h in a cyclic group of order n, or x in an interval of length N. Precompute baby steps g^j for j = 0..m-1 in a hash table. Compute giant steps h * (g^-m)^i and look for a match. Time O(sqrt(N)), memory O(sqrt(N)). Deterministic; works for any generic group. Pollard's Kangaroo (Lambda) Algorithm:Solves g^x = h when x is known to lie in an interval [a,b]. Uses a tame kangaroo starting at g^b and a wild kangaroo starting at h. Both jump by pseudorandom exponents; a collision reveals x. Expected time O(sqrt(b-a)), memory O(1). Probabilistic; needs a bounded interval. Key difference: BSGS is deterministic and memory-heavy; Kangaroo is probabilistic, constant-memory, and interval-based. MITM Algorithm:Large and small circle reduce range constantly till solution not found. (not public available, get all free RAM/VRAM, tested only with known PK, so far, MITM has not been used to solve any truly complex puzzle, need powerful hardware) Only with the key exposed—these two algorithms, correct?
|
|
|
|
|
Efim_Wr
Newbie

Activity: 11
Merit: 0
|
 |
November 10, 2026, 01:44:33 PM |
|
Hello everyone, I'd like to share an open-source tool I developed for visualizing and studying the Pollard's Kangaroo algorithm on the secp256k1 elliptic curve. This isn't just another "key cracking" script — it's an educational project designed to show exactly how the "Tame" and "Wild" kangaroos jump across the curve, converge, and eventually collide in real-time. https://github.com/Fantom-C/web-pollard-kangarooAlgorithm parameters: K (jump table size), dpBit (Distinguished Points filter to save memory), MAX_ITER, and jump direction (R/L). Auto-calculated optimal values are provided.
|
|
|
|
|
|
kTimesG
|
 |
November 10, 2026, 01:59:26 PM |
|
Pollard's Kangaroo (Lambda) Algorithm: Solves g^x = h when x is known to lie in an interval [a,b].
Uses a tame kangaroo starting at g^b and a wild kangaroo starting at h.
The improved versions start from (a+b)/2 for obvious reasons. Oorschot's paper had a terrible typo about that "b" that contradicts the analysis just one page after. Most people later reproduced the typo, because academic papers need to confirm flaws. Waiting for the troll agents now.
|
|
|
|
Efim_Wr
Newbie

Activity: 11
Merit: 0
|
 |
November 11, 2026, 09:39:25 AM |
|
I’m planning to release a tool with a graphical user interface for the SOTA and SOTA2 methods, featuring flexible settings for the "kangaroos" and their behavior, with GPU-accelerated processing. Do you think there’s a need for a tool like this?
|
|
|
|
|
cctv5go
Newbie

Activity: 65
Merit: 0
|
 |
November 12, 2026, 08:49:54 AM |
|
==========* FOUND!========= [Launch 58] Total:93, 415, 538, 688 koys | Rate: 377.25 M keys/s | Elapsed: 4.3s Device Name: NVIDIA GeForce GTX 1650 Ti FOUND VERIFIED SOLUTION: PRIVATE KEY: 1,003,651,412,950 SEARCH TIME: 00:00:02 probes_done: 536870912 (0.0977% of sweep)
 The scanning method is different, and so are the results. Bro, you did a good job.
|
|
|
|
|
Bitcoin71
Newbie

Activity: 7
Merit: 1
|
 |
November 12, 2026, 09:22:11 AM |
|
Did anyone considered converting that private keys to RAW micro timestamp? From the exact time of the transaction You might get something here!
|
|
|
|
|
brainless
Member


Activity: 510
Merit: 46
|
 |
November 17, 2026, 01:09:33 PM |
|
Who have ability to check 1 million pubkeys in 100 bit range, with kangaroo +database And how much time it will take?
|
13sXkWqtivcMtNGQpskD78iqsgVy9hcHLF
|
|
|
bankeroft
Newbie

Activity: 26
Merit: 0
|
 |
November 17, 2026, 10:12:49 PM |
|
Who have ability to check 1 million pubkeys in 100 bit range, with kangaroo +database And how much time it will take?
Using Kangaroo + existing databases to "scan" 1 million 100-bit public keys one by one is theoretically possible but practically infeasible, with time measured in thousands of years or more 
|
|
|
|
|
Efim_Wr
Newbie

Activity: 11
Merit: 0
|
 |
November 18, 2026, 10:48:24 AM |
|
Who have ability to check 1 million pubkeys in 100 bit range, with kangaroo +database And how much time it will take?
On a Tesla V100, searching for a single key within a given range takes about a day; consequently, searching for 1 million keys on the same graphics card would require 1 million days—though if the card proves to be faster, the result could be obtained sooner.
|
|
|
|
|
|
kTimesG
|
 |
November 18, 2026, 02:48:32 PM |
|
Who have ability to check 1 million pubkeys in 100 bit range, with kangaroo +database And how much time it will take?
Assuming all keys are actually in the same interval: First key found after ~2**50 steps, more or less. Second key found faster. ... The millionth key found after around 2**33 steps, so basically instantly. Total cost: around a few million dollars in compute time, where each subsequent key costs less than the previous one. Totally feasible in matters of days if you have the bucks. It's funny to see opinions of this task taking millions of years, that is correct if you run things on toasters, and it would have the exact same total cost anyway.
|
|
|
|
Liquid_One
Newbie

Activity: 2
Merit: 0
|
 |
November 18, 2026, 08:56:51 PM |
|
I dunno why this puzzle still gets some users' attention. It just ain't mathematically profitable at the current difficulty. Maybe it's 'cause of the amount of money. If I was the creator, I'd just release the private keys for all the rest of 'em, at least from 76 on, and leave 4 up to the luck of the hashes, if in their head they also wanna test some hash vulnerability.
|
|
|
|
|
fecell
Jr. Member

Activity: 205
Merit: 2
|
 |
November 19, 2026, 09:35:33 AM |
|
I dunno why this puzzle still gets some users' attention. It just ain't mathematically profitable at the current difficulty. Maybe it's 'cause of the amount of money. If I was the creator, I'd just release the private keys for all the rest of 'em, at least from 76 on, and leave 4 up to the luck of the hashes, if in their head they also wanna test some hash vulnerability.
The essence of the experiment is to understand just how powerful modern technologies - algorithms, hardware, scalability, and so on - truly are.
|
|
|
|
|
linuzm0b
Newbie

Activity: 2
Merit: 0
|
 |
November 19, 2026, 10:33:55 AM |
|
Someone knows the original wallet software or generator implementation or any BIP32 derivation information (xpub, chain code or derivation path) ?
|
|
|
|
|
fecell
Jr. Member

Activity: 205
Merit: 2
|
 |
November 19, 2026, 12:30:05 PM |
|
point (scalar) 28 very interesting at secp256k1.  It is incomprehensible how two points ended up on the same straight line as the final point. """Гpaфичecкaя визyaлизaция тoчeк secp256k1: (2^i)G и cкaляpнoгo yмнoжeния P = k·G."""
import math import random import tkinter as tk from tkinter import ttk, messagebox
import matplotlib
matplotlib.use("TkAgg") from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk from matplotlib.figure import Figure
# Пapaмeтpы secp256k1 P_CURVE = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F A_CURVE = 0 B_CURVE = 7 GX = 0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798 GY = 0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8 N_ORDER = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
# Цвeтa гpaфикa COLOR_G = "red" # тoчкa G — кpacнaя звёздoчкa COLOR_POW = "tab:blue" # тoчки (2^i)G COLOR_P = "tab:green" # тoчкa P COLOR_LINE = "gray" # лyчи oт P к тoчкaм-cлaгaeмым
class ECPoint: """Toчкa кpивoй в aффинныx кoopдинaтax; бecкoнeчнocть зaдaётcя (None, None)."""
__slots__ = ("x", "y")
def __init__(self, x, y): self.x = x self.y = y
def is_infinity(self): return self.x is None
def __eq__(self, other): if not isinstance(other, ECPoint): return NotImplemented return self.x == other.x and self.y == other.y
def __repr__(self): if self.is_infinity(): return "ECPoint(infinity)" return f"ECPoint({hex(self.x)}, {hex(self.y)})"
INF = ECPoint(None, None) G = ECPoint(GX, GY)
def is_on_curve(point): """Пpoвepкa пpинaдлeжнocти тoчки кpивoй y^2 = x^3 + 7 (mod p).""" if point.is_infinity(): return True return (point.y ** 2 - (point.x ** 3 + A_CURVE * point.x + B_CURVE)) % P_CURVE == 0
def inv_mod(k, mod=P_CURVE): """Oбpaтный элeмeнт пo мoдyлю.""" return pow(k % mod, -1, mod)
def point_add(p1, p2): """Cлoжeниe тoчeк кpивoй.""" if p1.is_infinity(): return p2 if p2.is_infinity(): return p1
x1, y1 = p1.x, p1.y x2, y2 = p2.x, p2.y
if x1 == x2: if (y1 - y2) % P_CURVE == 0: # Удвoeниe (P == P); cлyчaй y == 0 дaёт тoчкy нa бecкoнeчнocти if y1 == 0: return INF lam = (3 * x1 * x1 + A_CURVE) * inv_mod(2 * y1) % P_CURVE else: # P1 == -P2 return INF else: lam = (y2 - y1) * inv_mod(x2 - x1) % P_CURVE
x3 = (lam * lam - x1 - x2) % P_CURVE y3 = (lam * (x1 - x3) - y1) % P_CURVE return ECPoint(x3, y3)
def point_double(point): return point_add(point, point)
def parse_int(text): """Paзбop цeлoгo в дecятичнoм или шecтнaдцaтepичнoм (0x...) видe.""" text = text.strip().replace("_", "").replace(" ", "") if not text: raise ValueError("пycтoe знaчeниe") return int(text, 0)
class NavigationToolbarNoCoords(NavigationToolbar2Tk): """Tyлбap matplotlib бeз вывoдa кoopдинaт кypcopa "(x, y) = ..."."""
def set_message(self, s): pass
class Secp256k1PlotApp: def __init__(self, root): self.root = root root.title("secp256k1: тoчки (2^i)G и cкaляp P") root.geometry("1000x780") root.minsize(700, 500)
self.scalar_var = tk.StringVar(value="1") self.bits_var = tk.StringVar(value="16") self._anim_running = False self._anim_job = None
self._build_ui() self.plot_current() self.root.protocol("WM_DELETE_WINDOW", self.on_close)
def on_close(self): self.on_stop() self.root.destroy()
def _build_ui(self): controls = ttk.Frame(self.root, padding=8) controls.pack(side=tk.TOP, fill=tk.X)
ttk.Label(controls, text="Cкaляp:").grid(row=0, column=0, sticky="w") ttk.Entry(controls, textvariable=self.scalar_var, width=50).grid( row=0, column=1, sticky="we", padx=(4, 12) )
ttk.Label(controls, text="Битнocть:").grid(row=0, column=2, sticky="w") ttk.Entry(controls, textvariable=self.bits_var, width=8).grid( row=0, column=3, sticky="w", padx=(4, 12) )
ttk.Button(controls, text="Random", command=self.on_random).grid(row=0, column=4, padx=(0, 6)) ttk.Button(controls, text="Пocтpoить", command=self.plot_current).grid(row=0, column=5)
self.start_btn = ttk.Button(controls, text="Start", command=self.on_start) self.start_btn.grid(row=0, column=6, padx=(12, 0)) self.stop_btn = ttk.Button(controls, text="Stop", command=self.on_stop, state=tk.DISABLED) self.stop_btn.grid(row=0, column=7, padx=(6, 0))
controls.columnconfigure(1, weight=1)
fig_frame = ttk.Frame(self.root) fig_frame.pack(side=tk.TOP, fill=tk.BOTH, expand=True)
self.fig = Figure(figsize=(9, 7), dpi=100) self.ax = self.fig.add_subplot(111) self.fig.subplots_adjust(left=0.04, right=0.97, top=0.96, bottom=0.05)
self.canvas = FigureCanvasTkAgg(self.fig, master=fig_frame) self.toolbar = NavigationToolbarNoCoords(self.canvas, fig_frame, pack_toolbar=False)
# Tyлбap и cтpoкa cyммы yпaкoвывaютcя ДO canvas, чтoбы canvas # (зaпpaшивaющий 900x700) нe oтнял вcё пpocтpaнcтвo oкнa. self.toolbar.pack(side=tk.BOTTOM, fill=tk.X)
self.sum_var = tk.StringVar(value="") self.sum_label = ttk.Label( fig_frame, textvariable=self.sum_var, padding=(8, 6), font=("TkDefaultFont", 10, "bold"), ) self.sum_label.pack(side=tk.BOTTOM, fill=tk.X)
self.canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=True)
self.root.bind("<Return>", lambda _e: self.plot_current())
def on_random(self): try: bits = parse_int(self.bits_var.get()) except ValueError: messagebox.showerror("Oшибкa", "Heкoppeктнoe знaчeниe битнocти.") return if not 1 <= bits <= 256: messagebox.showerror("Oшибкa", "Битнocть дoлжнa быть в диaпaзoнe 1..256.") return self.scalar_var.set(str(random.randint(2 ** (bits - 1), (2 ** bits) - 1))) self.plot_current()
# --- Peжим aнимaции: cкaляp yвeличивaeтcя нa 1 кaждыe 2 ceкyнды ---
def on_start(self): if self._anim_job is not None: return self._anim_running = True self.start_btn.config(state=tk.DISABLED) self.stop_btn.config(state=tk.NORMAL) self._anim_job = self.root.after(2000, self._anim_step)
def on_stop(self): self._anim_running = False if self._anim_job is not None: self.root.after_cancel(self._anim_job) self._anim_job = None self.start_btn.config(state=tk.NORMAL) self.stop_btn.config(state=tk.DISABLED)
def _anim_step(self): self._anim_job = None if not self._anim_running: return try: scalar = parse_int(self.scalar_var.get()) except ValueError: # Heкoppeктный ввoд — пpoпycкaeм шaг, нe мeшaя aнимaции self._anim_job = self.root.after(2000, self._anim_step) return # Пo дocтижeнии n-1 cкaляp пepeзaпycкaeтcя c 1 scalar = 1 if scalar >= N_ORDER - 1 else scalar + 1 self.scalar_var.set(str(scalar)) self.plot_current() self._anim_job = self.root.after(500, self._anim_step)
def plot_current(self): try: scalar = parse_int(self.scalar_var.get()) except ValueError: messagebox.showerror("Oшибкa", "Heкoppeктнoe знaчeниe cкaляpa.") return if not 0 < scalar < N_ORDER: messagebox.showerror("Oшибкa", "Cкaляp дoлжeн быть в диaпaзoнe 1..n-1.") return
# Oдин пpoxoд: cтpoим тoчки (2^i)G и oднoвpeмeннo P = cyммa cлaгaeмыx # пo eдиничным битaм cкaляpa. pow_points = [] components = [] # индeкcы i, вxoдящиe в бинapнoe paзлoжeниe cкaляpa p_point = INF cur = G tmp = scalar while tmp: if tmp & 1: components.append(len(pow_points)) p_point = point_add(p_point, cur) pow_points.append(cur) cur = point_double(cur) tmp >>= 1
# Cyммa длин вcex лyчeй (кoopдинaты нopмиpoвaны нa p, квaдpaт 0..1) px_n, py_n = p_point.x / P_CURVE, p_point.y / P_CURVE total_len = 0.0 for idx in components: q = pow_points[idx] total_len += math.hypot(px_n - q.x / P_CURVE, py_n - q.y / P_CURVE) self.sum_var.set(f"Cyммa длин лyчeй: {total_len:.6f}")
self._draw_plot(pow_points, components, p_point)
def _draw_plot(self, pow_points, components, p_point): ax = self.ax ax.clear()
# Toчки (2^i)G; пepвaя — G, выдeляeтcя кpacнoй звёздoчкoй. # Кoopдинaты нopмиpyютcя нa p, чтoбы гpaфик вceгдa зaнимaл квaдpaт 0..1. xs, ys = [], [] for idx, pt in enumerate(pow_points): x, y = pt.x / P_CURVE, pt.y / P_CURVE if idx == 0: ax.scatter([x], [y], s=140, marker="*", color=COLOR_G, zorder=5) ax.annotate( str(idx + 1), (x, y), textcoords="offset points", xytext=(6, 6), fontsize=9, fontweight="bold", color=COLOR_G, ) else: xs.append(x) ys.append(y) ax.annotate( str(idx + 1), (x, y), textcoords="offset points", xytext=(5, 4), fontsize=8, color=COLOR_POW, ) if xs: ax.scatter(xs, ys, s=40, marker="o", color=COLOR_POW, zorder=4)
# Toчкa P (бeз пoдпиcи) и лyчи к тoчкaм-cлaгaeмым if not p_point.is_infinity(): px, py = p_point.x / P_CURVE, p_point.y / P_CURVE for idx in components: q = pow_points[idx] ax.plot( [px, q.x / P_CURVE], [py, q.y / P_CURVE], color=COLOR_LINE, linewidth=1.0, alpha=0.6, zorder=3, ) ax.scatter([px], [py], s=40, marker="o", color=COLOR_P, zorder=6)
# Фикcиpoвaнный мacштaб 0..1 пo oбeим ocям, бeз дeлeний и пoдпиceй ax.set_xlim(0, 1) ax.set_ylim(0, 1) ax.set_autoscale_on(False) ax.tick_params(left=False, bottom=False, labelleft=False, labelbottom=False) ax.grid(False)
self.canvas.draw_idle()
def main(): if not is_on_curve(G): raise RuntimeError("Гeнepaтop G нe лeжит нa кpивoй secp256k1 — пpoвepьтe пapaмeтpы.")
root = tk.Tk() style = ttk.Style() if "clam" in style.theme_names(): style.theme_use("clam") Secp256k1PlotApp(root) root.mainloop()
if __name__ == "__main__": main()
|
|
|
|
|
Bitcoin71
Newbie

Activity: 7
Merit: 1
|
 |
November 21, 2026, 01:43:13 PM |
|
Is this range fully scanned anyone has data 410000000000000000:41ffffffffffffffff Thanks for anyone is answering in advance.
|
|
|
|
|
SecretAdmirere
Jr. Member

Activity: 35
Merit: 2
|
 |
Today at 12:23:15 AM |
|
CUDACyclone-SecretAdmirere: a Windows CUDA solver for the Bitcoin puzzle transaction Topic: https://bitcointalk.org/index.php?topic=5599906.msg67347221#msg67347221Hello everyone, I rewrote a version of a CUDA puzzle solver, and I'm releasing it as open source (GPLv3). Features- Compressed P2PKH addresses only
- Windows 10/11 x64 only, NVIDIA RTX 30xx, 40xx and 50xx GPUs only
- Randomized search (not a sequential scan)
- Modular design with easy-to-follow logic. The GPU math (CUDAMath.cuh) and hashing (CUDAHash.cuh) are separate headers. If you don't like my search logic, you are welcome to take these two files, or parts of the code, and use them in your own project under the GPLv3 license. The optimized math, hashing and kernels are where the speed increase on GPUs comes from.
SpeedI measured about +27% and +37% over the reference figure from btcpuzzle.info/benchmark on an RTX 3070 Ti and 3080 Ti (real kernel speed, not Speed With Included Overhead). I have only tested those two cards so far. The other values in the README table are estimates (27% applied to the reference figure), and I will replace them as people post results. Please post your GPU, --grid and speed below, and make sure you use NVIDIA's official reference TDP for the card you benchmark. RTX 5090 - 10,236 Mkeys/s (10.2B key/s) Estimated RTX 4090 - 7,569 Mkeys/s (7.5B key/s) Estimated RTX 3090 Ti - 3,581 Mkeys/s (3.5B key/s) Estimated Notes- It is a probabilistic search: there is no guaranteed coverage and no guaranteed time to find a key.
- --pubkey mode is intended for benchmarking only.
- The precompiled .exe may be flagged by some antivirus programs. The full source is in the repo, so you can build it yourself with Visual Studio 2022 and the latest CUDA Toolkit.
Download / sourceGitHub: CUDACyclone-SecretAdmirereCreditsInspired by Dookoo2's CUDACyclone. Includes parts derived from Jean Luc PONS' VanitySearch and RetiredCoder's RCKangaroo (both GPLv3). DonationsMy PC was recently destroyed by a PSU failure and I'm saving for used parts to keep developing (about $2,000 needed). Any help is appreciated: bc1q67nxvkge5ylq7fsvkhujmpvnut2a3964jqn4el Use at your own risk. Feedback, bug reports, suggestions, thoughts are welcome.
|
bc1q67nxvkge5ylq7fsvkhujmpvnut2a3964jqn4el
|
|
|
|