Bitcoin Forum

from ecpy.curves     import Curve,Point
cv = Curve.get_curve('secp256k1')

G  = Point(0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798,
           0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8,
           cv)

startKey = 0x12345678
startKeyPub = G * startKey
lucky_pub = "02A88049484BBD7DC717FF0414262F03074E784BBBF86DF052933104A2DFE6AD86"

for i in range(0, 1000):
    startKeyPub = startKeyPub + G * (i * 1000000)
    if startKeyPub == lucky_pub:
        print(hex(startKey + (i * 1000000)))
        break

import hashlib
import base58

def sha256(arg) :
	byte_array = bytearray.fromhex(arg)
	m = hashlib.sha256()
	m.update(byte_array)
	return m.hexdigest()

def ripemd160(arg):
    h = hashlib.new('ripemd160')
    h.update(bytearray.fromhex(arg))
    return h.hexdigest()

def final_hash(arg):
    h256 = sha256(arg)
    h160 = ripemd160(h256)
    tmp = "00" + h160
    checksum = sha256(sha256(tmp))[:8]
    return tmp + checksum

def getAddress(arg):
    h = final_hash(arg)
    return base58.b58encode(bytes.fromhex(h)).decode('utf-8')

targetAddress = "INSERT_YOUR_ADDRESS"

file = open('your_file_with_pubkeys.txt', 'r')

for line in file:
    pk = line.strip()
    if getAddress(pk) == targetAddress:
         print("The Public Key for address " + targetAddress + " is : " + pk )

 
file.close()

import multiprocessing
import hashlib
import binascii
from Crypto.Util.number import long_to_bytes, bytes_to_long

start_hex = '0000000000000000000000000000000000000000000000000000000000000000'
end_hex = '0000000000000000000000000000000000000000000000000000000000000000'
start = int(start_hex, 16)
end = int(end_hex, 16)
num_parts = 4

