Pages:
Author

Topic: Bitcoin puzzle transaction ~32 BTC prize to who solves it - page 19. (Read 230658 times)

newbie
Activity: 10
Merit: 0
if you use bsgs(kangaroo)

What is bsgs(kangaroo) Huh

Those are different things, ONE think is Kangaroo and another complete different thing is bsgs.
Kangaroo is much more faster because it doesn't depend of memory like BSGS does.

kangaroo can solve that challenge in less of one minute with the proper data already precomputed.
This is the choice of bsgs or kangaroo...
You are too critical of words.
by reading my comments and responding to them, you contradict what you said. You don't have much time to talk...Or am I wrong again somewhere?
hero member
Activity: 862
Merit: 662
I would estimate the likelihood of human versus AI authorship as follows:

AI-written: 60%
Human-written: 40%

@Akito obviously it was partially or fully generated by AI. But to be Honest I really like such comparative and explanation.

@kTimesG thank you very much about your post, i am reading the papers that you linked the other day in some other topic.

@albert0bsd: why would I ever need to break my own key? I will already know it...

No, I will not try to replace the TX.

Thanks for the clarification, in that case it is going to be a really nice challenge. Sorry for spoil the public key transformation/rotation.
member
Activity: 499
Merit: 38
Hahahaha! For god's sake... how did we even get here? One minute, we're discussing technical nuances, and the next, AI-generated texts are spiraling out of control.  Roll Eyes Grin
jr. member
Activity: 42
Merit: 0
The moral of the story?

ChatGPT language analysis.

AI Indicators:
Structured Narrative: The text has a playful, somewhat formulaic narrative structure that is reminiscent of how AI might organize a story, especially when blending humor and technical content.
Consistent Voice: The tone is consistent throughout, which is typical of AI-generated content, as AI tends to maintain a steady writing style and tone.
Lack of Personal Experience or Deep Subjectivity: The text presents abstract concepts in a playful manner but doesn’t delve into personal experiences or unique subjective perspectives, which can sometimes be a giveaway of AI content.

I would estimate the likelihood of human versus AI authorship as follows:

AI-written: 60%
Human-written: 40%


I don't have the ability to directly access information about specific users like Digaran or their writing. If this is someone whose work you are familiar with, you might be able to identify their style or content based on your own knowledge of their writing patterns, but I can't definitively say whether this text was initiated by them or not.
member
Activity: 165
Merit: 26
if you use bsgs(kangaroo)

What is bsgs(kangaroo) Huh

BSGS(Kangaroo)

In the cryptic world of Elliptic Curve Land, there lived two kangaroos on a mission to solve one of Bitcoin’s deepest mysteries: finding k such that k · G = P. To be fair, no one asked kangaroos to solve the discrete logarithm problem, but that’s where we ended up. Blame cryptographers. They just really love making things unnecessarily complex.

So, we had two types of kangaroos: one Tame and one Wild, both with vastly different ideas about how to go about the job.



The Tame Kangaroo: Mr. Organized (a bit too much)

The Tame Kangaroo was the sort of kangaroo that kept spreadsheets for everything. It approached the problem with the Baby Step Giant Step (BSGS) method. Step one: methodically start from a known point and hop forward in baby steps, taking small, calculated leaps along the elliptic curve. Every step was carefully recorded in what cryptographers would call a “hash table,” but really it was just a fancy scroll of distinguished points.

Each point was a “distinguished point,” which is cryptographer-speak for "the Tame Kangaroo decided this point was important, even if no one else cares." The kangaroo filled its scroll with these, convinced that someday, all this careful planning would pay off.

“Slow and steady,” the Tame Kangaroo mumbled, hopping one tiny step at a time. Of course, slow and steady also means slow, like the kind of slow that makes you question if elliptic curves are really worth it. But the Tame Kangaroo was committed, carefully calculating every single move, knowing it was storing each of these baby steps for future reference.

Once the scroll was filled with baby steps, the Tame Kangaroo moved on to giant steps. Now, instead of inching along like a cautious librarian, it started bounding across the elliptic curve with bigger leaps. Giant steps! Progress! But of course, every few hops, the Tame Kangaroo had to stop and check its giant scroll of baby steps, making sure it wasn’t missing anything. This was still BSGS, after all. Planning was everything.



The Wild Kangaroo: Leaping Without a Plan

