VanBitCracken - a program to use for 32 BTC challenge (supports RTX 30xx cards)

[WanderingPhilospher]

UPDATE 2: Newest version, VBCr 2.0 has been released. Now works with full address and/or prefix/strings.

It has been tested on Windows 10 and Windows 11 on RTX 30xx cards, RTX 20xx cards and a GTX 1660 Ti card.

Link:
https://github.com/WanderingPhilosopher/VanBitCrackenRandom2

SHA256 Checksum:

Code:

5415d56416632faa7058e1ddf2a6cde037d6df22778606128369df4557627dc3

Flags:

Code:

printf("VBCr [-check] [-v] [-u] [-b] [-c] [-gpu] [-stop] [-i inputfile]\n");
printf("             [-gpuId gpuId1[,gpuId2,...]] [-g g1x,g1y,[,g2x,g2y,...]]\n");
printf("             [-o outputfile] [-m maxFound] [-ps seed] [-s seed] [-t nbThread]\n");
printf("             [-bits bitsNumber] [-begr BeginRange] [-endr EndRange] [-dis Display Private Key] [-drk Display random keys] \n");
printf("             [-nosse] [-r rekey] [-check] [-kp] [-sp startPubKey] [-rp privkey partialkeyfile] [prefix]\n\n");
printf(" prefix: prefix to search (Can contain wildcard '?' or '*')\n");
printf(" -v: Print version\n");
printf(" -u: Search uncompressed addresses\n");
printf(" -b: Search both uncompressed or compressed addresses\n");
printf(" -c: Case unsensitive search\n");
printf(" -gpu: Enable gpu calculation\n");
printf(" -stop: Stop when all prefixes are found\n");
printf(" -i inputfile: Get list of prefixes to search from specified file\n");
printf(" -o outputfile: Output results to the specified file; Default is KeysFound.txt\n");
printf(" -gpu gpuId1,gpuId2,...: List of GPU(s) to use, default is 0\n");
printf(" -g g1x,g1y,g2x,g2y, ...: Specify GPU(s) kernel gridsize, default is 8*(MP number),128\n");
printf(" -m: Specify maximun number of prefixes found by each kernel call\n");
printf(" -s seed: Specify a seed for the base key, default is random\n");
printf(" -ps seed: Specify a seed concatened with a crypto secure random seed\n");
printf(" -t threadNumber: Specify number of CPU thread(s). Default is number of core(s)\n");
printf(" -bits bitsNumber: Specify bit length for private key. Default is 0 bits. -bits overrides -begr/-endr. \n");
printf(" -begr Begin Range: Specify Beginning Range in which you want to search, ex: 30000000000000000. Must use with -endr\n");
printf(" -endr End Range: Specify End of Range in which you want to search, ex: 3FFFFFFFFFFFFFFFF. Must use with -begr\n");
printf(" NOTE: when using -beginr and -endr, the program generates random keys in between those ranges. It will not\n");
printf("       search sequentially such as start at begr and stop at endr. Random keys in between the 2 ranges ONLY.\n");
printf(" -dis Display Private Key info on screen: 0 = off, 1 = on. Default is 0 / off.\n");
printf(" -drk Display random keys: 0 = off, 1 = on. Default is 0 / off.\n");
printf(" -nosse: Disable SSE hash function\n");
printf(" -l: List cuda enabled devices\n");
printf(" -check: Check CPU and GPU kernel vs CPU\n");
printf(" -cp privKey: Compute public key (privKey in hex hormat)\n");
printf(" -ca pubKey: Compute address (pubKey in hex hormat)\n");
printf(" -kp: Generate key pair\n");
printf(" -rp privkey partialkeyfile: Reconstruct final private key(s) from partial key(s) info.\n");
printf(" -sp startPubKey: Start the search with a pubKey (for private key splitting)\n");
printf(" -r rekey: Rekey interval in MegaKey (millions). Default is disabled / 0.\n");

Example batch file (for #66):

Code:

VBCr.exe -t 0 -bits 66 -gpu -g 360,512 -dis 1 -r 4800 -stop 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so
pause

Or, if you want to narrow the search down in between a specific range:

Code:

VBCr.exe -t 0 -begr 20000000000000000 -endr 21000000000000000 -gpu -g 360,512 -dis 1 -r 4800 -stop 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so
pause

UPDATE: The Random version is now available.
Link
https://github.com/WanderingPhilosopher/VanBitCrackenRandom

Read the readme to understand the different flags to use:
https://github.com/WanderingPhilosopher/VanBitCrackenRandom#readme


This thread is just to inform people of the release of the "Spread" version of VanBitCracken and now the Random version.

Link:
https://github.com/WanderingPhilosopher/VanBitCrakcenS

For now, I only have a Windows binary release. I will post source code later and may need help with Makefile since I am not a Linux/Makefile person; I mainly use Windows only, for better or for worse.

What is VanBitCracken?  It is a cross between Vanity Search and Bitcrack.  Telariust did the heavy lifting on this many months ago. I took the code and made minor tweaks and mods.  

What does it do?  Well, it can do what Vanity Search and Bitcrack do.  But it's primary purpose is to help find the keys in the 32 BTC transaction challenge.  AND, it does support RTX 30xx cards. Tested on a RTX 3070 card.  For now, if you are using a 30xx card, you will have to use an address string, not the full address.  Example:  Use 16jY7qLJnxb7CHZyqBP8qca9d51 instead of full address 16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN

A few people have the newer RTX 30xx cards but no program to run them on.  A few in the community are attempting to rewrite/rebuild/modify an existing program and that is great.  This program can be a fill in the gap until they accomplish tweaking the other program.

THAT IS THE reason behind the release...people struggling to use 30xx cards.

Hopefully someone does tweak existing programs or writes a new one to fully utilize the 30xx cards.

This is the VanBitCracken Spread Version. The Spread means that this specific version is geared towards covering ranges, not doing any random mode. The random mode will come later.

You can use the flags/options that the program known as "Bitcrack" uses, except the -b -t -p options. This program uses the grid size options that JLPs version used in version 15. If you want to adjust grid size, use the -g option. Since this is based off of version 15, the y grid size is hard coded so all you can adjust is the x grid size.

Example: -gpu -g 512 -gpuId 0 .

The other bonus feature of this program versus Bitcrack is it supports multiple GPUs.

The other difference from Bitcrack is this program will search for partial/strings of addresses and does not need a full address and can search for wildcards.

I will update this more in-depth later.

Other flags include:

-t for CPU threads (not optimized for CPU use, that was not the intent/focus)
-gpu for gpu use
-gpuId 0 (if more than one gpu use -gpuId 0,1,2,3,4 etc.)
-g to adjust x grid size; -g 256
--keyspace to enter your start and end range; example 80000:FFFFF
--continue to save work/progress; --continue continue.txt
-o for output/results file; -o outputfile.txt
-i for input file of addresses/strings; -i inputfile.txt
-r for rekey; -r 100000 the -r is important because in this spread version, it really tells the program how often to save your continue file in MKey/s. Based on your gpu and its MKey/s, you need to adjust the -r. If your gpu's speed is 100 MKey/s and you want to save your continue file every minute, then you would calculate 60 (seconds) multiplied by 100 = 6000; so you would want to input -r 6000. If you do not input a -r it will go to the default of 10000 and depending on your card you could be saving every 5 to seconds (not recommended.)

You can also enter a single address/string at the end of your command line/batch file; command line ....... 19Hed12



More to follow...

[1713980438]

1713980438

[1713980438]

1713980438

[1713980438]

1713980438

[WanderingPhilospher]

Some benchmarks:

36 bit range:

Code:

VanBitCrackenS v1.0
Keyspace start=800000000
Keyspace   end=FFFFFFFFF
Difficulty: 49015701099621550400511978774011251513098240
Search: 1Be2UF9NLfyLFbtm3TCbmuocc9 [Compressed]
Started at Fri Apr  2 14:18:43 2021
CPU threads used: 0
GPU: GPU #1 GeForce RTX 3070 (46x128 cores) Grid(368x512)

Finish at Fri Apr  2 14:18:47 2021

(Yes, it finds the key before any MKey/s are displayed, it took 4 seconds, start to finish)

37 bit range:

Code:

VanBitCrackenS v1.0
Keyspace start=1000000000
Keyspace   end=1FFFFFFFFF
Difficulty: 2842910663778049606317044711835302213583896576
Search: 14iXhn8bGajVWegZHJ18vJLHhnt [Compressed]
Started at Fri Apr  2 13:53:18 2021
CPU threads used: 0
GPU: GPU #1 GeForce RTX 3070 (46x128 cores) Grid(368x512)
1291.518 MK/s (GPU 1291.518 MK/s) (2^35.06) [00:00:26 Elapsed Time][0]
Finish at Fri Apr  2 13:53:48 2021

Multi GPU support:

Code:

VanBitCrackenS v1.0
Keyspace start=8000000000
Keyspace   end=FFFFFFFFFF
Difficulty: 49015701099621550400511978774011251513098240
Search: 1EeAxcprB2PpCnr34VfZdFrkUW [Compressed]
Started at Fri Apr  2 14:30:51 2021
CPU threads used: 0
GPU: GPU #1 GeForce RTX 3070 (46x128 cores) Grid(1024x512)
GPU: GPU #2 GeForce RTX 3070 (46x128 cores) Grid(1024x512)
GPU: GPU #3 GeForce RTX 3070 (46x128 cores) Grid(1024x512)
GPU: GPU #0 GeForce RTX 3070 (46x128 cores) Grid(1024x512)
5063.635 MK/s (GPU 5063.635 MK/s) (2^38.89) [00:01:46 Elapsed Time][0]
Finish at Fri Apr  2 14:32:47 2021

The first 36 keys/addresses in 32BTC challenge transaction:

Code:

VanBitCrackenS v1.0
Keyspace start=1
Keyspace   end=FFFFFFFFF
Search: 36 prefixes (Lookup size 36) [Compressed]
Started at Fri Apr  2 15:15:27 2021
CPU threads used: 0
GPU: GPU #0 GeForce RTX 3070 (46x128 cores) Grid(46x512)
1160.747 MK/s (GPU 1160.747 MK/s) (2^35.34) [00:00:37 Elapsed Time][35]
Finish at Fri Apr  2 15:16:07 2021

Opened up in bigger range:

Code:

VanBitCrackenS v1.0
Keyspace start=8000000000000000
Keyspace   end=FFFFFFFFFFFFFFFF
Difficulty: 49015701099621550400511978774011251513098240
Search: 1Be2UF9NLfyLFbtm3TCbmuocc9 [Compressed]
Started at Fri Apr  2 15:44:17 2021
CPU threads used: 0
GPU: GPU #0 GeForce RTX 3070 (46x128 cores) Grid(512x512)
1502.555 MK/s (GPU 1502.555 MK/s) (2^33.52) [00:00:08 Elapsed Time][0]

[WanderingPhilospher]

Reserved for OP...

[WanderingPhilospher]

Reserved for OP...

[WanderingPhilospher]

For those who may have used a similar version and worried about not stopping after key range has been exhausted.

Code:

VanBitCrackenS v1.0
Keyspace start=800000000
Keyspace   end=FFFFFFFFF
Difficulty: 1287559351899699109443338982391808
Search: 1DZwL7cMCYXeRjXTBzXA [Compressed]
Started at Fri Apr  2 14:23:20 2021
CPU threads used: 0
GPU: GPU #1 GeForce RTX 3070 (46x128 cores) Grid(368x512)
1295.291 MK/s (GPU 1295.291 MK/s) (2^36.01) [00:00:43 Elapsed Time][0]
[EXIT] Reached end of keyspace.

Finish at Fri Apr  2 14:24:06 2021

I ran the above with a key not in the range so it would run the entire range/keyspace.

[zahid888]

Its just awesome speed is bit low maybe i have to play with -g please suggest best grid size ??

[WanderingPhilospher]

Its just awesome speed is bit low maybe i have to play with -g please suggest best grid size ??

What is your card and speed?

Try -gpu -g 256 -gpuId 0 (or -g 512, or -g 1024)

[zahid888]

Its just awesome speed is bit low maybe i have to play with -g please suggest best grid size ??

What is your card and speed?

here is my benchmark

C:\Users\VanBitCrackenS1.exe  -t 0 -gpu -g 256 -i C:/puzzleprefix.txt -o C:/Result.txt --keyspace A36D5FE700000000:A36D5FE7ffffffff
VanBitCrackenS v1.0
Keyspace start=A36D5FE700000000
Keyspace   end=A36D5FE7FFFFFFFF
Search: 13 prefixes (Lookup size 13) [Compressed]
Started at Sat Apr  3 01:04:43 2021
CPU threads used: 0
GPU: GPU #0 GeForce RTX 3060 Ti (38x128 cores) Grid(256x512)
714.845 MK/s (GPU 714.845 MK/s) (2^32.00) [00:00:06 Elapsed Time][0]
[EXIT] Reached end of keyspace.

Finish at Sat Apr  3 01:04:51 2021

[zahid888]

Is it working with full prefixes

[WanderingPhilospher]

Its just awesome speed is bit low maybe i have to play with -g please suggest best grid size ??

What is your card and speed?

here is my benchmark

C:\Users\VanBitCrackenS1.exe  -t 0 -gpu -g 256 -i C:/puzzleprefix.txt -o C:/Result.txt --keyspace A36D5FE700000000:A36D5FE7ffffffff
VanBitCrackenS v1.0
Keyspace start=A36D5FE700000000
Keyspace   end=A36D5FE7FFFFFFFF
Search: 13 prefixes (Lookup size 13) [Compressed]
Started at Sat Apr  3 01:04:43 2021
CPU threads used: 0
GPU: GPU #0 GeForce RTX 3060 Ti (38x128 cores) Grid(256x512)
714.845 MK/s (GPU 714.845 MK/s) (2^32.00) [00:00:06 Elapsed Time][0]
[EXIT] Reached end of keyspace.

Finish at Sat Apr  3 01:04:51 2021

8 seconds to get through the range? May need to open it up a bit.  Also, the MKey/s rate will drop when the program is getting ready to roll over to the next keys and then pick right back up. Try adding -r if you try a larger range.

[WanderingPhilospher]

Is it working with full prefixes

No, for now, if you are using a 30xx card, you will have to use an address string, not the full address.  Example:  Use 16jY7qLJnxb7CHZyqBP8qca9d51 instead of full address 16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN

But you can still use input file with many addresses you just have to cut off last 7-8 characters of address.

[zahid888]

https://imgur.com/PnFz735

[WanderingPhilospher]

https://imgur.com/PnFz735

In smaller range with mulitple prefixes, I actually drop the x grid size.

I match it up with the actual x size. So for 3070 it is 46 so I put in a -g 46.  But you can tweak to your liking.  Have you tried one prefix/address?

If it could use full address and search for RIPE, would be faster.

[zahid888]

I am very happy if --stride has also enabled here it would be icing on the cake 

[WanderingPhilospher]

I am very happy if --stride has also enabled here it would be icing on the cake 

Honestly, I never understood the point of stride. I was always "afraid" I would "stride" right over the key!

I prefer random over stride.  May have to get with Pawgo; I know he has implemented a stride function in one of JLPs other programs.  If it's something easy, I could possibly implement, but I haven't even thought about it since I really didn't understand the "why" behind it.

[zahid888]

In smaller range with mulitple prefixes, I actually drop the x grid size.

I match it up with the actual x size. So for 3070 it is 46 so I put in a -g 46.  But you can tweak to your liking.  Have you tried one prefix/address?

If it could use full address and search for RIPE, would be faster.

in full address

C:\VanBitCracken\VanBitCrackenS1.exe -gpu --keyspace 8000000000000000:ffffffffffffffff 16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN
VanBitCrackenS v1.0
Keyspace start=8000000000000000
Keyspace   end=FFFFFFFFFFFFFFFF
Difficulty: 1461501637330902918203684832716283019655932542976
Search: 16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN [Compressed]
Started at Sat Apr  3 02:26:04 2021
CPU threads used: 5
GPU: GPU #0 GeForce RTX 3060 Ti (38x128 cores) Grid(304x512)
794.487 MK/s (GPU 775.923 MK/s) (2^32.19) [00:00:06 Elapsed Time][0]GPUEngine: Launch: misaligned address

Finish at Sat Apr  3 02:26:13 2021

Can you release 512, 256 and 128 also

[WanderingPhilospher]

In smaller range with mulitple prefixes, I actually drop the x grid size.

I match it up with the actual x size. So for 3070 it is 46 so I put in a -g 46.  But you can tweak to your liking.  Have you tried one prefix/address?

If it could use full address and search for RIPE, would be faster.

in full address

C:\VanBitCracken\VanBitCrackenS1.exe -gpu --keyspace 8000000000000000:ffffffffffffffff 16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN
VanBitCrackenS v1.0
Keyspace start=8000000000000000
Keyspace   end=FFFFFFFFFFFFFFFF
Difficulty: 1461501637330902918203684832716283019655932542976
Search: 16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN [Compressed]
Started at Sat Apr  3 02:26:04 2021
CPU threads used: 5
GPU: GPU #0 GeForce RTX 3060 Ti (38x128 cores) Grid(304x512)
794.487 MK/s (GPU 775.923 MK/s) (2^32.19) [00:00:06 Elapsed Time][0]GPUEngine: Launch: misaligned address

Finish at Sat Apr  3 02:26:13 2021

Right, as I said, must use string vs full address. I usally chop 7 to 8 characters off.
That's what I don't get. Everyone trying to tweak the other program which won't even run with updated drivers, with any 20xx or 30xx cards, and try to fix the misaligned address issue. Where as VS/VBC only has the issue of using full address.  Maybe everyone loves the "stride" version as you stated  
Anywho, hopefully someone figures it all out or Jean Luc comes back to save the day!

Can you release 512, 256 and 128 also

I ran those for comparisons but the 512 always got through a range faster. I even recompiled newer version where you could manually enter -g x,y and it didn't even perform as well.

[fxsniper]

Thank you WanderingPhilospher for VanBitCracken

my test for small GPU

Code:

VanBitCrackenS1 -t 0 -gpu -gpuId 0 -r 150000 --keyspace d555555555555400:ffffffffffffffff -o output.txt -i input.txt 16jY7qLJnxb7CHZyqBP8qca9d51gAjyXQN
VanBitCrackenS v1.0
Keyspace start=D555555555555400
Keyspace   end=FFFFFFFFFFFFFFFF
Search: 11 prefixes (Lookup size 1) [Compressed]
Started at Sat Apr  3 08:11:22 2021
CPU threads used: 0
GPU: GPU #0 GeForce GTX 1050 (5x128 cores) Grid(40x512)
68.915 MK/s (GPU 68.915 MK/s) (2^29.64) [00:00:12 Elapsed Time][194]

I scan by strategy search (random keyspace) not scan by power of GPU my GPU is very very small

[fxsniper]

Code:

VanBitCrackenS1 -t 0 -gpu -gpuId 0 -r 150000 --keyspace 800000000:FFFFFFFFF 1Be2UF9NLfyLFbtm3TCbmuocc9
VanBitCrackenS v1.0
Keyspace start=800000000
Keyspace   end=FFFFFFFFF
Difficulty: 49015701099621550400511978774011251513098240
Search: 1Be2UF9NLfyLFbtm3TCbmuocc9 [Compressed]
Started at Sat Apr  3 08:45:35 2021
CPU threads used: 0
GPU: GPU #0 GeForce GTX 1050 (5x128 cores) Grid(40x512)
67.027 MK/s (GPU 67.027 MK/s) (2^31.85) [00:00:56 Elapsed Time][0]
65.763 MK/s (GPU 65.763 MK/s) (2^37.13) [00:37:06 Elapsed Time][1]
[EXIT] Reached end of keyspace.

Finish at Sat Apr  3 09:22:44 2021

compare
GeForce RTX 3060 Ti use time 1 second

my GTX 1050 use time near 1 hour for scan all key space

Can possible to print out key if not use options output
or print both may be safety

Scan found key but not use -o out.txt for save it make mission key

[WanderingPhilospher]

Code:

VanBitCrackenS1 -t 0 -gpu -gpuId 0 -r 150000 --keyspace 800000000:FFFFFFFFF 1Be2UF9NLfyLFbtm3TCbmuocc9
VanBitCrackenS v1.0
Keyspace start=800000000
Keyspace   end=FFFFFFFFF
Difficulty: 49015701099621550400511978774011251513098240
Search: 1Be2UF9NLfyLFbtm3TCbmuocc9 [Compressed]
Started at Sat Apr  3 08:45:35 2021
CPU threads used: 0
GPU: GPU #0 GeForce GTX 1050 (5x128 cores) Grid(40x512)
67.027 MK/s (GPU 67.027 MK/s) (2^31.85) [00:00:56 Elapsed Time][0]
65.763 MK/s (GPU 65.763 MK/s) (2^37.13) [00:37:06 Elapsed Time][1]
[EXIT] Reached end of keyspace.

Finish at Sat Apr  3 09:22:44 2021

compare
GeForce RTX 3060 Ti use time 1 second

my GTX 1050 use time near 1 hour for scan all key space

Can possible to print out key if not use options output
or print both may be safety

Scan found key but not use -o out.txt for save it make mission key

I'll look into it fxsniper...I do understand the concern.
Also, since you are using a 1050, you should be able to use full address and gain speed.

[fxsniper]

I'll look into it fxsniper...I do understand the concern.
Also, since you are using a 1050, you should be able to use full address and gain speed.

I try again program work fine result

output.txt
1Be2UF9NLfyLFbtm3TCbmuocc9N1Kduci1  9DE820A7C


actually this is user error, user forget use output option to save result

so, make it both print out to default is better  (and make option for don't print out)
make program to feel better use
if user error still work fine

1. default ==> printout output when found key

2. no use any option = default => printout

3. use option -o output.txt  ==> do both
save result to output.txt
and print output

4. if use option -noprint will no print on screen

5. or warning no output setting

because if missing it is found key but make it Waste of time a lot
user error, but don't blame user

thank for update

[WanderingPhilospher]

I'll look into it fxsniper...I do understand the concern.
Also, since you are using a 1050, you should be able to use full address and gain speed.

I try again program work fine result

output.txt
1Be2UF9NLfyLFbtm3TCbmuocc9N1Kduci1  9DE820A7C


actually this is user error, user forget use output option to save result

so, make it both print out to default is better  (and make option for don't print out)
make program to feel better use
if user error still work fine

1. default ==> printout output when found key

2. no use any option = default => printout

3. use option -o output.txt  ==> do both
save result to output.txt
and print output

4. if use option -noprint will no print on screen

5. or warning no output setting

because if missing it is found key but make it Waste of time a lot
user error, but don't blame user

thank for update

I released version 1.1; will print keys found to "KeysFound.txt" if user forgets to add -o option or pause at end of batch file. Try with no -o

https://github.com/WanderingPhilosopher/VanBitCrakcenS/releases/tag/1.1

Actually it will print KeysFound.txt whether -o was used or not, but a fail safe for now.

[fxsniper]

I released version 1.1; will print keys found to "KeysFound.txt" if user forgets to add -o option or pause at end of batch file. Try with no -o

https://github.com/WanderingPhilosopher/VanBitCrakcenS/releases/tag/1.1

Actually it will print KeysFound.txt whether -o was used or not, but a fail safe for now.

Thank you very much for fast update

[lostrelic]

Any chance of step by step guide to run this i cant even get it to run. Ive downloaded all files but not sure what to do after sorry if its simple just wanted to test my 3080 on it. Thanks lostrelic

[fxsniper]

I released version 1.1; will print keys found to "KeysFound.txt" if user forgets to add -o option or pause at end of batch file. Try with no -o

https://github.com/WanderingPhilosopher/VanBitCrakcenS/releases/tag/1.1

Actually it will print KeysFound.txt whether -o was used or not, but a fail safe for now.

Now I roll back to using version 1.0
I use -o output  for save  result that save difference key

version 1.1 not save from command -o output
but every thing move to save on KeysFound.txt

[NotATether]

Great job. I can write the Makefile for you if it doesn't exist.

So apparently JeanLucPONS was making patches to Bitcrack at one point, is that correct?

The README file has this gem in it:

the y grid size is hard coded so all you can adjust is the x grid size.

My question is is there a benefit to being able to adjust the Y grid size? CUDA usually sets the limit for the x and y dimensions to the same number so I'm just wondering if there's a possibility that CUDA is more "tuned" for large Y/small x or small Y/large x or equal dimensions or something like that.

[fxsniper]

Reference with post on thread bitcoin puzzle 100 update

it is good idea for mod output to csv format and have other data information


https://bitcointalk.org/index.php?topic=5218972.msg56696467#msg56696467

my output ...

PADDXR,
Privkey_HEX,
BTC_ADDRESS,
Base58_Decode(BTC_ADDRESS),
PublicKeyHEX,
Priv (WIF),
0xPrivkey_HEX_64byte

[WanderingPhilospher]

Any chance of step by step guide to run this i cant even get it to run. Ive downloaded all files but not sure what to do after sorry if its simple just wanted to test my 3080 on it. Thanks lostrelic

Download exe and place in a folder. Create a batchfile and place in same folder. 

If you downloaded version 1.1

Batch file:

Code:

VanBitCrackenS1.1 -t 0 -gpu -g 512 -gpuId 0 -r 60000 --keyspace 8000000000000000:FFFFFFFFFFFFFFFF 16jY7qLJ
pause

(remember to save as .bat)

If you downloaded version 1.0

Code:

VanBitCrackenS1 -t 0 -gpu -g 512 -gpuId 0 -r 60000 --keyspace 8000000000000000:FFFFFFFFFFFFFFFF -o output.txt 16jY7qLJ
pause

(remember to save as .bat)

Double click batch file and let it run.

[WanderingPhilospher]

Great job. I can write the Makefile for you if it doesn't exist.

So apparently JeanLucPONS was making patches to Bitcrack at one point, is that correct?

The README file has this gem in it:

the y grid size is hard coded so all you can adjust is the x grid size.

My question is is there a benefit to being able to adjust the Y grid size? CUDA usually sets the limit for the x and y dimensions to the same number so I'm just wondering if there's a possibility that CUDA is more "tuned" for large Y/small x or small Y/large x or equal dimensions or something like that.

You know, I'm not sure if JLP did or did not make any patches for Bitcrack.

For the x and y CUDA grids, that's a good question.  It always seems if you increase the y, the card performs better from a speed standpoint.

I will PM you the Makefile and you can take a look at it.

[lostrelic]

Any chance of step by step guide to run this i cant even get it to run. Ive downloaded all files but not sure what to do after sorry if its simple just wanted to test my 3080 on it. Thanks lostrelic

Download exe and place in a folder. Create a batchfile and place in same folder. 

If you downloaded version 1.1

Batch file:

Code:

VanBitCrackenS1.1 -t 0 -gpu -g 512 -gpuId 0 -r 60000 --keyspace 8000000000000000:FFFFFFFFFFFFFFFF 16jY7qLJ
pause

(remember to save as .bat)

If you downloaded version 1.0

Code:

VanBitCrackenS1 -t 0 -gpu -g 512 -gpuId 0 -r 60000 --keyspace 8000000000000000:FFFFFFFFFFFFFFFF -o output.txt 16jY7qLJ
pause

(remember to save as .bat)

Double click batch file and let it run.

Thanks will try again

[a.a]

Where is the sourcecode?

[Desyationer]

stride mode please not work

[BitNoob21]

awesome program, thank you for your hard work...  Signed up just to post these suggestions...

I know in its current form, its just a start from one point and 1by1 increment....

1) like many the -stride function (aka increment up by 100,000 instead of 1)
2) ability to check for the REVERSE of the hash
3) -random function with some options
      a) ability to also create a "mask" that will increment each position a certain number (for instance 000000001100111000111000110045980813040) would increment each position by the number in that position forwards
          and backwards
      b) again to do the reverse with the above options
      c) if possible restrict the number of duplicates in a row...example... -max-duplicates 3 means in the key no more than 3 of the same letters/numbers in a row... (not sure if this can be controlled with "random" but thought I would ask)

