Bitcoin puzzle transaction ~32 BTC prize to who solves it

[nomachine]

- clear CMOS / flash UEFI or BIOS

Someone in Russian intelligence is about to have an abrupt meeting with an open window.  

Another step is missing here. Clean bios with me_cleaner


https://github.com/corna/me_cleaner


Here is a demo of how to hack even the power-off computer via IME


https://youtu.be/9fhNokIgBMU

[AndrewWeb]

Is JLP's Kangaroo program used for puzzle 130, which is original and published on github? Yes or no ?

Some said you can use it because the range width is 125 bits. Some have said that the original version of JLP has 130 puzzles and you cannot use it for more comprehensive puzzles.

Which one is right ?


What I'm talking about is the 130 bit range width, that is, if there is more than a 125 bit gap between the start and end, does the program work?

I tried JLP's Kangaroo on puzzle 65. It found the privat key in 28 seconds ! 

[pbies]

I tried JLP's Kangaroo on puzzle 65. It found the privat key in 28 seconds ! 

Can you share the exact command?

[kalos15btc]

Hi..Digaran..Meet you after a long time..How are you..Lol

I also have this suspicion about that user and other users, a lot of newbie accounts recently came up to this topic, all of them writing non-senses

the probleme is not there, the probleme is we didint see digran reply from a long time, so you know the conclusion now xd we need mod here to check their ip and ban those users,

[AndrewWeb]

I tried JLP's Kangaroo on puzzle 65. It found the privat key in 28 seconds !  

Can you share the exact command?

Today it found it in 46 seconds. It's probably possible to do this in 1 second or much faster than 46 seconds. If somebody knows exactly how please let me know.

[brainless]

I tried JLP's Kangaroo on puzzle 65. It found the privat key in 28 seconds !  

Can you share the exact command?

Today it found it in 46 seconds. It's probably possible to do this in 1 second or much faster than 46 seconds. If somebody knows exactly how please let me know.

Better to focus unsolved keys
Try 66 with Bitcrack2

[cryptoperson678]

Can anyone please be so kind and explain to me what it means that some public keys from this puzzle (like task 130 but not task 66 for example) have been found which makes kangaroo and keyhunt with bsgs mode possible?

I thought we know public addresses as they hold the reward and the task is to find the suitable public key from a reduced key range. So what does it mean that the public key for task 130 is known and is 03633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852? I literally don't understand this.

Thank you

[AlanJohnson]

Can anyone please be so kind and explain to me what it means that some public keys from this puzzle (like task 130 but not task 66 for example) have been found which makes kangaroo and keyhunt with bsgs mode possible?

I thought we know public addresses as they hold the reward and the task is to find the suitable public key from a reduced key range. So what does it mean that the public key for task 130 is known and is 03633cbe3ec02b9401c5effa144c5b4d22f87940259634858fc7e59b1c09937852? I literally don't understand this.

Thank you

There are private keys , public keys and addresses. These are three different things.

You can use BSGS or Kangaroo modes only on public keys but not on addresses.

The known public keys in this whole challenge were intentionally released by it's creator.

If you see an outgoing transactions in given address history you can easily check it's public key and try the BSGS or Kangaroo modes.

When you have just address without any outgoing transactions your only method is to blindly guessing private keys in hope you will find one which corresponds to address.

Currently finding 66bit privkey without knows public key can be considered as hard as finding 130bit privkey with public key known.

[shelby0930]

So who has reached the closest to 130 puzzle?

[albert0bsd]

So who has reached the closest to 130 puzzle?

There is no way to know, only until you hit the key

[Feron]

which processor is faster amd ryzen or intel in python intel core i9 14900hx---intel core i9-13980hx---amd ryzen 9 7945hx, does anyone have any experience with how fast your processors with iceland secp256k1 library go
I know it depends on the code settings, but it would be nice to know such approximate information

[AndrewWeb]

There are private keys , public keys and addresses. These are three different things.

You can use BSGS or Kangaroo modes only on public keys but not on addresses.

The known public keys in this whole challenge were intentionally released by it's creator.

If you see an outgoing transactions in given address history you can easily check it's public key and try the BSGS or Kangaroo modes.

When you have just address without any outgoing transactions your only method is to blindly guessing private keys in hope you will find one which corresponds to address.

Currently finding 66bit privkey without knows public key can be considered as hard as finding 130bit privkey with public key known.

Ok, but what is it that makes having the public key so much easier to find the privat key ? What role does the public key play ? What is it about the public key, that helps the program find the privat key ? What does the public key tell the program, that makes is easier to find the privat key ? Does the letters and numbers of the public key have anything to say, or what is it ? Why is it not blindly when you have the public key ? What do you see, when you have the public key ?

[albert0bsd]

Ok, but what is it that makes having the public key so much easier to find the privat key ? What role does the public key play ? What is it about the public key, that helps the program find the privat key ? What does the public key tell the program, that makes is easier to find the privat key ? Does the letters and numbers of the public key have anything to say, or what is it ? Why is it not blindly when you have the public key ? What do you see, when you have the public key ?