Meanwhile, the Wild Kangaroo couldn’t have cared less about precomputation. Baby steps? Scrolls? Giant steps? Nah, it had a different strategy: random hopping. Armed with nothing but a vague sense of direction and the Kangaroo Method, it launched itself into the curve, jumping around at random like it was trying to escape the logic of elliptic curves altogether. The Wild Kangaroo didn’t precompute anything. Why would it? If it hopped enough, surely it’d land on something important.

Now, this hopping wasn’t completely without structure. The Wild Kangaroo relied on those distinguished points—because even chaos needs occasional markers to know it’s not completely lost. Every time the Wild Kangaroo landed on one of these distinguished points, it would stop and look around, hoping the Tame Kangaroo was nearby.

“Who needs a plan when you can just bounce around until something works?” thought the Wild Kangaroo, probably mid-leap. And, honestly, it wasn’t wrong. The Wild Kangaroo’s approach was all about finding k through sheer trial and error, covering large parts of the curve quickly, and hoping the Tame Kangaroo would eventually cross paths with it.



The Moment of Collision

Both kangaroos were now bounding around the elliptic curve, one methodical, one chaotic. The Tame Kangaroo carefully hopping in giant steps, pausing to check its scroll every few leaps, and the Wild Kangaroo bouncing between distinguished points, blissfully ignoring the concept of “memory.”

And then it happened. They collided.

Right on the same distinguished point, both kangaroos landed at the exact same time. For a brief moment, they just stared at each other, both surprised that they had ended up in the same place.

“I spent days calculating every hop,” the Tame Kangaroo muttered, exhausted from all the memory management. “Giant steps, baby steps, a whole scroll of computations.”

“Oh,” said the Wild Kangaroo, scratching its head. “I just kinda… jumped around and got lucky.”

The Tame Kangaroo sighed. After all that work, the Wild Kangaroo had stumbled onto the same solution without bothering with any of the precomputation, baby steps, or giant scrolls. They both had the value of k, but only one of them had bothered to keep notes.



The Final Lesson: Kangaroo Chaos Works, Sort of

So, in the end, they both cracked the elliptic curve problem. But here’s the thing: the BSGS(Kangaroo) method works, sure, but the Kangaroo Method doesn’t care about your fancy scrolls or precomputed baby steps. It hops randomly from distinguished point to distinguished point, hoping to get lucky—and sometimes, it does.

The moral of the story? You can spend ages carefully calculating every baby step, or you can jump around without a plan. Both approaches will get you to k, but the Tame Kangaroo will be left wondering if all that meticulous planning was really worth it when the Wild Kangaroo got there by sheer dumb luck. In the world of elliptic curves, sometimes random hopping works just as well as careful thought—especially when the math is more stubborn than a kangaroo in mid-leap.
hero member
Activity: 862
Merit: 662
if you use bsgs(kangaroo)

What is bsgs(kangaroo) Huh

Those are different things, ONE think is Kangaroo and another complete different thing is bsgs.
Kangaroo is much more faster because it doesn't depend of memory like BSGS does.

kangaroo can solve that challenge in less of one minute with the proper data already precomputed.
newbie
Activity: 10
Merit: 0
hello! I'm sorry, it seemed to me or you explained everything somehow difficult. to solve the problem.

Difficult?

It clear like a water!!

can I write to you in private messages?

TBH i don't have enough time for this, so the answer is no.

Understood, sorry to bother you.



Part of this challenge is to see how different people think about it. Take it as a survey of mindsets.

@albert0bsd: why would I ever need to break my own key? I will already know it...

No, I will not try to replace the TX.

All of you have until 11.01 00:00 to get your EC checked up. Let's all hope COBRAS doesn't break it by then, he's really into something interesting, dividing and multiplying values just to end up with what he started with.
if you use bsgs(kangaroo) at a speed of 20 ekeys / sec, a complete search will take 9 hours. if you run 10-16 computers at a speed of 2ekeys / sec, it should be found in 1-2 hours. a rough approach to solving your problem and in fact the simplest) although, for this you need to change the generation of bsgs(kangaroo), and this may be more difficult. Good luck with you survey of mindsets.
member
Activity: 165
Merit: 26
Part of this challenge is to see how different people think about it. Take it as a survey of mindsets.

@albert0bsd: why would I ever need to break my own key? I will already know it...

No, I will not try to replace the TX.

All of you have until 11.01 00:00 to get your EC checked up. Let's all hope COBRAS doesn't break it by then, he's really into something interesting, dividing and multiplying values just to end up with what he started with.
hero member
Activity: 862
Merit: 662
hello! I'm sorry, it seemed to me or you explained everything somehow difficult. to solve the problem.

Difficult?

