lordfrs
Jr. Member
Offline
Activity: 57
Merit: 1
|
 |
August 12, 2023, 07:04:17 AM |
|
Puzzle #66 is not about pattern dudes
is all about logic and hardware power
If you have a bunch of 4090's out there and a optimized software to search it so you are in the game, If no you'll realize that is not simple as you think.
there's no pattern.
I rented 4090s for 2 months. how do you think I lost the $23k? what I need to know is what you meant by "optimized software" Because I want to know your definition of searching the range wisely and not considering the speed and time and resources need and amount of investment or capital needed to complete the scan. and I need to know your calculation for the keys/s and I know the best speed you can get on the 4090s is 5billion keys/s and if you use the keyhunt cuda you can use all the device in a machine to scan the range. Please explain... I am still waiting for an explanation for your defined term "optimized software" The fastest I can achieve on a 14 * 4090 is below GPU IDS : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 GPU GRIDSIZE : 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512 SSE : YES RKEY : 0 Mkeys MAX FOUND : 65536 BTC ADDRESS : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so OUTPUT FILE : Found.txt Start Time : Sat Aug 12 03:37:01 2023 Global start : 2CA60FFFFFFFFFFFF (66 bit) Global end : 40000000000000000 (67 bit) Global range : 1359F000000000001 (65 bit) GPU : GPU #6 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #2 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #7 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #3 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #13 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #0 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #5 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #9 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #4 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #1 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #8 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #12 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #10 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #11 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) [00:02:26] [CPU+GPU: 71119.07 Mk/s] [GPU: 71119.07 Mk/s] [C: 0.000047 %] [R: 0] [T: 10,526,964,842,496 (44 bit)] [F: 0] So I want to understand your magic for the defined term optimized software where did you rent the cards ?
|
If you want to buy me a coffee
Btc = 3246y1G9YjnQQNRUrVMnaeCFrymZRgJAP7
Doge = DGNd8UTi8jVTVZ2twhKydyqicynbsERMjs
|
|
|
bestie1549
Jr. Member
Offline
Activity: 75
Merit: 5
|
 |
August 12, 2023, 07:35:01 AM |
|
Puzzle #66 is not about pattern dudes
is all about logic and hardware power
If you have a bunch of 4090's out there and a optimized software to search it so you are in the game, If no you'll realize that is not simple as you think.
there's no pattern.
I rented 4090s for 2 months. how do you think I lost the $23k? what I need to know is what you meant by "optimized software" Because I want to know your definition of searching the range wisely and not considering the speed and time and resources need and amount of investment or capital needed to complete the scan. and I need to know your calculation for the keys/s and I know the best speed you can get on the 4090s is 5billion keys/s and if you use the keyhunt cuda you can use all the device in a machine to scan the range. Please explain... I am still waiting for an explanation for your defined term "optimized software" The fastest I can achieve on a 14 * 4090 is below GPU IDS : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 GPU GRIDSIZE : 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512 SSE : YES RKEY : 0 Mkeys MAX FOUND : 65536 BTC ADDRESS : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so OUTPUT FILE : Found.txt Start Time : Sat Aug 12 03:37:01 2023 Global start : 2CA60FFFFFFFFFFFF (66 bit) Global end : 40000000000000000 (67 bit) Global range : 1359F000000000001 (65 bit) GPU : GPU #6 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #2 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #7 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #3 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #13 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #0 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #5 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #9 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #4 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #1 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #8 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #12 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #10 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #11 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) [00:02:26] [CPU+GPU: 71119.07 Mk/s] [GPU: 71119.07 Mk/s] [C: 0.000047 %] [R: 0] [T: 10,526,964,842,496 (44 bit)] [F: 0] So I want to understand your magic for the defined term optimized software where did you rent the cards ? vast.ai
|
|
|
|
bestie1549
Jr. Member
Offline
Activity: 75
Merit: 5
|
 |
