Upload 5 files

README.md

@@ -1,55 +1,29 @@
 ---
-title: Bitcoin Wallet Recovery
+title: BTCRecover Streamlit
 emoji: 🔑
 colorFrom: blue
 colorTo: green
-sdk: streamlit
-sdk_version: 1.26.0 # Or your streamlit version
-app_file: app.py
+sdk: docker
 pinned: false
-license: mit # Or apache-2.0 if you prefer, consistent with btcrecover
+app_port: 8501 # Should match EXPOSE and CMD in Dockerfile
 ---
 
-# Bitcoin Wallet Password Recovery (via `btcrecover`)
+# Bitcoin Wallet (`wallet.dat`) Password Recovery Tool
 
-This Streamlit application provides a web interface to use `btcrecover` for attempting to recover passwords for Bitcoin `wallet.dat` files.
+This Space provides a web interface for `btcrecover` to help recover lost passwords for Bitcoin `wallet.dat` files.
 
-**[Link to the running Space (You'll add this after deploying)]**
+**How to Use:**
 
-## ⚠️ Important Disclaimers
+1.  Upload your `wallet.dat` file.
+2.  Upload a text file containing potential passwords (one per line) OR paste them directly into the text area.
+3.  Select any relevant options (e.g., `--no-strict-wallet-verify`).
+4.  Click "🚀 Start Recovery Attempt".
+5.  The output from `btcrecover` will be displayed in real-time.
 
-*   **SECURITY RISK**: Uploading your `wallet.dat` file to any online service, including this one, carries inherent security risks. This tool is intended for **educational and personal recovery purposes only**. Do NOT use it with wallets containing significant value unless you fully understand and accept the risks. The application processes files in temporary storage on the server.
-*   **RESOURCE LIMITS**: This application runs on Hugging Face Spaces, which has resource (CPU, memory, time) limitations. Password recovery, especially with large password lists, can be very time-consuming and CPU-intensive. Long-running tasks may be terminated. For extensive recovery attempts, it's highly recommended to run `btcrecover` locally on your own machine.
-*   **NO GUARANTEES**: The success of password recovery depends entirely on the quality and completeness of your password list and the complexity of the original password. This tool does not guarantee that your password will be found.
-*   **FOR YOUR OWN WALLETS ONLY**: Only use this tool on `wallet.dat` files that you legally own and have forgotten the password to.
+**⚠️ Important Limitations on Hugging Face Spaces:**
 
-## How to Use
+*   **Resource Intensive:** Password recovery is CPU-heavy. Free tier Spaces have limited resources.
+*   **Execution Timeouts:** Operations may be terminated if they run for too long (e.g., >30 minutes on free tier). This tool is **not suitable for large password lists or complex passwords** on this platform.
+*   **Security:** Your `wallet.dat` is uploaded to the server for processing. While this app doesn't store it permanently, be mindful of uploading sensitive data.
 
-1.  **Upload `wallet.dat`**: Use the sidebar to upload your encrypted `wallet.dat` file.
-2.  **Provide Passwords**:
-    *   **Upload a list**: Upload a `.txt` file containing potential passwords, one password per line.
-    *   **Enter manually**: Type or paste potential passwords directly into the text area, one per line.
-3.  **Options (Optional)**:
-    *   Check `Use '--no-strict-wallet-verify'` if you are dealing with a very old wallet or if `btcrecover` reports issues with wallet integrity.
-4.  **Start Recovery**: Click the "Start Recovery Process" button.
-5.  **Monitor Output**: The application will display the live log from `btcrecover`. This process can take a significant amount of time.
-6.  **Result**: If a password is found, it will be displayed. Otherwise, a "not found" message or error will be shown.
-
-## Technical Details
-
-This application uses:
-*   [Streamlit](https://streamlit.io/) for the web interface.
-*   [btcrecover](https://github.com/gurnec/btcrecover) as the backend engine for password recovery.
-
-The uploaded files are stored temporarily on the server for processing by `btcrecover` and are deleted after the attempt.
-
-## Local Development
-
-1.  Clone this repository.
-2.  Create a virtual environment: `python -m venv venv && source venv/bin/activate` (or `venv\Scripts\activate` on Windows).
-3.  Install dependencies: `pip install -r requirements.txt`.
-4.  Run the Streamlit app: `streamlit run app.py`.
-
-## Acknowledgment
-
-This tool is a wrapper around the powerful `btcrecover` utility. Please consider supporting its original author.
+This tool is primarily for educational purposes or for attempting recovery with very small, targeted password lists on Hugging Face Spaces. For serious recovery attempts, running `btcrecover` locally on a more powerful machine is recommended.

app.py

@@ -1,148 +1,168 @@
 import streamlit as st
 import subprocess
-import os
 import tempfile
-from wallet_utils import find_btcrecover_executable # Or paste the function directly here
+import os
+import shutil
 
 # --- Configuration ---
-DEFAULT_WALLET_FILENAME = "wallet.dat"
+APP_TITLE = "Bitcoin Wallet.dat Password Recovery (btcrecover)"
+APP_INTRO = """
+Upload your `wallet.dat` file and a password list to attempt recovery.
+This tool uses `btcrecover` in the backend.
+"""
+WARNING_TEXT = """
+**⚠️ Important Considerations for Hugging Face Spaces:**
+- **Resource Limits:** Hugging Face Spaces (especially free tier) have CPU, memory, and execution time limits.
+- **Execution Time:** Password recovery can be very time-consuming. Long-running jobs might be terminated. This tool is best for very small password lists or educational purposes on this platform.
+- **Security:** Your `wallet.dat` file is uploaded to the server for processing. While not stored permanently by this app, please be aware of this.
+- **Patience:** The process can be slow. Output will stream below.
+"""
+
+def find_btcrecover_executable():
+    """Tries to find the btcrecover executable."""
+    executable = shutil.which("btcrecover")
+    if executable:
+        return executable
+    # Fallback for some environments, though `shutil.which` should work in Docker with PATH set
+    possible_paths = [
+        "/usr/local/bin/btcrecover",
+        os.path.expanduser("~/.local/bin/btcrecover")
+    ]
+    for path in possible_paths:
+        if os.path.exists(path) and os.access(path, os.X_OK):
+            return path
+    return None
+
+def run_btcrecover(wallet_path, password_list_path, btcrecover_exe, extra_args=None):
+    """Runs btcrecover and streams its output."""
+    command = [
+        btcrecover_exe,
+        "--walletfile", wallet_path,
+        "--passwordlist", password_list_path,
+    ]
+    if extra_args:
+        command.extend(extra_args)
+
+    st.info(f"Executing: {' '.join(command)}")
+    
+    # Placeholder for real-time output
+    output_placeholder = st.empty()
+    log_output = ""
 
-# --- Helper Functions ---
-# If not using wallet_utils.py, paste find_btcrecover_executable here.
+    try:
+        process = subprocess.Popen(
+            command,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT, # Combine stdout and stderr
+            text=True,
+            bufsize=1, # Line buffered
+            universal_newlines=True
+        )
 
-# --- Streamlit UI ---
-st.set_page_config(page_title="Bitcoin Wallet Recovery", layout="wide")
-
-st.title("🔑 Bitcoin Wallet Password Recovery Tool (via btcrecover)")
-st.markdown("""
-**Disclaimer:**
-- **Security Risk:** Uploading your `wallet.dat` file to any online service carries inherent security risks. Use with caution and only with wallets you are comfortable exposing in this manner. This tool is intended for educational and personal recovery purposes.
-- **Resource Limits:** This tool runs on a shared environment (Hugging Face Spaces). Long recovery processes with large password lists may be slow or terminated due to resource limits. For extensive searches, running `btcrecover` locally is recommended.
-- **No Guarantees:** Password recovery success depends entirely on the quality of your password list and the original password's complexity.
-""")
-st.markdown("---")
+        if process.stdout:
+            for line in iter(process.stdout.readline, ''):
+                log_output += line
+                output_placeholder.code(log_output, language="text") # Update placeholder with cumulative log
+                if "Password found:" in line:
+                    st.balloons()
+                    st.success(f"🎉 Password potentially found! Check logs above. Line: {line.strip()}")
+                elif "Password not found" in line and "exhaustive" in line:
+                    st.warning("Password not found in the list after exhaustive search by btcrecover.")
+            process.stdout.close()
+        
+        return_code = process.wait()
 
-# --- Inputs ---
-st.sidebar.header("Configuration")
-uploaded_wallet_file = st.sidebar.file_uploader("1. Upload your `wallet.dat` file", type=["dat"])
+        if return_code != 0 and "Password found:" not in log_output:
+            st.error(f"btcrecover exited with error code {return_code}. Check the logs.")
+        elif "Password found:" not in log_output and ("Password not found" not in log_output or "exhaustive" not in log_output) :
+            # If no "Password found" and no clear "not found" message from btcrecover, it might be an unknown state or early exit
+             st.info("btcrecover finished. Please review the logs above to determine the outcome.")
 
-password_source = st.sidebar.radio(
-    "2. Provide Passwords:",
-    ("Upload a password list (.txt)", "Enter passwords manually")
-)
 
-passwords = []
-uploaded_password_file = None
-manual_passwords_text = ""
+    except FileNotFoundError:
+        st.error(f"Error: btcrecover executable not found at '{btcrecover_exe}'. Ensure it's installed and in PATH.")
+    except Exception as e:
+        st.error(f"An unexpected error occurred: {str(e)}")
+        st.code(log_output, language="text") # Show any logs gathered so far
 
-if password_source == "Upload a password list (.txt)":
-    uploaded_password_file = st.sidebar.file_uploader("Upload your password list (one password per line)", type=["txt"])
+# --- Streamlit UI ---
+st.set_page_config(page_title=APP_TITLE, layout="wide")
+st.title(APP_TITLE)
+st.markdown(APP_INTRO)
+st.warning(WARNING_TEXT)
+
+btcrecover_exe = find_btcrecover_executable()
+if not btcrecover_exe:
+    st.error("`btcrecover` executable not found in the environment. The application cannot proceed.")
+    st.stop()
 else:
-    manual_passwords_text = st.sidebar.text_area("Enter passwords (one per line)", height=150)
-
-use_no_strict_verify = st.sidebar.checkbox(
-    "Use '--no-strict-wallet-verify' (for old/potentially corrupt wallets)",
-    value=False,
-    help="Useful if btcrecover complains about wallet integrity or if it's a very old wallet."
-)
-
-# --- Execution ---
-output_placeholder = st.empty()
-result_placeholder = st.empty()
-
-if st.sidebar.button("🚀 Start Recovery Process", type="primary"):
-    if not uploaded_wallet_file:
-        st.error("🚨 Please upload a `wallet.dat` file.")
-        st.stop()
-
-    if uploaded_password_file:
-        passwords = [line.decode('utf-8', errors='ignore').strip() for line in uploaded_password_file.readlines() if line.strip()]
-    elif manual_passwords_text:
-        passwords = [line.strip() for line in manual_passwords_text.split('\n') if line.strip()]
-    else:
-        st.error("🚨 Please provide passwords either by uploading a list or entering them manually.")
-        st.stop()
+    st.sidebar.success(f"btcrecover found: {btcrecover_exe}")
 
-    if not passwords:
-        st.error("🚨 The password list is empty.")
-        st.stop()
 
-    btcrecover_exe = find_btcrecover_executable()
-    if not btcrecover_exe:
-        st.error("CRITICAL: `btcrecover` executable not found. Ensure it's installed in the environment.")
-        st.stop()
+# File Uploaders
+st.sidebar.header("1. Upload Files")
+uploaded_wallet_file = st.sidebar.file_uploader("Upload wallet.dat", type=['dat', 'wallet'])
+uploaded_password_list = st.sidebar.file_uploader("Upload password list (text file, one password per line)", type=['txt', 'list'])
 
-    # Create temporary files for wallet and password list
-    # These will be automatically deleted when closed or when the 'with' block exits.
-    # btcrecover needs file paths, so we can't just pass bytes.
-    # delete=False is important here because Popen needs to access the file after it's written.
-    # We'll manually delete them in a finally block.
+# Or provide passwords directly in a textarea
+st.sidebar.markdown("--- OR ---")
+passwords_text_area = st.sidebar.text_area("Paste passwords (one per line)", height=150,
+                                           help="If you provide passwords here, the uploaded password list will be ignored.")
 
-    tmp_wallet_file = None
-    tmp_password_list_file = None
+st.sidebar.header("2. Options")
+no_strict_verify = st.sidebar.checkbox("Disable strict wallet verification (`--no-strict-wallet-verify`)",
+                                       help="Useful for very old or slightly non-standard wallet.dat files.")
+# processes_auto = st.sidebar.checkbox("Use multiple processes if available (`--processes auto`)",
+#                                        help="Might be limited by Hugging Face Spaces resources.")
 
-    try:
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".dat") as twf:
-            twf.write(uploaded_wallet_file.getvalue())
-            tmp_wallet_file_path = twf.name
-
-        with tempfile.NamedTemporaryFile(delete=False, mode="w", encoding="utf-8", suffix=".txt") as tpf:
-            for p in passwords:
-                tpf.write(p + "\n")
-            tmp_password_list_file_path = tpf.name
-
-        command = [
-            btcrecover_exe,
-            "--walletfile", tmp_wallet_file_path,
-            "--passwordlist", tmp_password_list_file_path
-        ]
-        if use_no_strict_verify:
-            command.append("--no-strict-wallet-verify")
-        # command.append("--no-eta") # Optional: for cleaner output if ETA is not desired
-
-        st.info(f"ℹ️ Starting `btcrecover` with {len(passwords)} passwords...")
-        st.markdown(f"**Command:** `{' '.join(command)}` (paths are temporary)")
-        st.markdown("---")
-        output_placeholder.markdown("### Recovery Log:")
-        log_output_area = st.empty() # For streaming output
-
-        full_log = ""
-        found_password_str = None
-
-        process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, universal_newlines=True)
 
-        if process.stdout:
-            with st.spinner("⏳ `btcrecover` is running... This may take a while."):
-                for line in iter(process.stdout.readline, ''):
-                    full_log += line
-                    log_output_area.code(full_log, language=None) # Display live log
-                    if "Password found:" in line:
-                        found_password_str = line.split("Password found:", 1)[1].strip()
-                        # Don't break, let btcrecover finish its output if any
-                    if process.poll() is not None: # Process finished
-                        break
-            process.stdout.close()
-        return_code = process.wait()
-        log_output_area.code(full_log, language=None) # Display final log
-
-        st.markdown("---")
-        if found_password_str:
-            result_placeholder.success(f"🎉 **PASSWORD FOUND:** `{found_password_str}`")
-        elif return_code == 0: # btcrecover might exit 0 even if not found
-            result_placeholder.warning("⚠️ Password not found in the provided list (btcrecover completed).")
-        else:
-            result_placeholder.error(f"🚫 `btcrecover` exited with an error (code: {return_code}). Password likely not found or an issue occurred.")
-            st.info("Check the log above for details. Common issues: wallet format, corrupted wallet (try --no-strict-wallet-verify).")
-
-    except Exception as e:
-        st.error(f"An unexpected error occurred: {e}")
-    finally:
-        # Clean up temporary files
-        if tmp_wallet_file_path and os.path.exists(tmp_wallet_file_path):
-            os.remove(tmp_wallet_file_path)
-        if tmp_password_list_file_path and os.path.exists(tmp_password_list_file_path):
-            os.remove(tmp_password_list_file_path)
+if st.sidebar.button("🚀 Start Recovery Attempt"):
+    if not uploaded_wallet_file:
+        st.error("Please upload a wallet.dat file.")
+    elif not uploaded_password_list and not passwords_text_area.strip():
+        st.error("Please upload a password list file OR paste passwords into the text area.")
+    else:
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".dat") as tmp_wallet, \
+             tempfile.NamedTemporaryFile(mode="w+", delete=False, suffix=".txt") as tmp_passlist:
+
+            # Save uploaded wallet to a temporary file
+            tmp_wallet.write(uploaded_wallet_file.getvalue())
+            tmp_wallet_path = tmp_wallet.name
+
+            # Prepare password list
+            if passwords_text_area.strip():
+                tmp_passlist.write(passwords_text_area.strip())
+            else:
+                tmp_passlist.write(uploaded_password_list.getvalue().decode())
+            tmp_passlist_path = tmp_passlist.name
+            
+            # Ensure files are closed before btcrecover tries to access them
+            tmp_wallet.close()
+            tmp_passlist.close()
+
+            st.info(f"Wallet file saved to: {tmp_wallet_path}")
+            st.info(f"Password list saved to: {tmp_passlist_path}")
+
+            extra_args = []
+            if no_strict_verify:
+                extra_args.append("--no-strict-wallet-verify")
+            # if processes_auto: # Be cautious with this on shared resources
+            #     extra_args.append("--processes")
+            #     extra_args.append("auto")
+
+            with st.spinner("Attempting password recovery... Please wait. This can take a very long time."):
+                run_btcrecover(tmp_wallet_path, tmp_passlist_path, btcrecover_exe, extra_args)
+
+            # Clean up temporary files
+            try:
+                os.unlink(tmp_wallet_path)
+                os.unlink(tmp_passlist_path)
+                st.caption(f"Cleaned up temporary files: {os.path.basename(tmp_wallet_path)}, {os.path.basename(tmp_passlist_path)}")
+            except Exception as e:
+                st.warning(f"Could not clean up temporary files: {e}")
+else:
+    st.info("Upload your files and click 'Start Recovery Attempt' in the sidebar.")
 
 st.markdown("---")
-st.markdown("Crafted for educational and recovery purposes. Use responsibly.")
-st.markdown("Consider supporting the original `btcrecover` tool: [btcrecover on GitHub](https://github.com/gurnec/btcrecover)")
+st.markdown("Powered by [btcrecover](https://github.com/gurnec/btcrecover) and [Streamlit](https://streamlit.io/).")
+st.markdown("Remember the limitations when running on free cloud platforms.")

requirements.txt

@@ -1,2 +1,3 @@
 streamlit
-btcrecover
+btcrecover
+# requests # btcrecover might pull this or similar, good to list explicitly if known