It clear like a water!!

can I write to you in private messages?

TBH i don't have enough time for this, so the answer is no.
newbie
Activity: 10
Merit: 0
Together with the target address I will also provide the range of the search interval.

This will be in the form (just an example):

Code:
minKey = 0xf2e542b46066c4e6f91abc80000000000000000000185e689447431d74c5b133
maxKey = 0xf2e542b46066c4e6f91abcbfffffffffffffffffffd85e689447431d74c5b133

The Hamming length of the range will therefore be 80 contiguous bits, but they may start anywhere.


Nice Challenge

Well If you provide the EXACT range it can be solve subtracting the bits that remain same in both start an end range example for some key as your example:

Code:
StarRange: f2e542b46066c4e6f91abc80000000000000000000185e689447431d74c5b133
ENDRange:  f2e542b46066c4e6f91abcbfffffffffffffffffff185e689447431d74c5b133

Key:       f2e542b46066c4e6f91abcc206b831c41b15d6bf49185e689447431d74c5b133
Publickey: 0259f57acc739162a68785c08baf201da1b2797d90ded6cd5dde5c3f26b6df24ae
MSB      : f2e542b46066c4e6f91abc000000000000000000000000000000000000000000


Subtracting Most significan bits:

Code:
./keymath 0259f57acc739162a68785c08baf201da1b2797d90ded6cd5dde5c3f26b6df24ae - 0xf2e542b46066c4e6f91abc000000000000000000000000000000000000000000
Result: 03dc89a446662604456da1f1fdfba0e578fb69e9750751081b3e070cb747280bfc

With this step the original  key may look like: 0xc206b831c41b15d6bf49185e689447431d74c5b133

Subtracting Less significan bits:

LSB:       000000000000000000000000000000000000000000185e689447431d74c5b133

Code:
./keymath 03dc89a446662604456da1f1fdfba0e578fb69e9750751081b3e070cb747280bfc - 0x185e689447431d74c5b133
Result: 029659ffde564a27b7e6ea76936dcc6c33ef969d1a089a05214151ebc9ef4f9db7

With this step the original key may look like: 0xc206b831c41b15d6bf490000000000000000000000

Now we need to remove zeros on the right:

0xc206b831c41b15d6bf490000000000000000000000
                   0x10000000000000000000000

Code:
./keymath 029659ffde564a27b7e6ea76936dcc6c33ef969d1a089a05214151ebc9ef4f9db7 / 0x10000000000000000000000
Result: 027fb98c7edb7aef934a25eaf02384dbb42a9b8a32a85b451a5e13e5ebdd613f85

With this step the original key may look like: 0xc206b831c41b15d6bf49
So once that you solve the public key: 027fb98c7edb7aef934a25eaf02384dbb42a9b8a32a85b451a5e13e5ebdd613f85

You need to do do the same steps backwards to get the original key.

So this is just a simple 80 bit challenge that can be solve with kangaroo:

Now

Currently I have a 80-bits solver DP database that can solve any key in under 6 seconds on a GPU, and under a minute if using the CPU.

If you can solve it under 6 seconds on GPU or under a minute un CPU then this is not any challenge if you already have the right tools and scripts to the operations on the public key.

Since time ago you have such DP dataset the I bet nobody is going to beat you

Well, that's it, we're screwed. My 3-kangaroo C program also runs on Raspberry Pi. I also have it an Android app with native JNI bindings to it. So every time I wake it up it runs a few batches to mine DPs. Next step is to implement kang on mobile GPUs using Vulkan.


hello! I'm sorry, it seemed to me or you explained everything somehow difficult. to solve the problem, you need to change the generation of kangaroos or bsgs. so that she leaves the beginning and the end and goes through the middle (the 80-bit segment selected by him in a 256-bit key). the public key, he will give. I'm sorry again...
and also, I have one question for you, can I write to you in private messages?
hero member
Activity: 862
Merit: 662
Together with the target address I will also provide the range of the search interval.

This will be in the form (just an example):

Code:
minKey = 0xf2e542b46066c4e6f91abc80000000000000000000185e689447431d74c5b133
maxKey = 0xf2e542b46066c4e6f91abcbfffffffffffffffffffd85e689447431d74c5b133

The Hamming length of the range will therefore be 80 contiguous bits, but they may start anywhere.


Nice Challenge

Well If you provide the EXACT range it can be solve subtracting the bits that remain same in both start an end range example for some key as your example:

