I run customise python code on M2, work as like vanity gen, but speed is okay.
i run the 34 Bit Puzzle.
and the result is mostly satisfying, it almost hit 50-70% from target.
Searching for addresses starting with 1pwa and matching 1pwabe7ouahg2affqhhvviqovncr4rev7q with partial length 6 in the range 8589934592 to 17179869183
Searched 27902 keys in 6.61 seconds | Private key: 000000000000000000000000000000000000000000000000000000029281670d | Address (Compressed): 1PWaaEg8tHYzVZRoXia4YjkMci2Bq8s5Xd
Searched 38419 keys in 9.03 seconds | Private key: 000000000000000000000000000000000000000000000000000000037439dffc | Address (Compressed): 1PWAt7AjKjCHp4NhheRc3cR2YRwwrkbRNj
Searched 39670 keys in 9.31 seconds | Private key: 00000000000000000000000000000000000000000000000000000003c0460191 | Address (Compressed): 1PWa47ZVP1pzgySaPtn9pMvCSdxNkjCCfM
Searched 44105 keys in 10.34 seconds | Private key: 00000000000000000000000000000000000000000000000000000002ea112d43 | Address (Compressed): 1PwAGySRoG8XCn5EwHszxEG5Q4oMikeUgC
Searched 86491 keys in 20.33 seconds | Private key: 00000000000000000000000000000000000000000000000000000002b55bda6d | Address (Compressed): 1PwaXp8YZUFk5hP7YivAieG7zEnaKVhwA6
Searched 102573 keys in 24.10 seconds | Private key: 00000000000000000000000000000000000000000000000000000002db48641a | Address (Compressed): 1Pwau8X2xjKieab9Xj6C7NjpMRQtZ5HhAz
Searched 116748 keys in 27.40 seconds | Private key: 0000000000000000000000000000000000000000000000000000000316d12e4d | Address (Compressed): 1PwAPdUUayDEqaxDP3q9VJDWiAq7CHfQFJ
Searched 123543 keys in 28.99 seconds | Private key: 00000000000000000000000000000000000000000000000000000003bf357910 | Address (Compressed): 1PwAUFihpnUudcAL5iioXPbUESMvYadCFW
Searched 124873 keys in 29.28 seconds | Private key: 0000000000000000000000000000000000000000000000000000000288ac21dd | Address (Compressed): 1PWa4zB1YrjobsHM2K3PzugeXJdBUqQrdt
Searched 154049 keys in 36.10 seconds | Private key: 00000000000000000000000000000000000000000000000000000002178fd357 | Address (Compressed): 1PwAk5hxgBBp79y9NP1Xv9Ez2tYcR5aiBJ
Searched 159895 keys in 37.45 seconds | Private key: 00000000000000000000000000000000000000000000000000000002ff515a66 | Address (Compressed): 1PWAngTsfo7VfiJf5LtmWM66cvUhURg6uo
Searched 173862 keys in 40.74 seconds | Private key: 0000000000000000000000000000000000000000000000000000000374830ffc | Address (Compressed): 1Pwab9zMnNd5aeM2KZX8itAncLxUzcZNwn
the search is using secret formula to make the rate of search not far away from actual range.
the real private key is 000000000000000000000000000000000000000000000000000000034a65911d
btw anyone have configuration code to make speed faster enough with cpu ?
Bitcoin address and hash160, has no meaning when searching for a private key. You can select absolutely any search range and get the same results. |
|
|
|
For those solving puzzle 130... I have been able to reduce 026a0747b3229f32ce2f0f7bd77a7bd306f6c95d27e7c5bee22a417938d9988605 to a 110 bit search range and have the 1st 4 digits. I have worked on this daily for the past 2 months. and unfortunately do not have the hardware that would allow me to perform an optimal search in the range. I am willing to sell this info for the fair price of 1BTC. PM if interested. If you want a clue if what am offering is real...feel free to ask.
That public key is useless, why would we need it? Besides, if you have managed to reduce the size, you should continue reducing it further, unless your imaginary method doesn't actually work, but nice try asking 1 BTC for nothing. I will give you a public key and a range, if you can tell me it's first 3 characters, then I will ask you to reveal the 4 characters you claim to know to puzzle creator and receive your coin, deal? It actually is not useless. 026a0747b3229f32ce2f0f7bd77a7bd306f6c95d27e7c5bee22a417938d9988605 is the difference between the public key of puzzle 130 and the end range. Once you know it, you just need to subtract the private key of 026a...from the end range of puzzle 130 and then get the key of puzzle 130. Well, decide for yourself, why do you need to share money with someone? As for the equipment, there are no problems now. You can rent any server, even with huge RAM, or with powerful video cards. |
|
|
|
How many keys are you generating in your DB?
Are you using OPs github script versions? Or did you make any changes?
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')) 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("Процесс был прерван пользователем")
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("Основной скрипт был прерван. Завершение всех процессов.")
for p in processes:
p.terminate()
p.join()
print("Все процессы успешно завершены.")
file_map.close() The scripts have changed a little, but the general meaning is the same. Perhaps I made a mistake somewhere? |
|
|
|
Another modified script using a modified version of your DB script. Incremental, BSGS, Meet in the Middle, lol. 48 Bit Range Results: 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
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? |
|
|
|
updated 12/11/2023. #by mcdouglasx
import secp256k1 as ice
from bitstring import BitArray
print("creating Baby Step")
#create baby step
num = 2000000 # Keys number in Binary Babystep. same m in search script
Low_m= 20
lm= num // Low_m
Add = 1
Add_pub= ice.scalar_multiplication(Add)
res= ice.point_sequential_increment(lm, Add_pub)
binary = ''
for t in range (lm):
h= (res[t*65:t*65+65]).hex()
hc= int(h[2:], 16)
if str(hc).endswith(('0','2','4','6','8')):
A="0"
binary+= ''.join(str(A))
if str(hc).endswith(('1','3','5','7','9')):
A="1"
binary+= ''.join(str(A))
my_str = (BitArray(bin=binary))#bin=binary
binary_file = open('baby_steps__binary.bin', 'ab')
my_str.tofile(binary_file)
binary_file.close()
for i in range (1,Low_m):
print("stage: "+ str(i+1)+"/"+str(20))
lm_upub= ice.scalar_multiplication((lm*i))
res= ice.point_sequential_increment(lm, lm_upub)
binary = ''
for t in range (lm):
h= (res[t*65:t*65+65]).hex()
hc= int(h[2:], 16)
if str(hc).endswith(('0','2','4','6','8')):
A="0"
binary+= ''.join(str(A))
if str(hc).endswith(('1','3','5','7','9')):
A="1"
binary+= ''.join(str(A))
my_str = (BitArray(bin=binary))#bin=binary
binary_file = open('baby_steps__binary.bin', 'ab')
my_str.tofile(binary_file)
binary_file.close()
Add = 1 Could this variable have a different meaning? Or is there an analogue in the second script? The fact is that when changing the value in this variable, the search script does not find matches. |
|
|
|
This is the public key: f5c03157f4a489ed71c0df0f37799431b3f432654a9bd6efdbb79ba767b62e81
I need to find this private key: 821480591424854
Private key found!!!
Collision!
258530638003543
604085cce892dbb8bf9e70959ef178bc78fb123caaa4e9b1f3521139542da57f For example, I got a collision, how to calculate the private key? The key 821480591424854 is in the range 2^49 - 2^50 Try with these parameters: start_key = 1
num_public_keys = 2**50
bits_to_store = 64
bytes_to_store = bits_to_store//8
rate_of_key_to_generate = 2**24
Did you use bits_to_store = 64? And the other parameters? start_key = 2**49
num_public_keys = 2**50
bits_to_store = 64
bytes_to_store = bits_to_store//8
rate_of_key_to_generate = 2**20 In general, I already figured it out, the difference is 2**49). By the way, how to calculate this parameter? Calculate the golden mean. When you set it above 2**26, the search script eats up all the RAM. If you decrease it, the size of the database increases. rate_of_key_to_generate = 2**20 |
|
|
|
The first version of the script worked, the second does not find matches.
There may be an error in the code.
On my PC, 100 keys found out of 100, ....  Did you set the same parameters in both scripts? About an hour and a half ago, I copied both scripts, created a database and launched the search script. I didn't change anything in the parameters. Ah, I uploaded a version of create_database that doesn't match with that version of the search_pk script Now it should work: To perform multiple search, for linux: time for i in {1..100}; do python3 search_pk_arulbero.py; done This is the public key: f5c03157f4a489ed71c0df0f37799431b3f432654a9bd6efdbb79ba767b62e81
I need to find this private key: 821480591424854
Private key found!!!
Collision!
258530638003543
604085cce892dbb8bf9e70959ef178bc78fb123caaa4e9b1f3521139542da57f For example, I got a collision, how to calculate the private key? |
|
|
|
The first version of the script worked, the second does not find matches.
There may be an error in the code.
On my PC, 100 keys found out of 100, .... Did you set the same parameters in both scripts? About an hour and a half ago, I copied both scripts, created a database and launched the search script. I didn't change anything in the parameters. |
|
|
|
4) my script finds the key every time? So far, yes. Ok, when I ran your original script, it was less than 20% of the time the key was found. Keep working on the database size. I know you will get it down! If you can get it down to 1 bit per key like the OPs, then you're onto something. His DB is unmatched so far. Less than 20%? Did you try with the last version? Maybe the first version was not correct, I fixed some stuff. I don't understand why: 1 bit for 2^32 key is better than 64bits for 2^32/2^20 = 2^12 keys. Less size, less search time, 100% keys found. The first version of the script worked, the second does not find matches. There may be an error in the code. |
|
|
|
This script generates a database of 32 million keys (3.9 MB) in 3.5 seconds, it stores only 1 key each 64 keys, and only 8 bytes for each key #!/usr/bin/env python3
# 2023/Dec/03, arulbero_pub_key.py
import secp256k1 as ice
#############################################################################
# Set the number of public keys to generate and other parameters
#############################################################################
start_key = 1
num_public_keys = 32000000
bits_to_store = 64
bytes_to_store = bits_to_store//8
rate_of_key_to_generate = 64
rate_of_key_to_store = rate_of_key_to_generate
interval_to_generate = range(start_key,num_public_keys+1, rate_of_key_to_store)
interval_to_store = range(start_key,num_public_keys+1,rate_of_key_to_store)
binary_mode = 1
#private_keys = list(interval_to_generate)
#############################################################################
if (binary_mode == 1):
f = open("public_keys_database.bin", "wb") #binary mode
###########generation#################
public_keys=[]
for i in interval_to_generate: #generate the other keys
P = ice.scalar_multiplication(i)
public_keys.append(P[33-bytes_to_store:33].hex())
###########writing the db###############
for i in range(0,len(interval_to_store)):
h = int(public_keys[i],16)
f.write(h.to_bytes(bytes_to_store,byteorder='big'))
f.close()
else:
f = open("public_keys_database.txt", "w")
###########generation#################
public_keys=[]
for i in interval_to_generate:
P = ice.scalar_multiplication(i)
public_keys.append(P[33-bytes_to_store:33].hex())
###########writing the db###############
for i in range(0,len(interval_to_store)):
h = public_keys[i]
f.write(h)
f.close()
If you want to read the data, switch to "binary_mode = 0". With 2^32 keys (4 billions), it takes about 4 minutes to generates a db of 257 MB (1 key each 128 keys, 64 bits for key). This is quite interesting, but how can we use it, for example, to find puzzle 65? |
|
|
|
How many keys are you trying to generate?!
For me to make a 2^32 DB, it took over 5 hours. I used the low memory script and wrote to file 2^26 keys, roughly every 5 minutes. 64 (2^32 / 2^26) x 5 minutes = 320 minutes
Also, just for info, a DB with 2^32 values = 524 MB (incredible!)
Can you share your script to create the database file? I want to create a file of size 2000000000 keys to test on puzzle 65. I have it prefilled out for you: #@mcdouglasx
import secp256k1 as ice
from bitstring import BitArray
import bitcoin
print("Making Binary Data-Base")
target_public_key = "0230210c23b1a047bc9bdbb13448e67deddc108946de6de639bcc75d47c0216b1b"
target = ice.pub2upub(target_public_key)
num = 2000000000 # number of keys.
sustract = 1 #amount to subtract each time.
Low_m= 200
#2^28 / 2^ 26 = 4
#2^29 / 2^26 = 8
#2^30 / 2^26 = 16
#2^32 / 2^26 = 64
lm= num // Low_m
sustract_pub= ice.scalar_multiplication(sustract)
res= ice.point_loop_subtraction(lm, target, sustract_pub)
binary = ''
for t in range (lm):
h= (res[t*65:t*65+65]).hex()
hc= int(h[2:], 16)
if str(hc).endswith(('0','2','4','6','8')):
A="0"
binary+= ''.join(str(A))
if str(hc).endswith(('1','3','5','7','9')):
A="1"
binary+= ''.join(str(A))
my_str = bytes(BitArray(bin=binary))
binary_file = open('130Bit.bin', 'wb')
binary_file.write(my_str)
binary_file.close()
for i in range (1,Low_m):
mem= ice.to_cpub(ice.scalar_multiplication(lm).hex())
Apk= bitcoin.multiply(mem, i)
Apk_upu= ice.pub2upub(Apk)
A1= ice.point_addition(target, Apk_upu)
sustract_pub= ice.scalar_multiplication(sustract)
res= ice.point_loop_subtraction(lm, A1, sustract_pub)
binary = ''
for t in range (lm):
h= (res[t*65:t*65+65]).hex()
hc= int(h[2:], 16)
if str(hc).endswith(('0','2','4','6','8')):
A="0"
binary+= ''.join(str(A))
if str(hc).endswith(('1','3','5','7','9')):
A="1"
binary+= ''.join(str(A))
my_str = bytes(BitArray(bin=binary))
binary_file = open('65Bit.bin', 'ab')
binary_file.write(my_str)
binary_file.close()
It will write to file, every 10,000,000 keys. Let me know if it works for you. binary_file = open('130Bit.bin', 'wb') ---------------------------------------- binary_file = open('65Bit.bin', 'ab') I understand the meaning, only the names of the files need to be changed) |
|
|
|
How many keys are you trying to generate?!
For me to make a 2^32 DB, it took over 5 hours. I used the low memory script and wrote to file 2^26 keys, roughly every 5 minutes. 64 (2^32 / 2^26) x 5 minutes = 320 minutes
Also, just for info, a DB with 2^32 values = 524 MB (incredible!)
Can you share your script to create the database file? I want to create a file of size 2000000000 keys to test on puzzle 65. |
|
|
|
I have generated a DB with 2**32 Keys in it.
Can you tell me how you created the database? Apparently you have a different method for creating a database. |
|
|
|
Regarding the scan script; if I use any subtract other than one, it always gets a false positive.
I've used subtract values from 16 up to in the thousands and always get a wrong result (false positive).
If you use a large subtraction number, the result shows up way out of the upper limit range.
Can you shed any wisdom as to why?
have you possible to generate DB more than 2**28? I have generated a DB with 2**32 Keys in it. how long its take? 3 hours nothing changed? no file *.bin created... what can be wrong& @mcdouglasx I have the same. Range 45 bits, 100000000 keys. More than 12 hours of work, but still no database file... The old version of the database creation script worked, the one that first saved it to a text file. |
|
|
|
The script works, the problem lies when it makes subtraction jumps other than 1, I hope it is solved.
I checked that the script is working correctly now. But in the high ranges of 40 and above, there are no coincidences yet. In principle, up to 40 bits and simple random can cope with the same success. |
|
|
|
You already deleted the message, but I saw it in the mail. Here are other options. But I don't see any difference. num = 1024
Pk: 0x49552b0d0
Pk: 0x497fddd50
Pk: 0x499a7d5d0
Pk: 0x4a000b210
Pk: 0x4a5f30078
Pk: 0x4ae3ea090
Pk: 0x49ad6b998
num = 4096
Pk: 0x4a090c6e0
Pk: 0x49a1b7a78
Pk: 0x49fd6a730
Pk: 0x4ab095b80
Pk: 0x4a6b69d50
Pk: 0x498660e38
Pk: 0x4a4416ed8
num = 8192
Pk: 0x4a2fc3bb8
Pk: 0x499b576b8
Pk: 0x4a125b9a0
Pk: 0x4a9f3a5b0
Pk: 0x4985b0678 Although knowing the first digit and 50% of the second, this greatly facilitates further work) Thanks for the work done, I will continue testing. |
|
|
|
|
By the way, for the 40-bit range there are no collisions at all.
What database size is required for higher ranges? How can one calculate the size for a specific range?
Is it possible to parallelize work across physical processor cores?
|
|
|
|
What is that? I don't understand, are they false positives?
If so, you must increase the collision margin from 64 to 128 or higher and problem solved.
It is still random+ scalar so you can increase the margin of precision thanks to scalar multiplication.
import secp256k1 as ice
print("Making Binary Data-Base")
target_public_key = "02f6a8148a62320e149cb15c544fe8a25ab483a0095d2280d03b8a00a7feada13d"
target = ice.pub2upub(target_public_key)
num = 50000000 # number of times.
sustract= 10 #amount to subtract each time.
sustract_pub= ice.scalar_multiplication(sustract)
res= ice.point_loop_subtraction(num, target, sustract_pub)
for t in range(num+1):
h = (res[t*65:t*65+65]).hex()
if h:
hc = int(h[2:], 16)
if str(hc).endswith(('0','2','4','6','8')):
A = "0"
elif str(hc).endswith(('1','3','5','7','9')):
A = "1"
with open("dat-bin35.txt", "a") as data:
data.write(A)
else:
break
#@mcdouglasx
import secp256k1 as ice
import random
from bitstring import BitArray
print("Scanning Binary Sequence")
#range
start= 1
end= 34359738366
while True:
pk= random.randint(start, end)
target = ice.scalar_multiplication(pk)
num = 32768 # number of times.
sustract= 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')):
A="0"
binary+= ''.join(str(A))
if str(hc).endswith(('1','3','5','7','9')):
A="1"
binary+= ''.join(str(A))
my_str = binary
b = bytes(BitArray(bin=my_str))
file = open("data-base35.bin", "rb")
dat = bytes(file.read())
if b in dat:
with open (r"data-base35.bin", "rb") as file:
s = b
f = bytes(file.read())
inx = f.find(s)
Pk = (int(pk) + int(inx))+int(inx)*7
data = open("win.txt","a")
data.write("Pk:"+" "+hex(Pk)+"\n")
data.close()
pass
|
|
|
|
generating sequences 01001....
The possibility of finding an identical sequence is very low.
The traditional way limits you in space, and it works the same. If you choose 64 as the collision margin you will divide your computing power/64, but with a huge database, you would still find the key faster than using xpoint.
Tested for 35 bit range, 50 million keys. You write that the probability of false collisions is small, but I see something else. Pk: 0x4a6af41c8
Pk: 0x4ab282db0
Pk: 0x4aa361888
Pk: 0x4995442d8
Pk: 0x4ac360410
Pk: 0x4aae069e0
Pk: 0x4990d2b70
Pk: 0x4a8293880
Pk: 0x49f888a98
Pk: 0x4a561b330
Pk: 0x4941be9a8
Pk: 0x49f676c08
Pk: 0x4ac3f4a18
Pk: 0x4abf25b48
Pk: 0x49cd58448
Pk: 0x4a3d172c0
Pk: 0x4a61e9c68
Pk: 0x497caefb0
Pk: 0x49ad43d20
Pk: 0x49b2be970
Pk: 0x4a2da0e08
Pk: 0x49daf14c8
Pk: 0x4a703a6d8
Pk: 0x4ac0ab410
Pk: 0x4ad48cd78
Pk: 0x49e381bf8
Pk: 0x4a8ce39b8
Pk: 0x4a2dbdcb0
Pk: 0x4a4b02ed0
Pk: 0x496075af8
Pk: 0x49df04bc8
Pk: 0x4968e4c58
Pk: 0x49b84c1d8
Pk: 0x4a7274c00
Pk: 0x4a103c310
Pk: 0x49dbc9168
Pk: 0x4980b4718
Pk: 0x4ac09a4a8
Pk: 0x496513eb8
Pk: 0x4a7fde400
Pk: 0x49e0a30d8
Pk: 0x4a0ca7000
Pk: 0x4a8ce5788
Pk: 0x4a29828a8
Pk: 0x4aa33ffe8
Pk: 0x49a7d8070
Pk: 0x4a7761668
Pk: 0x4ab04fb48
Pk: 0x49d3b4878
Pk: 0x49f91b288
Pk: 0x495b36470
Pk: 0x4a5b73060
Pk: 0x4a73533c8
Pk: 0x4a069d880
Pk: 0x495857b48 |
|
|
|
Just info.
Think in your own way and your own point of view about this WIF range
Do we have GPU crackers for WIF Private Keys? or do we have someone that can build 1? these have more potentials for brute forcing puzzle 66 from the Random Point of view for probably the last 16 - 18 characters ranges scanned sequentially, compared to the hexadecimal private keys because of the checksum involved in the WIF Private keys... this might be it, every hexadecimal key is valid but not all WIFs are which brings us to the point where scanning might be fun to play with What is the point of this if what you see in every row is just representation of padded zeros? That is the point right there "padded zeros" as explained earlier, the hexadecimal is just from 0 to F base16 whereas the WIF is a base58 equivalent of that base 16 hexadecimal representation... so what point does this make? Well, I can have 3.625 of the hexadecimal character represented as just 1 character of the WIF... this in otherwords simply means if you are able to hit the correct first 3 WIF characters, then you probably don't have too much range to scan compared to hitting the correct first 3 characters of the hexadecimal representation of the same key... you've got a long way to go bro... So i See some potentials in this WIF bruteforcing for the puzzle 66 Key search range 66 KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3q ZVfMsBQggk69993Lj3p KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3q aCtgAeZDbST4e5pMroG We can't do anything with this information. In fact, it will be the same brute force of keys. There is no difference in what format to sort through the keys, even in binary, even in hex, even in base58. How you can explain this ? Puzzle 118 address is 1PJZPzvGX19a7twf5HyD2VvNiPdHLzm9F6this is the 0000000000000000000000000000000000af0f4d11574f5deee49961d9609ac6 address 1PEuXxTXfc3qJM4H7EKRbSb8TSPFtds9A5Public key 02bc5f15678ceb70dad97a6b695b9e0df7c405142586931801c2df664563042fe7 I just random search WIF range on that, and i have lock the range area by Hex padded. yeah it's suck it's like 0.0000001% chance hit the 4 same HEX value / WIF. [EDIT 10:41 Indonesia Time] Target 1PJZPzvGX19a7twf5HyD2VvNiPdHLzm9F6 # 118 this, i found 3 word same address range, from range padded hex. 031e841aa39d5d92ae850400a2d8be24a245d53e9ba29dc86b86696e65290c32d7 = 1PJgNwNbpr1KRxdmPxPXMCWqdBT1bwgDEe The public address has no binding either to the public key or to the private key. You need to carefully study the process of obtaining bitcoin addresses. |
|
|
|
|
Show Posts
