Bitcoin puzzle transaction ~32 BTC prize to who solves it

[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

[AliBah]

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

thank you, i will try

[nomachine]

# ./keyhunt -m bsgs -f 65.txt -t 12 -k 4096 -l compress -b 65 -S -q -S -e

• Version 0.2.230519 Satoshi Quest, developed by AlbertoBSD
• Threads : 12
• K factor 4096
• Search compress only
• Quiet thread output
• Endomorphism enabled
• Mode BSGS sequential
• Opening file 65.txt
• Added 1 points from file
• Bit Range 65
• -- from : 0x10000000000000000
• -- to   : 0x20000000000000000
• N = 0x100000000000
• Bloom filter for 17179869184 elements : 58890.60 MB
• Bloom filter for 536870912 elements : 1840.33 MB
• Bloom filter for 16777216 elements : 57.51 MB
• Allocating 256.00 MB for 16777216 bP Points
• Reading bloom filter from file keyhunt_bsgs_4_17179869184.blm .... Done!
• Reading bloom filter from file keyhunt_bsgs_6_536870912.blm .... Done!
• Reading bP Table from file keyhunt_bsgs_2_16777216.tbl .... Done!
• Reading bloom filter from file keyhunt_bsgs_7_16777216.blm .... Done!
• Thread Key found privkey 1a838b13505b26867  
• Publickey 0230210c23b1a047bc9bdbb13448e67deddc108946de6de639bcc75d47c0216b1b

All points were found

It takes about 10 seconds to find after the files are loaded.
AMD Ryzen 5 3600 / 64GB RAM

*It even depends on how it is compiled for which platform - for example:

Code:

gcc -Q -march=native --help=target | grep -E '^\s+-.*(sse|march)'

  -march=                           znver2
  -mfpmath=                         sse
  -mno-sse4                         [disabled]
  -msse4.2                          [enabled]
  -msse4a                           [enabled]
  -msse5                            -mavx
  -msseregparm                      [disabled]
  -mssse3                           [enabled]



Makefile
g++ -m64 -march=native -mtune=native -msse4.2 ...etc...

[AliBah]

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

Thank you for your advise , now im in WSL and i did everything exactly from your github, but after 10 min the processing is sill in 0

ali@DESKTOP-HVET2KH:~/keyhunt$ ./keyhunt -m bsgs -f key.txt -b 130 -t 4 -s 5 -k 256 -S

• Version 0.2.230519 Satoshi Quest, developed by AlbertoBSD
• Threads : 4
• Stats output every 5 seconds
• K factor 256
• Mode BSGS sequential
• Opening file key.txt
• Added 1 points from file
• Bit Range 130
• -- from : 0x200000000000000000000000000000000
• -- to   : 0x400000000000000000000000000000000
• N = 0x100000000000
• Bloom filter for 1073741824 elements : 3680.66 MB
• Bloom filter for 33554432 elements : 115.02 MB
• Bloom filter for 1048576 elements : 3.59 MB
• Allocating 16.00 MB for 1048576 bP Points
• processing 0/1073741824 bP points : 0%

whats the problem now?

[albert0bsd]

For keyhunt issues/doubts/talk please use the next topic: Keyhunt - development requests - bug reports