Code:
StarRange: f2e542b46066c4e6f91abc80000000000000000000185e689447431d74c5b133
ENDRange:  f2e542b46066c4e6f91abcbfffffffffffffffffff185e689447431d74c5b133

Key:       f2e542b46066c4e6f91abcc206b831c41b15d6bf49185e689447431d74c5b133
Publickey: 0259f57acc739162a68785c08baf201da1b2797d90ded6cd5dde5c3f26b6df24ae
MSB      : f2e542b46066c4e6f91abc000000000000000000000000000000000000000000


Subtracting Most significan bits:

Code:
./keymath 0259f57acc739162a68785c08baf201da1b2797d90ded6cd5dde5c3f26b6df24ae - 0xf2e542b46066c4e6f91abc000000000000000000000000000000000000000000
Result: 03dc89a446662604456da1f1fdfba0e578fb69e9750751081b3e070cb747280bfc

With this step the original  key may look like: 0xc206b831c41b15d6bf49185e689447431d74c5b133

Subtracting Less significan bits:

LSB:       000000000000000000000000000000000000000000185e689447431d74c5b133

Code:
./keymath 03dc89a446662604456da1f1fdfba0e578fb69e9750751081b3e070cb747280bfc - 0x185e689447431d74c5b133
Result: 029659ffde564a27b7e6ea76936dcc6c33ef969d1a089a05214151ebc9ef4f9db7

With this step the original key may look like: 0xc206b831c41b15d6bf490000000000000000000000

Now we need to remove zeros on the right:

0xc206b831c41b15d6bf490000000000000000000000
                   0x10000000000000000000000

Code:
./keymath 029659ffde564a27b7e6ea76936dcc6c33ef969d1a089a05214151ebc9ef4f9db7 / 0x10000000000000000000000
Result: 027fb98c7edb7aef934a25eaf02384dbb42a9b8a32a85b451a5e13e5ebdd613f85

With this step the original key may look like: 0xc206b831c41b15d6bf49
So once that you solve the public key: 027fb98c7edb7aef934a25eaf02384dbb42a9b8a32a85b451a5e13e5ebdd613f85

You need to do do the same steps backwards to get the original key.

So this is just a simple 80 bit challenge that can be solve with kangaroo:

Now

Currently I have a 80-bits solver DP database that can solve any key in under 6 seconds on a GPU, and under a minute if using the CPU.

If you can solve it under 6 seconds on GPU or under a minute un CPU then this is not any challenge if you already have the right tools and scripts to the operations on the public key.

Since time ago you have such DP dataset the I bet nobody is going to beat you

Well, that's it, we're screwed. My 3-kangaroo C program also runs on Raspberry Pi. I also have it an Android app with native JNI bindings to it. So every time I wake it up it runs a few batches to mine DPs. Next step is to implement kang on mobile GPUs using Vulkan.

member
Activity: 873
Merit: 22
$$P2P BTC BRUTE.JOIN NOW ! https://uclck.me/SQPJk
Digaran, Cobras, etc. go to bed please

)))

use DD = (P - D) %N as a P many times, result  from 2^120 to
print( 0x29d7a836ea187f2e1fc2 -2**77) 78 bit.This is by hands calculation, without for/wile - not many pubkeys.
hero member
Activity: 630
Merit: 731
Bitcoin g33k
Digaran, Cobras, etc. go to bed please
member
Activity: 873
Merit: 22
$$P2P BTC BRUTE.JOIN NOW ! https://uclck.me/SQPJk
How to get 2^60 publick or privkey from 120bit privkey. This is not ready to use, but, maybe someone will be interested:



Code:

N = 115792089237316195423570985008687907852837564279074904382605163141518161494337

# Фyнкция для нaxoждeния oбpaтнoгo элeмeнтa
def inv(v):
    return pow(v, N - 2, N)
def divnum(a, b):
    return (a * inv(b)) % N



target = 2**40 #this is what thant in result

divider = 2**40

P= 0x0000000000000000000000000000000000b10f22572c497a836ea187f2e1fc23 #privkey of 2**120




D = (target * divider) %N

DD = (P - D) %N

print(hex(DD*1%N))

F = ((P -DD %N)*1%N)%N

print(hex(F))

result= divnum(F,divider)

print(hex(result))








output:

0xb10f22572b497a836ea187f2e1fc23
0x100000000000000000000
0x10000000000


for get 2**40  priv after dividing to 2**40,  from 2**120 priv need  substract  from 2**120 priv this number 0xb10f22572b497a836ea187f2e1fc23 and divide to 2**40

