0.1 BTC for python help!

[Unplugged Taste]

1. Adding numbers to private keys ? Is that even possible/safe ? How would that generate a public key ? Hmm RSA, eclipctive curve ? hmmm..

2. 1 BTC each in one of these billion addresses ? Euh are you aware bitcoin only has 21 million coins ?! LOL.

This smells and sounds fishy to me ! =D

Perhaps you misunderstood what I said. There is only 1 BTC in only 1 address. That 1 address that I already know & its public key has 1 billion public keys around it. you can turn any number to become your private key or any sequence of number some people are asking whether it is possible or not!

[Unplugged Taste]

First of all I generated a random private key from within a range, like that of BITCOIN Puzzle range. I generated its public key and I than started adding 1 million in the private key and generated its public key. Again I added 1 million in the private key and generated its public key. I continued this for 1k times. So basically from first private key and last private there is 1 billion private keys.
In case you didn't get my point:
Suppose I randomly chosen private key as 980
I added 1 million in private key = 1,000,980
Again added 1 million = 2,000,980,
...
...
...
Up till I added 1 billion in my first private key.

From start to end of private keys, I generated all public keys! YES, I still have 1 billion public keys of those 1 billion private keys.
Ironically I lost all my private keys. Not a single public key is released since no transaction has ever happened.