August 12, 2023, 10:18:56 AM |
|
Puzzle #66 is not about pattern dudes
is all about logic and hardware power
If you have a bunch of 4090's out there and a optimized software to search it so you are in the game, If no you'll realize that is not simple as you think.
there's no pattern.
I rented 4090s for 2 months. how do you think I lost the $23k? what I need to know is what you meant by "optimized software" Because I want to know your definition of searching the range wisely and not considering the speed and time and resources need and amount of investment or capital needed to complete the scan. and I need to know your calculation for the keys/s and I know the best speed you can get on the 4090s is 5billion keys/s and if you use the keyhunt cuda you can use all the device in a machine to scan the range. Please explain... I am still waiting for an explanation for your defined term "optimized software" The fastest I can achieve on a 14 * 4090 is below GPU IDS : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 GPU GRIDSIZE : 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512 SSE : YES RKEY : 0 Mkeys MAX FOUND : 65536 BTC ADDRESS : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so OUTPUT FILE : Found.txt Start Time : Sat Aug 12 03:37:01 2023 Global start : 2CA60FFFFFFFFFFFF (66 bit) Global end : 40000000000000000 (67 bit) Global range : 1359F000000000001 (65 bit) GPU : GPU #6 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #2 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #7 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #3 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #13 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #0 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #5 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #9 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #4 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #1 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #8 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #12 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #10 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #11 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) [00:02:26] [CPU+GPU: 71119.07 Mk/s] [GPU: 71119.07 Mk/s] [C: 0.000047 %] [R: 0] [T: 10,526,964,842,496 (44 bit)] [F: 0] So I want to understand your magic for the defined term optimized software where did you rent the cards ? vast.ai I achieved the same result with 12 devices in a single machine " KeyHunt-Cuda v1.07 COMP MODE : COMPRESSED COIN TYPE : BITCOIN SEARCH MODE : Single Address DEVICE : GPU CPU THREAD : 0 GPU IDS : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 GPU GRIDSIZE : 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512 SSE : YES RKEY : 0 Mkeys MAX FOUND : 65536 BTC ADDRESS : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so OUTPUT FILE : Found.txt Start Time : Sat Aug 12 10:07:11 2023 Global start : 2E601111111111111 (66 bit) Global end : 40000000000000000 (67 bit) Global range : 119FEEEEEEEEEEEEF (65 bit) GPU : GPU #4 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512) GPU : GPU #6 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512) GPU : GPU #9 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512) GPU : GPU #2 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512) GPU : GPU #7 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512) GPU : GPU #1 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512) GPU : GPU #0 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512) GPU : GPU #3 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512) GPU : GPU #8 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512) GPU : GPU #10 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512) GPU : GPU #11 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512) GPU : GPU #5 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512) [00:04:38] [CPU+GPU: 71921.28 Mk/s] [GPU: 71921.28 Mk/s] [C: 0.000094 %] [R: 0] [T: 19,155,554,140,160 (45 bit)] [F: 0] " But the time is still not adding up... if you can do the calculations and also note the costs of renting the machines. you would end up resorting to random generation of at least the 1st 1 to 3 characters because scanning all that range from 20 to wherever you think the key would be doesn't cost pennies but the 1s and 0s scanning can assure you you scanned all the ranges covering that specifically defined bit ranges without worries and you can just keep doing it over and over again until you find the bit configuration for the specified puzzle you're searching for
|
|
|
|
tptkimikaze
Newbie
Offline
Activity: 25
Merit: 2
|
 |
August 12, 2023, 11:32:21 AM |
|
Puzzle #66 is not about pattern dudes
is all about logic and hardware power
If you have a bunch of 4090's out there and a optimized software to search it so you are in the game, If no you'll realize that is not simple as you think.
there's no pattern.
I rented 4090s for 2 months. how do you think I lost the $23k? what I need to know is what you meant by "optimized software" Because I want to know your definition of searching the range wisely and not considering the speed and time and resources need and amount of investment or capital needed to complete the scan. and I need to know your calculation for the keys/s and I know the best speed you can get on the 4090s is 5billion keys/s and if you use the keyhunt cuda you can use all the device in a machine to scan the range. Please explain... I am still waiting for an explanation for your defined term "optimized software" The fastest I can achieve on a 14 * 4090 is below GPU IDS : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 GPU GRIDSIZE : 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512, 2048x512 SSE : YES RKEY : 0 Mkeys MAX FOUND : 65536 BTC ADDRESS : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so OUTPUT FILE : Found.txt Start Time : Sat Aug 12 03:37:01 2023 Global start : 2CA60FFFFFFFFFFFF (66 bit) Global end : 40000000000000000 (67 bit) Global range : 1359F000000000001 (65 bit) GPU : GPU #6 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #2 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #7 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #3 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #13 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #0 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #5 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #9 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #4 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #1 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #8 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #12 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #10 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) GPU : GPU #11 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(2048x512) [00:02:26] [CPU+GPU: 71119.07 Mk/s] [GPU: 71119.07 Mk/s] [C: 0.000047 %] [R: 0] [T: 10,526,964,842,496 (44 bit)] [F: 0] So I want to understand your magic for the defined term optimized software where did you rent the cards ? vast.ai I achieved the same result with 12 devices in a single machine " KeyHunt-Cuda v1.07 COMP MODE : COMPRESSED COIN TYPE : BITCOIN SEARCH MODE : Single Address DEVICE : GPU CPU THREAD : 0 GPU IDS : 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 GPU GRIDSIZE : 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512, 16384x512 SSE : YES RKEY : 0 Mkeys MAX FOUND : 65536 BTC ADDRESS : 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so OUTPUT FILE : Found.txt Start Time : Sat Aug 12 10:07:11 2023 Global start : 2E601111111111111 (66 bit) Global end : 40000000000000000 (67 bit) Global range : 119FEEEEEEEEEEEEF (65 bit) GPU : GPU #4 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512) GPU : GPU #6 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512) GPU : GPU #9 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512) GPU : GPU #2 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512) GPU : GPU #7 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512) GPU : GPU #1 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512) GPU : GPU #0 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512) GPU : GPU #3 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512) GPU : GPU #8 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512) GPU : GPU #10 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512) GPU : GPU #11 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512) GPU : GPU #5 NVIDIA GeForce RTX 4090 (128x0 cores) Grid(16384x512) [00:04:38] [CPU+GPU: 71921.28 Mk/s] [GPU: 71921.28 Mk/s] [C: 0.000094 %] [R: 0] [T: 19,155,554,140,160 (45 bit)] [F: 0] " But the time is still not adding up... if you can do the calculations and also note the costs of renting the machines. you would end up resorting to random generation of at least the 1st 1 to 3 characters because scanning all that range from 20 to wherever you think the key would be doesn't cost pennies but the 1s and 0s scanning can assure you you scanned all the ranges covering that specifically defined bit ranges without worries and you can just keep doing it over and over again until you find the bit configuration for the specified puzzle you're searching for I guess that's what James idea trying to tell. Just start to scan from 50-50, 51-49, 52-48 and so on and it will save a lot of time and unnecessary scan from the beginning of useless less likely range.
|
|
|
|
tptkimikaze
Newbie
Offline
Activity: 25
Merit: 2
|
 |