any ideas ?
member
Activity: 165
Merit: 26
Well, that's it, we're screwed. My 3-kangaroo C program also runs on Raspberry Pi. I also have it an Android app with native JNI bindings to it. So every time I wake it up it runs a few batches to mine DPs. Next step is to implement kang on mobile GPUs using Vulkan.

I'm now looking for a place to rent ASICs where I can run custom software. However, there are firmware restrictions. Most ASICs, such as those from Bitmain (Antminer) or MicroBT (Whatsminer), come with firmware that may limit the ability to install custom software.

So, I guess you're going after #67 / 68 / etc? Cheesy

At this point, we might as well send an inquiry directly to TSMC and ask them how much they'd ask for a custom 3nm secp256k1 SoC. I don't think it's an issue for them, surely NSA already bought a ton of those by now.
newbie
Activity: 14
Merit: 0
I'm now looking for a place to rent ASICs where I can run custom software. However, there are firmware restrictions. Most ASICs, such as those from Bitmain (Antminer) or MicroBT (Whatsminer), come with firmware that may limit the ability to install custom software.
Did you check bitaxe family ?
member
Activity: 499
Merit: 38
Well, that's it, we're screwed. My 3-kangaroo C program also runs on Raspberry Pi. I also have it an Android app with native JNI bindings to it. So every time I wake it up it runs a few batches to mine DPs. Next step is to implement kang on mobile GPUs using Vulkan.


I'm now looking for a place to rent ASICs where I can run custom software. However, there are firmware restrictions. Most ASICs, such as those from Bitmain (Antminer) or MicroBT (Whatsminer), come with firmware that may limit the ability to install custom software.
member
Activity: 165
Merit: 26
Puzzle #60 with a MacBook M1 Max
4.01e+03 seconds is 4010 seconds. So 1 hour and 11 minutes
I'm curious how much would it be with multithreading.

Same speed. Python uses GIL by default, so all threads are actually sequential (interleaved) at the interpreter level, unless you mix in some native libraries and disable GIL while they run.

You'd need to run multiple processes instead (multiprocessing module) but at that point you'll need some way to have a shared concurrency-safe hashmap.

Moral? it's just a high-level kang, not a high-performance kang.

Btw...These days, I'm implementing Kangaroo in VHDL.  Grin

Well, that's it, we're screwed. My 3-kangaroo C program also runs on Raspberry Pi. I also have it an Android app with native JNI bindings to it. So every time I wake it up it runs a few batches to mine DPs. Next step is to implement kang on mobile GPUs using Vulkan.
member
Activity: 499
Merit: 38
LE: oh ok, you said single core, but still... should be 10x - 15x faster than 600k/s.

Rust is 15-20 times faster, but it depends on the architecture.

Btw...These days, I'm implementing Kangaroo in VHDL.  Grin

Code:
architecture fsm of scalar_mult is
  type state_type is (INIT, DOUBLE_ADD, DONE);
  signal state : state_type := INIT;
  signal k : unsigned(255 downto 0); -- Scalar
  signal P, Q : point_type; -- Points on the elliptic curve

begin
  process(clk, reset)
  begin
    if reset = '1' then
      state <= INIT;
    elsif rising_edge(clk) then
      case state is
        when INIT =>
          -- Set up initial values
          Q <= identity_point; -- Q = O
          P <= input_point;    -- P = input point
          state <= DOUBLE_ADD;

        when DOUBLE_ADD =>
          if k(255) = '1' then
            Q <= point_add(Q, P); -- Q = Q + P
          end if;
          P <= point_double(P);   -- P = 2P
          k <= k(254 downto 0) & '0'; -- Shift scalar
          if k = 0 then
            state <= DONE;
          end if;

        when DONE =>
          result <= Q; -- Output the result
      end case;
    end if;
  end process;
end architecture;

and so on.......
member
Activity: 122
Merit: 11
Puzzle #60 with a MacBook M1 Max
4.01e+03 seconds is 4010 seconds. So 1 hour and 11 minutes
I'm curious how much would it be with multithreading.

Code:
Ops: 1640142848 Table size: 25626624 Speed: 408909 ops/s
Ops: 1640964096 Table size: 25639463 Speed: 408910 ops/s
Private Key: 0xfc07a1825367bbe
Ops: 1641142272 Stored: 25642283
Speed: 408885 ops/s
Finished in 4.01e+03 s


What's the point of all of this ?  You will never solve puzzle #135 with consumer class CPU.  Lower ranges can be solved with currently existing tools much faster  than python script...
Pages:
Jump to: