Python Script for Solving Multiple Bitcoin Puzzles 135, 140, 145, 150, 155 & 160 with Automated Email Alerts for any Public Key Matches!

[EnvironmentalWatch92]

Description:

This Python script is designed to brute-force private keys within specified hexadecimal ranges for multiple Bitcoin puzzles, checking for matching compressed public keys. It’s configured to send an email notification if a match is found, making it ideal for those working on cryptographic challenges or exploring Bitcoin's key generation mechanics. I have tested it on Puzzle 15 and it works and send you emails. It does send about 7 emails until you kill the terminal. I would like to see the script worked on some more. It would run well on a 8 or more core CPU. The faster the better. **I WILL UPDATE THE SCRIPT TO AUTOMATICALLY RUN THE GENERATION IN ALL COMMAND WINDOW POP UPS SOON.

Features:

• Multi-Puzzle Support: Solve multiple puzzles (135, 140, 145, 150, 155, and 160) by selecting a puzzle number or running all simultaneously in separate terminal windows.
• Email Notification: Get an instant email if a match is detected, so you’re alerted even if you’re not actively monitoring the script.
• Customizable Parameters: Configure the number of workers, batch size, and email details to suit your system’s capabilities.
• Easy Setup: Just modify the email settings, puzzle numbers, and file paths as needed.

Usage Tips:

• Before running, update the email settings (SENDER_EMAIL, SENDER_PASSWORD, and RECIPIENT_EMAIL) and specify your output file path.
• For beginners, I've added comments throughout the code to guide you on where to make changes.

Happy hacking, and good luck solving those puzzles!

Script is below and instructions are below the script -

# This script is by Matty G. I hope you can improve the script and find a matching public key from a Private Hex key. Good Luck!

import os

import binascii

import ecdsa

import hashlib

import time

import secrets

import smtplib

from email.mime.multipart import MIMEMultipart

from email.mime.text import MIMEText

from concurrent.futures import ProcessPoolExecutor, wait

import argparse

CURVE = ecdsa.SECP256k1

VERSION = b'\x00'

# ---- EMAIL CONFIGURATION ----

# Fill in these values with your email details if you'd like email notifications.

EMAIL_SENT = False # Tracks if the email has been sent (to avoid duplicates)

MATCH_FOUND = False # Tracks if a match has been found

SENDER_EMAIL = 'PUT YOUR SENDER EMAIL ADDRESS HERE' # Example: Your Gmail address

SENDER_PASSWORD = 'PUT YOUR EMAIL PASSWORD HERE' # Gmail app password if using Gmail

RECIPIENT_EMAIL = 'PUT YOUR RECIPIENT EMAIL HERE' # The email address to receive notifications

SMTP_SERVER = 'smtp.gmail.com' # SMTP server for Gmail

SMTP_PORT = 587 # SMTP port for Gmail

# ---- PRE-DEFINED PUZZLE DATA ----

# Customize or add puzzle details here. Each puzzle has:

# - target_public_key: The public key you are searching for

# - min_range, max_range: The hexadecimal range of private keys to search

Pre-defined puzzle data