August 12, 2023, 11:48:04 AM Last edit: August 12, 2023, 12:05:04 PM by tptkimikaze |
|
from itertools import combinations import sys
def place_ones(size, count): for positions in combinations(range(size), count): p = [0] * size
for i in positions: p[i] = 1
yield p
f = open("demo.txt", "a") print(list(place_ones(60, 30)), file=f)
f.close()) Simple combination for bits. Maybe someone can add some coding to convert 0s and 1s to hexadecimal, print in bat file, put it in bitcrack and run it. Step 1 Let's say start scanning from 60 bits. 0s - 30 - 1s -30 = 50% 0s - 31 - 1s 29 = 51.67% 0s - 32 - 1s 28 = 53.4% 0s - 33 - 1s 27 = 55% 0s - 34 - 1s 26 = 56.67% 0s - 35 - 1s 25 = 58.34% 0s - 36 - 1s 24 = 60% Then reverse 0s and 1s position in max 60% which is most likely where the key are. Step 2 Convert Binary to Hexa Step 3 Print in .CMD for continuous execution in Bitcrack. Step 4 Run until it hits the key or else increase the percentages if it doesn't. Make sense or any argument? I am doing it already but doesn't have huge power like you guys. Maybe share it here and someone can crack it very soon here.
|
|
|
|
vneos
Newbie
Offline
Activity: 27
Merit: 9
|
 |
August 12, 2023, 12:07:47 PM |
|
Just start to scan from 50-50, 51-49, 52-48 and so on and it will save a lot of time and unnecessary scan from the beginning of useless less likely range. The key is how to write code to run the specified 0 and 1 digits on the gpu. Also, I think that there is a high probability that the hexadecimal number of the private key for puzzle 66 starts with 3. That is, the highest 2 bits of the binary private key we can both set to 1, and we can specify the number of bits for 0s and 1s, and we can even search for less than just 2^63 private keys if we use bits with a probability of more than 40%! Of course, this is an extreme case, using too many coincidences. If we continue to exclude combinations with negligible probability, such as 10 consecutive 0's or 1's, then the search space will be further reduced.
|
|
|
|
tptkimikaze
Newbie
Offline
Activity: 25
Merit: 2
|
 |
August 12, 2023, 12:10:52 PM |
|
Just start to scan from 50-50, 51-49, 52-48 and so on and it will save a lot of time and unnecessary scan from the beginning of useless less likely range. The key is how to write code to run the specified 0 and 1 digits on the gpu. Also, I think that there is a high probability that the hexadecimal number of the private key for puzzle 66 starts with 3. That is, the highest 2 bits of the binary private key we can both set to 1, and we can specify the number of bits for 0s and 1s, and we can even search for less than just 2^63 private keys if we use bits with a probability of more than 40%! Of course, this is an extreme case, using too many coincidences. If we continue to exclude combinations with negligible probability, such as 10 consecutive 0's or 1's, then the search space will be further reduced. You don't write it in GPU. Just write it in Python, print it in CMD and automate it in Bitcrack. Then the whole thing transfered to GPU already with Bitcrack.
|
|
|
|
tptkimikaze
Newbie
Offline
Activity: 25
Merit: 2
|
 |
