Python 更改Plutus.py的比特币钱包地址范围

我正在使用来自的以下脚本

该脚本适用于2^160范围内的钱包地址。我很好奇，在脚本中的什么地方可以将其更改为2^128范围或2^n范围。有可能有一扇窗户吗？比如2^0-2^100

不试图做任何恶意的事情，只是试图获取数据，以表明由于地址数量巨大，即使选择范围也是徒劳的

 # Plutus Bitcoin Brute Forcer
# Made by Isaac Delly
# https://github.com/Isaacdelly/Plutus

try:
    import sys
    import os
    import time
    import hashlib
    import binascii
    import multiprocessing
    from multiprocessing import Process, Queue
    from multiprocessing.pool import ThreadPool
    import threading
    import base58
    import ecdsa
    import requests
except ImportError:
    import subprocess
    subprocess.check_call(["python", '-m', 'pip', 'install', 'base58==1.0.0'])
    subprocess.check_call(["python", '-m', 'pip', 'install', 'ecdsa==0.13'])
    subprocess.check_call(["python", '-m', 'pip', 'install', 'requests==2.19.1'])
    import base58
    import ecdsa
    import requests

def generate_private_key():
    return binascii.hexlify(os.urandom(32)).decode('utf-8')

def private_key_to_WIF(private_key):
    var80 = "80" + str(private_key) 
    var = hashlib.sha256(binascii.unhexlify(hashlib.sha256(binascii.unhexlify(var80)).hexdigest())).hexdigest()
    return str(base58.b58encode(binascii.unhexlify(str(var80) + str(var[0:8]))), 'utf-8')

def private_key_to_public_key(private_key):
    sign = ecdsa.SigningKey.from_string(binascii.unhexlify(private_key), curve = ecdsa.SECP256k1)
    return ('04' + binascii.hexlify(sign.verifying_key.to_string()).decode('utf-8'))

def public_key_to_address(public_key):
    alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
    count = 0; val = 0
    var = hashlib.new('ripemd160')
    var.update(hashlib.sha256(binascii.unhexlify(public_key.encode())).digest())
    doublehash = hashlib.sha256(hashlib.sha256(binascii.unhexlify(('00' + var.hexdigest()).encode())).digest()).hexdigest()
    address = '00' + var.hexdigest() + doublehash[0:8]
    for char in address:
        if (char != '0'):
            break
        count += 1
    count = count // 2
    n = int(address, 16)
    output = []
    while (n > 0):
        n, remainder = divmod (n, 58)
        output.append(alphabet[remainder])
    while (val < count):
        output.append(alphabet[0])
        val += 1
    return ''.join(output[::-1])

def get_balance(address):
    try:
        response = requests.get("https://bitaps.com/api/address/" + str(address))
        return int(response.json()['balance']) 
    except:
        return -1

def data_export(queue):
    while True:
        private_key = generate_private_key()
        public_key = private_key_to_public_key(private_key)
        address = public_key_to_address(public_key)
        data = (private_key, address)
        queue.put(data, block = False)

def worker(queue):
    while True:
        if not queue.empty():
            data = queue.get(block = True)
            balance = get_balance(data[1])
            process(data, balance)

def process(data, balance):
    private_key = data[0]
    address = data[1]
    if (balance == 0):
        print("{:<34}".format(str(address)) + ": " + str(balance))
    if (balance > 0):
        file = open("plutus.txt","a")
        file.write("address: " + str(address) + "\n" +
                   "private key: " + str(private_key) + "\n" +
                   "WIF private key: " + str(private_key_to_WIF(private_key)) + "\n" +
                   "public key: " + str(private_key_to_public_key(private_key)).upper() + "\n" +
                   "balance: " + str(balance) + "\n\n")
        file.close()

def thread(iterator):
    processes = []
    data = Queue()
    data_factory = Process(target = data_export, args = (data,))
    data_factory.daemon = True
    processes.append(data_factory)
    data_factory.start()
    work = Process(target = worker, args = (data,))
    work.daemon = True
    processes.append(work)
    work.start()
    data_factory.join()

if __name__ == '__main__':
    try:
        pool = ThreadPool(processes = multiprocessing.cpu_count()*2)
        pool.map(thread, range(0, 10))
    except:
        pool.close()
        exit()

#Plutus比特币暴力工具
#由艾萨克·德利制作
# https://github.com/Isaacdelly/Plutus
尝试：
导入系统
导入操作系统
导入时间
导入hashlib
导入binascii
导入多处理
从多处理导入进程，队列
从multiprocessing.pool导入线程池
导入线程
进口基数58
导入ecdsa
导入请求
除恐怖外：
导入子流程
子进程。检查_调用（[“python”、'-m'，pip'，install'，base58==1.0.0']）
子进程。检查_调用（[“python”、'-m'，pip'，install'，ecdsa==0.13']）
子进程。检查_调用（[“python”、'-m'，pip'，install'，requests==2.19.1']）
进口基数58
导入ecdsa
导入请求
def生成私钥（）：
返回binascii.hexlify（os.uradom（32））.decode（'utf-8'）
def私钥到WIF（私钥）：
var80=“80”+str（私钥）
var=hashlib.sha256（binascii.unhexlify（hashlib.sha256（binascii.unhexlify（var80））.hexdigest（））.hexdigest（）
返回str（base58.b58encode（binascii.unexlify（str（var80）+str（var[0:8]）），'utf-8'）
def私钥到公钥（私钥）：
sign=ecdsa.SigningKey.from_string（binascii.unhexlify（private_key），curve=ecdsa.SECP256k1）
返回（'04'+binascii.hexlify（sign.verifying_key.to_string（））。解码（'utf-8'））
def公钥地址（公钥）：
字母表=“123456789abcdefghjklmnpqrstuvxyzabcdefghijkmnopqrstuvxyz”
计数=0；val=0
var=hashlib.new（'ripemd160'）
var.update（hashlib.sha256（binascii.unhexlify（public_key.encode（）））.digest（））
doublehash=hashlib.sha256（hashlib.sha256（binascii.unhexlify（（'00'+var.hexdigest（））.encode（））.digest（））.hexdigest（）
地址='00'+变量hexdigest（）+双哈希[0:8]
对于地址中的字符：
如果（字符！=“0”）：
打破
计数+=1
计数=计数//2
n=int（地址，16）
输出=[]
而（n>0）：
n、 余数=divmod（n，58）
output.append（字母表[余数]）
而（val打印（“{：您似乎误解了2^160位范围的用途

每个标准比特币地址都绑定到公钥的哈希160。哈希160的长度为160位，这就是为什么您的搜索空间为2^160。如果您能够找到两个公钥哈希160相等的私钥，则这两个私钥中的任何一个都可以将硬币发送到该地址

搜索较小的空间没有意义，因为您不再搜索比特币地址。如果您只想搜索随机哈希函数，则只需将RIPEMD160哈希函数替换为另一个具有任意比特大小输出的哈希函数即可

请注意，如果您这样做，那么其余关于检查余额等的代码将毫无用处，因为您的输出将不再是比特币地址