jeanlucpons / kangaroo

Pollard's kangaroo for SECPK1

Pollard's kangaroo for SECPK1

A Pollard's kangaroo interval ECDLP solver for SECP256K1 (based on VanitySearch engine).
This program is limited to a 125bit interval search.

Feature

• Fixed size arithmetic
• Fast Modular Inversion (Delayed Right Shift 62 bits)
• SecpK1 Fast modular multiplication (2 steps folding 512bits to 256bits reduction using 64 bits digits)
• Multi-GPU support
• CUDA optimisation via inline PTX assembly

Discussion Thread

Discusion thread: https://bitcointalk.org/index.php?topic=5244940.0

Usage

Kangaroo v2.1
Kangaroo [-v] [-t nbThread] [-d dpBit] [gpu] [-check]
         [-gpuId gpuId1[,gpuId2,...]] [-g g1x,g1y[,g2x,g2y,...]]
         inFile
 -v: Print version
 -gpu: Enable gpu calculation
 -gpuId gpuId1,gpuId2,...: List of GPU(s) to use, default is 0
 -g g1x,g1y,g2x,g2y,...: Specify GPU(s) kernel gridsize, default is 2*(MP),2*(Core/MP)
 -d: Specify number of leading zeros for the DP method (default is auto)
 -t nbThread: Secify number of thread
 -w workfile: Specify file to save work into (current processed key only)
 -i workfile: Specify file to load work from (current processed key only)
 -wi workInterval: Periodic interval (in seconds) for saving work
 -ws: Save kangaroos in the work file
 -wss: Save kangaroos via the server
 -wsplit: Split work file of server and reset hashtable
 -wm file1 file2 destfile: Merge work file
 -wmdir dir destfile: Merge directory of work files
 -wt timeout: Save work timeout in millisec (default is 3000ms)
 -winfo file1: Work file info file
 -wpartcreate name: Create empty partitioned work file (name is a directory)
 -wcheck worfile: Check workfile integrity
 -m maxStep: number of operations before give up the search (maxStep*expected operation)
 -s: Start in server mode
 -c server_ip: Start in client mode and connect to server server_ip
 -sp port: Server port, default is 17403
 -nt timeout: Network timeout in millisec (default is 3000ms)
 -o fileName: output result to fileName
 -l: List cuda enabled devices
 -check: Check GPU kernel vs CPU
 inFile: intput configuration file

Structure of the input file:

• All values are in hex format
• Public keys can be given either in compressed or uncompressed format

Start range
End range
Key #1
Key #2
...

ex

49dccfd96dc5df56487436f5a1b18c4f5d34f65ddb48cb5e0000000000000000
49dccfd96dc5df56487436f5a1b18c4f5d34f65ddb48cb5effffffffffffffff
0459A3BFDAD718C9D3FAC7C187F1139F0815AC5D923910D516E186AFDA28B221DC994327554CED887AAE5D211A2407CDD025CFC3779ECB9C9D7F2F1A1DDF3E9FF8
0335BB25364370D4DD14A9FC2B406D398C4B53C85BE58FCC7297BD34004602EBEC

Note on Time/Memory tradeoff of the DP method

The distinguished point (DP) method is an efficient method for storing random walks and detect collision between them. Instead of storing all points of all kangagroo's random walks, we store only points that have an x value starting with dpBit zero bits. When 2 kangaroos collide, they will then follow the same path because their jumps are a function of their x values. The collision will be then detected when the 2 kangaroos reach a distinguished point.
This has a drawback when you have a lot of kangaroos and looking for collision in a small range as the overhead is in the order of nbKangaroo.2^dpBit until a collision is detected. If dpBit is too small a large number of point will enter in the central table, will decrease performance and quickly fill the RAM. Powerfull GPUs with large number of cores won't be very efficient on small range, you can try to decrease the grid size in order to have less kangaroos but the GPU performance may not be optimal. Yau can change manualy the DP mask size using the -d option, take in consideration that it will require more operations to complete. See table below:

nbKangaroo.2dpBit/sqrt(N)	DP Overhead	Avg
4.000	cubicroot(1+4.000) = ~71.0%	3.55 sqrt(N)
2.000	cubicroot(1+2.000) = ~44.2%	2.99 sqrt(N)
1.000	cubicroot(1+1.000) = ~26.0%	2.62 sqrt(N)
0.500	cubicroot(1+0.500) = ~14.5%	2.38 sqrt(N)
0.250	cubicroot(1+0.250) = ~7.7%	2.24 sqrt(N)
0.125	cubicroot(1+0.125) = ~4.0%	2.16 sqrt(N)

DP overhead according to the range size (N), DP mask size (dpBit) and number of kangaroos running in paralell (nbKangaroo).

Note that restarting a client without having a kangaroo backup is like adding more kangaroos, when you merge workfiles coming from different kangaroos, it is also like having more kangaroos.

How to deal with work files

You can save periodicaly work files using -w -wi -ws options. When you save a work file, if it does not contain the kangaroos (-ws) you will lost a bit of work due to the DP overhead, so if you want to continue a file on a same configuration it is recommended to use -ws. To restart a work, use the -i option, the input ascii file is not needed.
When you continue a work file on a different hardware, or using a different number of bits for the distinguished points, or a different number of kangaroos, you will also get an overhead.
However, work files are compatible (same key and range) and can be merged, if 2 work files have a different number of distinguished bits, the lowest will be recorded in the destination file.
If you have several hosts with different configurations, it is preferable to use -ws on each host and then merge all files from time to time in order to check if the key can be solved. When a merge solve a key, no output file is written. A merged file does not contain kangaroos.

Start a work from scratch and save work file every 30 seconds:

Kangaroo.exe -ws -w save.work -wi 30 in.txt

Continue the work from save.work and save work file every 30 seconds:

Kangaroo.exe -ws -w save.work -wi 30 -i save.work

Getting info from a work file:

Kangaroo.exe -winfo save.work
Kangaroo v1.5
Loading: save.work
Version   : 0
DP bits   : 16
Start     : 3447F65ABC9F46F736A95F87B044829C8A0129D56782D635CD00000000000000
Stop      : 3447F65ABC9F46F736A95F87B044829C8A0129D56782D635CDFFFFFFFFFFFFFF
Key       : 031D91282433E664132046D25189A5FE0F64645A73494A37AB17BD6FB283AE5BA2
Count     : 808510464 2^29.591
Time      : 01:35
DP Size   : 2.4/5.8MB
DP Count  : 12199 2^13.574
HT Max    : 3 [@ 008A9F]
HT Min    : 0 [@ 000000]
HT Avg    : 0.05
HT SDev   : 0.22
Kangaroos : 4096 2^12.000

