Author

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

newbie
Activity: 18
Merit: 0
hi "nomachine"
It is not possible to send private messages.
Please email me if possible.
[email protected]
member
Activity: 462
Merit: 24
I'm curious how many of these you've solved with this method of seeding the random with specific values; was it only #50?


I've tried all possible puzzles from 1 to 50 and iterate over possible seed values, set the seed, generate a random number, and check if it matches target number(WIF in decimal). Solved up to 50.

I tried the same method with #65 and I'm getting an approximate number for now.

Code:
import random
min_number = 18446744073709551615
max_number = 36893488147419103231
random_bytes = b'r\xbd\x83\r\xec}\xfc\xbf\xde'
random.seed(random_bytes)
generated_number = random.randint(min_number, max_number)
print("Seed :", random_bytes)
print("Generated number:", generated_number)

Seed : b'r\xbd\x83\r\xec}\xfc\xbf\xde'
Generated number: 30568377314984161259

And need to be:
30568377312064202855


This approach may take a very long time to find the correct seed value, as it essentially involves brute-forcing all possible seeds. Depending on the range of possible seeds (length in bytes) and the complexity of the random number generator, this process could be impractical. Require an enormous amount of computational resources and time.

What I concluded from everything is that the seed is a value in bytes with 90% certainty. And there is no pattern.
Not a timestamp - can't be reproduced by going back in time.
member
Activity: 93
Merit: 16
You are right. To be more precise, we use the van Oorschot and Weiner Method of kangaroos.

I imagined if you use Gaudry Schost method (re-place a kangaroo at a new random point as soon as you hit a distinguished point) that you could have an advantage.
Especially when using tame points in the target bitrange and wild points where one or many might not be in the target bit-range (e.g. when having many targets while experimenting with division).

You would kind of saturate the tame DPs more and more while the chance to hit a DP with the wild range increases.

But today I don't think it is of much use.
You can move tame kangaroos like this:
Code:
// Random Tame StartingKey range bnL - bnU
Int TameStartingKey;
Int tsk;
new_tsk:
tsk.Rand(pow2U);
if (tsk.IsLower(&bnL)) goto new_tsk;
TameStartingKey.Set(&tsk);
//
Int tkey;
tkey.Rand(pow2W);
keys[index].SetInt32(0);
keys[index].Add(&TameStartingKey);// Tame keys
keys[index].Add(&tkey);
hero member
Activity: 630
Merit: 731
Bitcoin g33k
Please everyone, just stop feeding the troll. The ignore button on your left is very useful. I have used it for a long time, but it doesn't work well when others are quoting the troll and prompting more garbage.



I meant the actual ...[some bullshit]

You lower the value of this thread so much by just using it as your personal diary.

absolutely agree! +1
newbie
Activity: 7
Merit: 0
We can either try to brute-force the pkeys, and/or we can try to reverse-engineer (also by some amount of brute-force, I guess) and recreate the process by which the pkeys were created...

I just can't quite grok what's happening here  Huh

Let me explain more... [snip]

Thank you for your answers to my posts, they've been helpful Smiley I'm curious how many of these you've solved with this method of seeding the random with specific values; was it only #50?

I'd like to review all your posts (and some other users' too) but whenever I go to your profile and click either "Show the last posts of this person" or "Show the last topics started by this person" I don't get any results Sad

...this silly thread where lately only a bunch of newbies divide some public keys.

This is me NGL Cheesy
full member
Activity: 1162
Merit: 237
Shooters Shoot...
Code:
400000000000000000000000000000000
282a8bfbda44ad168dfff85563a4be809
17d5740425bb52e9720007aa9c5b417f7

Really, this is your discovery? Lol.

I found many like this, in decimal format; it is AMAZING:

Code:
110
99
11

110
88
22

1110
888
222

1110
777
333


9=1, 8=2, 7=3, 6=4, etc
After someone solves #130 through #160, I would appreciate a tip, to me, for showing and explaining this extremely, thoroughly etcly.
copper member
Activity: 1330
Merit: 899
🖤😏
Another angle to work on #130, there are many ways to manipulate the ranges, I'm just providing the easiest ones.
Code:
400000000000000000000000000000000
282a8bfbda44ad168dfff85563a4be809
17d5740425bb52e9720007aa9c5b417f7
The second and the third keys above could be considered as #130, look what happens when we subtract each of them from the end range, they are the reverse of each other in hex like 8 turns to 7, a=5, b=4, c=3, d=2, e=1, f=0 etc.