def kangaroo(start, end, pubkeys):
    G = 2
    hash_size = 256
    max_iters = 2**32

    def H(x):
        if isinstance(x, bytes):
            return hashlib.sha256(x).digest()
        else:
            return hashlib.sha256(x.to_bytes((x.bit_length() + 7) // 8, byteorder='big')).digest()




    def kangaroo_algorithm(x1, x2, step):
        x = x1
        xs = set()
        for i in range(max_iters):
            x = (x + step) % end
            h = bytes_to_long(H(long_to_bytes(x)))
            if h in pubkeys:
                return x, pubkeys[h]
            xs.add(x)
            if len(xs) == hash_size:
                xs.clear()
                y = x2
                for j in range(i):
                    y = (y + step) % end
                    if y in xs:
                        return x, None
        return None, None

    step = end // hash_size
    x1 = start
    x2 = start + step
    private_key, public_key = kangaroo_algorithm(x1, x2, step)
    if private_key is not None:
        private_hex = hex(private_key)[2:]
        private_hex = '0' * (64 - len(private_hex)) + private_hex
        return (private_key, private_hex, public_key)
    else:
        return None

if __name__ == '__main__':
    pubkeys_file = 'pubkeys.txt'
    foundkeys_file = 'foundkeys.txt'

    with open(pubkeys_file, 'r') as f:
        pubkeys = {int(line.strip(), 16) for line in f}

    pool = multiprocessing.Pool(processes=num_parts)

    start_ranges = [start + i * ((end - start) // num_parts) for i in range(num_parts)]
    end_ranges = [start + (i + 1) * ((end - start) // num_parts) for i in range(num_parts)]
    args = [(start_ranges[i], end_ranges[i], pubkeys) for i in range(num_parts)]

    results = pool.starmap(kangaroo, args)
    foundkeys = [result for result in results if result is not None]

    with open(foundkeys_file, 'w') as f:
        for result in foundkeys:
            f.write(f"{result[0]}\n")
            print(f"Found private key: {result[1]} for public key: {result[2]}")

    print("Done.")

start =1000000000
h = hex(start)[2: ]
print('hex :', h)

end =2000000000
h = hex(end)[2: ]
print('hex :', h)

import bitcoin as bit
import random




#edit range_start


range_start= int(10000095)
N=int(1000000)
for N in range(1000000000):
    add= str(N) +'000000'
    result= int(add)
    sum= int(result + range_start)
    b = hex(sum)[2:]
    c = str.format(b)
    pk= c.zfill(64)
    public_key = bit.privkey_to_pubkey(pk)
    public_key_compressed = bit.compress(public_key)
    data = open("found.txt","a")
    data.write(str(public_key_compressed)+"\n"+ str(pk)+"\n")
    data.close()

import bitcoin as bit
import random




#edit range_start

range_start= int(10000095)
N=int(1000000)
for N in range(1000000000):
    add= str(N) +'000000'
    result= int(add)
    sum= int(result + range_start)
    b = hex(sum)[2:]
    c = str.format(b)
    pk= c.zfill(64)
    public_key = bit.privkey_to_pubkey(pk)
    data = open("found.txt","a")
    data.write(str(public_key)+"\n"+ str(pk)+"\n")
    data.close()

import bitcoin as bit
import random


#edit range_start


range_start= int(10000095)
N=int(1000000)
for N in range(1000000000):
    add= str(N) +'000000'
    result= int(add)
    sum= int(result + range_start)
    b = hex(sum)[2:]
    c = str.format(b)
    pk= c.zfill(64)
    public_key = bit.privkey_to_pubkey(pk)
    public_key_compressed = bit.compress(public_key)
    target = "here your public key"
    if public_key_compressed in target:
        print("address found")
        data = open("found.txt","a")
        data.write(str(pk)+"\n"+ str(public_key_compressed)+"\n")
        data.close()

import bitcoin as bit
import random




#edit range_start


range_start= int(10000095)
N=int(1000000)
for N in range(1000000000):
    add= str(N) +'000000'
    result= int(add)
    sum= int(result + range_start)
    b = hex(sum)[2:]
    c = str.format(b)
    pk= c.zfill(64)
    public_key = bit.privkey_to_pubkey(pk)
    target = "here your public key"
    if public_key in target:
        print("address found")
        data = open("found.txt","a")
        data.write(str(pk)+"\n"+ str(public_key)+"\n")
        data.close()

import bitcoin as bit
import random




#edit range_start

range_start= int(10000095)
N=int(1000000)
for N in range(1000000000):
    add= str(N) +'000000'
    result= int(add)
    sum= str(result + range_start)
    pk= sum.zfill(64)
    public_key = bit.privkey_to_pubkey(pk)
    public_key_compressed = bit.compress(public_key)
    data = open("found.txt","a")
    data.write(str(public_key_compressed)+"\n"+ str(pk)+"\n")
    data.close()

import bitcoin as bit
import random




#edit range_start

range_start= int(10000095)
N=int(1000000)
for N in range(1000000000):
    add= str(N) +'000000'
    result= int(add)
    sum= str(result + range_start)
    pk= sum.zfill(64)
    public_key = bit.privkey_to_pubkey(pk)
    data = open("found.txt","a")
    data.write(str(public_key)+"\n"+ str(pk)+"\n")
    data.close()

import bitcoin as bit
import random




#edit range_start

range_start= int(10000095)
N=int(1000000)
for N in range(1000000000):
    add= str(N) +'000000'
    result= int(add)
    sum= str(result + range_start)
    pk= sum.zfill(64)
    public_key = bit.privkey_to_pubkey(pk)
    public_key_compressed = bit.compress(public_key)
    target = "here your public key"
    if public_key_compressed in target:
        print("address found")
        data = open("found.txt","a")
        data.write(str(pk)+"\n"+ str(public_key_compressed)+"\n")
        data.close()

import bitcoin as bit
import random




#edit range_start

range_start= int(10000095)
N=int(1000000)
for N in range(1000000000):
    add= str(N) +'000000'
    result= int(add)
    sum= str(result + range_start)
    pk= sum.zfill(64)
    public_key = bit.privkey_to_pubkey(pk))
    target = "here your public key"
    if public_key in target:
        print("address found")
        data = open("found.txt","a")
        data.write(str(pk)+"\n"+ str(public_key)+"\n")
        data.close()