Merge 2 work files (here the key has been solved during the merge):

Kangaroo.exe -wm save1.work save2.work save3.work
Kangaroo v1.5
Loading: save1.work
MergeWork: [HashTable1 2.3/5.3MB] [00s]
Loading: save2.work
MergeWork: [HashTable2 2.3/5.3MB] [00s]
Merging...
Range width: 2^56

Key# 0 [1S]Pub:  0x031D91282433E664132046D25189A5FE0F64645A73494A37AB17BD6FB283AE5BA2
       Priv: 0x3447F65ABC9F46F736A95F87B044829C8A0129D56782D635CD612C0F05F3DA03
Dead kangaroo: 0
Total f1+f2: count 2^30.04 [02:17]

Note on the wsplit option:

In order to avoid to handle a big hashtable in RAM, it is possible to save it and reset it at each backup. It will save a work file with a prefix at each backup and reset the hashtable in RAM. Then a merge can be done offline and key solved by merge. Even with a small hashtable, the program may also solve the key as paths continue and collision may occur in the small hashtable so don't forget to use -o option when using server(s).

Exemple with a 64bit key:

Kangaroo.exe -d 10 -s -w save.work -wsplit -wi 10 ..\VC_CUDA8\in64.txt

Kangaroo v1.6
Start:5B3F38AF935A3640D158E871CE6E9666DB862636383386EE0000000000000000
Stop :5B3F38AF935A3640D158E871CE6E9666DB862636383386EEFFFFFFFFFFFFFFFF
Keys :1
Range width: 2^64
Expected operations: 2^33.05
Expected RAM: 344.2MB
DP size: 10 [0xFFC0000000000000]
Kangaroo server is ready and listening to TCP port 17403 ...
[Client 0][Kang 2^-inf][DP Count 2^-inf/2^23.05][Dead 0][04s][2.0/4.0MB]
New connection from 127.0.0.1:58358
[Client 1][Kang 2^18.58][DP Count 2^-inf/2^23.05][Dead 0][08s][2.0/4.0MB]
New connection from 172.24.9.18:52090
[Client 2][Kang 2^18.61][DP Count 2^16.17/2^23.05][Dead 0][10s][4.2/14.1MB]
SaveWork: save.work_27May20_063455...............done [4.2 MB] [00s] Wed May 27 06:34:55 2020
[Client 2][Kang 2^18.61][DP Count 2^20.25/2^23.05][Dead 0][20s][40.1/73.9MB]
SaveWork: save.work_27May20_063505...............done [40.1 MB] [00s] Wed May 27 06:35:06 2020
[Client 2][Kang 2^18.61][DP Count 2^20.17/2^23.05][Dead 0][30s][37.9/71.5MB]
SaveWork: save.work_27May20_063516...............done [37.9 MB] [00s] Wed May 27 06:35:16 2020
[Client 2][Kang 2^18.61][DP Count 2^20.55/2^23.05][Dead 0][41s][48.9/82.8MB]
SaveWork: save.work_27May20_063526...............done [48.9 MB] [00s] Wed May 27 06:35:27 2020
[Client 2][Kang 2^18.61][DP Count 2^20.29/2^23.05][Dead 0][51s][41.1/74.9MB]
SaveWork: save.work_27May20_063537...............done [41.1 MB] [00s] Wed May 27 06:35:37 2020
[Client 2][Kang 2^18.61][DP Count 2^20.30/2^23.05][Dead 0][01:02][41.5/75.2MB]
SaveWork: save.work_27May20_063547...............done [41.5 MB] [00s] Wed May 27 06:35:48 2020
[Client 2][Kang 2^18.61][DP Count 2^20.28/2^23.05][Dead 0][01:12][40.9/74.6MB]
SaveWork: save.work_27May20_063558...............done [40.9 MB] [00s] Wed May 27 06:35:58 2020 <= offline merge solved the key there
[Client 2][Kang 2^18.61][DP Count 2^20.19/2^23.05][Dead 0][01:22][38.5/72.2MB]
SaveWork: save.work_27May20_063608...............done [38.5 MB] [00s] Wed May 27 06:36:08 2020
[Client 2][Kang 2^18.61][DP Count 2^20.55/2^23.05][Dead 0][01:33][48.8/82.7MB]
SaveWork: save.work_27May20_063618...............done [48.8 MB] [00s] Wed May 27 06:36:19 2020
[Client 2][Kang 2^18.61][DP Count 2^19.98/2^23.05][Dead 0][01:41][33.5/66.8MB]
Key# 0 [1S]Pub:  0x03BB113592002132E6EF387C3AEBC04667670D4CD40B2103C7D0EE4969E9FF56E4
       Priv: 0x5B3F38AF935A3640D158E871CE6E9666DB862636383386EE510F18CCC3BD72EB

Note on -wss option:

The wss option allow to use the server to make kangaroo backups, the client send kangaroo (in compressed format) to the server. When a client restart with -wss option, it tries to download the backup. If the specified file is not found by the server, the client creates new kangaroos. There is no need to use -i option here. Make sure when restarting a new job with a different range or key, that the client does not download an old backup. Make sure that when a backup is downloaded, that no kangaroos are created or not handled by the client. This option is usefull if you cannot rely on client side to handle kangaoo backup.

Send kangaroo to the server every 20 second and, when starting, try to download kang.

./kangaroo -w kang -wss -wi 20 -c pcjlpons

Distributed clients and central server(s)

It is possible to run Kangaroo in client/server mode. The server has the same options as the standard program except that you have to specify manually the number of distinguished point bits number using -d. All clients which connect will get back the configuration from the server. At the moment, the server is limited to one single key. If you restart the server with a different configuration (range or key), you need to stop all clients otherwise they will reconnect and send wrong points.

Starting the server with backup every 5 min, 12 distinguished bits, in64.txt as config file:

pons@linpons:~/Kangaroo$./kangaroo -w save.work -wi 300 -o result.txt -s -d 12 in64.txt

Warning: The server is very simple and has no authentication mechanism, so if you want to export it on the net, use at your own risk.

Starting client, using gpu and connect to the server linpons, backup kangaroos every 10min:

Kangaroo.exe -t 0 -gpu -w kang.work -wi 600 -c linpons

What to do in case of a server crash:
When the server is stopped, clients wait for reconnection, so simply restart it, no need to reload a backup if using wsplit (recommended).
What to do in case of a client crash:
Retart the client using the last kangaroos backup:

Kangaroo.exe -t 0 -gpu -i kang.work -w kang.work -wi 600 -c linpons

When the client restart from backup, it will produce duplicate points (counted as dead kangaroos) until it reaches its progress before the crash. It is important to restart the client with its backup, otherwise new kangaroos are created and the DP overhead increases.

To build such an architecture, the total number of kangaroo running in parallel must be know at the starting time to estimate the DP overhead. It is not recommended to add or remove clients during running time, the number of kangaroo must be constant.

This program solved puzzle #110 in 2.1 days (109 bit key on the Secp256K1 field) using this architecture on 256 Tesla V100. It required 2^55.55 group operations using DP25 to complete. This program also solved #115 in 13 days (114 bit key on the Secp256K1 field). It required 2^58.36 group operations using DP25 to complete.

Probability of success

The picture below show the probability of success after a certain number of group operations. N is range size. This plot does not take into consideration the DP overhead.

How it works

The program uses 2 herds of kangaroos, a tame herd and a wild herd. When 2 kangoroos (a wild one and a tame one) collide, the key can be solved. Due to the birthday paradox, a collision happens (in average) after 2.08*sqrt(k2-k1) [1] group operations, the 2 herds have the same size. To detect collision, the distinguished points method is used with a hashtable.

Here is a brief description of the algorithm:

We have to solve P = k.G, P is the public key, we know that k lies in the range [k1,k2], G is the SecpK1 generator point.
Group operations are additions on the elliptic curve, scalar operations are done modulo the order of the curve.

n = floor(log2(sqrt(k2-k1)))+1

• Create a jump point table jP = [G,2G,4G,8G,...,2^n-1.G]
• Create a jump distance table jD = [1,2,4,8,....,2^n-1]

for all i in herdSize
  tame_i = rand(0..(k2-k1)) # Scalar operation
  tamePos_i = (k1+tame_i).G # Group operation
  wild_i = rand(0..(k2-k1)) - (k2-k1)/2 # Scalar operation
  wildPos_i = P + wild_i.G # Group operation

found = false

while not found
  for all i in herdSize
     tamePos_i = tamePos_i + jP[tamePos_i.x % n] # Group operation
     tame_i += jD[tamePos_i.x % n] # Scalar operation
     wildPos_i = wildPos_i + jP[wildPos_i.x % n] # Group operation
     wild_i += jD[wildPos_i.x % n] # Scalar operation
     if tamePos_i is distinguished
       add (TAME,tamePos_i,tame_i) to hashTable
     if wildPos_i is distinguished
       add (WILD,wildPos_i,wild_i) to hashTable
  found = is there a collision in hashTable between a tame and a wild kangaroo ?

(Tame,Wild) = Collision
k = k1 + Tame.dist - Wild.dist

Here is an illustration of what's happening. When 2 paths collide they form a shape similar to the lambda letter. This is why this method is also called lambda method.

Compilation

Windows

Install CUDA SDK 10.2 and open VC_CUDA102\Kangaroo.sln in Visual C++ 2019.
You may need to reset your Windows SDK version in project properties.
In Build->Configuration Manager, select the Release configuration.
Build and enjoy.

Note: The current release has been compiled with Visual studio 2019 and CUDA SDK 10.2, if you have a different release of the CUDA SDK, you may need to update CUDA SDK paths in Kangaroo.vcxproj using a text editor. The current nvcc option are set up to architecture starting at 3.0 capability, for older hardware, add the desired compute capabilities to the list in GPUEngine.cu properties, CUDA C/C++, Device, Code Generation.

Visual Studio 2015 + Cuda 8 => Take project files in VC_CUDA8
Visual Sutido 2017 + Cuda 10 => Take project files in VC_CUDA10 (project files might be out of date)
Visual Studio 2019 + Cuda10.2 => Take project files in VC_CUDA102\

Linux

Install CUDA SDK.
Depending on the CUDA SDK version and on your Linux distribution you may need to install an older g++ (just for the CUDA SDK).
Edit the makefile and set up the good CUDA SDK path and appropriate compiler for nvcc.

CUDA       = /usr/local/cuda-8.0
CXXCUDA    = /usr/bin/g++-4.8

You can enter a list of architecture (refer to nvcc documentation) if you have several GPU with different architecture. Compute capability 2.0 (Fermi) is deprecated for recent CUDA SDK. Kangaroo need to be compiled and linked with a recent gcc (>=7). The current release has been compiled with gcc 7.3.0.
Go to the Kangaroo directory. ccap is the desired compute capability.

$ g++ -v
gcc version 7.3.0 (Ubuntu 7.3.0-27ubuntu1~18.04)
$ make all (for build without CUDA support)
or
$ make gpu=1 ccap=20 all

Runnig Kangaroo (Intel(R) Xeon(R) CPU, 8 cores, @ 2.93GHz, Quadro 600 (x2))

$pons@linpons:~/Kangaroo$cat in.txt 
0
FFFFFFFFFFFFFF
02E9F43F810784FF1E91D8BC7C4FF06BFEE935DA71D7350734C3472FE305FEF82A
pons@linpons:~/Kangaroo$export LD_LIBRARY_PATH=/usr/local/cuda-8.0/lib64
pons@linpons:~/Kangaroo$./kangaroo -t 4 -gpu -gpuId 0,1 in.txt 
Kangaroo v1.2
Start:0
Stop :FFFFFFFFFFFFFF
Keys :1
Number of CPU thread: 4
Range width: 2^56
Number of random walk: 2^16.64 (Max DP=9)
DP size: 9 [0xff80000000000000]
SolveKeyCPU Thread 0: 1024 kangaroos
SolveKeyCPU Thread 2: 1024 kangaroos
SolveKeyCPU Thread 1: 1024 kangaroos
SolveKeyCPU Thread 3: 1024 kangaroos
GPU: GPU #0 Quadro 600 (2x48 cores) Grid(4x96) (13.5 MB used)
SolveKeyGPU Thread GPU#0: creating kangaroos...
GPU: GPU #1 Quadro 600 (2x48 cores) Grid(4x96) (13.5 MB used)
SolveKeyGPU Thread GPU#1: creating kangaroos...
SolveKeyGPU Thread GPU#0: 2^15.58 kangaroos in 334.8ms
SolveKeyGPU Thread GPU#1: 2^15.58 kangaroos in 364.7ms
[22.67 MKey/s][GPU 13.04 MKey/s][Count 2^29.06][Dead 0][28s][89.1MB]  
Key# 0 Pub:  0x02E9F43F810784FF1E91D8BC7C4FF06BFEE935DA71D7350734C3472FE305FEF82A 
       Priv: 0x378ABDEC51BC5D 