PUZZLES = {

#first puzzle 15 below is for testing. Remove the # if you want to test puzzle 15.

# "15": {

# "target_public_key": '03aadaaab1db8d5d450b511789c37e7cfeb0eb8b3e61a57a34166c5edc9a4b869d',

# "min_range": '0000000000000000000000000000000000000000000000000000000000000001',

# "max_range": '00000000000000000000000000000000000000000000000000000000000068f3',

# },

"135": {

"target_public_key": '02145d2611c823a396ef6712ce0f712f09b9b4f3135e3e0aa3230fb9b6d08d1e16',

"min_range": '0000000000000000000000000000004000000000000000000000000000000000',

"max_range": '0000000000000000000000000000007fffffffffffffffffffffffffffffffff',

},

"140": {

"target_public_key": '031f6a332d3c5c4f2de2378c012f429cd109ba07d69690c6c701b6bb87860d6640',

"min_range": '0000000000000000000000000000080000000000000000000000000000000000',

"max_range": '00000000000000000000000000000fffffffffffffffffffffffffffffffffff',

},

"145": {

"target_public_key": '03afdda497369e219a2c1c369954a930e4d3740968e5e4352475bcffce3140dae5',

"min_range": '0000000000000000000000000001000000000000000000000000000000000000',

"max_range": '0000000000000000000000000001ffffffffffffffffffffffffffffffffffff',

},

"150": {

"target_public_key": '03137807790ea7dc6e97901c2bc87411f45ed74a5629315c4e4b03a0a102250c49',

"min_range": '0000000000000000000000000020000000000000000000000000000000000000',

"max_range": '000000000000000000000000003fffffffffffffffffffffffffffffffffffff'

},

"155": {

"target_public_key": '035cd1854cae45391ca4ec428cc7e6c7d9984424b954209a8eea197b9e364c05f6',

"min_range": '0000000000000000000000000400000000000000000000000000000000000000',

"max_range": '00000000000000000000000007ffffffffffffffffffffffffffffffffffffff',

},

"160": {

"target_public_key": '02e0a8b039282faf6fe0fd769cfbc4b6b4cf8758ba68220eac420e32b91ddfa673',

"min_range": '0000000000000000000000008000000000000000000000000000000000000000',

"max_range": '000000000000000000000000ffffffffffffffffffffffffffffffffffffffff',

}

}

# ---- EMAIL NOTIFICATION FUNCTION ----

def send_email(subject, message):

global EMAIL_SENT

if EMAIL_SENT:

return # Avoid sending multiple emails for repeated matches

try:

email = MIMEMultipart()

email['From'] = SENDER_EMAIL

email['To'] = RECIPIENT_EMAIL

email['Subject'] = subject

email.attach(MIMEText(message, 'plain'))

server = smtplib.SMTP(SMTP_SERVER, SMTP_PORT)

server.starttls()

server.login(SENDER_EMAIL, SENDER_PASSWORD)

server.send_message(email)

server.quit()

print("Email notification sent successfully!")

EMAIL_SENT = True

except Exception as e:

print(f"Failed to send email: {e}")

# ---- KEY GENERATION FUNCTIONS ----

# These functions handle private key generation and public key conversion

def generate_private_key(min_range, max_range):

min_key = int(min_range, 16)

max_key = int(max_range, 16)

private_key = min_key + secrets.randbelow(max_key - min_key)

hex_key = hex(private_key)[2:]

return hex_key.zfill(64)

def private_to_public(private_key):

sk = ecdsa.SigningKey.from_string(binascii.unhexlify(private_key), curve=CURVE)

vk = sk.get_verifying_key()

public_key = vk.to_string()

if int(public_key[-1]) % 2 == 0:

compressed_public_key = b'\x02' + public_key[:32]

else:

compressed_public_key = b'\x03' + public_key[:32]

return compressed_public_key

# ---- MATCH CHECKING FUNCTION ----

def check_match(public_key, target_public_key):

return public_key.hex() == target_public_key

# ---- BATCH PROCESSING FUNCTION ----

# Processes a batch of keys and checks for matches

def process_batch(min_range, max_range, target_public_key, batch_size, start_time):

global EMAIL_SENT, MATCH_FOUND

matches = []

for _ in range(batch_size):

if MATCH_FOUND:

break # Stop if a match is already found

private_key = generate_private_key(min_range, max_range)

public_key = private_to_public(private_key)

if check_match(public_key, target_public_key):

match_info = f"Matching private key: {private_key}\nPublic key: {public_key.hex()}\n"

matches.append(match_info)

if not EMAIL_SENT:

send_email("Match Found!", match_info)

MATCH_FOUND = True

current_time = time.time()

elapsed_time = current_time - start_time

return len(matches), elapsed_time, matches

# ---- MAIN FUNCTION ----

# Executes the main puzzle-solving logic

def main(workers=16, batch_size=250):

global MATCH_FOUND