August 12, 2023, 12:19:58 PM |
|
Just start to scan from 50-50, 51-49, 52-48 and so on and it will save a lot of time and unnecessary scan from the beginning of useless less likely range. The key is how to write code to run the specified 0 and 1 digits on the gpu. Also, I think that there is a high probability that the hexadecimal number of the private key for puzzle 66 starts with 3. That is, the highest 2 bits of the binary private key we can both set to 1, and we can specify the number of bits for 0s and 1s, and we can even search for less than just 2^63 private keys if we use bits with a probability of more than 40%! Of course, this is an extreme case, using too many coincidences. If we continue to exclude combinations with negligible probability, such as 10 consecutive 0's or 1's, then the search space will be further reduced. Step 1 Let's say start scanning from 60 bits. Coding in Python. 0s - 30 - 1s -30 = 50% 0s - 31 - 1s 29 = 51.67% 0s - 32 - 1s 28 = 53.4% 0s - 33 - 1s 27 = 55% 0s - 34 - 1s 26 = 56.67% 0s - 35 - 1s 25 = 58.34% 0s - 36 - 1s 24 = 60% Then reverse 0s and 1s position in max 60% which is most likely where the key are. Step 2 Convert Binary to Hexa Step 3 Print in .CMD for continuous execution in Bitcrack. Step 4 Run until it hits the key or else increase the percentages if it doesn't. Make sense?
|
|
|
|
vneos
Newbie
Offline
Activity: 27
Merit: 9
|
 |