4) ability to input your own hex keys as a file input/stdin
5) on the command line display have the ability to see the status/pause/etc.. kinda like hashcat

Thank you again for your hard work.

[NotATether]

3) -random function with some options
      a) ability to also create a "mask" that will increment each position a certain number (for instance 000000001100111000111000110045980813040) would increment each position by the number in that position forwards
          and backwards
      b) again to do the reverse with the above options
      c) if possible restrict the number of duplicates in a row...example... -max-duplicates 3 means in the key no more than 3 of the same letters/numbers in a row... (not sure if this can be controlled with "random" but thought I would ask)

Masks are hard for users to find the optimal one, no? A bitmask will eventually translate down to a stride amount anyway so maybe instead of a bitmask, there could be some "oscillators" built inside the program each of which implements a different stride amount for each iteration. Kind of like how analog frequency is variable but has different patterns.

[WanderingPhilospher]

awesome program, thank you for your hard work...  Signed up just to post these suggestions...

I know in its current form, its just a start from one point and 1by1 increment....

1) like many the -stride function (aka increment up by 100,000 instead of 1)
2) ability to check for the REVERSE of the hash
3) -random function with some options
      a) ability to also create a "mask" that will increment each position a certain number (for instance 000000001100111000111000110045980813040) would increment each position by the number in that position forwards
          and backwards
      b) again to do the reverse with the above options
      c) if possible restrict the number of duplicates in a row...example... -max-duplicates 3 means in the key no more than 3 of the same letters/numbers in a row... (not sure if this can be controlled with "random" but thought I would ask)

4) ability to input your own hex keys as a file input/stdin
5) on the command line display have the ability to see the status/pause/etc.. kinda like hashcat

Thank you again for your hard work.

TBH, most of what you suggested is above my skillset.

I am currently looking for source code of the random version of VBC which randomly generates new points, so if you have grid size of 10*100 on your GPU, then the program will create 1000 random points and start searching incrementally from each random point, but you can adjust how often it re randomizes and starts the process all over again. So in theory you could set it to re randomize every second.

But that will be on my task list first. I had a project to create a solo mining pool on an old PC (running geth and acting as server) and see if I could mine some blocks; and I did that. So I have a few other personal tasks to complete and then I'll start on random feature.

Solo mining pool test with actual results; completed:
https://bitcointalk.org/index.php?topic=5346020.0

Eth miner / mining comparison tests up and running with real live results; completed:
https://bitcointalk.org/index.php?topic=5346433.0

Knocking things off the todo list, one by one.
I can say this, once mining cools down, I'll be back to experimenting with these key finding programs 100%

[gamefinder]

Heres the version of BitCrack that has the source code to generate random points.

Hopefully it helps in speeding things along for you and getting -r implemented.

https://github.com/neutron220/BitCrack

[WanderingPhilospher]

Heres the version of BitCrack that has the source code to generate random points.

Hopefully it helps in speeding things along for you and getting -r implemented.

https://github.com/neutron220/BitCrack

So are you just wanting to search in a keyspace of something like 80000:8FFFF and have a program that generates random points all in between that keyspace?

[gamefinder]

Heres the version of BitCrack that has the source code to generate random points.

Hopefully it helps in speeding things along for you and getting -r implemented.

https://github.com/neutron220/BitCrack

So are you just wanting to search in a keyspace of something like 80000:8FFFF and have a program that generates random points all in between that keyspace?

Yes that is correct!
I think a few others were requesting this above with the -r feature.

[gamefinder]

I can donate a few dollars in BTC for the random implementation, but sadly I don't have much. 

[WanderingPhilospher]

I can donate a few dollars in BTC for the random implementation, but sadly I don't have much. 

I may have what you already want.

I just need to make sure it is what it is.

Please reexplain what you are wanting to do. Is it just to create random points over and over inside a defined keyspace?

If it's something I have or can do, no need for donation, I do it to tinker, to actually get something to work.

[gamefinder]

I can donate a few dollars in BTC for the random implementation, but sadly I don't have much.  

I may have what you already want.

I just need to make sure it is what it is.

Please reexplain what you are wanting to do. Is it just to create random points over and over inside a defined keyspace?

If it's something I have or can do, no need for donation, I do it to tinker, to actually get something to work.

Yes that's correct, say I set a keyspace, it generates random points to search within that keyspace.

[Angelo1710]

I can donate a few dollars in BTC for the random implementation, but sadly I don't have much. 

I may have what you already want.

I just need to make sure it is what it is.

Please reexplain what you are wanting to do. Is it just to create random points over and over inside a defined keyspace?

If it's something I have or can do, no need for donation, I do it to tinker, to actually get something to work.

Tested program, it's nice. About 2x faster then pika's random version of bitcrack. I would love to have -r random feature here also. If possible that every point that is created is random in defined keyspace, not just starting points that are random like in bitcrack. So you define your keyspace and it goes randomly through whole keyspace it on each point, not just creating starting points and going in +1 increments.

[WanderingPhilospher]

I can donate a few dollars in BTC for the random implementation, but sadly I don't have much. 

I may have what you already want.

I just need to make sure it is what it is.

Please reexplain what you are wanting to do. Is it just to create random points over and over inside a defined keyspace?

If it's something I have or can do, no need for donation, I do it to tinker, to actually get something to work.

Tested program, it's nice. About 2x faster then pika's random version of bitcrack. I would love to have -r random feature here also. If possible that every point that is created is random in defined keyspace, not just starting points that are random like in bitcrack. So you define your keyspace and it goes randomly through whole keyspace it on each point, not just creating starting points and going in +1 increments.

You say "...define a keyspace and it goes randomly through whole keyspace "it" (not sure what you meant by it) on each point, not just creating starting points and going in +1 increments."
I do not understand how this is random. It sounds like you want it to go check each point in the keyspace or do random jumps through the keyspace. I get confused when you say through the whole keyspace. What I have does the following:

top range/keyspace/beginning range you want to start with
800000
so that is a 24 bit top range

You define if you want random keys generated in all of 24 bit range by selecting subrange of 23; now it will generate random points from 8000000 through FFFFFF
if you wanted to search subrange of 16 bit you select subrange of 16; now it will generate random points from 8000000 through 80FFFF

You control how often it generates random points using the -r (rekey) feature.

But this program is designed to generate and regenerate random points in a given keyspace as often as you like.  It will generate your GPU grid size random points and go sequentially from each random point. Once it rekeys, it generates new random points and goes sequentially. Let's say your GPU gets 100 MKey/s; you could put -r 100 and the program would generate new random points every 1 second.

The difference is; bitcrack generates random starting points and goes sequentially until keyspace has been searched; the program eventually ends.

My program just keeps generating random points and it will never end, until you close the program down. It will never start with random points and walk them sequentially until whole keyspace is searched.

[Angelo1710]

I can donate a few dollars in BTC for the random implementation, but sadly I don't have much.  

I may have what you already want.

I just need to make sure it is what it is.

Please reexplain what you are wanting to do. Is it just to create random points over and over inside a defined keyspace?

If it's something I have or can do, no need for donation, I do it to tinker, to actually get something to work.

Tested program, it's nice. About 2x faster then pika's random version of bitcrack. I would love to have -r random feature here also. If possible that every point that is created is random in defined keyspace, not just starting points that are random like in bitcrack. So you define your keyspace and it goes randomly through whole keyspace it on each point, not just creating starting points and going in +1 increments.

You say "...define a keyspace and it goes randomly through whole keyspace "it" (not sure what you meant by it) on each point, not just creating starting points and going in +1 increments."
I do not understand how this is random. It sounds like you want it to go check each point in the keyspace or do random jumps through the keyspace. I get confused when you say through the whole keyspace. What I have does the following:

top range/keyspace/beginning range you want to start with
800000
so that is a 24 bit top range

You define if you want random keys generated in all of 24 bit range by selecting subrange of 23; now it will generate random points from 8000000 through FFFFFF
if you wanted to search subrange of 16 bit you select subrange of 16; now it will generate random points from 8000000 through 80FFFF

You control how often it generates random points using the -r (rekey) feature.

But this program is designed to generate and regenerate random points in a given keyspace as often as you like.  It will generate your GPU grid size random points and go sequentially from each random point. Once it rekeys, it generates new random points and goes sequentially. Let's say your GPU gets 100 MKey/s; you could put -r 100 and the program would generate new random points every 1 second.

The difference is; bitcrack generates random starting points and goes sequentially until keyspace has been searched; the program eventually ends.

My program just keeps generating random points and it will never end, until you close the program down. It will never start with random points and walk them sequentially until whole keyspace is searched.

Tnx, now I understand. Had no idea your -r feature does that, will use it from now on, that is exactly what I wanted.

[Angelo1710]

Btw any idea why program is not working when you try to search for both compressed and uncompressed addresses? Getting error when I try and program stops.

[WanderingPhilospher]

Btw any idea why program is not working when you try to search for both compressed and uncompressed addresses? Getting error when I try and program stops.

Can you show what commands you are using when receiving this error? Your batch file command or cmd line?

Tnx, now I understand. Had no idea your -r feature does that, will use it from now on, that is exactly what I wanted.

The Spread version does not do this, it is the Random version that does that.

[gamefinder]

You control how often it generates random points using the -r (rekey) feature.
My program just keeps generating random points and it will never end, until you close the program down. It will never start with random points and walk them sequentially until whole keyspace is searched.

I've tried this, but I have a question about it, when it generates random points, is it confined to the current 2^? I put in C000000000000000 as a starting keyspace, will it only generate random points within the 2^35 vs all the way up to 2^64?

For example I put a --keyspace of C000000000000000:E000000000000000, it found a key at C00000037925BAAB, does this imply it's presently not searching in a higher range in the keyspace?

Also, is it completely random? As I've stopped and restarted, and always find the same key when using -r.

[WanderingPhilospher]

You control how often it generates random points using the -r (rekey) feature.
My program just keeps generating random points and it will never end, until you close the program down. It will never start with random points and walk them sequentially until whole keyspace is searched.

I've tried this, but I have a question about it, when it generates random points, is it confined to the current 2^? I put in C000000000000000 as a starting keyspace, will it only generate random points within the 2^35 vs all the way up to 2^64?

For example I put a --keyspace of C000000000000000:E000000000000000, it found a key at C00000037925BAAB, does this imply it's presently not searching in a higher range in the keyspace?

Also, is it completely random? As I've stopped and restarted, and always find the same key when using -r.

The Spread version does not work the random I have spoke about, Spread acts as normal, starts at start range and progresses the same way each time.
Go to Random version:
https://github.com/WanderingPhilosopher/VanBitCrackenRandom
I haven't had time to upload how to use the flags. But if you reread:

top range/keyspace/beginning range you want to start with
800000
so that is a 24 bit top range

You define if you want random keys generated in all of 24 bit range by selecting subrange of 23; now it will generate random points from 8000000 through FFFFFF
if you wanted to search subrange of 16 bit you select subrange of 16; now it will generate random points from 8000000 through 80FFFF

You control how often it generates random points using the -r (rekey) feature.

You will have an understanding.

use -topr for toprange such as -topr 800000
use -subr for subrange (in bits) such as -subr 16
use the -r to tell program how often to regen new random points within that range such as -r 1200 (every 1200,000,000 keys)

With that setup, the program will generate random points from 800000 to 80FFFF.

Try it let me know how it works for you and if you have any questions.

[WanderingPhilospher]

Here is VBCRandom in action.
Batch file settings:

Code:

VBCRandom -t 0 -gpu -gpuId 0 -topr 8000000000000000 -subr 48 -r 480 --keyspace 8000000000000000:FFFFFFFFFFFFFFFF -o randomtest.txt 16jY7q

Results:

Code:

Started Sat Aug 28 12:32:28 2021
Start Range  :  8000000000000000
End   Range  :  FFFFFFFFFFFFFFFF
Searching For:  16jY7q
Compression  :  Compressed
CPU threads  :  0
GPU          :  GPU #0 NVIDIA GeForce GTX 1060 6GB (10x128 cores) Grid(80x512)

