Ahhh I see what you are looking at! and I have an answer
I wrote the script before I even fathomed counting the number of possible combinations. Maybe my number of possible combinations is wrong, maybe it isnt, but I am *00% positive that the script will ONLY try each combination once. It doesn't do this because I did some fancy formula to skip the duplicates!
I sat down and wrote everything on a piece of paper...
This is what went through my head. I started very simple...
If I know these facts:
*. You have a plain text password.
2. The password can be a minimum of * character and a maximum of * characters.
*. The password can only contain the following letters (a,b,c)
How can I run through every possible combination to crack this plain text password? A password is a password. AAA=AAA=AAA=AAA It does not matter which A is in which spot right? I took think into consideration when writing this and thought of a way to bypass the possibility.
I started by writing every possible password combination down:
aaa
aab
aac
aba
abb
abc
aca
acb
acc
baa
bab
bac
bba
bbb
bbc
bca
bcb
bcc
caa
cab
cac
cba
cbb
cbc
cca
ccb
ccc
This would cover every single possibility right?
Well how could you code something to replicate this?
Think simple, very simple!
Ok, lets think math for a second. How do number systems work?
Base *0 = 0*2*45678*
It might be easier to view it vertically.
0
*
2
*
4
5
6
7
8
*
now what?
*0
and there is the basis of my entire script.
Here are the inner workings:
I created two arrays and a pointer to accomplish this:
Array*("a","b","c")
Array2("0","0","0")
Float("0")
Now lets make a note what happens on each side of a number when it reaches its maximum point:
000
00*
002
THE LEFT DIGIT INCREMENTS ONE AND THE RIGHT RETURNS TO ZERO (ALSO CAN BE VIEWED AS THE FIRST POINT IN THE ARRAY)
0*0
WHAT ABOUT *22?
This is when my magic FLOAT comes in handy. This is what the program does. The float would be in array position 2 (which is also the furthest right 2)
*. FLOAT realize it has reached its MAX point
2. FLOAT MOVES LEFT ONE PLACE (which is position * in the array)
*. FLOAT realize it has reached its MAX point
4. FLOAT MOVES LEFT ONE PLACE (which is position 0 in the array)
5. FLOAT realize it has NOT reached its MAX point so it increments it by one
6. FLOAT MOVES RIGHT * PLACE AND RESETS TO 0 (which is position * in the array)
7. FLOAT MOVES RIGHT * PLACE AND RESETS TO 0 (which is position 2 in the array)
8. FLOAT realize it has reached maximum length of the array.
PROCESS FINISHED
OUTPUT 200
PROCESS STARTS AGAIN
*. FLOAT realises it has NOT reached its MAX point
2. FLOAT realises it has NOT reached its MAX point so it increments it by one (which is position 2 in the array)
PROCESS FINISHED
OUTPUT 20*
Ok now you should be thinking, WTF! you said you could only use a,b,c what the hell are you doing counting?
Now think outside the box and look at the number again, but each digit representing a spot in the array.
000 or 0:0:0 or aaa
200 or 2:0:0 or caa
20* or 2:0:* or cab
How is that for an explanation? Did that make things a little more clear? or just confuse you more?
Oh yeah almost left this part out:
After 222 is reach (also 2:2:2 also ccc)
Array2 is rebuild with n-* places so array2 would be
Array2("0","0")
PROCESS WOULD BEGIN
00
0*
02
0*
*0
**
*2
**
20
~SyntaX