Topic: VanBitCracken - a program to use for 32 BTC challenge (supports RTX 30xx cards) - page 2. (Read 5209 times)

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.

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!

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?

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?

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

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.

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?

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.

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.

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?

Tks is in bsgs mode not rmd160 mode

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?

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.

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

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

Yes, if my math above was correct lol

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

Is my math correct?

What is required to run the program on Lambda machine?

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,