Random Key   :  800007AC8B3D5525
Random Key   :  8000201C33F5235B
Random Key   :  8000E2F090E63C7D
 [00:00:04 Run Time ] [Speed 82.524 MK/s] [Total Keys: 335,544,320] [# Rekeys: 0] [Found: 2]
Random Key   :  8000208FB1B474F6
Random Key   :  8000B9FC61E9ABA1
Random Key   :  8000F0310FBE3DD2
 [00:00:08 Run Time ] [Speed 82.563 MK/s] [Total Keys: 671,088,640] [# Rekeys: 1] [Found: 4]
Random Key   :  80004698D58E9E8F
Random Key   :  800089612D96CDA0
Random Key   :  8000C2190CD91261
 [00:00:15 Run Time ] [Speed 81.609 MK/s] [Total Keys: 1,258,291,200] [# Rekeys: 2] [Found: 6]
Random Key   :  800043E67DBAB51D
Random Key   :  800098B29829B7A7
Random Key   :  800045B53E8E1753
 [00:00:20 Run Time ] [Speed 79.286 MK/s] [Total Keys: 1,593,835,520] [# Rekeys: 2] [Found: 6]

Key results:

Code:

Pub Addr: 16jY7qzxujzi1K7GaEc17ZFokFymagY3jG
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLz94bU7Lw952JxZUX
Priv (HEX): 0x000000000000000000000000000000000000000000000000800015BE8DF950C5

Pub Addr: 16jY7qdry8xB4v6JeMH2R3ViVTSTzDGv2B
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLzUZ1qwKHqCmVgPRj
Priv (HEX): 0x000000000000000000000000000000000000000000000000800064574E06912E

Pub Addr: 16jY7qwSUyCss5jZYDjgJofLe7KgKxiCQo
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLzGCmCHBUm9fupLgz
Priv (HEX): 0x0000000000000000000000000000000000000000000000008000328A78D70051

Pub Addr: 16jY7q7x9EjwysPAYtappeDX6Lqtm32ekf
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLzCiYnMdjWKzRsXUn
Priv (HEX): 0x0000000000000000000000000000000000000000000000008000247B3183BFDC

Pub Addr: 16jY7qTWTgUzCEEH7E9UFxVKALnvCcykwV
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLziDMQ1SzkL55t52w
Priv (HEX): 0x00000000000000000000000000000000000000000000000080009B6E64AE0CAD

Pub Addr: 16jY7qwSwoyaH2NT2dKsY15h11Gma5bccb
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLzSjUdaY9XWkAo8pE
Priv (HEX): 0x00000000000000000000000000000000000000000000000080005D00CB38A1B5

Pub Addr: 16jY7qCNptT19yStBa3tgVFy2k7CvhLi8t
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvM13ZD8mLPHJMsj9c6
Priv (HEX): 0x0000000000000000000000000000000000000000000000008000E96EBB6FFC70

Pub Addr: 16jY7q3WZumGZ4gbrDTSte9JTbhEniZpqP
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLzLQVfZGJ81tzYnbi
Priv (HEX): 0x0000000000000000000000000000000000000000000000008000437CBF9A4063

Pub Addr: 16jY7qSaxGdCNribBnf6oxcpaw7aBUA6nN
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLzMkoUUXmUpiqDSm1
Priv (HEX): 0x000000000000000000000000000000000000000000000000800048EE90360155

Pub Addr: 16jY7qSV4qyaXJNmwWCu2t4DRWHuTnQuwz
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLz9toCoHuQiZuBD2p
Priv (HEX): 0x000000000000000000000000000000000000000000000000800019188671357A

Pub Addr: 16jY7qJ3MdatyubzBQ4e67n5D2iJRqFrDY
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLzZLFmMZj3v26fWhh
Priv (HEX): 0x0000000000000000000000000000000000000000000000008000779DFF73D53B

See how every new random key is within the same 48 bit range? Now you could change the -topr to whatever toprange and the -subr to whatever subrange. If in the example above you wanted to search every possible range in the toprange of 8000000000000000, you would use -topr 8000000000000000 and -subr 60.

Make sense?

use the -b for compressed and uncompressed.

[Angelo1710]

Btw any idea why program is not working when you try to search for both compressed and uncompressed addresses? Getting error when I try and program stops.

Can you show what commands you are using when receiving this error? Your batch file command or cmd line?

Tnx, now I understand. Had no idea your -r feature does that, will use it from now on, that is exactly what I wanted.

The Spread version does not do this, it is the Random version that does that.

I was using -b command. Ok will try VBCRandom verson later today and let you know. Can you explain more how exactly it creates random points and how many of them does it creates. If my gpu runs lets say at 100mk/s, and I use -r 100, will it then run at 100mk/s and evey single key would be random from those 100m keys?
I want it to run at 100mk/s for example and that every key is created randomly through whole keyspace I defined with --keyspace. Lets say I want it to search through --keyspace 1000000000000:FFFFFFFFFFFFF and that it runs through that whole keyspace completely randomly, every single point in that keyspace is generated randomly.
Sorry idk how to explain this better.

[WanderingPhilospher]

Btw any idea why program is not working when you try to search for both compressed and uncompressed addresses? Getting error when I try and program stops.

Can you show what commands you are using when receiving this error? Your batch file command or cmd line?

Tnx, now I understand. Had no idea your -r feature does that, will use it from now on, that is exactly what I wanted.

The Spread version does not do this, it is the Random version that does that.

I was using -b command. Ok will try VBCRandom verson later today and let you know. Can you explain more how exactly it creates random points and how many of them does it creates. If my gpu runs lets say at 100mk/s, and I use -r 100, will it then run at 100mk/s and evey single key would be random from those 100m keys?
I want it to run at 100mk/s for example and that every key is created randomly through whole keyspace I defined with --keyspace. Lets say I want it to search through --keyspace 1000000000000:FFFFFFFFFFFFF and that it runs through that whole keyspace completely randomly, every single point in that keyspace is generated randomly.
Sorry idk how to explain this better.

REread the above or the github page. The keyspace is not really needed in the random version.

(-topr stands for toprange and -subr stands for subrange)

If you wanted to generate random keys in the 8000000000000:FFFFFFFFFFFFF range (52 bit range) you would use the flags:
-topr 8000000000000 and -subr 51

Using subr of 51 (51 bits) will add 0 to 7FFFFFFFFFFFF TO the topr of 8000000000000. So the lowest point created will be in the 8000000000000 range and the highest point that can be created is FFFFFFFFFFFFF (topr 8000000000000 + subr 7FFFFFFFFFFFF)

If you wanted to just stay in the 8000000000000 range, you would use -topr 8000000000000 and -subr 48.

The random feature is generated via built in Rand function.
How many random points created each rekey depends on the grid size you use. The program currently has x*8,512, meaning if your GPUs grid size is 40x100 then by default, the final grid size would be 320x512 (40*8 = 320 for the x grid (times) the default 512 for the y grid) = 320x512. So in this case, each rekey will generate 320x512 = 163,840 random points. After points are generated they will start from that point and move sequentially until a rekey is made. So if your GPU gets 100 MK/s and you set the -r to 200, -r 200, then you would generate new random points roughly every 2 seconds.

[Angelo1710]

Tnx! I understand it all now after your in-depth explanation.

[zahid888]

Will you please add stride mode in Vanbitcracken where according to my speed I choose 7 characters random hex Ex: 7bbc039 and put stride mode -- stride 10000000 here 7 zeros are my random hex and I started counting after these 7 random hexes, suppose I am searching for the 64-bit key and the key is f9aa309c97bbc039 and I put the command --keyspace 7bbc039:fffffffff7bbc039 --stride 10000000 when I start counting through this command I have to count 9 hex to reach the end of keyspace and I will get the key in 1 minute as I say according to my speed. hope you understand what I am trying to say. if it would happen I will be very thankful to you.

[madmartyk]

OK I have been playing around with this on and off.  When I get the results (say from the example above) I can't IMPORTPRIVKEY into my wallet.  How do I get it to display a private key that can be imported into a wallet?

[stanner.austin]

@madmartyk
Hello
Its very easy if you found hex or int just convert to compressed key
You can find sample posted by me, you can even display key and import to any wallet like electrum or any of your choice.

https://bitcointalk.org/index.php?topic=5392986.msg59753846#msg59753846

[Trancefan]

I just dont fucking understand. You created the damn program. Why didn't and haven't you upload the source code? It is common knowledge that when you upload a program to github, you also upload the source code as well.

[Evillo]

Tested this today and I just wanna thank WanderingPhilosopher for such a beautiful software .. this by all means is the best way to search within a puzzle's range .. and as a tweak of both bitcrack and vanitysearch, it has beaten both of them.. faster than all I've tried before .. also very easy to use and was the best randomization option to finally land on .. great job

[opeael2]

Here is VBCRandom in action.
Batch file settings:

Code:

VBCRandom -t 0 -gpu -gpuId 0 -topr 8000000000000000 -subr 48 -r 480 --keyspace 8000000000000000:FFFFFFFFFFFFFFFF -o randomtest.txt 16jY7q

Results:

Code:

Started Sat Aug 28 12:32:28 2021
Start Range  :  8000000000000000
End   Range  :  FFFFFFFFFFFFFFFF
Searching For:  16jY7q
Compression  :  Compressed
CPU threads  :  0
GPU          :  GPU #0 NVIDIA GeForce GTX 1060 6GB (10x128 cores) Grid(80x512)

Random Key   :  800007AC8B3D5525
Random Key   :  8000201C33F5235B
Random Key   :  8000E2F090E63C7D
 [00:00:04 Run Time ] [Speed 82.524 MK/s] [Total Keys: 335,544,320] [# Rekeys: 0] [Found: 2]
Random Key   :  8000208FB1B474F6
Random Key   :  8000B9FC61E9ABA1
Random Key   :  8000F0310FBE3DD2
 [00:00:08 Run Time ] [Speed 82.563 MK/s] [Total Keys: 671,088,640] [# Rekeys: 1] [Found: 4]
Random Key   :  80004698D58E9E8F
Random Key   :  800089612D96CDA0
Random Key   :  8000C2190CD91261
 [00:00:15 Run Time ] [Speed 81.609 MK/s] [Total Keys: 1,258,291,200] [# Rekeys: 2] [Found: 6]
Random Key   :  800043E67DBAB51D
Random Key   :  800098B29829B7A7
Random Key   :  800045B53E8E1753
 [00:00:20 Run Time ] [Speed 79.286 MK/s] [Total Keys: 1,593,835,520] [# Rekeys: 2] [Found: 6]

Key results:

Code:

Pub Addr: 16jY7qzxujzi1K7GaEc17ZFokFymagY3jG
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLz94bU7Lw952JxZUX
Priv (HEX): 0x000000000000000000000000000000000000000000000000800015BE8DF950C5

Pub Addr: 16jY7qdry8xB4v6JeMH2R3ViVTSTzDGv2B
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLzUZ1qwKHqCmVgPRj
Priv (HEX): 0x000000000000000000000000000000000000000000000000800064574E06912E

Pub Addr: 16jY7qwSUyCss5jZYDjgJofLe7KgKxiCQo
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLzGCmCHBUm9fupLgz
Priv (HEX): 0x0000000000000000000000000000000000000000000000008000328A78D70051

Pub Addr: 16jY7q7x9EjwysPAYtappeDX6Lqtm32ekf
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLzCiYnMdjWKzRsXUn
Priv (HEX): 0x0000000000000000000000000000000000000000000000008000247B3183BFDC

Pub Addr: 16jY7qTWTgUzCEEH7E9UFxVKALnvCcykwV
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLziDMQ1SzkL55t52w
Priv (HEX): 0x00000000000000000000000000000000000000000000000080009B6E64AE0CAD

Pub Addr: 16jY7qwSwoyaH2NT2dKsY15h11Gma5bccb
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLzSjUdaY9XWkAo8pE
Priv (HEX): 0x00000000000000000000000000000000000000000000000080005D00CB38A1B5

Pub Addr: 16jY7qCNptT19yStBa3tgVFy2k7CvhLi8t
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvM13ZD8mLPHJMsj9c6
Priv (HEX): 0x0000000000000000000000000000000000000000000000008000E96EBB6FFC70

Pub Addr: 16jY7q3WZumGZ4gbrDTSte9JTbhEniZpqP
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLzLQVfZGJ81tzYnbi
Priv (HEX): 0x0000000000000000000000000000000000000000000000008000437CBF9A4063

Pub Addr: 16jY7qSaxGdCNribBnf6oxcpaw7aBUA6nN
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLzMkoUUXmUpiqDSm1
Priv (HEX): 0x000000000000000000000000000000000000000000000000800048EE90360155

Pub Addr: 16jY7qSV4qyaXJNmwWCu2t4DRWHuTnQuwz
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLz9toCoHuQiZuBD2p
Priv (HEX): 0x000000000000000000000000000000000000000000000000800019188671357A

Pub Addr: 16jY7qJ3MdatyubzBQ4e67n5D2iJRqFrDY
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLzZLFmMZj3v26fWhh
Priv (HEX): 0x0000000000000000000000000000000000000000000000008000779DFF73D53B

See how every new random key is within the same 48 bit range? Now you could change the -topr to whatever toprange and the -subr to whatever subrange. If in the example above you wanted to search every possible range in the toprange of 8000000000000000, you would use -topr 8000000000000000 and -subr 60.

Make sense?

use the -b for compressed and uncompressed.

Do you know any script or program that will check the list of private keys? balance?

[WanderingPhilospher]

Do you know any script or program that will check the list of private keys? balance?

If you mean check addresses with balance, there is a python script floating around somewhere and LoyceV has a list that he updates daily with all BTC addresses and balances.

[NotATether]

Do you know any script or program that will check the list of private keys? balance?

If you mean check addresses with balance, there is a python script floating around somewhere and LoyceV has a list that he updates daily with all BTC addresses and balances.

Have you ever thought of building a Mac version of this? Those Apple Silicon processors have beefy GPUs inside and are worth a shot.

It will also give us a chance to see just how powerful the iPhone/Pad chips are as well (compared to some not-so-old desktop GPUs widely used for cracking puzzles).

[digaran]

Hi there dear dev, just wanted to say I'm also a *dev, so dev to dev can you help here, I'm not a win dev so don't know much about these. What's wrong with this code?
I used bold inside the quote to show that I know things, I know zero.🤣

C:\Users\Desktop\VanBit>VanBitCrackenS1.1_2  -t 0 -gpu -g 256 -gpuId 0 -r 100000 -check  --keyspace 337d48f41c4bb8886:35071626a0b64d0ce --continue continue.txt -o outputfile.txt -v -b -l nosse -kp -rp privkey partialkeyfile  13zb1hQbWVsc2S7ZTZn pause
GetBase10() Results OK
Add() Results OK : 237.530 MegaAdd/sec
Mult() Results OK : 25.947 MegaMult/sec
Div() Results OK : 3.102 MegaDiv/sec
ModInv()/ModExp() Results OK
ModInv() Results OK : 186.301 KiloInv/sec
IntGroup.ModInv() Results OK : 5.751 MegaInv/sec
ModMulK1() Results OK : 7.511 MegaMult/sec
ModSquareK1() Results OK : 6.821 MegaMult/sec
ModMulK1order() Results OK :3.525 MegaMult/sec

GPU: GPU #0 NVIDIA GeForce 920MX (2x128 cores) Grid(256x512)
GPUEngine: Launch: the launch timed out and was terminated
37.275 MegaKey/sec
(thread=3, incr=743, endo=0)
C:\Users\Desktop\VanBit>bitcrackens1.1_2.bat

C:\Users\Desktop\VanBit>VanBitCrackenS1.1_2  -t 0 -gpu -g 512 -gpuId 0 -r 100000 -check  --keyspace 337d48f41c4bb8886:35071626a0b64d0ce --continue continue.txt -o outputfile.txt -v -b -l nosse -kp -rp privkey partialkeyfile  13zb1hQbWVsc2S7ZTZn pause
GetBase10() Results OK
Add() Results OK : 303.951 MegaAdd/sec
Mult() Results OK : 22.351 MegaMult/sec
Div() Results OK : 2.602 MegaDiv/sec
ModInv()/ModExp() Results OK
ModInv() Results OK : 188.328 KiloInv/sec
IntGroup.ModInv() Results OK :5.753 MegaInv/sec
ModMulK1() Results OK :7.510 MegaMult/sec
ModSquareK1() Results OK : 7.824 MegaMult/sec
ModMulK1order() Results OK :3.829 MegaMult/sec

GPU: GPU #0 NVIDIA GeForce 920MX (2x128 cores) Grid(512x512)
Seed:
GPUEngine: Launch: the launch timed out and was terminated
83.871 MegaKey/sec
Add() Results OK : 303.030 MegaAdd/sec
Grid(1024x512)
167.744 MegaKey/sec
(thread=17, incr=876, endo=0)
Add() Results OK : 264.550 MegaAdd/sec
Adress : 18******TkHbjJTTshxLnqPzQvAtdCe OK!
Adress : 1*******KNngkdXEeobR76b53LETtpyT OK!Grid(2048x512)
206.455 MegaKey/sec
 (thread=31, incr=518, endo=0)

*=fake dev. lol

Edit= on random version, is there any way to search for other addresses? And when I reset, does it have to repeat all over, and is it possible to hit duplicates? Meaning searching a range twice.

[WanderingPhilospher]

Hi there dear dev, just wanted to say I'm also a *dev, so dev to dev can you help here, I'm not a win dev so don't know much about these. What's wrong with this code?
I used bold inside the quote to show that I know things, I know zero.🤣

C:\Users\Desktop\VanBit>VanBitCrackenS1.1_2  -t 0 -gpu -g 256 -gpuId 0 -r 100000 -check  --keyspace 337d48f41c4bb8886:35071626a0b64d0ce --continue continue.txt -o outputfile.txt -v -b -l nosse -kp -rp privkey partialkeyfile  13zb1hQbWVsc2S7ZTZn pause
GetBase10() Results OK
Add() Results OK : 237.530 MegaAdd/sec
Mult() Results OK : 25.947 MegaMult/sec
Div() Results OK : 3.102 MegaDiv/sec
ModInv()/ModExp() Results OK
ModInv() Results OK : 186.301 KiloInv/sec
IntGroup.ModInv() Results OK : 5.751 MegaInv/sec
ModMulK1() Results OK : 7.511 MegaMult/sec
ModSquareK1() Results OK : 6.821 MegaMult/sec
ModMulK1order() Results OK :3.525 MegaMult/sec

GPU: GPU #0 NVIDIA GeForce 920MX (2x128 cores) Grid(256x512)
GPUEngine: Launch: the launch timed out and was terminated
37.275 MegaKey/sec
(thread=3, incr=743, endo=0)
C:\Users\Desktop\VanBit>bitcrackens1.1_2.bat

C:\Users\Desktop\VanBit>VanBitCrackenS1.1_2  -t 0 -gpu -g 512 -gpuId 0 -r 100000 -check  --keyspace 337d48f41c4bb8886:35071626a0b64d0ce --continue continue.txt -o outputfile.txt -v -b -l nosse -kp -rp privkey partialkeyfile  13zb1hQbWVsc2S7ZTZn pause
GetBase10() Results OK
Add() Results OK : 303.951 MegaAdd/sec
Mult() Results OK : 22.351 MegaMult/sec
Div() Results OK : 2.602 MegaDiv/sec
ModInv()/ModExp() Results OK
ModInv() Results OK : 188.328 KiloInv/sec
IntGroup.ModInv() Results OK :5.753 MegaInv/sec
ModMulK1() Results OK :7.510 MegaMult/sec
ModSquareK1() Results OK : 7.824 MegaMult/sec
ModMulK1order() Results OK :3.829 MegaMult/sec

GPU: GPU #0 NVIDIA GeForce 920MX (2x128 cores) Grid(512x512)
Seed:
GPUEngine: Launch: the launch timed out and was terminated
83.871 MegaKey/sec
Add() Results OK : 303.030 MegaAdd/sec
Grid(1024x512)
167.744 MegaKey/sec
(thread=17, incr=876, endo=0)
Add() Results OK : 264.550 MegaAdd/sec
Adress : 18******TkHbjJTTshxLnqPzQvAtdCe OK!
Adress : 1*******KNngkdXEeobR76b53LETtpyT OK!Grid(2048x512)
206.455 MegaKey/sec
 (thread=31, incr=518, endo=0)

*=fake dev. lol

Edit= on random version, is there any way to search for other addresses? And when I reset, does it have to repeat all over, and is it possible to hit duplicates? Meaning searching a range twice.

With the VBC R, Random version; what do you mean search for other addresses? You can search multiple addresses with an input file; such as addresses.txt file. 
The only way it repeats, is if you are searching in a small range; 44 bit and below may get multiple duplicate hits.

[digaran]

Vanbitcrack doesn't work, I posted the results, it just tries to do something like generating a vanity address. I also have a question about random version, why is it only showing compute_0 working under performance tab on task manager and compute_1 is at 0%? I'm getting 28MK/s  on a Geforce 920MX.

[WanderingPhilospher]

Vanbitcrack doesn't work, I posted the results, it just tries to do something like generating a vanity address. I also have a question about random version, why is it only showing compute_0 working under performance tab on task manager and compute_1 is at 0%? I'm getting 28MK/s  on a Geforce 920MX.

LOL...It does work; take off all those options like -check -v -b -l nosse -kp -rp privkey partialkeyfile  13zb1hQbWVsc2S7ZTZn

A typical run using VBCRandom would look like this:

Code:

VBCRandom -t 0 -gpu -gpuId 0 -topr 8000000000000000 -subr 48 -r 480 --keyspace 8000000000000000:FFFFFFFFFFFFFFFF -o randomtest.txt 16jY7q

Also, do not use the --continue option with Random; only use it with Spread.

[digaran]

Vanbitcrack doesn't work, I posted the results, it just tries to do something like generating a vanity address. I also have a question about random version, why is it only showing compute_0 working under performance tab on task manager and compute_1 is at 0%? I'm getting 28MK/s  on a Geforce 920MX.

LOL...It does work; take off all those options like -check -v -b -l nosse -kp -rp privkey partialkeyfile  13zb1hQbWVsc2S7ZTZn

A typical run using VBCRandom would look like this:

Code:

VBCRandom -t 0 -gpu -gpuId 0 -topr 8000000000000000 -subr 48 -r 480 --keyspace 8000000000000000:FFFFFFFFFFFFFFFF -o randomtest.txt 16jY7q

Also, do not use the --continue option with Random; only use it with Spread.

Lol indeed, Just another question, if I want to search between start key range and end key range, why do I need to set topr and subr? For example if I want to search random between 20000000000000000 and 3ffffffffffffffff what should I do? I'm trying to test my luck on puzzle #66

[WanderingPhilospher]

Vanbitcrack doesn't work, I posted the results, it just tries to do something like generating a vanity address. I also have a question about random version, why is it only showing compute_0 working under performance tab on task manager and compute_1 is at 0%? I'm getting 28MK/s  on a Geforce 920MX.

LOL...It does work; take off all those options like -check -v -b -l nosse -kp -rp privkey partialkeyfile  13zb1hQbWVsc2S7ZTZn

A typical run using VBCRandom would look like this:

Code:

VBCRandom -t 0 -gpu -gpuId 0 -topr 8000000000000000 -subr 48 -r 480 --keyspace 8000000000000000:FFFFFFFFFFFFFFFF -o randomtest.txt 16jY7q

Also, do not use the --continue option with Random; only use it with Spread.

Lol indeed, Just another question, if I want to search between start key range and end key range, why do I need to set topr and subr? For example if I want to search random between 20000000000000000 and 3ffffffffffffffff what should I do? I'm trying to test my luck on puzzle #66

Code:

VBCRandom -t 0 -gpu -gpuId 0 -topr 20000000000000000 -subr 65 -r 480 --keyspace 20000000000000000:3ffffffffffffffff -o 66BitKeyHasBeenFound.txt 13zb1hQbWVsc2S7ZTZn

[WanderingPhilospher]

A new VanBitCracken Random version will be released soon. I am doing some final testing.

The new version works with full addresses with RTX 30xx cards.

It also supports the usual -topr and -subr flags AND now will support -bits. So if you want to dig deeper into the bits range, you can use the -topr and -subr flags, or if you want to randomly search the entire bit range, you can use the -bits flag.

CPU tests:
Using the -bits flag:

Code:

VBCr v2.00
 Difficulty: 1461501637330902918203684832716283019655932542976
 Search For: 12jbtzBb54r97TCwW3G1gCFoumpckRAPdY [Compressed]
 Started on: Tue Jan 17 15:12:31 2023
 Randomness: Keys Randomly Change Every 20 Mkeys
   Key Bits: 28
CPU Threads: 3

Random Key :  A87E95E
Random Key :  A241DEF
 [00:00:00:04 Run Time][CPU 8.93 MK/s][GPU 0.00 MK/s][Keys 36,295,680][Found 0][Rekeys: 0]
Random Key :  D066F69
Random Key :  AF0AB9D
 [00:00:00:06 Run Time][CPU 8.61 MK/s][GPU 0.00 MK/s][Keys 52,476,928][Found 0][Rekeys: 1]

PubAddress: 12jbtzBb54r97TCwW3G1gCFoumpckRAPdY
Priv (WIF): p2pkh: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M82GSgY8p5EkUe
Priv (HEX): D916CE8 (28 bit)

Using the -topr and -subr flags:

Code:

VBCr v2.00
 Difficulty: 1461501637330902918203684832716283019655932542976
 Search For: 12jbtzBb54r97TCwW3G1gCFoumpckRAPdY [Compressed]
 Started on: Tue Jan 17 15:13:47 2023
 Randomness: Keys Randomly Change Every 20 Mkeys
  Top Range: D000000
   Sub Bits: 20
CPU Threads: 3

Random Key :  D0AC4E2
Random Key :  D0FF07F
 [00:00:00:02 Run Time][CPU 9.73 MK/s][GPU 0.00 MK/s][Keys 19,647,488][Found 0][Rekeys: 0]

PubAddress: 12jbtzBb54r97TCwW3G1gCFoumpckRAPdY
Priv (WIF): p2pkh: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M82GSgY8p5EkUe
Priv (HEX): D916CE8 (28 bit)

GPU tests (on a RTX 30xx card):
Using the -bits flag:

Code:

VBCr v2.00
 Difficulty: 1461501637330902918203684832716283019655932542976
 Search For: 1Be2UF9NLfyLFbtm3TCbmuocc9N1Kduci1 [Compressed]
 Started on: Tue Jan 17 14:23:29 2023
 Randomness: Keys Randomly Change Every 1500 Mkeys
   Key Bits: 36
CPU Threads: 0
GPU: GPU #5 NVIDIA GeForce RTX 3060 (28x128 cores) Grid(280x512)

Random Key :  C9EE5FE55
Random Key :  E5D4F54F7
Random Key :  CC7CA808F
Random Key :  9FA502A1B
Random Key :  D96016A1B
Random Key :  876214E5A
Random Key :  C6A877E56
 [00:00:00:02 Run Time][CPU 1004.24 MK/s][GPU 1004.24 MK/s][Keys 2,055,208,960][Found 0][Rekeys: 0]
Random Key :  D8804C962
Random Key :  B715039B7
Random Key :  9383B5449
 [00:00:00:06 Run Time][CPU 836.74 MK/s][GPU 836.74 MK/s][Keys 5,138,022,400][Found 0][Rekeys: 1]
Random Key :  DEC839A21
Random Key :  BA6DEEF42
Random Key :  B3743D201
 [00:00:00:10 Run Time][CPU 803.61 MK/s][GPU 803.61 MK/s][Keys 8,220,835,840][Found 0][Rekeys: 2]
Random Key :  99A84C258
Random Key :  EEE976549
Random Key :  8A01B1C12
 [00:00:00:14 Run Time][CPU 790.11 MK/s][GPU 790.11 MK/s][Keys 11,303,649,280][Found 0][Rekeys: 3]
Random Key :  A63B3CE9F
Random Key :  E038B2356
Random Key :  DD6E4D371
 [00:00:00:18 Run Time][CPU 755.52 MK/s][GPU 755.52 MK/s][Keys 14,386,462,720][Found 0][Rekeys: 4]
Random Key :  A7DBAA917
Random Key :  9E5B95A26
Random Key :  F34CDCA66
 [00:00:00:20 Run Time][CPU 755.53 MK/s][GPU 755.53 MK/s][Keys 15,707,668,480][Found 0][Rekeys: 5]

PubAddress: 1Be2UF9NLfyLFbtm3TCbmuocc9N1Kduci1
Priv (WIF): p2pkh: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9Mg1Upu7eJAtiDr
Priv (HEX): 9DE820A7C (36 bit)

Using the -topr and -subr flags:

Code:

VBCr v2.00
 Difficulty: 1461501637330902918203684832716283019655932542976
 Search For: 1Be2UF9NLfyLFbtm3TCbmuocc9N1Kduci1 [Compressed]
 Started on: Tue Jan 17 14:25:58 2023
 Randomness: Keys Randomly Change Every 1500 Mkeys
  Top Range: 900000000
   Sub Bits: 32
CPU Threads: 0
GPU: GPU #5 NVIDIA GeForce RTX 3060 (28x128 cores) Grid(280x512)

Random Key :  9FC8AD570
Random Key :  9CF418D48
Random Key :  9D50338AF
Random Key :  9F7DFB98D
Random Key :  9BCB80E13
Random Key :  9A197B762
Random Key :  9BE0BF75B
 [00:00:00:02 Run Time][CPU 932.38 MK/s][GPU 932.38 MK/s][Keys 1,908,408,320][Found 0][Rekeys: 0]
Random Key :  9D3DEDBF5
Random Key :  98AD9E9B8
Random Key :  9CD3B216F
Random Key :  9DB279043

PubAddress: 1Be2UF9NLfyLFbtm3TCbmuocc9N1Kduci1
Priv (WIF): p2pkh: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9Mg1Upu7eJAtiDr
Priv (HEX): 9DE820A7C (36 bit)

[digaran]

Version 1 didn't work with the full address?

[WanderingPhilospher]

Version 1 didn't work with the full address?

Correct...not with the RTX 30xx cards.

[PawGo]

GPU tests (on a RTX 30xx card):
Using the -bits flag:

Code:

 [00:00:00:02 Run Time][CPU 1004.24 MK/s][GPU 1004.24 MK/s][Keys 2,055,208,960][Found 0][Rekeys: 0]

 [00:00:00:06 Run Time][CPU 836.74 MK/s][GPU 836.74 MK/s][Keys 5,138,022,400][Found 0][Rekeys: 1]

 [00:00:00:10 Run Time][CPU 803.61 MK/s][GPU 803.61 MK/s][Keys 8,220,835,840][Found 0][Rekeys: 2]

 [00:00:00:14 Run Time][CPU 790.11 MK/s][GPU 790.11 MK/s][Keys 11,303,649,280][Found 0][Rekeys: 3]

 [00:00:00:18 Run Time][CPU 755.52 MK/s][GPU 755.52 MK/s][Keys 14,386,462,720][Found 0][Rekeys: 4]

 [00:00:00:20 Run Time][CPU 755.53 MK/s][GPU 755.53 MK/s][Keys 15,707,668,480][Found 0][Rekeys: 5]

Interesting. Do you know why the performance is decreasing so much? 25% in 20 seconds is rather a lot.
Maybe card becomes too hot? But I doubt it, I think 20 sec is not enough.

[WanderingPhilospher]

GPU tests (on a RTX 30xx card):
Using the -bits flag:

Code:

 [00:00:00:02 Run Time][CPU 1004.24 MK/s][GPU 1004.24 MK/s][Keys 2,055,208,960][Found 0][Rekeys: 0]

 [00:00:00:06 Run Time][CPU 836.74 MK/s][GPU 836.74 MK/s][Keys 5,138,022,400][Found 0][Rekeys: 1]

 [00:00:00:10 Run Time][CPU 803.61 MK/s][GPU 803.61 MK/s][Keys 8,220,835,840][Found 0][Rekeys: 2]

 [00:00:00:14 Run Time][CPU 790.11 MK/s][GPU 790.11 MK/s][Keys 11,303,649,280][Found 0][Rekeys: 3]

 [00:00:00:18 Run Time][CPU 755.52 MK/s][GPU 755.52 MK/s][Keys 14,386,462,720][Found 0][Rekeys: 4]

 [00:00:00:20 Run Time][CPU 755.53 MK/s][GPU 755.53 MK/s][Keys 15,707,668,480][Found 0][Rekeys: 5]

Interesting. Do you know why the performance is decreasing so much? 25% in 20 seconds is rather a lot.
Maybe card becomes too hot? But I doubt it, I think 20 sec is not enough.

The speed decreases because of the low rekey number I set. The card is regenerating new random keys every 1.5 seconds. The tests were done with a -r 1500.

The below was done with a -r 25000.

Code:

VBCr v2.00
 Difficulty: 1461501637330902918203684832716283019655932542976
 Search For: 1fe2UF9NLfyLFbtm3TCbmuocc9N1Kduci1 [Compressed]
 Started on: Wed Jan 18 11:10:44 2023
 Randomness: Keys Randomly Change Every 25000 Mkeys
  Top Range: 900000000
   Sub Bits: 32
CPU Threads: 0
GPU: GPU #5 NVIDIA GeForce RTX 3060 (28x128 cores) Grid(420x512)

Random Key :  9AE01B634
Random Key :  9FCFA9D02
Random Key :  9D69C42E9
Random Key :  9B0DF9E38
Random Key :  9C8553CB4
Random Key :  998B52035
Random Key :  9F7663B15
 [00:00:00:28 Run Time][CPU 874.94 MK/s][GPU 874.94 MK/s][Keys 25,323,110,400][Found 0][Rekeys: 0]
Random Key :  987052D12
Random Key :  9A0326BE8
Random Key :  98D8B5FD3
 [00:00:00:59 Run Time][CPU 885.92 MK/s][GPU 885.92 MK/s][Keys 51,747,225,600][Found 0][Rekeys: 1]
Random Key :  9817E6B93
Random Key :  9F46F2FA1
Random Key :  9B1D6B5A9
 [00:00:01:29 Run Time][CPU 892.62 MK/s][GPU 892.62 MK/s][Keys 78,171,340,800][Found 0][Rekeys: 2]
Random Key :  991806476
Random Key :  982C4C95C
Random Key :  992310ECD
 [00:00:02:00 Run Time][CPU 890.11 MK/s][GPU 890.11 MK/s][Keys 104,815,656,960][Found 0][Rekeys: 3]
Random Key :  9CCD5A14E
Random Key :  9B6950FFD
Random Key :  987B1F906
 [00:00:02:29 Run Time][CPU 907.71 MK/s][GPU 907.71 MK/s][Keys 129,918,566,400][Found 0][Rekeys: 4]
Random Key :  9CDECB4B9
Random Key :  9F16BEC20
Random Key :  9C1EF95D6
 [00:00:02:58 Run Time][CPU 896.48 MK/s][GPU 896.48 MK/s][Keys 155,021,475,840][Found 0][Rekeys: 5]
Random Key :  9D5F84326
Random Key :  9DDFF0B31
Random Key :  9FB7A0EDB
 [00:00:03:27 Run Time][CPU 894.36 MK/s][GPU 894.36 MK/s][Keys 180,124,385,280][Found 0][Rekeys: 6]
Random Key :  9C78B0D8B
Random Key :  9C960F418
Random Key :  9E437B06F
 [00:00:03:56 Run Time][CPU 894.36 MK/s][GPU 894.36 MK/s][Keys 205,227,294,720][Found 0][Rekeys: 7]
Random Key :  989240021
Random Key :  982B52739
Random Key :  9D9441CDA
 [00:00:04:25 Run Time][CPU 897.28 MK/s][GPU 897.28 MK/s][Keys 230,330,204,160][Found 0][Rekeys: 8]
Random Key :  99C7F58CA
Random Key :  9C4ACC52A
Random Key :  9F03C4E54

With a low -r (rekey) value, the GPU will be regenerating keys more often. And if that is the case, the speed will definitely be slower as seen by my tests, it's always resetting the random keys.

[Trancefan]

I still don't understand why there isn't the source code for the program on github.

[zahid888]

can we put -bits manually like -stride ?

[WanderingPhilospher]

can we put -bits manually like -stride ?

-bits is a flag. so yes, you enter the bits range you want to search. -stride...not there yet lol.
I did (I think) figure out a way to program in a stride, but that will take tinkering and testing. But it looks promising.

I still don't understand why there isn't the source code for the program on github.

I know, right?!

[zahid888]

actually i use stride in sequence but bits is even better.

[digaran]

Hi dev, do I need to set -bits to 65 for puzzle 66 and -bits 66 for puzzle 67? It will then search the entire range? Didn't setting -subr do the same?

[WanderingPhilospher]

Hi dev, do I need to set -bits to 65 for puzzle 66 and -bits 66 for puzzle 67? It will then search the entire range? Didn't setting -subr do the same?

New version has not been released. If you want to search (using current version) for #66, yes, set -topr to 2000...and -subr to 65. For #67. set -topr to 4000... and -subr to 66.

The new version all you will have to do is set -bits to 66 or 67, etc.

[NotATether]

Hi dev, do I need to set -bits to 65 for puzzle 66 and -bits 66 for puzzle 67? It will then search the entire range? Didn't setting -subr do the same?

New version has not been released. If you want to search (using current version) for #66, yes, set -topr to 2000...and -subr to 65. For #67. set -topr to 4000... and -subr to 66.

The new version all you will have to do is set -bits to 66 or 67, etc.

Does this new unreleased version support RTX 40xx cards by any chance? I know the topic says "supports RTX 30xx" cards but adding the new support should be as simple as bumping the CCAP version.

[PawGo]

Does this new unreleased version support RTX 40xx cards by any chance? I know the topic says "supports RTX 30xx" cards but adding the new support should be as simple as bumping the CCAP version.

If program works with CCAP 86, it will work with 40xx, as they use 89 (Ada). Not a big difference, really.

There are some hardware changes which could be nice, like increased L2 cache, and to use them code should be changed, but I am not sure if it is the case.

[WanderingPhilospher]

Hi dev, do I need to set -bits to 65 for puzzle 66 and -bits 66 for puzzle 67? It will then search the entire range? Didn't setting -subr do the same?

New version has not been released. If you want to search (using current version) for #66, yes, set -topr to 2000...and -subr to 65. For #67. set -topr to 4000... and -subr to 66.

The new version all you will have to do is set -bits to 66 or 67, etc.

Does this new unreleased version support RTX 40xx cards by any chance? I know the topic says "supports RTX 30xx" cards but adding the new support should be as simple as bumping the CCAP version.

I'm not sure as I do not own any 40xx cards. When I released this moons ago, 30xx were the big dawgs.

the 30xx cards currently work with 10.2 target/props and a max CCAP of compute_75,sm_75. Interesting...

I am downloading 11.5 target/props and adjusting CCAP up to 8.6 and then retesting on the 30xx cards to ensure it still works.

EDIT: Update. Apparently 11.5 (or the 8.6 CAP) doesn't like a big grid size (420,512).

Code:

GPUEngine: Kernel: too many resources requested for launch.

 But with 10.2, I can run any size grid size. It's apparently from using 11.5 target/props.

I used 11.0 target/props and did not receive the "too many resources" error.  Interesting...

[dextronomous]

Hi there WanderingPh.
is this one ready and released. thanks man wan't to try it out..

thanks for your time.

laters

[digaran]

Hi again dev, the usuall bother is here again,🙂.
I'v got a questions if you could answer please.
These are my CPU and GPU graphs while using VanBitRandom version 1 :
Only 1 engine is working, is there a way to boost the speed by utilizing other engines?

[WanderingPhilospher]

Hi there WanderingPh.
is this one ready and released. thanks man wan't to try it out..

thanks for your time.

laters

Working out different approach and testing now. Instead of -topr and -subr (since a few were/are confused by it) I am implementing a -begr and -endr flag; so now users can just use a range.  example: -begr 80000000000 -endr 8ffffffffff. Now the program will generate random keys inside of the range. The -bits flag has been done and tested and works flawlessly. Just a few more tweaks and tests on the -begr (begin range) and -endr (end range); I may tweak those flags prior to release. Something like -bor and -eor; beginning of range and end of range...

[WanderingPhilospher]

Hi again dev, the usuall bother is here again,🙂.
I'v got a questions if you could answer please.
These are my CPU and GPU graphs while using VanBitRandom version 1 :
Only 1 engine is working, is there a way to boost the speed by utilizing other engines?

Can you tell me what your settings/flags are when running the program?

[digaran]

Code:

-t 0 -gpu -gpuid 0 -topr (puzzle66 key range) -subr #66 -r 480 --keyspace #66 -o randomtest.txt 13zb1h

I get 28MK/s with it.

[digaran]

Code:

-t 0 -gpu -gpuid 0 -topr (puzzle66 key range) -subr #66 -r 480 --keyspace #66 -o randomtest.txt 13zb1h

I get 28MK/s with it.

I'm coming back to you, lol. When will you release the new version?

Also have a read if you have 5 mins of time :

~snip

Thanks for teaching me things, this means a lot, I'm also waiting on your new version release, the reason why I use several tools is purely for educational purposes, I'm like 15 days into this new world, I never had to do complie/build, run anything from command line, so I'm a newbie in this field.
One strange behavior I noticed from wifsolver is the fact that my speed goes to 6 Gkey/s and drops down to 60 Mkey/s. I'm not sure if me opening the filestatus.txt to see the progress which is kinda like going into the womb in different stages of baby's development lol, you can see the ugly pk with several 1s and a few 3,2,6 etc.

What I was able to figure out is that if you remove 10 chars from the end of your wif and place it at wifstart, then removing 15 chars from your wifend will result in a much higher end key range, so practically even if your wif with 10 missing chars returns no result after trying all possible combinations, it will automatically remove more chars from your wifstart to reach the wifend range.

For example, - wifstart kabcdefghijkL"1111111111"
You set - wifend kabcdefghi"zzzzzzzzzzzzz"

After solving all the 10 missing chars of wifstart if it doesn't find your key it will change the char on the left side of the red bold 1 above until it reaches the "i" in green bold on wifend. This will search to the end of range.

What I'm saying is that I was able to figure this out in few hours with your help, without it, I'd be scraching my head wasting time and no experience after hourse of work.

This is why teaching people is important, when you make a tool, ofcourse you know every thing it's due to years of practice and hard work, so you'd assume every body else is like you, capable and educated on such particular subject, news for you not all of us had the luxury to use certain opportunities in our life so our life took a different turn..

Know that teaching was one of the important job of all prophets, the entire universe send you positive energy when you teach sonmething to someone, and you might even not realize the impact  of your actions on people's lives.

I myself have never felt ashamed to ask questions, not asking them is rather a stupid thing to do, because if you don' ask, you'ill never learn, and according to the rules of KARMA not sharing your God given knowledge and wisdom will result in you losing your knowledge because you are deemed unworthy.


Using AI to generate to deliver a thorough explanation :


The word "Zakat" can be translated to English as "alms" or "charitable giving". It is a mandatory form of giving a portion of one's wealth to the poor and needy, as well as other charitable causes that are approved in Islamic law, and it is considered one of the Five Pillars of Islam.


In terms of sharing knowledge about Zakat, there is no specific equivalent phrase or term in English. However, the phrase "educating others about Zakat" or "spreading awareness about Zakat" could be used to convey the idea of sharing knowledge about the Islamic practice of charitable giving. Additionally, "teaching the principles of Zakat" or "sharing one's understanding of Zakat" could also be used to express the idea of sharing knowledge about the practice.

Purification of wealth: Giving Zakat is believed to purify one's wealth and remove any impurities or sins associated with it.

Encourages compassion and empathy: Giving Zakat promotes a sense of compassion and empathy for those who are less fortunate and encourages individuals to be more giving and charitable.

Redistribution of wealth: Zakat helps redistribute wealth in society and ensures that the basic needs of the poor and needy are met.

Promotes social justice: By supporting the poor and needy, Zakat helps promote social justice and reduces the gap between the rich and the poor.

Spiritual growth: Giving Zakat is considered an act of worship and a way to draw closer to God.

In Islamic tradition, teaching and education are highly valued, and there is a belief that knowledge is a form of wealth that should be shared with others. So, teaching and educating others, especially those who are uneducated, could be considered a form of Zakat of knowledge. Giving people the tools and resources they need to better their lives and improve their circumstances, could be seen as a way of fulfilling the Islamic obligation of Zakat and helping the less fortunate.

 Zakat is a specific practice in Islam, that is mandatory and has certain rules and guidelines to follow, while teaching and educating others is a broader concept that could be applied to many different context.

[WanderingPhilospher]

This is why teaching people is important

I agree...and like I said, most people on here go above and beyond in explaining things, especially if they know the whole story or what you are trying to accomplish.

But this is a bad example:

Code:

-t 0 -gpu -gpuid 0 -topr (puzzle66 key range) -subr #66 -r 480 --keyspace #66 -o randomtest.txt 13zb1h

You should have put the exact settings/flags from your batch file.
Such as:

Code:

-t 0 -gpu -gpuid 0 -topr 26000000000000000 -subr 60 -r 480 --keyspace 26000000000000000:27000000000000000 -o randomtest.txt 13zb1h

That's the only way to try and figure out an issue or help you better.

New version will be released soon.

[digaran]

Thanks for the update, I will bother you about my command line then, master/teacher. 😘 please don't be mad at me, I never cheated on you, I just wanted to explore my other options, by far you are the one for me, lol.

I'm referring to your cross posting on another topic acting upset seeing me with another dev.

Just a joke for fun. I'm waiting for you to eat dinner together tonight, please forgive me it was a one-night stand, won't happen again, didn't like that dev anyways.Lol.

[WanderingPhilospher]

Thanks for the update, I will bother you about my command line then, master/teacher. 😘 please don't be mad at me, I never cheated on you, I just wanted to explore my other options, by far you are the one for me, lol.

I'm referring to your cross posting on another topic acting upset seeing me with another dev.

Just a joke for fun. I'm waiting for you to eat dinner together tonight, please forgive me it was a one-night stand, won't happen again, didn't like that dev anyways.Lol.

I follow for new posts and post on several different 'cracking' topics. Nothing special.

That Dev, PawGo is an actual dev...I'm just a wandering philosopher...

[WanderingPhilospher]

Newest version, VBCr 2.0 has been released. Now works with full address and/or prefix/strings.

It has been tested on Windows 10 and Windows 11 on RTX 30xx cards, RTX 20xx cards and a GTX 1660 Ti card.

Link:
https://github.com/WanderingPhilosopher/VanBitCrackenRandom2

SHA256 Checksum:

Code:

5415d56416632faa7058e1ddf2a6cde037d6df22778606128369df4557627dc3

[Denis_Hitov]

Newest version, VBCr 2.0 has been released. Now works with full address and/or prefix/strings.

It has been tested on Windows 10 and Windows 11 on RTX 30xx cards, RTX 20xx cards and a GTX 1660 Ti card.

Link:
https://github.com/WanderingPhilosopher/VanBitCrackenRandom2

SHA256 Checksum:

Code:

5415d56416632faa7058e1ddf2a6cde037d6df22778606128369df4557627dc3

Thank you very much.
I'll start testing.

[zahid888]

C:\VBCr.exe -t 0 -gpu -r 15000 -drk 1 -dis 1 -o found.txt -begr 30000000000000000 -endr 3ffffffffffffffff 13zb1hQb
VBCr v2.00
 Search For: 13zb1hQb [Compressed]
 Started on: Sun Jan 29 00:31:42 2023
 Randomness: New Random Keys Every 15000 Mkeys
  Beg Range: 30000000000000000 (66 bit)
  End Range: 3FFFFFFFFFFFFFFFF (66 bit)
  Rng Width: FFFFFFFFFFFFFFFF (64 bit)
CPU Threads: 0
GPU: GPU #0 NVIDIA GeForce RTX 3060 Ti (38x128 cores) Grid(304x128)

Random Key :  3CA66AE31988943F8
Random Key :  33AFD9BFD0E7C3C05
Random Key :  3944E73119C628547
Random Key :  310FDC71F53342D9F
Random Key :  38EF7FB791B94062C
Random Key :  38E48FCBB8625EDA5
Random Key :  31CF7D3BB3CFC36AE
Random Key :  3BDAF9BCF6B24ACA9
Random Key :  35E1042DFF80011FF
 [00:00:00:18 Run Time][Total 858.08 MK/s][GPU 858.08 MK/s][Keys 16,177,430,528][Found 0][Rekeys: 0]
Random Key :  3008E60BB05D94019
Random Key :  30D1FBB9DA1B4BDBF
Random Key :  32FD1EE6B5FD66D91
Random Key :  3F6521943CE216A3B
 [00:00:00:36 Run Time][Total 858.08 MK/s][GPU 858.08 MK/s][Keys 31,757,172,736][Found 0][Rekeys: 1]
Random Key :  3ED9B23AFDD6128D8
Random Key :  3A594FF7516E2EFB9
Random Key :  35A40CF719C3979D4
Random Key :  3AAF4875926BE1420
 [00:00:00:55 Run Time][Total 861.55 MK/s][GPU 861.55 MK/s][Keys 47,376,760,832][Found 0][Rekeys: 2]
Random Key :  33EEA9FD1CCC0D0F2
Random Key :  31653F1D5A32EA932
Random Key :  3CABAE3ABEB95FEBE
Random Key :  3A444A67B8ECC9C4E
 [00:00:01:13 Run Time][Total 861.35 MK/s][GPU 861.35 MK/s][Keys 62,996,348,928][Found 0][Rekeys: 3]
Random Key :  300F749CBC4C59838
Random Key :  37005A2FDF63860E1
Random Key :  3490B1ED9F6064209
Random Key :  3CED2B87B914AB67B
 [00:00:01:31 Run Time][Total 864.77 MK/s][GPU 864.77 MK/s][Keys 78,615,937,024][Found 0][Rekeys: 4]
Random Key :  30C71CC2755A87386
Random Key :  350D7417544F9B548
Random Key :  342666D310D99B345
Random Key :  3F10606217880DFBA
 [00:00:01:49 Run Time][Total 863.57 MK/s][GPU 863.57 MK/s][Keys 94,195,679,232][Found 0][Rekeys: 5]
Random Key :  35C6A8E49A8727D75
Random Key :  3AB07A1DBC7A24409
Random Key :  3F33373FF91D8D719
Random Key :  3E0BBA28D716638A3
 [00:00:02:08 Run Time][Total 862.73 MK/s][GPU 862.73 MK/s][Keys 109,815,267,328][Found 0][Rekeys: 6]
Random Key :  37A622CE3BAF76DB1
Random Key :  311CFAC3D827DBEB1
Random Key :  3DC4F6C5F5B9E8741
Random Key :  34D1C557BEE11DEC6
 [00:00:02:26 Run Time][Total 861.78 MK/s][GPU 861.78 MK/s][Keys 125,434,855,424][Found 0][Rekeys: 7]
Random Key :  3F3D75B89F76CF7B8
Random Key :  3F8160F759073B373
Random Key :  32C215D5DACFDC987
Random Key :  3CCB7E8015AE495A3
 [00:00:02:44 Run Time][Total 860.66 MK/s][GPU 860.66 MK/s][Keys 141,014,597,632][Found 0][Rekeys: 8]
Random Key :  3D1742B3F6F3BE018
Random Key :  3C425D849A3354009
Random Key :  353F39573DC796493
Random Key :  39EF2C59BCA4C930D
 [00:00:03:03 Run Time][Total 860.97 MK/s][GPU 860.97 MK/s][Keys 156,634,185,728][Found 0][Rekeys: 9]
Random Key :  34DEA4A9D9997FC67
Random Key :  326549655309C3791
Random Key :  32EB4E52F0BEEFFDB
Random Key :  32685160B26BC91B2
 [00:00:03:21 Run Time][Total 859.01 MK/s][GPU 859.01 MK/s][Keys 172,253,773,824][Found 0][Rekeys: 10]
Random Key :  3C1ADA16D65D7CB8F
Random Key :  376BC90A9859EBF61
Random Key :  325AA16A954C20D28
Random Key :  366A8F831289EDCB9
 [00:00:03:39 Run Time][Total 858.58 MK/s][GPU 858.58 MK/s][Keys 187,833,516,032][Found 0][Rekeys: 11]
Random Key :  308178D894914B018
Random Key :  37A27BAF77E26D46A
Random Key :  3F003E86BEDEF0D2A
Random Key :  30922D6C9F19F6987
 [00:00:03:58 Run Time][Total 858.59 MK/s][GPU 858.59 MK/s][Keys 203,453,104,128][Found 0][Rekeys: 12]
Random Key :  31FFB6CD9CD4BCEF6
Random Key :  38B6E86EBA2DD6665
Random Key :  309EDDF31C43D5C06
Random Key :  32381CDE30EF5302F
 [00:00:04:16 Run Time][Total 858.54 MK/s][GPU 858.54 MK/s][Keys 219,072,692,224][Found 0][Rekeys: 13]
Random Key :  3AE19FFD7044F08AD
Random Key :  3FCCA40559B955F5A
Random Key :  3D25073D54019C971
Random Key :  39650A5B1399AA017
 [00:00:04:35 Run Time][Total 858.34 MK/s][GPU 858.34 MK/s][Keys 234,652,434,432][Found 0][Rekeys: 14]
Random Key :  3A894C881693D709F
Random Key :  3F2D332D3A294C4AB
Random Key :  3558E3A09EEB76FE5
Random Key :  3433BC1B506FE8E16
 [00:00:04:49 Run Time][Total 849.80 MK/s][GPU 849.80 MK/s][Keys 246,765,584,384][Found 0][Rekeys: 15]

PubAddress: 13zb1hQbEFu5qBRejJqnvbfPB9kqCq8GFp
Priv (WIF): p2pkh: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qZrs5JUQ3XJ2wutBFXee
Priv (HEX): 30E8CB8AB89331488 (66 bit)
 [00:00:04:53 Run Time][Total 859.12 MK/s][GPU 859.12 MK/s][Keys 250,272,022,528][Found 1][Rekeys: 15]
Random Key :  33F53F2C7F6C773B2
Random Key :  3A94BC3B785EBD63F
Random Key :  3B6E56A7DF01AD8F9
Random Key :  30814C0952D93289B
 [00:00:05:11 Run Time][Total 859.67 MK/s][GPU 859.67 MK/s][Keys 265,891,610,624][Found 1][Rekeys: 16]
Random Key :  3FA813D6BFBC50837
Random Key :  3B9DA8775CDAEBBE1
Random Key :  3F7D9DCF326962B09
Random Key :  30F8286C5EE911C97
 [00:00:05:30 Run Time][Total 861.62 MK/s][GPU 861.62 MK/s][Keys 281,471,352,832][Found 1][Rekeys: 17]
Random Key :  346473293D32CAFF9
Random Key :  31DE93BF1C391AA8D
Random Key :  3305CB2C52D1B3092
Random Key :  39937E143E3A86299
 [00:00:05:40 Run Time][Total 851.67 MK/s][GPU 851.67 MK/s][Keys 290,078,064,640][Found 1][Rekeys: 18]

when key found it's displayed in green text. that is very attractive, but after that whole information getting green.

And please add enter between results of output file..

PubAddress: 13zb1hQbEFu5qBRejJqnvbfPB9kqCq8GFp
Priv (WIF): p2pkh: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qZrs5JUQ3XJ2wutBFXee
Priv (HEX): 30E8CB8AB89331488 (66 bit)
PubAddress: 13zb1hQfLmmnfXB6XaXgUZugnJahg5kra5
Priv (WIF): p2pkh: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qZg8Ax4wuKBnjVQSbvM5
Priv (HEX): 28D9C0534956C8657 (66 bit)
PubAddress: 13zb1hQEqJH6ASLHBA7K8YDpuZ3i95pcQH
Priv (WIF): p2pkh: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qZsRoqnNMPJXwgNgWAav
Priv (HEX): 3155352F07721F47A (66 bit)
PubAddress: 13zb1hQVq18cDNrKNfS9ikvg5FhSfhrd6v
Priv (WIF): p2pkh: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qZqLvz1QrVYuXgMszkrw
Priv (HEX): 2FC4DD8DBDF7C50AE (66 bit)
PubAddress: 13zb1hQEehEWRt3unpxBZP9TdRH2itrDsq
Priv (WIF): p2pkh: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qa5vHepym48BDGcfcKuU
Priv (HEX): 3AB4AC319B1C37EB5 (66 bit)
PubAddress: 13zb1hQc52D3nAUQ4ZGAbM1aqfAvD5UW4d
Priv (WIF): p2pkh: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qZfNya2qnHbMhJUzuoFT
Priv (HEX): 284AAFA4B03B5D6D9 (66 bit)
PubAddress: 13zb1hQNZa5krg2AM6Yz75KNi7zv7hR7vL
Priv (WIF): p2pkh: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qZWncfMDyKs2XGefa3En
Priv (HEX): 21D81FB76B95CF22A (66 bit)
PubAddress: 13zb1hQjh5r4Rn8nuS3HddsxCni5QJCBok
Priv (WIF): p2pkh: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qa521gJy6ZrX66Hk5ME8
Priv (HEX): 3A078988FD6F96C0E (66 bit)
PubAddress: 13zb1hQeEVUssoDb69qnPSgjPivLnMVJxR
Priv (WIF): p2pkh: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qa2asjhFru97DbzwxGyo
Priv (HEX): 3834180C56676C027 (66 bit)
PubAddress: 13zb1hQA5w2bgcALJrrHjhbfWMLdQZDz9p
Priv (WIF): p2pkh: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qZsYSFFJr5xS6XBeuXbs
Priv (HEX): 316B28919FC36C327 (66 bit)
PubAddress: 13zb1hQLLdx4Y5ni8hVTAbQN2fSfEbNypm
Priv (WIF): p2pkh: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qa6GAYMYGuqYnezK9u2b
Priv (HEX): 3AF6819812ACDAA3E (66 bit)

Your program is working very smoothly. I hope very soon we will also see the stride function here

[WanderingPhilospher]

when key found it's displayed in green text. that is very attractive, but after that whole information getting green.

And please add enter between results of output file..

Yeah I didn't account for the fact that people may still search for prefixes. I turned it green so I could quickly tell if full address had been found.
I will tinker with it.

As far as the space between output, no problem.

VBCr v2.00
 Search For: 13zb1L [Compressed]
 Started on: Sat Jan 28 21:33:25 2023
 Randomness: New Random Keys Every 4 Mkeys
   Key Bits: 66
CPU Threads: 1

 [00:00:00:02 Run Time][Total 3.74 MK/s][GPU 0.00 MK/s][Keys 7,614,464][Found 0][Rekeys: 0]
 [00:00:00:04 Run Time][Total 3.38 MK/s][GPU 0.00 MK/s][Keys 13,763,584][Found 0][Rekeys: 1]
 [00:00:00:06 Run Time][Total 3.27 MK/s][GPU 0.00 MK/s][Keys 19,977,216][Found 0][Rekeys: 2]
 [00:00:00:08 Run Time][Total 3.22 MK/s][GPU 0.00 MK/s][Keys 26,193,920][Found 0][Rekeys: 3]
 [00:00:00:10 Run Time][Total 3.19 MK/s][GPU 0.00 MK/s][Keys 32,400,384][Found 0][Rekeys: 4]
 [00:00:00:12 Run Time][Total 3.17 MK/s][GPU 0.00 MK/s][Keys 38,662,144][Found 0][Rekeys: 5]
 [00:00:00:14 Run Time][Total 3.15 MK/s][GPU 0.00 MK/s][Keys 44,843,008][Found 0][Rekeys: 6]
 [00:00:00:16 Run Time][Total 3.14 MK/s][GPU 0.00 MK/s][Keys 51,088,384][Found 0][Rekeys: 7]
 [00:00:00:18 Run Time][Total 3.05 MK/s][GPU 0.00 MK/s][Keys 57,317,376][Found 0][Rekeys: 8]
Random Key :  2B67C3431FC584CDD

PubAddress: 13zb1LpeZkWr5wJigyHyFN39fuTHLDJnjA
Priv (WIF): p2pkh: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qZjXe6wnesspv91ZQ8hH
Priv (HEX): 2B67C3431FC88A42A (66 bit)
 [00:00:00:20 Run Time][Total 3.06 MK/s][GPU 0.00 MK/s][Keys 63,535,104][Found 1][Rekeys: 9]
 [00:00:00:22 Run Time][Total 3.03 MK/s][GPU 0.00 MK/s][Keys 69,353,472][Found 1][Rekeys: 10]
 [00:00:00:24 Run Time][Total 3.03 MK/s][GPU 0.00 MK/s][Keys 75,533,312][Found 1][Rekeys: 11]
 [00:00:00:26 Run Time][Total 3.03 MK/s][GPU 0.00 MK/s][Keys 81,771,520][Found 1][Rekeys: 12]
 [00:00:00:28 Run Time][Total 3.03 MK/s][GPU 0.00 MK/s][Keys 87,992,320][Found 1][Rekeys: 13]
 [00:00:00:30 Run Time][Total 3.03 MK/s][GPU 0.00 MK/s][Keys 94,232,576][Found 1][Rekeys: 14]
 [00:00:00:32 Run Time][Total 3.03 MK/s][GPU 0.00 MK/s][Keys 100,447,232][Found 1][Rekeys: 15]
 [00:00:00:34 Run Time][Total 3.03 MK/s][GPU 0.00 MK/s][Keys 106,649,600][Found 1][Rekeys: 16]
 [00:00:00:36 Run Time][Total 3.03 MK/s][GPU 0.00 MK/s][Keys 112,854,016][Found 1][Rekeys: 17]
 [00:00:00:38 Run Time][Total 3.05 MK/s][GPU 0.00 MK/s][Keys 119,070,720][Found 1][Rekeys: 18]
Random Key :  3EA417A3E491E2F69

PubAddress: 13zb1LEQG1nRuSMWXQrDACWxBMHfZV7HCF
Priv (WIF): p2pkh: KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qaBATkJdpwZPDcKRP1ic
Priv (HEX): 3EA417A3E493D32D6 (66 bit)
 [00:00:00:40 Run Time][Total 3.05 MK/s][GPU 0.00 MK/s][Keys 125,189,120][Found 2][Rekeys: 19]
 [00:00:00:42 Run Time][Total 3.05 MK/s][GPU 0.00 MK/s][Keys 131,412,992][Found 2][Rekeys: 20]
 [00:00:00:44 Run Time][Total 3.05 MK/s][GPU 0.00 MK/s][Keys 137,633,792][Found 2][Rekeys: 21]
 [00:00:00:46 Run Time][Total 3.04 MK/s][GPU 0.00 MK/s][Keys 143,791,104][Found 2][Rekeys: 22]
 [00:00:00:48 Run Time][Total 3.05 MK/s][GPU 0.00 MK/s][Keys 150,020,096][Found 2][Rekeys: 23]
 [00:00:00:50 Run Time][Total 3.05 MK/s][GPU 0.00 MK/s][Keys 156,213,248][Found 2][Rekeys: 24]
 [00:00:00:52 Run Time][Total 3.04 MK/s][GPU 0.00 MK/s][Keys 162,408,448][Found 2][Rekeys: 25]
 [00:00:00:54 Run Time][Total 3.04 MK/s][GPU 0.00 MK/s][Keys 168,599,552][Found 2][Rekeys: 26]
 [00:00:00:56 Run Time][Total 3.05 MK/s][GPU 0.00 MK/s][Keys 174,797,824][Found 2][Rekeys: 27]
 [00:00:00:59 Run Time][Total 3.04 MK/s][GPU 0.00 MK/s][Keys 180,985,856][Found 2][Rekeys: 28]
 [00:00:01:01 Run Time][Total 3.04 MK/s][GPU 0.00 MK/s][Keys 187,189,248][Found 2][Rekeys: 29]
 [00:00:01:03 Run Time][Total 3.05 MK/s][GPU 0.00 MK/s][Keys 193,416,192][Found 2][Rekeys: 30]
 [00:00:01:05 Run Time][Total 3.04 MK/s][GPU 0.00 MK/s][Keys 199,517,184][Found 2][Rekeys: 31]
 [00:00:01:07 Run Time][Total 3.04 MK/s][GPU 0.00 MK/s][Keys 205,746,176][Found 2][Rekeys: 32]
 [00:00:01:09 Run Time][Total 3.04 MK/s][GPU 0.00 MK/s][Keys 211,922,944][Found 2][Rekeys: 33]

I hope very soon we will also see the stride function here

I thought you said you didn't really care about the stride anymore lol...

[digaran]

Can we set our own x,y,z grid size?

[WanderingPhilospher]

Can we set our own x,y,z grid size?

For grid size, use -g x,y; example -g 128,256

There is no z.

[opeael2]

Can we save progress ?
And can someone give best grid settings for old 1050 ti ?

[WanderingPhilospher]

Can we save progress ?
And can someone give best grid settings for old 1050 ti ?

No, it is random, not sequential, so there is no point in saving progress.

For grid size, you just have to experiment with your 1050Ti.

[digaran]

So this is my CUDA device query, max thread per block, 1024. Max dimension size of a thread block 1024, 1024, 64. Max grid size 2147483647, 65535, 65535. 2×128 CUDA cores, which one should I use?

Edit: setting my grid to -g 64,512 increased my speed by 4Mkey/s. Setting higher sizes would close the command window after a few seconds.

Edit 2 : 16,512 appears to be the best for my device.

[WanderingPhilospher]

So this is my CUDA device query, max thread per block, 1024. Max dimension size of a thread block 1024, 1024, 64. Max grid size 2147483647, 65535, 65535. 2×128 CUDA cores, which one should I use?

Edit: setting my grid to -g 64,512 increased my speed by 4Mkey/s. Setting higher sizes would close the command window after a few seconds.

Your command window will not close if you add pause...that way you can see why the program stopped.

Code:

VBCr -gpu -g x,y -r 123, etc.
pause

What kind of card do you have?

[digaran]

If I set anything more than 64×512 it says kernel launch timed out and was terminated, Geforce 920MX. Since I didn't build the tool to apply my device specifics, looks like my GPU only uses one core.

[Lolo54]

is it possible to have an example of using the -rp command?

[WanderingPhilospher]

If I set anything more than 64×512 it says kernel launch timed out and was terminated, Geforce 920MX. Since I didn't build the tool to apply my device specifics, looks like my GPU only uses one core.

What is your actual core count, x*y? The program will show this when it first starts.

Also, you have to keep in mind, your card has low memory.

I don't know what you mean by it only uses one core...if you are running 64x512, that is way more than 1.

[digaran]

If I set anything more than 64×512 it says kernel launch timed out and was terminated, Geforce 920MX. Since I didn't build the tool to apply my device specifics, looks like my GPU only uses one core.

What is your actual core count, x*y? The program will show this when it first starts.

Also, you have to keep in mind, your card has low memory.

I don't know what you mean by it only uses one core...if you are running 64x512, that is way more than 1.

To be honest I'm so confused regarding, block, thread, core, engine, grid size etc.
It shows ( 2x128 cores ). On another note, will you add the reverse bit range search for this random version or is it only available on your other ( CPU ) tool?

BTW, what are those small ranges you are searching, do you search them in random or sequence? Send me a few small ranges and the needed flags, I would search them.
My speed is around 28 Mkey/s.

[WanderingPhilospher]

If I set anything more than 64×512 it says kernel launch timed out and was terminated, Geforce 920MX. Since I didn't build the tool to apply my device specifics, looks like my GPU only uses one core.

What is your actual core count, x*y? The program will show this when it first starts.

Also, you have to keep in mind, your card has low memory.

I don't know what you mean by it only uses one core...if you are running 64x512, that is way more than 1.

On another note, will you add the reverse bit range search for this random version or is it only available on your other ( CPU ) tool?

That is just for the other tool where sequential is possible. VBCr is just random.

BTW, what are those small ranges you are searching, do you search them in random or sequence? Send me a few small ranges and the needed flags, I would search them.
My speed is around 28 Mkey/s.

Which ranges are you referring to and with which program?

[digaran]

You said on puzzle thread that you are searching small chunks of ranges, even added a file with password. I guess you are searching them sequential correct?

[WanderingPhilospher]

You said on puzzle thread that you are searching small chunks of ranges, even added a file with password. I guess you are searching them sequential correct?

No, those ranges are created via the random mode.

If one of the random keys generated is 0x100; and I know each thread searched 0xff keys (total keys checked / total threads), then that range searched is 0x100 + 0xff = 0x100:0x1ff or 100:1ff

Make sense?

[digaran]

You said on puzzle thread that you are searching small chunks of ranges, even added a file with password. I guess you are searching them sequential correct?

No, those ranges are created via the random mode.

If one of the random keys generated is 0x100; and I know each thread searched 0xff keys (total keys checked / total threads), then that range searched is 0x100 + 0xff = 0x100:0x1ff or 100:1ff

Make sense?

No. Lol. If I knew how to do these calculations, it'd be great,  do you save each random key or you just see it on screen?

[WanderingPhilospher]

You said on puzzle thread that you are searching small chunks of ranges, even added a file with password. I guess you are searching them sequential correct?

No, those ranges are created via the random mode.

If one of the random keys generated is 0x100; and I know each thread searched 0xff keys (total keys checked / total threads), then that range searched is 0x100 + 0xff = 0x100:0x1ff or 100:1ff

Make sense?

No. Lol. If I knew how to do these calculations, it'd be great,  do you save each random key or you just see it on screen?

I save them, when I want to see the ranges covered/checked/completed...like when I posted those files of ranges ran.

But do you understand the calculations now?

[digaran]

I save them, when I want to see the ranges covered/checked/completed...like when I posted those files of ranges ran.

But do you understand the calculations now?

Of course, I might be noob in all of this but I'm not stupid.
Maybe doing that is somehow useful if others joined, so can I join the hunt as well? I just set your provided ranges and start searching or are you trying to do it solo?

[WanderingPhilospher]

I save them, when I want to see the ranges covered/checked/completed...like when I posted those files of ranges ran.

But do you understand the calculations now?

Of course, I might be noob in all of this but I'm not stupid.
Maybe doing that is somehow useful if others joined, so can I join the hunt as well? I just set your provided ranges and start searching or are you trying to do it solo?

Those ranges I posted in the file have already been checked.

As far as new ranges I run; they all come from VBCr and are random. I just capture them...was really showing people what a single small GPU could do/search in a limited time. But like I said, it's a little skill and all LUCK, IMO. But it's like the lottery, the more tickets you buy, the better your odds lol.

[digaran]

3 days of searching only found 3 addresses starting with 13zb1hQb, while finding more than 200 addresses starting with 13zb1hQ.
My first 13zb1hQb is in 203c0df74e49 next one is in 401f8aa ( lol was testing ). Third one is in 3b650e1d66a7.
I can't really tell how rare those are considering I'm using random mode. Have you found any of those rare addresses yet? Could this mean that 13zb1hQbW when found is the only address in the entire range? Maybe I'm wrong given the small ranges I have searched.

[WanderingPhilospher]

3 days of searching only found 3 addresses starting with 13zb1hQb, while finding more than 200 addresses starting with 13zb1hQ.
My first 13zb1hQb is in 203c0df74e49 next one is in 401f8aa ( lol was testing ). Third one is in 3b650e1d66a7.
I can't really tell how rare those are considering I'm using random mode. Have you found any of those rare addresses yet? Could this mean that 13zb1hQbW when found is the only address in the entire range? Maybe I'm wrong given the small ranges I have searched.

I am only searching full address, not partial string.

I used to know how to try and figure out how many leading characters in address could be in a specific range.

Maybe someone else can answer better/more accurate.

Take number of characters, minus the leading 1, 13zb1hQbW has 8 characters. Multiply that by base 58 to the power of characters; 58^8 = 128,063,081,718,016. Now divide range size by that. 2^65 / 58^8 = 288,088. So there could be up to 288,000 addresses starting with 13zb1hQbW in the #66 range.

[digaran]

Hi, do you have a windows binary for kangaroo or something similar to that to work with public keys?

[WanderingPhilospher]

Hi, do you have a windows binary for kangaroo or something similar to that to work with public keys?

Best on the market as far as kangaroo...but it is limited to 125 bits.

https://github.com/JeanLucPons/Kangaroo

https://github.com/JeanLucPons/Kangaroo/releases/tag/2.2

[Lolo54]

hi WanderingPhilospher I wanted to test https://github.com/WanderingPhilosopher/Windows-KeySubtractor/releases
but impossible error message at launch 0xc000007b I saw that many encountered this problem how to solve it?

[WanderingPhilospher]

hi WanderingPhilospher I wanted to test https://github.com/WanderingPhilosopher/Windows-KeySubtractor/releases
but impossible error message at launch 0xc000007b I saw that many encountered this problem how to solve it?

Do me a favor, see if you can download the newest .exe and if it works...
I just uploaded a new one. I think the issue was if your PC didn't have some of the dependencies, it wouldn't work, but I added those (I think) to the exe file.

Try and see. Thanks

[Lolo54]

hi WanderingPhilospher I wanted to test https://github.com/WanderingPhilosopher/Windows-KeySubtractor/releases
but impossible error message at launch 0xc000007b I saw that many encountered this problem how to solve it?

Do me a favor, see if you can download the newest .exe and if it works...
I just uploaded a new one. I think the issue was if your PC didn't have some of the dependencies, it wouldn't work, but I added those (I think) to the exe file.

Try and see. Thanks

now it launches without an error message but it doesn't seem to work or am I inserting a wrong command line?

C:\Users\Laurent>C:\Users\Laurent\Documents\Bitcoin\WindowsKeySubtracter.exe -p 02ceb6cbbcdbdf5ef7150682150f4ce2c6f4807b349827dcdbdd1f2efa885a2630 -n 10 -r 0:32

• Min range: 0
• Max range: 32

Version: 0.1
[E] there are some missing parameter

Usage:
-h              show this help
-b bits         For some puzzles you only need a bit range
-n number       Number of publikeys to be geneted, this numbe will be even
-f number       Format: 1 for text, 2 for binary
-o file         Output file
-p key          Publickey to be substracted compress or uncompress
-r A:B          range A to B
-R              Set the publickey substraction Random instead of secuential
-x              X point only without extra byte of odd/even of Y point

it seems that several parameters are missing for the program to run [E]
I inserted other commands same message
-p 02ceb6cbbcdbdf5ef7150682150f4ce2c6f4807b349827dcdbdd1f2efa885a2630 -n 200 -b 120
-p 02ceb6cbbcdbdf5ef7150682150f4ce2c6f4807b349827dcdbdd1f2efa885a2630 -n 10 -b 60 -o keysubtracter

[WanderingPhilospher]

hi WanderingPhilospher I wanted to test https://github.com/WanderingPhilosopher/Windows-KeySubtractor/releases
but impossible error message at launch 0xc000007b I saw that many encountered this problem how to solve it?

Do me a favor, see if you can download the newest .exe and if it works...
I just uploaded a new one. I think the issue was if your PC didn't have some of the dependencies, it wouldn't work, but I added those (I think) to the exe file.

Try and see. Thanks

now it launches without an error message but it doesn't seem to work or am I inserting a wrong command line?

C:\Users\Laurent>C:\Users\Laurent\Documents\Bitcoin\WindowsKeySubtracter.exe -p 02ceb6cbbcdbdf5ef7150682150f4ce2c6f4807b349827dcdbdd1f2efa885a2630 -n 10 -r 0:32

• Min range: 0
• Max range: 32

Version: 0.1
[E] there are some missing parameter

Usage:
-h              show this help
-b bits         For some puzzles you only need a bit range
-n number       Number of publikeys to be geneted, this numbe will be even
-f number       Format: 1 for text, 2 for binary
-o file         Output file
-p key          Publickey to be substracted compress or uncompress
-r A:B          range A to B
-R              Set the publickey substraction Random instead of secuential
-x              X point only without extra byte of odd/even of Y point

it seems that several parameters are missing for the program to run [E]
I inserted other commands same message
-p 02ceb6cbbcdbdf5ef7150682150f4ce2c6f4807b349827dcdbdd1f2efa885a2630 -n 200 -b 120
-p 02ceb6cbbcdbdf5ef7150682150f4ce2c6f4807b349827dcdbdd1f2efa885a2630 -n 10 -b 60 -o keysubtracter

Try this and let me know results:

Code:

WindowsKeySubtracter.exe -f 1 -o 120testx.txt -p 02FDD766926BC7EB713CB57FC71CB066DE3D97379F283BBE6E657016A812DC7735 -n 1000 -r 1:700000000000000000000000000000 -x
pause

[Lolo54]

Try this and let me know results:

Code:

WindowsKeySubtracter.exe -f 1 -o 120testx.txt -p 02FDD766926BC7EB713CB57FC71CB066DE3D97379F283BBE6E657016A812DC7735 -n 1000 -r 1:700000000000000000000000000000 -x
pause

I just ran the command line but it doesn't work.

Code:

C:\Users\Laurent>C:\Users\Laurent\Documents\Bitcoin\WindowsKeySubtracter.exe -f 1 -o 120testx.txt -p 02FDD766926BC7EB713CB57FC71CB066DE3D97379F283BBE6E657016A812DC7735 -n 1000 -r 1:700000000000000000000000000000 -x pause
[+] Min range: 1
[+] Max range: 700000000000000000000000000000
0.000000
C:\Users\Laurent>

Nothing is happening

[digaran]

Wait a minute, do you have a tool that searches for public key collisions? Can we use it on 120+ bit ranges? 🥳🥳 lol.

[WanderingPhilospher]

Wait a minute, do you have a tool that searches for public key collisions? Can we use it on 120+ bit ranges? 🥳🥳 lol.

No, but the kangaroo link above, that program will find x point collisions...

The tool Lolo54 and I were working on, takes a given public key and subtracts from and adds to the given public key.

[digaran]

Do you use CPU on the random search? I just used -t 2 and my speed went up from 28 MK to 31.5 MK also the random key points increased from 4 to 6, however adding -t 4 didn't increase the speed but generated 2 more random points.

I was wondering, do random key points depend on GPU/ CPU cores or we can generate more maybe by changing grid size? Though changing grid size never generates more key points. Lol I think I just realized what parallel computing is.

[WanderingPhilospher]

Do you use CPU on the random search? I just used -t 2 and my speed went up from 28 MK to 31.5 MK also the random key points increased from 4 to 6, however adding -t 4 didn't increase the speed but generated 2 more random points.

I was wondering, do random key points depend on GPU/ CPU cores or we can generate more maybe by changing grid size? Though changing grid size never generates more key points. Lol I think I just realized what parallel computing is.

Its programmed to only show x amount of new random starting points. However big your grid size, is how many new points are generated on each rekey. If your grid size is 10x128 then you are generating 1280 new points each rekey. I can generate and run 2800x512 grid sizes and I did not want all those points, cluttering up the screen and slowing the program down any.

[digaran]

Hi dev, I didn't get my answer elsewhere.
So I deleted my post on another topic and reposting it here.
Does anyone know how many of 2^160 addresses are uncompressed? How many compressed. Is it correct to assume that there are 2^128(compressed)×2^32(uncompressed) addresses?  Whatever the correct answer is. Could we just search in 160 bit range for both un/compressed addresses with only half the performance while searching in 256 bit range is exponentially harder?

[WanderingPhilospher]

Hi dev, I didn't get my answer elsewhere.
So I deleted my post on another topic and reposting it here.
Does anyone know how many of 2^160 addresses are uncompressed? How many compressed. Is it correct to assume that there are 2^128(compressed)×2^32(uncompressed) addresses?  Whatever the correct answer is. Could we just search in 160 bit range for both un/compressed addresses with only half the performance while searching in 256 bit range is exponentially harder?

Not sure what you are really asking/maybe I am misunderstanding your question but here goes:

We will just stick with legacy public addresses, or those that start with a "1".
You can generate just under 2^256 private keys, multiplied by the gen point, that translate to a public key, an x and y coordinate.
For uncompressed, it takes both the x and y coords, adds a "04" to the beginning, and does a sha256.
For compressed, it takes the x coord and if y is even, then public key starts with 02, if odd, starts with 03; and then does a sha256.

Now, for both uncompressed and compressed, it takes the resulting public key, a sha256, and performs a ripemd-160 of the resulting sha256.

Private key(gen)
Public key(whether uncompressed "04..." or compressed "02..." or "03..."
SHA256(Public key)
RIPEMD-160(SHA256)

For the purpose of this convo, this is all we will look at.

In theory, you can have 2^160 uncompressed addresses and/or 2^160 compressed addresses. Which again, in theory, many of those will overlap, meaning you could derive an uncompressed public address from private key 14ed2324 that also is the same public address as a compressed address from private key ed83ad448367.
Again, in theory, if you generated 2^160 uncompressed public keys (generated from x and y coords, starting with 04), or if you generated 2^160 compressed public keys (using only the x coord and the y parity (odd/even), you would in theory, have created all available public bitcoin addresses starting with "1".

So I would say there are 2^160 uncompressed public addresses and 2^160 compressed addresses lol.

Code:

1-Private ECDSA Key

12 (in hex)
 
2-Public ECDSA Key

045601570CB47F238D2B0286DB4A990FA0F3BA28D1A319F5E7CF55C2A2444DA7CCC136C1DC0CBEB930E9E298043589351D81D8E0BC736AE2A1F5192E5E8B061D58 (uncompressed)
 
3-SHA-256 hash of 2

0DA4D8594DA0D4A518922AF0E96D54857A1BBB7FA895C936BE434A43F3C304CF

4-RIPEMD-160 Hash of 3

6FC2F6488DCE92411D2498CB969B739BEFCC7988
 
5-Adding network bytes to 4

006FC2F6488DCE92411D2498CB969B739BEFCC7988
 
6-SHA-256 hash of 5

89C6CC88C80563B115A6F29060B0480729299E7EF40879047D0A340DC0E5F5C4

7-SHA-256 hash of 6

69BD5949E7E0D9F8E06258C6E2A59736726C311E13C8AF416E2D9355F7DE6839

8-First four bytes of 7

69BD5949

9-Adding 8 to the end of 5

006FC2F6488DCE92411D2498CB969B739BEFCC798869BD5949
 
10-Base58 encoding of 9

1BBwZVdBjoPxotHfrKLpHJBSy7vmc2pjex (public address)

[bigvito19]

Hi dev, I didn't get my answer elsewhere.
So I deleted my post on another topic and reposting it here.
Does anyone know how many of 2^160 addresses are uncompressed? How many compressed. Is it correct to assume that there are 2^128(compressed)×2^32(uncompressed) addresses?  Whatever the correct answer is. Could we just search in 160 bit range for both un/compressed addresses with only half the performance while searching in 256 bit range is exponentially harder?

2^80 compressed addresses * 2^80 uncompressed addresses = 2^160 addresses

2^128 compressed addresses * 2^128 uncompressed addresses = 2^256 addresses

[digaran]

Wow guys, so knowledgable people around here. But I have discovered there are only 2^160 valid addresses. If the number of un/compressed addresses are equal, meaning half of each, then we should have 2^48 valid private keys for each address. Though there is a possibility of 2^128 uncompressed addresses with 2^64 valid private keys for each and having 2^32 compressed with 2^32 valid private keys for each address. In total 2^160 add, 2^256 Private keys. Then compressed addresses in theory should be safer to use.

I think I just invented a new algorithm Lol.

I don't know if any of the above measures are correct.
Let's move on to other measures, Since I'm a newbie to math. Lol

Does anyone know the probability of finding several private keys for one address? I couldn't quantify the probable outcome, In order to find them, you'd have to divide 2^96 and spread it throughout the whole 2^256 range? And then start scratching the surface. Stay tuned for my future discoveries. 😉

@OP, 2^160 uncompressed, 2^160 compressed is equal to 2^161 total addresses.

[WanderingPhilospher]

@OP, 2^160 uncompressed, 2^160 compressed is equal to 2^161 total addresses.

Ummmm, thanks LOL. When did I say it wasn't?

[digaran]

@OP, 2^160 uncompressed, 2^160 compressed is equal to 2^161 total addresses.

Ummmm, thanks LOL. When did I say it wasn't?

But that doesn't add up with the number of possible private keys, maybe we are discussing over some precision calculations. Haven't found a provable answer to my questions yet. These ideas keep me up at nights, among other stuff.🤣

[WanderingPhilospher]

@OP, 2^160 uncompressed, 2^160 compressed is equal to 2^161 total addresses.

Ummmm, thanks LOL. When did I say it wasn't?

But that doesn't add up with the number of possible private keys, maybe we are discussing over some precision calculations. Haven't found a provable answer to my questions yet. These ideas keep me up at nights, among other stuff.🤣

I am not sure what doesn't add up. You are just adding numbers of addresses not necessarily different addresses.

2^256 uncompressed, 2^256 compressed is equal to 2^257 total addresses. What is their not to understand or what doesn't add up?

Now if you want to get into theory, then 2^161 addresses would contain, each possible address, twice.

[digaran]

Hi, I'm here again with more questions, appreciate the answer. Isn't it faster to search for RIPEMD-160 instead of address? Or the check encoding of hash 160 to address doesn't require any computation

[GR Sasa]

Hi, I'm here again with more questions, appreciate the answer. Isn't it faster to search for RIPEMD-160 instead of address?

Correct. Searching directly for RIPEMD-160 is slightly faster because it skips the base58 encoding. But it doesn't really boost the speed a lot. So i would say it doesn't matter that much.

Let's take an example:

The Bitcoin Address 16UwLL9Risc3QfPqBUvKofHmBQ7wMtjvM is the same as 010966776006953D5567439E5E39F86A0D273BEE.

The first one is the base58 encoded, and the second one is the RIPEMD-160. They're actually the same but in different view and shape. They're always both 160 bits too. 40-HEX x 4 = 160 bits. And you can always convert the RIPEMD-160 to base58, and base58 back to RIPEMD-160.

You can create as well a fun valid Bitcoin Burner Address. 1ELonMuskTrashAndHasNobrainyzXpEm =  0285F0F3222B4F2DB6F7B0EA4BD1B1D53A7D4852. They're both valid but obviously no one has its privates keys for this address. You can get its private key after bruteforcing about 2^160 addressess, which is older than the sperms of my 2^69 grand grand fathers. Keep in mind too, an Bitcoin Address is always valid as long as its RIPEMD-160 is 40 Hexadecimal characters.

BUT You only skip the base58 encoding. You still need to perform the steps that are needed for bruteforcing in order to get the wanted RIPEMD-160 if you search by skipping base58.

HexPrivateKey => SHA256 of PubKey => RIPEMD-160 of PubKey's Hash

[digaran]

Well I know all the things you said, I just wanted the cost of check encoding in computing units. And the information about the 69 position of your ancestors sperms was uncalled for. Lol.

[gw08brdx7g]

printf(" NOTE: when using -beginr and -endr, the program generates random keys in between those ranges. It will not\n");
printf("       search sequentially such as start at begr and stop at endr. Random keys in between the 2 ranges ONLY.\n");

VBCr.exe -t 0 -begr 20000000000000000 -endr 21000000000000000 -gpu -g 360,512 -dis 1 -r 0 -stop 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so


this command is sequential search or random search?

[digaran]

printf(" NOTE: when using -beginr and -endr, the program generates random keys in between those ranges. It will not\n");
printf("       search sequentially such as start at begr and stop at endr. Random keys in between the 2 ranges ONLY.\n");

VBCr.exe -t 0 -begr 20000000000000000 -endr 21000000000000000 -gpu -g 360,512 -dis 1 -r 0 -stop 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so


this command is sequential search or random search?

Random version does not search sequentially, the first version which is not marked as random on github will only search in sequence. -r 0 means generating new random keys after every 0 generated and checked addresses, so you need to increase it, if your speed is 100 M/s, changing -r to 100 means generating random search points every second, if you have a speed of 100 M/s it's better to add -r 1000 in order to generate random points every 10 seconds, additionally you could add whatever you want, but don't make it too short because it can decrease your overall speed.

[WanderingPhilospher]

printf(" NOTE: when using -beginr and -endr, the program generates random keys in between those ranges. It will not\n");
printf("       search sequentially such as start at begr and stop at endr. Random keys in between the 2 ranges ONLY.\n");

VBCr.exe -t 0 -begr 20000000000000000 -endr 21000000000000000 -gpu -g 360,512 -dis 1 -r 0 -stop 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so


this command is sequential search or random search?

The program generates random starting points/keys and then searches sequentially from those until specified rekey number has been reached. So yes, if you use -r 0, it will search sequentially from the random generated keys and will not generate any new random keys.

[gw08brdx7g]

printf(" NOTE: when using -beginr and -endr, the program generates random keys in between those ranges. It will not\n");
printf("       search sequentially such as start at begr and stop at endr. Random keys in between the 2 ranges ONLY.\n");

VBCr.exe -t 0 -begr 20000000000000000 -endr 21000000000000000 -gpu -g 360,512 -dis 1 -r 0 -stop 13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so


this command is sequential search or random search?

The program generates random starting points/keys and then searches sequentially from those until specified rekey number has been reached. So yes, if you use -r 0, it will search sequentially from the random generated keys and will not generate any new random keys.

can you add an option to keep generate&checked random keys in the start-to-end range? no sequential search

[WanderingPhilospher]

can you add an option to keep generate&checked random keys in the start-to-end range? no sequential search

I’m not understanding what you are asking. Can you elaborate or give an example?

[gw08brdx7g]

can you add an option to keep generate&checked random keys in the start-to-end range? no sequential search

I’m not understanding what you are asking. Can you elaborate or give an example?

Code:

import random

start_range = int("20000000000000000", 16)
end_range = int("21000000000000000", 16)
target_address = "13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so"

while True:
 random_hex = hex(random.randint(start_range, end_range))[2:].zfill(16) #generate random key
 #address = random_hex to address
 if(address==target_address):
  print(random_hex)
  break

just keep generate new random keys, no sequential

[digaran]

just keep generate new random keys, no sequential

In VanBitCracken, use -r 400, it will generate thousands of new mini random ranges and searches them until 400 million searches are done and will again generate random keys, the cycle goes on for ever random.😉

[rhxo]

Hey all,

Great discussion and lots of knowledge here. Thanks for sharing. Here is my question. I had the chance to test a few Lambda machines and they are very powerful machines. Was wondering if it's possible to run an experiment with VanBitCracken on Lambda machines specifically 2x NVIDIA RTX 6000 Ada 48 GB GPUs (not a cloud version - physical machine). I'm willing to share the results of the experiment.

Thanks,

[WanderingPhilospher]

What is required to run the program on Lambda machine?

[Evillo]

3 days of searching only found 3 addresses starting with 13zb1hQb, while finding more than 200 addresses starting with 13zb1hQ.
My first 13zb1hQb is in 203c0df74e49 next one is in 401f8aa ( lol was testing ). Third one is in 3b650e1d66a7.
I can't really tell how rare those are considering I'm using random mode. Have you found any of those rare addresses yet? Could this mean that 13zb1hQbW when found is the only address in the entire range? Maybe I'm wrong given the small ranges I have searched.

I am only searching full address, not partial string.

I used to know how to try and figure out how many leading characters in address could be in a specific range.

Maybe someone else can answer better/more accurate.

Take number of characters, minus the leading 1, 13zb1hQbW has 8 characters. Multiply that by base 58 to the power of characters; 58^8 = 128,063,081,718,016. Now divide range size by that. 2^65 / 58^8 = 288,088. So there could be up to 288,000 addresses starting with 13zb1hQbW in the #66 range.

Based on your calculations, i found a prefix that only repeats 4967 times in the entire 66 puzzle range: 13zb1hQbWV

Is my math correct?

[WanderingPhilospher]

3 days of searching only found 3 addresses starting with 13zb1hQb, while finding more than 200 addresses starting with 13zb1hQ.
My first 13zb1hQb is in 203c0df74e49 next one is in 401f8aa ( lol was testing ). Third one is in 3b650e1d66a7.
I can't really tell how rare those are considering I'm using random mode. Have you found any of those rare addresses yet? Could this mean that 13zb1hQbW when found is the only address in the entire range? Maybe I'm wrong given the small ranges I have searched.

I am only searching full address, not partial string.

I used to know how to try and figure out how many leading characters in address could be in a specific range.

Maybe someone else can answer better/more accurate.

Take number of characters, minus the leading 1, 13zb1hQbW has 8 characters. Multiply that by base 58 to the power of characters; 58^8 = 128,063,081,718,016. Now divide range size by that. 2^65 / 58^8 = 288,088. So there could be up to 288,000 addresses starting with 13zb1hQbW in the #66 range.

Based on your calculations, i found a prefix that only repeats 4967 times in the entire 66 puzzle range: 13zb1hQbWV

Is my math correct?

Yes, if my math above was correct lol

[Evillo]

Hi, I'm here again with more questions, appreciate the answer. Isn't it faster to search for RIPEMD-160 instead of address? Or the check encoding of hash 160 to address doesn't require any computation

I've tested this today with a modified Bitcrack and my conclusion is it doesn't really matter skipping one more step of converting PKH to address. Speed boost was minimal.

Devices: 01
Targets: 01
Use: RX 5700XT 8GB OC
Key Random points: 47,185,920
Addr Speed: 499 mil/sec
Ripemd160 speed: 511 mil/sec


Edit: i will test it with millions of targets to see if it causes any speed boost then post results

-----

Test done.. here it is:

Devices: 01
Targets: 6,000,000
Use: RX 5700XT 8GB OC
Key Random points: 47,185,920
Addr speed: 272 mil/sec
Ripemd160 speed: 286 mil/sec

[GR Sasa]

Devices: 01
Targets: 6,000,000
Use: RX 5700XT 8GB OC
Key Random points: 47,185,920
Addr speed: 272 mil/sec
Ripemd160 speed: 286 mil/sec


How does this not matter?! This is a 14 MILLION differences of hashing PER SECOND!!. I'd say it's good improvement.

I mean imagine a human counting 14 million times ? He wouldn't finish not even in 10 years. haha

[Evillo]

Devices: 01
Targets: 6,000,000
Use: RX 5700XT 8GB OC
Key Random points: 47,185,920
Addr speed: 272 mil/sec
Ripemd160 speed: 286 mil/sec


How does this not matter?! This is a 14 MILLION differences of hashing PER SECOND!!. I'd say it's good improvement.

I mean imagine a human counting 14 million times ? He wouldn't finish not even in 10 years. haha

In human terms, it's amazing. In 36.8 million trillion sea of keys, it's almost nothing. But technically yes it's an improvement nonetheless.

[digaran]

Hi, I'm here again with more questions, appreciate the answer. Isn't it faster to search for RIPEMD-160 instead of address? Or the check encoding of hash 160 to address doesn't require any computation

I've tested this today with a modified Bitcrack and my conclusion is it doesn't really matter skipping one more step of converting PKH to address. Speed boost was minimal.

Devices: 01
Targets: 01
Use: RX 5700XT 8GB OC
Key Random points: 47,185,920
Addr Speed: 499 mil/sec
Ripemd160 speed: 511 mil/sec


Edit: i will test it with millions of targets to see if it causes any speed boost then post results

-----

Test done.. here it is:

Devices: 01
Targets: 6,000,000
Use: RX 5700XT 8GB OC
Key Random points: 47,185,920
Addr speed: 272 mil/sec
Ripemd160 speed: 286 mil/sec

So it's around 5% improvement give or take? Well that shows that double sha256 only takes 5% of our performance, so why is it that keyhunt can reach Tk/s speed on CPU? It just skips one sha256 and one rmd160,  or am I missing something here?

[Evillo]

Hi, I'm here again with more questions, appreciate the answer. Isn't it faster to search for RIPEMD-160 instead of address? Or the check encoding of hash 160 to address doesn't require any computation

I've tested this today with a modified Bitcrack and my conclusion is it doesn't really matter skipping one more step of converting PKH to address. Speed boost was minimal.

Devices: 01
Targets: 01
Use: RX 5700XT 8GB OC
Key Random points: 47,185,920
Addr Speed: 499 mil/sec
Ripemd160 speed: 511 mil/sec


Edit: i will test it with millions of targets to see if it causes any speed boost then post results

-----

Test done.. here it is:

Devices: 01
Targets: 6,000,000
Use: RX 5700XT 8GB OC
Key Random points: 47,185,920
Addr speed: 272 mil/sec
Ripemd160 speed: 286 mil/sec

So it's around 5% improvement give or take? Well that shows that double sha256 only takes 5% of our performance, so why is it that keyhunt can reach Tk/s speed on CPU? It just skips one sha256 and one rmd160,  or am I missing something here?

Tks is in bsgs mode not rmd160 mode

[Dandar87]

Reserved for OP...

[kalos15btc]

why we cant add to vbcr2 option to save as bp table or something a file the random hex we generated and searched, where we can save the progress, not printing the hex, i mean save the ranges between and between so the random mode dont search again and again in same ranges or same hexes in this case we will earn so much time, when we load the progress the program load the ranges that we searched and never search in those ranges again,,
thats cool, isn't it?

[WanderingPhilospher]

why we cant add to vbcr2 option to save as bp table or something a file the random hex we generated and searched, where we can save the progress, not printing the hex, i mean save the ranges between and between so the random mode dont search again and again in same ranges or same hexes in this case we will earn so much time, when we load the progress the program load the ranges that we searched and never search in those ranges again,,
thats cool, isn't it?

I think I had it programmed to save ranges ran to a .txt file.
That just shows you the ranges ran, but doesn’t guarantee you won’t run the same one.
But in testing, I can say it’s highly unlikely to search a same range, if your ranges are small enough, say 0-40 bit ranges.

I had a python program that would auto generate a range, and save to a file as well and I also had a python program that would select ranges from an input file (a random line inside text file) and run it.
This was the guaranteed approach that the program would not run the same range twice.

[GR Sasa]

Hello @WanderingPhilospher,

Thank you for being active lately and answering most people's question.

I have a question. I hope you can help me and give me the right explanation, because it needs calculations.

I'm trying to understand and learn stride function more and more and trying to see the exact differences between stride and random functions.

I would love to use puzzle #110 as an example. Puzzle 110's range is between 2000000000000000000000000000 - 4000000000000000000000000000

Real private key of #110: 35C0D7234DF7DEB0F20CF7062444

Can you show me the calculations steps that you perform to get that HEX stride to be able to instantly jump from starting key 2000000000000000000000000000 to exact 35C0D7234DF7DEB0F20CF7062444? This would be my wish.

Many thanks.

[digaran]

Hello @WanderingPhilospher,

Thank you for being active lately and answering most people's question.

I have a question. I hope you can help me and give me the right explanation, because it needs calculations.

I'm trying to understand and learn stride function more and more and trying to see the exact differences between stride and random functions.

I would love to use puzzle #110 as an example. Puzzle 110's range is between 2000000000000000000000000000 - 4000000000000000000000000000

Real private key of #110: 35C0D7234DF7DEB0F20CF7062444

Can you show me the calculations steps that you perform to get that HEX stride to be able to instantly jump from starting key 2000000000000000000000000000 to exact 35C0D7234DF7DEB0F20CF7062444? This would be my wish.

Many thanks.

For future use, F = 15, E = 14, D = 13, C = 12, B = 11, A = 10.
Example: key = "AF4565DBBAE50C" Now how to use a stride with starting range of 10000000000000, you will add "9F4565DBBAE50C" As your stride and the 10000000000000 as your starting point to jump instantly to the point. Because you already have "1" as your start range, all you need to add to it is a "9". If your start point was "B" the key must either start with B or C or D or E or F, and if the key starts with "D" you'd need to add "2" as the first digit of your stride, so B + 2 = D. And A - 2 is 9. etc.

Take the first 2 digits, 20, replace them with 15, like this
15c0d7234df7deb0f20cf7062444 now add the starting range as your stride, 2000000000000000000000000000, however this is the case when you know the actual key beforehand, moreover if you set the above values you will instantly land on the key, problem is when you don't know the key, so setting any random stride is the same as just searching randomly, with random at least you have more chance, but trying different stride values could also increase your chance.

Btw, AFAIK, WP's tools have no stride function, which tool are you using?

[GR Sasa]

For future use, F = 15, E = 14, D = 13, C = 12, B = 11, A = 10.

What about 1, 2, 3, 4, 5, 6, 7, 8, 9,?

Damn, this is more complicated than i thought it would be. I really didn't get it 100%%

Maybe because of the big numbers lol... Can you try it with a smaller puzzle? Maybe puzzle 64. F7051F27B09112D4. Please try step - by step .

Starting from 8000000000000000 and instanly Landing to F7051F27B09112D4.

And an example from puzzle 66 if possible too. What if the keys starts with 3? How the stride should look like? How about if the key starts with 2?

I am using clbitcrack. I have seen the source code, and i decided to develop my own stride function.. but i first need to fully understand it.

With the correct understanding of stride function and a little luck, puzzle 66 can be solved.`


EDITS: I will try your results after i go back home from work, and tell you if works.

[digaran]

For future use, F = 15, E = 14, D = 13, C = 12, B = 11, A = 10.

What about 1, 2, 3, 4, 5, 6, 7, 8, 9,?

Damn, this is more complicated than i thought it would be. I really didn't get it 100%%

Maybe because of the big numbers lol... Can you try it with a smaller puzzle? Maybe puzzle 64. F7051F27B09112D4. Please try step - by step .

Starting from 8000000000000000 and instanly Landing to F7051F27B09112D4.

And an example from puzzle 66 if possible too. What if the keys starts with 3? How the stride should look like? How about if the key starts with 2?

I am using clbitcrack. I have seen the source code, and i decided to develop my own stride function.. but i first need to fully understand it.

With the correct understanding of stride function and a little luck, puzzle 66 can be solved.`


EDITS: I will try your results after i go back home from work, and tell you if works.

0 is reverse of F, 1 is reverse of E, 2 is D, 3 is C, 4 is B, 5 is A, 6 is 9, 7 is 8, 8 is 7, 9 is 6, 10 is 16. 10 here is actually hex and not decimal, but decimal 10 is A.

It's a bit confusing I know, but think about it this way, we have 9 numbers with 0 we have 10 numbers in total and only six characters A-F, so 6, 7, 8 and 9 can not be represented by any hex characters, therefore from 0 to 5 we have to  mirror them with 6 hex characters.

First learn the above, now if you want to add a number to 8 in order to have F, since F is 15, you'd need to add 7.

If you add 8 to 8 you are adding 1 to 15 and because after F  (15) we have 16(0x10) you are actually adding another bit to your number.
Example you asked, if you wanna learn hexadecimal structure, just convert your big numbers to decimal and subtract 0x8000000000000000 from  0xF7051F27B09112D4, once you start treating them all as decimals you will see how easy it is to calculate the stride.

So you need to add 0x77051F27B09112D4   and if you change the last digit "4" to "5" the last digit above will turn to 9 because you are adding 5 to 4. Replacing 4 with E is adding 11 to 4 = 15 (0xF) you will have  0x77051F27B09112DF but adding 4 to E,  you will be adding 3 to it's left digit, e.g, adding this   0x77051F27B09112D4 to this>   0xF7051F27B09112DE will give you this :  0x77051F27B09112E2.


I'd advise not to read my post though, you will forget whatever you already knew. Lol

[WanderingPhilospher]

For future use, F = 15, E = 14, D = 13, C = 12, B = 11, A = 10.

What about 1, 2, 3, 4, 5, 6, 7, 8, 9,?

Damn, this is more complicated than i thought it would be. I really didn't get it 100%%

Maybe because of the big numbers lol... Can you try it with a smaller puzzle? Maybe puzzle 64. F7051F27B09112D4. Please try step - by step .

Starting from 8000000000000000 and instanly Landing to F7051F27B09112D4.

And an example from puzzle 66 if possible too. What if the keys starts with 3? How the stride should look like? How about if the key starts with 2?

I am using clbitcrack. I have seen the source code, and i decided to develop my own stride function.. but i first need to fully understand it.

With the correct understanding of stride function and a little luck, puzzle 66 can be solved.`


EDITS: I will try your results after i go back home from work, and tell you if works.

DO NOT overcomplicate it with all of the previous posts/replies.

If you are using bitcrack, I think it uses decimals or hex. But either way, don't overcomplicate the stride function.

To make it easy, take whatever private key you are experimenting with; let's keep it small and say the private key is:
0x3E8, which equals 1,000 in decimal.

Your start range using bitcrack, has to at least start with 1, it can't be 0.

Now, we know our start range = 1.
For our demonstration, our private key is 0x3E8, which equals 1,000 in decimal.
1000 - 1 = 999 in decimal, or 3E7 in hex.
Now, to land on the private key we are looking for, 0x3E8, our stride needs to be a multiple of 999.
To keep this shorter and sweet, let's use a stride of 333.
So we have 1 gpu/cpu thread that will start on our starting range of 1.
It will first jump/stride 333 spots = 334
Next, it jumps/strides another 333 spots = 667
Next, another jump/stride of 333 spots = 1,000.
BOOM, we found the private key we were looking for.

If you chose a stride, because you do not know the private key, of let's say 334.
1+334 = 335
335+334=669
668+334=1002
In this example, we skipped/strided over the private key.

But do not fret, if you stay the course, eventually the key will be found.
In the next iteration, you will start with a starting range of 2, and then 3, ect.
Once you get to starting range 332, you will have a hit/find that private key.
332+334+334 = 1000, our private key.

Does this make more sense now on the stride function?

[WanderingPhilospher]

Hello @WanderingPhilospher,

Thank you for being active lately and answering most people's question.

I have a question. I hope you can help me and give me the right explanation, because it needs calculations.

I'm trying to understand and learn stride function more and more and trying to see the exact differences between stride and random functions.

I would love to use puzzle #110 as an example. Puzzle 110's range is between 2000000000000000000000000000 - 4000000000000000000000000000

Real private key of #110: 35C0D7234DF7DEB0F20CF7062444

Can you show me the calculations steps that you perform to get that HEX stride to be able to instantly jump from starting key 2000000000000000000000000000 to exact 35C0D7234DF7DEB0F20CF7062444? This would be my wish.

Many thanks.

Start key = 2000000000000000000000000000
Stride = 15C0D7234DF7DEB0F20CF7062444 (hex) or 441208990837133718981428417799236 (decimal) I believe bitcrack takes both but maybe just hex.

Calculations:
start key = 2000000000000000000000000000 or 649037107316853453566312041152512 in decimal
private key  = 35C0D7234DF7DEB0F20CF7062444 or 1090246098153987172547740458951748 decimal
stride to get right to the key = 1090246098153987172547740458951748 - 649037107316853453566312041152512 = 441208990837133718981428417799236 or 15C0D7234DF7DEB0F20CF7062444 in hex

Make sense?

[GR Sasa]

It make definitely sense now. Thank you so much friend WanderingPhilospher!  

I have now better image on how stride calculations works.

Which do you think is stronger Stride or Random function? (for puzzle 66) I believe both have high power ability. Luck plays a big role too

What digaran explained is also good, but MORE confusing lol.

Ty anyways!

[WanderingPhilospher]

It make definitely sense now. Thank you so much friend WanderingPhilospher!  

I have now better image on how stride calculations works.

Which do you think is stronger Stride or Random function? (for puzzle 66) I believe both have high power ability. Luck plays a big role too

What digaran explained is also good, but MORE confusing lol.

Ty anyways!

Stride is better if you know the public key, so for #66, I would think random is better. But that is just an opinion, nothing factual.

[andiu9999]

hi, is there any chance to make a option to save the ranges searched and if power outage come so when search again in random mode to not search the same ranges?

[WanderingPhilospher]

hi, is there any chance to make a option to save the ranges searched and if power outage come so when search again in random mode to not search the same ranges?

If you are using random mode, the program does not stay in a specific range, other than the one you supplied. It randomly bounces around in the bits range or the beginning/ending range you supplied.

What you can do is keep track of any ranges you supplied with beg and end ranges. But you can do that manually or use a program like python to keep track of them.

[Evillo]

WanderingPhilospher

Prefix search works on all address types except for bc1p .. any workaround for this or not?

[andiu9999]

hi, is there any chance to make new change in program and after it scan random that range scanned keys to not be scanned again?

[WanderingPhilospher]

hi, is there any chance to make new change in program and after it scan random that range scanned keys to not be scanned again?

Yo yo...andiu! The program doesn't scan a range, it scans random keys within a range.

If you are wanting to keep track of the ranges you randomly search in, python or a batch file is best used in this situation.

[akaros]

I don't know how is it possible but the "VanBitCrackenRandom2" is exactly doing what I want to do. You are reading my mind! Thank you so much.

[akaros]

it scans random keys within a range.

How much random keys? 4 showed or more depends on grid?

[WanderingPhilospher]

it scans random keys within a range.

How much random keys? 4 showed or more depends on grid?

Correct. It is based on grid size, but only 4 will show, to limit the display text.

[andiu9999]

Hi tested program in small and highe ranges nut somtimes it keeps search on same key and to repeat them https://ibb.co/4fxkJDQ if i keep track will not scan again same keys in random mode?

[jan1102]

Here is VBCRandom in action.
Batch file settings:

Code:

VBCRandom -t 0 -gpu -gpuId 0 -topr 8000000000000000 -subr 48 -r 480 --keyspace 8000000000000000:FFFFFFFFFFFFFFFF -o randomtest.txt 16jY7q

Results:

Code:

Started Sat Aug 28 12:32:28 2021
Start Range  :  8000000000000000
End   Range  :  FFFFFFFFFFFFFFFF
Searching For:  16jY7q
Compression  :  Compressed
CPU threads  :  0
GPU          :  GPU #0 NVIDIA GeForce GTX 1060 6GB (10x128 cores) Grid(80x512)

Random Key   :  800007AC8B3D5525
Random Key   :  8000201C33F5235B
Random Key   :  8000E2F090E63C7D
 [00:00:04 Run Time ] [Speed 82.524 MK/s] [Total Keys: 335,544,320] [# Rekeys: 0] [Found: 2]
Random Key   :  8000208FB1B474F6
Random Key   :  8000B9FC61E9ABA1
Random Key   :  8000F0310FBE3DD2
 [00:00:08 Run Time ] [Speed 82.563 MK/s] [Total Keys: 671,088,640] [# Rekeys: 1] [Found: 4]
Random Key   :  80004698D58E9E8F
Random Key   :  800089612D96CDA0
Random Key   :  8000C2190CD91261
 [00:00:15 Run Time ] [Speed 81.609 MK/s] [Total Keys: 1,258,291,200] [# Rekeys: 2] [Found: 6]
Random Key   :  800043E67DBAB51D
Random Key   :  800098B29829B7A7
Random Key   :  800045B53E8E1753
 [00:00:20 Run Time ] [Speed 79.286 MK/s] [Total Keys: 1,593,835,520] [# Rekeys: 2] [Found: 6]

Key results:

Code:

Pub Addr: 16jY7qzxujzi1K7GaEc17ZFokFymagY3jG
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLz94bU7Lw952JxZUX
Priv (HEX): 0x000000000000000000000000000000000000000000000000800015BE8DF950C5

Pub Addr: 16jY7qdry8xB4v6JeMH2R3ViVTSTzDGv2B
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLzUZ1qwKHqCmVgPRj
Priv (HEX): 0x000000000000000000000000000000000000000000000000800064574E06912E

Pub Addr: 16jY7qwSUyCss5jZYDjgJofLe7KgKxiCQo
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLzGCmCHBUm9fupLgz
Priv (HEX): 0x0000000000000000000000000000000000000000000000008000328A78D70051

Pub Addr: 16jY7q7x9EjwysPAYtappeDX6Lqtm32ekf
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLzCiYnMdjWKzRsXUn
Priv (HEX): 0x0000000000000000000000000000000000000000000000008000247B3183BFDC

Pub Addr: 16jY7qTWTgUzCEEH7E9UFxVKALnvCcykwV
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLziDMQ1SzkL55t52w
Priv (HEX): 0x00000000000000000000000000000000000000000000000080009B6E64AE0CAD

Pub Addr: 16jY7qwSwoyaH2NT2dKsY15h11Gma5bccb
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLzSjUdaY9XWkAo8pE
Priv (HEX): 0x00000000000000000000000000000000000000000000000080005D00CB38A1B5

Pub Addr: 16jY7qCNptT19yStBa3tgVFy2k7CvhLi8t
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvM13ZD8mLPHJMsj9c6
Priv (HEX): 0x0000000000000000000000000000000000000000000000008000E96EBB6FFC70

Pub Addr: 16jY7q3WZumGZ4gbrDTSte9JTbhEniZpqP
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLzLQVfZGJ81tzYnbi
Priv (HEX): 0x0000000000000000000000000000000000000000000000008000437CBF9A4063

Pub Addr: 16jY7qSaxGdCNribBnf6oxcpaw7aBUA6nN
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLzMkoUUXmUpiqDSm1
Priv (HEX): 0x000000000000000000000000000000000000000000000000800048EE90360155

Pub Addr: 16jY7qSV4qyaXJNmwWCu2t4DRWHuTnQuwz
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLz9toCoHuQiZuBD2p
Priv (HEX): 0x000000000000000000000000000000000000000000000000800019188671357A

Pub Addr: 16jY7qJ3MdatyubzBQ4e67n5D2iJRqFrDY
Priv (WIF): p2pkh:KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYvLzZLFmMZj3v26fWhh
Priv (HEX): 0x0000000000000000000000000000000000000000000000008000779DFF73D53B

See how every new random key is within the same 48 bit range? Now you could change the -topr to whatever toprange and the -subr to whatever subrange. If in the example above you wanted to search every possible range in the toprange of 8000000000000000, you would use -topr 8000000000000000 and -subr 60.

Make sense?

use the -b for compressed and uncompressed.

Do you know any script or program that will check the list of private keys? balance?

how to check balance? or if someone has a script to extract to a separate txt pub address walett

[digaran]

how to check balance? or if someone has a script to extract to a separate txt pub address walett

You don't need to check for balance, you are already searching for addresses with balance. Not that it matters, because you'd need to grind 10 trillion keys a second for a few thousand years to find one of the smallest puzzle keys.

[DrShams]

is vbcr checks for patterns in a  range randomly , or it increments the hexadecimal start range by 1 ??

[zahid888]

Suddenly, the older version of VanBitCrackenS1.exe, which is a compiled executable, stops functioning, and the 10-12 MB exe file suddenly becomes 0 MB. I download the new version from GitHub (compiled exe of VanBitCrackenS v1.1). Everything is the same as it was in the old version. After a few days, whenever addresses are found, a separate text file is created named keys.found.txt, even though I had already specified -o found.txt along with its path. So the question is, has this software been compiled in such a way that any feature can be added or removed at any time, as I have experienced, which is a terrifying experience.

[digaran]

Suddenly, the older version of VanBitCrackenS1.exe, which is a compiled executable, stops functioning, and the 10-12 MB exe file suddenly becomes 0 MB. I download the new version from GitHub (compiled exe of VanBitCrackenS v1.1). Everything is the same as it was in the old version. After a few days, whenever addresses are found, a separate text file is created named keys.found.txt, even though I had already specified -o found.txt along with its path. So the question is, has this software been compiled in such a way that any feature can be added or removed at any time, as I have experienced, which is a terrifying experience.

What do you mean you downloaded the new version? did you see any changes in repository? Because that would make it "a new version" but if the file wasn't changed then it's not a new version looking the same, it's the same old one, besides how exactly an executable file is reduced to 0MB but still exist, I have never seen a file with a no size, it should at least show some size. Also I have never seen a file delete itself.

Anyways, I don't even have the found keys command set but when it finds an address it creates the text file named keysfound.txt by default. My cracker is also untouched.😉

[CatalanaBTC]

Good afternoon, I hope everything is well.

My idea is the following:

I have a BTC.txt file, which has all addresses with a balance greater than 0 starting with 1 (both compressed and uncompressed) (BTC.TXT IS 19 GB AND has 1 btc address in each line)

I want to run bitcrack, VanBitCracken or VBCr which work perfectly, but when I put -i btc.txt, in bitcrack it stays loading for about 6 hours and is removed, and in VanBitCracken and VBCr it doesn't seem to read it directly

I would like to know if I can modify the exe file from either bitcrack, VanBitCracken or VBCr to perform my search or is there another program?


PS: Create a code in python that more or less does the following:

Creates a random 32 byte hex key, then converts it to its respective WIF key both compressed and decompressed, then checks if the compressed and decompressed address of that address matches any address in btc.txt, if so it saves it to found. txt, if it does not find anything it will continue searching until it finds a match OR until it stops the program. What I mean is that in python I have achieved my goal and I would like to do the same but with my gpu

This is the result of my python file WITHOUT GPU and using 4 processors out of 16:

Generated: 20400000 (SHA-256 - HEX)
Last generated key in hexadecimal: 13d0f03fab9c75a97fa6492b8b832b0ce7b11b8cc30f25e8eb1164b9fbc57ded
Compressed Bitcoin address: 1LZfGfy88QjBVkB3DTqpjFwonStb93Bed4
Decompressed Bitcoin address: 1DUXqLAJch8pncVKf63HZBefaKT3b81p5E
Generation rate: 4497.490059165694 keys per second

Generated: 20500000 (SHA-256 - HEX)
Last key generated in hexadecimal: f55599ce4720d4061894e644b99e190ffebb758c7780572e43651e9d622c2f69
Compressed Bitcoin address: 1Nr4BuyWgxS6Bmd4WzUZrkRFZHM6FQcqXp
Decompressed Bitcoin address: 1FgYyC5RAQwr8AUqHH7CP7Sx52avAJYtb
Generation rate: 4572.502992815531 keys per second



PS: I am aware of the difficulty and luck it takes to get 1 match that is very very very unlikely, but I know what I want and that is it



Excuse my English, I am from BCN (SPAIN) and I only speak Spanish and Catalan, so my English is translated

[digaran]

I would like to know if I can modify the exe file from either bitcrack, VanBitCracken or VBCr to perform my search or is there another program?

This tool is not open source, even if it was you couldn't modify exe file, first you need to modify the source code and recompile it to make a new exe. This dev is no longer among us unfortunately, he left these woods a couple of month ago.

At first I was just like you, I thought I could hit a key by "chance" until I got to know about public keys, if you are interested in hunting for puzzles, join us in a futile search for them.😂

Ps, I hope you are not going to post the same thing in every brute force related topic.😉  welcome and happy hunting.

Pss, check my python museum on this same board, I have the ultimate cracking scripts.🙃

[CatalanaBTC]

I would like to know if I can modify the exe file from either bitcrack, VanBitCracken or VBCr to perform my search or is there another program?

This tool is not open source, even if it was you couldn't modify exe file, first you need to modify the source code and recompile it to make a new exe. This dev is no longer among us unfortunately, he left these woods a couple of month ago.

At first I was just like you, I thought I could hit a key by "chance" until I got to know about public keys, if you are interested in hunting for puzzles, join us in a futile search for them.😂

Ps, I hope you are not going to post the same thing in every brute force related topic.😉  welcome and happy hunting.

Pss, check my python museum on this same board, I have the ultimate cracking scripts.🙃

Hello again hahaha
I will not publish in more posts, I only published it in the previous post that I just responded to you and in this, the two posts where I saw that I could get precise answers Smiley

I'll check your wall in a while and let you know if I find anything interesting, although I'm sure I will.

Thank you !! I will take your help into account and although I don't have much knowledge about these things and I am learning, here is a friend to chat with and try to help us with whatever you need.

[bjpark]

I want to get in touch with someone who can make a kangaroo program.
I'm the one who made this public key calculator.
https://youtu.be/9i6cQOTYAkU
I want to modify the kangaroo program to solve puzzle 130.
All I want is a multi-list that doesn't operate kangaroos with one public key
I want to make it a searchable ganghouse.
I made a referral to another programmer and succeeded in multi-listing a small search segment but not in a slightly wider one...
And for me, it's a special case, but 50% of the public key value is + or - value
I succeeded in a program that can tell the difference...

I'm looking for a programmer to work with me.
The connection with me is
t.me/kyscolx

@WanderingPhilospher

Please contact me