What that means, is that if you could find a definitive mathematical/modular relation between such keys, then you could theoretically solve any keys by doing the same subtractions as above.
They are like when added, they generate a composite number divisible by powers of 2.  Only thing you have to figure, is to find a way either by +, -, /, and *, to land on a constant key, for example it doesn't matter what your key is, if you add 10  to 50 and divide by 2, you can get 30 which has a distance of 10 from half of 30(15) to 25 aka half of target.
I mean some relation like that, find that then you can solve any keys.
Let me show you, if you divide both keys and subtract their results, you can have:
Code:
2- 82a8bfbda44ad168dfff85563a4be809
3- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa28e5131837b7a1186a8bed42070170dc
4- 7fffffffffffffffffffffffffffffff9eabce5229c9b8d24fe8f1f1854114a5
5- 34437fe574eaba29f33302227db7f66a
6- 555555555555555555555555555555551472898c1bdbd08c3545f6a10380b86e
7- 2554c9119ca7a98badb6b861c78366de
8- bfffffffffffffffffffffffffffffff2cad559c6c892c8707dda83f2abbaaf3

Now if you add the results, you will have these :
Code:
2- 200000000000000000000000000000000
3- aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab271f3def1f85c027d536e9b3357980d6
4- 100000000000000000000000000000000
5- 99999999999999999999999999999999a335b7bd9c5ec68a3fe49f2149ba2727
6- 55555555555555555555555555555555938f9ef78fc2e013ea9b74d99abcc06b
7- 9249249249249249249249249249249221887e3aad4e126b490a7f2be4b149dc
8- 80000000000000000000000000000000
Now remember you can always know the second offsets, when you divide and add, if you are interested, try to find a relation between the first 8 offsets and the second 8 offsets, and note that they are only divided by 2 through 8, you can go beyond 2^100 and study the results carefully.

🦟🦟, who let these flies in?
full member
Activity: 1162
Merit: 237
Shooters Shoot...
You are right. To be more precise, we use the van Oorschot and Weiner Method of kangaroos.
The van Oorshot and Weiner method of was the fastest kangaroo method for
over 15 years. In this method, there is one ’Tame’ kangaroo (labelled T), and one ’Wild’
kangaroo (labelled W).
I don't even use files (for Tame & Wild) in my script. Everything happens in RAM. (with a bunch of caching and memoization)
Code:
   t = [
        mpz(
            lower_range_limit
            + mpz(random.randint(0, upper_range_limit - lower_range_limit))
        )
        for _ in range(Nt)
    ]
    T = [mulk(ti) for ti in t]
    dt = [mpz(0) for _ in range(Nt)]
    w = [
        mpz(random.randint(0, upper_range_limit - lower_range_limit)) for _ in range(Nw)
    ]
    W = [add_points(W0, mulk(wk)) for wk in w]
    dw = [mpz(0) for _ in range(Nw)]

    Hops, Hops_old = 0, 0

    oldtime = time.time()
    starttime = oldtime

    while True:
        for k in range(Nt):
            Hops += 1
            pw = T[k].x % hop_modulo
            dt[k] = powers_of_two[pw]
            solved = check(T[k], t[k], DP_rarity, T, t, W, w)
            if solved:
                STOP_EVENT.set()
                break
            t[k] = mpz(t[k]) + dt[k]  # Use mpz here
            T[k] = add_points(POINTS_TABLE[pw], T[k])

        for k in range(Nw):
            Hops += 1
            pw = W[k].x % hop_modulo
            dw[k] = powers_of_two[pw]
            solved = check(W[k], w[k], DP_rarity, W, w, T, t)
            if solved:
                STOP_EVENT.set()
                break
            w[k] = mpz(w[k]) + dw[k]  # Use mpz here
            W[k] = add_points(POINTS_TABLE[pw], W[k])