Done: Total time 29s 

Example of usage

Puzzle 32BTC, every 5 addresses, the public key is exposed and can be attacked with Kangaroo ECDLP solver.

Puzzle #85: 84bits private key [2⁸⁴,2⁸⁵-1], 1Kh22PvXERd2xpTQk3ur6pPEqFeckCJfAr

1000000000000000000000
1FFFFFFFFFFFFFFFFFFFFF
0329c4574a4fd8c810b7e42a4b398882b381bcd85e40c6883712912d167c83e73a

On an Xeon E5-2690 V4 with 4xTesla V100 (GPU only):

Kangaroo v2.1
Start:1000000000000000000000
Stop :1FFFFFFFFFFFFFFFFFFFFF
Keys :1
Number of CPU thread: 0
Range width: 2^84
Jump Avg distance: 2^42.03
Number of kangaroos: 2^23.32
Suggested DP: 16
Expected operations: 2^43.12
Expected RAM: 6347.6MB
DP size: 16 [0xFFFF000000000000]
GPU: GPU #1 Tesla V100-PCIE-16GB (80x64 cores) Grid(160x128) (207.0 MB used)
SolveKeyGPU Thread GPU#1: creating kangaroos...
GPU: GPU #2 Tesla V100-PCIE-16GB (80x64 cores) Grid(160x128) (207.0 MB used)
SolveKeyGPU Thread GPU#2: creating kangaroos...
GPU: GPU #0 Tesla V100-PCIE-16GB (80x64 cores) Grid(160x128) (207.0 MB used)
SolveKeyGPU Thread GPU#0: creating kangaroos...
GPU: GPU #3 Tesla V100-PCIE-16GB (80x64 cores) Grid(160x128) (207.0 MB used)
SolveKeyGPU Thread GPU#3: creating kangaroos...
SolveKeyGPU Thread GPU#1: 2^21.32 kangaroos [12.3s]
SolveKeyGPU Thread GPU#2: 2^21.32 kangaroos [12.3s]
SolveKeyGPU Thread GPU#3: 2^21.32 kangaroos [12.3s]
SolveKeyGPU Thread GPU#0: 2^21.32 kangaroos [12.4s]
[7828.45 MK/s][GPU 7828.45 MK/s][Count 2^43.22][Dead 2][24:56 (Avg 20:24)][4.8/6.9GB]
Key# 0 [1S]Pub:  0x0329C4574A4FD8C810B7E42A4B398882B381BCD85E40C6883712912D167C83E73A
       Priv: 0x11720C4F018D51B8CEBBA8

Next puzzles to solve:

#110, 109bits private key [2¹⁰⁹,2¹¹⁰-1], 12JzYkkN76xkwvcPT6AWKZtGX6w2LAgsJg 1.10BTC Solved by this program

2000000000000000000000000000
3FFFFFFFFFFFFFFFFFFFFFFFFFFF
0309976BA5570966BF889196B7FDF5A0F9A1E9AB340556EC29F8BB60599616167D

#115, 114bits private key [2¹¹⁴,2¹¹⁵-1], 1NLbHuJebVwUZ1XqDjsAyfTRUPwDQbemfv 1.15BTC Solved by this program

40000000000000000000000000000
7FFFFFFFFFFFFFFFFFFFFFFFFFFFF
0248D313B0398D4923CDCA73B8CFA6532B91B96703902FC8B32FD438A3B7CD7F55

#130, 129bits private key [2¹²⁹,2¹³⁰-1], 1Fo65aKq8s8iquMt6weF1rku1moWVEd5Ua 13.0BTC

Expected time: several years on 256 Tesla V100 (Not possible with this program without modification)

Up to #160

Articles

• [1] Using Equivalence Classes to Accelerate Solvingthe Discrete Logarithm Problem in a Short Interval
  https://www.iacr.org/archive/pkc2010/60560372/60560372.pdf
• [2] Kangaroo Methods for Solving theInterval Discrete Logarithm Problem
  https://arxiv.org/pdf/1501.07019.pdf
• [3] Factoring and Discrete Logarithms using Pseudorandom Walks
  https://www.math.auckland.ac.nz/~sgal018/crypto-book/ch14.pdf
• [4] Kangaroos, Monopoly and Discrete Logarithms
  https://web.northeastern.edu/seigen/11Magic/KruskalsCount/PollardKangarooMonopoly.pdf

kangaroo's Issues

GPU issue

simply gpu heat shown from 42c to 65c, gpu ram 0 used, gpu core 0 used
speed seems app useing cpu cores and finsih

./kangaroo in.txt
Kangaroo v1.0
Start:0
Stop :FFFFFFFFFFFFFF
Keys :1
Number of CPU thread: 4
Range width: 2^56
Number of random walk: 2^12.00 (Max DP=14)
DP size: 14 [0xfffc000000000000]
SolveKeyCPU Thread 2: 1024 kangaroos
SolveKeyCPU Thread 1: 1024 kangaroos
SolveKeyCPU Thread 0: 1024 kangaroos
SolveKeyCPU Thread 3: 1024 kangaroos
[6.18 MKey/s][GPU 0.00 MKey/s][Count 2^29.26][Dead 4][01:59][7.3MB]
Key# 0 Pub: 0x02E9F43F810784FF1E91D8BC7C4FF06BFEE935DA71D7350734C3472FE305FEF82A
Priv: 0x378ABDEC51BC5D

GPU code not compiled, use -DWITHGPU when compiling.

The code is only running on my CPU

GPU code not compiled, use -DWITHGPU when compiling.
Number of CPU thread: 4
Range width: 2^119
Jump Avg distance: 2^58.98
Number of kangaroos: 2^12.00
Suggested DP: 44
Expected operations: 2^60.59
Expected RAM: 15.8MB
DP size: 44 [0xfffffffffff00000]
SolveKeyCPU Thread 0: 1024 kangaroos
SolveKeyCPU Thread 3: 1024 kangaroos
SolveKeyCPU Thread 1: 1024 kangaroos
SolveKeyCPU Thread 2: 1024 kangaroos

Problem with save.work file

Hello i started Kangaroo with the 80 bit in.txt problem is i want to save every 10 sec and i tryed bevor with every 30 sec but sometimes it comes an time out for save.work.

and speed is not constant it decrease after time out

here is command:

Kangaroo.exe -t 0 -gpu -gpuId 0,1,2,3,4,5 -ws -w save.work -wi 10 in.txt
Kangaroo v1.4
Start:25FEEE926526B0B4F0085358DF14702F7F6F04E8EC2200000000000000000000
Stop :25FEEE926526B0B4F0085358DF14702F7F6F04E8EC22FFFFFFFFFFFFFFFFFFFF
Keys :1
Number of CPU thread: 0
Range width: 2^80
Jump Avg distance: 2^40.03
Number of kangaroos: 2^22.49
Suggested DP: 17
Expected operations: 2^41.47
Expected RAM: 901.5MB
DP size: 17 [0xFFFF800000000000]
GPU: GPU #0 P104-100 (15x128 cores) Grid(30x256) (99.0 MB used)
SolveKeyGPU Thread GPU#0: creating kangaroos...
GPU: GPU #2 P104-100 (15x128 cores) Grid(30x256) (99.0 MB used)
SolveKeyGPU Thread GPU#2: creating kangaroos...
GPU: GPU #1 P104-100 (15x128 cores) Grid(30x256) (99.0 MB used)
SolveKeyGPU Thread GPU#1: creating kangaroos...
GPU: GPU #4 GeForce GTX 1070 (15x128 cores) Grid(30x256) (99.0 MB used)
SolveKeyGPU Thread GPU#4: creating kangaroos...
GPU: GPU #5 GeForce GTX 1070 (15x128 cores) Grid(30x256) (99.0 MB used)
SolveKeyGPU Thread GPU#5: creating kangaroos...
GPU: GPU #3 GeForce GTX 1070 (15x128 cores) Grid(30x256) (99.0 MB used)
SolveKeyGPU Thread GPU#3: creating kangaroos...
SolveKeyGPU Thread GPU#0: 2^19.91 kangaroos [11.6s]
SolveKeyGPU Thread GPU#2: 2^19.91 kangaroos [11.6s]
SolveKeyGPU Thread GPU#4: 2^19.91 kangaroos [11.8s]
SolveKeyGPU Thread GPU#1: 2^19.91 kangaroos [15.5s]
SolveKeyGPU Thread GPU#5: 2^19.91 kangaroos [11.4s]
SolveKeyGPU Thread GPU#3: 2^19.91 kangaroos [11.1s]
[2894.72 MK/s][GPU 1743.13 MK/s][Count 2^32.75][Dead 0][02s (Avg 17:35)][3.7/11.7MB]
SaveWork timweout !
[1259.27 MK/s][GPU 779.44 MK/s][Count 2^32.86][Dead 0][12s (Avg 40:27)][3.8/12.3MB]
SaveWork: save.work..............................done [543.8 MB] [02s] Fri May 8 18:14:20 2020
[1209.22 MK/s][GPU 1009.52 MK/s][Count 2^34.28][Dead 0][23s (Avg 42:07)][6.8/23.3MB]
SaveWork timweout !
[659.89 MK/s][GPU 657.25 MK/s][Count 2^34.31][Dead 0][33s (Avg 01:17:11)][7.0/23.7MB]
SaveWork timweout !
[561.03 MK/s][GPU 561.02 MK/s][Count 2^34.35][Dead 0][43s (Avg 01:30:47)][7.1/24.1MB]
SaveWork timweout !
[59.70 MK/s][GPU 59.70 MK/s][Count 2^34.39][Dead 0][56s (Avg 14:13:15)][7.2/24.6MB]
SaveWork: save.work..............................done [547.2 MB] [02s] Fri May 8 18:15:04 2020
[617.18 MK/s][GPU 617.18 MK/s][Count 2^35.04][Dead 0][01:06 (Avg 01:22:32)][10.2/32.7MB]
SaveWork timweout !
[652.92 MK/s][GPU 652.92 MK/s][Count 2^35.06][Dead 0][01:13 (Avg 01:18:00)][10.3/33.0MB]

Send Key to output text file

JeanLuc,

Is there anyway to either add -o key.txt option or hard code where the key will be automatically sent to a text file? If the key is found while one is sleeping or computer crashes or power goes out, there is currently no way to know if key was found or not.
I can add code in and compile if you will tell me what and where to put the code.

Thank you!

Using Convolutional Neural Networks to Improve Kangaroo Algorithm

have a very bold idea, Kangaroo algorithm plus Convolutional Neural Networks. Because with the current computing power, we can't crack the high-level keys. The range is too large, and the process of tame kangaroos is like a needle in the sea. But if we can accurately locate, we still have hope. Let's make an analogy: Our key search process is like a kangaroo looking for a mother on a very high floor. This floor is 904625697166532776746648320380374280100293470930272690489102837043110636675 so high. We asked kangaroos to search one floor at a time or to jump a few floors, but it still takes a long time, and it is difficult to find in the life of kangaroos. But if we can reduce the range to the minimum through the locator Convolutional Neural Networks, the probability that the kangaroo finds its mother will be higher. This is a bold idea, I am not a programmer but I think this idea must be great. This is a new cracking idea. Kangaroo algorithm plus Convolutional Neural Networks. Convolutional Neural Networks can provide kangaroo solution accuracy.

GPUEngine

Hello.
An error appears on the virtual machine, what can be ?

SolveKeyGPU Thread GPU#0: creating kangaroos...
GPUEngine: SetParams: Failed to copy to constant memory: invalid device symbol
GPUEngine: Kernel: no kernel image is available for execution on the device
SolveKeyGPU Thread GPU#0: 2^21.32 kangaroos [33.9s]
GPUEngine: Kernel: no kernel image is available for execution on the device

Puzzle 110 run is over

Now waiting for privatekey

Herds - add more?

Jean Luc,

If I wanted to add more herds (evenly) between wild and tame herds, where would I do this in the code? Basically, if currently there is 1 tame and 1 wild herd, how would I make 2 tame and 2 wild herds and create different starting points for each?

-r walks

Jean Luc,

Have you read studies/papers/experiments on the -r walking that can be used with Kangaroo? Seems interesting.