What was the purpose to iterate 1k times to add 1m to the initial and then intermediate random key of this iteration? To me it makes no sense when you used also all intermediate private keys anyway (or I can't follow your procedure).

If I understand you correctly you have a starting private key from some range and you stepped over a consecutive range of 1 billion (1k times 1m) private keys. All private keys are only one unit apart from each other.
Then you generated from all those 1 billion private keys the respective public keys. It's a fair assumption that you only initially stored the starting private key and not all the intermediate ones. You did that by some script or program and kept only the output of the public keys. You had no or poor backup and somehow lost your program or script and with it your initial private key. Well, shit happens. Out of curiosity, when did you do that and how much was 1 BTC worth at that time?

I placed 1 BTC in any one of those 1 billion private keys that I am looking for.

Just to be clear: there's 1 BTC controlled by a single private key from your range of 1 billion consecutive private keys located somewhere in the private key space of Bitcoin?

Still, your 1k steps don't make any sense to me in the context of your other details. Feel free to correct me where I'm wrong.

So far you are the only one who has perfectly understood what I am saying! You are 100% correct, there's 1 BTC controlled by a single private key within the range. It was around 2 months ago.

[larry_vw_1955]

Hi everyone! I hope you are all doing great.

I am not a programmer. Just started running ready made python scripts given by Chat GPT. But now I realized robots cannot replace humans whatsoever Tech advancements may happen.
Here is my situation. I am private keys lost case. AND I just don't want to handover matters into other's hands for obvious reasons.
My case is super identical. I created a bitcoin puzzle myself with my own BTCs and in the process I lost my own private keys, very funny hah! BUT its true.
First of all I generated a random private key from within a range, like that of BITCOIN Puzzle range. I generated its public key and I than started adding 1 million in the private key and generated its public key. Again I added 1 million in the private key and generated its public key. I continued this for 1k times. So basically from first private key and last private there is 1 billion private keys.
In case you didn't get my point:
Suppose I randomly chosen private key as 980
I added 1 million in private key = 1,000,980
Again added 1 million = 2,000,980,
...
...
...
Up till I added 1 billion in my first private key.

From start to end of private keys, I generated all public keys! YES, I still have 1 billion public keys of those 1 billion private keys.

I don't understand the motivation for creating 1 billion bitcoin private keys (and public keys). And then depositing 1 BTC on to one of them. What's the purpose of the other 999,999 private keys? i mean 999,999,999.

Ironically I lost all my private keys.

You have to write them down on paper. Of course, in your case you would need to make a trip to office depot to get a couple packs of copy paper that comes in the 500 quantity stacks... you could even get that box that has like 3000 perforated sheets all connected together so you could print them out on a dot matrix printer.

[Unplugged Taste]

Would someone please see the script that I think is best suited for my needs.
The script is generated by chatGPT not me. So if you suggest any changes in it please be specific like which should be replaced with which line of code. Thanks.

Code:

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.")

I ran the script its just blinking since there are no print statements added along... I don't know whether it is working correctly or not.

[whanau]

If you really want to use python then use this. Much easier than deciphering the robot code.

https://github.com/Telariust/pollard-kangaroo/blob/master/pollard-kangaroo.py

start it by running
python3 kangaroo.py 00008:0000ff 02049370a4b5f43412ea25f514e8ecdad05266115e4a7ecb1387231808f8b45963

replacing the range 00008 (start)  : 0000ff (end)   and public keys with your own.

It has a set of test keys too so if you just run

python3 kangaroo.py

you can see how it works with test data

[Unplugged Taste]

If you really want to use python then use this. Much easier than deciphering the robot code.

https://github.com/Telariust/pollard-kangaroo/blob/master/pollard-kangaroo.py

start it by running
python3 kangaroo.py 00008:0000ff 02049370a4b5f43412ea25f514e8ecdad05266115e4a7ecb1387231808f8b45963

replacing the range 00008 (start)  : 0000ff (end)   and public keys with your own.

It has a set of test keys too so if you just run

python3 kangaroo.py

you can see how it works with test data

Where in the above script should I insert my own start and end range? the script you suggested https://github.com/Telariust/pollard-kangaroo/blob/master/pollard-kangaroo.py
It has also inserted pubkeys in an awkward way that I don't understand

[whanau]

just download the code to a directory(folder)
change to that directory don't alter any code.  It is all run from the command line.


Open a terminal / powershell window and type in the command line

python3 kangaroo.py 00008:0000ff 02049370a4b5f43412ea25f514e8ecdad05266115e4a7ecb1387231808f8b45963
cut & paste the above to get the idea.

python 3 calls the program kangaroo.py

00008 is the start of the range in hexadecimal.
Here you put in your start range of the first key you generated yours might be much bigger 1234567abcde or whatever.

: is a separator

000ff is the end of the range (1000 decimal is a different number to 1000 hex
again put in your end range

then put in the public key of the first key you generated and wait.

If successful, a file containing the key will be generated as well as being shown on the screen

I have tested this program and it works.
good luck.

[Minase]

still dont know what the author wants..

@Unplugged Taste
tell us, do you know the public key of the address containing 1 BTC or not ??

from your posts i believe you dont know which public key is the correct one....

i posted on the first page a script that converts all the public keys you have into addresses and compares them to the address containing your money.
it will return only the address and it's public key

IF you already know the public key of the address why would you need to check all the public keys at once??

[Unplugged Taste]

still dont know what the author wants..

@Unplugged Taste
tell us, do you know the public key of the address containing 1 BTC or not ??

from your posts i believe you dont know which public key is the correct one....

i posted on the first page a script that converts all the public keys you have into addresses and compares them to the address containing your money.
it will return only the address and it's public key

IF you already know the public key of the address why would you need to check all the public keys at once??

Perhaps you misunderstood what I said. Let me clear you that I know the public key & address carrying funds. The reason of me stressing on 1 billion public keys around it and trying to find any one private key of any of them is that it is increasing chances by 1 billion times. Why? Because they are in a sequence like 1,2,3,4,... etc. Its like there are 1 billion private keys carrying that 1 BTC because any one could easily lead to the principle private key easily.

[pooya87]

1. Adding numbers to private keys ? Is that even possible/safe ? How would that generate a public key ? Hmm RSA, eclipctive curve ? hmmm..

It's called elliptic curve and the private keys are merely numbers so you can perform any kind of arithmetic operation on them as you like (add, subtract, multiply, divide, etc.) as long as you end up with an integer that is between 1 and curve order (N).

As for safety it comes down to how the initial key was selected, if it were random the result will also be safe. In fact this is the method that vanity address generators use.

[Unplugged Taste]

just download the code to a directory(folder)
change to that directory don't alter any code.  It is all run from the command line.


Open a terminal / powershell window and type in the command line

python3 kangaroo.py 00008:0000ff 02049370a4b5f43412ea25f514e8ecdad05266115e4a7ecb1387231808f8b45963
cut & paste the above to get the idea.

python 3 calls the program kangaroo.py

00008 is the start of the range in hexadecimal.
Here you put in your start range of the first key you generated yours might be much bigger 1234567abcde or whatever.

: is a separator

000ff is the end of the range (1000 decimal is a different number to 1000 hex
again put in your end range

then put in the public key of the first key you generated and wait.

If successful, a file containing the key will be generated as well as being shown on the screen

I have tested this program and it works.
good luck.

Thanks for helping, it worked.
Here comes the interesting part, that this Kangaroo algorithm takes only 1 public key. which is like finding 1 drop in an ocean as someone quoted. What about finding 1 billion drops instead of 1? Thats my point, when I say that 1 billion public keys increase the probability by 1 billion times. Hence, I am convinced if this Kangaroo algorithm takes 1 billion public keys instead of 1, the chances of finding one would increase exponentially. What do you say?

[_Counselor]

Thanks for helping, it worked.
Here comes the interesting part, that this Kangaroo algorithm takes only 1 public key. which is like finding 1 drop in an ocean as someone quoted. What about finding 1 billion drops instead of 1? Thats my point, when I say that 1 billion public keys increase the probability by 1 billion times. Hence, I am convinced if this Kangaroo algorithm takes 1 billion public keys instead of 1, the chances of finding one would increase exponentially. What do you say?

Kangaroo algorithm is originally designed to search for a specific point (public key) and does not work with multiple keys. In the process of work, he already creates a lot of points, mathematically related with original point. Basically you need to generate a number of pubkeys equal to square root of range to solve the ECDLP. If we talking about range like 2^125 (current unsolved puzzle), you have to generate 2^63 pubkeys to solve it (no need to save them all, it is futher kangaroo optimizations called distinguished points)

[whanau]

Thanks for helping, it worked.
Here comes the interesting part, that this Kangaroo algorithm takes only 1 public key. which is like finding 1 drop in an ocean as someone quoted. What about finding 1 billion drops instead of 1? Thats my point, when I say that 1 billion public keys increase the probability by 1 billion times. Hence, I am convinced if this Kangaroo algorithm takes 1 billion public keys instead of 1, the chances of finding one would increase exponentially. What do you say?

I am pleased it worked and you have recovered your BTC.
Can I claim the bounty?  My BTC address 1NcFJzayiHy4iPFz4QR9BqP8XHuSDCv5qx

The chances may increase exponentially with more addresses but of course it slows down with a billion keys to check.
The keyhunt program is much faster.
Plus a billion addresses may seem like a lot but it is a tiny drop in the ocean.

Well done again on recovering your btc.   

[Minase]

Thanks for helping, it worked.
Here comes the interesting part, that this Kangaroo algorithm takes only 1 public key. which is like finding 1 drop in an ocean as someone quoted. What about finding 1 billion drops instead of 1? Thats my point, when I say that 1 billion public keys increase the probability by 1 billion times. Hence, I am convinced if this Kangaroo algorithm takes 1 billion public keys instead of 1, the chances of finding one would increase exponentially. What do you say?

yes, the program can be modified to accept 1 billion keys and the chances do increase by the number of keys but also the speed drops proportionally with the number of keys.

it's a tradeoff speed or keys

[Unplugged Taste]

Thanks for helping, it worked.
Here comes the interesting part, that this Kangaroo algorithm takes only 1 public key. which is like finding 1 drop in an ocean as someone quoted. What about finding 1 billion drops instead of 1? Thats my point, when I say that 1 billion public keys increase the probability by 1 billion times. Hence, I am convinced if this Kangaroo algorithm takes 1 billion public keys instead of 1, the chances of finding one would increase exponentially. What do you say?

I am pleased it worked and you have recovered your BTC.
Can I claim the bounty?  My BTC address 1NcFJzayiHy4iPFz4QR9BqP8XHuSDCv5qx

The chances may increase exponentially with more addresses but of course it slows down with a billion keys to check.
The keyhunt program is much faster.
Plus a billion addresses may seem like a lot but it is a tiny drop in the ocean.

Well done again on recovering your btc.   

By "it worked" I meant that the script worked. It says I have to wait 1.7 million year before it actually finds the key.

[Unplugged Taste]

Thanks for helping, it worked.
Here comes the interesting part, that this Kangaroo algorithm takes only 1 public key. which is like finding 1 drop in an ocean as someone quoted. What about finding 1 billion drops instead of 1? Thats my point, when I say that 1 billion public keys increase the probability by 1 billion times. Hence, I am convinced if this Kangaroo algorithm takes 1 billion public keys instead of 1, the chances of finding one would increase exponentially. What do you say?

yes, the program can be modified to accept 1 billion keys and the chances do increase by the number of keys but also the speed drops proportionally with the number of keys.

it's a tradeoff speed or keys

Obviously with 1 billion key input its going to get super slow, but with manageable input it should be super fast. Can you elaborate further how can kangaroo algorithm take multiple pubkeys

[whanau]

you put them in a text file one key on each line and execute the program replacing the single key with the file
Not sure if you can do that with the python version but certainly with keyhunt.

[algorithm32]

Do you just want a script that scans the public keys in "x" range and when it matches the public one that 1btc has, it saves its respective private key?

[algorithm32]

Let's see if I understand


possibility #1


you generated 1000m of keys with intervals of 1m between each 1
1000095 to 1000000095

1000095
1000000095

in
hex

00000000000000000000000000000000000000000000000000000000000f429f
000000000000000000000000000000000000000000000000000000003b9aca5f


you put 1btc in any of them

you lost the private key

You know the address, the public key, and the range so finding it will only take minutes.



if the range is in hex
use

download repo
https://github.com/WanderingPhilosopher/KeyHuntCudaClient

open x64 folder

open console in folder

paste

with GPU

KeyHunt-Cuda.exe -t 0 -g --gpui 0 --gpux 256,256 -m xpoint --coin BTC --range "your range here. start:end" "your public here whitout first 2 ch"

example

KeyHunt-Cuda.exe -t 0 -g --gpui 0 --gpux 256,256 -m xpoint --coin BTC --range 8000000000:ffffffffff a2efa402fd5268400c77c20e574ba86409ededee7c4020e4b9f0edbee53de0d4

with CPU

KeyHunt-Cuda.exe -t "HERE CPU CORES TO USE"  --gpui 0 --gpux 256,256 -m xpoint --coin BTC --range "your range heree. start:end" "your public here whitout first 2"

example

KeyHunt-Cuda.exe -t 4  --gpui 0 --gpux 256,256 -m xpoint --coin BTC --range 8000000000:ffffffffff a2efa402fd5268400c77c20e574ba86409ededee7c4020e4b9f0edbee53de0d4

testet with my 4 cpu cores

1mkey/s = 1000mKeys in 1000 sec or 17 minutes.

If range is Decimal

example

1000000 to 20000000

in python

decimal to hex

Code:

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

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

use hex in keyhuntcuda

to generate the ranges of 1000000 in decimals you only add 1m x times

if you want to save all pubkey and privkey in ranges of every 1m

python modules

random
bitcoin

pip install bitcoin

for compressed addr

Code:

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()

           


for uncompressed addr
  

Code:

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()

if you know the public key and you want to save it

for compressed addr

Code:

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()

for uncompressed addr

Code:

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()

possibility #2

you take Hex(only numbers)

example

1000000 in decimal is 1000000

1000000 in hex is f4240


range 1000000- 1000000000 in hex is

0000000000000000000000000000000000000000000000000000000001000000
0000000000000000000000000000000000000000000000000000001000000000

this increase your search range


use python

if you want to save all public keys and private keys in ranges of every 1m

for compressed addr

Code:

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()

           

for uncompressed addr

Code:

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()

if you know the public key, and you want to save it

for compressed addr

Code:

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()

for uncompressed addr

Code:

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()

in case you are an honest person.

bc1qtfhwwgf5pmq99f5x8hwvvklepzxumdxgrmya8k

[COBRAS]

still dont know what the author wants..

@Unplugged Taste
tell us, do you know the public key of the address containing 1 BTC or not ??

from your posts i believe you dont know which public key is the correct one....

i posted on the first page a script that converts all the public keys you have into addresses and compares them to the address containing your money.
it will return only the address and it's public key

IF you already know the public key of the address why would you need to check all the public keys at once??

I will write an example, we will take 125 original public key puzzles and generate 1 billion keys from them, then just crack one single public key out of billion public keys, you will get a private key in the form of numbers and according to it you can calculate the private key for 125

there is vinner of your 0.1 BTC ?