Yeah, this is pointless for higher ranges. Unless you have RAM in the Terabytes.
I don't think most know how Kangaroo actually works.
jr. member
Activity: 82
Merit: 2
Please everyone, just stop feeding the troll. The ignore button on your left is very useful. I have used it for a long time, but it doesn't work well when others are quoting the troll and prompting more garbage.



I meant the actual ...[some bullshit]

You lower the value of this thread so much by just using it as your personal diary.
copper member
Activity: 1330
Merit: 899
🖤😏
Seriously what is there to learn from random keys? When you go random on rmd160/addresses, it's like being in a gun fight and shoot blindly with your fingers, not a real gun.

Let me give you something to work with public keys through +, - only, it's best to use key subtracter.
First select a range and do subtractions in bulk, then pick one of the offsets and perform the same subtraction on it, then pick one of the second offsets and add it to your original target, if you see the distance between your original target and second offset was added to your original target, it means the second offset is not -n, but if you see the distance was subtracted after trying to do addition, it means the 2nd offset is -n, which indicates your second attempt at bulk subtraction, subtracted a larger number than your original key.

Now since you have your ranges saved, you can conclude the size of your target.
member
Activity: 462
Merit: 24
We can either try to brute-force the pkeys, and/or we can try to reverse-engineer (also by some amount of brute-force, I guess) and recreate the process by which the pkeys were created...

I just can't quite grok what's happening here  Huh

Let me explain more...I use a trial-and-error method a problem-solving approach where you systematically try different options or solutions until you find one that works or achieves the desired result.
It involves a process of experimentation and learning from your attempts, and it's often used when you don't have a straightforward or known solution to a problem.

You start by making an attempt or trying a particular option, strategy, or input.
In this case it is a random seed.
After your attempt, you carefully observe the results and outcomes. You gather information about what worked and what didn't. You analyze the results to determine if your attempt was successful or not. If it was unsuccessful, you analyze why it didn't work. If something is nonsense, you reject it immediately and move on further. You are NOT holding back like some of the above.

Based on your analysis, you make adjustments to your approach, such as trying a different option, changing a parameter, or using a new strategy.

You repeat the process, trying the adjusted approach or a new option. You continue this cycle until you achieve the desired result or solve the problem. This cycle can last for years.
jr. member
Activity: 38
Merit: 11
I meant the actual ...[some bullshit]

You lower the value of this thread so much by just using it as your personal diary.
copper member
Activity: 1330
Merit: 899
🖤😏
They are here. You don't have to believe me. it's just that they won't write in their papers that they are directly dealing with solving the Puzzles from this topic. .   Grin
I meant the actual BIG GUNS, not some wannabes, I mean someone like "MinghuaQu" who apparently worked for NSA
And evidence suggest he might be the one generating secp256k1 curve, and I would like to ask him about his selection of N the group order, why this specific value? Why so many leading Fs?
Especially to ask him if he knows that the following keys posses  any unique properties such as some kind of backdoor etc.?
Code:
14551231950b75fc4402da1732fc9bebf
ebaaedce6af48a03bbfd25e8cd0364141
jr. member
Activity: 38
Merit: 11
They are here. You don't have to believe me. it's just that they won't write in their papers that they are directly dealing with solving the Puzzles from this topic. .   Grin

What the fuck! No they are not here! They do not care about this silly thread where lately only a bunch of newbies divide some public keys.
member
Activity: 462
Merit: 24
If someone is interested in more detail,  start here from page 33
https://riunet.upv.es/bitstream/handle/10251/185866/Andreu%20-%20Kangaroo%20configuration%20for%20criptoanalysis%20of%20public%20key%20protocols.pdf?sequence=1&isAllowed=y
 Wink


I wonder where are the BIG GUNS of mathematics, there are millions of $ for the grab, why don't they join the party?
I don't think the world knows about this puzzle, at least  they should spread the word so everyone can join, I mean come on, the most active member here is a notorious but harmless forum troll.

They are here. You don't have to believe me. it's just that they won't write in their papers that they are directly dealing with solving the Puzzles from this topic. .   Grin
jr. member
Activity: 38
Merit: 11
You are right. To be more precise, we use the van Oorschot and Weiner Method of kangaroos.

