BitCrack - A tool for brute-forcing private keys

[kewa07]

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

[NotATether]

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?

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.

[nomachine]

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

We can utilize multiprocessing instead of threading. Multiprocessing allows us to take advantage of multiple CPU cores and achieve better parallelism. Also, we can optimize the search_for_key function by reducing unnecessary calculations within the loop.  There is a potential bottleneck that can be accelerated. The bottleneck lies in the line where a random integer is generated using os.urandom(32).  We can generate a batch of random numbers in advance and use these numbers in the search_for_key function instead of generating a new random number for each iteration.

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.")

But no matter how you turn it and perfect it, it takes a couple of million years to reach the result.

[ripemdhash]

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

[digaran]

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.

[ripemdhash]

my answer was to nomachine

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.")

he import :

Code:

from bitcoinlib.encoding import addr_to_pubkeyhash, to_hexstring
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

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:

which taking time.   

 

[tgfx]

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?

[COBRAS]

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

[JamiePoc]

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]

[GR Sasa]

What was the peak temperature that your 4090 reached using bitcrack?

[JamiePoc]

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%.

[GR Sasa]

My 2080 once reached 88 Celsius.

I don't think 79 was that bad lol,

but both are hot definitely!

[coolindark]

That will be nothing wrong until you reach and use with 90c all the time.
Also, the main problem is not the GPU temprature; it is VRM. Do not trust 60 degrees. Check your VRM temps.

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%.

[digaran]

This paper talks about something about using prime number spirals to break private key cryptography.

Not cool to post a suspicious link to some unknown blog, you should highlight the important parts and post them instead. But something tells me, if who ever wrote that paper knew how to crack private keys, he wouldn't publish it.😉

[COBRAS]

Hello

how many time will take search 2000 ranges in 55 bit ?

Thank You

[digaran]

Hello

how many time will take search 2000 ranges in 55 bit ?

Thank You

You mean dividing 2^55 by 2000 ranges? Well in that case it would take exactly the same as searching 2^55,  total range, if your ranges have specific size, then you should tell us their size or just multiply your range by 2000 and then divide the result by your speed per second, the answer would be seconds taking to search your range. Then divide 60 to get minutes, again divide by 60 to get hours, then divide by 24 to get days, /365 to get years etc, but you already knew that right?

[COBRAS]

Hello

how many time will take search 2000 ranges in 55 bit ?

Thank You

You mean dividing 2^55 by 2000 ranges? Well in that case it would take exactly the same as searching 2^55,  total range, if your ranges have specific size, then you should tell us their size or just multiply your range by 2000 and then divide the result by your speed per second, the answer would be seconds taking to search your range. Then divide 60 to get minutes, again divide by 60 to get hours, then divide by 24 to get days, /365 to get years etc, but you already knew that right?

no, I talk about 2000 pcs of 2**55. "2**55 * 2000 " = ?

??
...


What I'm talk about.

66 puzzle, I know what one of 2000 ranges, differ from 66 ouzzle range for 10 bit, and difference in range 2**55 . My idea was take 2000 end ranges (one by one) and  subtract 2**55 from all of them and search in this 2000 ranged and get 66 puzzzle.....


this example with difference from 66 bit to one of end range is 2**45:

4473851742395 5093917
6674995201175590393
6674990727323847998
25033953356734 5329065
6675015761277204732
6674990727323847998
17273917703686 6208005
6675008001241551684
6674990727323847998
18833788691815 6540667
6675009561112539813
6674990727323847998


4473851742395 -difference betwen end range and 2**66 bit puz ,she is <=2**45;

 5093917 range number
6674995201175590393 -  END  of range

6674990727323847998 - target 2**66 priv

[digaran]

I don't really understand what you trying to say, but from what I did understand,  here is 2^55 * 2000 = 72057594037927936000   and this is 2^66 =  73786976294838206464  difference between them is = 1729382256910270464

Before I loose my mind, let me give you what you initially asked, searching  2000 ranges with size of 2^55, with speed rate of 1 billion per second will take around 2284 years to brute force.

Edit: with 1000Bk/s, you can search that range in 833 days, and that's not even the entire 66 bit range.

[COBRAS]

I don't really understand what you trying to say, but from what I did understand,  here is 2^55 * 2000 = 72057594037927936000   and this is 2^66 =  73786976294838206464  difference between them is = 1729382256910270464

Before I loose my mind, let me give you what you initially asked, searching  2000 ranges with size of 2^55, with speed rate of 1 billion per second will take around 2284 years to brute force.

you understand me right

I asking about time need to....

thank you for you answer

[CatalanaBTC]

Good afternoon, I hope everything is well.

My idea is the following:

I have a BTC.txt file, which has all addresses with a balance greater than 0 starting with 1 (both compressed and uncompressed) (BTC.TXT IS 19 GB AND has 1 btc address in each line)

I want to run bitcrack, VanBitCracken or VBCr which work perfectly, but when I put -i btc.txt, in bitcrack it stays loading for about 6 hours and is removed, and in VanBitCracken and VBCr it doesn't seem to read it directly

I would like to know if I can modify the exe file from either bitcrack, VanBitCracken or VBCr to perform my search or is there another program?


PS: Create a code in python that more or less does the following:

Creates a random 32 byte hex key, then converts it to its respective WIF key both compressed and decompressed, then checks if the compressed and decompressed address of that address matches any address in btc.txt, if so it saves it to found. txt, if it does not find anything it will continue searching until it finds a match OR until it stops the program. What I mean is that in python I have achieved my goal and I would like to do the same but with my gpu

This is the result of my python file WITHOUT GPU and using 4 processors out of 16:

Generated: 20400000 (SHA-256 - HEX)
Last generated key in hexadecimal: 13d0f03fab9c75a97fa6492b8b832b0ce7b11b8cc30f25e8eb1164b9fbc57ded
Compressed Bitcoin address: 1LZfGfy88QjBVkB3DTqpjFwonStb93Bed4
Decompressed Bitcoin address: 1DUXqLAJch8pncVKf63HZBefaKT3b81p5E
Generation rate: 4497.490059165694 keys per second

Generated: 20500000 (SHA-256 - HEX)
Last key generated in hexadecimal: f55599ce4720d4061894e644b99e190ffebb758c7780572e43651e9d622c2f69
Compressed Bitcoin address: 1Nr4BuyWgxS6Bmd4WzUZrkRFZHM6FQcqXp
Decompressed Bitcoin address: 1FgYyC5RAQwr8AUqHH7CP7Sx52avAJYtb
Generation rate: 4572.502992815531 keys per second



PD: I am aware of the difficulty and luck it takes to get 1 match that is very very very unlikely, but I know what I want and that is it Smiley

PD2: If necessary, I could search O randomly OR sequentially, for example I would put from 20% to 40% of the total range, I would scan that range randomly and sequentially for a few days or weeks, and then I would go to the range 40% 60% and so and one last question



Excuse my English, I am from BCN (SPAIN) and I only speak Spanish and Catalan, so my English is translated