You might be using a hash function that is not pointless.
This is actually the same as Half LM Challenge, only differences are it's slower and it won't tell you if you crack the first 7 characters.
Instead generate Half LM Challenge and Second Half LM Challenge tables. Second Half LM Challenge tables would look like this in RT* format:
2ndhalflmchall_hybird2(byte#1-1,alpha#1-7)#0-0_*.rt*
P.S. If you have LM Challenge tables just rename them from lmchall_* to halflmchall_* and you'll get a speed increase.
Only problem comes in if the table has a password longer than 7 characters because some implementations will buffer overflow like rcracki_mt:
So if you make an RT of this make sure the brute force point is at least 94*94*maxPwLen*1000 for it to be useful.
With mixalpha-numeric-all#1-7 you'll need a chain length of 364 for it to have a good brute force point.
Only problem is that it will be 7 TB in DIRT format.
FYI: It takes 40 seconds (on a computer from 2003) to brute force mixalpha-numeric-all#1-7 (key space of 2^45.90).
Worthless if you obtain the "hash" to crack you are already able to get on the network.
N/A (if too high increase number of tables and/or steps)
bits / unique chain
bits / unique chain (preliminary results for 99.9%, 4 tables: 3 for perfect and 5 for imperfect)
expected unique chains / mini index
expected chains / mini index
bits / index
expected chains / index
expected chains / index
N/A (N/A, N/A, N/A, N/A) bits / chain
N/A
N/A
N/A
N/A
N/A
N/A
Size calculations for RTI2 will in some cases be smaller than actually possible by a bit or two per chain.
Size calculations for RTC are umm estimates. OK fine I pulled a formula out my ass.
These were done to increase speed:
Large chain lengths and imperfect tables will take a long time. I actually set a max of 500,000 for the chain length in the calculation for the table work factor.
Imperfect tables have a max table work factor of just under 256x (you won't hit this limit unless you try).
If you change the chain count on imperfect tables the table work factor calculation will be off. Since it does not refine the calculation multible times to find the correct chain length.
To do:
User input of brute force point
Better function for finding table work factor when chain length is the unknown (chain count was changed last).
Nonfunctional Preview
MLinks / Second
RF
Seq
CS Len
PW Lens
Key Space
Total SR
Total MR
Perfect
Tables
Total WF
Table WF
Gen Time
Format
SP Size
EP Size
Index Size
Chain Len
Chains
Crack Time
Size
FPM
256
10-10
2 ^ 52.5741
99.917210%
1207.8753
10
62.7956x
15.6989x
3y 123d
DIRT
40 b/Ch
16 b/Ch
2.6125 b/Ch
1,000,000
10,525,764,370,931
16m 40s
153.17 TiB
FPM
256
10-10
2 ^ 52.5741
99.917210%
1207.8753
10
62.7956x
15.6989x
3y 123d
DIRT
40 b/Ch
16 b/Ch
2.6125 b/Ch
1,000,000
10,525,764,370,931
16m 40s
153.17 TiB
FPM
256
10-10
2 ^ 52.5741
99.917210%
1207.8753
10
62.7956x
15.6989x
3y 123d
DIRT
40 b/Ch
16 b/Ch
2.6125 b/Ch
1,000,000
10,525,764,370,931
16m 40s
153.17 TiB
Nonfunctional Preview
...
Unfinished
RT Formats Sorted Best to Worst (rated on bits/chain, search ability, and functional) IPRT "Indexed Perfect RT" (<⅓x RT size) ------------ fix me
Created by me in March 2010
Rainbow table must be perfect
Uses a mini prefix index and magic for saving space and searching
Variable bit per start point
Mini prefix index (1/6-1/12 bits per chain) + about 2.5 bits per chain for magic
Header has the rainbow table parameters
Support for different reduction functions
Support for variable byte characters
This is stated as less than one third RT's size because in most cases it is. To make it greater than one third of RT's size one would need to do one or more of the following:
Non sequential start points
Large key space (>2 ^ 52)
Large brute force point (>800,000)
Check points
*.iprt
Header
Tag "IPRT0" (5 bytes)
Start point bit length "SP" (1 byte)
Mini indexed bits (1 byte)
Check points "CP" (1 byte)
First file index (4 bytes)
Files (4 bytes)
Virtual files (in this file) (4 bytes)
Rainbow table parameters
Minimum start point (8 bytes)
Chain length (4 bytes)
Table index (1 byte)
Key space (1 byte)
Algorithm (1 byte)
Will never support: MySQL323, LM Challenge, or WPA-PSK
Reduction function (1 byte)
If Algorithm is Custom "0"
Algorithm name length (1 byte)
Algorithm name (Algorithm name length bytes)
Invalid algorithm names: all the algorithms mentioned earlier that also includes MySQL323, LMChall, and WPA-PSK.
If Algorithm has salt or is Custom "0"
Salt length (1 byte)
Salt (Salt length bytes)
If Key space is Custom "0"
Character sets (1 byte)
Character set
Number of hybrid sets (1 byte)
Hybrid sets
Password length (1 byte)
Copy char set (0xffff - new character set) (2 bytes)
Character set # (1 byte)
Hybrid set # (1 byte)
If Copy char set = 0xffff
Character1 set size (Char1 set size = 1 * (Data + 1)) (1 byte)
Character2 set size (Char2 set size = 2 * (Data + 1)) (1 byte)
Character3 set size (Char3 set size = 3 * (Data + 1)) (1 byte)
Character4 set size (Char4 set size = 4 * (Data + 1)) (1 byte)
Character1 set (1 byte characters) (Char1 set size bytes)
Character2 set (2 byte characters) (Char2 set size bytes)
Character3 set (3 byte characters) (Char3 set size bytes)
Character4 set (4 byte characters) (Char4 set size bytes)
If Key space is Markov "11"
Max password length (1 byte)
Max Markov weight (2 bytes)
Default weight (2 bytes)
Stats file size (if zero use default stats file from John the Ripper) (2 bytes)
If Stats file size is not zero
Number of first character weights (1 byte)
Number of double character weights (2 bytes)
First character weights
First character (1 byte)
Weight (2 bytes)
Double character weights
Current character (1 byte)
Previous character (1 byte)
Weight (2 bytes)
If Key space is Word list "12"
Number of rules (1 byte)
Max word length (1 byte)
Rules
??? (? bytes) ------------ fix me
For X = 1 to Max word length
Number of X character words (4 bytes)
For X = 1 to Max word length
X character word
Word (X bytes)
Check point positions (4*CP bytes)
If Virtual files > 1
Virtual files
Virtual file byte offset (8 bytes)
Virtual files
Mini prefix indexes
Chain block offset (4 bytes)
Chain blocks
Magic data (about 2.5 bits per chain)
Chains
Start point (SP bits)
Check points (CP bits)
IRT "Indexed RT" (<½x RT size) ------------ fix me
Created by me in March 2010
Uses a mini prefix index and bit field for saving space and searching
Variable bit per chain
Mini prefix index (1/6-1/12 bits per chain) + 1.5-2 bits per index (2-3 bits per chain)
Header has the rainbow table parameters
Support for different reduction functions
Support for variable byte characters
This is stated as less than one half RT's size because in most cases it is. To make it greater than one half of RT's size one would need to do one or more of the following:
Non sequential start points
Large key space (>2 ^ 56)
Check points
*.irt
Header
Tag "IRT0" (4 bytes)
Start point bit length "SP" (1 byte)
Mini indexed bits (1 byte)
Total indexed bits "N" (1 byte)
Check points "CP" (1 byte)
First file index (4 bytes)
Files (4 bytes)
Virtual files (in this file) (4 bytes)
Rainbow table parameters
Minimum start point (8 bytes)
Chain length (4 bytes)
Table index (1 byte)
Key space (1 byte)
Algorithm (1 byte)
Will never support: MySQL323, LM Challenge, or WPA-PSK
Reduction function (1 byte)
If Algorithm is Custom "0"
Algorithm name length (1 byte)
Algorithm name (Algorithm name length bytes)
Invalid algorithm names: all the algorithms mentioned earlier that also includes MySQL323, LMChall, and WPA-PSK.
If Algorithm has salt or is Custom "0"
Salt length (1 byte)
Salt (Salt length bytes)
If Key space is Custom "0"
Character sets (1 byte)
Character set
Number of hybrid sets (1 byte)
Hybrid sets
Password length (1 byte)
Copy char set (0xffff - new character set) (2 bytes)
Character set # (1 byte)
Hybrid set # (1 byte)
If Copy char set = 0xffff
Character1 set size (Char1 set size = 1 * (Data + 1)) (1 byte)
Character2 set size (Char2 set size = 2 * (Data + 1)) (1 byte)
Character3 set size (Char3 set size = 3 * (Data + 1)) (1 byte)
Character4 set size (Char4 set size = 4 * (Data + 1)) (1 byte)
Character1 set (1 byte characters) (Char1 set size bytes)
Character2 set (2 byte characters) (Char2 set size bytes)
Character3 set (3 byte characters) (Char3 set size bytes)
Character4 set (4 byte characters) (Char4 set size bytes)
If Key space is Markov "11"
Max password length (1 byte)
Max Markov weight (2 bytes)
Default weight (2 bytes)
Stats file size (if zero use default stats file from John the Ripper) (2 bytes)
If Stats file size is not zero
Number of first character weights (1 byte)
Number of double character weights (2 bytes)
First character weights
First character (1 byte)
Weight (2 bytes)
Double character weights
Current character (1 byte)
Previous character (1 byte)
Weight (2 bytes)
If Key space is Word list "12"
Number of rules (1 byte)
Max word length (1 byte)
Rules
??? (? bytes) ------------ fix me
For X = 1 to Max word length
Number of X character words (4 bytes)
For X = 1 to Max word length
X character word
Word (X bytes)
Check point positions (4*CP bytes)
If Virtual files > 1
Virtual files
Virtual file byte offset (8 bytes)
Virtual files
Mini prefix indexes
Chain block offset (4 bytes)
Chain blocks
Bit field to determine which chain is part of which end point prefix
Chains
End point (log2(keySpace) - N bits)
Start point (SP bits)
Check points (CP bits)
RTI2 "RT Improved 2" (<½x RT size)
Created by PowerBlade from FreeRainbowTables.com in June 2009 (finalized in October 2011)
Uses a prefix index for saving space
Variable byte per chain
1 byte per index
Header has the rainbow table parameters (ignore key space in minor 0x00)
File name has the rainbow table parameters (use key space in minor 0x00)
Support for different reduction functions
Support for variable byte characters
*_*#*-*_*_*x*_*.rti2
Only in minor 0x00
Hash algorithm
Character set name
Minimum password length
Maximum password length
Table index
Chain length
Chain count
Comment
*.rti2
Header
Tag "RTI2" (4 bytes)
Minor "0x00" (1 byte)
Start point bit length "SP" (1 byte)
End point bit length "EP" (1 byte)
Number of check points "CP" (1 byte)
File index (4 bytes)
Files (4 bytes)
Rainbow table parameters
Minimum start point (8 bytes)
Chain length (4 bytes)
Table index (4 bytes)
Algorithm (1 byte)
Reduction function (1 byte)
If Algorithm has salt
Salt length (1 byte)
Salt (Salt length bytes)
Number of sub key spaces (1 byte)
Sub key space
Number of hybrid character sets (1 byte)
Hybrid character set
Password length (1 byte)
Multi-byte character set flags (1 - char len 1, 2 - char len 2, 4 - char len 3, 8 - char len 4) (1 byte)
MB_Character1 set size (MB_Character1 set size = 1 * (Data + 1)) (if enabled 1 byte, else 0 bytes)
MB_Character2 set size (MB_Character2 set size = 2 * (Data + 1)) (if enabled 1 byte, else 0 bytes)
MB_Character3 set size (MB_Character3 set size = 3 * (Data + 1)) (if enabled 1 byte, else 0 bytes)
MB_Character4 set size (MB_Character4 set size = 4 * (Data + 1)) (if enabled 1 byte, else 0 bytes)
MB_Character1 set (1 byte characters) (MB_Character1 set size bytes)
MB_Character2 set (2 byte characters) (MB_Character2 set size bytes)
MB_Character3 set (3 byte characters) (MB_Character3 set size bytes)
MB_Character4 set (4 byte characters) (MB_Character4 set size bytes)
Index bit length must be 8 (rare too find and easy to exploit, but simple to fix just drop chains [as long as it's not a large percentage])
SP+EP+CP must be at most 64 (can be limiting with check points, non sequential start points, and/or large key spaces)
RTC "RT Compact" (~½x RT size)
Created by Zhu Shuanglei from Project-RainbowCrack.com in August 2009
Uses linear regression for saving space and sorted for searching
Variable byte per chain
File name has the rainbow table parameters
*_*#*-*_*_*x*_*.rtc
Hash algorithm
Character set name
Minimum password length
Maximum password length
Table index
Chain length
Chain count
Comment
*.rtc
Header (32 bytes)
Tag "RTC0" (4 bytes)
Start point length in bits "SP" (2 bytes, 1 to 64)
End point length in bits "EP" (2 bytes, 1 to 64)
SP+EP must be a multiple of 8
Minimum start point (8 bytes)
Minimum end point (8 bytes)
End point interval (8 bytes)
Chains (ceiling[[SP+EP]/8] bytes)
Start point (SP bits)
End point error (EP bits)
End point is compressed with linear regression to minimize max error
EndPoint[i] = EndPointInterval * i + MinimumEndPoint + EndPointError
Ophcrack Format (<½x, >⅜x RT size)
Created by Philippe Oechslin in "2003?" before September 2004
Uses a prefix index for saving space and searching
6 bytes per chain
4 bytes per index
Max 2^32 chains / table
End point is truncated to less than the key space, max end point is 48 bits
Ophcrack looks at the beginning of the table to see which rainbow table it is (or user inputted)
*.index
Chain offset (4 bytes)
*.start
Start point (4 bytes)
Generated from sequential start points also check points are stored here if there are any but all the free tables do not have check points. If I remember correctly I asked about the lack of check points in their old forum and got a reply of they are not that useful.
*.bin
End point (2 bytes)
RTI "RT Improved" (>½x RT size)
Created by PowerBlade from FreeRainbowTables.com in June 2008
Uses a prefix index for saving space (and searching [not implemented])
8 bytes per chain
11 bytes per index
File name has the rainbow table parameters
*_*#*-*_*_*x*_*.rti*
Hash algorithm
Character set name
Minimum password length
Maximum password length
Table index
Chain length
Chain count
Comment
[.index]
*.rti
Chains
Start point (6 bytes)
End point (2 bytes)
*.rti.index
Prefix indexes
End point prefix (5 bytes)
All but one end point prefix is not needed
One reason for this being on each prefix index is so that you can save space by removing prefix indexes with no chains, but almost doubling the size of a prefix index makes this reason a bad one.
Chain offset (4 bytes)
Number of chains (2 bytes)
Number of chains is not needed
I think PowerBlade said this was for validation.
RT "Original format for RCrack"
Created by Zhu Shuanglei from Project-RainbowCrack.com in September 2003
Sorted for searching
16 bytes per chain
File name has the rainbow table parameters
*_*#*-*_*_*x*_*.rt
Hash algorithm
Character set name
Minimum password length
Maximum password length
Table index
Chain length
Chain count
Comment
*.rt
Chains
Start point (8 bytes)
End point (8 bytes)
GRT "GPU RT" (>2x RT size)
Created by Bitweasil from CryptoHaze.com in July 2010
Character set count [1 - single character set, N - character set per position] (1 byte)
16 Character set lengths (16*1 bytes)
16 Character sets (16*256 bytes)
Future use (2000 bytes)
Comments (1000 bytes)
Null padding to 8 KiB
Chains
End hash (16 bytes)
Start password (16 bytes)
*.grt.idx
Prefix indexes
End point prefix (4 bytes)
All but one end point prefix is not needed
Chain offset (8 bytes)
"Slow Thing" (½x RT size)
Created by Vrizlynn Thing and Hwei-Ming Ying in August 2009
Rainbow table must be imperfect
Must be unsorted
Must be generated with given start points
8 bytes per chain
File format (this is not a finalized format)
Start point seed (8 bytes)
Chains
End point (8 bytes)
I make fun of this one because searching is slow O(chainCount) vs. [O(chainLength) or O(files * chainLength * log(chainCount / files))],
but for small tables it might not matter too much. That and "start point seed" instead of "first start point."
It was stated in their paper to do h[0] = hash(index2pw("start point seed")), h[i + 1] = (h[i] + 1) % (2 ^ hashBits), startPoint[i] = hash2pw(h[i])
why it wasn't just startPoint[0] = "start point seed", startPoint[i + 1] = (startPoint[i] + 1) % keySpace.
Also depending on a few things h[i + 1] = (h[i] + 1) % (2 ^ hashBits) could cause duplicate start points.
4, 1 GiB *.rt files with a chain length of 5000:
average operations to search = 520,000 = 4 * 5,000 * 26
4, 0.5 GiB "*.rtd" files a with chain length of 5000:
average operations to search = 268,435,456 = 268,435,456
4, 1 GiB "*.rtd" files a with chain length of 2500:
average operations to search = 536,870,912 = 536,870,912
As you can see that's 516 and 1,032 times more operations than searching a *.rt, but the *.rt will thrash your CPU's cache which will make it slower but overall it should be faster just not by 500x.
RTI0 "RT Improved Broken" (>½x RT size)
Created by PowerBlade from FreeRainbowTables.com in April 2008
Uses a prefix index for saving space (and searching [not implemented])
8 bytes per chain
11 bytes per index
File name has the rainbow table parameters
*_*#*-*_*_*x*_*[i]*.rt*
Hash algorithm
Character set name
Minimum password length
Maximum password length
Table index
Chain length
Chain count
Comment
[p] if perfect
[.index]
*[i]*.rt
Chains
Start point (5 bytes)
Start point was not big enough to hold a random start point