I imagined if you use Gaudry Schost method (re-place a kangaroo at a new random point as soon as you hit a distinguished point) that you could have an advantage.
Especially when using tame points in the target bitrange and wild points where one or many might not be in the target bit-range (e.g. when having many targets while experimenting with division).

You would kind of saturate the tame DPs more and more while the chance to hit a DP with the wild range increases.

But today I don't think it is of much use.
member
Activity: 462
Merit: 24
You are right. To be more precise, we use the van Oorschot and Weiner Method of kangaroos.
The van Oorshot and Weiner method of was the fastest kangaroo method for
over 15 years. In this method, there is one ’Tame’ kangaroo (labelled T), and one ’Wild’
kangaroo (labelled W).
I don't even use files (for Tame & Wild) in my script. Everything happens in RAM. (with a bunch of caching and memoization)
Code:
   t = [
        mpz(
            lower_range_limit
            + mpz(random.randint(0, upper_range_limit - lower_range_limit))
        )
        for _ in range(Nt)
    ]
    T = [mulk(ti) for ti in t]
    dt = [mpz(0) for _ in range(Nt)]
    w = [
        mpz(random.randint(0, upper_range_limit - lower_range_limit)) for _ in range(Nw)
    ]
    W = [add_points(W0, mulk(wk)) for wk in w]
    dw = [mpz(0) for _ in range(Nw)]

    Hops, Hops_old = 0, 0

    oldtime = time.time()
    starttime = oldtime

    while True:
        for k in range(Nt):
            Hops += 1
            pw = T[k].x % hop_modulo
            dt[k] = powers_of_two[pw]
            solved = check(T[k], t[k], DP_rarity, T, t, W, w)
            if solved:
                STOP_EVENT.set()
                break
            t[k] = mpz(t[k]) + dt[k]  # Use mpz here
            T[k] = add_points(POINTS_TABLE[pw], T[k])

        for k in range(Nw):
            Hops += 1
            pw = W[k].x % hop_modulo
            dw[k] = powers_of_two[pw]
            solved = check(W[k], w[k], DP_rarity, W, w, T, t)
            if solved:
                STOP_EVENT.set()
                break
            w[k] = mpz(w[k]) + dw[k]  # Use mpz here
            W[k] = add_points(POINTS_TABLE[pw], W[k])
full member
Activity: 1162
Merit: 237
Shooters Shoot...
Ok, since I just learned THE SECRET, I'm gonna continue as usual. 😉 because if you stop, you can never know what could have happened if you had continued to work harder.

So, does anyone here knows a way to always find 2 keys 1 being +n, the other 1 being -n without their last digit ever changing?
For example, if +n is 23785778 and -n is something like 678789915549,  do you know how to get 2 other keys ending with 8 and 9? And only by subtraction, not division.

Lets mind storm about this idea, and discuss how could knowing your target's last digit help in solving a key.
Sure, for the example you provided:

23785778
         -10
23785768

But none of this matters when you do not know the ending of the actual private key; nor does knowing the last digit of a private key help you in determining anything with regards to what a public key will look like when subtracting from it.

jr. member
Activity: 38
Merit: 11
Ok, since I just learned THE SECRET, I'm gonna continue as usual. 😉 because if you stop, you can never know what could have happened if you had continued to work harder.

So, does anyone here knows a way to always find 2 keys 1 being +n, the other 1 being -n without their last digit ever changing?
For example, if +n is 23785778 and -n is something like 678789915549,  do you know how to get 2 other keys ending with 8 and 9? And only by subtraction, not division.

Lets mind storm about this idea, and discuss how could knowing your target's last digit help in solving a key.

1 person claims to understand what you mean but you should write this in your personal diary instead of here.
full member
Activity: 1162
Merit: 237
Shooters Shoot...
Quote
data base

1582856285957395958375836588-1
1582856285957395958375836588-2
.....................................................
1582856285957395958375836588-10000000

one of those keys in the database will be like this:
1582856285957395958360000000

Therefore, changing G to 10000000, we would only have to scan this range:
158285628595739595836
Once you get a match you look for the rest of the key.
scanning 1582856285957395958360000000-1582856285957395958380000000 using the official G
The problem with this, is that 1582856285957395958375836588 is such a small number in the scheme of what we are dealing with.

I have done something similar to speed up search times for a different project.
Jump to: