Feature Request - Flags to break up the sequence for more parallel generation.

[sigkill]

If we could get a function in place to take a look at a tokenlist, and tell the steps between A to Z - then break those into evenly per core, or per gpu, whatever - it would be possible to build a parallel password generator that could also start and stop at points within a given set - so you could let your system run during the cheap power hours, or return to a point when adding more hardware etc.

Example: 0000 to ZZZZ. That's not hard. But when you have 00000000000000000000000000000000000 to ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ and all steps inbetween, it's still not hard because it's literally just alphas. It still make take time because we are having to go from 0 toZZZZ...

We know that the beginning password token is 00000000000000000000000000000000000, and end is ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ, but then everything in between is 26 steps per character - so the first string:

"00000000000000000000000000000000000" is 36 long. Equally the second string in the set is: "ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ" and equally 36 characters, also 36 characters between each of the characters within the string - a possible total combination of

This makes our process take 36 steps per line - 0-9, A-Z, 221,256,270,138,418,330,000 combinations. If we break that up and add start stop points to the counter for the 0-Z function, we can then break our password list up into smaller chunks, and distribute that. If you went as far as adding functionality like this to automate the process it would help a ton, but equally, just knowing the start and end values, one could also take a given array and compute these values, and generate output tokens to then take to another system to run another instance of btcrecover on.

That might also be better in the sense that you could pre-compute your dictionary, and distribute the work across systems.

Now when we get into really big passwords, this is where a benefit would be shown - things with upper, lower, special, divider characters etc.

If a feature such as this were added it would make brute-forcing things like BIP38 a lot less intensive, probably others as well.

I originally wanted to work on getting hashcat style mask support, but have since realized the password regex is based on python regex standard, which may be superior to the hashcat generators - a translator between the two should still be a goal, however, getting this function I've mentioned above would make this tool even better than it already is.

Likewise - a function within the tokenlist function for adding additional threads per line might be helpful if you have a few different combinations of a given password possibility.

Anyhow I hope this is seen and someone with better scripting skills than myself can make sense of the request. Most of the changes would be within btcrpass.py

Thanks!