We can do some basic arithmetic operations (blindly) with them.

But this is only useful when you know some information about the privatekey like the range ( smallest ranges are easy)

Please read :
https://andrea.corbellini.name/2015/06/08/elliptic-curve-cryptography-breaking-security-and-a-comparison-with-rsa/

[satashi_nokamato]

What do you see, when you have the public key ?

What do you see here?
3+2= 5, 3*2= 6, 6/3= 2, 2-3= 1, 3-2= -1.  Now we have public key of 1, 2, 3, 4, 5, 6. Add, divide, subtract and multiply, it all works the same whether you do it with public keys of the private keys, or you just do them directly with private keys.

In other words, if you have the public key of private key 89, then by having 1 up to 9 public keys saved, you could solve  the private key after subtracting G 80 times from 89, when you reach public key of 9 after 80 steps then you know the target's value. It works the same with multiplying, dividing etc.

[unclevito]

What do you see, when you have the public key ?

What do you see here?
3+2= 5, 3*2= 6, 6/3= 2, 2-3= 1, 3-2= -1.  Now we have public key of 1, 2, 3, 4, 5, 6. Add, divide, subtract and multiply, it all works the same whether you do it with public keys of the private keys, or you just do them directly with private keys.

In other words, if you have the public key of private key 89, then by having 1 up to 9 public keys saved, you could solve  the private key after subtracting G 80 times from 89, when you reach public key of 9 after 80 steps then you know the target's value. It works the same with multiplying, dividing etc.

“if you knew the magnificence of 3, 6 and 9, you would have a key to the universe.” Nikola Tesla

[nomachine]

which processor is faster amd ryzen or intel in python intel core i9 14900hx---intel core i9-13980hx---amd ryzen 9 7945hx, does anyone have any experience with how fast your processors with iceland secp256k1 library go
I know it depends on the code settings, but it would be nice to know such approximate information

This is a demonstration and test of how slow Python is. Even if it's a few million keys per second.

Random sequence:

Code:

from multiprocessing.pool import Pool
from subprocess import check_output
from tqdm import tqdm
from tqdm.contrib.concurrent import process_map
import secp256k1 as ice
import math
import random
import sys

div=16384
start=0x20000000000000000
end=0x3ffffffffffffffff
rng=0x3ffffffffffffffff-0x20000000000000000
stepout=int(rng/div)
stepin=0x200000000
right='13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so'
sys.stdout.write("\033[01;33m")
print('[+] target: '+right)

def int_to_bytes3(value, length = None): # in: int out: bytearray(b'\x80...
if not length and value == 0:
result = [0]
else:
result = []
for i in range(0, length or 1+int(math.log(value, 2**8))):
result.append(value >> (i * 8) & 0xff)
result.reverse()
return bytearray(result)

def pvk_to_addr(pvk):

    return ice.privatekey_to_address(0, True, pvk)

global c
c = 0

def go(r):
    global c
    if c % 100 == 0:
        print(f'[+] {c:,} Keys\r'.replace(',', ' '), end='')
    c = c + 1
    by = int_to_bytes3(r, 32)
    pvk = int.from_bytes(by, byteorder='big')  # Convert bytearray to integer
    ad = pvk_to_addr(pvk)
    # print('\r'+ad,end='')
    if ad == right:
        print('found!')
        print(r)
        print(hex(r))        
        HEX = "%064x" % int(r)
        wifc = ice.btc_pvk_to_wif(HEX)
        print(wifc)
        print('\a')
        with open('found.txt', 'w') as f:
            f.write(str(r))
            f.write('\n')
            f.write(hex(r))
            f.write('\n')
            f.write(wifc)
            f.write('\n')
            f.flush()
        sys.exit(0)
    return

def n(a,b):
return list(range(a,b))

s=int(rng/div)
pool = Pool(10)

u=1048576
while True:
ra=random.randint(start,end-u)
rb=ra+u
print(f'\r[+] from: {hex(ra)} to: {hex(rb)} range: {hex(u)}={u}')
#global c
c=0
pool.map(go, range(ra,rb), chunksize=32768)

pool.close()
pool.join()

Sequential sequence:

Code:

from multiprocessing.pool import Pool
from subprocess import check_output
from tqdm import tqdm
from tqdm.contrib.concurrent import process_map
import secp256k1 as ice
import math
import random
import sys

div=16384
start=0x20000000000000000
end=0x3ffffffffffffffff
rng=0x3ffffffffffffffff-0x20000000000000000
stepout=int(rng/div)
stepin=0x200000000
right='13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so'
sys.stdout.write("\033[01;33m")
print('[+] target: '+right)

def int_to_bytes3(value, length = None): # in: int out: bytearray(b'\x80...
if not length and value == 0:
result = [0]
else:
result = []
for i in range(0, length or 1+int(math.log(value, 2**8))):
result.append(value >> (i * 8) & 0xff)
result.reverse()
return bytearray(result)