August 12, 2023, 12:21:45 PM Last edit: August 12, 2023, 08:50:41 PM by Mr. Big |
|
Using this code below to find the private key for puzzle 30, which specifies that the first 4 bits are 1. Running it with 12 processes on my i7-12700kf, the private key was found in about 1 minute and 28 seconds. 000000000000000000000000000000000000000000000000000000003d94cd64 hash160: d39c4704664e1deb76c9331e637564c257d68a08 Target hash found! Time: 0 h, 1 m, 28 s import hashlib import ecdsa import random import time from multiprocessing import Process, Event
target_hash = "d39c4704664e1deb76c9331e637564c257d68a08"
def binary_to_hex(bin_string): return hex(int(bin_string, 2))[2:].zfill(len(bin_string) // 4)
def worker(num_zeros, num_ones, stop_event):
while True: if stop_event.is_set(): break
bits = ['0'] * num_zeros + ['1'] * (num_ones - 4) random.shuffle(bits)
bits.insert(0, '1') bits.insert(1, '1') bits.insert(2, '1') bits.insert(3, '1') private_key_bin = ''.join(bits)
private_key_bin = '0' * (256 - 30) + private_key_bin
private_key_hex = binary_to_hex(private_key_bin)
sk = ecdsa.SigningKey.from_string(bytes.fromhex(private_key_hex), curve=ecdsa.SECP256k1) public_key = sk.get_verifying_key().to_string().hex()
compressed_public_key = '02' + public_key[0:64] if int(public_key[-2:], 16) % 2 == 0 else '03' + public_key[0:64] compressed_public_key_bytes = bytes.fromhex(compressed_public_key)
ripemd160_hash = hashlib.new('ripemd160') ripemd160_hash.update(hashlib.sha256(compressed_public_key_bytes).digest()) hashed_compressed_public_key = ripemd160_hash.digest().hex()
if hashed_compressed_public_key == target_hash: print(private_key_hex) print("hash160:", hashed_compressed_public_key) print("Target hash found!")
stop_event.set() break
def main(): num_processes = 12 processes = [] stop_event = Event()
start_time = time.time()
for _ in range(num_processes): process = Process(target=worker, args=(14, 16, stop_event)) processes.append(process)
for process in processes: process.start()
for process in processes: process.join()
if stop_event.is_set(): for process in processes: process.terminate()
end_time = time.time() execution_time_seconds = end_time - start_time
hours = int(execution_time_seconds // 3600) minutes = int((execution_time_seconds % 3600) // 60) seconds = int(execution_time_seconds % 60)
print(f"Time: {hours} h, {minutes} m, {seconds} s")
if __name__ == '__main__': main()
Using this code below to find the private key for puzzle 30, which specifies that the first 4 bits are 1. Running it with 12 processes on my i7-12700kf, the private key was found in about 1 minute and 28 seconds. Of course, it's just trying my luck. But who isn't trying their luck for hunters who don't have a lot of gpu? I believe that any other tool used by each of us hunters with only a small amount of resources is using random mode to search for private keys, so why not rule out some combinations with lower probability to try some private keys with higher probability?
|
|
|
|
digaran
Copper Member
Hero Member
   
Offline
Activity: 1330
Merit: 900
🖤😏
|
 |
August 12, 2023, 01:08:44 PM |
|
Using this code below to find the private key for puzzle 30, which specifies that the first 4 bits are 1. Running it with 12 processes on my i7-12700kf, the private key was found in about 1 minute and 28 seconds. Of course, it's just trying my luck. But who isn't trying their luck for hunters who don't have a lot of gpu? I believe that any other tool used by each of us hunters with only a small amount of resources is using random mode to search for private keys, so why not rule out some combinations with lower probability to try some private keys with higher probability? More importantly, why do you guys wasting your time on keys with no exposed public key? While you depend on luck trying to find #66, you could use your skills to find a way to reduce the range of public keys.😉
|
🖤😏
|
|
|
tptkimikaze
Newbie
Offline
Activity: 25
Merit: 2
|
 |
August 12, 2023, 02:27:52 PM |
|
Using this code below to find the private key for puzzle 30, which specifies that the first 4 bits are 1. Running it with 12 processes on my i7-12700kf, the private key was found in about 1 minute and 28 seconds. 000000000000000000000000000000000000000000000000000000003d94cd64 hash160: d39c4704664e1deb76c9331e637564c257d68a08 Target hash found! Time: 0 h, 1 m, 28 s import hashlib import ecdsa import random import time from multiprocessing import Process, Event
target_hash = "d39c4704664e1deb76c9331e637564c257d68a08"
def binary_to_hex(bin_string): return hex(int(bin_string, 2))[2:].zfill(len(bin_string) // 4)
def worker(num_zeros, num_ones, stop_event):
while True: if stop_event.is_set(): break
bits = ['0'] * num_zeros + ['1'] * (num_ones - 4) random.shuffle(bits)
bits.insert(0, '1') bits.insert(1, '1') bits.insert(2, '1') bits.insert(3, '1') private_key_bin = ''.join(bits)
private_key_bin = '0' * (256 - 30) + private_key_bin
private_key_hex = binary_to_hex(private_key_bin)
sk = ecdsa.SigningKey.from_string(bytes.fromhex(private_key_hex), curve=ecdsa.SECP256k1) public_key = sk.get_verifying_key().to_string().hex()
compressed_public_key = '02' + public_key[0:64] if int(public_key[-2:], 16) % 2 == 0 else '03' + public_key[0:64] compressed_public_key_bytes = bytes.fromhex(compressed_public_key)
ripemd160_hash = hashlib.new('ripemd160') ripemd160_hash.update(hashlib.sha256(compressed_public_key_bytes).digest()) hashed_compressed_public_key = ripemd160_hash.digest().hex()
if hashed_compressed_public_key == target_hash: print(private_key_hex) print("hash160:", hashed_compressed_public_key) print("Target hash found!")
stop_event.set() break
def main(): num_processes = 12 processes = [] stop_event = Event()
start_time = time.time()
for _ in range(num_processes): process = Process(target=worker, args=(14, 16, stop_event)) processes.append(process)
for process in processes: process.start()
for process in processes: process.join()
if stop_event.is_set(): for process in processes: process.terminate()
end_time = time.time() execution_time_seconds = end_time - start_time
hours = int(execution_time_seconds // 3600) minutes = int((execution_time_seconds % 3600) // 60) seconds = int(execution_time_seconds % 60)
print(f"Time: {hours} h, {minutes} m, {seconds} s")
if __name__ == '__main__': main()
I just try it and I can find it in 30 sec on #30. For #66 it's still difficult to scan without GPU.
|
|
|
|
james5000
Jr. Member
Offline
Activity: 69
Merit: 2
|
 |
August 12, 2023, 04:09:34 PM |
|
Folks, the focus shouldn't be on how many 1s or 0s bits keys should have; it should be on how to scan faster or how we can skip less probable keys.
|
|
|
|
james5000
Jr. Member
Offline
Activity: 69
Merit: 2
|
 |
August 12, 2023, 04:44:03 PM |
|
Using this code below to find the private key for puzzle 30, which specifies that the first 4 bits are 1. Running it with 12 processes on my i7-12700kf, the private key was found in about 1 minute and 28 seconds. 000000000000000000000000000000000000000000000000000000003d94cd64 hash160: d39c4704664e1deb76c9331e637564c257d68a08 Target hash found! Time: 0 h, 1 m, 28 s import hashlib import ecdsa import random import time from multiprocessing import Process, Event
target_hash = "d39c4704664e1deb76c9331e637564c257d68a08"
def binary_to_hex(bin_string): return hex(int(bin_string, 2))[2:].zfill(len(bin_string) // 4)
def worker(num_zeros, num_ones, stop_event):
while True: if stop_event.is_set(): break
bits = ['0'] * num_zeros + ['1'] * (num_ones - 4) random.shuffle(bits)
bits.insert(0, '1') bits.insert(1, '1') bits.insert(2, '1') bits.insert(3, '1') private_key_bin = ''.join(bits)
private_key_bin = '0' * (256 - 30) + private_key_bin
private_key_hex = binary_to_hex(private_key_bin)
sk = ecdsa.SigningKey.from_string(bytes.fromhex(private_key_hex), curve=ecdsa.SECP256k1) public_key = sk.get_verifying_key().to_string().hex()
compressed_public_key = '02' + public_key[0:64] if int(public_key[-2:], 16) % 2 == 0 else '03' + public_key[0:64] compressed_public_key_bytes = bytes.fromhex(compressed_public_key)
ripemd160_hash = hashlib.new('ripemd160') ripemd160_hash.update(hashlib.sha256(compressed_public_key_bytes).digest()) hashed_compressed_public_key = ripemd160_hash.digest().hex()
if hashed_compressed_public_key == target_hash: print(private_key_hex) print("hash160:", hashed_compressed_public_key) print("Target hash found!")
stop_event.set() break
def main(): num_processes = 12 processes = [] stop_event = Event()
start_time = time.time()
for _ in range(num_processes): process = Process(target=worker, args=(14, 16, stop_event)) processes.append(process)
for process in processes: process.start()
for process in processes: process.join()
if stop_event.is_set(): for process in processes: process.terminate()
end_time = time.time() execution_time_seconds = end_time - start_time
hours = int(execution_time_seconds // 3600) minutes = int((execution_time_seconds % 3600) // 60) seconds = int(execution_time_seconds % 60)
print(f"Time: {hours} h, {minutes} m, {seconds} s")
if __name__ == '__main__': main()
I just try it and I can find it in 30 sec on #30. For #66 it's still difficult to scan without GPU. Try also for #35, #40, or #45.
|
|
|
|
bestie1549
Jr. Member
Offline
Activity: 75
Merit: 5
|
 |
August 12, 2023, 05:33:50 PM |
|
Folks, the focus shouldn't be on how many 1s or 0s bits keys should have; it should be on how to scan faster or how we can skip less probable keys.
That's the point right there folk. Before BitCrack was developed do you think people were scanning at the speed we're scanning right now? Before BitCrack was developed people were only scanning in thousands and million keys/s and even when BitCrack was developed the GPUs available at that time were not as powerful as the ones we have right now. I understand that some projects needs to be funded but the point is that some people here don't see potentials in the logic but I believe these people are also willing to give us better means to solve the puzzles without the exposed public keys because there will be a time when all the public keys stages would have been successfully conquered and we would all be forced to start scanning the stages without the exposed public keys which would be some kind of problem then because we had only chosen to stick to the stages with the exposed pubkeys. Now let us start with making something work. the probability of guessing the 0s and 1s in levels without the pubkeys is much higher than the probability of guessing if puzzle 66 starts with either 2 or 3 because for you to find out if its 2 or 3 you'd have had to scan half of the keyspace and if you're wrong then you'd see that the investment used and time wasted to scan that range alone isn't worth it compared to guessing the 0s and 1s. I buy the 0s and 1s scanning methodology pretty well but I'd advise we look for a way to make the scan work faster and not only based on CPUs. If we can get the logic to work efficiently well on GPUs, I'm not saying 1 week to scan the level 66,67 and 68 but we can achieve that in 3 days, with the availability of GPUs on demand and it will as well be cost efficient than scanning through all the ranges endlessly
|
|
|
|
tptkimikaze
Newbie
Offline
Activity: 25
Merit: 2
|
 |
August 12, 2023, 07:16:01 PM |
|
Using this code below to find the private key for puzzle 30, which specifies that the first 4 bits are 1. Running it with 12 processes on my i7-12700kf, the private key was found in about 1 minute and 28 seconds. 000000000000000000000000000000000000000000000000000000003d94cd64 hash160: d39c4704664e1deb76c9331e637564c257d68a08 Target hash found! Time: 0 h, 1 m, 28 s import hashlib import ecdsa import random import time from multiprocessing import Process, Event
target_hash = "d39c4704664e1deb76c9331e637564c257d68a08"
def binary_to_hex(bin_string): return hex(int(bin_string, 2))[2:].zfill(len(bin_string) // 4)
def worker(num_zeros, num_ones, stop_event):
while True: if stop_event.is_set(): break
bits = ['0'] * num_zeros + ['1'] * (num_ones - 4) random.shuffle(bits)
bits.insert(0, '1') bits.insert(1, '1') bits.insert(2, '1') bits.insert(3, '1') private_key_bin = ''.join(bits)
private_key_bin = '0' * (256 - 30) + private_key_bin
private_key_hex = binary_to_hex(private_key_bin)
sk = ecdsa.SigningKey.from_string(bytes.fromhex(private_key_hex), curve=ecdsa.SECP256k1) public_key = sk.get_verifying_key().to_string().hex()
compressed_public_key = '02' + public_key[0:64] if int(public_key[-2:], 16) % 2 == 0 else '03' + public_key[0:64] compressed_public_key_bytes = bytes.fromhex(compressed_public_key)
ripemd160_hash = hashlib.new('ripemd160') ripemd160_hash.update(hashlib.sha256(compressed_public_key_bytes).digest()) hashed_compressed_public_key = ripemd160_hash.digest().hex()
if hashed_compressed_public_key == target_hash: print(private_key_hex) print("hash160:", hashed_compressed_public_key) print("Target hash found!")
stop_event.set() break
def main(): num_processes = 12 processes = [] stop_event = Event()
start_time = time.time()
for _ in range(num_processes): process = Process(target=worker, args=(14, 16, stop_event)) processes.append(process)
for process in processes: process.start()
for process in processes: process.join()
if stop_event.is_set(): for process in processes: process.terminate()
end_time = time.time() execution_time_seconds = end_time - start_time
hours = int(execution_time_seconds // 3600) minutes = int((execution_time_seconds % 3600) // 60) seconds = int(execution_time_seconds % 60)
print(f"Time: {hours} h, {minutes} m, {seconds} s")
if __name__ == '__main__': main()
I just try it and I can find it in 30 sec on #30. For #66 it's still difficult to scan without GPU. Try also for #35, #40, or #45. Scan it in python without GPU too slow for 66 bit. The only way I can figure out now as I previous posted. Step 1 Let's say start scanning from 60 bits. Use Python to do the combination. 0s - 30 - 1s -30 = 50% 0s - 31 - 1s 29 = 51.67% 0s - 32 - 1s 28 = 53.4% 0s - 33 - 1s 27 = 55% 0s - 34 - 1s 26 = 56.67% 0s - 35 - 1s 25 = 58.34% 0s - 36 - 1s 24 = 60% Then reverse 0s and 1s position in max 60% which is most likely where the key are. Step 2 Convert results from Binary to Hexa Step 3 Make a batch file and run in Bitcrack to use GPU Step 4 Run until it hits the key or else increase the percentages if it doesn't. By using Python to eliminate those less like key first, then scan the list with GPU
|
|
|
|
tptkimikaze
Newbie
Offline
Activity: 25
Merit: 2
|
 |
August 12, 2023, 07:35:45 PM |
|
Using this code below to find the private key for puzzle 30, which specifies that the first 4 bits are 1. Running it with 12 processes on my i7-12700kf, the private key was found in about 1 minute and 28 seconds. 000000000000000000000000000000000000000000000000000000003d94cd64 hash160: d39c4704664e1deb76c9331e637564c257d68a08 Target hash found! Time: 0 h, 1 m, 28 s import hashlib import ecdsa import random import time from multiprocessing import Process, Event
target_hash = "d39c4704664e1deb76c9331e637564c257d68a08"
def binary_to_hex(bin_string): return hex(int(bin_string, 2))[2:].zfill(len(bin_string) // 4)
def worker(num_zeros, num_ones, stop_event):
while True: if stop_event.is_set(): break
bits = ['0'] * num_zeros + ['1'] * (num_ones - 4) random.shuffle(bits)
bits.insert(0, '1') bits.insert(1, '1') bits.insert(2, '1') bits.insert(3, '1') private_key_bin = ''.join(bits)
private_key_bin = '0' * (256 - 30) + private_key_bin
private_key_hex = binary_to_hex(private_key_bin)
sk = ecdsa.SigningKey.from_string(bytes.fromhex(private_key_hex), curve=ecdsa.SECP256k1) public_key = sk.get_verifying_key().to_string().hex()
compressed_public_key = '02' + public_key[0:64] if int(public_key[-2:], 16) % 2 == 0 else '03' + public_key[0:64] compressed_public_key_bytes = bytes.fromhex(compressed_public_key)
ripemd160_hash = hashlib.new('ripemd160') ripemd160_hash.update(hashlib.sha256(compressed_public_key_bytes).digest()) hashed_compressed_public_key = ripemd160_hash.digest().hex()
if hashed_compressed_public_key == target_hash: print(private_key_hex) print("hash160:", hashed_compressed_public_key) print("Target hash found!")
stop_event.set() break
def main(): num_processes = 12 processes = [] stop_event = Event()
start_time = time.time()
for _ in range(num_processes): process = Process(target=worker, args=(14, 16, stop_event)) processes.append(process)
for process in processes: process.start()
for process in processes: process.join()
if stop_event.is_set(): for process in processes: process.terminate()
end_time = time.time() execution_time_seconds = end_time - start_time
hours = int(execution_time_seconds // 3600) minutes = int((execution_time_seconds % 3600) // 60) seconds = int(execution_time_seconds % 60)
print(f"Time: {hours} h, {minutes} m, {seconds} s")
if __name__ == '__main__': main()
I just try it and I can find it in 30 sec on #30. For #66 it's still difficult to scan without GPU. Try also for #35, #40, or #45. Scan it in python without GPU too slow for 66 bit. The only way I can figure out now as I previous posted. Step 1 Let's say start scanning from 60 bits. Use Python to do the combination. 0s - 30 - 1s -30 = 50% 0s - 31 - 1s 29 = 51.67% 0s - 32 - 1s 28 = 53.4% 0s - 33 - 1s 27 = 55% 0s - 34 - 1s 26 = 56.67% 0s - 35 - 1s 25 = 58.34% 0s - 36 - 1s 24 = 60% Then reverse 0s and 1s position in max 60% which is most likely where the key are. Step 2 Convert results from Binary to Hexa Step 3 Make a batch file and run in Bitcrack to use GPU Step 4 Run until it hits the key or else increase the percentages if it doesn't. By using Python to eliminate those less like key first, then scan the list with GPU Pro Python definitely have no problem with it but I'm not pro. Combine pro Python with GPU, I believe the results will be as Bestie said, achievable in 3 days.
|
|
|
|
mcdouglasx
|
 |
August 12, 2023, 07:53:15 PM |
|
Folks, the focus shouldn't be on how many 1s or 0s bits keys should have; it should be on how to scan faster or how we can skip less probable keys.
If you want to play luck with #66 just change the parameter of the curve. Gx = 55066263022277343669578718895168534326250603453777594175500187360389116729240 Gy = 32670510020758816978083085130507043184471273380659243275938904335757337482424 G = (Gx, Gy) for example pub pk #2 (50-50 of probabilities) Gy = 89565891926547004231252920425935692360644145829622209833684329913297188986597 Gy = 12158399299693830322967808612713398636155367887041628176798871954788371653930 G = (Gx, Gy) or with any other pub to skip certain keys.
|
|
|
|
james5000
Jr. Member
Offline
Activity: 69
Merit: 2
|
 |
August 12, 2023, 08:40:49 PM |
|
Folks, the focus shouldn't be on how many 1s or 0s bits keys should have; it should be on how to scan faster or how we can skip less probable keys.
If you want to play luck with #66 just change the parameter of the curve. Gx = 55066263022277343669578718895168534326250603453777594175500187360389116729240 Gy = 32670510020758816978083085130507043184471273380659243275938904335757337482424 G = (Gx, Gy) for example pub pk #2 (50-50 of probabilities) Gy = 89565891926547004231252920425935692360644145829622209833684329913297188986597 Gy = 12158399299693830322967808612713398636155367887041628176798871954788371653930 G = (Gx, Gy) or with any other pub to skip certain keys. Please explain how to modify the parameters of the skip keys curve?
|
|
|
|
mcdouglasx
|
 |
August 12, 2023, 10:06:58 PM |
|
Folks, the focus shouldn't be on how many 1s or 0s bits keys should have; it should be on how to scan faster or how we can skip less probable keys.
If you want to play luck with #66 just change the parameter of the curve. Gx = 55066263022277343669578718895168534326250603453777594175500187360389116729240 Gy = 32670510020758816978083085130507043184471273380659243275938904335757337482424 G = (Gx, Gy) for example pub pk #2 (50-50 of probabilities) Gy = 89565891926547004231252920425935692360644145829622209833684329913297188986597 Gy = 12158399299693830322967808612713398636155367887041628176798871954788371653930 G = (Gx, Gy) or with any other pub to skip certain keys. Please explain how to modify the parameters of the skip keys curve? For example, the default parameter in the curve is this: Gx = 55066263022277343669578718895168534326250603453777594175500187360389116729240 Gy = 32670510020758816978083085130507043184471273380659243275938904335757337482424 G = (Gx, Gy) or in hex Gx = 79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798 Gy = 483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8 If we change this to this(pub key corresponding to private key #2): Gx = 89565891926547004231252920425935692360644145829622209833684329913297188986597 Gy = 12158399299693830322967808612713398636155367887041628176798871954788371653930 G = (Gx, Gy) hex Gx = C6047F9441ED7D6D3045406E95C07CD85C778E4B8CEF3CA7ABAC09B95C709EE5 Gy = 1AE168FEA63DC339A3C58419466CEAEEF7F632653266D0E1236431A950CFE52A our search will go from 1,2,3,4,5,6,7..... to 2,4,6,8,10..... if we want to search for a key in the range 2000:6000 we divide the range by 2 1000:3000 if we find the pk in 1024 multiply by 2 and this will be the original pk 2048 we would just skip odds. if you use the pubkey from pk #3 then it would be sequence 3,6,9,12.... that is, 33.3% probability
|
|
|
|
james5000
Jr. Member
Offline
Activity: 69
Merit: 2
|
 |
August 12, 2023, 10:19:40 PM |
|
Interesting!! However, in this case, you're not skipping keys; you're transposing the range from 2000:6000 to 1000:3000, which results in the same number of keys.
|
|
|
|
|