Server does not support -ws, ignoring

Waring: Server does not support -ws, ignoring
Kangaroo server is ready and listening to TCP port 17403 ...

What's going on, the server no longer doesn't work anymore?

Tame and Wild Range Question

@JeanLucPons

How would I need to configure the random starting distance, for the herds, if I wanted
Tame -N/2..N/2 and Wild 0..2/N ?

Puzzle 115 run is over

0000000000000000000000000000000000060f4d11574f5deee49961d9609ac6
1NLbHuJebVwUZ1XqDjsAyfTRUPwDQbemfv
P.S.
Taken from the Russian telegram channel

Ram

Hi JLP! What will be if all RAM memory of PC will be full? And when it’s possible to restart script if speed is decreased? I mean for rxample if my normal speed is 830m when it’s going down to 100 or 30 it’s ty to no waist a time and change bit to higher. Or when all rang will scan and nothing found it’s show the info like “nothing found”? Thanks

Client/Server

If you have more than one client, is it updating/saving input from all of the clients?

Also, did you change something in the merge file? I lost 2^5 (from 2^53 to 2^48) merging files today.

Lots of dead kangaroos

Hi,

Is this normal?, i'm runing in server mode with 4 clients.

How can I reduce the number of dead kagaroos?

Optimization

I changed the starting points and limited the number of kangaroos. I am currently working on a CPU and I have received the following results:

CPU i3, 534.2K j/s, 64 bit key, 100 tests - mean runtime ~ 3 hours

I have to say how the tests were conducted so that there were no questions about this. Each time a key was found, a new random 64-bit key was created and the search algorithm was run again

Now I'm busy porting code to OpenCL, this is a big and complicated job for me.

I think it's still possible to optimize the key finding time by calculating the correct jump size for each kangaroo.

Any ideas?

Adding flag -o

Hey Jean-Luc,

It would be nice when you could add flag -o for example (-o output.txt), to create a output file with the found results.

Thank you in advance!

Cheers Satoshi

Skipe pubkey in given period

Hi Jean Luc pont,
How to skipe pubkeys in a given period ex: I do the 40 bit test with 1000 pubkey, if the result of the first address is not found in a given period (1min max) is it possible to go to the address next and so on for all the pubkeys on the list.

Then how to save in a txt file if the result is found.