def pvk_to_addr(pvk):

    return ice.privatekey_to_address(0, True, pvk)

global c
c = 0

def go(r):
    global c
    if c % 100 == 0:
        print(f'[+] {c:,} Keys\r'.replace(',', ' '), end='')
    c = c + 1
    by = int_to_bytes3(r, 32)
    pvk = int.from_bytes(by, byteorder='big')  # Convert bytearray to integer
    ad = pvk_to_addr(pvk)
    # print('\r'+ad,end='')
    if ad == right:
        print('found!')
        print(r)
        print(hex(r))        
        HEX = "%064x" % int(r)
        wifc = ice.btc_pvk_to_wif(HEX)
        print(wifc)
        print('\a')
        with open('found.txt', 'w') as f:
            f.write(str(r))
            f.write('\n')
            f.write(hex(r))
            f.write('\n')
            f.write(wifc)
            f.write('\n')
            f.flush()
        sys.exit(0)
    return

def n(a,b):
return list(range(a,b))

s=int(rng/div)
pool = Pool(10)

u = 1048576
for ra in range(start, end - u + 1, u):
    rb = ra + u
    print(f'\r[+] from: {hex(ra)} to: {hex(rb)} range: {hex(u)}={u}')
    c = 0
    pool.map(go, range(ra, rb), chunksize=32768)


pool.close()
pool.join()

You can test with this...
Very slow. About a million keys per core.
Just for the sake of comparison, I have about 40 Mkeys/s on BSGS with 12 Cores in address mode.....

[AliBah]

Ok, but what is it that makes having the public key so much easier to find the privat key ? What role does the public key play ? What is it about the public key, that helps the program find the privat key ? What does the public key tell the program, that makes is easier to find the privat key ? Does the letters and numbers of the public key have anything to say, or what is it ? Why is it not blindly when you have the public key ? What do you see, when you have the public key ?

We can do some basic arithmetic operations (blindly) with them.

But this is only useful when you know some information about the privatekey like the range ( smallest ranges are easy)

Please read :
https://andrea.corbellini.name/2015/06/08/elliptic-curve-cryptography-breaking-security-and-a-comparison-with-rsa/

for puzzle 66 i used bsgs with i7 7500U and that took 30 min to scan all the range.
is it normal or i missed something to make my scan faster?

[albert0bsd]

for puzzle 66 i used bsgs with i7 7500U and that took 30 min to scan all the range.
is it normal or i missed something to make my scan faster?

Well in the case of Keyhunt BSGS the speed is made by a combination of CPU Generation, Number of Thread and Memory available

Also some other considerations Like: Is the blooom filter File already available? , with the -S parameter you triger the load or creation of files just to be available the next time of execution

In mi case with bloom filter files available
My laptop: "11th Gen Intel(R) Core(TM) i5-1145G7 @ 2.60GHz" with 8 GB of RAM  and 8 threads the program found the test key in 5 minutes
My PC: 13th Gen Intel Core i7-13700 with 32 GB of RAM and 24 threads the program found the test key in less than 1 minute
and the same PC with the BSGS server the program found the test key in less than 20 seconds (The difference here is that the files are already loaded in memory)
For keyhunt issues/doubts/talk please use the next topic: Keyhunt - development requests - bug reports

[AliBah]

for puzzle 66 i used bsgs with i7 7500U and that took 30 min to scan all the range.
is it normal or i missed something to make my scan faster?

Well in the case of Keyhunt BSGS the speed is made by a combination of CPU Generation, Number of Thread and Memory available

Also some other considerations Like: Is the blooom filter File already available? , with the -S parameter you triger the load or creation of files just to be available the next time of execution

In mi case with bloom filter files available
My laptop: "11th Gen Intel(R) Core(TM) i5-1145G7 @ 2.60GHz" with 8 GB of RAM  and 8 threads the program found the test key in 5 minutes
My PC: 13th Gen Intel Core i7-13700 with 32 GB of RAM and 24 threads the program found the test key in less than 1 minute
and the same PC with the BSGS server the program found the test key in less than 20 seconds (The difference here is that the files are already loaded in memory)
For keyhunt issues/doubts/talk please use the next topic: Keyhunt - development requests - bug reports

Yes the the bloom filter file is ready, and my cpu is 7th Gen and Ram is 8.
for puzzle 130 my speed is (10Pkeys/s)
Im using this command :
.\keyhunt.exe -m bsgs -f keys.txt -b 130 -t 4 -s 10 -k 256 -S
should i change something or this is my power and i cant do anything more ?

[albert0bsd]

Im using this command :
.\keyhunt.exe -m bsgs -f keys.txt -b 130 -t 4 -s 10 -k 256 -S
should i change something or this is my power and i cant do anything more ?

Your problem is the .exe and windows stuff

Don use it on windows, compile it your self in a WSL environment or native linux

The lastest version is Version 0.2.230519 Satoshi Quest it provide an increment of speed X2 compared with previous version