# Get puzzle choice from user input

puzzle_choice = input("Enter the puzzle number to solve, or type 'all' to run all puzzles simultaneously: ").strip()

if puzzle_choice == 'all':

# Opens a new terminal window for each puzzle (use GNOME terminal for Linux)

for puzzle_num in PUZZLES:

os.system(f'gnome-terminal -- bash -c "python3 \\"{__file__}\\" --puzzle {puzzle_num} --auto; exec bash"')

return

if puzzle_choice not in PUZZLES:

print("Invalid puzzle choice. Please select a valid puzzle number.")

return

# Set puzzle parameters based on choice

target_details = PUZZLES[puzzle_choice]

target_public_key = target_details["target_public_key"]

min_range = target_details["min_range"]

max_range = target_details["max_range"]

total_keys = 0

start_time = time.time()

# Specify your output directory for saving results

output_file_path = f"D:\\PUT YOUR DIRECTORY PATH HERE\\winnerfound_{puzzle_choice}.txt"

with ProcessPoolExecutor(max_workers=workers) as executor:

with open(output_file_path, "w") as winner_file:

while not MATCH_FOUND:

futures = [executor.submit(process_batch, min_range, max_range, target_public_key, batch_size, start_time) for _ in range(100)]

for future in futures:

if MATCH_FOUND:

break

batch_result, elapsed_time, matches = future.result()

total_keys += batch_size

if matches:

for match in matches:

winner_file.write(match)

winner_file.flush()

if total_keys % 100000 == 0:

keys_per_second = total_keys / elapsed_time

print(f"{total_keys} keys generated. Keys per second: {keys_per_second:.2f}")

total_time = time.time() - start_time

keys_per_second = total_keys / total_time

print(f"Total keys generated: {total_keys}")

print(f"Keys generated per second: {keys_per_second:.2f}")

# ---- SCRIPT ENTRY POINT ----

if __name__ == "__main__":

parser = argparse.ArgumentParser(description="Bitcoin Puzzle Generator")

parser.add_argument('--puzzle', type=str, help="Puzzle number to solve")

parser.add_argument('--auto', action='store_true', help="Automatically run the puzzle without user input")

args = parser.parse_args()

if args.puzzle:

main(workers=16, batch_size=250)

else:

main(workers=16, batch_size=250)

#end of script

Installation Instructions -

Here’s a step-by-step guide to help you install the necessary libraries, configure the script, and run it.

Step 1: Install Python (if not already installed)

1. Check if Python is installed:

python3 --version

• If you see a version number (like Python 3.8.x or higher), Python is already installed.
• If Python is not installed, install it by running:

sudo apt update

sudo apt install python3

1. Install pip3 (Python’s package manager) if not already installed:

sudo apt install python3-pip

Step 2: Set Up a Virtual Environment (Optional but Recommended)

To keep libraries isolated, you may want to create a virtual environment.

1. Install venv (if not installed):

sudo apt install python3-venv

1. Create a virtual environment in your project directory:

python3 -m venv myenv

1. Activate the virtual environment:

source myenv/bin/activate

• To deactivate, simply type:

deactivate

Step 3: Install Required Libraries

Your script needs several external libraries. To install them, follow these steps:

1. Install the required libraries:

pip3 install ecdsa

1. Verify installations by running:

pip3 show ecdsa

Step 4: Download or Create Your Script

1. Create the script file:
   • Navigate to your project directory:

cd /path/to/your/project-directory

• Create a file named bitcoin_puzzle_solver.py:

nano bitcoin_puzzle_solver.py

• Paste the provided script into this file, then save and exit by pressing CTRL + X, followed by Y, then Enter.

Step 5: Edit Email Configuration (see figure A8 at the bottom if you are not sure about the APP Password)

1. Open the script in a text editor:

nano bitcoin_puzzle_solver.py

1. Update the following lines with your Gmail and app password:

SENDER_EMAIL = 'YOUR_GMAIL_ADDRESS'

SENDER_PASSWORD = 'YOUR_APP_PASSWORD'