For these two subjects if there is a code to do it I would like to have it (skipe and passed to the following address in a given period then save the result in a txt file) I would also like to know which section to modify to add the code (I'm not a developer) thanks.

Flag -wsplit

Hey Jean-Luc,

What does the flag -wsplit exactly??

Maybe you can give an example.

Thanks in advance.

Cheers Satoshi

Operation Timed Out

Attempting to connect to my server which is running. Firewall is off.

PS C:\Users\user\Desktop\kangaroo> .\Kangaroo.exe -t 0 -gpu -c 127.0.0.1
Kangaroo v1.5
Number of CPU thread: 0

ReadError(Version): The operation timed out

JeanLucPons

JeanLucPons commented on 24 Apr
lol
I will give you if I find but I'm not searching ;)
I'm especially interested in understanding algorithms and technology.
This tool cannot solve a full range, more dedicated to help in some puzzle game...

promised to give and does not give bitcoin ((((
12veu1AvzHfH8Y4MKissusi4tMPktCcTJf

status add

current status
Start:0
Stop :FFFFFFFFFFFFFF
Keys :1
Number of CPU thread: 0
Range width: 2^56
Jump Avg distance: 2^28.01
Number of kangaroos: 2^17.39
Suggested DP: 10
Expected operations: 2^29.08
Expected RAM: 350.8MB

---

looking to add 1 more line example
pubkey : 03F93F8BEA92B4E860048D98C65BEA0B85C26B135433BE58647EE3EDE5D0315EFC

status will would be
Start:0
Stop :FFFFFFFFFFFFFF
Keys :1
pubkey : 03F93F8BEA92B4E860048D98C65BEA0B85C26B135433BE58647EE3EDE5D0315EFC
Number of CPU thread: 0
Range width: 2^56
Jump Avg distance: 2^28.01
Number of kangaroos: 2^17.39
Suggested DP: 10
Expected operations: 2^29.08
Expected RAM: 350.8MB

thankx

Opencl version ?

Any project in sight for amd gpu type? Thanks.

Herd / Kangaroo Questions

@JeanLucPons

When I use CPU and 16 threads, the output says Thread 0 = 1024 Kangaroos, Thread 1 = 1024 Kangaroos, and so on.

What is actually on each thread? Is thread 1,3,5,7,9,11,13,15 tame or wild Kangaroos and the even thread the opposite?

Are all the Kangaroos part of 1 herd or more herds? If more, how many herds?

Where in the code do you assign which threads/kangaroos are wild and which ones are tame?

JeanLucPons

give me the bitcoins if you find )))
everyone here is waiting for this only to find someone else's bitcoins and steal them

mistyping count = getCPUCount() + getCPUCount();

Kangaroo/Thread.cpp

Line 257 in 21a4538

count = getCPUCount() + getCPUCount();

Kangaroo Starting Positions

@JeanLucPons each time the program starts, are both Tame and Wild starting positions chosen randomly? Each time?
Or are they started from same position every time via a 'seed'?

Using seeds generates same thing every time, so if the starting positions are random each time, how is the randomness selected?

Thanks

Low speed with GTX1070

Hello i have a mining rig with 3 GTX 1070 and 3 nvidia P104
i compiled code with cuda 10.0

here is my command with 1 card

Kangaroo.exe -t 0 -g 128,256 -gpu -gpuId 1 in.txt
Kangaroo v1.2
Start:49DCCFD96DC5DF56487436F5A1B18C4F5D34F65DDB48CB5E0000000000000000
Stop :49DCCFD96DC5DF56487436F5A1B18C4F5D34F65DDB48CB5EFFFFFFFFFFFFFFFF
Keys :16
Number of CPU thread: 0
Range width: 2^64
Number of random walk: 2^22.00 (Max DP=8)
DP size: 8 [0xFF00000000000000]
GPU: GPU #1 P104-100 (15x128 cores) Grid(128x256) (393.0 MB used)
SolveKeyGPU Thread GPU#1: creating kangaroos...
SolveKeyGPU Thread GPU#1: 2^22.00 kangaroos in 175088.1ms
[9.80 MKey/s][GPU 9.80 MKey/s][Count 2^29.64][Dead 0][01:35][255.3MB]

and here is command with all cards

Kangaroo.exe -t 4 -gpu -gpuId 0,1,2,3,4,5 in.txt
Kangaroo v1.2
Start:25FEEE926526B0B4F0085358DF14702F7F6F04E8EC2200000000000000000000
Stop :25FEEE926526B0B4F0085358DF14702F7F6F04E8EC22FFFFFFFFFFFFFFFFFFFF
Keys :1
Number of CPU thread: 4
Range width: 2^80
Number of random walk: 2^22.49 (Max DP=15)
DP size: 15 [0xFFFE000000000000]
SolveKeyCPU Thread 0: 1024 kangaroos
SolveKeyCPU Thread 1: 1024 kangaroos
SolveKeyCPU Thread 3: 1024 kangaroos
SolveKeyCPU Thread 2: 1024 kangaroos
GPU: GPU #0 P104-100 (15x128 cores) Grid(30x256) (99.0 MB used)
SolveKeyGPU Thread GPU#0: creating kangaroos...
GPU: GPU #1 P104-100 (15x128 cores) Grid(30x256) (99.0 MB used)
SolveKeyGPU Thread GPU#1: creating kangaroos...
GPU: GPU #2 P104-100 (15x128 cores) Grid(30x256) (99.0 MB used)
SolveKeyGPU Thread GPU#2: creating kangaroos...
GPU: GPU #4 GeForce GTX 1070 (15x128 cores) Grid(30x256) (99.0 MB used)
SolveKeyGPU Thread GPU#4: creating kangaroos...
GPU: GPU #3 GeForce GTX 1070 (15x128 cores) Grid(30x256) (99.0 MB used)
GPU: GPU #5 GeForce GTX 1070 (15x128 cores) Grid(30x256) (99.0 MB used)
SolveKeyGPU Thread GPU#5: creating kangaroos...
SolveKeyGPU Thread GPU#3: creating kangaroos...
SolveKeyGPU Thread GPU#0: 2^19.91 kangaroos in 275949.1ms
SolveKeyGPU Thread GPU#2: 2^19.91 kangaroos in 274457.6ms
SolveKeyGPU Thread GPU#1: 2^19.91 kangaroos in 274979.0ms
SolveKeyGPU Thread GPU#4: 2^19.91 kangaroos in 275555.0ms
SolveKeyGPU Thread GPU#3: 2^19.91 kangaroos in 275891.8ms
SolveKeyGPU Thread GPU#5: 2^19.91 kangaroos in 276465.1ms
[57.85 MKey/s][GPU 56.81 MKey/s][Count 2^33.09][Dead 0][03:03][28.0MB]<

my question is why is it so slow when you get with 1 GTX 1050TI 125 Mkeys per card ?

Ubuntu compilation error. Help needed

Good day.

How to solve this problem:

 make gpu=1 ccap=20 all
cd obj &&       mkdir -p SECPK1
g++ -DWITHGPU -m64 -mssse3 -Wno-unused-result -Wno-write-strings -O2 -I. -I/usr/local/cuda-10.0/include -o obj/SECPK1/IntGroup.o -c SECPK1/IntGroup.cpp
SECPK1/IntGroup.cpp: In constructor 'IntGroup::IntGroup(int)':
[b]SECPK1/IntGroup.cpp:24:42: error: 'malloc' was not declared in this scope[/b]
   subp = (Int *)malloc(size * sizeof(Int));
                                          ^
SECPK1/IntGroup.cpp: In destructor 'IntGroup::~IntGroup()':
[b]SECPK1/IntGroup.cpp:28:12: error: 'free' was not declared in this scope[/b]
   free(subp);
            ^
Makefile:80: recipe for target 'obj/SECPK1/IntGroup.o' failed
make: *** [obj/SECPK1/IntGroup.o] Error 1`

???

Flag -ws -w -m combined regarding Multi pub key

Dear Jean-Luc,

When applying flags -ws -w -m in combination regarding a list of multi pub keys, I encountered the situation that the -w save.work file will be flushed after pubkey #0 is aborted, so pubkey 1 and 2 and so and so on will not advantage from the build save.work file regarding kangaroos.

Like to learn from you.

Cheers Satoshi

useing with gtx970

hi friends

i have gtx 970 gpu,also i have a list of adresses in a txt file. how can i use this exe file? which commands i have to write. i am very new. thank you in advance.

Running Comparison Test

@JeanLucPons

can you post the file that contains the 1000 keys for the test you did:

-t 2 -d 5 in40_1000.txt
[999] 2^21.926 Dead:5 Avg:2^21.147 DeadAvg:1.4 (2.214sqrt(N) 2.139sqrt(N))

Or tell me how you ran it? I'd like to run a test with some tweaks I've made and compare it against yours. I will post results.

Thanks

Error: invalid argument

Hi! Im error: invalid argument
Windows server 2019
Windows 10 ok.
What problem?
Bitcrack and vs-vanity-hybrid run without error, but bsgs and kangaroo no.

Satoshi address

What do you think guys some one is guess this 17XiVVooLcdCUCMf9s4t4jTExacxwFS5uh address.. i am pretty excited to know the bit range of those addresses. I hear that satoshi lost the private key of those addresses, is it true ???

Quadratic sieve

Hi @JeanLucPons! Look at Quadratic sieve math solving of the DLP

desired accuracy option and its default value

Hi!

Is it possible to add the desired accuracy option and also set its default value in the program? Accuracy could be set in probability %% (for example 75%) or in deviation from the average expected operations (for example +30% for the expected average range). If the desired acuuracy met the program stops and say that the key was not found.

The issue is the program will work forever if the input range was wrong. Even the program made the whole range operations, it will not stop.

Here is the short example:

I used the 2^33 range and the public key as the input:
3d2351dafaf9b1b4dd11e2ae87c6e5d4007100f36afd1740a885f9416c84a01e
3d2351dafaf9b1b4dd11e2ae87c6e5d4007100f36afd1740a885f94276067b89
04ac94fc802939963cab6818b890448c756ab5b44b523a9e90e65c48f87a3244df0748a7c458de0b0162a4b0848a0d856f2abb07557b0bbe5791156d4258ff9253

However the actual range was edited (instead or real range 4d2351... I used 3d2351... - changed the 1st letter from 4 to 3), so the 2^33 range was not correct.

This was the result of the program:
Kangaroo v1.3
Start:3D2351DAFAF9B1B4DD11E2AE87C6E5D4007100F36AFD1740A885F9416C84A01E
Stop :3D2351DAFAF9B1B4DD11E2AE87C6E5D4007100F36AFD1740A885F94276067B89
Keys :1
Number of CPU thread: 0
Range width: 2^33
Number of random walk: 2^20.81 (Max DP=0)
DP size: 0 [0x0]
GPU: GPU #0 GeForce GTX 1080 Ti (28x128 cores) Grid(56x256) (177.0 MB used)
SolveKeyGPU Thread GPU#0: creating kangaroos...
SolveKeyGPU Thread GPU#0: 2^20.81 kangaroos in 5439.5ms

Warning, 29229056 items lost
Hint: Search with less threads (-g)
[31.41 MKey/s][GPU 31.41 MKey/s][Count 2^33.25][Dead 1876287][03:46][3348.0MB]

We see that even the range length was 2^33, the program performed 2^33.25 operations... but it continued to work and kill kangaroos.... (almost 1.9 millions kangaroos were killed).

Reminder Support Multi Pub Key

Dear Jean luc
i think when you start dev GPU ver, first issue post is about Support Multi Pub Key
for 110 puzzle search range is big, and your program not fixed for search in range ( man, each time it will start 0 to 2110), each time attempt users are frusrated to see long time working, users want to have start and stop withing define working range inside 2110, hope your will maangae it
2nd most user want Support Multi Pub Key, its too much important for find 110 puzzle in early time, without Support Multi Pub Key, all way of dev regarding GPU kangaroo ver is good till 100 bit range, onword, Support Multi Pub Key version + multiGPU, +client server capablilities these required to find 110,115,120 only, for other puzzle like 125, strategy will be change again,
btw, you can design and dev as per your own experiance, and research
thankx

Train the LSTM network to associate public Bitcoin addresses with private keys

This is an interesting code that I unintentionally found, hoping to be inspiring to program development, code library address https://github.com/btc-room101

Benchmark GPU

Hi to all! I purpose to post here your results with your GPU and parameters!

Kangaroo jump program optimization suggestions

Almost all kangaroo jumping schemes are striding forward. Can we jump from both sides? To make an analogy: Now we are looking for a kangaroo between 1 and 100, set the kangaroo to jump from 1, 1,2,3,4,5,6 ......... the other side The kangaroo starts subtraction jumping from 100. 100,99,98,97,96,95 ......... The value of the kangaroo jump on both sides must be the same, both adding and subtracting 1 or 3 or 6. Others. 1 to 100 has an intermediate value of 50. In the case of even numbers (odd numbers divided by 2 plus 1 to remove the decimal point and mantissa), when the left kangaroo runs from 1 to 50 (in the case of the same jump, 100 kangaroos also just run To 50) Use percentage to indicate that 100% has been completed, the program ends, or continues to the next solution. I think the advantage of doing this is that it reduces the solution range by 2 times, and it is also beneficial to run on the server side, or even run two public keys at the same time, one on the left and one on the right. Of course, this may only run the range. 50%. What I mean may not be very good, this is just an idea for me, please advise me, thank you!

Convert to hex

Hello, how to convert the address to the right one for work? you can make sure that -bits 120 parameters are loaded, for example, and that you would re-arrange the usual address to 1 in the desired hex address

1.4gamma

./kangaroo -t 0 -gpu in.txt
Kangaroo v1.4gamma
Start:0
Stop :FFFFFFFFFFFFFF
Keys :1
Number of CPU thread: 0
Range width: 2^56
Jump Avg distance: 2^26.99
Number of kangaroos: 2^17.39
Suggested DP: 10
Expected operations: 2^29.45
Expected RAM: 55.7MB
DP size: 10 [0xffc0000000000000]
GPU: GPU #0 GeForce GTX 460 (7x48 cores) Grid(14x96) (24.8 MB used)
SolveKeyGPU Thread GPU#0: creating kangaroos...
SolveKeyGPU Thread GPU#0: 2^17.39 kangaroos in 810.0ms
[28.24 MK/s][GPU 28.24 MK/s][Count 2^33.57][Dead 271][08:35 (Avg 25s)][953.7MB] ^C

not solved

RAM usage question

When checking a range (say a smaller one like 1000000000000000:AFFFFFFFFFFFFFFF which is a 64 bit) and no result found, at what point will the program give up and move onto the next in list? I was seeing well above 6GB RAM with multiple "dead". Is it going to go thru however much RAM is free or is there a point where the program will say "nah, we're done here. Nothing to see. What's next?"

I suppose I'm thinking of in Telariust's CPU Kangaroo program, where you could pretty much tell when it was approaching hashtable overflow.

RAM / Memory / Storage

So program currently uses RAM. I know that RAM is faster than say SSD or HD. Why can't the DP/hashtable be written to a space on SSD and checked so many minutes for collision or just let it be slower than the current RAM way? I wouldn't care if I had to wait 30 minutes, an hour, 2 hours, etc to verify if a collision has been made, if I could increase the storage requirement by using SSD/HD.

Not possible? Am I missing something?

Support Multi Pub Key

Jean-Luc,

At first clap your hands for our French Master!

Thank you for this great app.

An question...how does the multi pub key search work...does it searches sequentially (start searching for the first pubkey in the in.txt file and move on) or searches it for ALL the pub keys at the same time and quotes a private key when it finds one of the pubkeys in the in.txt file.

Like to learn from you!

Greetings Satoshi

Suggestion for a "Restart Option"

It would be nice to save the hash-table into a file every predetermined time lapse for restarting purposes. It could be useful In case of a crash or maybe if one wants to interrupt the process which may last many days or months in real cases.

noob question

Is there any way to run those types of scripts through mining machines any information regarding my question is appreciated.. thank you

@jeanLucPons really appreciate.

Will you add this quarry where we input multiple used bitcoin addresses and through that quarry kangaroo will convert these addresses to public key and start searching in full range 0 to fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140 and one more thing search will be random if possible.

slow with multiple public keys or may be i am wrong please guide me

i put 2^1 to 2^64 different 600 public keys in in.txt set 0000000000000000:fffffffffffffffff it taking lot of time to find public keys if i am trying to find a single key which in under 2^64 it takes only 4 minutes maximum to find it . why with multiple keys it is slow or how long it will take to complete it please guide me

How to convert bitcoin address into format acceptable by in.txt

How can I convert a bitcoin address into the hex public key to put in my input file?

Preferably in python.