I wrote to the OP, but I think he died according to his last post, or maybe he's a troll, I don't know.
He's not dead, he's been posting in this thread: https://bitcointalksearch.org/topic/m.64634546
Topic: lightweight database, for brute force using publickeys-32Mk =3.81MB(secp256k1) (Read 2690 times)
October 15, 2024, 02:08:06 AM
He's not dead, he's been posting in this thread: https://bitcointalksearch.org/topic/m.64634546
April 10, 2024, 01:10:36 PM
I wrote the both scripts:
create_database_arulbero.py
search_key_arulbero.py
parameters:
private key interval: from 1 to 2^32
keys stored: 2^32 / 2^7 = 2^25 (1 each 128)
bits for each key = 64
size of database: 257 MB
time to create the database: 3 min 55 s
time to find the private key of a single random public key in the db: 0.1 - 0.3 s
create_database_arulbero.py
search_key_arulbero.py
create_database_arulbero.py
search_key_arulbero.py
parameters:
private key interval: from 1 to 2^32
keys stored: 2^32 / 2^7 = 2^25 (1 each 128)
bits for each key = 64
size of database: 257 MB
time to create the database: 3 min 55 s
time to find the private key of a single random public key in the db: 0.1 - 0.3 s
create_database_arulbero.py
Code:
#!/usr/bin/env python3
# 2023/Dec/03, create_database_arulbero.py
import secp256k1 as ice
import sys
#############################################################################
# Set the number of public keys to generate
#############################################################################
start_key = 1
num_public_keys = 2**32 #(about 4 billions of keys)
bits_to_store = 64
bytes_to_store = bits_to_store//8
rate_of_key_to_generate = 2**20
rate_of_key_to_store = rate_of_key_to_generate
interval_to_generate = range(start_key, start_key + num_public_keys, rate_of_key_to_store)
interval_to_store = range(start_key,start_key + num_public_keys,rate_of_key_to_store)
binary_mode = 1
#############################################################################
if (binary_mode == 1):
f = open("public_keys_database.bin", "wb") #binary mode
########################################generation#############################################
public_keys=[]
public_keys_complete=list(map(ice.scalar_multiplication,interval_to_generate)) #generates the public keys complete
public_keys=list(map(lambda w: int(w[33-bytes_to_store:33].hex(),16),public_keys_complete)) #extract only the last bytes_to_store
########################################writing the db##########################################
for i in range(0,len(interval_to_store)):
f.write(public_keys[i].to_bytes(bytes_to_store,sys.byteorder)) #writes each key
f.close()
else:
f = open("public_keys_database.txt", "w")
#generation
public_keys=[]
for i in interval_to_generate:
P4 = ice.scalar_multiplication(i)
public_keys.append(P4[33-bytes_to_store:33].hex())
#writing the db
for i in range(0,len(interval_to_store)):
f.write(public_keys[i])
f.close()
search_key_arulbero.py
Code:
# 2023/Dec/03, arulbero_search_key.py
import secp256k1 as ice
import random
import sys
#############################################################################
# Set the number of public keys to generate
#############################################################################
start_key = 1
num_public_keys = 2**32
bits_to_store = 64
bytes_to_store = bits_to_store//8
rate_of_key_to_generate = 2**20
rate_of_key_to_store = rate_of_key_to_generate
split_database = 256 #read only a fraction of the database to speedup the finding of the string
interval_to_generate = range(start_key,start_key + num_public_keys, rate_of_key_to_store)
interval_to_store = range(start_key,start_key + num_public_keys,rate_of_key_to_store)
binary_mode = 1
#########################################################################################
#pk = 0x3243 = 12867
#P = ice.scalar_multiplication(12867)
#P="0x6800b#b8a9dffe1709ceac95d7d06646188c2cb656c09cd2e717ec67487ce1be3"
#############generates random private key and public key#################################
pk= random.randint(start_key, start_key + num_public_keys)
#pk=start_key + num_public_keys-1
P = ice.scalar_multiplication(pk)
print()
print("This is the public key: " + P[1:33].hex())
print("I need to find this private key: "+str(pk))
###################subtraction of : P - 1G, P - 2G, ..., P - rate_of_key*G################
substract_pub = ice.scalar_multiplication(1)
complete_pub= ice.point_loop_subtraction(rate_of_key_to_generate, P, substract_pub)
partial_pub=[] #need only the last bytes_to_store
P2=int(P[33-bytes_to_store:33].hex(),16).to_bytes(bytes_to_store,sys.byteorder)
partial_pub.append(P2)
for i in range(1,rate_of_key_to_store+1):
partial_pub.append(int(complete_pub[(i-1)*65+33-bytes_to_store:(i-1)*65+33].hex(),16).to_bytes(bytes_to_store,sys.byteorder))
################search in database##########################################################
num_bytes = num_public_keys*bytes_to_store//rate_of_key_to_store
size = num_bytes//split_database
s_partial_pub = set(partial_pub)
with open("public_keys_database.bin", 'r+b') as f:
#s=f.read()
for k in range(0, num_bytes, num_bytes//split_database):
f.seek(0,1)
partial_db = f.read(num_bytes//split_database)
l_partial_db = [partial_db[i:i + bytes_to_store] for i in range(0, size, bytes_to_store)]
s_partial_db = set(l_partial_db)
a = list(s_partial_db & s_partial_pub)
if (len(a)>0):
n = partial_db.find(a[0])
if n > -1:
print()
print("Private key found!!!")
private_key = (n+k)//bytes_to_store*rate_of_key_to_generate + partial_pub.index(a[0])+1
if(pk == private_key):
print("It is correct!!!")
else:
print("Collision!")
print(private_key)
P3 = ice.scalar_multiplication(private_key)
pub_key=P3[1:33].hex()
print((pub_key)[:])
f.close()
sys.exit(0)
print("string not found")
This code works very well as does the code on the OP's Github page.
April 10, 2024, 07:43:39 AM
lol tried to even find where is working codes but all seems like chit chat and no solid code are available not even on github
please provide all working codes or update it in github
please provide all working codes or update it in github
I wrote to the OP, but I think he died according to his last post, or maybe he's a troll, I don't know.
April 10, 2024, 04:17:49 AM
lol tried to even find where is working codes but all seems like chit chat and no solid code are available not even on github
please provide all working codes or update it in github
please provide all working codes or update it in github
April 09, 2024, 10:08:06 PM
what is the highest scalar (private key) you have found with this method?
What were your settings?.
Thanks
What were your settings?.
Thanks
April 08, 2024, 10:23:13 AM
Does anyone have C or C++ code to create databases faster?
December 14, 2023, 02:47:14 PM
Hi new to this topic, asking if there is a newer single core script that we can try, than the one in the first post.
December 14, 2023, 01:50:55 PM
Quote
EDIT2:
multithread (16 cores), 2^25 keys (33.5M) with distance = 16 (using ice.point_loop_subtraction): 4.8 seconds
multithread (16 cores), 2^25 consecutive keys (using ice.point_sequential_decrement): 1.06 seconds
multithread (16 cores), 2^25 keys (33.5M) with distance = 16 (using ice.point_loop_subtraction): 4.8 seconds
multithread (16 cores), 2^25 consecutive keys (using ice.point_sequential_decrement): 1.06 seconds
Wow, impressive!
My results have all been single core. I have not attempted to do anything with multi-core yet.
Then your results are better than mine.
With only 1 cpu in 4 seconds I get around 16.5 M consecutive keys, not 20 M.
That’s probably just because of the different CPUs.
December 14, 2023, 12:29:00 PM
Quote
EDIT2:
multithread (16 cores), 2^25 keys (33.5M) with distance = 16 (using ice.point_loop_subtraction): 4.8 seconds
multithread (16 cores), 2^25 consecutive keys (using ice.point_sequential_decrement): 1.06 seconds
multithread (16 cores), 2^25 keys (33.5M) with distance = 16 (using ice.point_loop_subtraction): 4.8 seconds
multithread (16 cores), 2^25 consecutive keys (using ice.point_sequential_decrement): 1.06 seconds
Wow, impressive!
My results have all been single core. I have not attempted to do anything with multi-core yet.
Then your results are better than mine.
With only 1 cpu in 4 seconds I get around 16.5 M consecutive keys, not 20 M.
December 14, 2023, 11:55:08 AM
Quote
EDIT2:
multithread (16 cores), 2^25 keys (33.5M) with distance = 16 (using ice.point_loop_subtraction): 4.8 seconds
multithread (16 cores), 2^25 consecutive keys (using ice.point_sequential_decrement): 1.06 seconds
multithread (16 cores), 2^25 keys (33.5M) with distance = 16 (using ice.point_loop_subtraction): 4.8 seconds
multithread (16 cores), 2^25 consecutive keys (using ice.point_sequential_decrement): 1.06 seconds
Wow, impressive!
My results have all been single core. I have not attempted to do anything with multi-core yet.
December 13, 2023, 09:48:55 AM
Be careful with those who use multithreading to create the db, if you do something wrong and write the bits where they don't belong, they could obtain partially correct keys, such as:
private key = 32685509
private key = 33435509
when you should really get:
target = 33185509
Test your codes first, before believing that it is a false positive when it is really a human error.
private key = 32685509
private key = 33435509
when you should really get:
target = 33185509
Test your codes first, before believing that it is a false positive when it is really a human error.
December 12, 2023, 05:16:41 PM
After more script tweaking, I can generate a 20,000,000 key database in less than 10 seconds. Search time less than 2 seconds.
36 Bit Result:
EDIT: If I use the BitArray option, as in original code, 20,000,000 keys generated into DB takes right at 4 seconds.
36 Bit Result:
Code:
This is the public key: 02b3e772216695845fa9dda419fb5daca28154d8aa59ea302f05e916635e47b9f6
Building the Binary Database
Targeting PubKey: 02b3e772216695845fa9dda419fb5daca28154d8aa59ea302f05e916635e47b9f6
Number of PubKeys: 20,000,000
Writing to file every: 20,000,000 keys
Subtract Value: 1
Space Covered: 20,000,000 / 0x1312d00
DB Generation Time: 0:00:09.604563
Scanning Randomly
Current Random Key: 0x9dd926219 Jumps Made: 291
PK Found: 42387769980
PK Found: 0x9de820a7c
Search Time: 0:00:01.815859
Total Time: 0:00:11.420422
EDIT: If I use the BitArray option, as in original code, 20,000,000 keys generated into DB takes right at 4 seconds.
Are you using multithreading? It works only for consecutive keys?
With multithreading and 16 cores, I get 2**24 (16.77M) keys in 4.35 seconds. Non consecutive keys.
EDIT:
multithread (16 cores), 2^25 keys (33.5M) with distance = 16 (using ice.point_loop_subtraction): 5.15 seconds
multithread (16 cores), 2^25 consecutive keys (using ice.point_sequential_decrement): 1.39 seconds
EDIT2:
multithread (16 cores), 2^25 keys (33.5M) with distance = 16 (using ice.point_loop_subtraction): 4.8 seconds
multithread (16 cores), 2^25 consecutive keys (using ice.point_sequential_decrement): 1.06 seconds
EDIT3:
multithread (16 cores), 2^25 keys (33.5M) with distance = 16 (using ice.point_loop_subtraction): 4.67 seconds
multithread (16 cores), 2^25 consecutive keys (using ice.point_sequential_decrement): 0.89 seconds
December 12, 2023, 01:24:24 PM
How many keys are you generating in your DB?
Are you using OPs github script versions? Or did you make any changes?
Are you using OPs github script versions? Or did you make any changes?
Code:
import secp256k1 as ice
def _point_subtraction(pubkey1_bytes, pubkey2_bytes):
return ice.point_subtraction(pubkey1_bytes, pubkey2_bytes)
def point_subtraction(pubkey1_bytes, pubkey2_bytes):
res = _point_subtraction(pubkey1_bytes, pubkey2_bytes)
return bytes(bytearray(res))
target_public_key = "026ecabd2d22fdb737be21975ce9a694e108eb94f3649c586cc7461c8abf5da71a"
target = ice.pub2upub(target_public_key)
num = 2**23
subtract= 2**10
subtract_pub= ice.scalar_multiplication(subtract)
with open('data-base.bin', 'wb') as binary_file:
current_pubkey = target
byte_accumulator = 0
bit_position = 0
for _ in range(num):
current_pubkey = point_subtraction(current_pubkey, subtract_pub)
binary_data = int(current_pubkey.hex(), 16)
bit = 0 if str(binary_data).endswith(('0', '2', '4', '6', '8')) else 1
byte_accumulator = (byte_accumulator << 1) | bit
bit_position += 1
if bit_position == 8:
binary_file.write(byte_accumulator.to_bytes(1, byteorder='big'))
byte_accumulator = 0
bit_position = 0
if bit_position > 0:
byte_accumulator <<= (8 - bit_position)
binary_file.write(byte_accumulator.to_bytes(1, byteorder='big'))
Code:
import multiprocessing
import random
import secp256k1 as ice
from bitstring import BitArray
import psutil
import mmap
def kmp_prefix(pattern):
prefix_table = [0] * len(pattern)
j = 0
for i in range(1, len(pattern)):
while j > 0 and pattern[i] != pattern[j]:
j = prefix_table[j - 1]
if pattern[i] == pattern[j]:
j += 1
prefix_table[i] = j
return prefix_table
def kmp_search(text, pattern, prefix_table):
j = 0
for i in range(len(text)):
while j > 0 and text[i] != pattern[j]:
j = prefix_table[j - 1]
if text[i] == pattern[j]:
j += 1
if j == len(pattern):
return i - j + 1
return -1
def main_task(start, end, file_map):
prefix_table = kmp_prefix(file_map)
try:
while True:
pk = random.randint(start, end)
target = ice.scalar_multiplication(pk)
num = 64 # number of times
sustract = 2**10 # amount to subtract each time
sustract_pub = ice.scalar_multiplication(sustract)
res = ice.point_loop_subtraction(num, target, sustract_pub)
binary = ''
for t in range(num):
h = (res[t * 65:t * 65 + 65]).hex()
hc = int(h[2:], 16)
if str(hc).endswith(('0', '2', '4', '6', '8')):
binary += "0"
if str(hc).endswith(('1', '3', '5', '7', '9')):
binary += "1"
my_str = binary
b = bytes(BitArray(bin=my_str))
match_position = kmp_search(file_map, b, prefix_table)
if match_position != -1:
inx = match_position * sustract
Pk = (int(pk) + int(inx)) + int(inx) * 7
print(hex(Pk))
with open("win45.txt", "a") as data_file:
data_file.write("Pk:" + " " + hex(Pk) + "\n")
except KeyboardInterrupt:
print("Пpoцecc был пpepвaн пoльзoвaтeлeм")
return
def worker(start, end, file_map):
main_task(start, end, file_map)
def split_range(start, end, num_splits):
step = (end - start) // num_splits
return [(start + i * step, start + (i + 1) * step) for i in range(num_splits)]
if __name__ == '__main__':
total_start = 2**44
total_end = 2**45
num_physical_cores = psutil.cpu_count(logical=False)
with open("data-base.bin", "r+b") as f:
file_map = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ)
range_splits = split_range(total_start, total_end, num_physical_cores)
processes = []
try:
for start, end in range_splits:
p = multiprocessing.Process(target=worker, args=(start, end, file_map))
processes.append(p)
p.start()
for p in processes:
p.join()
except KeyboardInterrupt:
print("Ocнoвнoй cкpипт был пpepвaн. Зaвepшeниe вcex пpoцeccoв.")
for p in processes:
p.terminate()
p.join()
print("Bce пpoцeccы ycпeшнo зaвepшeны.")
file_map.close()
The scripts have changed a little, but the general meaning is the same.
Perhaps I made a mistake somewhere?
December 12, 2023, 11:15:21 AM
Another modified script using a modified version of your DB script.
Incremental, BSGS, Meet in the Middle, lol.
48 Bit Range Results:
Not bad. Under 2 seconds to find the key in a 48 bit range. Less than 33 seconds combined with generating the DB.
Incremental, BSGS, Meet in the Middle, lol.
48 Bit Range Results:
Code:
This is the public key: 0291bee5cf4b14c291c650732faa166040e4c18a14731f9a930c1e87d3ec12debb
Building the Binary Database
Targeting PubKey: 0291bee5cf4b14c291c650732faa166040e4c18a14731f9a930c1e87d3ec12debb
Number of PubKeys: 60,000,000
Writing to file every: 60,000,000 keys
Subtract Value: 1
Space Covered: 60,000,000 / 0x3938700
DB Generation Time: 0:00:31.915161
Code:
Scanning Incrementally (BSGS?! Maybe Meet In The Middle?)
Current Key Position: 0x8000d693a3e2 Jumps Made: 30
PK Found: 191206974700443
PK Found: 0xade6d7ce3b9b
Search Time: 0:00:01.605224
Total Time: 0:00:01.606917
Not bad. Under 2 seconds to find the key in a 48 bit range. Less than 33 seconds combined with generating the DB.
Testing different versions of the script, I can't get a result in puzzles higher than 42. How are you doing with your modified versions of the script?
Are you using OPs github script versions? Or did you make any changes?
December 12, 2023, 10:11:38 AM
Another modified script using a modified version of your DB script.
Incremental, BSGS, Meet in the Middle, lol.
48 Bit Range Results:
Not bad. Under 2 seconds to find the key in a 48 bit range. Less than 33 seconds combined with generating the DB.
Incremental, BSGS, Meet in the Middle, lol.
48 Bit Range Results:
Code:
This is the public key: 0291bee5cf4b14c291c650732faa166040e4c18a14731f9a930c1e87d3ec12debb
Building the Binary Database
Targeting PubKey: 0291bee5cf4b14c291c650732faa166040e4c18a14731f9a930c1e87d3ec12debb
Number of PubKeys: 60,000,000
Writing to file every: 60,000,000 keys
Subtract Value: 1
Space Covered: 60,000,000 / 0x3938700
DB Generation Time: 0:00:31.915161
Code:
Scanning Incrementally (BSGS?! Maybe Meet In The Middle?)
Current Key Position: 0x8000d693a3e2 Jumps Made: 30
PK Found: 191206974700443
PK Found: 0xade6d7ce3b9b
Search Time: 0:00:01.605224
Total Time: 0:00:01.606917
Not bad. Under 2 seconds to find the key in a 48 bit range. Less than 33 seconds combined with generating the DB.
Testing different versions of the script, I can't get a result in puzzles higher than 42. How are you doing with your modified versions of the script?
December 12, 2023, 12:49:37 AM
Another modified script using a modified version of your DB script.
Incremental, BSGS, Meet in the Middle, lol.
48 Bit Range Results:
Not bad. Under 2 seconds to find the key in a 48 bit range. Less than 33 seconds combined with generating the DB.
Incremental, BSGS, Meet in the Middle, lol.
48 Bit Range Results:
Code:
This is the public key: 0291bee5cf4b14c291c650732faa166040e4c18a14731f9a930c1e87d3ec12debb
Building the Binary Database
Targeting PubKey: 0291bee5cf4b14c291c650732faa166040e4c18a14731f9a930c1e87d3ec12debb
Number of PubKeys: 60,000,000
Writing to file every: 60,000,000 keys
Subtract Value: 1
Space Covered: 60,000,000 / 0x3938700
DB Generation Time: 0:00:31.915161
Code:
Scanning Incrementally (BSGS?! Maybe Meet In The Middle?)
Current Key Position: 0x8000d693a3e2 Jumps Made: 30
PK Found: 191206974700443
PK Found: 0xade6d7ce3b9b
Search Time: 0:00:01.605224
Total Time: 0:00:01.606917
Not bad. Under 2 seconds to find the key in a 48 bit range. Less than 33 seconds combined with generating the DB.
December 11, 2023, 11:34:27 PM
I really don't understand the differences in the two scripts, when doing an incremental like I did.
Anywho, results for same 36 bit test using the other script:
Start to finish using same concept as "BSGS", incremental search versus random.
BSGS results:
The problem with your tests may possibly be that the script that I uploaded as an example uses BitArray and using bitarray is much slower than using bytes (in python) and as the database increases, python becomes even slower, but I leave it that way. because my intention is to demonstrate how the use of bits should really be, with bytes it is faster but you ignore certain bits, and that is not what I intend.Anywho, results for same 36 bit test using the other script:
Code:
This is the public key: 02b3e772216695845fa9dda419fb5daca28154d8aa59ea302f05e916635e47b9f6
Building the Binary Database
Targeting PubKey: 02b3e772216695845fa9dda419fb5daca28154d8aa59ea302f05e916635e47b9f6
Number of PubKeys: 60,000,000
Writing to file every: 60,000,000 keys
Subtract Value: 1
Space Covered: 60,000,000 / 0x3938700
DB Generation Time: 0:00:31.133606
Scanning Randomly
Current Random Key: 0x9dba52300 Jumps Made: 133
PK Found: 42387769980
PK Found: 0x9de820a7c
Search Time: 0:00:02.973942
Total Time: 0:00:34.107548
BSGS results:
Code:
creating Baby Step
DB Generation Time: 0:00:27.731941
Found the Baby Steps Table file: baby_steps__binary.bin. Will be used directly
Checking 3600000000000000 keys from 0x800000000
BSGS FOUND PrivateKey : 42387769979
Time Spent : 60.55 seconds
baby step is a simple incremental database from point a to b (although you could make jumps but that would involve changing some things to the script
Since bsgs is a mathematical algorithm, you cannot be so close or so far from your objective, that is, you could believe that with a larger database you would reach the objective faster, but this is not the case in all cases because sometimes many bits of that database are useless for the calculation, you could spend hours looking for a match, in a pk that with the other script you find in a few seconds if you do not configure it correctly,
That is why a simple search with a larger database finds you faster than when you use BSGS because you are not taking into account the mathematical point of view.
My intention was to prove that we can eliminate the hash table and use a 1 bit per key binary database, but this did not prove fast.
For speed there is no other way than to use C.
or if you feel comfortable with python, create a dll that reads the bits in the database and integrate it with ctypes.
just like iceland does in his scripts.
Surely someone is using this in C, because there are programmers and developers and once the idea is developed, the programmers execute it without problems.
December 11, 2023, 11:31:05 PM
Code:
Found the Baby Steps Table file: baby_steps__binary.bin. Will be used directly
Checking 3600000000000000 keys from 0x9de000a7c
BSGS FOUND PrivateKey : 42387769979
Time Spent : 0.13 seconds
Oh hey look, .13 seconds, but look where the checking keys from is.
Man you can bullchit some people, but not this dawg.
In your script you have:
k1 = random.randint(start, end)
so if the random key is close to the key, then you will find it faster, but if you do not know the key, you must start from at least the starting range of the bit range.
My results above clearly showed the starting key of 0x1 and the amount of keys. You purposely didn't add that in your snippet.
Not today OP, not today lol.
I don't have the need to lie, I work hard and I sleep little, I used another script, that's all, there is no need to create a witch hunt Lol, like Albertobsd, he told me I was a liar, he ignored me, i shut his mouth and surely in a while we will see keyhunt with binary DB.
Definitely, not only Keyhunt will be with binary DB, Mister
Your binary DB is real good. Thank you very mach for your binary DB !!! December 11, 2023, 10:18:14 PM
I really don't understand the differences in the two scripts, when doing an incremental like I did.
Anywho, results for same 36 bit test using the other script:
Start to finish using same concept as "BSGS", incremental search versus random.
BSGS results:
Anywho, results for same 36 bit test using the other script:
Code:
This is the public key: 02b3e772216695845fa9dda419fb5daca28154d8aa59ea302f05e916635e47b9f6
Building the Binary Database
Targeting PubKey: 02b3e772216695845fa9dda419fb5daca28154d8aa59ea302f05e916635e47b9f6
Number of PubKeys: 60,000,000
Writing to file every: 60,000,000 keys
Subtract Value: 1
Space Covered: 60,000,000 / 0x3938700
DB Generation Time: 0:00:31.133606
Scanning Randomly
Current Random Key: 0x9dba52300 Jumps Made: 133
PK Found: 42387769980
PK Found: 0x9de820a7c
Search Time: 0:00:02.973942
Total Time: 0:00:34.107548
BSGS results:
Code:
creating Baby Step
DB Generation Time: 0:00:27.731941
Found the Baby Steps Table file: baby_steps__binary.bin. Will be used directly
Checking 3600000000000000 keys from 0x800000000
BSGS FOUND PrivateKey : 42387769979
Time Spent : 60.55 seconds
Maybe you yse Celeron cpu ?))
December 11, 2023, 10:01:10 PM
I really don't understand the differences in the two scripts, when doing an incremental like I did.
Anywho, results for same 36 bit test using the other script:
Start to finish using same concept as "BSGS", incremental search versus random.
BSGS results:
Anywho, results for same 36 bit test using the other script:
Code:
This is the public key: 02b3e772216695845fa9dda419fb5daca28154d8aa59ea302f05e916635e47b9f6
Building the Binary Database
Targeting PubKey: 02b3e772216695845fa9dda419fb5daca28154d8aa59ea302f05e916635e47b9f6
Number of PubKeys: 60,000,000
Writing to file every: 60,000,000 keys
Subtract Value: 1
Space Covered: 60,000,000 / 0x3938700
DB Generation Time: 0:00:31.133606
Scanning Randomly
Current Random Key: 0x9dba52300 Jumps Made: 133
PK Found: 42387769980
PK Found: 0x9de820a7c
Search Time: 0:00:02.973942
Total Time: 0:00:34.107548
BSGS results:
Code:
creating Baby Step
DB Generation Time: 0:00:27.731941
Found the Baby Steps Table file: baby_steps__binary.bin. Will be used directly
Checking 3600000000000000 keys from 0x800000000
BSGS FOUND PrivateKey : 42387769979
Time Spent : 60.55 seconds
Jump to: