1How to use the 'dynamic' format within john. 2 3John has been enhanced to be able to handle MANY MD5/SHA1 and other cipher 4variants easily. 5 6'variants' are things like: 7 8md5($p) (Note, $p is the password, $s will be the salt, etc) 9md5(md5($p)) (Note, this is md5 of the 32 byte result of a prior md5) 10md5($p.$s) (Note, . is the concatenate operator, so $p.$s is 11 password with salt appended) 12sha1($p) (Note, $p is password, and sha1 is the cipher). 13sha1(md5($p)) Here we first run md5 on password, then sha1 on the 14 resultant 'hex' string. 15sha512($s.sha512($p.$s).$p) This uses a couple of calls to sha512. 16 The intermedidate results are possible to be in 17 base-16 (or base-16 uppercase), base-64 (MIME), or 18 raw 64 bytes. 19... 20 21Most of the above rules are php 'style' rules, but I think in php, 22$pass is used, and $salt is used. In this document, they have been 23simplified to $p and $s. 24 25This is done by using a new file format string: dynamic_# where 26the # is a number. John reserves numbers from dynamic_0 up to 27dynamic_999 for 'built-in' formats. Not all are defined at this 28time, but those have been reserved. 29 30The format of the input file lines will be: 31 32userID:$dynamic_#$base_16_hash[$salt] 33 34Salts can contain some problematic characters. Some of these would be 35characters such as: : \r \n \ NULL, etc. The : (colon) char is used 36by JtR as a field separator. If it exists in the salt, it will split 37the salt into multiple fields (i.e. wrong). A carriage return or line 38feed, will cause the line to split, and JtR to not read it right. 39NULL bytes are a problem in any C file, using normal 'string' functions. 40The \ char, is used as a quoting char within dynamic, and can cause issues. 41One other recently found issue, is if the salt ends in ' ' or '\t' (space 42or tab), then if the dyna hash is placed on a line by itself (i.e. without 43a user: prepended), then jtr will trim the whitespace off. This is a known 44issue, and this is just a bad side effect of a known wanted behavior where 45the raw hash files are cleaned up during processing. 46DUE to all of these problems, dynamic has been expanded to take this as 47the salt: $dyanamic_#$base_16_hash$HEX$hex_bytes_of_salt. In this 48format, if the salt was 1234, then $HEX$31323334 would be the equivalent 49value. This allows salts such as $\x0:\r\nBadSalt to actually be encoded. 50This salt CAN be used, if you use the representation: 51$HEX$003a0a0d42616453616c74. 52There is an application in ./run which can 'help' This is ./run/raw2dyna 53This process will convert files in the format of hashCsalt (c can be any char), 54into the proper $dynamic_#$hash$salt It can also handle saltChash (if 55salt is a fixed size). It also properly handle the problematic characters, 56and uses the $HEX$hex_salt method, if there are bad characters in the salt. 57 58There may be a 2nd salt added in the near future, but not sure how it 59will be implemented. 60 61Here is an 'example' of the format required: 62 63userID:$dynamic_0$28fc2782ea7ef51c1104ccf7b9bea13d 64 65which is 'raw' md5, with a password of 1402 66 67userID:$dynamic_6$8d8cac84f234f42e32daeb94e7cd49e8$*.* 68 69which is in the vBulletin format: md5(md5($p).$s), and which has a 70fixed 3 byte salt (the $*.* above is the salt signature, and the 71salt is *.*), solomon1 is the password for the above hash. NOTE 72vBulletin is actually dynamic_7. It is the expression format, but 73puts to additional constraints on input. dynamic_7 forces a 3 byte 74salt, and it will NOT allow ':' character to be used as a separator, 75since vBulletin salts can contain that character. However, the 76above dynamic_6 works for this document, since *.* salt does not 77have a ':' 78 79Expressions can be added to john.conf (john.ini), dynamic.conf 80(included by john.conf) or john.local.conf to allow an end user 81to add a new format type, without having to do ANY coding at all. 82The end user would have to learn the $dynamic_n$ 83primitives, and how the data is used (input data, key data, 84encryption data, etc). Also, the user would have to build 85properly formatted SAMPLE test values (john requires this). 86For the full 'HOW TO USE' documentation, see the dynamic.conf. 87 88 89How to build the 'test' value is beyond the scope of this readme, 90but a trivial example might help. 91Expression format: md5(md5($p).md5($p)) 92Password test1 93md5(test1) == 5a105e8b9d40e1329780d62ea2265d8a 94so we want to md5 that result concatenated 95so md5(md5(test1).md5(test1)) is the same as 96md5(5a105e8b9d40e1329780d62ea2265d8a5a105e8b9d40e1329780d62ea2265d8a) 97which equals 478b10974f15e7295883224fd286ccba 98so a proper 'test' line is: 99Test=$dynamic_1003$478b10974f15e7295883224fd286ccba:test1 100( as can be seen in dynamic.conf for dynamic_1003 ) 101 102To get a list of all dynamic formats, you can use 103 104./john --list=subformats 105 106This command will create output like this: 107 108Format = dynamic_0 type = dynamic_0: md5($p) (raw-md5) 109Format = dynamic_1 type = dynamic_1: md5($p.$s) (joomla) 110Format = dynamic_2 type = dynamic_2: md5(md5($p)) (e107) 111... 112Format = dynamic_32 type = dynamic_32: md4($p.$s) 113Format = dynamic_33 type = dynamic_33: md4(unicode($p)) 114Format = dynamic_34 type = dynamic_34: md5(md4($p)) 115UserFormat = dynamic_1001 type = dynamic_1001 md5(md5(md5(md5($p)))) 116UserFormat = dynamic_1002 type = dynamic_1002 md5(md5(md5(md5(md5($p))))) 117UserFormat = dynamic_1003 type = dynamic_1003 md5(md5($p).md5($p)) 118 119The "Format = ..." lines list builtin formats, the lines "UserFormat = ..." 120list user formats (or sample formats). 121 122The builtiin formats that john has right now are: 123 124------------+-------------------------+-------+------------------ 125Signature | expression | Salt | notes 126------------+-------------------------+-------+------------------ 127dynamic_0 | md5($p) | No | raw-md5 128dynamic_1 | md5($p.$s) | Yes | (joomla) 129dynamic_2 | md5(md5($p)) | No | double md5 (e107) 130dynamic_3 | md5(md5(md5($p))) | No | triple md5 131dynamic_4 | md5($s.$p) | Yes | (OS Commerce) 132dynamic_5 | md5($s.$p.$s) | Yes | 133dynamic_6 | md5(md5($p).$s) | Yes | 134dynamic_7 | md5(md5($p).$s) | Yes | vBulletin. 3 byte salt, salt uses ':' char 135dynamic_8 | md5(md5($s).$p) | Yes | 136dynamic_9 | md5($s.md5($p)) | Yes | 137dynamic_10 | md5($s.md5($s.$p)) | Yes | 138dynamic_11 | md5($s.md5($p.$s)) | Yes | 139dynamic_12 | md5(md5($s).md5($p)) | Yes | (IPB) 140dynamic_13 | md5(md5($p).md5($s)) | Yes | 141dynamic_14 | md5($s.md5($p).$s) | Yes | 142dynamic_15 | md5($u.md5($p).$s) | Yes | 143dynamic_16 | md5(md5(md5($p).$s).$s2)| Yes | 144dynamic_17 | phpass ($H$ and $P$) | Yes | phpass and PHPbb-v3 hashes 145dynamic_18 | PostOffice MD5 (PO) | Yes | md5($s.Y.$p.\xF7.$s) (Post.Office MD5) 146dynamic_19 | Cisco PIX | No | 147dynamic_20 | Cisco PIX (salted) | Yes | 148dynamic_21 | HTTP Digest Access Auth | Yes | Contains a 'special' salt function. 149dynamic_22 | md5(sha1($p)) | No | Use sha1 internally, but sill md5 hash (32 byte hex number) 150dynamic_23 | sha1(md5($p)) | No | Requires a 40 byte hex number (valid sha1 input) 151dynamic_24 | sha1($p.$s) | Yes | Requires a 40 byte hex number (valid sha1 input) 152dynamic_25 | sha1($s.$p) | Yes | Requires a 40 byte hex number (valid sha1 input) 153dynamic_26 | sha1($p) (raw-sha1) | No | Requires a 40 byte hex number (valid sha1 input) 154dynamic_27 | FreeBSD md5 | Yes | 155dynamic_28 | Apache MD5 | Yes | 156dynamic_29 | md5(unicode($p)) | No | 157dynamic_30 | md4($p) (raw-md4) | No | 158dynamic_31 | md4($s.$p) | Yes | 159dynamic_32 | md4($p.$s) | Yes | 160dynamic_33 | md4(unicode($p)) | No | 161dynamic_34 | md5(md4($p)) | No | 162dynamic_35 | sha1(uc($u).:.$p) | Yes | ManGOS 163dynamic_36 | sha1($u.:.$p) | Yes | ManGOS2 164dynamic_37 | sha1(lc($u).$p) | Yes | SMF 165dynamic_38 | sha1($s.sha1($s.sha1($p)))| Yes | Wolt3BB 166dynamic_39 | md5($s.pad_16($p)) | Yes | Net-md5. Long salt, passwords are 16 bytes, null padded for under 16 bytes 167dynamic_40 | sha1($s.pad_16($p)) | Yes | Net-sha1. Long salt, passwords are 16 bytes, null padded for under 16 bytes 168dynamic_50 | sha224($p) | No | 169dynamic_51 | sha224($s.$p) | Yes | 170dynamic_52 | sha224($p.$s) | Yes | 171dynamic_53 | sha224(sha224($p)) | No | 172dynamic_54 | sha224(sha224_raw($p)) | No | 173dynamic_55 | sha224(sha224($p).$s) | Yes | 174dynamic_56 | sha224($s.sha224($p)) | Yes | 175dynamic_57 | sha224(sha224($s).sha224($p)) | Yes | 176dynamic_58 | sha224(sha224($p).sha224($p)) | No | 177dynamic_60 | sha256($p) | No | 178dynamic_61 | sha256($s.$p) | Yes | 179dynamic_62 | sha256($p.$s) | Yes | 180dynamic_63 | sha256(sha256($p)) | No | 181dynamic_64 | sha256(sha256_raw($p)) | No | 182dynamic_65 | sha256(sha256($p).$s) | Yes | 183dynamic_66 | sha256($s.sha256($p)) | Yes | 184dynamic_67 | sha256(sha256($s).sha256($p)) | Yes | 185dynamic_68 | sha256(sha256($p).sha256($p)) | No | 186dynamic_70 | sha384($p) | No | 187dynamic_71 | sha384($s.$p) | Yes | 188dynamic_72 | sha384($p.$s) | Yes | 189dynamic_73 | sha384(sha384($p)) | No | 190dynamic_74 | sha384(sha384_raw($p)) | No | 191dynamic_75 | sha384(sha384($p).$s) | Yes | 192dynamic_76 | sha384($s.sha384($p)) | Yes | 193dynamic_77 | sha384(sha384($s).sha384($p)) | Yes | 194dynamic_78 | sha384(sha384($p).sha384($p)) | No | 195dynamic_80 | sha512($p) | No | 196dynamic_81 | sha512($s.$p) | Yes | 197dynamic_82 | sha512($p.$s) | Yes | 198dynamic_83 | sha512(sha512($p)) | No | 199dynamic_84 | sha512(sha512_raw($p)) | No | 200dynamic_85 | sha512(sha512($p).$s) | Yes | 201dynamic_86 | sha512($s.sha512($p)) | Yes | 202dynamic_87 | sha512(sha512($s).sha512($p)) | Yes | 203dynamic_88 | sha512(sha512($p).sha512($p)) | No | 204dynamic_90 | GOST($p) | No | 205dynamic_91 | GOST($s.$p) | Yes | 206dynamic_92 | GOST($p.$s) | Yes | 207dynamic_93 | GOST(GOST($p)) | No | 208dynamic_94 | GOST(GOST_raw($p)) | No | 209dynamic_95 | GOST(GOST($p).$s) | Yes | 210dynamic_96 | GOST($s.GOST($p)) | Yes | 211dynamic_97 | GOST(GOST($s).GOST($p)) | Yes | 212dynamic_98 | GOST(GOST($p).GOST($p)) | No | 213dynamic_100 | WHIRLPOOL($p) | No | 214dynamic_101 | WHIRLPOOL($s.$p) | Yes | 215dynamic_102 | WHIRLPOOL($p.$s) | Yes | 216dynamic_103 | WHIRLPOOL(WHIRLPOOL($p)) | No | 217dynamic_104 | WHIRLPOOL(WHIRLPOOL_raw($p)) | No | 218dynamic_105 | WHIRLPOOL(WHIRLPOOL($p).$s) | Yes | 219dynamic_106 | WHIRLPOOL($s.WHIRLPOOL($p)) | Yes | 220dynamic_107 | WHIRLPOOL(WHIRLPOOL($s).WHIRLPOOL($p)) | Yes | 221dynamic_108 | WHIRLPOOL(WHIRLPOOL($p).WHIRLPOOL($p)) | No | 222dynamic_110 | Tiger($p) | No | 223dynamic_111 | Tiger($s.$p) | Yes | 224dynamic_112 | Tiger($p.$s) | Yes | 225dynamic_113 | Tiger(Tiger($p)) | No | 226dynamic_114 | Tiger(Tiger_raw($p)) | No | 227dynamic_115 | Tiger(Tiger($p).$s) | Yes | 228dynamic_116 | Tiger($s.Tiger($p)) | Yes | 229dynamic_117 | Tiger(Tiger($s).Tiger($p)) | Yes | 230dynamic_118 | Tiger(Tiger($p).Tiger($p)) | No | 231dynamic_120 | RIPEMD128($p) | No | 232dynamic_121 | RIPEMD128($s.$p) | Yes | 233dynamic_122 | RIPEMD128($p.$s) | Yes | 234dynamic_123 | RIPEMD128(RIPEMD128($p)) | No | 235dynamic_124 | RIPEMD128(RIPEMD128_raw($p)) | No | 236dynamic_125 | RIPEMD128(RIPEMD128($p).$s) | Yes | 237dynamic_126 | RIPEMD128($s.RIPEMD128($p)) | Yes | 238dynamic_127 | RIPEMD128(RIPEMD128($s).RIPEMD128($p)) | Yes | 239dynamic_128 | RIPEMD128(RIPEMD128($p).RIPEMD128($p)) | No | 240dynamic_130 | RIPEMD160($p) | No | 241dynamic_131 | RIPEMD160($s.$p) | Yes | 242dynamic_132 | RIPEMD160($p.$s) | Yes | 243dynamic_133 | RIPEMD160(RIPEMD160($p)) | No | 244dynamic_134 | RIPEMD160(RIPEMD160_raw($p)) | No | 245dynamic_135 | RIPEMD160(RIPEMD160($p).$s) | Yes | 246dynamic_136 | RIPEMD160($s.RIPEMD160($p)) | Yes | 247dynamic_137 | RIPEMD160(RIPEMD160($s).RIPEMD160($p)) | Yes | 248dynamic_138 | RIPEMD160(RIPEMD160($p).RIPEMD160($p)) | No | 249dynamic_140 | RIPEMD256($p) | No | 250dynamic_141 | RIPEMD256($s.$p) | Yes | 251dynamic_142 | RIPEMD256($p.$s) | Yes | 252dynamic_143 | RIPEMD256(RIPEMD256($p)) | No | 253dynamic_144 | RIPEMD256(RIPEMD256_raw($p)) | No | 254dynamic_145 | RIPEMD256(RIPEMD256($p).$s) | Yes | 255dynamic_146 | RIPEMD256($s.RIPEMD256($p)) | Yes | 256dynamic_147 | RIPEMD256(RIPEMD256($s).RIPEMD256($p)) | Yes | 257dynamic_148 | RIPEMD256(RIPEMD256($p).RIPEMD256($p)) | No | 258dynamic_150 | RIPEMD320($p) | No | 259dynamic_151 | RIPEMD320($s.$p) | Yes | 260dynamic_152 | RIPEMD320($p.$s) | Yes | 261dynamic_153 | RIPEMD320(RIPEMD320($p)) | No | 262dynamic_154 | RIPEMD320(RIPEMD320_raw($p)) | No | 263dynamic_155 | RIPEMD320(RIPEMD320($p).$s) | Yes | 264dynamic_156 | RIPEMD320($s.RIPEMD320($p)) | Yes | 265dynamic_157 | RIPEMD320(RIPEMD320($s).RIPEMD320($p)) | Yes | 266dynamic_158 | RIPEMD320(RIPEMD320($p).RIPEMD320($p)) | No | 267 268 269........ | RESERVED | UNK | 270dynamic_999 | RESERVED | UNK | 271 272The 'samples' stored in dynamic.conf (to be used as is, or as examples) are: 273 274dynamic_1001 md5(md5(md5(md5($p)))) 275dynamic_1002 md5(md5(md5(md5(md5($p))))) 276dynamic_1003 md5(md5($p).md5($p)) 277dynamic_1004 md5(md5(md5(md5(md5(md5($p)))))) 278dynamic_1005 md5(md5(md5(md5(md5(md5(md5($p))))))) 279dynamic_1006 md5(md5(md5(md5(md5(md5(md5(md5($p)))))))) 280dynamic_1007 md5(md5($p).$s) (vBulletin) 281dynamic_1008 md5($p.$s) (joomla) 282# and many other newer items, added from user requests. 283dynamic_1010 md5($p null_padded_to_len_100) RAdmin v2.x MD5 284dynamic_1011 md5($p.md5($s)) (webEdition CMS) 285dynamic_1012 md5($p.md5($s)) (webEdition CMS) (much faster) 286dynamic_1013 md5($p.PMD5(username)) (webEdition CMS) (fast speed, but user name is stored in md5 hash format) 287dynamic_1014 md5($p.$s) (long salt) 288dynamic_1015 md5(md5($p.$u).$s) 289dynamic_1018 md5(sha1(sha1($pass))) 290dynamic_1019 md5(sha1(sha1(md5($pass)))) 291dynamic_1020 md5(sha1(md5($pass))) 292dynamic_1021 md5(sha1(md5(sha1($pass)))) 293dynamic_1022 md5(sha1(md5(sha1(md5($pass))))) 294dynamic_1023 sha1($pass) (hash truncated to length 32) 295dynamic_1024 sha1(md5($pass)) (hash truncated to length 32) 296dynamic_1025 sha1(md5(md5($pass))) (hash truncated to length 32) 297dynamic_1026 sha1(sha1($pass))) (hash truncated to length 32) 298dynamic_1027 sha1(sha1(sha1($pass)))) (hash truncated to length 32) 299dynamic_1028 sha1(sha1_raw($pass)) (hash truncated to length 32) 300dynamic_1029 sha256($pass) (hash truncated to length 32) 301dynamic_1030 Whirlpool($pass) (hash truncated to length 32) 302dynamic_1031 GOST($pass) (hash truncated to length 32) 303dynamic_1300 md5(md5_raw($pass)) 304dynamic_1350 md5(md5($s.$p):$s) 305 306 307NOTE the documentation section of dynamic.conf is listed here. It shows 308how to setup dynamiceric functions (above 1000). All of the primitives 309are defined, the data structures are defined, the expression, flags, 310saltlen, etc. Following the 'howto use' section, are some working 311examples (this whole list is also found in dynamic.conf). 312 313#################################################################### 314#################################################################### 315# here are some examples of DYNAMIC formats 316#################################################################### 317#################################################################### 318 319#################################################################### 320# Documenation of how to 'setup' DYNAMIC formats 321#################################################################### 322# 323# Variables / workspaces: 324# 325# keys[] - Array Used to stored keys (optionally used, we 'may' be able to use input field 1 array) 326# input1[] - Array used for encryption, key appending, salt appending, etc happens to/from these 327# NOTE if DynamicFunc__InitialLoadKeysToInput then this is used to store the keys 328# and MUST NOT be damaged, since any later key retrieval will come from this buffer. 329# This is done as an optimization. Thus input2 is required for additional scratch buffer work. 330# output1[] - Array encryption happens and output is put here. 331# NOTE final result MUST be put here. This is what the 'hash' array is checked against. 332# salt - the salt is put here 333# salt2 - 2nd salt ($$2) 334# input2[] - Array same as input 1, but a totally different array 335# output2[] - Array same as output 2, but totally different array (can not be used as 'final' result) 336# userid - User name (fld1). Can be done normal, upper or lower case 337# fld0 to fld9 - data from fld1 to fld9 of the input file. 338# 339# NOTE within the scratch work spaces (input1[] and input2[] arrays), we can only do things like append_keys 340# append_salt or other things. Thus, each work space keeps track of each array element (knowing its contents), 341# and keeps track of the length. In the way the scripting works, we can clear them (sets lengths of all 342# elements to 0, and 'might' clear out the actual memory). We can append to them (keys, output conversions, 343# salt, etc) or we can force set their length to 32 ('special' optimization used in conjunction with 344# DynamicFunc__InitialLoadKeys_md5crypt_ToOutput2_Base16_to_Input1). 345# 346# NOTE there is NO length validation done, other than input keys are reduced to the max allowable length. 347# Thus, if building, and you attempt something like: clear_keys append_keys append_keys append_keys append_keys 348# append_keys append_keys and the keys are too long, then they will overflow. The maximal sizes of the 349# input arrays are 95 bytes for x86 and 54 bytes for SSE/MMX. Above this will simply give invalid results 350# (garbage in, garbage out). 351# 352##################################################################################### 353# 354# Flags= values. These flags are 'special' loader flags. They are optional. If used, 355# then only ONE of them can be used. 356# 357################# 358# 359# Special input flags (all flags listed later). They have certain 'side-effects', and some have special 360# rules that MUST be maintained within the script, and thus may not be usable for all scripts. 361# These are here mostly for optimization. They do NOT have to be used. If not used, then when 362# john adds keys one at a time, they are placed into the array of keys. Then, when loading keys 363# the keys are copied from the keys array, into the input1 (2) as needed. 364# 365# MGF_KEYS_INPUT 366# It will not use the keys[] array, but put the keys right 367# into the input1[] array. This buffer must not be destroyed. john will NOT use the keys[] 368# array, and later retrieval of the key will happen from here (if there are any hashes broken). 369# For this to be able to be used. 370# $pass must be at the START of the expression. expressions like md5($s.$p) would not work, since 371# $pass is not the 'start' of the expression. 372# the $pass expression 'may' have to be all by itself. Thus md5($p.$s) would not work (such as joomla) 373# but md5(md5($p).$s) can be made to work. 374# The input1[] array must NOT be touched (after it is loaded). Thus the below set of functions can NOT 375# be used in the script. 376# DynamicFunc__append_keys 377# DynamicFunc__append_keys2 378# DynamicFunc__clean_input 379# DynamicFunc__append_salt 380# DynamicFunc__append_from_last_output2_to_input1_as_base16 381# DynamicFunc__overwrite_from_last_output2_to_input1_as_base16_no_size_fix 382# DynamicFunc__append_from_last_output_as_base16 383# DynamicFunc__overwrite_from_last_output_as_base16_no_size_fix 384# DynamicFunc__append_2nd_salt DynamicFunc__append_userid 385# DynamicFunc__append_2nd_salt 386# DynamicFunc__set_input_len_32 387# DynamicFunc__set_input_len_64 388# DynamicFunc__overwrite_salt_to_input1_no_size_fix 389# DynamicFunc__append_input_from_input2 390# and the flag MGF_KEYS_UNICODE_B4_CRYPT 391# 392# MGF_KEYS_CRYPT_IN2 393# This will load keys into the keys[] array. It will then perform a md5() and put the ouput 394# into output2. This was done a signficant enhancement for forms like md5(md5($p).$s) so that we 395# load ALL of the inner md5($p) only once, then re-used them over and over again for each new salt. 396# 397# MGF_KEYS_BASE16_IN1 398# This is like the above flag, but it takes the extra step of storing the base16 conversion 399# of the md5 into input1[] array. Due to this function, we have md5(md5($p).$s) actually working 400# FASTER than simple md5($p) (if there are many salts). This is a significant optimization if it can 401# be used properly. 402# MGF_KEYS_BASE16_X86_IN1 403# same as MGF_KEYS_BASE16_IN1, however, if running in SSE mode, the loader will switch to X86 mode, 404# prior to outputting the base-16 back to input1. NOTE, the initial crypt IS done in SSE mode. 405# 406# MGF_KEYS_BASE16_IN1_Offset32 407# This flag is a not valid for SSE2 (will build a 64 byte password, and 54 bytes is max SSE2 size) 408# Psudo function that does the same work as DynamicFunc__InitialLoadKeys_md5crypt_ToOutput2_Base16_to_Input1 409# however, it loaded the hext to offset 32 (instead of the 'start' of the buffer). When done, the 410# input1[] buffers will have 64 byte passwords. The first 32 bytes are null, and the last 411# 32 bytes are the hex values. This function is for md5(md5($s).md5($p)) (but certainly could 412# be used for other formats. 413# MGF_KEYS_BASE16_X86_IN1_Offset32 414# Same as MGF_KEYS_BASE16_IN1_Offset32, but the output is in x86. NOTE, if running in SSE mode, then 415# both MGF_KEYS_BASE16_IN1_Offset32 and MGF_KEYS_BASE16_X86_IN1_Offset32 perform exactly the same. Neither 416# one of them 'work' in SSE mode, since we will end up with a 64 byte input string (not SSE valid). 417# 418# MGF_KEYS_UNICODE_B4_CRYPT 419# Switch into 'unicode' converstion mode, prior to doing the 'early' MGF_KEYS* flags. The flags which 420# can be used with this are: MGF_KEYS_CRYPT_IN2, MGF_KEYS_BASE16_IN1, MGF_KEYS_BASE16_X86_IN1, 421# MGF_KEYS_BASE16_IN1_Offset32 (and the x86 versions). Note, that MGF_KEYS_INPUT can NOT be used 422# with this flag. 423# 424# MGF_PHPassSetup 425# Special flag used to link the salt, set_salt and set_hash members of the format object to the 'special' 426# functions for phpass encryption. 427# 428# MGF_POSetup 429# Special flag used for the special "Post Office" Crypt function. 430# 431# Depricated 'pseudo' functions (must be first function). These functions still work, but have been depricated. 432# dynamic simply 'transforms' them into the current flag, at script loading time. It is best to NOT use 433# these functions in any new scripts, and to remove any usage of them. Since these are depricated, they have 434# KEPT the already depricated MD5GenBaseFunc__ 'signatures', and have not been 'updated' to the new 'dynamic' 435# format signature. These SHOULD NOT be used. 436# MD5GenBaseFunc__PHPassSetup == MGF_PHPassSetup 437# MD5GenBaseFunc__InitialLoadKeysToInput == MGF_KEYS_INPUT 438# MD5GenBaseFunc__InitialLoadKeys_md5crypt_ToOutput2 == MGF_KEYS_CRYPT_IN2 439# MD5GenBaseFunc__InitialLoadKeys_md5crypt_ToOutput2_Base16_to_Input1 == MGF_KEYS_BASE16_IN1 440# MD5GenBaseFunc__InitialLoadKeys_md5crypt_ToOutput2_Base16_to_Input1_offset32 == MGF_KEYS_BASE16_IN1_Offset32 441# 442#################################################################### 443# 444# Flag= line(s) Optional, but required IF the format needs them. 445# Multiple flags ARE allowed. 446# 447################# 448# 449# Flags are just that, switches that tell the dynamic parser that 450# certain things need to be handled. One common used flag is MGF_SALTED 451# If the format is a salted hash, then this flag must be present. 452# Here is the list of flags, and what they mean, and when you should 453# use them 454# 455# Flag=MGF_SALTED 456# Use this for any salted format 457# 458# Flag=MGF_SALTED2 459# If there are 2 salts in the format, use this flag. NOTE 2 salts 460# is defined, but has not be implemented yet in john. 461# 462# Flag=MGF_ColonNOTValid 463# If there is some reason why the : char should not be used by john 464# (such as the : is a valid character in the salt. If this is 465# set, then the character to be used should be put into the Test= 466# lines, AND the user should use that on the command line 467# 468# Flag=MGF_NOTSSE2Safe 469# The max encryption the SSE2 code can handle is 54 bytes. The max 470# size encryption for the 'generic' is 125 bytes. So, if it is 471# OBVIOUS that sse2 can not be used, due to encryption lengths, 472# then set this flag. An example is md5(md5($p).md5($s)) In this 473# case, will be 3 md5's. 2 of them will be over the salt, and 474# one over the password. Thus, if the password and salt are each 475# under 54 bytes, then sse2 could be used. HOWEVER, the 3rd md5 476# (the final one), is done against the concatenation of 2 32 byte 477# strings (the md5 results of the first 2 encryptions). THUS we 478# KNOW this is a 64 byte string. That will not work in the current 479# SSE2 (or mmx) code, and thus, the SSE2/MMX builds can NOT be used 480# to test that format. 481# 482# Flag=MGF_FLAT_BUFFERS 483# This is similar to MGF_NOTSSE2Safe in 'some' ways. It will cause 484# dynamic to only use the flat buffers. However, it is used for 485# large formats which HAVE SSE2 code. These formats will use the 486# the data from the flat buffers directly (even nulling them out 487# and placing the # of bits into the right locations, and the 0x80 488# trailing byte also). So this tells dyna to store the data and 489# intermediate flat, but use the special SSE2 code for this format 490# that loads from flat. Currently, all formats which has SIMD code 491# have flat buffer behavior. NOTE most (all except md5/md4 and some 492# for sha1), ONLY have the flat buffer code. These other 3 formats 493# do have custom 'mixed' coding. 494# One really nice thing about doing SIMD this way is the single limb 495# limit has been removed. The SIMD code is currently in MD4/5, SHA1, 496# and 32 bit SHA2 (SHA224/SHA256). The SIMD code has not been done 497# for the flat SHA384/SHA512 code yet. 498# 499# Flag=MGF_INPBASE64 500# If the hashes are in base-64 (such as phpass), then use this 501# flag. Note, the base 64 'format' used is that of phpass. If there 502# are other orderings, then this will not work. I know of no formats 503# in use, other than phpass (phpbb, wordpress, etc) which use base-64 504# for md5. This is actually the same format as CryptBS in base64conv 505# utility. This has been improved now. It should work for any standard 506# length hash (from 16 bytes up to 64 bytes). The only part of the 507# hash that is base-64 decoded is within the binary hash value itself. 508# dynamic does not handle base-64 decoding within any part of the salt. 509# 510# Flag=MGF_INPBASE64b 511# This is like the MGF_INPBASE64 flag, BUT the encoding is in BE format 512# crypt. This is the same as Crypt encoding in base64conv utility 513# 514# Flag=MGF_INPBASE64m 515# This is like the MGF_INPBASE64 flag, BUT the encoding is in MIME. 516# This is the same as MIME encoding in base64conv utility. NOTE, the 517# hash can end with optional '=' place holding characters. These will 518# be stripped off, in the prepare/split functions, to canonicalize the 519# value of the hash to be NON-equal padded. But an input file can have 520# the '=' padding or not (or even mixed) and still process properly. 521# 522# Flag=MGF_INPBASE64_4x6 523# If this flag is set, then the input will be base-64, where 4 bytes are 524# loaded 6 bits at a time (i.e. 16 bytes of hash). Used in Cisco PIX-MD5 525# Thus, only the lowest 24 bits of each part of the MD5 hash are used. 526# This has to happen on the binary loader and comparison functions. 527# 528# Flag=MGF_USERNAME 529# If there is a Username used in the format, use this flag. 530# 531# Flag=MGF_USERNAME_UPCASE User name, but it is forced to uppercase 532# Flag=MGF_USERNAME_LOCASE User name, but it is forced to lowercase 533# 534# Flag=MGF_SALT_AS_HEX 535# This flag is for formats such as md5(md5($p).md5($s)) What this 536# does, is to return the md5($s) to john as the salt, and not simply 537# return the 'original' salt. Thus, we run md5's for the salt at 538# initialization, and never MD5 them again. DO NOT use this for a 539# format like md5($s.md5($p).md5($s)) In that format, you NEED 540# the salt (along with the md5 of that salt). This flag can not 541# be used in that instance. 542# 543# Flag=MGF_SALT_AS_HEX_TO_SALT2 544# This is 'similar' to MGF_SALT_AS_HEX. It will perform the 545# base16 crypt of the salt. However, it stores both the original 546# salt, and creates a 'salt2' which is the base16 This is so a 547# format like, md5($p.$s.md5($s)) could have both the salt 548# and still have the base-16 of the salt. So in this case 549# using append_salt would append the original salt, and 550# append_2nd_salt would append the base-16 hash of the salt. 551# 552# Flag=MGF_StartInX86Mode 553# This flag will case the format to 'start' in X86 mode, so that 554# any initial key loading will also be done to the X86 buffers. 555# 556# Flag=MGF_SALT_UNICODE_B4_CRYPT 557# This flag will case the format to 'start' in Unicode conversion 558# mode, so that any initial key loading will also be done to the 559# using unicode conversions. 560# 561# Flag=MGF_BASE_16_OUTPUT_UPCASE 562# This flag will case the format to 'start' in uppercase base-16 563# conversion mode, so that any initial key loading will also be 564# done to the using unicode conversions. 565# 566# MGF_FLD0, MGF_FLD1, MGF_FLD2, ... ,MGF_FLD9 567# If any of the fields of the file are part of the format (and 568# used within the script), then they either must be part of 569# the hash value, or the field must be present on the line. 570# If a field IS used, then you also MUST have the proper 571# flag set, or the prepare function will NOT load it. 572# 573# MGF_INPUT_20_BYTE 574# Tell $dynamic$ that the 'final' crypt is an SHA1 (still experimental 575# code, so 'caveat emptor' ). What this will do, is cause john to only load 576# hashes that are 20 binary bytes of input (40 hex digits md5 is 32 hex 577# digits). NOTE, when the 'final' crypt is done (in SHA1), it will only 578# have the first 16 bytes compared against (vs the full 20 bytes which 579# sha1 generates). This 'should' be more than adequate to know 580# you have cracked the hash. 581# MGF_INPUT_24_BYTE 582# MGF_INPUT_28_BYTE 583# MGF_INPUT_32_BYTE 584# MGF_INPUT_40_BYTE 585# MGF_INPUT_48_BYTE 586# MGF_INPUT_64_BYTE 587# These are similar to the 20 byte flag for the SHA1. NOTE, this 588# means that dynamic will only look for valid input strings which 589# are the appropriate length, based upon that final hash size. 590# One off these flags MUST be used, on a format that is longer than 591# the 16 byte MD5 (or md4) hash. 592# 593# MGF_INPBASE64a 594# The binary input hash data format of the FreeBSD_MD5 and Apache_MD5. 595# 596# MGF_UTF8 597# This format 'allows' the --encoding=utf-8 switch, and will perform 598# full UTF conversions, if the DynamicFunc__setmode_unicode() 599# function has been issued (or one of the user name or preload 600# password unicode flags were used). 601# 602# 603######################################################## 604# 605# Function primitives, and what they do (REQUIRED in each format section) 606# 607################# 608# DynamicFunc__clean_input 609# Sets lengths of all input1[] array to ZERO, and sets the memory null (memory only set in SSE2, since it does 610# not matter in x86 builds) 611# 612# DynamicFunc__clean_input2 613# Same as DynamicFunc__clean_input but this one works on input2[] array. 614# 615# DynamicFunc__clean_input_kwik 616# Sets lengths of all input1[] array to ZERO. Memory not cleared. Optimization that can be used when you KNOW 617# that the length of any of the input1 strings will never be less than they once were. So if you load keys, 618# crypt, clean_input, then repeatedly append_base16 to input and crypt, then during that repeated set of work 619# you can call clean_kwik since ALL things being crypted, would be 32 bytes, and the single 'deep' clean would 620# get the buffers read to go, and they would not need fully cleaning again. 621# 622# DynamicFunc__clean_input2_kwik 623# Same as DynamicFunc__clean_input_kwik but this one works on input2[] array. 624# 625# DynamicFunc__clean_input_full 626# This makes sure that the entire keys are set with NULL's prior to running. This is a full 'deep' clean. 627# In x86 builds, it will fully null out the entire input buffer. In SSE mode, it nulls out both the 628# x86 and SSE input buffers (fully). 629# 630# DynamicFunc__clean_input2_full 631# Same as DynamicFunc__clean_input_kwik but this one works on input2[] array. 632# 633# DynamicFunc__append_keys 634# append the array of keys to the array input1[] 635# 636# DynamicFunc__append_keys_pad16 637# append the array of keys to the array input1[], padding with nulls to 16 bytes, if input shorter. 638# Needed for net-md5 and net-sha1 formats. 639# 640# DynamicFunc__append_keys2 641# append the array of keys to the array input2[] 642# 643# DynamicFunc__append_salt 644# Appends the salt to each element of input1[], and adjusts the length of each element. 645# NOTE, the MGF_SALT flag must be used in the format. 646# 647# DynamicFunc__append_salt2 648# Appends the salt to each element of input2[], and adjusts the length of each element. 649# 650# DynamicFunc__append_2nd_salt 651# append the salt2 (second salt value) to the array input1[] 652# NOTE, the MGF_SALT2 flag must be used in the format. 653# 654# DynamicFunc__append_2nd_salt2 655# append the salt2 to the array input2[] 656# 657# DynamicFunc__append_userid 658# DynamicFunc__append_userid2 659# appends the username into either input1 or input2 fields. 660# 661# DynamicFunc__crypt_md5 662# performs a md5 on all elements of input1[] and places the results into output1[] The output will be the 663# 16 byte BINARY blob of the 'raw' md5. 664# 665# DynamicFunc__crypt_md4 666# same as DynamicFunc__crypt_md5, but uses the MD4 hash instead of md5. 667# 668# DynamicFunc__crypt2_md5 669# Same as DynamicFunc__crypt_md5 but this one works on input2[] -> output2[] arrays. 670# 671# DynamicFunc__crypt2_md4 672# Same as DynamicFunc__crypt2_md4 but uses the MD4 hash instead of md5. 673# 674# DynamicFunc__crypt_md5_in1_to_out2 675# Takes the data from input1, performs the MD5 crypts, and stores this data into Output2 676# 677# DynamicFunc__crypt_md4_in1_to_out2 678# Takes the data from input1, performs the MD4 crypts, and stores this data into Output2 679# 680# DynamicFunc__crypt_md5_in2_to_out1 681# Takes the data from input2, performs the MD5 crypts, and stores this data into Output1 682# 683# DynamicFunc__crypt_md4_in2_to_out1 684# Takes the data from input2, performs the MD4 crypts, and stores this data into Output1 685# 686# DynamicFunc__append_from_last_output_as_base16 687# Takes the 16 byte binary values from each output1[] array, and does a base-16 conversion, appending the 688# results to the same 'index' of the input1[] array. ALL of the lengths of the array1[] elements will be 689# 32 bytes more than they were (the base-16 of each 16 byte binary value is 32 bytes long). 690# 691# DynamicFunc__append_from_last_output2_as_base16 692# Same as DynamicFunc__append_from_last_output_as_base16 but this one works on output2[] -> input2[] arrays. 693# 694# DynamicFunc__append_from_last_output_to_input2_as_base16 695# output1[] append -> input2[] arrays. (note, output #1 appending to input #2, base-16) 696# 697# DynamicFunc__append_from_last_output2_to_input1_as_base16 698# output2[] append -> input1[] arrays. (note, output #2 appending to input #1, base-16) 699# 700# DynamicFunc__append_input_from_input2 701# Appends input2 to input input += input2. Note, the inputX -> inputY copying in SSE2 is slower than 702# doing output -> input. 703# 704# DynamicFunc__append_input2_from_input 705# Appends input1 to input2 input2 += input 706# 707# DynamicFunc__append_input_from_input 708# Appends input1 to input1 input1 += input2 709# 710# DynamicFunc__append_input2_from_input2 711# Appends input2 to input2 input2 += input2 712# 713# DynamicFunc__append_from_last_output2_as_raw 714# Appends the 'raw' output data from output2 to input1. Length of input1 grows by 16 bytes. 715# 716# DynamicFunc__overwrite_from_last_output_as_base16_no_size_fix 717# NOT IMPLEMENTED: 718# Takes the 16 byte binary values from the output1[] array, and overwrites from byte 0 to byte 31 of each 719# element of the input1[] array. This is used as an optimizations for formats such as: md5(md5($s).$p) 720# in this format, we can place the keys into input1[] at 32 bytes past the start of the buffer, and set 721# the lengths to be the length of each key + 32, and then simply call this function for each salt, to 722# drop the 32 bytes of md5 data to the start of the strings, without touching the passwords that were 723# already stored, or the lengths of the strings. 724# 725# DynamicFunc__overwrite_from_last_output2_as_base16_no_size_fix 726# NOT IMPLEMENTED: 727# Same as DynamicFunc__overwrite_from_last_output_as_base16_no_size_fix but this one works on output2[] -> input2[] arrays. 728# 729# DynamicFunc__overwrite_from_last_output_to_input2_as_base16_no_size_fix 730# NOT IMPLEMENTED: 731# output1[] overwrite start of input2[] arrays. (note, output #1 going to start of input #2, base-16, no size 'fix') 732# like DynamicFunc__overwrite_from_last_output_as_base16_no_size_fix but different input output vars. 733# 734# DynamicFunc__overwrite_from_last_output2_to_input1_as_base16_no_size_fix 735# NOT IMPLEMENTED: 736# output2[] overwrite start of input1[] arrays. (note, output #2 going to start of input #1, base-16, no size 'fix') 737# like DynamicFunc__overwrite_from_last_output_as_base16_no_size_fix but different input output vars. 738# 739# DynamicFunc__overwrite_salt_to_input1_no_size_fix 740# Inserts the salt to the start of the first input buffer. DOES NOT append null bytes, nor does it 741# adjust the length of the strings. Used if the 'top' part of input buffer 1 stays constant, and 742# the salt gets inserted to the start of input buffer (but lengths never change). 743# 744# DynamicFunc__overwrite_salt_to_input2_no_size_fix 745# Same as DynamicFunc__overwrite_salt_to_input1_no_size_fix but this one works on salt -> input2[] arrays. 746# 747# DynamicFunc__append2_from_last_output2_as_raw 748# NOT IMPLEMENTED 749# DynamicFunc__append_from_last_output1_as_raw 750# NOT IMPLEMENTED 751# DynamicFunc__append2_from_last_output1_as_raw 752# NOT IMPLEMENTED 753# 754# DynamicFunc__set_input_len_16 755# Sets the length of each element of input1[] to 16. In SSE2 mode, if the length of the input buffer 756# was less than 16, then that 0x80 end of marker is removed, and a new one is 'added' at offset 16. 757# 758# DynamicFunc__set_input_len_20 759# Sets the length of each element of input1[] to 20. In SSE2 mode, if the length of the input buffer 760# was less than 20, then that 0x80 end of marker is removed, and a new one is 'added' at offset 20. 761# 762# DynamicFunc__set_input2_len_16 763# Sets the length of each element of input2[] to 16. 764# 765# DynamicFunc__set_input2_len_20 766# Sets the length of each element of input2[] to 20. 767# 768# DynamicFunc__set_input_len_32 769# Sets the length of each element of input1[] to 32. This was designed as is used in conjunction with 770# the funtion overwrite_from_last_output_as_base16_no_size_fix in mind, but would not 771# be the 'only' reason to use it (but is the only reason I have at this time). This function does NOT 772# clean the input[] items prior to this. Usually a call to clean_input would be required prior to 773# calling this function, to make sure the buffer is 'clean'. A 0x80 is placed into offset 32 774# 775# DynamicFunc__set_input2_len_32 776# Same as DynamicFunc__set_input_len_32 but this one works on input2[] array. 777# 778# DynamicFunc__set_input_len_40 779# Sets the length of each element of input1[] to 30. A 0x80 is placed into offset 40. This would be 780# the companion function to DynamicFunc__set_input_len_32, but useful for SHA1 hashes which would 781# themselves output 40 bytes of hex. 782# 783# DynamicFunc__set_input2_len_40 784# Same as DynamicFunc__set_input_len_40 but this one works on input2[] array. 785# 786# DynamicFunc__set_input_len_64 787# Like the above function, but sets lengths to 64 bytes. NOTE valid to use in SSE2 mode. 788# 789# DynamicFunc__set_input2_len_64 790# Same as DynamicFunc__set_input2_len_64 but this one works on input2[] array. 791# 792# DynamicFunc__set_input_len_100 793# Like the above function, but sets lengths to 100 bytes. NOTE valid to use in SSE2 mode. 794# This is a 'specialized' function for the RAdmin hash, and simply nulls out the buffer 795# up to 100 bytes. 796# 797# SSE 'switching' functions. SSE is only valid for 54 byte or less input strings. 798# This is due to optimizations which place a 'single' md5 limb restriction on the 799# crypts. Thus, for some formats, we have to be in x86 mode only, but for others, 800# we can jump in and out of SSE mode. However, to do this, we likely will have 801# to convert a buffer (or more). The input buffers, and output buffers are NOT 802# compatible between x86 and SSE2. If possible, convert the output buffers, they 803# are smaller, and faster (usually). 804# 805# NOTE, proper usage of these functions CAN improve performance of some SHA1 processing 806# putting the data into or out of 'flat' model. The SHA1 hash does have SSE code, however 807# since it also requires BE layout for the data (vs LE for md5), a design choice was made 808# to not store the BE sse buffers long term. All crypting will determin IF sse sha1 code 809# should be used, and if so, the crypt function will convert from flat into sse format. 810# however, if the data already is in sse format, it has to be transformed into a format 811# valid for ShA1. Look at formats 1022 to 1031 for insite on how to best use these 812# data conversion functions with SHA1. 813# 814# DynamicFunc__SSEtoX86_switch_input1 815# Copies the SSE Input1 buffer to x86 Input1. Changes 'mode' to non-SSE for any 816# functions that are done after this call. 817# DynamicFunc__SSEtoX86_switch_input2 818# Copies the SSE Input2 buffer to x86 Input2. and changes to non-SSE mode. 819# DynamicFunc__SSEtoX86_switch_output1 820# Copies the SSE Output1 buffer to x86 Output1. and changes to non-SSE mode. 821# DynamicFunc__SSEtoX86_switch_output2 822# Copies the SSE Output2 buffer to x86 Output2. and changes to non-SSE mode. 823# 824# DynamicFunc__X86toSSE_switch_input1 825# Copies the x86 Input1 buffer to SSE Input1. Changes 'mode' to SSE for any 826# functions that are done after this call. 827# DynamicFunc__X86toSSE_switch_input2 828# Copies the x86 Input2 buffer to SSE Input2. and changes to SSE mode. 829# DynamicFunc__X86toSSE_switch_output1 830# Copies the x86 Output1 buffer to SSE Output1. and changes to SSE mode. 831# DynamicFunc__X86toSSE_switch_output2 832# Copies the x86 Output2 buffer to SSE Output2. and changes to SSE mode. 833# 834# DynamicFunc__ToSSE 835# Simply switches mode to SSE. No data buffers copied. Usually, used as first 836# or last command in a script 837# DynamicFunc__ToX86 838# Simply switches mode to x86. No data buffers copied. Usually, used as first 839# or last command in a script 840# 841# 842# Unicode mode. This allows $dynamic$ to do unicode coversion when doing string 843# append (overwrite) operations. Thus, a format such as md5(unicode($p).$s) can 844# be generated. 845# 846# DynamicFunc__setmode_unicode 847# All string ops do Unicode conversions. These are DynamicFunc__append_keys, 848# append_keys2, append_salt, append_salt2, overwrite_salt_to_input1_no_size_fix, 849# overwrite_salt_to_input2_no_size_fix, append_2nd_salt, append_2nd_salt2, 850# append_userid, append_userid2, append_input1_from_CONST1 (and ALL other const 851# append functions) If --encoding=utf-8 switch is set, then a utf-8 to unicode 852# conversion is done. If that switch was not used on the command line, then a 853# simple ascii to unicode (which is simply appending a null byte after each byte 854# of string). The --encoding=utf-8 conversion is considerably slower, but is required 855# for many Unicode or UTF-8 systems. NOTE, to honor the --encoding=utf-8 switch, the 856# format MUST use the MGF_UTF8 flag. 857# 858# DynamicFunc__setmode_normal 859# This is the 'normal' run for john. Back to ascii (or utf-8, if --encoding=utf-8 860# command line switch was used). But there will be NO Unicode conversions done. 861# 862# 863# Upper/Lowercase of md5 - base16 conversions. Normally, this is done to lower 864# case. However, there may be systems which do md5 to base 16 in upper case. 865# thus, if a hash is md5(upper(md5($p)) this is different than md5(md5($p)) 866# These functions turn on or off the upper/lower case conversions. 867# 868# DynamicFunc__base16_convert_locase 869# This is the 'normal' lowercase. Thus, md5(md5($p)) is assumed to have the 870# base-16 done in lower case. 871# 872# DynamicFunc__base16_convert_upcase 873# Perform base-16 converts in upper case base-16. 874# 875# DynamicFunc__append_input1_from_CONST1 876# This will append the first constant value to the input1[] array 877# DynamicFunc__append_input1_from_CONST2 878# DynamicFunc__append_input1_from_CONST3 879# DynamicFunc__append_input1_from_CONST4 880# DynamicFunc__append_input1_from_CONST5 881# DynamicFunc__append_input1_from_CONST6 882# DynamicFunc__append_input1_from_CONST7 883# DynamicFunc__append_input1_from_CONST8 884# Same as DynamicFunc__append_input1_from_CONST1 but they load the other constant 885# values into input1. 886# 887# DynamicFunc__append_input2_from_CONST1 888# This loads the first constant value into the input2[] array 889# DynamicFunc__append_input2_from_CONST2 890# DynamicFunc__append_input2_from_CONST3 891# DynamicFunc__append_input2_from_CONST4 892# DynamicFunc__append_input2_from_CONST5 893# DynamicFunc__append_input2_from_CONST6 894# DynamicFunc__append_input2_from_CONST7 895# DynamicFunc__append_input2_from_CONST8 896# Same as DynamicFunc__append_input2_from_CONST1 but they load the other constant 897# values into input2. 898# 899# DynamicFunc__append_fld0 900# This will append the data from $$F0 (field 0 of the line, or 'username', to input 1. 901# DynamicFunc__append_fld1 902# DynamicFunc__append_fld2 903# .... 904# DynamicFunc__append_fld9 905# Will append data from the other fields (from 1 to 9). NOTE, 1 is the 'hash' line, and 906# almost certainly should NOT be used. 907# 908# DynamicFunc__append2_fld0 -- to -- DynamicFunc__append2_fld9 909# Loads data from $$F0 to $$F9 (field 0 to field 9) into input buffer 2. 910# 911# DynamicFunc__SHA1_crypt_input1_append_input2_base16 ** 912# DynamicFunc__SHA1_crypt_input2_append_input1_base16 ** 913# DynamicFunc__SHA1_crypt_input1_overwrite_input1_base16 ** 914# DynamicFunc__SHA1_crypt_input2_overwrite_input2_base16 ** 915# DynamicFunc__SHA1_crypt_input1_overwrite_input2_base16 ** 916# DynamicFunc__SHA1_crypt_input2_overwrite_input1_base16 ** 917# DynamicFunc__SHA1_crypt_input1_to_output1_FINAL 918# DynamicFunc__SHA1_crypt_input2_to_output1_FINAL 919# Currently 'experimental' addition of SHA1 into the md5() syntax. Still much work to 920# do. Not for general use (yet). Hopefully, will be able to get things like 921# md5(sha1(md5($p))) working (sort of works now, but again, still experimental). 922# The 2 '_FINAL' functions should ONLY be used as the last call. This allows 923# for support of sha1(sha1(m5($p).$s)) type hashes. NOTE, if you use on of the 924# *_FINAL calls, then you have to use the MGF_INPUT_20_BYTE flag, and notes 925# that only the first 16 bytes of the final hash are evaluated. Also, only 40 bytes 926# long hex string hashes will be loaded (base-64? needed?). 927# At this time, ALL sha1 is done in non-SSE code (x86, OpenSSL). Also note, that 928# ALL output from the SHA1 functions is directly appended or overwritten, right into 929# an input buffer. 930# 931# ** NOTE, these functions are depricated. They should not be used any more. 932# The proper usage would be to set the output format (no setting is needed 933# IF base-16 is wanted, as that will be default), and then to call the same 934# named function primate, but that function name is minus the _base16 part. 935# so DynamicFunc__SHA1_crypt_input1_append_input2 would be the proper function, 936# instead of the depricated DynamicFunc__SHA1_crypt_input1_append_input2_base16 937# 938#################### 939# 940# OTHER large hash functions (SHA2 hashes, GOST, WHIRLPOOL, Tiger, RIPEMD(128/160/256/512) currently) 941# 942#################### 943# 944# These other large hash types, have been built like the SHA1 (listed above). They will have 945# the same 8 function primitives, and be named exactly the same as the SHA1, except they 946# will have the crypt in the function name. The current hashes supported are: 947# SHA224, SHA256, SHA384, SHA512, GOST, WHIRLPOOL. 948# NOTE Whirlpool is ONLY supported in new versions of OpenSSL, so if the version of oSSL 949# is not new enough, the whirlpool part of dynamic will NOT be compiled into JtR. 950# 951# Here is an example. Listed will be the functions for SHA256. NOTE all of the other types 952# will be exactly the same, just using different crypt values in the function names. 953# 954# DynamicFunc__SHA256_crypt_input1_append_input2 955# DynamicFunc__SHA256_crypt_input2_append_input1 956# DynamicFunc__SHA256_crypt_input1_overwrite_input1 957# DynamicFunc__SHA256_crypt_input2_overwrite_input2 958# DynamicFunc__SHA256_crypt_input1_overwrite_input2 959# DynamicFunc__SHA256_crypt_input2_overwrite_input1 960# DynamicFunc__SHA256_crypt_input1_to_output1_FINAL 961# DynamicFunc__SHA256_crypt_input2_to_output1_FINAL 962# 963# All of these 'large' hash functions, when used MUST end with either an MD5 or MD4 into 964# output1, OR by using one of the *_to_output1_FINAL calls. The ONLY call actaully 965# has to be one of the *_to_output1_FINAL calls (if the format is a simple single 966# hash, such as SHA512($s.$p.$u) In this case, we would simply load one of the input 967# variables with the salt, the password, and the userid, and then call a single 968# DynamicFunc__SHA256_crypt_input1_to_output1_FINAL to perform the crypt. 969# 970#################### 971# Controlling the output of 'large' crypts. 972#################### 973# 974# All of the 'large' crypts, have simple function primitives. These will perform the 975# crypt, and then write output to one of the 2 buffers. The output can be appeneded, 976# or overwritten. The format this output is done in CAN be controlled. The output 977# formats are: base-16 (0-9 and a-f), base-16 upcase (0-9 and A-F), base-64 (MIME) 978# base-64 with no 'trailing' '=' characters (the '=' is normally inserted for strings 979# that are not evenly divisible by 3). Also, 'RAW' hash value can be output. 980# 981# These are the 'helper' functions that affect large hash output. Every call to crypt_all 982# will set base-16 to be the default output format. These helper functions change this, 983# and once an output format it set, it 'stays' in that format, until set by another 984# helper, or at the next call to crypt_all (i.e. the format starts over again) 985# 986# DynamicFunc__LargeHash_OUTMode_base16 987# DynamicFunc__LargeHash_OUTMode_base16u 988# DynamicFunc__LargeHash_OUTMode_base64 989# DynamicFunc__LargeHash_OUTMode_base64_nte 990# DynamicFunc__LargeHash_OUTMode_raw 991# 992#################### 993# These are special functions written SPECIFCALLY for usage by phpass code, in builtin 994# function dynamic_17. These are likely NOT useful. However, they 'are' open to be used. 995#################### 996# 997# DynamicFunc__crypt_md5_to_input_raw 998# Used as 'first' step of phpass crypt. it will put 16 binary bytes of md5 encryption 999# into array1[]. It will write this to the beginning of the arrays (does not append), and 1000# when done, sets ALL lengths of array1[] to 16. Once this function is called, the keys 1001# are appended (see spec for phpass encryption), which sets the length of input1[] elements 1002# to 16 + strlen(keys). Then there is a loop that calls the next function. 1003# 1004# DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1005# This function will encrypt input1[] and drop the 16 bytes of MD5 binary right back over 1006# the first 16 bytes of input1[] The length of each input1[] item is NOT touched, thus 1007# whatever the length was before is what it is now. 1008# 1009# DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen_but_setlen_in_SSE 1010# This is the very first call. It DOES set the length up properly. From that point on, 1011# the other (1000's) of calls are done using DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1012# 1013# DynamicFunc__PHPassCrypt 1014# Special function for phpass, probably not useful in john.conf scripting 1015# 1016# DynamicFunc__POCrypt 1017# This is the 'special' crypt call for MD5-PO dynamic_18. It was done as a 'special', because 1018# there was about 20% overhead, doing the individual calls. It was much faster to hammer in 1019# values in a special crypt call. 1020# 1021#################################################################### 1022# 1023# Test= line(s) (REQUIRED in each format section) 1024# 1025# NOTE within these lines, if there are binary values which need to 1026# be inserted, then use the format of \xHH (2 hex digits which will 1027# be converted into the 1 byte). So, \xF7 will output the single 1028# byte "\xF7" which in some ASCII formats, it is the squiggly 1029# 'about' equals sign. To output some UNICODE or 'wide' type 1030# characters, you will need to know the exact bytes that are used 1031# and place a \xHH for each byte. To output the actual \ character 1032# use \\ So, to output \\ use \\\\ (2 \\ which each get replaced 1033# with a single \ character). 1034# NOTE that HH MUST be uppercased for the A to F values, and the 'x' 1035# MUST be lowercase. 1036# NOTE, you MUST use \xHH. So, to put an ASCII(1) value, you would 1037# use \x01 (not \x1 ). 1038# ALL conversions are done prior to the line being 'looked at' within 1039# the parser. 1040# 1041# There are other specialized 'Test=' lines that may need to be used 1042# in certain situations. 1043# 1044# TestU= allows placing a test case out, that will ONLY load if the encoding 1045# of utf-8 is selected from command line. 1046# 1047# TestA= allows placing a test case will will NEVER be loaded if encoding of 1048# utf-8 is selected at command line (ASCII test case). 1049# 1050# TestM= Allows placing a test case that will ONLY load if this is an MMX or 1051# SSE build. 1052# 1053# TestD= Allows placing a test case that will ONLY load, if -DDEBUG build of 1054# JtR is done (for testing). At this time, the REALLY long password hashes 1055# are being added with TestD= so that the timing of the formats will not be 1056# impacted, but so that a debugging build can be done, and the extra long 1057# test strings will still be there and be tested. 1058# 1059# TestF= Allows placing a test case that will NEVER be loaded if this was an 1060# MMX or SSE build (Only load for 'flat' builds, like oSSL only). 1061# 1062################# 1063# 1064# The testing line is simply of this format: 1065# 1066# test=$dynamic_#$hash[$salt]:password 1067# 1068# the hash listed, MUST be the hash generated for this password (and 1069# salt) for the expression. John uses this at startup to validate 1070# that the format is 'valid'. If this Test= line(s) are not right 1071# john will not work. NOTE if the format does not allow a colon 1072# in the format (such as dynamic_1007, then the exact same field 1073# separator must be used in the Test= line, as what is specified 1074# in the --field-separator-char=c used on the command line 1075# 1076#################################################################### 1077# 1078# Expression= line (Optional) 1079# 1080################# 1081# 1082# If the Expression= line is there, then the value shown there will 1083# also be used on the startup line of john. If missing, john will 1084# output dynamic_1001 (or whatever number was used), and if 1085# Expression=, then the dynamic_1001 will be followed by the 1086# expression line. 1087# 1088#################################################################### 1089# 1090# SaltLen=# line (Optional, but required IF the format needs it) 1091# 1092################# 1093# 1094# If this is a salted hash, and ALL valid salts must be a specific 1095# length (vBulletin is an example, where 3 byte salts are specified 1096# and OSCommerce is another with 2 byte hashes). If this is the 1097# case, add a SaltLen=# line and john will validate, and only test 1098# lines which have valid salts (i.e. right length salt is part of 1099# the initial validation of the line) 1100# 1101#################################################################### 1102# 1103# SaltLenX86=# line (Optional, but required IF the format needs it) 1104# 1105################# 1106# 1107# This is almost never needed. But if needed to have a different 1108# salt size on non-MMX/SSE builds, then this is how to do it. 1109# 1110#################################################################### 1111# 1112# MaxInputLen=# line (Optional, but required IF the format needs it) 1113# 1114################# 1115# 1116# If a format has a 'max' length of password (such as Cisco PIX has 1117# a max length of 16 byte PW), then this must be set. If this is 1118# not set, then the format will have a max password allowed to be 1119# 55-abs(saltlen) (80-abs(saltlen) if not an SSE/MMX build) 1120# 1121#################################################################### 1122# 1123# MaxInputLenX86=# line (Optional, but required IF the format needs it) 1124# 1125################# 1126# 1127# Similar to the SaltLenX86, in that it allows a different password 1128# length to be force set in non-SSE builds. So if a format should 1129# ONLY have 16 byte passwords, and no salt, then you would need 1130# to set MaxInputLen=16 and have a MaxInputLenX86=16 set also. 1131# 1132#################################################################### 1133# 1134# CONST#=str line (Optional, but required IF the format needs it) 1135# 1136# These lines will also use the \xHH (or \\ for a \ ) same as the 1137# 'Test=' lines. 1138# 1139################# 1140# 1141# This will allow a constant value to be 'set' and then later used 1142# in the format. So a format such as md5($p.CONSTANT.$s) can be 1143# done by setting const 1 to 'CONSTANT' (whatever that string is) 1144# and then calling DynamicFunc__append_input1_from_CONST1 at the 1145# proper time to insert it into the string. 1146# CONST1=str to CONST8=str are valid (8 constant values.) NOTE 1147# if you have 3 constants, then use CONST1, CONST2 and CONST3 (i.e. 1148# pack them into the first X number constants). 1149# 1150#################################################################### 1151 1152 1153 1154#################################################################### 1155#################################################################### 1156#################################################################### 1157# Here are some additional 'test' formats. To use these, simply 1158# cut them and place them under a new name at the bottom of 1159# dynamic.conf. 1160# These require john-1.7.7 jumbo2 + to work properly 1161#################################################################### 1162#################################################################### 1163#################################################################### 1164 1165 1166#################################################################### 1167# Simple DYNAMIC type for PostOffice-MD5 md5($s.Y.$p.\xF7.$s) 1168# Included here to 'exercise' the script parser (constants) 1169# NOTE, the internal dynamic_18 has a specialized crypt 1170# function. It does the same as what this script does 1171# but does not have the overhead of this script work, and 1172# runs 10-15% faster. 1173#################################################################### 1174[List.Generic:dynamic_1009] 1175Expression=dynamic_1009: md5($s.Y.$p.\xF7.$s) [Post.Office MD5] 1176Flag=MGF_SALTED 1177Flag=MGF_NOTSSE2Safe 1178Func=DynamicFunc__clean_input 1179Func=DynamicFunc__append_salt 1180Func=DynamicFunc__append_input1_from_CONST1 1181Func=DynamicFunc__append_keys 1182Func=DynamicFunc__append_input1_from_CONST2 1183Func=DynamicFunc__append_salt 1184Func=DynamicFunc__crypt_md5 1185Test=$dynamic_1009$550c41c11bab48f9dbd8203ed313eef0$aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:abc123 1186Test=$dynamic_1009$0c78bdef7d5448105cfbbc9aaa490a44$550c41c11bab48f9dbd8203ed313eef0:abc123 1187Test=$dynamic_1009$9be296cf73d2f548dae3cccafaff1dd9$82916963c701200625cba2acd40d6569:FRED 1188Test=$dynamic_1009$a0e2078f0354846ec5bc4c7d7be08a46$82916963c701200625cba2acd40d6569: 1189CONST1=Y 1190CONST2=\xF7 1191SaltLen=32 1192 1193#################################################################### 1194# Simple DYNAMIC type for Cisco PIX hash (same as pixMD5_fmt.c) 1195#################################################################### 1196[List.Generic:dynamic_1010] 1197Expression=dynamic_1010: pixMD5 1198Flag=MGF_INPBASE64_4x6 1199Flag=MGF_NOTSSE2Safe 1200Func=DynamicFunc__clean_input 1201Func=DynamicFunc__append_keys 1202Func=DynamicFunc__set_input_len_16 1203Func=DynamicFunc__crypt_md5 1204Test=$dynamic_1010$2KFQnbNIdI.2KYOU:cisco 1205Test=$dynamic_1010$TRPEas6f/aa6JSPL:test1 1206Test=$dynamic_1010$OMT6mXmAvGyzrCtp:test2 1207Test=$dynamic_1010$gTC7RIy1XJzagmLm:test3 1208Test=$dynamic_1010$oWC1WRwqlBlbpf/O:test4 1209Test=$dynamic_1010$NuLKvvWGg.x9HEKO:password 1210Test=$dynamic_1010$8Ry2YjIyt7RRXU24: 1211Test=$dynamic_1010$.7nfVBEIEu4KbF/1:0123456789abcdef 1212MaxInputLen=16 1213 1214#################################################################### 1215# Simple DYNAMIC type for Cisco PIX hash with a salt. The salt 1216# is the first 4 bytes of the user name. I have made an assumption 1217# about PW len. I assume it maxes at 12 chars, so the full salt is 1218# allowed. 1219#################################################################### 1220[List.Generic:dynamic_1011] 1221Expression=dynamic_1011: pixMD5-salted 1222Flag=MGF_INPBASE64_4x6 1223Flag=MGF_SALTED 1224Flag=MGF_NOTSSE2Safe 1225Func=DynamicFunc__clean_input 1226Func=DynamicFunc__append_keys 1227Func=DynamicFunc__append_salt 1228Func=DynamicFunc__set_input_len_16 1229Func=DynamicFunc__crypt_md5 1230Test=$dynamic_1011$h3mJrcH0901pqX/m$alex:ripper 1231Test=$dynamic_1011$3USUcOPFUiMCO4Jk$cisc:cisco 1232Test=$dynamic_1011$lZt7HSIXw3.QP7.R$admc:CscFw-ITC! 1233Test=$dynamic_1011$hN7LzeyYjw12FSIU$john:cisco 1234Test=$dynamic_1011$7DrfeZ7cyOj/PslD$jack:cisco 1235MaxInputLen=12 1236SaltLen=4 1237 1238#################################################################### 1239# Simple DYNAMIC type for PostOffice-MD5 md5($s.Y.$p.\xF7.$s) 1240# Included here to 'exercise' the script parser (constants) 1241# NOTE, the internal dynamic_18 has a specialized crypt 1242# function, as does this version. This is same as dynamic_18 1243#################################################################### 1244[List.Generic:dynamic_1012] 1245Expression=dynamic_1012: md5($s.Y.$p.\xF7.$s) [Post.Office MD5] 1246Flag=MGF_SALTED 1247Flag=MGF_NOTSSE2Safe 1248Flag=MGF_POSetup 1249Func=DynamicFunc__POCrypt 1250Test=$dynamic_1012$550c41c11bab48f9dbd8203ed313eef0$aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:abc123 1251Test=$dynamic_1012$0c78bdef7d5448105cfbbc9aaa490a44$550c41c11bab48f9dbd8203ed313eef0:abc123 1252Test=$dynamic_1012$9be296cf73d2f548dae3cccafaff1dd9$82916963c701200625cba2acd40d6569:FRED 1253Test=$dynamic_1012$a0e2078f0354846ec5bc4c7d7be08a46$82916963c701200625cba2acd40d6569: 1254Test=$dynamic_1012$eddfe6493d7e692994cf3526c71f8c84$aabbccddeeffgghhlksjflksjlfkdjsl:test1 1255SaltLen=32 1256 1257#################################################################### 1258# Simple DYNAMIC type for phpass-MD5. Same as dynamic_17 1259#################################################################### 1260[List.Generic:dynamic_1013] 1261Expression=dynamic_1013: phpass ($P$ or $H$) 1262Flag=MGF_SALTED 1263Flag=MGF_PHPassSetup 1264Flag=MGF_INPBASE64 1265Func=DynamicFunc__PHPassCrypt 1266Test=$dynamic_1013$jgypwqm.JsMssPLiS8YQ00$9aaaaaSXB:test1 1267Test=$dynamic_1013$5R3ueot5zwV.7MyzAItyg/$912345678:thatsworking 1268Test=$dynamic_1013$yhzfTrJXcouTpLleLSbnY/$7aaaaaSXB:test1 1269Test=$dynamic_1013$mwulIMWPGe6RPXG1/R8l50$712345678:thatsworking 1270Test=$dynamic_1013$nfKm8qpXa88RVUjLgjY/u1$7555555hh:test3 1271Test=$dynamic_1013$JSe8S8ufpLrsNE7utOpWc/$BaaaaaSXB:test1 1272Test=$dynamic_1013$aqkw6carDzQ67zCLOvVp60$B12345678:thatsworking 1273Test=$dynamic_1013$o2j.1E7X1NvVyEJ/QY9hX0$B555555hh:test3 1274Test=$dynamic_1013$Y5RwgMij0xFsUIrr33lM1/$9555555hh:test3 1275SaltLen=9 1276 1277 1278#################################################################### 1279# Simple DYNAMIC type for phpass-MD5. Same as dynamic_17 1280# This format shows what happens under the hood, INSIDE of the 1281# DynamicFunc__PHPassCrypt() function. We ONLY do $P$7, since 1282# it is the 'smallest' of the set. To do this WITHOUT the 1283# DynamicFunc__PHPassCrypt() function, we would have to have a 1284# special format for EACH type. NOTE the timings will 'appear' to 1285# be MUCH faster than normal phpass. This is due to ONLY checking 1286# a version of phpass that uses 512 crypts. In the phpass testing 1287# we select a version that tests 2048 of them. So in other words 1288# if this format was same 'speed', it would be 4x faster. NOTE it 1289# is a little slower than that, due to added overhead. 1290#################################################################### 1291[List.Generic:dynamic_1014] 1292Expression=dynamic_1014: phpass(512 crypt version) ($P$7 or $H$7 ) 1293Flag=MGF_SALTED 1294Flag=MGF_INPBASE64 1295Func=DynamicFunc__clean_input 1296Func=DynamicFunc__append_salt 1297Func=DynamicFunc__append_keys 1298Func=DynamicFunc__crypt_md5_to_input_raw 1299Func=DynamicFunc__append_keys 1300# for type 7, we perform 512 crypts 1301# 1 crypt here 1302Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen_but_setlen_in_SSE 1303# Now, perform 512 crypts 1304Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1305Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1306Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1307Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1308Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1309Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1310Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1311Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1312#8 done 1313Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1314Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1315Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1316Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1317Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1318Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1319Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1320Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1321#16 done 1322Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1323Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1324Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1325Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1326Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1327Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1328Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1329Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1330Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1331Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1332Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1333Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1334Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1335Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1336Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1337Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1338#32 done 1339Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1340Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1341Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1342Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1343Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1344Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1345Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1346Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1347Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1348Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1349Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1350Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1351Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1352Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1353Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1354Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1355Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1356Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1357Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1358Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1359Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1360Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1361Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1362Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1363Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1364Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1365Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1366Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1367Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1368Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1369Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1370Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1371#64 done 1372Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1373Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1374Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1375Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1376Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1377Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1378Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1379Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1380Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1381Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1382Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1383Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1384Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1385Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1386Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1387Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1388Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1389Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1390Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1391Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1392Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1393Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1394Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1395Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1396Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1397Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1398Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1399Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1400Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1401Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1402Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1403Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1404Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1405Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1406Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1407Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1408Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1409Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1410Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1411Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1412Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1413Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1414Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1415Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1416Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1417Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1418Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1419Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1420Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1421Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1422Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1423Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1424Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1425Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1426Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1427Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1428Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1429Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1430Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1431Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1432Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1433Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1434Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1435Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1436#128 done 1437Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1438Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1439Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1440Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1441Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1442Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1443Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1444Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1445Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1446Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1447Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1448Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1449Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1450Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1451Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1452Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1453Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1454Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1455Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1456Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1457Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1458Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1459Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1460Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1461Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1462Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1463Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1464Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1465Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1466Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1467Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1468Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1469Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1470Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1471Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1472Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1473Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1474Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1475Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1476Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1477Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1478Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1479Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1480Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1481Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1482Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1483Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1484Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1485Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1486Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1487Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1488Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1489Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1490Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1491Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1492Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1493Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1494Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1495Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1496Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1497Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1498Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1499Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1500Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1501Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1502Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1503Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1504Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1505Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1506Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1507Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1508Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1509Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1510Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1511Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1512Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1513Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1514Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1515Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1516Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1517Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1518Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1519Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1520Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1521Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1522Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1523Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1524Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1525Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1526Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1527Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1528Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1529Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1530Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1531Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1532Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1533Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1534Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1535Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1536Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1537Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1538Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1539Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1540Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1541Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1542Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1543Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1544Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1545Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1546Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1547Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1548Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1549Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1550Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1551Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1552Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1553Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1554Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1555Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1556Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1557Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1558Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1559Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1560Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1561Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1562Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1563Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1564Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1565#256 done 1566Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1567Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1568Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1569Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1570Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1571Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1572Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1573Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1574Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1575Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1576Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1577Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1578Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1579Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1580Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1581Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1582Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1583Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1584Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1585Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1586Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1587Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1588Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1589Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1590Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1591Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1592Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1593Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1594Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1595Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1596Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1597Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1598Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1599Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1600Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1601Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1602Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1603Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1604Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1605Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1606Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1607Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1608Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1609Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1610Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1611Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1612Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1613Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1614Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1615Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1616Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1617Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1618Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1619Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1620Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1621Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1622Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1623Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1624Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1625Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1626Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1627Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1628Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1629Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1630Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1631Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1632Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1633Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1634Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1635Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1636Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1637Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1638Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1639Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1640Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1641Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1642Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1643Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1644Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1645Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1646Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1647Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1648Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1649Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1650Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1651Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1652Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1653Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1654Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1655Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1656Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1657Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1658Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1659Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1660Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1661Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1662Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1663Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1664Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1665Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1666Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1667Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1668Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1669Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1670Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1671Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1672Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1673Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1674Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1675Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1676Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1677Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1678Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1679Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1680Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1681Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1682Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1683Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1684Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1685Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1686Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1687Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1688Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1689Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1690Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1691Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1692Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1693Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1694Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1695Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1696Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1697Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1698Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1699Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1700Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1701Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1702Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1703Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1704Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1705Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1706Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1707Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1708Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1709Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1710Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1711Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1712Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1713Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1714Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1715Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1716Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1717Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1718Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1719Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1720Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1721Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1722Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1723Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1724Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1725Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1726Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1727Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1728Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1729Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1730Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1731Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1732Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1733Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1734Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1735Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1736Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1737Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1738Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1739Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1740Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1741Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1742Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1743Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1744Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1745Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1746Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1747Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1748Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1749Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1750Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1751Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1752Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1753Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1754Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1755Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1756Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1757Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1758Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1759Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1760Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1761Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1762Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1763Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1764Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1765Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1766Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1767Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1768Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1769Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1770Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1771Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1772Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1773Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1774Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1775Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1776Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1777Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1778Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1779Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1780Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1781Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1782Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1783Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1784Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1785Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1786Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1787Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1788Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1789Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1790Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1791Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1792Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1793Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1794Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1795Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1796Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1797Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1798Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1799Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1800Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1801Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1802Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1803Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1804Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1805Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1806Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1807Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1808Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1809Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1810Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1811Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1812Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1813Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1814Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1815Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1816Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1817Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1818Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1819Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1820#Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1821#Func=DynamicFunc__crypt_md5_to_input_raw_Overwrite_NoLen 1822#512 done, but we did not test last 2 1823# last crypt (makes 512 crypts TOTAL). 1824# This will FAIL for big endian machines. We have special code 1825# inside our phpass to correctly deal with this. In this format 1826# there is NO way to do that. Sorry, It simply can not be done 1827# right now on BE systems. 1828Func=DynamicFunc__crypt_md5 1829Test=$dynamic_1014$yhzfTrJXcouTpLleLSbnY/$aaaaaSXB:test1 1830Test=$dynamic_1014$mwulIMWPGe6RPXG1/R8l50$12345678:thatsworking 1831Test=$dynamic_1014$nfKm8qpXa88RVUjLgjY/u1$555555hh:test3 1832SaltLen=8 1833 1834[List.Generic:dynamic_1015] 1835# same as 15, the user id format 1836Expression=md5($u.md5($p).$s) 1837Flag=MGF_SALTED 1838Flag=MGF_USERNAME 1839Flag=MGF_KEYS_CRYPT_IN2 1840Func=DynamicFunc__clean_input 1841Func=DynamicFunc__append_userid 1842Func=DynamicFunc__append_from_last_output2_to_input1_as_base16 1843Func=DynamicFunc__append_salt 1844Func=DynamicFunc__crypt_md5 1845Test=$dynamic_1015$6093d5cb3e2f99d9110eb9c4bbca5f8c$aaaSXB$$Ujoeblow:test1 1846Test=$dynamic_1015$6a2dc4a6637bc5c2488f27faeead8720$123456$$Uadmin:thatsworking 1847Test=$dynamic_1015$63aea4b8fe491df8545cc0099ac668d4$5555hh$$Uralph:test3 1848# to test 'like' we would see from an 'input file' where user name would be first field 1849Test=$dynamic_1015$6093d5cb3e2f99d9110eb9c4bbca5f8c$aaaSXB:test1:joeblow 1850Test=$dynamic_1015$6a2dc4a6637bc5c2488f27faeead8720$123456:thatsworking:admin 1851Test=$dynamic_1015$63aea4b8fe491df8545cc0099ac668d4$5555hh:test3:ralph 1852 1853 1854#################################################################### 1855# md5(upper(md5($p))) Included here to 'exercise' the script parser 1856#################################################################### 1857[List.Generic:dynamic_1016] 1858Expression=md5(upper(md5($p))) 1859# Flag needed here, is Salt. There is no 'fixed' saltlen. 1860Flag=MGF_KEYS_INPUT 1861Flag=MGF_BASE_16_OUTPUT_UPCASE 1862Func=DynamicFunc__crypt_md5 1863Func=DynamicFunc__clean_input2_kwik 1864Func=DynamicFunc__append_from_last_output_to_input2_as_base16 1865Func=DynamicFunc__crypt_md5_in2_to_out1 1866Test=$dynamic_1016$42b01e6aebac08b1d481990c77e93206:test1 1867Test=$dynamic_1016$11d382887431b076d540c4d3e37fe89a:Thatsworking 1868Test=$dynamic_1016$9ed1f40dffbb84dadc33138958e927b2:test3 1869 1870[List.Generic:dynamic_1017] 1871Expression=md5(upper(md5(upper(md5($p))))) 1872# Flag needed here, is Salt. There is no 'fixed' saltlen. 1873Flag=MGF_KEYS_INPUT 1874Flag=MGF_BASE_16_OUTPUT_UPCASE 1875Func=DynamicFunc__crypt_md5 1876Func=DynamicFunc__clean_input2_kwik 1877Func=DynamicFunc__append_from_last_output_to_input2_as_base16 1878Func=DynamicFunc__crypt2_md5 1879Func=DynamicFunc__clean_input2_kwik 1880Func=DynamicFunc__append_from_last_output2_as_base16 1881Func=DynamicFunc__crypt_md5_in2_to_out1 1882Test=$dynamic_1017$9D55D308E01806EF0227CF5A3AC90F4E:test1 1883Test=$dynamic_1017$1E80483A2F51520646542CCDC657E476:Thatsworking 1884Test=$dynamic_1017$0E8851B6B060F9A5A101F540C3E3D669:test3 1885 1886[List.Generic:dynamic_1018] 1887Expression=md5(upper(md5(upper(md5(upper(md5($p))))))) 1888# Flag needed here, is Salt. There is no 'fixed' saltlen. 1889Flag=MGF_KEYS_INPUT 1890Flag=MGF_BASE_16_OUTPUT_UPCASE 1891Func=DynamicFunc__crypt_md5 1892Func=DynamicFunc__clean_input2_kwik 1893Func=DynamicFunc__append_from_last_output_to_input2_as_base16 1894Func=DynamicFunc__crypt2_md5 1895Func=DynamicFunc__clean_input2_kwik 1896Func=DynamicFunc__append_from_last_output2_as_base16 1897Func=DynamicFunc__crypt2_md5 1898Func=DynamicFunc__clean_input2_kwik 1899Func=DynamicFunc__append_from_last_output2_as_base16 1900Func=DynamicFunc__crypt_md5_in2_to_out1 1901Test=$dynamic_1018$CDA798A1D3B4ED11BCA6C0A3D9747B9A:test1 1902Test=$dynamic_1018$98D346A7C2079BC2D6F49882E4847CDB:Thatsworking 1903Test=$dynamic_1018$82262EE9D6DF9E1138F602737A9F897E:test3 1904 1905 1906[List.Generic:dynamic_1021] 1907Expression=md5(md5(md5(md5($p)))) 1908# here is the optimized 'script' to perform the md5 4 times on itself 1909Func=DynamicFunc__clean_input 1910Func=DynamicFunc__append_keys 1911Func=DynamicFunc__crypt_md5 1912Func=DynamicFunc__clean_input 1913Func=DynamicFunc__append_from_last_output_as_base16 1914Func=DynamicFunc__crypt_md5 1915Func=DynamicFunc__clean_input_kwik 1916Func=DynamicFunc__append_from_last_output_as_base16 1917Func=DynamicFunc__crypt_md5 1918Func=DynamicFunc__clean_input_kwik 1919Func=DynamicFunc__append_from_last_output_as_base16 1920Func=DynamicFunc__crypt_md5 1921Test=$dynamic_1021$57200e13b490d4ae47d5e19be026b057:test1 1922Test=$dynamic_1021$c6cc44f9e7fb7efcde62ba2e627a49c6:thatsworking 1923Test=$dynamic_1021$0ae9549604e539a249c1fa9f5e5fb73b:test3 1924 1925[List.Generic:dynamic_1022] 1926# expression shown will be the string: dynamic_1022 md5(md5($s.md5($p.md5($p.md5($s.md5($p.$p).$s)))).md5($s.md5($p.md5($p.md5($s.$p)))).md5($s.md5($s.md5($p.md5($p.$s))))) 1927Expression=md5(md5($s.md5($p.md5($p.md5($s.md5($p.$p).$s)))).md5($s.md5($p.md5($p.md5($s.$p)))).md5($s.md5($s.md5($p.md5($p.$s))))) 1928Flag=MGF_SALTED 1929# 1930#md5(md5($s.md5($p.md5($p.md5($s.C1.$s)))).md5($s.md5($p.md5($p.md5($s.$p)))).md5($s.md5($s.md5($p.md5($p.$s))))) 1931#C1=md5($p.$p) 1932#md5(md5($s.md5($p.md5($p.C2))).md5($s.md5($p.md5($p.md5($s.$p)))).md5($s.md5($s.md5($p.md5($p.$s))))) 1933#C2=md5($s.C1.$s) (32+len_s2) 1934#md5(md5($s.md5($p.C3)).md5($s.md5($p.md5($p.md5($s.$p)))).md5($s.md5($s.md5($p.md5($p.$s))))) 1935#C3 = md5($p.C2) 1936#md5(md5($s.C4).md5($s.md5($p.md5($p.md5($s.$p)))).md5($s.md5($s.md5($p.md5($p.$s))))) 1937#C4 = md5($p.C3) 1938#md5(C5.md5($s.md5($p.md5($p.md5($s.$p)))).md5($s.md5($s.md5($p.md5($p.$s))))) 1939#C5 = md5($s.C4) 1940#md5(C5.md5($s.md5($p.md5($p.C6))).md5($s.md5($s.md5($p.md5($p.$s))))) 1941#C6=md5($s.$p) 1942#md5(C5.md5($s.md5($p.C7)).md5($s.md5($s.md5($p.md5($p.$s))))) 1943#C7=md5($p.C6) 1944#md5(C5.md5($s.C8).md5($s.md5($s.md5($p.md5($p.$s))))) 1945#C8=md5($p.C7) 1946#md5(C5.C9.md5($s.md5($s.md5($p.md5($p.$s))))) 1947#C9=md5($s.C8) 1948#md5(C5.C9.md5($s.md5($s.md5($p.C10)))) 1949#C10=md5($p.$s) 1950#md5(C5.C9.md5($s.md5($s.C11))) 1951#C11=md5($p.C11) 1952#md5(C5.C9.md5($s.C12)) 1953#C12=md5($s.C11) 1954#md5(C5.C9.C13) 1955#C13=md5($s.C12) 1956#C5.C9.C13 is NOT SSE safe. 1957# 1958Func=DynamicFunc__clean_input 1959Func=DynamicFunc__append_keys 1960Func=DynamicFunc__append_keys 1961Func=DynamicFunc__crypt_md5 1962#C1 in Out Inp, Inp2, Out2 free 1963Func=DynamicFunc__clean_input 1964Func=DynamicFunc__append_salt 1965Func=DynamicFunc__append_from_last_output_as_base16 1966Func=DynamicFunc__append_salt 1967Func=DynamicFunc__crypt_md5 1968#C2 in Out Inp, Inp2, Out2 free 1969Func=DynamicFunc__clean_input 1970Func=DynamicFunc__append_keys 1971Func=DynamicFunc__append_from_last_output_as_base16 1972Func=DynamicFunc__crypt_md5 1973#C3 in Out Inp, Inp2, Out2 free 1974Func=DynamicFunc__clean_input 1975Func=DynamicFunc__append_keys 1976Func=DynamicFunc__append_from_last_output_as_base16 1977Func=DynamicFunc__crypt_md5 1978#C4 in Out Inp, Inp2, Out2 free 1979Func=DynamicFunc__clean_input 1980Func=DynamicFunc__append_salt 1981Func=DynamicFunc__append_from_last_output_as_base16 1982Func=DynamicFunc__crypt_md5 1983#C5 in Out Inp, Inp2, Out2 free 1984 1985Func=DynamicFunc__SSEtoX86_switch_output1 1986Func=DynamicFunc__clean_input 1987Func=DynamicFunc__append_from_last_output_as_base16 1988##Func=DynamicFunc__SSEtoX86_switch_input1 1989#C5 in Inp[x86] Out, Inp2, Out2 free 1990Func=DynamicFunc__ToSSE 1991 1992Func=DynamicFunc__clean_input2 1993Func=DynamicFunc__append_salt2 1994##Func=DynamicFunc__SSEtoX86_switch_input2 1995Func=DynamicFunc__append_keys2 1996##Func=DynamicFunc__X86toSSE_switch_input2 1997Func=DynamicFunc__crypt2_md5 1998 1999#C5 in Inp - C6 in Out2 Out, Inp2 free 2000Func=DynamicFunc__clean_input2 2001Func=DynamicFunc__append_keys2 2002Func=DynamicFunc__append_from_last_output2_as_base16 2003Func=DynamicFunc__crypt2_md5 2004#C5 in Inp - C7 in Out2 Out, Inp2 free 2005Func=DynamicFunc__clean_input2 2006Func=DynamicFunc__append_keys2 2007Func=DynamicFunc__append_from_last_output2_as_base16 2008Func=DynamicFunc__crypt2_md5 2009#C5 in Inp - C8 in Out2 Out, Inp2 free 2010Func=DynamicFunc__clean_input2 2011Func=DynamicFunc__append_salt2 2012Func=DynamicFunc__append_from_last_output2_as_base16 2013Func=DynamicFunc__crypt2_md5 2014#C5 in Inp - C9 in Out2 Out, Inp2 free 2015 2016Func=DynamicFunc__SSEtoX86_switch_output2 2017Func=DynamicFunc__append_from_last_output2_to_input1_as_base16 2018#C5.C9 in Inp[x86] Out, Inp2 Out2 free 2019Func=DynamicFunc__ToSSE 2020 2021Func=DynamicFunc__clean_input2 2022Func=DynamicFunc__append_keys2 2023Func=DynamicFunc__append_salt2 2024Func=DynamicFunc__crypt2_md5 2025#C5.C9 in Inp - C10 in Out2 Out, Inp2 free 2026Func=DynamicFunc__clean_input2 2027Func=DynamicFunc__append_keys2 2028Func=DynamicFunc__append_from_last_output2_as_base16 2029Func=DynamicFunc__crypt2_md5 2030#C5.C9 in Inp - C11 in Out2 Out, Inp2 free 2031Func=DynamicFunc__clean_input2 2032Func=DynamicFunc__append_salt2 2033Func=DynamicFunc__append_from_last_output2_as_base16 2034Func=DynamicFunc__crypt2_md5 2035#C5.C9 in Inp - C12 in Out2 Out, Inp2 free 2036Func=DynamicFunc__clean_input2 2037Func=DynamicFunc__append_salt2 2038Func=DynamicFunc__append_from_last_output2_as_base16 2039Func=DynamicFunc__crypt2_md5 2040#C5.C9 in Inp - C13 in Out2 Out, Inp2 free 2041 2042Func=DynamicFunc__SSEtoX86_switch_output2 2043Func=DynamicFunc__append_from_last_output2_to_input1_as_base16 2044#C5.C9.C13 Inp[x86] Out, Inp2, Out2 free 2045Func=DynamicFunc__crypt_md5 2046#Final answer in Out Inp, Inp2, Out2 free 2047Func=DynamicFunc__X86toSSE_switch_output1 2048 2049 2050Test=$dynamic_1022$c901de937291c6232e789d70dde2cd7f$aabbccdd:test1 2051 2052 2053#################################################################### 2054# mkmd5gen generated DYNAMIC type for md5(md5($p).md5($p.md5($p.$s).md5($s.$p))) 2055#################################################################### 2056[List.Generic:dynamic_1023] 2057Expression=dynamic_1023: md5(md5($p).md5($p.md5($p.$s).md5($s.$p))) 2058Flag=MGF_SALTED 2059Flag=MGF_NOTSSE2Safe 2060# 2061#md5(md5($p).md5($p.md5($p.$s).md5($s.$p))) 2062#md5(C1.md5($p.md5($p.$s).md5($s.$p))) 2063#md5(C1.md5($p.C2.md5($s.$p))) 2064#md5(C1.md5($p.C2.C3)) 2065#md5(C1.C4) 2066# 2067Func=DynamicFunc__clean_input 2068Func=DynamicFunc__append_keys 2069Func=DynamicFunc__crypt_md5 2070#C1 in Out Inp, Inp2, Out2 free 2071Func=DynamicFunc__clean_input 2072Func=DynamicFunc__append_from_last_output_as_base16 2073#C1 in Inp Out, Inp2 Out2 free 2074Func=DynamicFunc__clean_input2 2075Func=DynamicFunc__append_keys2 2076Func=DynamicFunc__append_salt2 2077Func=DynamicFunc__crypt2_md5 2078#C1 in Inp C2 in Out2 Free: Out, Inp2 2079Func=DynamicFunc__clean_input2 2080Func=DynamicFunc__append_salt2 2081Func=DynamicFunc__append_keys2 2082Func=DynamicFunc__crypt_md5_in2_to_out1 2083#C1 in Inp C2 in Out2 C3 in Out1 Free: Inp2 2084Func=DynamicFunc__clean_input2 2085Func=DynamicFunc__append_keys2 2086Func=DynamicFunc__append_from_last_output2_as_base16 2087Func=DynamicFunc__append_from_last_output_to_input2_as_base16 2088Func=DynamicFunc__crypt2_md5 2089#C1 in Inp C4 in Out2 Free: Out1, Inp2 2090Func=DynamicFunc__append_from_last_output2_to_input1_as_base16 2091#C1.C4 in Inp Free: Out1, Inp2 Out2 2092Func=DynamicFunc__crypt_md5 2093#Result in Out1 2094# 2095Test=$dynamic_1023$529f4a3600b1ed4af606a5fbc80f58ee$aabbccdd:test1 2096Test=$dynamic_1023$aa8dbd8512be7a045ba602ddc2cab64b$zzyyxxww:test3 2097Test=$dynamic_1023$bd0d60add4315f6d0b13c63226d7111e$01234567:ThisisWorking 2098Test=$dynamic_1023$7174c2398175d2cb1d86e463cb6c8edd$98765432:abc 2099Test=$dynamic_1023$cef72db811843bd37f1121f714c32752$65432198:Longer Pass Here 2100Test=$dynamic_1023$8b0131c839db57eb6410ad84076f2fa2$32165498:Junk 2101Test=$dynamic_1023$736d738772ae81411d96f56d0edc95c9$74185296:Junk1 2102Test=$dynamic_1023$d66166897605b76f276e76b5596834f3$96325874:Junky3 2103SaltLen=8 2104 2105 2106#################################################################### 2107# mkmd5gen generated DYNAMIC type for md5(md5($p).md5($p.md5($p.$s).md5($s.$p).md5($p.$p))) 2108 2109#################################################################### 2110# mkmd5gen generated DYNAMIC type for md5($p) 2111#################################################################### 2112[List.Generic:dynamic_1024] 2113Expression=dynamic_1024: md5($p) 2114Func=DynamicFunc__clean_input 2115Func=DynamicFunc__append_keys 2116Func=DynamicFunc__crypt_md5 2117Test=$dynamic_1024$5a105e8b9d40e1329780d62ea2265d8a:test1 2118Test=$dynamic_1024$8ad8757baa8564dc136c1e07507f4a98:test3 2119Test=$dynamic_1024$abbd6ffd1e10de751a20f97436a50dde:ThisisWorking 2120Test=$dynamic_1024$900150983cd24fb0d6963f7d28e17f72:abc 2121Test=$dynamic_1024$ffb756913c91d25a7094d3fa3d1206dd:Longer Pass Here 2122Test=$dynamic_1024$50a16f415160a7132a86a551fc34bdc9:Junk 2123Test=$dynamic_1024$1d5615d1e07f2554970cb4a93d776ca3:Junk1 2124Test=$dynamic_1024$778f5c751de2d5a32faf89626c786103:Junky3 2125 2126#################################################################### 2127# mkmd5gen generated DYNAMIC type for md5($p) 2128#################################################################### 2129[List.Generic:dynamic_1025] 2130Expression=dynamic_1025: md5($p) 2131Flag=MGF_KEYS_INPUT 2132Func=DynamicFunc__crypt_md5 2133Test=$dynamic_1025$5a105e8b9d40e1329780d62ea2265d8a:test1 2134Test=$dynamic_1025$8ad8757baa8564dc136c1e07507f4a98:test3 2135Test=$dynamic_1025$900150983cd24fb0d6963f7d28e17f72:abc 2136 2137[List.Generic:dynamic_1030] 2138Expression=dynamic_1030: md5($p.$p) 2139Func=DynamicFunc__clean_input 2140Func=DynamicFunc__append_keys 2141Func=DynamicFunc__append_keys 2142Func=DynamicFunc__crypt_md5 2143Test=$dynamic_1030$42b72f913c3201fc62660d512f5ac746:test1 2144 2145[List.Generic:dynamic_1031] 2146Expression=dynamic_1031: md5($s.md5($p).$p) 2147Flag=MGF_SALTED 2148Func=DynamicFunc__clean_input 2149Func=DynamicFunc__append_keys 2150Func=DynamicFunc__SSEtoX86_switch_input1 2151Func=DynamicFunc__ToSSE 2152Func=DynamicFunc__crypt_md5 2153Func=DynamicFunc__clean_input_kwik 2154Func=DynamicFunc__append_from_last_output_as_base16 2155Func=DynamicFunc__SSEtoX86_switch_input1 2156Func=DynamicFunc__ToSSE 2157Func=DynamicFunc__clean_input_kwik 2158Func=DynamicFunc__append_salt 2159Func=DynamicFunc__append_from_last_output_as_base16 2160Func=DynamicFunc__append_keys 2161Func=DynamicFunc__SSEtoX86_switch_input1 2162Func=DynamicFunc__ToSSE 2163Func=DynamicFunc__crypt_md5 2164Test=$dynamic_1031$a459f60614498dbdd9a79dcc9c538749$aabbccdd:test1 2165 2166[List.Generic:dynamic_1032] 2167Expression=dynamic_1032: md5(md5($s).md5($p).$p) 2168Flag=MGF_SALTED 2169Flag=MGF_NOTSSE2Safe 2170Func=DynamicFunc__clean_input 2171Func=DynamicFunc__append_salt 2172Func=DynamicFunc__crypt_md5 2173Func=DynamicFunc__clean_input2 2174Func=DynamicFunc__append_keys2 2175Func=DynamicFunc__crypt2_md5 2176Func=DynamicFunc__clean_input 2177Func=DynamicFunc__append_from_last_output_as_base16 2178Func=DynamicFunc__append_from_last_output2_to_input1_as_base16 2179Func=DynamicFunc__append_keys 2180Func=DynamicFunc__crypt_md5 2181Test=$dynamic_1032$042d1f15ed57929a2ac8ee4f0a924679$aabbccdd:test1 2182 2183 2184[List.Generic:dynamic_1042] 2185Expression=dynamic_1042: md5(md5($s).md5($p).$p) 2186Flag=MGF_SALTED 2187Flag=MGF_SALT_AS_HEX 2188Flag=MGF_NOTSSE2Safe 2189Func=DynamicFunc__clean_input 2190Func=DynamicFunc__append_keys 2191Func=DynamicFunc__crypt_md5 2192Func=DynamicFunc__clean_input 2193Func=DynamicFunc__append_salt 2194Func=DynamicFunc__append_from_last_output_as_base16 2195Func=DynamicFunc__append_keys 2196Func=DynamicFunc__crypt_md5 2197Test=$dynamic_1042$042d1f15ed57929a2ac8ee4f0a924679$aabbccdd:test1 2198 2199 2200[List.Generic:dynamic_1052] 2201Expression=dynamic_1052: md5(md5($s).md5($p).$p) 2202Flag=MGF_SALTED 2203Flag=MGF_SALT_AS_HEX 2204Flag=MGF_KEYS_BASE16_IN1_Offset32 2205Flag=MGF_NOTSSE2Safe 2206Func=DynamicFunc__overwrite_salt_to_input1_no_size_fix 2207Func=DynamicFunc__set_input_len_64 2208Func=DynamicFunc__append_keys 2209Func=DynamicFunc__crypt_md5 2210Test=$dynamic_1052$042d1f15ed57929a2ac8ee4f0a924679$aabbccdd:test1 2211 2212[List.Generic:dynamic_1062] 2213Expression=dynamic_1062: md5(md5($s).md5($p).$p) 2214Flag=MGF_SALTED 2215Flag=MGF_SALT_AS_HEX 2216Func=DynamicFunc__clean_input 2217Func=DynamicFunc__append_keys 2218Func=DynamicFunc__crypt_md5 2219Func=DynamicFunc__SSEtoX86_switch_output1 2220Func=DynamicFunc__clean_input 2221Func=DynamicFunc__append_salt 2222Func=DynamicFunc__append_from_last_output_as_base16 2223Func=DynamicFunc__append_keys 2224Func=DynamicFunc__crypt_md5 2225Func=DynamicFunc__X86toSSE_switch_output1 2226Test=$dynamic_1062$042d1f15ed57929a2ac8ee4f0a924679$aabbccdd:test1 2227 2228[List.Generic:dynamic_1033] 2229Expression=dynamic_1033: md5(md5($p).$s) 2230Flag=MGF_SALTED 2231Func=DynamicFunc__clean_input 2232Func=DynamicFunc__append_keys 2233Func=DynamicFunc__crypt_md5 2234Func=DynamicFunc__clean_input 2235Func=DynamicFunc__append_from_last_output_as_base16 2236Func=DynamicFunc__append_salt 2237Func=DynamicFunc__crypt_md5 2238Test=$dynamic_1033$e9fb44106edf60419d26a10b5439d0c7$aabbccddeeff:test1 2239SaltLen=12 2240 2241[List.Generic:dynamic_1043] 2242Expression=dynamic_1043: md5(md5($p).$s) 2243Flag=MGF_SALTED 2244Flag=MGF_KEYS_BASE16_IN1 2245Func=DynamicFunc__set_input_len_32 2246Func=DynamicFunc__append_salt 2247Func=DynamicFunc__crypt_md5 2248Test=$dynamic_1043$e9fb44106edf60419d26a10b5439d0c7$aabbccddeeff:test1 2249SaltLen=12 2250 2251 2252[List.Generic:dynamic_1044] 2253Expression=dynamic_1044: md5(md5($p.md5($p.md5($s.$p))).$s) 2254Flag=MGF_SALTED 2255Func=DynamicFunc__clean_input 2256Func=DynamicFunc__append_salt 2257Func=DynamicFunc__append_keys 2258Func=DynamicFunc__crypt_md5 2259Func=DynamicFunc__clean_input 2260Func=DynamicFunc__append_keys 2261Func=DynamicFunc__append_from_last_output_as_base16 2262Func=DynamicFunc__crypt_md5 2263Func=DynamicFunc__clean_input2 2264Func=DynamicFunc__append_keys2 2265Func=DynamicFunc__append_from_last_output_to_input2_as_base16 2266Func=DynamicFunc__crypt2_md5 2267Func=DynamicFunc__clean_input2 2268Func=DynamicFunc__append_from_last_output2_as_base16 2269Func=DynamicFunc__append_salt2 2270Func=DynamicFunc__crypt_md5_in2_to_out1 2271Test=$dynamic_1044$e4f0714e3e616ed7647dbd44aaff3c00$aabbccdd:test1 2272 2273 2274 2275#################################################################### 2276# Simple DYNAMIC type for md5(md5($p).md5($p)) 2277#################################################################### 2278[List.Generic:dynamic_1063] 2279# expression shown will be the string: dynamic_1063 md5(md5($p).md5($p)) 2280Expression=md5(md5($p).md5($p)) 2281# NOTE, this format does NOT work on SSE2. It requires a md5() of a 64 byte string. 2282# SSE (or MMX) is limtited to 54 byte max password, due to 'enhancements' 2283# Thus, we need a non-sse2 safe flag. 2284#Flag=MGF_NOTSSE2Safe 2285Flag=MGF_KEYS_INPUT 2286# here is the optimized 'script' to perform hash 'like' IPB but salt replaced with password. 2287Func=DynamicFunc__crypt_md5 2288Func=DynamicFunc__SSEtoX86_switch_output1 2289Func=DynamicFunc__clean_input2_kwik 2290Func=DynamicFunc__append_from_last_output_to_input2_as_base16 2291Func=DynamicFunc__append_from_last_output_to_input2_as_base16 2292Func=DynamicFunc__crypt_md5_in2_to_out1 2293Func=DynamicFunc__X86toSSE_switch_output1 2294# These are test strings for this format. 2295Test=$dynamic_1063$478b10974f15e7295883224fd286ccba:test1 2296Test=$dynamic_1063$18a59101e6c6fb38260d542a394ecb22:thatsworking 2297Test=$dynamic_1063$630b01b68b6db6fd43a751f8147d1faf:test3 2298 2299 2300#################################################################### 2301# mkmd5gen generated DYNAMIC type for md5($s.md5($p.$s.md5(md5($s2)).$c1.$c3.$c4.$c5.$c7.$c6.$c8).$c2) 2302#################################################################### 2303[List.Generic:dynamic_5001] 2304Expression=dynamic_5001: md5($s.md5($p.$s.md5(md5($s2)).$c1.$c3.$c4.$c5.$c7.$c6.$c8).$c2) 2305Flag=MGF_SALTED 2306Flag=MGF_SALTED2 2307Flag=MGF_NOTSSE2Safe 2308Func=DynamicFunc__clean_input 2309Func=DynamicFunc__append_2nd_salt 2310Func=DynamicFunc__crypt_md5_in1_to_out2 2311Func=DynamicFunc__clean_input2 2312Func=DynamicFunc__append_from_last_output2_as_base16 2313Func=DynamicFunc__crypt2_md5 2314Func=DynamicFunc__clean_input2 2315Func=DynamicFunc__clean_input 2316Func=DynamicFunc__append_keys2 2317Func=DynamicFunc__append_salt2 2318Func=DynamicFunc__append_from_last_output2_as_base16 2319Func=DynamicFunc__append_input2_from_CONST1 2320Func=DynamicFunc__append_input2_from_CONST3 2321Func=DynamicFunc__append_input2_from_CONST4 2322Func=DynamicFunc__append_input2_from_CONST5 2323Func=DynamicFunc__append_input2_from_CONST7 2324Func=DynamicFunc__append_input2_from_CONST6 2325Func=DynamicFunc__append_input2_from_CONST8 2326Func=DynamicFunc__crypt2_md5 2327Func=DynamicFunc__append_salt 2328Func=DynamicFunc__append_from_last_output2_to_input1_as_base16 2329Func=DynamicFunc__append_input1_from_CONST2 2330Func=DynamicFunc__crypt_md5 2331Test=$dynamic_5001$6d1a31e525633013d52bc065328ecd7c$aabbccdd$$2xszef:test1 2332Test=$dynamic_5001$1ad6b42d7f22fcafbf9609c3efbea182$zzyyxxww$$2ER#^s:test3 2333Test=$dynamic_5001$5eeeca352107c1b565af4a249a8452ee$01234567$$2hhhas:ThisisWorking 2334Test=$dynamic_5001$fdb9c4702c7f82e3431d64f3b9d06136$98765432$$2hrhas:abc 2335Test=$dynamic_5001$4b1fce298a29af07a8d66542222fb36e$65432198$$2ksjas:Longer Pass Here 2336Test=$dynamic_5001$20d8de9d5a19e44181b0a8102e9345e4$32165498$$2Zhbbb:Junk 2337Test=$dynamic_5001$9dfb9c3259dfc316a098d6d45fc77f54$74185296$$2Thxyz:Junk1 2338Test=$dynamic_5001$7ea6b7fa2c1f0e2baee1792b0234034d$96325874$$2ABCDEF:Junky3 2339CONST1=c1 2340CONST2=2 2341CONST3=333 2342CONST4=4444 2343CONST5=c5 2344CONST6=666666 2345CONST7=const_7 2346CONST8=c8 2347SaltLen=8 2348 2349[List.Generic:dynamic_5002] 2350Expression=dynamic_5002: md5(md5($p)) 2351Flag=MGF_KEYS_INPUT 2352Func=DynamicFunc__crypt_md5_in1_to_out2 2353Func=DynamicFunc__SSEtoX86_switch_output2 2354Func=DynamicFunc__clean_input2 2355Func=DynamicFunc__append_from_last_output2_as_base16 2356Func=DynamicFunc__crypt_md5_in2_to_out1 2357#sFunc=DynamicFunc__X86toSsE_switch_output1 2358Test=$dynamic_5002$418d89a45edadb8ce4da17e07f72536c:test1 2359Test=$dynamic_5002$ccd3c4231a072b5e13856a2059d04fad:thatsworking 2360Test=$dynamic_5002$9992295627e7e7162bdf77f14734acf8:test3 2361 2362[List.Generic:dynamic_5003] 2363Expression=dynamic_5003: md5($c1.md5($c2.md5($c3.md5($c4.md5($c5.md5($c6.md5($c7.md5($c8.$p).$c1).$c2).$c3).$c4).$c5).$c6).$c7) 2364Func=DynamicFunc__clean_input2 2365Func=DynamicFunc__append_input2_from_CONST8 2366Func=DynamicFunc__append_keys2 2367Func=DynamicFunc__crypt2_md5 2368Func=DynamicFunc__clean_input2 2369Func=DynamicFunc__append_input2_from_CONST7 2370Func=DynamicFunc__append_from_last_output2_as_base16 2371Func=DynamicFunc__append_input2_from_CONST1 2372Func=DynamicFunc__crypt2_md5 2373Func=DynamicFunc__clean_input2 2374Func=DynamicFunc__append_input2_from_CONST6 2375Func=DynamicFunc__append_from_last_output2_as_base16 2376Func=DynamicFunc__append_input2_from_CONST2 2377Func=DynamicFunc__crypt2_md5 2378Func=DynamicFunc__clean_input2 2379Func=DynamicFunc__append_input2_from_CONST5 2380Func=DynamicFunc__append_from_last_output2_as_base16 2381Func=DynamicFunc__append_input2_from_CONST3 2382Func=DynamicFunc__crypt2_md5 2383Func=DynamicFunc__clean_input2 2384Func=DynamicFunc__append_input2_from_CONST4 2385Func=DynamicFunc__append_from_last_output2_as_base16 2386Func=DynamicFunc__append_input2_from_CONST4 2387Func=DynamicFunc__crypt2_md5 2388Func=DynamicFunc__clean_input2 2389Func=DynamicFunc__append_input2_from_CONST3 2390Func=DynamicFunc__append_from_last_output2_as_base16 2391Func=DynamicFunc__append_input2_from_CONST5 2392Func=DynamicFunc__crypt2_md5 2393Func=DynamicFunc__clean_input2 2394Func=DynamicFunc__append_input2_from_CONST2 2395Func=DynamicFunc__append_from_last_output2_as_base16 2396Func=DynamicFunc__append_input2_from_CONST6 2397Func=DynamicFunc__crypt2_md5 2398Func=DynamicFunc__clean_input2 2399Func=DynamicFunc__append_input2_from_CONST1 2400Func=DynamicFunc__append_from_last_output2_as_base16 2401Func=DynamicFunc__append_input2_from_CONST7 2402Func=DynamicFunc__crypt_md5_in2_to_out1 2403Test=$dynamic_5003$116475e5dcb0f34933dad42ba23f1c5d:test1 2404Test=$dynamic_5003$78a24cda1176ee0a361204ad523e84db:test3 2405Test=$dynamic_5003$33dd28264da1606c681d883947e1dc69:ThisisWorking 2406Test=$dynamic_5003$7ee41d938e2711ec317f2b6bebd27438:abc 2407Test=$dynamic_5003$31a334471399b2fe1ed00badc36d3163:Longer Pass Here 2408Test=$dynamic_5003$1a4eda9b6cd32febe9f9aa5d0a7f53ec:Junk 2409Test=$dynamic_5003$c3c4959e6cde82d9035fbc55608a53ef:Junk1 2410Test=$dynamic_5003$75242eca2f979739a1b047f74f9b6851:Junky3 2411CONST1=1 2412CONST2=c2 2413CONST3=333 2414CONST4=4..4 2415CONST5=5---5 2416CONST6=6,,,,6 2417CONST7=7!!!!!7 2418CONST8=88888888 2419 2420[List.Generic:dynamic_5004] 2421Expression=dynamic_5004: md5($c1.md5($c2.md5($c3.md5($c4.md5($c5.md5($c6.md5($c7.md5($c8.$p).$c1).$c2).$c3).$c4).$c5).$c6).$c7) 2422Func=DynamicFunc__clean_input 2423Func=DynamicFunc__append_input1_from_CONST8 2424Func=DynamicFunc__append_keys 2425Func=DynamicFunc__crypt_md5 2426Func=DynamicFunc__clean_input 2427Func=DynamicFunc__append_input1_from_CONST7 2428Func=DynamicFunc__append_from_last_output_as_base16 2429Func=DynamicFunc__append_input1_from_CONST1 2430Func=DynamicFunc__crypt_md5 2431Func=DynamicFunc__clean_input 2432Func=DynamicFunc__append_input1_from_CONST6 2433Func=DynamicFunc__append_from_last_output_as_base16 2434Func=DynamicFunc__append_input1_from_CONST2 2435Func=DynamicFunc__crypt_md5 2436Func=DynamicFunc__clean_input 2437Func=DynamicFunc__append_input1_from_CONST5 2438Func=DynamicFunc__append_from_last_output_as_base16 2439Func=DynamicFunc__append_input1_from_CONST3 2440Func=DynamicFunc__crypt_md5 2441Func=DynamicFunc__clean_input 2442Func=DynamicFunc__append_input1_from_CONST4 2443Func=DynamicFunc__append_from_last_output_as_base16 2444Func=DynamicFunc__append_input1_from_CONST4 2445Func=DynamicFunc__crypt_md5 2446Func=DynamicFunc__clean_input 2447Func=DynamicFunc__append_input1_from_CONST3 2448Func=DynamicFunc__append_from_last_output_as_base16 2449Func=DynamicFunc__append_input1_from_CONST5 2450Func=DynamicFunc__crypt_md5 2451Func=DynamicFunc__clean_input 2452Func=DynamicFunc__append_input1_from_CONST2 2453Func=DynamicFunc__append_from_last_output_as_base16 2454Func=DynamicFunc__append_input1_from_CONST6 2455Func=DynamicFunc__crypt_md5 2456Func=DynamicFunc__clean_input 2457Func=DynamicFunc__append_input1_from_CONST1 2458Func=DynamicFunc__append_from_last_output_as_base16 2459Func=DynamicFunc__append_input1_from_CONST7 2460Func=DynamicFunc__crypt_md5 2461Test=$dynamic_5004$116475e5dcb0f34933dad42ba23f1c5d:test1 2462Test=$dynamic_5004$78a24cda1176ee0a361204ad523e84db:test3 2463Test=$dynamic_5004$33dd28264da1606c681d883947e1dc69:ThisisWorking 2464Test=$dynamic_5004$7ee41d938e2711ec317f2b6bebd27438:abc 2465Test=$dynamic_5004$31a334471399b2fe1ed00badc36d3163:Longer Pass Here 2466Test=$dynamic_5004$1a4eda9b6cd32febe9f9aa5d0a7f53ec:Junk 2467Test=$dynamic_5004$c3c4959e6cde82d9035fbc55608a53ef:Junk1 2468Test=$dynamic_5004$75242eca2f979739a1b047f74f9b6851:Junky3 2469CONST1=1 2470CONST2=c2 2471CONST3=333 2472CONST4=4..4 2473CONST5=5---5 2474CONST6=6,,,,6 2475CONST7=7!!!!!7 2476CONST8=88888888 2477 2478[List.Generic:dynamic_5005] 2479Expression=dynamic_5005: md5($c1.md5($c2.md5($c3.md5($c4.md5($c5.md5($c6.md5($c7.md5($c8.$p).$c1).$c2).$c3).$c4).$c5).$c6).$c7) 2480Func=DynamicFunc__clean_input 2481Func=DynamicFunc__clean_input2 2482Func=DynamicFunc__append_input1_from_CONST8 2483Func=DynamicFunc__append_input2_from_input 2484Func=DynamicFunc__append_keys2 2485Func=DynamicFunc__crypt_md5_in2_to_out1 2486Func=DynamicFunc__clean_input 2487Func=DynamicFunc__clean_input2 2488Func=DynamicFunc__append_input2_from_CONST7 2489Func=DynamicFunc__append_from_last_output_to_input2_as_base16 2490Func=DynamicFunc__append_input2_from_CONST1 2491Func=DynamicFunc__crypt_md5_in2_to_out1 2492Func=DynamicFunc__clean_input 2493Func=DynamicFunc__clean_input2 2494Func=DynamicFunc__append_input2_from_CONST6 2495Func=DynamicFunc__append_input_from_input2 2496Func=DynamicFunc__append_from_last_output_as_base16 2497Func=DynamicFunc__append_input1_from_CONST2 2498Func=DynamicFunc__crypt_md5 2499Func=DynamicFunc__clean_input 2500Func=DynamicFunc__append_input1_from_CONST5 2501Func=DynamicFunc__append_from_last_output_as_base16 2502Func=DynamicFunc__append_input1_from_CONST3 2503Func=DynamicFunc__crypt_md5 2504Func=DynamicFunc__clean_input 2505Func=DynamicFunc__append_input1_from_CONST4 2506Func=DynamicFunc__append_from_last_output_as_base16 2507Func=DynamicFunc__append_input1_from_CONST4 2508Func=DynamicFunc__crypt_md5 2509Func=DynamicFunc__clean_input 2510Func=DynamicFunc__append_input1_from_CONST3 2511Func=DynamicFunc__append_from_last_output_as_base16 2512Func=DynamicFunc__append_input1_from_CONST5 2513Func=DynamicFunc__crypt_md5 2514Func=DynamicFunc__clean_input 2515Func=DynamicFunc__append_input1_from_CONST2 2516Func=DynamicFunc__append_from_last_output_as_base16 2517Func=DynamicFunc__append_input1_from_CONST6 2518Func=DynamicFunc__crypt_md5 2519Func=DynamicFunc__clean_input 2520Func=DynamicFunc__append_input1_from_CONST1 2521Func=DynamicFunc__append_from_last_output_as_base16 2522Func=DynamicFunc__append_input1_from_CONST7 2523Func=DynamicFunc__crypt_md5 2524Test=$dynamic_5005$116475e5dcb0f34933dad42ba23f1c5d:test1 2525Test=$dynamic_5005$78a24cda1176ee0a361204ad523e84db:test3 2526Test=$dynamic_5005$33dd28264da1606c681d883947e1dc69:ThisisWorking 2527Test=$dynamic_5005$7ee41d938e2711ec317f2b6bebd27438:abc 2528Test=$dynamic_5005$31a334471399b2fe1ed00badc36d3163:Longer Pass Here 2529Test=$dynamic_5005$1a4eda9b6cd32febe9f9aa5d0a7f53ec:Junk 2530Test=$dynamic_5005$c3c4959e6cde82d9035fbc55608a53ef:Junk1 2531Test=$dynamic_5005$75242eca2f979739a1b047f74f9b6851:Junky3 2532CONST1=1 2533CONST2=c2 2534CONST3=333 2535CONST4=4..4 2536CONST5=5---5 2537CONST6=6,,,,6 2538CONST7=7!!!!!7 2539CONST8=88888888 2540 2541# -num=5003 -const1=1 -const2=c2 -const3=333 -const4-4..4 -const5-5---5 -const6=6,,,,6 -const7=7!!!!!7 -const8=88888888 md5($c1.md5($c2.md5($c3.md5($c4.md5($c5.md5($c6.md5($c7.md5($c8.$p).$c1).$c2).$c3).$c4).$c5).$c6).$c7) 2542 2543[List.Generic:dynamic_1053] 2544Expression=dynamic_1053: md5($s.md5($s).$p) 2545Flag=MGF_SALTED 2546Flag=MGF_SALT_AS_HEX_TO_SALT2 2547Func=DynamicFunc__clean_input 2548#Func=DynamicFunc__append_salt 2549#Func=DynamicFunc__crypt_md5 2550#Func=DynamicFunc__clean_input 2551Func=DynamicFunc__append_salt 2552#Func=DynamicFunc__append_from_last_output_as_base16 2553Func=DynamicFunc__append_2nd_salt 2554Func=DynamicFunc__append_keys 2555Func=DynamicFunc__crypt_md5 2556Test=$dynamic_1053$94eead61c1c07bb832ff855dd6115702$aabbccdd:test1 2557Test=$dynamic_1053$0c6253b0b82dc81bc5f5de0dcb59ee80$zzyyxxww:test3 2558Test=$dynamic_1053$86d00c5383bbdaf1661d7729160766ed$01234567:ThisisWorking 2559Test=$dynamic_1053$22c4c1568720e6db338d672c8241d0e4$98765432:abc 2560Test=$dynamic_1053$f55723bdf8e577bf691b079aeadffe1f$32165498:Junk 2561Test=$dynamic_1053$133857938ba2921bb079b3eca170bc77$74185296:Junk1 2562Test=$dynamic_1053$b24df1c9f98699a99e492a591bdf1241$96325874:Junky3 2563 2564 2565[List.Generic:dynamic_1054] 2566Expression=dynamic_1054: md5($s.md5(unicode($p))) 2567Flag=MGF_SALTED 2568Func=DynamicFunc__clean_input 2569Func=DynamicFunc__setmode_unicode 2570Func=DynamicFunc__append_keys 2571Func=DynamicFunc__crypt_md5 2572Func=DynamicFunc__setmode_normal 2573Func=DynamicFunc__clean_input 2574Func=DynamicFunc__append_salt 2575Func=DynamicFunc__append_from_last_output_as_base16 2576Func=DynamicFunc__crypt_md5 2577Test=$dynamic_1054$2e233d5102d2be03307ec5490075121d$aabbccdd:test1 2578Test=$dynamic_1054$0474efd4022743c1113636fc1f34d88a$zzyyxxww:test3 2579Test=$dynamic_1054$e3ab32d7db8521616781f13919bb17bc$01234567:ThisisWorking 2580Test=$dynamic_1054$9bc5270127c0a61c031ede0a61a79d98$98765432:abc 2581Test=$dynamic_1054$e3546ff029afaba5977ed1db0da8b467$32165498:Junk 2582Test=$dynamic_1054$e7c1a5215b06a7ee4048d70b50d086dd$74185296:Junk1 2583Test=$dynamic_1054$66d4e0e951d5f064538b9b2db3bdf41d$96325874:Junky3 2584 2585 2586[List.Generic:dynamic_1055] 2587Expression=dynamic_1055: md5($s.md5(unicode($p))) 2588Flag=MGF_SALTED 2589Flag=MGF_KEYS_UNICODE_B4_CRYPT 2590Flag=MGF_KEYS_CRYPT_IN2 2591Func=DynamicFunc__setmode_normal 2592Func=DynamicFunc__clean_input 2593Func=DynamicFunc__append_salt 2594Func=DynamicFunc__append_from_last_output2_to_input1_as_base16 2595Func=DynamicFunc__crypt_md5 2596Test=$dynamic_1055$2e233d5102d2be03307ec5490075121d$aabbccdd:test1 2597Test=$dynamic_1055$0474efd4022743c1113636fc1f34d88a$zzyyxxww:test3 2598Test=$dynamic_1055$e3ab32d7db8521616781f13919bb17bc$01234567:ThisisWorking 2599Test=$dynamic_1055$9bc5270127c0a61c031ede0a61a79d98$98765432:abc 2600Test=$dynamic_1055$e3546ff029afaba5977ed1db0da8b467$32165498:Junk 2601Test=$dynamic_1055$e7c1a5215b06a7ee4048d70b50d086dd$74185296:Junk1 2602Test=$dynamic_1055$66d4e0e951d5f064538b9b2db3bdf41d$96325874:Junky3 2603 2604 2605[List.Generic:dynamic_1056] 2606Expression=dynamic_1056: md5(unicode($p).md5(unicode($s))) 2607Flag=MGF_SALTED 2608Func=DynamicFunc__clean_input 2609Func=DynamicFunc__setmode_unicode 2610Func=DynamicFunc__append_salt 2611Func=DynamicFunc__crypt_md5 2612Func=DynamicFunc__clean_input 2613Func=DynamicFunc__append_keys 2614Func=DynamicFunc__append_from_last_output_as_base16 2615Func=DynamicFunc__setmode_normal 2616Func=DynamicFunc__crypt_md5 2617Test=$dynamic_1056$34ba9cf3d8f61e6eb21942feb1164261$aabbccdd:test1 2618Test=$dynamic_1056$7b4fdbaab27929e18808c96e41b846f0$zzyyxxww:test3 2619 2620 2621[List.Generic:dynamic_1057] 2622Expression=dynamic_1057: md5(unicode($p).md5(unicode($s))) 2623Flag=MGF_SALTED 2624Flag=MGF_SALT_UNICODE_B4_CRYPT 2625Flag=MGF_SALT_AS_HEX 2626Func=DynamicFunc__clean_input 2627Func=DynamicFunc__setmode_unicode 2628Func=DynamicFunc__append_keys 2629Func=DynamicFunc__setmode_normal 2630Func=DynamicFunc__append_salt 2631Func=DynamicFunc__crypt_md5 2632Test=$dynamic_1057$34ba9cf3d8f61e6eb21942feb1164261$aabbccdd:test1 2633Test=$dynamic_1057$7b4fdbaab27929e18808c96e41b846f0$zzyyxxww:test3 2634 2635[List.Generic:dynamic_1058] 2636Expression=dynamic_1058: md5(unicode($p)) 2637Func=DynamicFunc__clean_input 2638Func=DynamicFunc__setmode_unicode 2639Func=DynamicFunc__append_keys 2640Func=DynamicFunc__crypt_md5 2641Test=$dynamic_1058$16c47151c18ac087cd12b3a70746c790:test1 2642Test=$dynamic_1058$537e738b1ac5551f65106368dc301ece:thatsworking 2643Test=$dynamic_1058$849ee1b88b5d887bdb058180a666b450:test3 2644 2645[List.Generic:dynamic_1059] 2646Expression=dynamic_1059: md5(md5(unicode($p))) 2647Func=DynamicFunc__clean_input 2648Func=DynamicFunc__setmode_unicode 2649Func=DynamicFunc__append_keys 2650Func=DynamicFunc__setmode_normal 2651Func=DynamicFunc__crypt_md5 2652Func=DynamicFunc__clean_input2_kwik 2653Func=DynamicFunc__append_from_last_output_to_input2_as_base16 2654Func=DynamicFunc__crypt_md5_in2_to_out1 2655Test=$dynamic_1059$ef1b8ee3ad8690fd1678093588727529:test1 2656Test=$dynamic_1059$18a7e5f289730525111f7b65cb223506:thatsworking 2657Test=$dynamic_1059$01a0359d0cabbf49a0b0a8a941c7f5ab:test3 2658 2659 2660[List.Generic:dynamic_1090] 2661Expression=md5(md5($p.$s).md5(md5($p).$s.md5($s.md5($s.$p))).md5(md5($s.$p.$p).$s.md5($p.md5($p.$s.$p))).$p.md5($s.$p.md5($s.$p.$s).$p.md5($s.$p.md5($p.$s.$s)))) 2662Flag=MGF_SALTED 2663Flag=MGF_NOTSSE2Safe 2664Func=DynamicFunc__clean_input 2665Func=DynamicFunc__append_keys 2666Func=DynamicFunc__append_salt 2667Func=DynamicFunc__crypt_md5 2668Func=DynamicFunc__clean_input 2669Func=DynamicFunc__append_from_last_output_as_base16 2670Func=DynamicFunc__clean_input2 2671Func=DynamicFunc__append_salt2 2672Func=DynamicFunc__append_keys2 2673Func=DynamicFunc__crypt2_md5 2674Func=DynamicFunc__clean_input2 2675Func=DynamicFunc__append_salt2 2676Func=DynamicFunc__append_from_last_output2_as_base16 2677Func=DynamicFunc__crypt2_md5 2678Func=DynamicFunc__clean_input2 2679Func=DynamicFunc__append_keys2 2680Func=DynamicFunc__crypt_in2_to_out1 2681Func=DynamicFunc__clean_input2 2682Func=DynamicFunc__append_from_last_output_to_input2_as_base16 2683Func=DynamicFunc__append_salt2 2684Func=DynamicFunc__append_from_last_output2_as_base16 2685Func=DynamicFunc__crypt2_md5 2686Func=DynamicFunc__append_from_last_output2_to_input1_as_base16 2687Func=DynamicFunc__clean_input2 2688Func=DynamicFunc__append_keys2 2689Func=DynamicFunc__append_salt2 2690Func=DynamicFunc__append_keys2 2691Func=DynamicFunc__crypt2_md5 2692Func=DynamicFunc__clean_input2 2693Func=DynamicFunc__append_keys2 2694Func=DynamicFunc__append_from_last_output2_as_base16 2695Func=DynamicFunc__crypt2_md5 2696Func=DynamicFunc__clean_input2 2697Func=DynamicFunc__append_salt2 2698Func=DynamicFunc__append_keys2 2699Func=DynamicFunc__append_keys2 2700Func=DynamicFunc__crypt_md5_in2_to_out1 2701Func=DynamicFunc__clean_input2 2702Func=DynamicFunc__append_from_last_output_to_input2_as_base16 2703Func=DynamicFunc__append_salt2 2704Func=DynamicFunc__append_from_last_output2_as_base16 2705Func=DynamicFunc__crypt2_md5 2706Func=DynamicFunc__append_from_last_output2_to_input1_as_base16 2707Func=DynamicFunc__append_keys 2708Func=DynamicFunc__clean_input2 2709Func=DynamicFunc__append_keys2 2710Func=DynamicFunc__append_salt2 2711Func=DynamicFunc__append_salt2 2712Func=DynamicFunc__crypt2_md5 2713Func=DynamicFunc__clean_input2 2714Func=DynamicFunc__append_salt2 2715Func=DynamicFunc__append_keys2 2716Func=DynamicFunc__append_from_last_output2_as_base16 2717Func=DynamicFunc__crypt2_md5 2718Func=DynamicFunc__clean_input2 2719Func=DynamicFunc__append_salt2 2720Func=DynamicFunc__append_keys2 2721Func=DynamicFunc__append_salt2 2722Func=DynamicFunc__crypt_md5_in2_to_out1 2723Func=DynamicFunc__clean_input2 2724Func=DynamicFunc__append_salt2 2725Func=DynamicFunc__append_keys2 2726Func=DynamicFunc__append_from_last_output_to_input2_as_base16 2727Func=DynamicFunc__append_keys2 2728Func=DynamicFunc__append_from_last_output2_as_base16 2729Func=DynamicFunc__crypt_in2_to_out1 2730Func=DynamicFunc__append_from_last_output_as_base16 2731Func=DynamicFunc__crypt_md5 2732Test=$dynamic_1090$e49995dd9328ba663e8839734aaef068$zRwIEOWX:hallo 2733 2734 2735[List.Generic:dynamic_1061] 2736Expression=dynamic_1061: md5($s.'-'.md5($p)) 2737Flag=MGF_SALTED 2738Func=DynamicFunc__clean_input 2739Func=DynamicFunc__append_keys 2740Func=DynamicFunc__crypt_md5 2741Func=DynamicFunc__clean_input 2742Func=DynamicFunc__append_salt 2743Func=DynamicFunc__append_input1_from_CONST1 2744Func=DynamicFunc__append_from_last_output_as_base16 2745Func=DynamicFunc__crypt_md5 2746Test=$dynamic_1061$7fc1aa71056429e9f773b2cde1106aee$salt1:test1 2747Test=$dynamic_1061$abdb2b7fbc78abaf475d3a5bb48b48bc$2tlas:testword2 2748CONST1=- 2749 2750# md5(sha1($p)) 2751[List.Generic:dynamic_1062] 2752Expression=dynamic_1062: md5(sha1($p)) 2753Flag=MGF_StartInX86Mode 2754Flag=MGF_KEYS_INPUT_BE_SAFE 2755Func=DynamicFunc__clean_input2_kwik 2756Func=DynamicFunc__SHA1_crypt_md5_input1_append_input2_base16 2757Func=DynamicFunc__X86toSSE_switch_input2 2758Func=DynamicFunc__crypt_md5_in2_to_out1 2759Test=$dynamic_1062$a7168f0f249e3add33da11a59e228a57:test1 2760Test=$dynamic_1062$067dda3ad565339fffa61ba74fab0ba3:thatsworking 2761Test=$dynamic_1062$71a1083be5c288da7e57b8c2bd7cbc96:test3 2762 2763# sha1(md5($p)) 2764[List.Generic:dynamic_1063] 2765Expression=dynamic_1063: sha1(md5($p)) 2766Flag=MGF_KEYS_INPUT 2767Flag=MGF_INPUT_20_BYTE 2768Func=DynamicFunc__crypt_md5 2769Func=DynamicFunc__SSEtoX86_switch_output1 2770Func=DynamicFunc__clean_input2 2771Func=DynamicFunc__append_from_last_output_to_input2_as_base16 2772Func=DynamicFunc__SHA1_crypt_md5_input2_to_output1_FINAL 2773Test=$dynamic_1063$81d84525eb1499d518cf3cb3efcbe1d11c4ccf25:test1 2774Test=$dynamic_1063$6cd62e1767b65eec58d687de6d9c08a828018254:thatsworking 2775Test=$dynamic_1063$7d653cf00d747a9fbab213b6c2b335cfe8199ff3:test3 2776 2777 2778# sha1($p) 2779[List.Generic:dynamic_1064] 2780Expression=dynamic_1064: sha1($p) 2781Flag=MGF_INPUT_20_BYTE 2782Flag=MGF_FLAT_BUFFERS 2783Func=DynamicFunc__SHA1_crypt_md5_input1_to_output1_FINAL 2784Test=$dynamic_1064$b444ac06613fc8d63795be9ad0beaf55011936ac:test1 2785Test=$dynamic_1064$1068db2941b46d12f790df99d72fe8c2eb6d3aaf:thatsworking 2786Test=$dynamic_1064$3ebfa301dc59196f18593c45e519287a23297589:test3 2787 2788[List.Generic:dynamic_1165] 2789Expression=dynamic_1165: md5(sha1(md5(sha1($p)))) 2790Flag=MGF_StartInX86Mode 2791Func=DynamicFunc__clean_input 2792Func=DynamicFunc__clean_input2 2793Func=DynamicFunc__append_keys 2794Func=DynamicFunc__SHA1_crypt_md5_input1_append_input2_base16 2795Func=DynamicFunc__X86toSSE_switch_input2 2796Func=DynamicFunc__crypt_md5_in2_to_out1 2797Func=DynamicFunc__SSEtoX86_switch_output1 2798Func=DynamicFunc__clean_input 2799Func=DynamicFunc__append_from_last_output_as_base16 2800Func=DynamicFunc__clean_input2 2801Func=DynamicFunc__SHA1_crypt_md5_input1_append_input2_base16 2802Func=DynamicFunc__X86toSSE_switch_input2 2803Func=DynamicFunc__crypt_md5_in2_to_out1 2804Test=$dynamic_1165$62f2dd3da9a39eea4314b846aaa02a3d:test1 2805Test=$dynamic_1165$288f19a5a0967ef40d8e9ebfef79b0ea:thatsworking 2806Test=$dynamic_1165$72a4064912ccaea4b982b3e9fc710cd7:test3 2807 2808[List.Generic:dynamic_1066] 2809Expression=dynamic_1066: sha1($p.$s) 2810Flag=MGF_NOTSSE2Safe 2811Flag=MGF_SALTED 2812Flag=MGF_INPUT_20_BYTE 2813Func=DynamicFunc__clean_input 2814Func=DynamicFunc__append_keys 2815Func=DynamicFunc__append_salt 2816Func=DynamicFunc__SHA1_crypt_md5_input1_to_output1_FINAL 2817Test=$dynamic_1066$5a12479f0a8286a832288e1dc2ea9b2eda4e382d$sG:test1 2818Test=$dynamic_1066$c72b6f1caddb158831cab0b08d29243ea20fc869$xxRW:thatsworking 2819Test=$dynamic_1066$b966eff1aac95e92818a7c59326cce297b935eff$s3xx:test3 2820 2821[List.Generic:dynamic_1067] 2822Expression=dynamic_1067: sha1($s.$p) 2823Flag=MGF_NOTSSE2Safe 2824Flag=MGF_SALTED 2825Flag=MGF_INPUT_20_BYTE 2826Func=DynamicFunc__clean_input 2827Func=DynamicFunc__append_salt 2828Func=DynamicFunc__append_keys 2829Func=DynamicFunc__SHA1_crypt_md5_input1_to_output1_FINAL 2830Test=$dynamic_1067$f5266f29ff7f1ea6fc30085c8347fcf6a6e36e9c$sG:test1 2831Test=$dynamic_1067$a34af873d9047541b4d76ceae7b391f0664ca99e$xxRW:thatsworking 2832Test=$dynamic_1067$f0058038be0e821caa3031b463aed00fbe7e3beb$s3xx:test3 2833 2834[List.Generic:dynamic_1068] 2835Expression=dynamic_1068: sha1(sha1($p)) 2836Flag=MGF_NOTSSE2Safe 2837Flag=MGF_INPUT_20_BYTE 2838Func=DynamicFunc__clean_input 2839Func=DynamicFunc__clean_input2 2840Func=DynamicFunc__append_keys 2841Func=DynamicFunc__SHA1_crypt_md5_input1_append_input2_base16 2842Func=DynamicFunc__SHA1_crypt_md5_input2_to_output1_FINAL 2843Test=$dynamic_1068$2a367cbb171d78d293f40fd7d1defb31e3fb1728:test1 2844Test=$dynamic_1068$d3e0a4d2f3ec196a79ab2890c65144c20ff24ed8:thatsworking 2845Test=$dynamic_1068$b13773cfee62f832cacb618b257feec972f30b13:test3 2846 2847[List.Generic:dynamic_1069] 2848Expression=dynamic_1069: sha1(sha1($p)) 2849Flag=MGF_NOTSSE2Safe 2850Flag=MGF_INPUT_20_BYTE 2851Func=DynamicFunc__clean_input 2852Func=DynamicFunc__clean_input2 2853Func=DynamicFunc__append_keys 2854Func=DynamicFunc__SHA1_crypt_md5_input1_append_input2_base16 2855Func=DynamicFunc__SHA1_crypt_md5_input2_overwrite_input2_base16 2856Func=DynamicFunc__SHA1_crypt_md5_input2_to_output1_FINAL 2857Test=$dynamic_1069$00aeb6dc5e6269a6b2f39728cd8a6812a644dae6:test1 2858Test=$dynamic_1069$d60112917380bb0641f5d1a4ce8fb77e958452f7:thatsworking 2859Test=$dynamic_1069$54e45916fb79f7be1c695828fdba44915b50751e:test3 2860 2861[List.Generic:dynamic_1065] 2862Expression=dynamic_1065: md5(sha1(md5(sha1($p)))) 2863Flag=MGF_StartInX86Mode 2864Flag=MGF_KEYS_INPUT_BE_SAFE 2865Func=DynamicFunc__clean_input2 2866Func=DynamicFunc__SHA1_crypt_input1_append_input2_base16 2867Func=DynamicFunc__X86toSSE_switch_input2 2868Func=DynamicFunc__crypt_md5_in2_to_out1 2869Func=DynamicFunc__SSEtoX86_switch_output1 2870Func=DynamicFunc__clean_input2 2871Func=DynamicFunc__append_from_last_output_to_input2_as_base16 2872Func=DynamicFunc__SHA1_crypt_input2_overwrite_input2_base16 2873Func=DynamicFunc__X86toSSE_switch_input2 2874Func=DynamicFunc__crypt_md5_in2_to_out1 2875Test=$dynamic_1065$62f2dd3da9a39eea4314b846aaa02a3d:test1 2876Test=$dynamic_1065$288f19a5a0967ef40d8e9ebfef79b0ea:thatsworking 2877Test=$dynamic_1065$72a4064912ccaea4b982b3e9fc710cd7:test3 2878 2879[List.Generic:dynamic_1070] 2880Expression=dynamic_1070: sha1(upr($u).':'.$p) 2881Flag=MGF_NOTSSE2Safe 2882Flag=MGF_INPUT_20_BYTE 2883Flag=MGF_USERNAME_UPCASE 2884Func=DynamicFunc__clean_input 2885Func=DynamicFunc__clean_input2 2886Func=DynamicFunc__append_userid 2887Func=DynamicFunc__append_input1_from_CONST1 2888Func=DynamicFunc__append_keys 2889Func=DynamicFunc__SHA1_crypt_input1_to_output1_FINAL 2890Test=$dynamic_1070$20fa5cf803e363ba9f13e12ca61586e2efabc737$$UROOT:test1 2891Test=$dynamic_1070$2e839b0c32af0e2099584ea22f20d2f2c477d908$$UJAS0N:thatsworking 2892Test=$dynamic_1070$55496ed9edcabdd2368e7cd22eaae633c6d6c40e$$UJOEBLOW:test3 2893CONST1=: 2894 2895# this format is unicode raw-md5. It shows the TestA= and TestU=. These will only 2896# be loaded depending upon --encoding=utf-8. If that is not present, then the TestA= 2897# lines are loaded. If --encoding=utf-8 IS set, then the TestU= lines are loaded. 2898# the Test= lines are always loaded. 2899[List.Generic:dynamic_1100] 2900Expression=md5(unicode($p)) [rawmd5-unicode utf-8 input)] 2901Flag=MGF_UTF8 2902Func=DynamicFunc__clean_input 2903Func=DynamicFunc__setmode_unicode 2904Func=DynamicFunc__append_keys 2905Func=DynamicFunc__crypt_md5 2906TestU=$dynamic_1100$94a4e171de16580742c4d141e6607bf7:\xE2\x82\xAC 2907TestU=$dynamic_1400$03c60810f0e54d16e826aca385d776c8:\xE2\x82\xAC\xE2\x82\xAC 2908TestU=$dynamic_1100$2d554433d7cde7ec8d16aaf126c3be6b:\xE2\x82\xAC\xC3\xBC 2909TestU=$dynamic_1100$8007d9070b27db7b30433df2cd10abc1:\xC3\xBC\xE2\x82\xAC 2910TestA=$dynamic_1100$ea7ab2b5c07650badab30790d0c9b63e:\xFC 2911TestA=$dynamic_1100$f0a0b9f1dea0e458cec9a284ff434d44:\xFC\xFC 2912TestA=$dynamic_1100$d25a0b436b768777cc9a343d283dbf5a:\xFC\xFC\xFC 2913TestA=$dynamic_1100$719917322bf12168f8c55939e4fec8de:\xFC\xFC\xFC\xFC 2914Test=$dynamic_1100$16c47151c18ac087cd12b3a70746c790:test1 2915Test=$dynamic_1100$d41d8cd98f00b204e9800998ecf8427e: 2916Test=$dynamic_1100$9c3abef89ff76f8acd80eae37b35f64f:test2 2917Test=$dynamic_1100$849ee1b88b5d887bdb058180a666b450:test3 2918Test=$dynamic_1100$8c4cb7e8b33b56a833cdaa8673f3b425:test4 2919Test=$dynamic_1100$537e738b1ac5551f65106368dc301ece:thatsworking 2920 2921#################################################################### 2922# sha1(UTF16LE($p)) 2923#################################################################### 2924[List.Generic:dynamic_1101] 2925Expression=sha1(unicode($p)) 2926Flag=MGF_INPUT_20_BYTE 2927Func=DynamicFunc__clean_input 2928Func=DynamicFunc__setmode_unicode 2929Func=DynamicFunc__append_keys 2930Func=DynamicFunc__SHA1_crypt_input1_to_output1_FINAL 2931Test=$dynamic_1101$87f8ed9157125ffc4da9e06a7b8011ad80a53fe1:test 2932Test=$dynamic_1101$28f69840b617ece11b24fcb4bd380f6aa4569d60:thatsworking 2933Test=$dynamic_1101$ab7a9c43394b8631a2947e064efeb19a48c5ed89:test3 2934 2935[List.Generic:dynamic_1400] 2936Expression=md5($s.:asterisk:.$p) [Asterisk SIP] 2937Flag=MGF_SALTED 2938Func=DynamicFunc__clean_input 2939Func=DynamicFunc__append_salt 2940Func=DynamicFunc__append_input1_from_CONST1 2941Func=DynamicFunc__append_keys 2942Func=DynamicFunc__crypt_md5 2943CONST1=:asterisk: 2944Test=$dynamic_1400$4a8e71480c5b1ef0a5d502a8eb98576a$1234:abcd 2945 2946[List.Generic:dynamic_1401] 2947Expression=md5($u.:asterisk:.$p) [Asterisk SIP] 2948Flag=MGF_USERNAME 2949Func=DynamicFunc__clean_input 2950Func=DynamicFunc__append_userid 2951Func=DynamicFunc__append_input1_from_CONST1 2952Func=DynamicFunc__append_keys 2953Func=DynamicFunc__crypt_md5 2954CONST1=:asterisk: 2955Test=$dynamic_1401$4a8e71480c5b1ef0a5d502a8eb98576a:abcd:1234 2956 2957[List.Generic:dynamic_1403] 2958Expression=dynamic_1403: sha1(upr($u).':'.$p) 2959Flag=MGF_INPUT_20_BYTE 2960Flag=MGF_USERNAME_UPCASE 2961Func=DynamicFunc__clean_input 2962Func=DynamicFunc__clean_input2 2963Func=DynamicFunc__append_userid 2964Func=DynamicFunc__append_input1_from_CONST1 2965Func=DynamicFunc__append_keys 2966Func=DynamicFunc__SHA1_crypt_input1_to_output1_FINAL 2967Test=$dynamic_1403$20fa5cf803e363ba9f13e12ca61586e2efabc737$$UROOT:test1 2968Test=$dynamic_1403$2e839b0c32af0e2099584ea22f20d2f2c477d908$$UJAS0N:thatsworking 2969Test=$dynamic_1403$55496ed9edcabdd2368e7cd22eaae633c6d6c40e$$UJOEBLOW:test3 2970Test=$dynamic_1403$20fa5cf803e363ba9f13e12ca61586e2efabc737:test1:root 2971CONST1=: 2972 2973[List.Generic:dynamic_1404] 2974Expression=dynamic_1404: md5($s.':'.upr($p)) 2975Flag=MGF_SALTED 2976Flag=MGF_PASSWORD_UPCASE 2977Func=DynamicFunc__clean_input 2978Func=DynamicFunc__append_salt 2979Func=DynamicFunc__append_input1_from_CONST1 2980Func=DynamicFunc__append_keys 2981Func=DynamicFunc__crypt_md5 2982Test=$dynamic_1404$d097de40a351866a024e6ba9ce2595eb$f8sKST:TEST1 2983Test=$dynamic_1404$496ff0193acd6b92f92f9a8e05d3f2f2$tVJ9Gu:TESTLONG 2984Test=$dynamic_1404$67557c91c31c1803a9fd55454ca102fe$IIpTKQ:HAPPY 2985Test=$dynamic_1404$d097de40a351866a024e6ba9ce2595eb$f8sKST:TEST1 2986CONST1=: 2987 2988#################################################################### 2989#################################################################### 2990# END of DYNAMIC examples 2991#################################################################### 2992#################################################################### 2993