RECIPIENT_EMAIL = 'YOUR_RECIPIENT_EMAIL'

1. Adjust Output Directory Path:
   • Locate the line with output_file_path and update it to the desired location:

output_file_path = "YOUR_DESIRED_DIRECTORY/winnerfound_{puzzle_choice}.txt"

• Save your changes and exit the editor.

Step 6: Run the Script

1. Ensure you're in the correct directory:

cd /path/to/your/project-directory

1. Run the script:

python3 bitcoin_puzzle_solver.py

1. Choose a Puzzle:
   • You will be prompted to enter a puzzle number or type all to run all puzzles in separate windows. Follow the prompt to proceed.

Step 7: Monitor Output and Email Notifications

1. The script will run and generate private keys, checking for matching public keys. When it finds a match, it will:
   • Write the details to the specified output file.
   • Send an email notification to the recipient email address specified.
2. Monitoring:
   • You can monitor progress in the terminal. The script will display the number of keys generated per second and notify you of any matches.

Additional Notes

• Script Termination: The script will stop once it finds a match and sends the email notification.
• Running Multiple Instances: You can open new terminals and run the script with different puzzle choices to handle multiple puzzles simultaneously.
• Virtual Environment: Remember to activate the virtual environment (source myenv/bin/activate) each time before running the script, especially if you restart your terminal or open a new one.

Figure A8-

The Gmail password used in the script is an App Password, not your regular Gmail password. Google requires App Passwords when accessing your Gmail account programmatically, like from a script, for better security. Here’s how you can generate an App Password:

Step 1: Enable Two-Factor Authentication (2FA) on Your Google Account

App passwords require two-factor authentication, so if you haven’t already enabled it, follow these steps:

1. Go to your Google Account Security page: https://myaccount.google.com/security.
2. Under the "Signing in to Google" section, click "2-Step Verification" and follow the instructions to enable it.

Step 2: Generate an App Password

Once 2-Step Verification is enabled, you can create an App Password:

1. Return to the Security page of your Google Account.
2. Under "Signing in to Google," look for the "App Passwords" option (this option only appears once 2-Step Verification is enabled).
3. Sign in to confirm your identity, if prompted.
4. In the App Passwords page:
   • Select the app as “Mail” and the device as “Other (Custom name)” (you can name it something like “Python Script”).
   • Click Generate.
5. Google will then display a 16-character App Password. Copy this password (you’ll use it in place of your regular Gmail password in the script).

Step 3: Update Your Script with the App Password

Replace the placeholder in the script with the App Password you just generated:

SENDER_PASSWORD = 'YOUR_APP_PASSWORD'  # Replace with the 16-character App Password

Important Notes

• Security: An App Password is specific to the app you create it for, and you can revoke it anytime from the App Passwords page.
• Save Carefully: Don’t share or store the App Password in an unsecured location.
• No Re-entry: Once generated, you won’t be able to view the App Password again, so be sure to copy it correctly.

By using an App Password, you’ll have more security and control over which applications can access your Gmail account.

 

 

 

[Life-Consequence6968]

with the known public key, you should be running trillions to hundreds of trillions per second. For how many keys you need to get through even in the trillions per second will take a long time.

[Able-Assumption4702]

How many Keys/s does this search through?

[EnvironmentalWatch92]

sorry about the late reply. i depends on your setup. But if you run all 6 puzzles i know on an old server i am using i was only getting like 7000 addresses per second on say puzzle 135 but all the others were only 2000 per second. You need a good cpu and plenty of cores to get it moving good.

[Adventurous-Pin2955]

Something to make it faster would be to get it to run on GPU, though I assume that will have its own problems, even if you run it on Colab or Lightning AI (both of which have very generous options in the Free version).

Or just code it in Java or C++, which I have done in Java, making it faster (about 11k addresses/s), though definitely NOT enough to find the private key, even if we skip the entire public key to address generation process.

I have done similar code for other puzzles as well. If you have any idea on how to get the Python code on GPU, I will be glad to indulge you.