I never trust other people's code. Only the programs I write myself are the most stable. Reward address: 1JWM1RsRFuct6y9JCwhx3TibvhDJVB2Ldn
import hashlib
import ecdsa
import base58
import threading
import logging
# 设置日志记录
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(threadName)s - %(message)s')
# 匹配的固定地址（写在代码中）
addresses_in_code = [
"1BY8GQbnueYofwSuFAT3USAhGjPrkxDdW9",
"1MVDYgVaSN6iKKEsbzRUAYFrYJadLYZvvZ",
"19vkiEajfhuZ8bs8Zu2jgmC6oqZbWqhxhG",
"19YZECXj3SxEZMoUeJ1yiPsw8xANe7M7QR",
"1PWo3JeB9jrGwfHDNpdGK54CRas7fsVzXU",
"1JTK7s9YVYywfm5XUH7RNhHJH1LshCaRFR",
"12VVRNPi4SJqUTsp6FmqDqY5sGosDtysn4"
]
# 生成私钥对应的比特币地址
def private_key_to_address(private_key_hex):
private_key_bytes = bytes.fromhex(private_key_hex)
signing_key = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)
verifying_key = signing_key.verifying_key
pub_key = b'\x04' + verifying_key.to_string() # 非压缩公钥格式
# 计算公钥的哈希 (SHA256 + RIPEMD160)
sha256_hash = hashlib.sha256(pub_key).digest()
ripemd160_hash = hashlib.new('ripemd160', sha256_hash).digest()
# 添加比特币网络前缀
network_byte = b'\x00' + ripemd160_hash
checksum = hashlib.sha256(hashlib.sha256(network_byte).digest()).digest()[:4]
binary_address = network_byte + checksum
return base58.b58encode(binary_address).decode()
# 按顺序递增生成私钥
def generate_private_keys_in_range(start_key_int, end_key_int):
for key_int in range(start_key_int, end_key_int + 1): # 递增 +1 生成私钥
private_key_hex = format(key_int, '064x')
yield private_key_hex
# 多线程生成私钥并匹配地址
def generate_and_match_private_keys(start_key_int, end_key_int):
for private_key_hex in generate_private_keys_in_range(start_key_int, end_key_int):
address = private_key_to_address(private_key_hex)
# 匹配地址
if address in addresses_in_code:
logging.info(f"匹配成功: 私钥 {private_key_hex} 对应地址 {address}")
# 匹配成功后立即写入 add.txt 文件
with open('add.txt', 'a') as f_add:
f_add.write(f"{private_key_hex},{address}\n")
else:
logging.info(f"未匹配: 私钥 {private_key_hex} 对应地址 {address}")
# 计算私钥区间的差值并划分成320份
def divide_key_range_into_parts(start_key, end_key, num_parts):
start_int = int(start_key, 16)
end_int = int(end_key, 16)
total_range = end_int - start_int # 修改为递增范围
part_size = total_range // num_parts # 每个线程的区间大小
return [(start_int + i * part_size, start_int + (i + 1) * part_size - 1) for i in range(num_parts)]
# 启动320个线程，每个线程负责生成区间内的私钥
def start_threads_for_key_range(start_key, end_key, num_threads=320):
key_ranges = divide_key_range_into_parts(start_key, end_key, num_threads)
threads = []
for i, (start_key_int, end_key_int) in enumerate(key_ranges):
t = threading.Thread(target=generate_and_match_private_keys, args=(start_key_int, end_key_int), name=f"线程-{i+1}")
threads.append(t)
t.start()
try:
for t in threads:
t.join()
except KeyboardInterrupt:
logging.info("捕获到 KeyboardInterrupt, 正在终止线程...")
# 主程序入口
if __name__ == "__main__":
start_key = "00000000000000000000000000000000000000000000001b8f59c6c922e5426d"
end_key = "00000000000000000000000000000000000000000000002c4221111a7294a017"
try:
# 启动320个线程，每个线程负责相应的私钥区间
start_threads_for_key_range(start_key, end_key, num_threads=320)
except KeyboardInterrupt:
logging.info("程序手动终止")
os._exit(0)
I never trust other people's code. Only the programs I write myself are the most stable.（linux）
Reward address: 1JWM1RsRFuct6y9JCwhx3TibvhDJVB2Ldn
import hashlib
import binascii
import base58
import threading
import ecdsa
# 匹配的比特币地址列表
target_addresses = {
"1MVDYgVaSN6iKKEsbzRUAYFrYJadLYZvvZ",
"19vkiEajfhuZ8bs8Zu2jgmC6oqZbWqhxhG"
}
# 初始私钥列表（8个私钥）
initial_private_keys = [
"000000000000000000000000000000000000000000000024351b116fe05a4ef1",
"00000000000000000000000000000000000000000000001b0f680b1092d881e6",
"00000000000000000000000000000000000000000000001c478360fcc5f7e4c3",
"00000000000000000000000000000000000000000000001de29e256292c39398",
"000000000000000000000000000000000000000000000024351b116fe05a426d",
"0000000000000000000000000000000000000000000000288707c8ae1738f142",
"000000000000000000000000000000000000000000000020cbae528b05b2a017",
"00000000000000000000000000000000000000000000001ea2011cc8a10e4eec"
]
# 检查私钥是否符合规则（不允许三个连续相同的字符）
def is_valid_key_suffix(private_key_hex):
for i in range(len(private_key_hex) - 2):
if private_key_hex
== private_key_hex[i + 1] == private_key_hex[i + 2]:
return False
return True
# 生成比特币地址（P2PKH Legacy）
def pubkey_to_address(public_key):
sha256_hash = hashlib.sha256(public_key).digest()
ripemd160_hash = hashlib.new('ripemd160', sha256_hash).digest()
extended_ripemd160 = b'\x00' + ripemd160_hash # 比特币地址前缀 0x00
checksum = hashlib.sha256(hashlib.sha256(extended_ripemd160).digest()).digest()[:4]
binary_address = extended_ripemd160 + checksum
return base58.b58encode(binary_address).decode()
# 生成公钥（压缩）
def private_key_to_public_key(private_key_hex):
private_key_bytes = binascii.unhexlify(private_key_hex)
sk = ecdsa.SigningKey.from_string(private_key_bytes, curve=ecdsa.SECP256k1)
vk = sk.verifying_key
public_key = b'\x02' + vk.to_string()[:32] if int.from_bytes(vk.to_string()[32:], 'big') % 2 == 0 else b'\x03' + vk.to_string()[:32]
return public_key
# 线程函数：从初始私钥开始递减，并生成对应的比特币地址
def worker_thread(start_private_key, thread_id):
private_key_int = int(start_private_key, 16)
total_generated = 0
matched_count = 0
while True:
private_key_hex = format(private_key_int, '064x')
# 检查私钥是否符合规则
if is_valid_key_suffix(private_key_hex):
public_key = private_key_to_public_key(private_key_hex)
address = pubkey_to_address(public_key)
# 检查生成的地址是否在目标地址列表中
if address in target_addresses:
with open("add.txt", "a") as f:
f.write(f"Private Key: {private_key_hex}, Address: {address}\n")
matched_count += 1
private_key_int -= 1
total_generated += 1
# 打印每个线程生成的私钥总数
if total_generated % 100000 == 0:
print(f"Thread {thread_id}: Total keys generated: {total_generated}, Matched: {matched_count}", end='\r')
# 启动8个线程，每个线程从不同的私钥开始递减
def start_threads():
threads = []
for idx, initial_key in enumerate(initial_private_keys):
t = threading.Thread(target=worker_thread, args=(initial_key, idx + 1))
threads.append(t)
t.start()
for t in threads:
t.join()
# 启动程序
if __name__ == "__main__":
start_threads()
