Search content
Sort by
Showing 20 of 64 results by Jolly Jocker
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
I cannot get your @jolly_jocker code to run correctly.
However, I think what you are trying to achieve is using the known WIF key part and tumble searching the remaining characters to find the WIF private key. I am able to again, use the known key part and add a randomize search for the remaining part and output this in hexadecimal format. It is not any faster than a general hexadecimal search.
I am not sure if you can generate a WIF private key with a check sum and convert/compare ; and then print the WIF key again in the same script.
I do agree that this puzzle is about testing the strength and secure-ness of bitcoin with new, creative code.
This is a basic python script and variation of VanityGen:
However, I think what you are trying to achieve is using the known WIF key part and tumble searching the remaining characters to find the WIF private key. I am able to again, use the known key part and add a randomize search for the remaining part and output this in hexadecimal format. It is not any faster than a general hexadecimal search.
I am not sure if you can generate a WIF private key with a check sum and convert/compare ; and then print the WIF key again in the same script.
I do agree that this puzzle is about testing the strength and secure-ness of bitcoin with new, creative code.
This is a basic python script and variation of VanityGen:
Code:
import secrets
import base58
import binascii
from bitcoin import privtopub, pubtoaddr
import sys
vanity = "13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so"
btc_addr = ""
while btc_addr[:len(vanity)] != vanity:
prefix = "KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qa"
alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
postfix = ''.join(secrets.choice(alphabet) for i in range(18))
first_encode = base58.b58decode(prefix + postfix)
private_key_full = binascii.hexlify(first_encode)
private_key = private_key_full[2:-8]
btc_pubkey = privtopub(private_key.decode())
btc_addr = pubtoaddr(btc_pubkey)
print(private_key.decode())
print(btc_pubkey)
print(btc_addr)
sys.exit()
import base58
import binascii
from bitcoin import privtopub, pubtoaddr
import sys
vanity = "13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so"
btc_addr = ""
while btc_addr[:len(vanity)] != vanity:
prefix = "KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qa"
alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
postfix = ''.join(secrets.choice(alphabet) for i in range(18))
first_encode = base58.b58decode(prefix + postfix)
private_key_full = binascii.hexlify(first_encode)
private_key = private_key_full[2:-8]
btc_pubkey = privtopub(private_key.decode())
btc_addr = pubtoaddr(btc_pubkey)
print(private_key.decode())
print(btc_pubkey)
print(btc_addr)
sys.exit()
I genuinely would like to know .. are any of these python scripts working any faster than known C programs like keyhunt or vanitygen etc? I mean the slowest I've ever seen to date was Brainflayer as it starts with pass->key->...... but to be honest i would be surprised if i see a fast python one getting the same speed as for example keyhunt .. plz post your speed results .. much appreciated
No, no WIF key is generated with a checksum, the correction (checksum) of the key only takes place after the 2nd conversion.. so the output is then correct.. 8 letters from the Wif-key are random, the last 10 letters from this key are range search.
Abstract:
Code:
L = []
while True:
for i in range(0x22000000000000000, 0x3ffffffffffffffff, 0x34fde3761da26c):
b = str(ice.btc_pvk_to_wif(i, True)[:-16])
x = ''.join(random.choices('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz', k=6))
key_WIF01 = b + x + '1111111111'
key_hex = ice.btc_wif_to_pvk_hex(key_WIF01)
L.append(key_hex)
if len(L) == ..............
while True:
for i in range(0x22000000000000000, 0x3ffffffffffffffff, 0x34fde3761da26c):
b = str(ice.btc_pvk_to_wif(i, True)[:-16])
x = ''.join(random.choices('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz', k=6))
key_WIF01 = b + x + '1111111111'
key_hex = ice.btc_wif_to_pvk_hex(key_WIF01)
L.append(key_hex)
if len(L) == ..............
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
Good luck
WIF->Private Key-> (only for key generation)
and
Publickey->Sha256->rmd160 (scan)
was a good encouragement... ca. 700000 keys/s nice one!
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
Quote
My CPU is core i5 @ 2.6 GHz.
Anyway if it is about innovation your code doesn't have any of them.
Your way is not the shorten way, and also is not a new way of programing.
You did not reply my question
Your way:
WIF->Private Key->Publickey->Sha256->rmd160->Address.
Why not only?
Publickey->Sha256->rmd160
Skipping the WIF to privatekey and the rmd160 to address you can save a lot of process and speed up your search up to 200% or more... Trust me I already pass for that process.
What I'm trying to write, is that you can do it better, what stop you from that slow speed? You can get a better performance from your current hardware
I see what you're getting at, it just doesn't work with (ICE)...
one option I will try is:
import hashlib
import codecs
publickey = codecs.decode(P, 'hex')
s = hashlib.new('sha256', publickey).digest()
r = hashlib.new('ripemd160', s).digest()
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
..it depends on the CPU used... I have 3GHz/core... be happy, the faster the better!
but the forum is not for saying "who can run faster"
it's about innovation, ideas to shorten the search... new ways in the programming..
but the forum is not for saying "who can run faster"
it's about innovation, ideas to shorten the search... new ways in the programming..
My CPU is core i5 @ 2.6 GHz.
Anyway if it is about innovation your code doesn't have any of them.
Your way is not the shorten way, and also is not a new way of programing.
You did not reply my question
Your way:
WIF->Private Key->Publickey->Sha256->rmd160->Address.
Why not only?
Publickey->Sha256->rmd160
Skipping the WIF to privatekey and the rmd160 to address you can save a lot of process and speed up your search up to 200% or more... Trust me I already pass for that process.
What I'm trying to write, is that you can do it better, what stop you from that slow speed? You can get a better performance from your current hardware
...brought forward the first conversion...
new speed test: [ Speed : 430391.52 Keys/s ]
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
..it depends on the CPU used... I have 3GHz/core... be happy, the faster the better!
but the forum is not for saying "who can run faster"
it's about innovation, ideas to shorten the search... new ways in the programming..
but the forum is not for saying "who can run faster"
it's about innovation, ideas to shorten the search... new ways in the programming..
My CPU is core i5 @ 2.6 GHz.
Anyway if it is about innovation your code doesn't have any of them.
Your way is not the shorten way, and also is not a new way of programing.
You did not reply my question
Your way:
WIF->Private Key->Publickey->Sha256->rmd160->Address.
Why not only?
Publickey->Sha256->rmd160
Skipping the WIF to privatekey and the rmd160 to address you can save a lot of process and speed up your search up to 200% or more... Trust me I already pass for that process.
What I'm trying to write, is that you can do it better, what stop you from that slow speed? You can get a better performance from your current hardware
you didn't understand the principle of this code.. the wifi key plays a big role.. i shortened the ramdon area to be searched... i also have other codes... that don't do these steps... but one need to search larger area...
example of how it works: x (6 letters) is the random area
key_WIF01 = 'KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qZUL' + x + '1111111111'
L.append(key_WIF01)
key_WIF02 = 'KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qZUM' + x + '1111111111'
L.append(key_WIF02)
key_WIF03 = 'KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qZUN' + x + '1111111111'
L.append(key_WIF03)
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
Speed test with 4 cores: [ Speed : 301444.62 Keys/s ]
the calculation takes place one after the other, not at the same time, which would take time...
I can get the same speed with only one core using my code
..it depends on the CPU used... I have 3GHz/core... be happy, the faster the better!
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
I have 16 available cores each capable of 4.5 GHz but I get only 1,186,383.53 Keys/s when running your code. When I check utilization in top or htop I see there are only about 4 cores utilized at 100% but even then I would have expected higher rate. Anything I'm missing ?
I'm using secp256k1 from iceland2k14. When I manually set core for instance to "15" it utilizes 15 cores, but I would have expected that the cpu_count enumeration had worked. Seems it didn't, despite that ... With 15 cores I can achieve 2003121.42 Keys/s that is 2 MKey/s. You said you're achieving 600 MKey/s, how do you do that with CPU only? Wouldn't it be better to utilize GPU for such things?
I'm using secp256k1 from iceland2k14. When I manually set core for instance to "15" it utilizes 15 cores, but I would have expected that the cpu_count enumeration had worked. Seems it didn't, despite that ... With 15 cores I can achieve 2003121.42 Keys/s that is 2 MKey/s. You said you're achieving 600 MKey/s, how do you do that with CPU only? Wouldn't it be better to utilize GPU for such things?
You are confusing something, I achieve the 600 MKeys/s with the GPU and not with this code...
for this code a CPU is working with 3 GHz/core..
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
Quote
Using python or any high level language to do heavy computations is trouble .. cracking is better coded with c/cpp/golang/java .. but thank you a lot for sharing your code
Thanks very much!
maybe this coder suits you better... have fun!
Code:
# * coding: utf-8 * Python 3.9(64-bit)
"""
author: JollyJocker
"""
import time
import random
import secp256k1 as ice
from time import sleep
from multiprocessing import Process, Queue, cpu_count, freeze_support
core = 4
group_size = 0x100000
def counter():
total=0
return total
def hunt_BTC_address(cores='all'):
available_cores = cpu_count()
if cores == 'all':
cores = available_cores
elif 0 < int(cores) <= available_cores:
cores = int(cores)
else:
cores = 1
queue = Queue()
workers = []
for r in range(cores):
p = Process(target=generate_key_address_pairs, args=(counter, queue, r))
workers.append(p)
p.start()
for worker in workers:
worker.join()
def generate_key_address_pairs(counter, queue, r):
st = time.time()
cnt = counter()
while True:
a = 0x20000000000000000
# x = random.uniform(1.01, 2.00)
x = random.triangular(1.000, 1.500, 2.001)
key_int = int(a * x)
P = ice.scalar_multiplication(key_int)
current_pvk = key_int + 1
Pv = ice.point_sequential_increment(group_size, P)
for t in range(group_size):
this_btc = ice.pubkey_to_address(0, True, Pv[t*65:t*65+65])
cnt += 1 * core
if this_btc.startswith('13zb1h'): # 13zb1hQ
l = [hex(current_pvk+t)[2:], this_btc]
queue.put(l)
results = queue.get()
print('\n\n', results, '\n')
if this_btc == '13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so':
file=open(u"BTC.Target.Info.txt","a")
file.write('\n ' + hex(current_pvk+t) + '| ' + this_btc)
file.close()
sleep(1)
exit()
if (cnt) % group_size == 0:
print(' ', hex(current_pvk+t), ' {0:.20f}'.format(x),'', str(cnt).zfill(13),' [ {1:.2f} Keys/s ] '.format(cnt, cnt/(time.time() - st)), end='\r')
P = Pv[-65:]
current_pvk += group_size
if __name__ == '__main__':
freeze_support()
print('\n |======SOURCE=======||===== MULTIPLIER =====||=====CNT=====||=======SPEED========|\n\n')
hunt_BTC_address(cores = core)
"""
author: JollyJocker
"""
import time
import random
import secp256k1 as ice
from time import sleep
from multiprocessing import Process, Queue, cpu_count, freeze_support
core = 4
group_size = 0x100000
def counter():
total=0
return total
def hunt_BTC_address(cores='all'):
available_cores = cpu_count()
if cores == 'all':
cores = available_cores
elif 0 < int(cores) <= available_cores:
cores = int(cores)
else:
cores = 1
queue = Queue()
workers = []
for r in range(cores):
p = Process(target=generate_key_address_pairs, args=(counter, queue, r))
workers.append(p)
p.start()
for worker in workers:
worker.join()
def generate_key_address_pairs(counter, queue, r):
st = time.time()
cnt = counter()
while True:
a = 0x20000000000000000
# x = random.uniform(1.01, 2.00)
x = random.triangular(1.000, 1.500, 2.001)
key_int = int(a * x)
P = ice.scalar_multiplication(key_int)
current_pvk = key_int + 1
Pv = ice.point_sequential_increment(group_size, P)
for t in range(group_size):
this_btc = ice.pubkey_to_address(0, True, Pv[t*65:t*65+65])
cnt += 1 * core
if this_btc.startswith('13zb1h'): # 13zb1hQ
l = [hex(current_pvk+t)[2:], this_btc]
queue.put(l)
results = queue.get()
print('\n\n', results, '\n')
if this_btc == '13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so':
file=open(u"BTC.Target.Info.txt","a")
file.write('\n ' + hex(current_pvk+t) + '| ' + this_btc)
file.close()
sleep(1)
exit()
if (cnt) % group_size == 0:
print(' ', hex(current_pvk+t), ' {0:.20f}'.format(x),'', str(cnt).zfill(13),' [ {1:.2f} Keys/s ] '.format(cnt, cnt/(time.time() - st)), end='\r')
P = Pv[-65:]
current_pvk += group_size
if __name__ == '__main__':
freeze_support()
print('\n |======SOURCE=======||===== MULTIPLIER =====||=====CNT=====||=======SPEED========|\n\n')
hunt_BTC_address(cores = core)
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
WIF-Key based scanner for the 66 bit range..
...happy Hunting!!
...happy Hunting!!
your code is the most inefficient way to search the puzzle.
Your way:
WIF->Private Key->Publickey->Sha256->rmd160->Address.
Why not only?
Publickey->Sha256->rmd160
In this way you avoid some steps that need a lot of calculation.
Regards!
simple answer...
the area that is random consists of only 6 letters from the Wif-key...
and the secp256k1 from (ice) is super fast...
the calculation takes place one after the other, not at the same time, which would take time...
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
WIF-Key based scanner for the 66 bit range..
...happy Hunting!!
Code:
# -*- coding: utf-8 -*-
"""
author: JollyJocker
"""
import sys
import time
import random
import secp256k1 as ice
from time import sleep
from multiprocessing import Process, freeze_support
def counter():
total=0
return total
L=[]
y = 0x090f
z = 0x100000
cores=4
def process1(number,counter,):
count = counter()
while True:
for i in range(0x22000000000000000, 0x3ffffffffffffffff, 0x34fde3761da26c):
b = str(ice.btc_pvk_to_wif(i, True)[:-16])
x = ''.join(random.choices('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz', k=6))
key_WIF01 = b + x + '1111111111'
L.append(key_WIF01)
sys.stdout.write('\r ' + '1********** LOADING! ************* ' + str(key_WIF01))
sleep(0.00001)
# --------------------------------------------------------------------------------------------------------
if len(L) == y:
line_count=0
for private_key_WIF in (L):
key_hex = ice.btc_wif_to_pvk_hex(private_key_WIF)[47:-5] + '00000'
key_int = int(key_hex, 16)
P = ice.scalar_multiplication(key_int)
current_pvk = key_int + 1
Pv = ice.point_sequential_increment(number, P)
for t in range(number):
addr = ice.pubkey_to_address(0, True, Pv[t*65:t*65+65])
line_count+=1
count += 1 * cores
if count % (z-0xbdc0) == 0:
ran = (current_pvk+t)
a = len(bin(ran)[2:])
WIF_Key = ice.btc_pvk_to_wif(ran, True)
sys.stdout.write('\r ' + addr + ' : (( ' + hex(ran) + ' )) .....' + str(WIF_Key)[33:] + ' ' + str(a).zfill(3))
if addr.startswith('13zb1h'): # 13zb1h
ran = (current_pvk+t)
a = len(bin(ran)[2:])
WIF_Key = ice.btc_pvk_to_wif(ran, True)
print('\n\n[ ' + addr + ' = ' + str(WIF_Key) + ' ' + str(a).zfill(3), ']\n')
if addr == '13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so':
print('\n\n E N D O F S E A R C H . . .\n\n')
file=open(u"BTC.Target.Info.txt","a")
file.write('\n ' + addr + ' | ' + hex(current_pvk+t))
file.close()
sleep(18000)
if line_count==y*z:
L.clear()
line_count=0
P = Pv[-65:]
current_pvk += number
if __name__ == '__main__':
freeze_support()
t = time.ctime()
print('',t)
number = z
workers = []
print('\n |13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so = KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3q*******************||BIT| \n\n')
for r in range(cores):
p = Process(target=process1, args=(number,counter,))
workers.append(p)
p.start()
for worker in workers:
worker.join()
"""
author: JollyJocker
"""
import sys
import time
import random
import secp256k1 as ice
from time import sleep
from multiprocessing import Process, freeze_support
def counter():
total=0
return total
L=[]
y = 0x090f
z = 0x100000
cores=4
def process1(number,counter,):
count = counter()
while True:
for i in range(0x22000000000000000, 0x3ffffffffffffffff, 0x34fde3761da26c):
b = str(ice.btc_pvk_to_wif(i, True)[:-16])
x = ''.join(random.choices('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz', k=6))
key_WIF01 = b + x + '1111111111'
L.append(key_WIF01)
sys.stdout.write('\r ' + '1********** LOADING! ************* ' + str(key_WIF01))
sleep(0.00001)
# --------------------------------------------------------------------------------------------------------
if len(L) == y:
line_count=0
for private_key_WIF in (L):
key_hex = ice.btc_wif_to_pvk_hex(private_key_WIF)[47:-5] + '00000'
key_int = int(key_hex, 16)
P = ice.scalar_multiplication(key_int)
current_pvk = key_int + 1
Pv = ice.point_sequential_increment(number, P)
for t in range(number):
addr = ice.pubkey_to_address(0, True, Pv[t*65:t*65+65])
line_count+=1
count += 1 * cores
if count % (z-0xbdc0) == 0:
ran = (current_pvk+t)
a = len(bin(ran)[2:])
WIF_Key = ice.btc_pvk_to_wif(ran, True)
sys.stdout.write('\r ' + addr + ' : (( ' + hex(ran) + ' )) .....' + str(WIF_Key)[33:] + ' ' + str(a).zfill(3))
if addr.startswith('13zb1h'): # 13zb1h
ran = (current_pvk+t)
a = len(bin(ran)[2:])
WIF_Key = ice.btc_pvk_to_wif(ran, True)
print('\n\n[ ' + addr + ' = ' + str(WIF_Key) + ' ' + str(a).zfill(3), ']\n')
if addr == '13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so':
print('\n\n E N D O F S E A R C H . . .\n\n')
file=open(u"BTC.Target.Info.txt","a")
file.write('\n ' + addr + ' | ' + hex(current_pvk+t))
file.close()
sleep(18000)
if line_count==y*z:
L.clear()
line_count=0
P = Pv[-65:]
current_pvk += number
if __name__ == '__main__':
freeze_support()
t = time.ctime()
print('',t)
number = z
workers = []
print('\n |13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so = KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3q*******************||BIT| \n\n')
for r in range(cores):
p = Process(target=process1, args=(number,counter,))
workers.append(p)
p.start()
for worker in workers:
worker.join()
...happy Hunting!!
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
A little WIF-Key Scanner for the 66 bit range...
Code:
# -*- coding: utf-8 -*-
"""
@author: JollyJocker
"""
import sys
import time
import random
import secp256k1 as ice
from time import sleep
from multiprocessing import Process, freeze_support
def counter():
total=0
return total
L=[]
y = 58 #541
z = 1048576
A = 1000000
cores=4
def process1(number,counter,):
count = counter()
while True:
for i in range(0x22000000000000000, 0x3ffffffffffffffff, 0xdf1290b78e9a34b):
b = str(ice.btc_pvk_to_wif(i, True)[:-11])
x = ''.join(random.choices('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz', k=1))
key_WIF01 = b + x + '1111111111'
L.append(key_WIF01)
print(' 1********************************* ' + str(b) + x + '1111111111', end='\r')
sleep(0.001)
# ----------------------------------------------------------------------------------------------------------------------------------------------------------------------
if len(L) == y:
line_count=0
for private_key_WIF in (L):
key_hex = ice.btc_wif_to_pvk_hex(private_key_WIF)[47:-5] + '00000'
key_int = int(key_hex, 16)
P = ice.scalar_multiplication(key_int)
current_pvk = key_int + 1
Pv = ice.point_sequential_increment(number, P)
for t in range(number):
addr = ice.pubkey_to_address(0, True, Pv[t*65:t*65+65])
line_count+=1
count += 1 * cores
if count % A == 0:
ran = (current_pvk+t)
a = len(bin(ran)[2:])
WIF_Key = ice.btc_pvk_to_wif(ran, True)
sys.stdout.write('\r ' + addr + ' : (( ' + hex(ran) + ' )) .....' + str(WIF_Key)[33:] + ' ' + str(a).zfill(3))
if addr.startswith('13zb1h'): # 13zb1h
ran = (current_pvk+t)
a = len(bin(ran)[2:])
WIF_Key = ice.btc_pvk_to_wif(ran, True)
print('\n\n[ ' + addr + ' = ' + str(WIF_Key) + ' ' + str(a).zfill(3), ']\n')
if addr.startswith('13zb1hQ'):
WIF_Key = ice.btc_pvk_to_wif(ran, True)
file=open(u"WIF1.Target.Info.txt","a")
file.write('\n ' + addr + ' | ' + str(WIF_Key) + ' ' + hex(ran)[2:])
file.close()
if addr.startswith('13zb1hQb'):
WIF_Key = ice.btc_pvk_to_wif(ran, True)
file=open(u"WIF2.Target.Info.txt","a")
file.write('\n ' + addr + ' | ' + str(WIF_Key) + ' ' + hex(ran)[2:])
file.close()
if addr.startswith('13zb1hQbW'):
WIF_Key = ice.btc_pvk_to_wif(ran, True)
file=open(u"WIF3.Target.Info.txt","a")
file.write('\n ' + addr + ' | ' + str(WIF_Key) + ' ' + hex(ran)[2:])
file.close()
if addr.startswith('13zb1hQbWV'):
WIF_Key = ice.btc_pvk_to_wif(ran, True)
file=open(u"WIF4.Target.Info.txt","a")
file.write('\n ' + addr + ' | ' + str(WIF_Key) + ' ' + hex(ran)[2:])
file.close()
if addr == '13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so':
print('\n\n E N D O F S E A R C H . . .\n\n')
file=open(u"BTC.Target.Info.txt","a")
file.write('\n ' + addr + ' | ' + hex(current_pvk+t))
file.close()
sleep(18000)
if line_count==y*z:
L.clear()
line_count=0
P = Pv[-65:]
current_pvk += number
if __name__ == '__main__':
freeze_support()
t = time.ctime()
print('',t)
number = z
workers = []
print('\n |13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so = KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3q*******************||BIT| \n\n')
for r in range(cores):
p = Process(target=process1, args=(number,counter,))
workers.append(p)
p.start()
for worker in workers:
worker.join()
"""
@author: JollyJocker
"""
import sys
import time
import random
import secp256k1 as ice
from time import sleep
from multiprocessing import Process, freeze_support
def counter():
total=0
return total
L=[]
y = 58 #541
z = 1048576
A = 1000000
cores=4
def process1(number,counter,):
count = counter()
while True:
for i in range(0x22000000000000000, 0x3ffffffffffffffff, 0xdf1290b78e9a34b):
b = str(ice.btc_pvk_to_wif(i, True)[:-11])
x = ''.join(random.choices('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz', k=1))
key_WIF01 = b + x + '1111111111'
L.append(key_WIF01)
print(' 1********************************* ' + str(b) + x + '1111111111', end='\r')
sleep(0.001)
# ----------------------------------------------------------------------------------------------------------------------------------------------------------------------
if len(L) == y:
line_count=0
for private_key_WIF in (L):
key_hex = ice.btc_wif_to_pvk_hex(private_key_WIF)[47:-5] + '00000'
key_int = int(key_hex, 16)
P = ice.scalar_multiplication(key_int)
current_pvk = key_int + 1
Pv = ice.point_sequential_increment(number, P)
for t in range(number):
addr = ice.pubkey_to_address(0, True, Pv[t*65:t*65+65])
line_count+=1
count += 1 * cores
if count % A == 0:
ran = (current_pvk+t)
a = len(bin(ran)[2:])
WIF_Key = ice.btc_pvk_to_wif(ran, True)
sys.stdout.write('\r ' + addr + ' : (( ' + hex(ran) + ' )) .....' + str(WIF_Key)[33:] + ' ' + str(a).zfill(3))
if addr.startswith('13zb1h'): # 13zb1h
ran = (current_pvk+t)
a = len(bin(ran)[2:])
WIF_Key = ice.btc_pvk_to_wif(ran, True)
print('\n\n[ ' + addr + ' = ' + str(WIF_Key) + ' ' + str(a).zfill(3), ']\n')
if addr.startswith('13zb1hQ'):
WIF_Key = ice.btc_pvk_to_wif(ran, True)
file=open(u"WIF1.Target.Info.txt","a")
file.write('\n ' + addr + ' | ' + str(WIF_Key) + ' ' + hex(ran)[2:])
file.close()
if addr.startswith('13zb1hQb'):
WIF_Key = ice.btc_pvk_to_wif(ran, True)
file=open(u"WIF2.Target.Info.txt","a")
file.write('\n ' + addr + ' | ' + str(WIF_Key) + ' ' + hex(ran)[2:])
file.close()
if addr.startswith('13zb1hQbW'):
WIF_Key = ice.btc_pvk_to_wif(ran, True)
file=open(u"WIF3.Target.Info.txt","a")
file.write('\n ' + addr + ' | ' + str(WIF_Key) + ' ' + hex(ran)[2:])
file.close()
if addr.startswith('13zb1hQbWV'):
WIF_Key = ice.btc_pvk_to_wif(ran, True)
file=open(u"WIF4.Target.Info.txt","a")
file.write('\n ' + addr + ' | ' + str(WIF_Key) + ' ' + hex(ran)[2:])
file.close()
if addr == '13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so':
print('\n\n E N D O F S E A R C H . . .\n\n')
file=open(u"BTC.Target.Info.txt","a")
file.write('\n ' + addr + ' | ' + hex(current_pvk+t))
file.close()
sleep(18000)
if line_count==y*z:
L.clear()
line_count=0
P = Pv[-65:]
current_pvk += number
if __name__ == '__main__':
freeze_support()
t = time.ctime()
print('',t)
number = z
workers = []
print('\n |13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so = KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3q*******************||BIT| \n\n')
for r in range(cores):
p = Process(target=process1, args=(number,counter,))
workers.append(p)
p.start()
for worker in workers:
worker.join()
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
Quote
They're relentless already. Check out NVIDIA's "Hybrid Quantum-Classical Computing Platform" .. and "cuQuantum SDK"
WOW! Thanks a lot for this information... THUMBS UP!
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
I wish we would have any quantum computing students or gurus here to discuss how many Qubits we need to break as much as 66 bits .. I'm guessing around 1000-3000 at most .. Quantum computing is amazingly useful when it comes to cryptography.
The "quantum leap" will come one day for us too, i'm confident at Nvidia, they are constantly working on the further development of their processors.. let's take a look at the developer cards... the computing power is overwhelming and will certainly continue to increase. Sure, it's not a comparison to the quantum computer... but but...
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
Quote
'....it's better after dividing the big range into smaller ones, to search within those subranges "randomly"'.
That's what I do.... that's exactly how I work..
I'm not a newbie in this matter.... But better with 600 MKeys/s than not looking for it at all... ^^Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
Quote
Yes and No ..
Yes, it does inspire to find solutions. After all, that's how humans evolved. Being Incredibly curious is what gave us the competitive advantage over all other creatures. However, it's very important to know what you're dealing with before raising hopes high. Puzzle #66 is 72 million trillion private keys.. and this means you're gonna encounter tons and tons of prefixes and only one of them is the right one. Trying to make a statistical analysis out of these is like trying to find a similar pattern across the whole universe. You are looking for only one Earth among too many Goldilock zone Earths in the Cosmos. There will be no pattern leading you to it. You just have to brute force your way through planets until you find that exact one Earth. No mathematical formula will get you there. Sure it can lead you to many Earth-like planets, but it doesn't find your exact desired Earth.
That being said, we don't even have to find a pattern in order to reach the private key, we only have to keep searching long enough until we find it, just like #64 got solved by keeping at it. In fact, it blew me away that within the exact month i thought we were never gonna solve it, someone solves it and proves me wrong. Nothing is impossible when it comes to luck and randomness. But then again, Luck and randomness do not get predicted, and that's why they're the only way to beat huge numbers. I'm so grateful they exist
yes, we are looking for a logarithm, a clue.. a system in the structure...
but the hash is so sophisticated that the patterns like 13zb1hQ... don't repeat themselves regularly... but you can still scan for system... divide the entire range into smaller areas and based on the addresses already found, a certain start/end point enclose. Of course, this should also be enjoyed with caution... ^^
"The route is the goal"...
Nonetheless, good luck!
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
Quote
And the main feature of sha256 hex pvt key that makes it secure in the first place is, once you change even one letter in (input) string, the entire hex output changes! This works both way, if you change the output (the sha256 32 byte) , the input will be hugely different. And to make things even harder, that's just one hash function, now let's continue the process of generating the address: we're doing ripemd of the sha256 of the resulting pub key to get the address .. By design, this means that whatever comes out as an address will change significantly after all that hashing we went through. This means that you can have trillions and trillions of addresses starting with 13zb1hQ.... Spread around the entire 256 bit range leaving you with the fact that none of them is the exact address you're looking for. Someone then might ask then why would we search by prefix instead of addresses?! The answer is simple: it's way faster to look for part of the address. That's the only advantage. But It doesn't say anything about determining the range.
Thanks for the detail... but the people who program themselves and work with hashes know that.. But that's not the content of the "statement"..
It only represents the difficulty of the search for the target address.. seen in this way, the difficulty is the incentive.. it inspires, it brings new ideas to the programming, new ways to solve the problem...
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
Quote
[2022-10-01.14:26:29] [Info] Address : 13zb1hQbWMzfvBudo1G28SjrDjwpcY8PA9
Private key : 319AFC93A46A34462
Compressed : yes
Public key : 03BA713FDDD4D0E475A60D3057F2E33B18A50B40827EF3728B4EE9E86C444D23C5
It's not just about the beginning of the address... There are tons of those... more about the similarities between the beginning and the end of the address..
13zb1hQbwfhhEryPWBrAioLY5tiFLrhs5o
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
Quote
my guess. it should be above this one,
00000000000000000000000000000000000000000000000319AFC9E3FF391B01
KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3q > ZsnspiitMKGTKUxzXus
KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3q > (a) something
ripemd -- 20D45A6A76AEB187FB6E669463E929D7072AB330
13zb1hQbwfhhEryPWBrAioLY5tiFLrhs5o
If you look at how many addresses start with "13zb1hQ..", that's to despair!
There are areas where there are significantly more... that makes it difficult to narrow down the range..
A good example of this was the 64-bit range, which was assumed to be in the middle of this range... unfortunately it was totally wrong ^^
Re: Bitcoin puzzle transaction ~32 BTC prize to who solves it
Quote
Will it work with Python?
If "NO" - perhaps there is an option for working with Python?
If "NO" - perhaps there is an option for working with Python?
This code is programmed in Python...
You need this for this code as import.. https://github.com/iceland2k14/secp256k1