79 Degrees at 99%
Edit:
The above was "off the shelf" settings.
Using the fan curve feature in MSI Afterburner I set the GPU fan speed curve to max the GPU fans out @ 70 degrees.
With this new temp curve in place I can maintain a temperature of 70 degrees (+/- 2) while @ 3,400 Mkeys/s but the card alone is consuming about 435Watt
2nd Edit
After removing the glass side from my PC case leaving the chassis open with a small external fan blowing into the case the card runs @ 3,422 Mkeys/s while maintaining 60 degrees (+/- 1).
The manufacturers documentation for my case states the case should be closed to maintain correct air flow however all temperature readings on the system suggest otherwise, the entire system is running much cooler, the GPU 20 degrees less on average.
So the FINAL answer to the original question is
The Zotac RTX 4090 running Bitcrack2 can process 3,422 Mkeys/s while maintaining 60 degrees with a fan speed floating between 65 to 68%.
Topic: BitCrack - A tool for brute-forcing private keys - page 3. (Read 74373 times)
What was the peak temperature that your 4090 reached using bitcrack?
- So after hours I finally got Bitcrack2 to compile with CUDA and up and running on my new PC i7-13700K 3.4 GHz 16 core running a Zotac RTX 4090.
BTW to build Bitcrack2 the instructions said you require Microsoft Visual Studio Community 2019, I also had to install 2017 due to a 3rd party file referencing the 2017 runtime, anyway.
For anyone interested here are some of the Bitcrack settings I played with and the respective stats running on the RTX 4090.
All use the following config, note the X drive is a Samsung Evo SSD containing nothing but Bitcrack2 and it's respective files.
X:\BitCrack.exe --continue X:\save.txt --in X:\ImportAddresses.txt --out X:\keysfound.txt --keyspace 300000000000000000:36FFFFFFFFFFFFFFF -b xx -t xx -p xx
The file "X:\ImportAddresses.txt" contains the single address for comp 66 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so
- b 256 -t 512 -p 2048 (Crashed)
- b 128 -t 512 -p 3072 (Crashed)
- b 128 -t 512 -p 2048 = 3,407 MKeys/s @ 435Watts = 7.8 Mkeys/s per watt
- b 128 -t 256 -p 2048 = 3,333 MKeys/s @ 447Watts = 7.4 Mkeys/s per watt
- b 96 -t 512 -p 2048 = 3,000 MKeys/s @ 445Watts = 6.7 Mkeys/s per watt
- b 96 -t 512 -p 1024 = 2,915 MKeys/s @ 444Watts = 6.5 Mkeys/s per watt
- b 96 -t 265 -p 1024 = 2,900 MKeys/s @ 435Watts = 6.6 Mkeys/s per watt
- b 96 -t 128 -p 1024 = 2,354 MKeys/s @ 458Watts = 5.1 Mkeys/s per watt
- b 64 -t 512 -p 2048 = 2,500 MKeys/s @ 378Watts = 6.6 Mkeys/s per watt
- b 64 -t 256 -p 2048 = 2,300 MKeys/s @ 357Watts = 6.4 Mkeys/s per watt
- b 64 -t 128 -p 1024 = 1,605 MKeys/s @ 278Watts = 5.7 Mkeys/s per watt (Fans don't cut in)
- b 64 -t 128 -p 512 = 1,610 MKeys/s @ 267Watts = 6.0 Mkeys/s per watt (Fans don't cut in)
In comparison to my other rig running a Xeon Hex core 3.46Ghz plus a GTX 970
- GTX 970 = b 64 -t 128 -p 512 = 150 MKeys/s (Flat out, it run warm and was the best I could ever get out of it.)
So the RTX 4090 running flat out is just over 22.6 times faster than my old GTX 970 which is crazy, what would have taken 22.6 years to scan will now take 1 year however in reality I don't think the RTX 4090 could last a year at those temperatures, it literally heated up the room more than my central heating system does.
If anyone else is running the RTX 4090 it would be interesting to compare Mkeys/s
[/list][/list]
Hello guy's
What computer need for generate numbers in range 2^60 - 2^64 ?
How long time this work get ?
PC with 100 cores will generate this numbers in not more then one week ?
Br
What computer need for generate numbers in range 2^60 - 2^64 ?
How long time this work get ?
PC with 100 cores will generate this numbers in not more then one week ?
Br
Hello everyone, I recently purchased a video card, I want to try the search. Tell me, what other alternatives are there ButCrack on CUDA cores?
my answer was to nomachine
his code:
he import :
and he calculate:
so first:
he calculate :
which taking time.
his code:
Code:
mport os
import multiprocessing as mp
from gmpy2 import mpz, powmod
from bitcoinlib.encoding import addr_to_pubkeyhash, to_hexstring
from bitcoinlib.keys import HDKey
from ecdsa import SigningKey, SECP256k1
def save_key_to_file(private_hex: str):
with open(f"{private_hex}.txt", "w") as f:
f.write(private_hex)
def generate_random_numbers(num_numbers):
return [os.urandom(32) for _ in range(num_numbers)]
def search_for_key(start_key_int, stop_key_int, target_address, attempts_per_process, random_numbers):
for i in range(attempts_per_process):
current_key_int = mpz(powmod(int.from_bytes(random_numbers[i], 'big'), 1, stop_key_int - start_key_int)) + start_key_int
ecdsa_private_key = SigningKey.from_secret_exponent(int(current_key_int), curve=SECP256k1)
key = HDKey(key=ecdsa_private_key.to_string())
if key.address() == target_address:
save_key_to_file(key.private_hex)
print(f"Private key found: {key.private_hex}")
return key
return None
def search_in_range(start_key_int, stop_key_int, target_address, attempts_per_process, random_numbers):
process_start_key_int = mpz(powmod(int.from_bytes(random_numbers[0], 'big'), 1, stop_key_int - start_key_int)) + start_key_int
process_stop_key_int = (process_start_key_int + attempts_per_process) % stop_key_int
search_for_key(process_start_key_int, process_stop_key_int, target_address, attempts_per_process, random_numbers)
if __name__ == "__main__":
address = '1FeexV6bAHb8ybZjqQMjJrcCrHGW9sb6uF'
start_key = '0000000000000000000000000000000000000000000000040000000000000000'
stop_key = '000000000000000000000000000000000000000000000007ffffffffffffffff'
start_key_int = mpz(start_key, 16)
stop_key_int = mpz(stop_key, 16)
attempts_per_process = 2000000
num_processes = 8
random_numbers = generate_random_numbers(attempts_per_process * num_processes)
processes = []
for _ in range(num_processes):
process = mp.Process(target=search_in_range, args=(start_key_int, stop_key_int, address, attempts_per_process, random_numbers))
processes.append(process)
process.start()
for process in processes:
process.join()
print(f"Private key not found in the given range after {num_processes * attempts_per_process} attempts.")
import multiprocessing as mp
from gmpy2 import mpz, powmod
from bitcoinlib.encoding import addr_to_pubkeyhash, to_hexstring
from bitcoinlib.keys import HDKey
from ecdsa import SigningKey, SECP256k1
def save_key_to_file(private_hex: str):
with open(f"{private_hex}.txt", "w") as f:
f.write(private_hex)
def generate_random_numbers(num_numbers):
return [os.urandom(32) for _ in range(num_numbers)]
def search_for_key(start_key_int, stop_key_int, target_address, attempts_per_process, random_numbers):
for i in range(attempts_per_process):
current_key_int = mpz(powmod(int.from_bytes(random_numbers[i], 'big'), 1, stop_key_int - start_key_int)) + start_key_int
ecdsa_private_key = SigningKey.from_secret_exponent(int(current_key_int), curve=SECP256k1)
key = HDKey(key=ecdsa_private_key.to_string())
if key.address() == target_address:
save_key_to_file(key.private_hex)
print(f"Private key found: {key.private_hex}")
return key
return None
def search_in_range(start_key_int, stop_key_int, target_address, attempts_per_process, random_numbers):
process_start_key_int = mpz(powmod(int.from_bytes(random_numbers[0], 'big'), 1, stop_key_int - start_key_int)) + start_key_int
process_stop_key_int = (process_start_key_int + attempts_per_process) % stop_key_int
search_for_key(process_start_key_int, process_stop_key_int, target_address, attempts_per_process, random_numbers)
if __name__ == "__main__":
address = '1FeexV6bAHb8ybZjqQMjJrcCrHGW9sb6uF'
start_key = '0000000000000000000000000000000000000000000000040000000000000000'
stop_key = '000000000000000000000000000000000000000000000007ffffffffffffffff'
start_key_int = mpz(start_key, 16)
stop_key_int = mpz(stop_key, 16)
attempts_per_process = 2000000
num_processes = 8
random_numbers = generate_random_numbers(attempts_per_process * num_processes)
processes = []
for _ in range(num_processes):
process = mp.Process(target=search_in_range, args=(start_key_int, stop_key_int, address, attempts_per_process, random_numbers))
processes.append(process)
process.start()
for process in processes:
process.join()
print(f"Private key not found in the given range after {num_processes * attempts_per_process} attempts.")
he import :
Code:
from bitcoinlib.encoding import addr_to_pubkeyhash, to_hexstring
from bitcoinlib.keys import HDKey
from ecdsa import SigningKey, SECP256k1
from bitcoinlib.keys import HDKey
from ecdsa import SigningKey, SECP256k1
and he calculate:
Code:
def search_for_key(start_key_int, stop_key_int, target_address, attempts_per_process, random_numbers):
for i in range(attempts_per_process):
current_key_int = mpz(powmod(int.from_bytes(random_numbers[i], 'big'), 1, stop_key_int - start_key_int)) + start_key_int
ecdsa_private_key = SigningKey.from_secret_exponent(int(current_key_int), curve=SECP256k1)
key = HDKey(key=ecdsa_private_key.to_string())
if key.address() == target_address:
save_key_to_file(key.private_hex)
print(f"Private key found: {key.private_hex}")
return key
return None
for i in range(attempts_per_process):
current_key_int = mpz(powmod(int.from_bytes(random_numbers[i], 'big'), 1, stop_key_int - start_key_int)) + start_key_int
ecdsa_private_key = SigningKey.from_secret_exponent(int(current_key_int), curve=SECP256k1)
key = HDKey(key=ecdsa_private_key.to_string())
if key.address() == target_address:
save_key_to_file(key.private_hex)
print(f"Private key found: {key.private_hex}")
return key
return None
so first:
he calculate :
Code:
ecdsa_private_key = SigningKey.from_secret_exponent(int(current_key_int), curve=SECP256k1)
key = HDKey(key=ecdsa_private_key.to_string())
if key.address() == target_address:
key = HDKey(key=ecdsa_private_key.to_string())
if key.address() == target_address:
which taking time.
why u use external library ?
it is your bottleneck.
you are comparing addres with address.
it means : additional you do:
Sha256 + sha256 for checksum.
?
better:
get target and change for decode base58 , delete 8 bytes (checksum)
and it is your target.
now :
get new public_key -> perform sha256 + ripemd and check it is your target.
now it is 3 or 4 times faster
Are you telling this based on the code, I mean did you check the code? If the code does the double hash for each key then you are right. it is your bottleneck.
you are comparing addres with address.
it means : additional you do:
Sha256 + sha256 for checksum.
?
better:
get target and change for decode base58 , delete 8 bytes (checksum)
and it is your target.
now :
get new public_key -> perform sha256 + ripemd and check it is your target.
now it is 3 or 4 times faster
why u use external library ?
it is your bottleneck.
you are comparing addres with address.
it means : additional you do:
Sha256 + sha256 for checksum.
?
better:
get target and change for decode base58 , delete 8 bytes (checksum)
and it is your target.
now :
get new public_key -> perform sha256 + ripemd and check it is your target.
now it is 3 or 4 times faster
it is your bottleneck.
you are comparing addres with address.
it means : additional you do:
Sha256 + sha256 for checksum.
?
better:
get target and change for decode base58 , delete 8 bytes (checksum)
and it is your target.
now :
get new public_key -> perform sha256 + ripemd and check it is your target.
now it is 3 or 4 times faster
I wonder if keys were generated by some deterministic wallet first, and then truncated to N bits. Because in that case, it could be possible to recover the master key, and then sweep coins from all of them, while it would not mean that ECDSA is broken (because HD keys could be non-hardened).
Interesting puzzle, I checked for patterns between binary values, decimal values, floor values. Just cant find anything
I updated an excel sheet puzzle bitcoin.xlsx with allot more data of each puzzle. Like decimal, binary, floor, and allot more data per puzzle. Even multipliers of the data to the next puzzle.
Since this range is just so huge, I think a random generator would maybe work best to try and find the needle.
I attached below my python script trying the next puzzle randomly if someone might benefit to
https://github.com/negate7o4/Bitcoin-Puzzle
On my rig, I7 if I run 5 X instances, it checks about 11 500 possibilities per second per thread, but eats 80% cpu. So the code chews threw 16.5 Mil random possibilities per day
If you want to try a different puzzle, just change these values in the script :
address = '1FeexV6bAHb8ybZjqQMjJrcCrHGW9sb6uF'
start_key = '0000000000000000000000000000000000000000000000040000000000000000' stop_key = '000000000000000000000000000000000000000000000007ffffffffffffffff'
Also take note of the cpu threads the code uses, update according to your threads.
Their is also a text file in my repository of the correct pip's you need to install for the code to work
Code:
import os
import multiprocessing as mp
from gmpy2 import mpz, powmod
from bitcoinlib.encoding import addr_to_pubkeyhash, to_hexstring
from bitcoinlib.keys import HDKey
from ecdsa import SigningKey, SECP256k1
def save_key_to_file(private_hex: str):
with open(f"{private_hex}.txt", "w") as f:
f.write(private_hex)
def generate_random_numbers(num_numbers):
return [os.urandom(32) for _ in range(num_numbers)]
def search_for_key(start_key_int, stop_key_int, target_address, attempts_per_process, random_numbers):
for i in range(attempts_per_process):
current_key_int = mpz(powmod(int.from_bytes(random_numbers[i], 'big'), 1, stop_key_int - start_key_int)) + start_key_int
ecdsa_private_key = SigningKey.from_secret_exponent(int(current_key_int), curve=SECP256k1)
key = HDKey(key=ecdsa_private_key.to_string())
if key.address() == target_address:
save_key_to_file(key.private_hex)
print(f"Private key found: {key.private_hex}")
return key
return None
def search_in_range(start_key_int, stop_key_int, target_address, attempts_per_process, random_numbers):
process_start_key_int = mpz(powmod(int.from_bytes(random_numbers[0], 'big'), 1, stop_key_int - start_key_int)) + start_key_int
process_stop_key_int = (process_start_key_int + attempts_per_process) % stop_key_int
search_for_key(process_start_key_int, process_stop_key_int, target_address, attempts_per_process, random_numbers)
if __name__ == "__main__":
address = '1FeexV6bAHb8ybZjqQMjJrcCrHGW9sb6uF'
start_key = '0000000000000000000000000000000000000000000000040000000000000000'
stop_key = '000000000000000000000000000000000000000000000007ffffffffffffffff'
start_key_int = mpz(start_key, 16)
stop_key_int = mpz(stop_key, 16)
attempts_per_process = 2000000
num_processes = 8
random_numbers = generate_random_numbers(attempts_per_process * num_processes)
processes = []
for _ in range(num_processes):
process = mp.Process(target=search_in_range, args=(start_key_int, stop_key_int, address, attempts_per_process, random_numbers))
processes.append(process)
process.start()
for process in processes:
process.join()
print(f"Private key not found in the given range after {num_processes * attempts_per_process} attempts.")
import multiprocessing as mp
from gmpy2 import mpz, powmod
from bitcoinlib.encoding import addr_to_pubkeyhash, to_hexstring
from bitcoinlib.keys import HDKey
from ecdsa import SigningKey, SECP256k1
def save_key_to_file(private_hex: str):
with open(f"{private_hex}.txt", "w") as f:
f.write(private_hex)
def generate_random_numbers(num_numbers):
return [os.urandom(32) for _ in range(num_numbers)]
def search_for_key(start_key_int, stop_key_int, target_address, attempts_per_process, random_numbers):
for i in range(attempts_per_process):
current_key_int = mpz(powmod(int.from_bytes(random_numbers[i], 'big'), 1, stop_key_int - start_key_int)) + start_key_int
ecdsa_private_key = SigningKey.from_secret_exponent(int(current_key_int), curve=SECP256k1)
key = HDKey(key=ecdsa_private_key.to_string())
if key.address() == target_address:
save_key_to_file(key.private_hex)
print(f"Private key found: {key.private_hex}")
return key
return None
def search_in_range(start_key_int, stop_key_int, target_address, attempts_per_process, random_numbers):
process_start_key_int = mpz(powmod(int.from_bytes(random_numbers[0], 'big'), 1, stop_key_int - start_key_int)) + start_key_int
process_stop_key_int = (process_start_key_int + attempts_per_process) % stop_key_int
search_for_key(process_start_key_int, process_stop_key_int, target_address, attempts_per_process, random_numbers)
if __name__ == "__main__":
address = '1FeexV6bAHb8ybZjqQMjJrcCrHGW9sb6uF'
start_key = '0000000000000000000000000000000000000000000000040000000000000000'
stop_key = '000000000000000000000000000000000000000000000007ffffffffffffffff'
start_key_int = mpz(start_key, 16)
stop_key_int = mpz(stop_key, 16)
attempts_per_process = 2000000
num_processes = 8
random_numbers = generate_random_numbers(attempts_per_process * num_processes)
processes = []
for _ in range(num_processes):
process = mp.Process(target=search_in_range, args=(start_key_int, stop_key_int, address, attempts_per_process, random_numbers))
processes.append(process)
process.start()
for process in processes:
process.join()
print(f"Private key not found in the given range after {num_processes * attempts_per_process} attempts.")
But no matter how you turn it and perfect it, it takes a couple of million years to reach the result.
tell me, is it possible to use bitcrack for Ethereum? 
you need AltCrack
does it work with ethereum? you need hash160, and the ether address is created differently
No, it does not.
ETH addresses take the Keccak (often mistaken for SHA-3 - they are NOT the same!) hash of the SHA-256 hash of the public key, they don't use hash160 at all.
Hey people!
I'm using BitCrack/AltCrack to find 66, but it only searches consecutively through 1 or some other number. Tell me if there is a program that can search for 66 puzzles by sorting through all the range options by mask.
for example this mask (decimal): XXXXXX123456XXXXXXXX
Now I have to run Altcrack 368,935 times consecutively to check the range for this mask, but this is very long. Is there any other way?
I'm using BitCrack/AltCrack to find 66, but it only searches consecutively through 1 or some other number. Tell me if there is a program that can search for 66 puzzles by sorting through all the range options by mask.
for example this mask (decimal): XXXXXX123456XXXXXXXX
Now I have to run Altcrack 368,935 times consecutively to check the range for this mask, but this is very long. Is there any other way?
Altcrack is for finding the private keys of Bitcoin-like addresses such as Namecoin, Litecoin, Doge, Dash etc. Frankly, you will be spending more time programming the calculation of the version bytes and stuff like that with Altcrack, so unless it has a massive speed optimization, it's better to just stick with Bitcrack.
tell me, is it possible to use bitcrack for Ethereum?
you need AltCrack
does it work with ethereum? you need hash160, and the ether address is created differently
Hey people!
I'm using BitCrack/AltCrack to find 66, but it only searches consecutively through 1 or some other number. Tell me if there is a program that can search for 66 puzzles by sorting through all the range options by mask.
for example this mask (decimal): XXXXXX123456XXXXXXXX
Now I have to run Altcrack 368,935 times consecutively to check the range for this mask, but this is very long. Is there any other way?
I'm using BitCrack/AltCrack to find 66, but it only searches consecutively through 1 or some other number. Tell me if there is a program that can search for 66 puzzles by sorting through all the range options by mask.
for example this mask (decimal): XXXXXX123456XXXXXXXX
Now I have to run Altcrack 368,935 times consecutively to check the range for this mask, but this is very long. Is there any other way?
tell me, is it possible to use bitcrack for Ethereum?
you need AltCrack
tell me, is it possible to use bitcrack for Ethereum?
No.It's mainly developed for the puzzle transaction which is Bitcoin-exclusive.
Example:
Code:
clbitcrack 0x0123
Result:Code:
[Error] Invalid address '0x0123'
What's your goal anyways, depending on it, I may know an alternative that'll work in Ethereum.
tell me, is it possible to use bitcrack for Ethereum?
who solved ? which tools useing to crack keyhunt or BitCrack
Very unlikely that it was bitcrack. This magic kangaroo stuff is.
I wonder of RAM requirements for 120 puzzle. Who's next p66 or p125? )
Needs too much effort more then guessing 256 bit key 
[/quote]
I read your posts on the forum. If you take the last digits of any private key and go through the entire range, you will find the key
check this
-b 64 -t 512 -p 1600 --keyspace 7FFFFFFFFF9112D4:FFFFFFFFFFFFFFFF 16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN --stride 1000000
-b 64 -t 512 -p 1600 --keyspace FFFFFFFFF5B26867:1FFFFFFFFFFFFFFFF 18ZMbwUFLMHoZBbfpCjUJQTCMCbktshgpe --stride 10000000
zahid888 i think you are on the right track
you for 66 you need to find 7 digitsneed to look in the starting range 0-9 A-F = full brute force 16^7
I don't know how to speed it up
[2023-06-19.21:22:02] [Info] Compression : compressed
[2023-06-19.21:22:02] [Info] Starting at : 000000000000000000000000000000000000000000000001FFFFFFFFF0000A18 (65 bit)
[2023-06-19.21:22:02] [Info] Ending at : 000000000000000000000000000000000000000000000003FFFFFFFFFFFFFFFF (66 bit)
[2023-06-19.21:22:02] [Info] Range : 000000000000000000000000000000000000000000000002000000000FFFF5E7 (66 bit)
[2023-06-19.21:22:02] [Info] Initializing NVIDIA GeForce RTX 3080
[2023-06-19.21:22:02] [Info] Generating 52,428,800 starting points (2000.0MB)
[2023-06-19.21:22:05] [Info] 10.0% 20.0% 30.0% 40.0% 50.0% 60.0% 70.0% 80.0% 90.0% 100.0%
[2023-06-19.21:22:07] [Info] Done
[DEV: NVIDIA GeForce R 9156/10239MB] [0000000000000000000000000000000000000000000000036A7FFFFFF0000A18 (66 bit)] [INC: 0, 0] [TARGET: 1] [SPEED: 1663.50 MKey/s] [TOTAL: 6,081,740,800] [00:00:01][2023-06-19.21:22:12] [Info] Reached end of keyspace
[2023-06-19.21:22:13] [Info] Compression : compressed
[2023-06-19.21:22:13] [Info] Starting at : 000000000000000000000000000000000000000000000001FFFFFFFFF0000A19 (65 bit)
[2023-06-19.21:22:13] [Info] Ending at : 000000000000000000000000000000000000000000000003FFFFFFFFFFFFFFFF (66 bit)
[2023-06-19.21:22:13] [Info] Range : 000000000000000000000000000000000000000000000002000000000FFFF5E6 (66 bit)
[2023-06-19.21:22:13] [Info] Initializing NVIDIA GeForce RTX 3080
[2023-06-19.21:22:13] [Info] Generating 52,428,800 starting points (2000.0MB)
[2023-06-19.21:22:16] [Info] 10.0% 20.0% 30.0% 40.0% 50.0% 60.0% 70.0% 80.0% 90.0% 100.0%
[2023-06-19.21:22:18] [Info] Done
[DEV: NVIDIA GeForce R 9156/10239MB] [00000000000000000000000000000000000000000000000370BFFFFFF0000A19 (66 bit)] [INC: 0, 0] [TARGET: 1] [SPEED: 1691.25 MKey/s] [TOTAL: 6,186,598,400] [00:00:01][2023-06-19.21:22:23] [Info] Reached end of keyspace
[2023-06-19.21:22:23] [Info] Compression : compressed
[2023-06-19.21:22:23] [Info] Starting at : 000000000000000000000000000000000000000000000001FFFFFFFFF0000A1A (65 bit)
[2023-06-19.21:22:23] [Info] Ending at : 000000000000000000000000000000000000000000000003FFFFFFFFFFFFFFFF (66 bit)
[2023-06-19.21:22:23] [Info] Range : 000000000000000000000000000000000000000000000002000000000FFFF5E5 (66 bit)
[2023-06-19.21:22:23] [Info] Initializing NVIDIA GeForce RTX 3080
[2023-06-19.21:22:24] [Info] Generating 52,428,800 starting points (2000.0MB)
[2023-06-19.21:22:27] [Info] 10.0% 20.0% 30.0% 40.0% 50.0% 60.0% 70.0% 80.0% 90.0% 100.0%
[2023-06-19.21:22:29] [Info] Done
[DEV: NVIDIA GeForce R 9156/10239MB] [0000000000000000000000000000000000000000000000036D9FFFFFF0000A1A (66 bit)] [INC: 0, 0] [TARGET: 1] [SPEED: 1663.50 MKey/s] [TOTAL: 6,134,169,600] [00:00:01][2023-06-19.21:22:34] [Info] Reached end of keyspace
[/quote]
I read your posts on the forum. If you take the last digits of any private key and go through the entire range, you will find the key
check this
-b 64 -t 512 -p 1600 --keyspace 7FFFFFFFFF9112D4:FFFFFFFFFFFFFFFF 16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN --stride 1000000
-b 64 -t 512 -p 1600 --keyspace FFFFFFFFF5B26867:1FFFFFFFFFFFFFFFF 18ZMbwUFLMHoZBbfpCjUJQTCMCbktshgpe --stride 10000000
zahid888 i think you are on the right track
you for 66 you need to find 7 digitsneed to look in the starting range 0-9 A-F = full brute force 16^7
I don't know how to speed it up
[2023-06-19.21:22:02] [Info] Compression : compressed
[2023-06-19.21:22:02] [Info] Starting at : 000000000000000000000000000000000000000000000001FFFFFFFFF0000A18 (65 bit)
[2023-06-19.21:22:02] [Info] Ending at : 000000000000000000000000000000000000000000000003FFFFFFFFFFFFFFFF (66 bit)
[2023-06-19.21:22:02] [Info] Range : 000000000000000000000000000000000000000000000002000000000FFFF5E7 (66 bit)
[2023-06-19.21:22:02] [Info] Initializing NVIDIA GeForce RTX 3080
[2023-06-19.21:22:02] [Info] Generating 52,428,800 starting points (2000.0MB)
[2023-06-19.21:22:05] [Info] 10.0% 20.0% 30.0% 40.0% 50.0% 60.0% 70.0% 80.0% 90.0% 100.0%
[2023-06-19.21:22:07] [Info] Done
[DEV: NVIDIA GeForce R 9156/10239MB] [0000000000000000000000000000000000000000000000036A7FFFFFF0000A18 (66 bit)] [INC: 0, 0] [TARGET: 1] [SPEED: 1663.50 MKey/s] [TOTAL: 6,081,740,800] [00:00:01][2023-06-19.21:22:12] [Info] Reached end of keyspace
[2023-06-19.21:22:13] [Info] Compression : compressed
[2023-06-19.21:22:13] [Info] Starting at : 000000000000000000000000000000000000000000000001FFFFFFFFF0000A19 (65 bit)
[2023-06-19.21:22:13] [Info] Ending at : 000000000000000000000000000000000000000000000003FFFFFFFFFFFFFFFF (66 bit)
[2023-06-19.21:22:13] [Info] Range : 000000000000000000000000000000000000000000000002000000000FFFF5E6 (66 bit)
[2023-06-19.21:22:13] [Info] Initializing NVIDIA GeForce RTX 3080
[2023-06-19.21:22:13] [Info] Generating 52,428,800 starting points (2000.0MB)
[2023-06-19.21:22:16] [Info] 10.0% 20.0% 30.0% 40.0% 50.0% 60.0% 70.0% 80.0% 90.0% 100.0%
[2023-06-19.21:22:18] [Info] Done
[DEV: NVIDIA GeForce R 9156/10239MB] [00000000000000000000000000000000000000000000000370BFFFFFF0000A19 (66 bit)] [INC: 0, 0] [TARGET: 1] [SPEED: 1691.25 MKey/s] [TOTAL: 6,186,598,400] [00:00:01][2023-06-19.21:22:23] [Info] Reached end of keyspace
[2023-06-19.21:22:23] [Info] Compression : compressed
[2023-06-19.21:22:23] [Info] Starting at : 000000000000000000000000000000000000000000000001FFFFFFFFF0000A1A (65 bit)
[2023-06-19.21:22:23] [Info] Ending at : 000000000000000000000000000000000000000000000003FFFFFFFFFFFFFFFF (66 bit)
[2023-06-19.21:22:23] [Info] Range : 000000000000000000000000000000000000000000000002000000000FFFF5E5 (66 bit)
[2023-06-19.21:22:23] [Info] Initializing NVIDIA GeForce RTX 3080
[2023-06-19.21:22:24] [Info] Generating 52,428,800 starting points (2000.0MB)
[2023-06-19.21:22:27] [Info] 10.0% 20.0% 30.0% 40.0% 50.0% 60.0% 70.0% 80.0% 90.0% 100.0%
[2023-06-19.21:22:29] [Info] Done
[DEV: NVIDIA GeForce R 9156/10239MB] [0000000000000000000000000000000000000000000000036D9FFFFFF0000A1A (66 bit)] [INC: 0, 0] [TARGET: 1] [SPEED: 1663.50 MKey/s] [TOTAL: 6,134,169,600] [00:00:01][2023-06-19.21:22:34] [Info] Reached end of keyspace
My data in my sheet in github did however reveal an interesting pattern. The decimals of all the private keys of every puzzle are within 12% to 49% of the base decimal (range)
how do you come up with this false claim? please show us the decimal value of the relative position for puzzles 38 and 60 as an example. And then... Well, what do you find ? I never thought bitcoin/blockchain technology will see a day where people are making efforts to brute force the only technology that we need to keep the way it is or just improve on the sides of network adoption, feasibility in terms of fees, p2p and KYC free adoption. This should be the development we need to have right now and not the other way around.
I see some negative implications of this idea. Irrespective of what others think I don’t like the idea of having brute force technology. It would be obvious that soon others will copy it and start misusing the same for their own benefit. Not sure if this is only for one time use but it’s bad idea.
By just reading it I’m frightened about my wallet security. Lolz.
First off, Doing this publicly will warn everyone about possible vulnerabilities and weaknesses, demonstrating to the world how we can find the keys of low range and exposed public keys will send the signal to everyone that they need to use standard and secure wallets to generate keys with high entropy and also never use an address more than once.I see some negative implications of this idea. Irrespective of what others think I don’t like the idea of having brute force technology. It would be obvious that soon others will copy it and start misusing the same for their own benefit. Not sure if this is only for one time use but it’s bad idea.
By just reading it I’m frightened about my wallet security. Lolz.
On the other hand, there are hundreds of thousands of bitcoins on exposed keys for years, nobody has managed to touch them.
If you want to be 100% assured of the safety of your coins, just store them on an address and when you are spending, don't use the same address as the return address, done and safe for a few billion years.😉
Hi all,
I've been working on a tool for brute-forcing Bitcoin private keys.
.....
The performance is good, but can likely be improved. On my hardware (GeForce GT 640) it gets 9.4 million keys per second compressed, 7.3 million uncompressed.
....
Thoughts?
Thanks!
I've been working on a tool for brute-forcing Bitcoin private keys.
.....
The performance is good, but can likely be improved. On my hardware (GeForce GT 640) it gets 9.4 million keys per second compressed, 7.3 million uncompressed.
....
Thoughts?
Thanks!
what I am going to say is purely theoretical, as I have never tried to brute force private keys.
I don´t think you will have any success doing this.
If you have enough hash power, you would probably make more money working as an honest node, mining.
Bitcoin protocol is secure enough. If it were brute force-able, bitcoin wouldn't be worth anything.
What i think you could do is to find a collision. If someone made an insecure private key, by just hashing some passphrase... maybe you could have some luck. I tried to do this once, but never found anything. I tried those terms like "wallet" "bitcoin". I found some addresses which used to have balances, but not anymore. But I was doing manually, like 1 address/3 minutes lol
If you could somehow at the same time check if any of those 9.4 million keys/sec have any balance in btc/bch/btg etc...
But I don't think any of that will work, and will be a waste of time and resources.
Jump to: