diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..f00268c --- /dev/null +++ b/.gitignore @@ -0,0 +1,27 @@ +# Byte-compiled / optimized files +__pycache__/ +*.py[cod] +*$py.class + +# Packaging / build artifacts +build/ +dist/ +*.egg-info/ +.eggs/ + +# Virtual environments +.venv/ +venv/ +env/ + +# PACK output files +*.rule +*.word +*.masks +*.hcmask + +# Editor / OS cruft +.idea/ +.vscode/ +*.swp +.DS_Store diff --git a/README b/README deleted file mode 100644 index 304fc69..0000000 --- a/README +++ /dev/null @@ -1,677 +0,0 @@ -Password Analysis and Cracking Kit by Peter Kacherginsky (iphelix) -================================================================== - -PACK (Password Analysis and Cracking Toolkit) is a collection of utilities developed to aid in analysis of password lists in order to enhance password cracking through pattern detection of masks, rules, character-sets and other password characteristics. The toolkit generates valid input files for Hashcat family of password crackers. - -NOTE: The toolkit itself is not able to crack passwords, but instead designed to make operation of password crackers more efficient. - -Selecting passwords lists for analysis -====================================== - -Before we can begin using the toolkit we must establish a selection criteria of password lists. Since we are looking to analyze the way people create their passwords, we must obtain as large of a sample of leaked passwords as possible. One such excellent list is based on RockYou.com compromise. This list both provides large and diverse enough collection that provides a good results for common passwords used by similar sites (e.g. social networking). The analysis obtained from this list may not work for organizations with specific password policies. As such, selecting sample input should be as close to your target as possible. In addition, try to avoid obtaining lists based on already cracked passwords as it will generate statistics bias of rules and masks used by individual(s) cracking the list and not actual users. - -StatsGen -======================================= - -The most basic analysis that you can perform is simply obtaining most common length, character-set and other characteristics of passwords in the provided list. In the example below, we will use 'rockyou.txt' containing approximately 14 million passwords. Launch `statsgen.py` with the following command line: - - $ python statsgen.py rockyou.txt - -Below is the output from the above command: - - _ - StatsGen #.#.# | | - _ __ __ _ ___| | _ - | '_ \ / _` |/ __| |/ / - | |_) | (_| | (__| < - | .__/ \__,_|\___|_|\_\ - | | - |_| iphelix@thesprawl.org - - - [*] Analyzing passwords in [rockyou.txt] - [+] Analyzing 100% (14344390/14344390) of passwords - NOTE: Statistics below is relative to the number of analyzed passwords, not total number of passwords - - [*] Length: - [+] 8: 20% (2966037) - [+] 7: 17% (2506271) - [+] 9: 15% (2191039) - [+] 10: 14% (2013695) - [+] 6: 13% (1947798) - ... - - [*] Character-set: - [+] loweralphanum: 42% (6074867) - [+] loweralpha: 25% (3726129) - [+] numeric: 16% (2346744) - [+] loweralphaspecialnum: 02% (426353) - [+] upperalphanum: 02% (407431) - ... - - [*] Password complexity: - [+] digit: min(0) max(255) - [+] lower: min(0) max(255) - [+] upper: min(0) max(187) - [+] special: min(0) max(255) - - [*] Simple Masks: - [+] stringdigit: 37% (5339556) - [+] string: 28% (4115314) - [+] digit: 16% (2346744) - [+] digitstring: 04% (663951) - [+] othermask: 04% (576324) - ... - - [*] Advanced Masks: - [+] ?l?l?l?l?l?l?l?l: 04% (687991) - [+] ?l?l?l?l?l?l: 04% (601152) - [+] ?l?l?l?l?l?l?l: 04% (585013) - [+] ?l?l?l?l?l?l?l?l?l: 03% (516830) - [+] ?d?d?d?d?d?d?d: 03% (487429) - ... - - -NOTE: You can reduce the number of outliers displayed by including the --hiderare flag which will not show any items with occurrence of less than 1%. - -Here is what we can immediately learn from the above list: - - * Most of the passwords have length 6 to 10 characters. - * The majority of passwords have loweralphanumeric character-set. - * There is no obvious minimum or maximum password complexity. - * Analyzed passwords tend to follow a simple masks "string followed by digits". - -The last section, "Advanced Masks", contains most frequently occurring masks using the Hashcat format. Individual symbols can be interpreted as follows: - - ?l - a single lowercase character - ?u - a single uppercase character - ?d - a single digit - ?s - a single special character - -For example, the very first mask, "?l?l?l?l?l?l?l?l", will match all of the lowercase alpha passwords. Given the sample size you will be able to crack approximately 4% of passwords. However, after generating the initial output, you may be interested in using filters to narrow down on password data. - -Using filters -------------- - -Let's see how RockYou users tend to select their passwords using the "stringdigit" simple mask (a string followed by numbers): - - $ python statsgen.py ../PACK-0.0.3/archive/rockyou.txt --simplemask stringdigit -q --hiderare - - [*] Analyzing passwords in [rockyou.txt] - [+] Analyzing 37% (5339556/14344390) of passwords - NOTE: Statistics below is relative to the number of analyzed passwords, not total number of passwords - - [*] Length: - [+] 8: 23% (1267260) - [+] 7: 18% (981432) - [+] 9: 17% (939971) - [+] 10: 14% (750938) - [+] 6: 11% (618983) - [+] 11: 05% (294869) - [+] 12: 03% (175875) - [+] 13: 01% (103047) - [+] 14: 01% (65958) - - [*] Character-set: - [+] loweralphanum: 88% (4720184) - [+] upperalphanum: 06% (325941) - [+] mixedalphanum: 05% (293431) - - [*] Password complexity: - [+] digit: min(1) max(252) - [+] lower: min(0) max(46) - [+] upper: min(0) max(31) - [+] special: min(0) max(0) - - [*] Simple Masks: - [+] stringdigit: 100% (5339556) - - [*] Advanced Masks: - [+] ?l?l?l?l?l?l?d?d: 07% (420318) - [+] ?l?l?l?l?l?d?d: 05% (292306) - [+] ?l?l?l?l?l?l?l?d?d: 05% (273624) - [+] ?l?l?l?l?d?d?d?d: 04% (235360) - [+] ?l?l?l?l?d?d: 04% (215074) - ... - -The very top of the output specifies what percentage of total passwords was analyzed. In this case, by cracking only passwords matching the "stringdigit" mask it is only possible to recover about 37% of the total set just as was displayed in the original output. Next, it appears that only 11% of this password type use anything other than lowercase. So it would be smart to concentrate on only lowercase strings matching this mask. At last, in the "Advanced Mask" section we can see that the majority of "stringdigit" passwords consist of a string with two or four digits following it. With the information gained from the above output, we can begin creating a mental image of target users' password generation patterns. - -There are a few other filters available for password length, mask, and character sets: - -**Length:** --minlength and/or --maxlength - -**Simple Mask:** --simplemask [numeric, loweralpha, upperalpha, mixedalpha, loweralphanum, etc.] - -**Character sets:** --charset [digit, string, stringdigit, digitstring, digitstringdigit, etc.] - -NOTE: More than one filter of the same class can be specified as a comma-separated list: - - --simplemask="stringdigit,digitstring" - -Saving advanced masks ---------------------- - -While the "Advanced Mask" section only displays patterns matching greater than 1% of all passwords, you can obtain and save a full list of password masks matching a given dictionary by using the following command: - - $ python statsgen.py rockyou.txt -o rockyou.masks - -All of the password masks and their frequencies will be saved into the specified file in the CSV format. Naturally, you can provide filters to only generate masks file matching specified parameters. The output file can be used as an input to MaskGen tool covered in the next section. - -MaskGen -================== - -MaskGen allows you to craft pattern-based mask attacks for input into Hashcat family of password crackers. The tool uses output produced by statsgen above with the '-o' flag in order to produce the most optimal mask attack sorted by mask complexity, mask occurrence or ratio of the two (optimal index). - -Let's run MaskGen with only StatGen's output as an argument: - - $ python maskgen.py rockyou.masks - - _ - MaskGen #.#.# | | - _ __ __ _ ___| | _ - | '_ \ / _` |/ __| |/ / - | |_) | (_| | (__| < - | .__/ \__,_|\___|_|\_\ - | | - |_| iphelix@thesprawl.org - - - [*] Analyzing masks in [rockyou.masks] - [*] Using 1,000,000,000 keys/sec for calculations. - [*] Sorting masks by their [optindex]. - [*] Finished generating masks: - Masks generated: 146578 - Masks coverage: 100% (14344390/14344390) - Masks runtime: >1 year - -There are several pieces of information that you should observe: - - * Default cracking speed used for calculations is 1,000,000,000 keys/sec - * Default sorting mode is [optindex] equivalent to --optindex flag. - * 146,578 unique masks were generated which have 100% coverage - * Total runtime of all generated masks is more than 1 year. - -Specifying target time ----------------------- - -Since you are usually limited in time to perform and craft attacks, maskgen allows you to specify how much time you have to perform mask attacks and will generate the most optimal collection of masks based on the sorting mode. Let's play a bit with different sorting modes and target times: - - $ python maskgen.py rockyou.masks --targettime 600 --optindex -q - [*] Analyzing masks in [rockyou.masks] - [*] Using 1,000,000,000 keys/sec for calculations. - [*] Sorting masks by their [optindex]. - [!] Target time exceeded. - [*] Finished generating masks: - Masks generated: 779 - Masks coverage: 56% (8116195/14344390) - Masks runtime: 0:11:36 - - - $ python maskgen.py rockyou.masks --targettime 600 --complexity -q - [*] Analyzing masks in [rockyou.masks] - [*] Using 1,000,000,000 keys/sec for calculations. - [*] Sorting masks by their [complexity]. - [!] Target time exceeded. - [*] Finished generating masks: - Masks generated: 5163 - Masks coverage: 31% (4572346/14344390) - Masks runtime: 0:10:01 - - - $ python maskgen.py rockyou.masks --targettime 600 --occurrence -q - [*] Analyzing masks in [rockyou.masks] - [*] Using 1,000,000,000 keys/sec for calculations. - [*] Sorting masks by their [occurrence]. - [!] Target time exceeded. - [*] Finished generating masks: - Masks generated: 4 - Masks coverage: 16% (2390986/14344390) - Masks runtime: 1:34:05 - -All of the above runs have target time of 600 seconds (or 10 minutes) with different sorting modes. Based on our experiments, masks generated using OptIndex sorting mode can crack 56% of RockYou passwords in about 10 minutes. At the same time masks generated using Occurrence sorting mode not only have pretty weak coverage of only 16%, but also exceeded specified target time by more than an hour. - -NOTE: Masks sorted by complexity can be very effective when attacking policy based lists. - -Let's see some of the masks generated by maskgen in optindex mode using the --showmasks flag: - - $ python maskgen.py rockyou.masks --targettime 43200 --optindex -q --showmasks - [*] Analyzing masks in [rockyou.masks] - [*] Using 1,000,000,000 keys/sec for calculations. - [*] Sorting masks by their [optindex]. - [L:] Mask: [ Occ: ] [ Time: ] - ... - [ 7] ?l?d?s?l?l?d?d [6 ] [ 0:00:00] - [ 8] ?s?l?l?l?l?l?l?s [3480 ] [ 0:05:36] - [ 9] ?l?l?l?l?d?d?d?d?s [1553 ] [ 0:02:30] - [ 8] ?d?l?d?d?d?l?l?l [47 ] [ 0:00:04] - [ 8] ?d?l?l?d?l?d?d?l [47 ] [ 0:00:04] - [ 8] ?d?l?l?d?d?l?d?l [47 ] [ 0:00:04] - [ 8] ?d?l?d?l?d?d?l?l [47 ] [ 0:00:04] - [ 8] ?d?d?l?l?d?l?d?l [47 ] [ 0:00:04] - [ 8] ?d?l?d?d?l?l?l?l [122 ] [ 0:00:11] - [ 8] ?u?u?d?u?d?d?d?d [18 ] [ 0:00:01] - [ 6] ?d?s?s?s?s?s [4 ] [ 0:00:00] - [10] ?l?l?l?l?l?l?l?l?d?d [213109 ] [ 5:48:02] - [!] Target time exceeded. - [*] Finished generating masks: - Masks generated: 3970 - Masks coverage: 74% (10620959/14344390) - Masks runtime: 16:10:38 - -Displayed masks follow a pretty intuitive format: - - - [ 9] ?l?l?l?l?d?d?d?d?s [1553 ] [ 0:02:30] - \ \ \ \ - \ \_ generated mask \ \_ mask runtime - \ \ - \_ mask length \_ mask occurrence - - -In the above sample you can see some of the logic that goes into mask generation. For example, while '?s?l?l?l?l?l?l?s' mask has one of the longest runtimes in the sample (5 minutes), it still has higher priority because of its relatively higher occurrence to '?l?l?l?l?d?d?d?d?s'. At the same time, while '?l?d?s?l?l?d?d' has pretty low coverage it still gets a higher priority than other masks because as only a six character mask it executes very quickly. - -Specifying mask filters ------------------------ - -You can further optimize your generated mask attacks by using filters. For example, you may have sufficiently powerful hardware where you can simple bruteforce all of the passwords up to 8 characters. In this case, you can generate masks only greater than 8 characters using the --minlength flag as follows: - - $ python maskgen.py rockyou.masks --targettime 43200 --optindex -q --minlength 8 - [*] Analyzing masks in [rockyou.masks] - [*] Using 1,000,000,000 keys/sec for calculations. - [*] Sorting masks by their [optindex]. - [!] Target time exceeded. - [*] Finished generating masks: - Masks generated: 585 - Masks coverage: 41% (5905182/14344390) - Masks runtime: 15:50:36 - -Naturally the generated mask coverage was reduced, but these filters become useful when preparing a collection of masks when attacking password lists other than the one used to generate them. - -The list below shows additional filters you can use: - - Individual Mask Filter Options: - --minlength=8 Minimum password length - --maxlength=8 Maximum password length - --mintime=3600 Minimum mask runtime (seconds) - --maxtime=3600 Maximum mask runtime (seconds) - --mincomplexity=1 Minimum complexity - --maxcomplexity=100 - Maximum complexity - --minoccurrence=1 Minimum occurrence - --maxoccurrence=100 - Maximum occurrence - -Occurrrence and complexity flags can be particularly powerful to fine-tune generated masks using different sorting modes. - -Saving generated masks ----------------------- - -Once you are satisfied with the above generated masks, you can save them using the -o flag: - - $ python maskgen.py rockyou.masks --targettime 43200 --optindex -q -o rockyou.hcmask - [*] Analyzing masks in [rockyou.masks] - [*] Saving generated masks to [rockyou.hcmask] - [*] Using 1,000,000,000 keys/sec for calculations. - [*] Sorting masks by their [optindex]. - [!] Target time exceeded. - [*] Finished generating masks: - Masks generated: 3970 - Masks coverage: 74% (10620959/14344390) - Masks runtime: 16:10:38 - -This will produce 'rockyou.hcmask' file which can be directly used by Hashcat suite of tools or as part of a custom script that loops through them. - -Checking mask coverage ----------------------- - -It is often useful to see how well generated masks perform against already cracked lists. Maskgen can compare a collection of masks against others to see how well they would perform if masks from one password list would be attempted against another. Let's compare how well masks generated from RockYou list will perform against another compromised list such as Gawker: - - $ python statsgen.py ../PACK-0.0.3/archive/gawker.dic -o gawker.masks - - $ python maskgen.py gawker.masks --checkmasksfile rockyou.hcmask -q - [*] Analyzing masks in [gawker.masks] - [*] Using 1,000,000,000 keys/sec for calculations. - [*] Checking coverage of masks in [rockyou.hcmask] - [*] Finished matching masks: - Masks matched: 1775 - Masks coverage: 96% (1048889/1084394) - Masks runtime: 16:25:44 - -Using the '--checkmasksfile' parameter we attempted to run masks inside 'rockyou.hcmask' file generated earlier against masks from a sample leaked list 'gawker.masks'. This results in a good 96% coverage where 1775 of the 3970 total generated RockYou-based masks matched masks in Gawker list. - -It is also possible to see the coverage of one or more masks by specifying them directly on the command-line as follows: - - $ python maskgen.py gawker.masks --checkmasks="?u?l?l?l?l?l?d,?l?l?l?l?l?d?d" -q - [*] Analyzing masks in [gawker.masks] - [*] Using 1,000,000,000 keys/sec for calculations. - [*] Checking coverage of the these masks [?u?l?l?l?l?l?d, ?l?l?l?l?l?d?d] - [*] Finished matching masks: - Masks matched: 2 - Masks coverage: 1% (18144/1084394) - Masks runtime: 0:00:04 - -Both of the specified masks matched with only 1% coverage. - -Specifying speed ----------------- - -Depending on your exact hardware specs and target hash you may want to increase or decrease keys/sec speed used during calculations using the '--pps' parameter: - - $ python maskgen.py rockyou.masks --targettime 43200 --pps 50000000 -q - [*] Analyzing masks in [rockyou.masks] - [*] Using 50,000,000 keys/sec for calculations. - [*] Sorting masks by their [optindex]. - [!] Target time exceeded. - [*] Finished generating masks: - Masks generated: 1192 - Masks coverage: 61% (8754548/14344390) - Masks runtime: 12:17:31 - -Using the '--pps' parameter to match you actual performance makes target time more meaningful. - -PolicyGen -========= - -A lot of the mask and dictionary attacks will fail in the corporate environment with minimum password complexity requirements. Instead of resorting to a pure bruteforcing attack, we can leverage known or guessed password complexity rules to avoid trying password candidates that are not compliant with the policy or inversely only audit for noncompliant passwords. Using PolicyGen, you will be able to generate a collection of masks following the password complexity in order to significantly reduce the cracking time. - -Below is a sample session where we generate all valid password masks for an environment requiring at least one digit, one upper, and one special characters. - - $ python policygen.py --minlength 8 --maxlength 8 --minlower 1 --minupper 1 --mindigit 1 --minspecial 1 -o complexity.hcmask - _ - PolicyGen #.#.# | | - _ __ __ _ ___| | _ - | '_ \ / _` |/ __| |/ / - | |_) | (_| | (__| < - | .__/ \__,_|\___|_|\_\ - | | - |_| iphelix@thesprawl.org - - - [*] Saving generated masks to [complexity.hcmask] - [*] Using 1,000,000,000 keys/sec for calculations. - [*] Password policy: - Pass Lengths: min:8 max:8 - Min strength: l:1 u:1 d:1 s:1 - Max strength: l:None u:None d:None s:None - [*] Generating [compliant] masks. - [*] Generating 8 character password masks. - [*] Total Masks: 65536 Time: 76 days, 18:50:04 - [*] Policy Masks: 40824 Time: 35 days, 0:33:09 - -From the above output you can see that we have generated 40824 masks matching the specified complexity that will take about 35 days to run at the speed of 1,000,000,000 keys/sec. - -In case you are simply performing a password audit and tasked to discover only non-compliant passwords you can specify '--noncompliant' flag to invert generated masks: - - $ python policygen.py --minlength 8 --maxlength 8 --minlower 1 --minupper 1 --mindigit 1 --minspecial 1 -o noncompliant.hcmask -q --noncompliant - [*] Saving generated masks to [noncompliant.hcmask] - [*] Using 1,000,000,000 keys/sec for calculations. - [*] Password policy: - Pass Lengths: min:8 max:8 - Min strength: l:1 u:1 d:1 s:1 - Max strength: l:None u:None d:None s:None - [*] Generating [non-compliant] masks. - [*] Generating 8 character password masks. - [*] Total Masks: 65536 Time: 76 days, 18:50:04 - [*] Policy Masks: 24712 Time: 41 days, 18:16:55 - -Let's see some of the non-compliant masks generated above using the '--showmasks' flag: - - $ python policygen.py --minlength 8 --maxlength 8 --minlower 1 --minupper 1 --mindigit 1 --minspecial 1 -o noncompliant.hcmask -q --noncompliant --showmasks - [*] Saving generated masks to [noncompliant.hcmask] - [*] Using 1,000,000,000 keys/sec for calculations. - [*] Password policy: - Pass Lengths: min:8 max:8 - Min strength: l:1 u:1 d:1 s:1 - Max strength: l:None u:None d:None s:None - [*] Generating [non-compliant] masks. - [*] Generating 8 character password masks. - [ 8] ?d?d?d?d?d?d?d?d [l: 0 u: 0 d: 8 s: 0] [ 0:00:00] - [ 8] ?d?d?d?d?d?d?d?l [l: 1 u: 0 d: 7 s: 0] [ 0:00:00] - [ 8] ?d?d?d?d?d?d?d?u [l: 0 u: 1 d: 7 s: 0] [ 0:00:00] - [ 8] ?d?d?d?d?d?d?d?s [l: 0 u: 0 d: 7 s: 1] [ 0:00:00] - ... - [ 8] ?s?s?s?s?s?s?s?d [l: 0 u: 0 d: 1 s: 7] [ 0:07:06] - [ 8] ?s?s?s?s?s?s?s?l [l: 1 u: 0 d: 0 s: 7] [ 0:18:28] - [ 8] ?s?s?s?s?s?s?s?u [l: 0 u: 1 d: 0 s: 7] [ 0:18:28] - [ 8] ?s?s?s?s?s?s?s?s [l: 0 u: 0 d: 0 s: 8] [ 0:23:26] - [*] Total Masks: 65536 Time: 76 days, 18:50:04 - [*] Policy Masks: 24712 Time: 41 days, 18:16:55 - -As you can see all of the masks have at least one missing password complexity requirement. Interestingly with fewer generated masks it takes longer to attack because of long running masks like '?s?s?s?s?s?s?s?s'. - -Specifying maximum complexity ------------------------------ - -It is also possible to specify maximum password complexity using --maxlower, --maxupper, --maxdigit and --maxspecial flags in order to fine-tune you attack. For example, below is a sample site which enforces password policy but does not allow any special characters: - - $ python policygen.py --minlength 8 --maxlength 8 --minlower 1 --minupper 1 --mindigit 1 --maxspecial 0 -o maxcomplexity.hcmask -q - [*] Saving generated masks to [maxcomplexity.hcmask] - [*] Using 1,000,000,000 keys/sec for calculations. - [*] Password policy: - Pass Lengths: min:8 max:8 - Min strength: l:1 u:1 d:1 s:None - Max strength: l:None u:None d:None s:0 - [*] Generating [compliant] masks. - [*] Generating 8 character password masks. - [*] Total Masks: 65536 Time: 76 days, 18:50:04 - [*] Policy Masks: 5796 Time: 1 day, 20:20:55 - -Rules Analysis -================== - -`rulegen.py` implements password analysis and rule generation for the Hashcat password cracker as described in the [Automatic Password Rule Analysis and Generation](http://thesprawl.org/research/automatic-password-rule-analysis-generation/) paper. Please review this document for detailed discussion on the theory of rule analysis and generation. - -Reversing source words and word mangling rules from already cracked passwords can be very effective in performing attacks against still encrypted hashes. By continuously recycling/expanding generated rules and words you may be able to crack a greater number of passwords. - -Prerequisites ------------------ -There are several prerequisites for the effective use of `rulegen.py`. The tool utilizes Enchant spell-checking library to interface with a number of spell-checking engines such as Aspell, MySpell, etc. You must install these tools prior to use. It is also critical to install dictionaries for whatever spell-checking engine you end up using (alternatively it is possible to use a custom wordlist). At last, I have bundled PyEnchant for convenience which should interface directly with Enchant's shared libraries; however, should there be any issues, simply remove the bundled 'enchant' directory and install PyEnchant for your distribution. - -For additional details on specific Hashcat rule syntax see [Hashcat Rule Based Attack](http://hashcat.net/wiki/doku.php?id=rule_based_attack). - -Analyzing a Single Password -------------------------------- - -The most basic use of `rulegen.py` involves analysis of a single password to automatically detect rules. Let's detect rules and potential source word used to generate a sample password `P@55w0rd123`: - - $ python rulegen.py --verbose --password P@55w0rd123 - _ - RuleGen #.#.# | | - _ __ __ _ ___| | _ - | '_ \ / _` |/ __| |/ / - | |_) | (_| | (__| < - | .__/ \__,_|\___|_|\_\ - | | - |_| iphelix@thesprawl.org - - - [*] Using Enchant 'aspell' module. For best results please install - 'aspell' module language dictionaries. - [*] Analyzing password: P@55w0rd123 - [-] Pas sword => {edit distance suboptimal: 8 (7)} => P@55w0rd123 - [+] Password => sa@ ss5 so0 $1 $2 $3 => P@55w0rd123 - [+] Passwords => sa@ ss5 so0 o81 $2 $3 => P@55w0rd123 - [+] Passwords => sa@ ss5 so0 i81 o92 $3 => P@55w0rd123 - [+] Passwords => sa@ ss5 so0 i81 i92 oA3 => P@55w0rd123 - [+] Password's => sa@ ss5 so0 o81 o92 $3 => P@55w0rd123 - [+] Password's => sa@ ss5 so0 o81 i92 oA3 => P@55w0rd123 - [+] Password's => sa@ ss5 so0 i81 o92 oA3 => P@55w0rd123 - -There are several flags that we have used for this example: - - * --password - specifies a single password to analyze. - * --verbose - prints out verbose information such as generated rules and performance statistics. - -Processing password files is covered in a section below; however, let's first discuss some of the available fine tuning options using a single password as an example. - -Spell-checking provider ---------------------------- - -Notice that we are using the `aspell` Enchant module for source word detection. The exact spell-checking engine can be changed using the `--provider` flag as follows: - - $ python rulegen.py --verbose --provider myspell --password P@55w0rd123 -q - [*] Using Enchant 'myspell' module. For best results please install - 'myspell' module language dictionaries. - ... - - -NOTE: Provider engine priority can be specified using a comma-separated list (e.g. --provider aspell,myspell). - -Forcing source word ------------------------ - -The use of the source word detection engine can be completely disabled by specifying a source word with the `--word` flag: - - $ python rulegen.py -q --verbose --word word --password P@55w0rd123 - [*] Analyzing password: P@55w0rd123 - [+] word => ^5 ^5 ^@ ^P so0 $1 $2 $3 => P@55w0rd123 - -By specifying different source words you can have a lot of fun experimenting with the rule generation engine. - -Defining Custom Dictionary ------------------------------- - -Inevitably you will come across a point where generating rules using the standard spelling-engine wordlist is no longer sufficient. You can specify a custom wordlist using the `--wordlist` flag. This is particularly useful when reusing source words from a previous analysis session: - - $ python rulegen.py -q --verbose --wordlist rockyou.txt --password 1pa55w0rd1 - [*] Using Enchant 'Personal Wordlist' module. For best results please install - 'Personal Wordlist' module language dictionaries. - [*] Analyzing password: 1pa55w0rd1 - [+] password => ^1 ss5 so0 $1 => 1pa55w0rd1 - -Custom wordlist can be particularly useful when using not normally found words such as slang as well as using already cracked passwords. - -Generating Suboptimal Rules and Words ------------------------------------------ - -While `rulegen.py` attempts to generate and record only the best source words and passwords, there may be cases when you are interested in more results. Use `--morewords` and `--morerules` flags to generate words and rules which may exceed optimal edit distance: - - $ python rulegen.py -q --verbose --password '$m0n3y$' --morerules --morewords - [*] Using Enchant 'aspell' module. For best results please install - 'aspell' module language dictionaries. - [*] Analyzing password: $m0n3y$ - [+] money => ^$ so0 se3 $$ => $m0n3y$ - [+] moneys => ^$ so0 se3 o6$ => $m0n3y$ - [+] mingy => ^$ si0 sg3 $$ => $m0n3y$ - [+] many => ^$ sa0 i43 $$ => $m0n3y$ - [+] Mooney => sM$ o1m so0 se3 $$ => $m0n3y$ - -It is possible to further expand generated words using `--maxworddist` and `--maxwords` flags. Similarly, you can produce more rules using `--maxrulelen` and `--maxrules` flags. - -Disabling Advanced Engines ------------------------------- - -`rulegen.py` includes a number of advanced engines to generate better quality words and rules. It is possible to disable them to observe the difference (or if they are causing issues) using `--simplewords` and `--simplerules` flags. Let's observe how both source words and rules change with these flags on: - - $ python rulegen.py -q --verbose --password '$m0n3y$' --simplewords --simplerules - [*] Using Enchant 'aspell' module. For best results please install - 'aspell' module language dictionaries. - [*] Analyzing password: $m0n3y$ - [-] Meany => {edit distance suboptimal: 5 (4)} => $m0n3y$ - [+] many => i0$ o20 i43 i6$ => $m0n3y$ - [+] mingy => i0$ o20 o43 i6$ => $m0n3y$ - [+] money => i0$ o20 o43 i6$ => $m0n3y$ - [+] mangy => i0$ o20 o43 i6$ => $m0n3y$ - [+] manky => i0$ o20 o43 i6$ => $m0n3y$ - -Notice the quality of generated words and rules was reduced significantly with words like 'manky' having less relationship to the actual source word 'money'. At the same time, generated rules were reduced to simple insertions, deletions and replacements. - -Processing password lists ------------------------------ - -Now that you have mastered all of the different flags and switches, we can attempt to generate words and rules for a collection of passwords. Let's generate a text file `korelogic.txt` containing the following fairly complex test passwords: - - &~defcon - '#(4)\ - August19681 - '&a123456 - 10-D'Ann - ~|Bailey - Krist0f3r - f@cebOOK - Nuclear$( - zxcvbn2010! - 13Hark's - NjB3qqm - Sydney93? - antalya%] - Annl05de - ;-Fluffy - -Now let's observe `rulegen.py` analysis by simply specifying the password file as the first argument: - - $ python rulegen.py korelogic.txt -q - [*] Using Enchant 'aspell' module. For best results please install - 'aspell' module language dictionaries. - [*] Analyzing passwords file: korelogic.txt: - [*] Press Ctrl-C to end execution and generate statistical analysis. - [*] Saving rules to analysis.rule - [*] Saving words to analysis.word - [*] Finished processing 16 passwords in 1.00 seconds at the rate of 15.94 p/sec - [*] Generating statistics for [analysis] rules and words. - [-] Skipped 0 all numeric passwords (0.00%) - [-] Skipped 2 passwords with less than 25% alpha characters (12.50%) - [-] Skipped 0 passwords with non ascii characters (0.00%) - - [*] Top 10 rules - [+] ^3 ^1 o4r - 3 (2.00%) - [+] i61 i79 i86 i98 oA1 - 2 (1.00%) - [+] ^- ^0 ^1 i4' o5A - 2 (1.00%) - [+] sS1 i13 T2 - 1 (0.00%) - [+] i61 se9 i86 i98 oA1 - 1 (0.00%) - [+] o61 i79 i86 i98 oA1 - 1 (0.00%) - [+] ^- ^0 ^1 so' i5A - 1 (0.00%) - [+] D3 si0 i55 $e - 1 (0.00%) - [+] i61 i79 se6 i98 oA1 - 1 (0.00%) - [+] i3a o5y o6a i7% o8] - 1 (0.00%) - - [*] Top 10 words - [+] Analyze - 1 (0.00%) - [+] defcon - 1 (0.00%) - [+] Kristen - 1 (0.00%) - [+] Bailey - 1 (0.00%) - [+] Augusts - 1 (0.00%) - [+] Annelid - 1 (0.00%) - [+] Hack's - 1 (0.00%) - [+] antlers - 1 (0.00%) - [+] antelope - 1 (0.00%) - [+] xxxv - 1 (0.00%) - -Using all default settings we were able to produce several high quality rules. The application displays some basic Top 10 rules and words statistics. All of the generated rules and words are saved using basename 'analysis' by default: - -* analysis.word - unsorted and ununiqued source words -* analysis-sorted.word - occurrence sorted and unique source words -* analysis.rule - unsorted and ununiqued rules -* analysis-sorted.rule - occurrence sorted and unique rules - -Notice that several passwords such as '#(4)\ and '&a123456 were skipped because they do not have sufficient characteristics to be processed. Other than alpha character count, the program will skip all numeric passwords and passwords containing non-ASCII characters. The latter is due to a bug in the Enchant engine which I hope to fix in the future thus allowing word processing of many languages. - -Specifying output basename ------------------------------- - -As previously mentioned `rulegen.py` saves output files using the 'analysis' basename by default. You can change file basename with the `--basename` or `-b` flag as follows: - - $ python rulegen.py korelogic.txt -q -b korelogic - [*] Using Enchant 'aspell' module. For best results please install - 'aspell' module language dictionaries. - [*] Analyzing passwords file: korelogic.txt: - [*] Press Ctrl-C to end execution and generate statistical analysis. - [*] Saving rules to korelogic.rule - [*] Saving words to korelogic.word - - -Debugging rules --------------------- - -There may be situations where you run into issues generating rules for the Hashcat password cracker. `rulegen.py` includes the `--hashcat` flag to validate generated words and rules using hashcat itself running in --stdout mode. In order for this mode to work correctly, you must download the latest version of hashcat-cli and edit the `HASHCAT_PATH` variable in the source. For example, at the time of this writing I have placed the hashcat-0.## folder in the PACK directory and defined `HASHCAT_PATH` as 'hashcat-0.##/'. - -You can also observe the inner workings of the rule generation engine with the `--debug` flag. Don't worry about messages of certain rule failings, this is the result of the halting problem solver trying to find an optimal and valid solution. - -Conclusion -============== - -While this guide introduces a number of methods to analyze passwords, reverse rules and generate masks, there are a number of other tricks that are waiting for you to discover. I would be excited if you told me about some unusual use or suggestions for any of the covered tools. - -Happy Cracking! - - -Peter \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..bd1ca5a --- /dev/null +++ b/README.md @@ -0,0 +1,165 @@ +# PACK — Password Analysis and Cracking Kit + +PACK is a collection of utilities to analyze password lists and turn what you +learn into effective attacks for the [hashcat](https://hashcat.net/hashcat/) +family of password crackers. It detects the masks, character sets, rules and +policies that people actually use, so you can prioritize the cheapest, most +productive candidates first. + +> PACK does **not** crack passwords itself. It produces input files (masks, +> rules and wordlists) that make a real cracker far more efficient. + +Originally written by Peter Kacherginsky (iphelix). This fork modernizes the +toolkit for current Python 3. + +## What's in the box + +| Tool | Purpose | +| -------------- | ----------------------------------------------------------------------- | +| `statsgen.py` | Statistical analysis of a password list (length, charset, masks, …). | +| `maskgen.py` | Turn `statsgen` output into optimal, sorted hashcat masks (`.hcmask`). | +| `policygen.py` | Generate masks matching (or violating) a password-complexity policy. | +| `rulegen.py` | Reverse source words and hashcat rules from already-cracked passwords. | + +## Requirements + +- **Python 3.8+** (no third-party packages for `statsgen`, `maskgen` or + `policygen` — standard library only). +- **`rulegen` only** additionally needs [PyEnchant](https://pyenchant.github.io/pyenchant/) + plus the system `enchant` library and a dictionary. + +On Debian/Ubuntu: + +```bash +sudo apt install libenchant-2-2 aspell-en hunspell-en-us +``` + +## Installation + +Clone and run the scripts directly: + +```bash +git clone https://github.com/iphelix/pack.git +cd pack + +# Optional: only needed for rulegen +pip install -r requirements.txt + +python3 statsgen.py --help +``` + +Or install as a package to get the `statsgen`, `maskgen`, `policygen` and +`rulegen` commands on your `PATH`: + +```bash +pip install . # core tools +pip install '.[rulegen]' # also pull in pyenchant for rulegen +``` + +## Usage + +### StatsGen — analyze a password list + +```bash +python3 statsgen.py rockyou.txt +``` + +Reports the most common lengths, character sets, password complexity, and both +"simple" masks (e.g. `stringdigit`) and hashcat "advanced" masks +(e.g. `?l?l?l?l?l?l?l?l`). Useful flags: + +- `--minlength` / `--maxlength`, `--charset`, `--simplemask` — filter the sample. +- `--hiderare` — hide items covering less than 1% of the sample. +- `-o out.masks` — save advanced masks with occurrences (feed this to `maskgen`). + +```bash +python3 statsgen.py rockyou.txt -o rockyou.masks --hiderare +``` + +### MaskGen — build optimal masks + +Consumes the `.masks` file produced by `statsgen -o` and emits a `.hcmask` +sorted by the *optimal index* (coverage vs. cost), occurrence, or complexity: + +```bash +python3 maskgen.py rockyou.masks --optindex --showmasks -o rockyou.hcmask +``` + +- `-t 86400` — stop once the accumulated masks would take longer than N seconds. +- `--pps 1000000000` — cracking speed used for time estimates. +- Filters: `--minlength/--maxlength`, `--min/maxtime`, `--min/maxcomplexity`, + `--min/maxoccurrence`. +- `--checkmasks '?u?l?l?l?l?l?d,...'` or `--checkmasksfile masks.hcmask` — report + how much of your sample a given set of masks would cover. + +### PolicyGen — masks for a password policy + +Generate only the masks that satisfy (or, with `--noncompliant`, violate) a +complexity policy, avoiding wasted work on impossible candidates: + +```bash +python3 policygen.py --minlength 8 --maxlength 8 \ + --minlower 1 --minupper 1 --mindigit 1 --minspecial 1 \ + -o complexity.hcmask +``` + +Add `--showmasks` to print each mask with its strength breakdown and estimated +runtime. Maximum bounds (`--maxlower/--maxupper/--maxdigit/--maxspecial`) let you +model sites that forbid certain classes (e.g. `--maxspecial 0`). + +### RuleGen — reverse words and hashcat rules + +Given already-cracked passwords, `rulegen` finds a likely dictionary source word +and the hashcat rule that transforms it into the password, using the Levenshtein +reverse-path algorithm and Enchant spell-checking. See the paper +[Automatic Password Rule Analysis and Generation](http://thesprawl.org/research/automatic-password-rule-analysis-generation/) +for the theory, and the [hashcat rule reference](https://hashcat.net/wiki/doku.php?id=rule_based_attack) +for rule syntax. + +Analyze a single password (prints the source word and rule): + +```bash +python3 rulegen.py --password 'P@ssw0rd' +# [word] Password +# [rule] sa@ o50 +``` + +Analyze a whole file — writes `analysis.rule` / `analysis.word` and their +frequency-sorted `-sorted` variants: + +```bash +python3 rulegen.py rockyou.txt -b rockyou +``` + +Handy options: + +- `-b BASENAME` — output base name. +- `-w wordlist.dict` — use a custom wordlist instead of the spell checker. +- `--providers aspell,hunspell` — choose enchant provider engines. +- `--maxwords` / `--maxworddist` and `--maxrules` / `--maxrulelen` — tune how many + candidate words/rules are considered and how large they may get. +- `--simplewords` / `--simplerules` — faster, less thorough generation. +- `--bruterules` — also try reversal/rotation pre-rules (slower). +- `-v` / `-d` — verbose / debug output. + +## What changed in this modernized fork + +- Ported the command-line interface of all four tools from the deprecated + `optparse` to `argparse`. +- Made `rulegen`'s `pyenchant` dependency optional with a clear install message + instead of a raw `ImportError`, and switched the default provider list from the + legacy `aspell,myspell` to `aspell,hunspell` (enchant-2). +- `rulegen --password` now prints the generated word and rule directly instead of + silently discarding them. +- Fixed several bugs: word-frequency percentages summed the wrong counter; the + extract (`x`) rule collided with the truncate (`'`) rule; a debug line was a + no-op string instead of a `print`. +- Guarded against division-by-zero and file-handle leaks on empty inputs, and + wrapped file access in context managers. +- Added packaging (`pyproject.toml`, `requirements.txt`) with console entry points + and a `.gitignore`. + +## License + +See [LICENSE](LICENSE). PACK is provided for authorized security testing, +password audits, and research. diff --git a/maskgen.py b/maskgen.py index 30aef4d..866b4dc 100755 --- a/maskgen.py +++ b/maskgen.py @@ -1,22 +1,21 @@ -#!/usr/bin/python +#!/usr/bin/env python3 # MaskGen - Generate Password Masks # # This tool is part of PACK (Password Analysis and Cracking Kit) # -# VERSION 0.0.3 +# VERSION 0.0.4 # # Copyright (C) 2013 Peter Kacherginsky # All rights reserved. # # Please see the attached LICENSE file for additional licensing information. -import sys +import argparse import csv import datetime -from operator import itemgetter -from optparse import OptionParser, OptionGroup -VERSION = "0.0.3" +VERSION = "0.0.4" + class MaskGen: def __init__(self): @@ -26,15 +25,16 @@ def __init__(self): self.target_time = None self.output_file = None - self.minlength = None - self.maxlength = None - self.mintime = None - self.maxtime = None + self.minlength = None + self.maxlength = None + self.mintime = None + self.maxtime = None self.mincomplexity = None self.maxcomplexity = None self.minoccurrence = None self.maxoccurrence = None + # Lengths for hashcat custom character sets (?1 through ?4). self.customcharset1len = None self.customcharset2len = None self.customcharset3len = None @@ -51,55 +51,68 @@ def getcomplexity(self, mask): """ Return mask complexity. """ count = 1 for char in mask[1:].split("?"): - if char == "l": count *= 26 - elif char == "u": count *= 26 - elif char == "d": count *= 10 - elif char == "s": count *= 33 - elif char == "a": count *= 95 - elif char == "b": count *= 256 - elif char == "h": count *= 16 - elif char == "H": count *= 16 - elif char == "1" and self.customcharset1len: count *= self.customcharset1len - elif char == "2" and self.customcharset2len: count *= self.customcharset2len - elif char == "3" and self.customcharset3len: count *= self.customcharset3len - elif char == "4" and self.customcharset4len: count *= self.customcharset4len - else: print "[!] Error, unknown mask ?%s in a mask %s" % (char,mask) + if char == "l": + count *= 26 + elif char == "u": + count *= 26 + elif char == "d": + count *= 10 + elif char == "s": + count *= 33 + elif char == "a": + count *= 95 + elif char == "b": + count *= 256 + elif char in ("h", "H"): + count *= 16 + elif char == "1" and self.customcharset1len is not None: + count *= self.customcharset1len + elif char == "2" and self.customcharset2len is not None: + count *= self.customcharset2len + elif char == "3" and self.customcharset3len is not None: + count *= self.customcharset3len + elif char == "4" and self.customcharset4len is not None: + count *= self.customcharset4len + else: + print("[!] Error, unknown mask ?%s in a mask %s" % (char, mask)) return count def loadmasks(self, filename): """ Load masks and apply filters. """ - maskReader = csv.reader(open(args[0],'r'), delimiter=',', quotechar='"') - - for (mask,occurrence) in maskReader: - - if mask == "": continue - - mask_occurrence = int(occurrence) - mask_length = len(mask)/2 - mask_complexity = self.getcomplexity(mask) - mask_time = mask_complexity/self.pps - - self.total_occurrence += mask_occurrence - - # Apply filters based on occurrence, length, complexity and time - if (self.minoccurrence == None or mask_occurrence >= self.minoccurrence) and \ - (self.maxoccurrence == None or mask_occurrence <= self.maxoccurrence) and \ - (self.mincomplexity == None or mask_complexity >= self.mincomplexity) and \ - (self.maxcomplexity == None or mask_complexity <= self.maxcomplexity) and \ - (self.mintime == None or mask_time >= self.mintime) and \ - (self.maxtime == None or mask_time <= self.maxtime) and \ - (self.maxlength == None or mask_length <= self.maxlength) and \ - (self.minlength == None or mask_length >= self.minlength): - - self.masks[mask] = dict() - self.masks[mask]['length'] = mask_length - self.masks[mask]['occurrence'] = mask_occurrence - self.masks[mask]['complexity'] = 1 - mask_complexity - self.masks[mask]['time'] = mask_time - self.masks[mask]['optindex'] = 1 - mask_complexity/mask_occurrence - - def generate_masks(self,sorting_mode): + with open(filename, 'r') as mask_file: + mask_reader = csv.reader(mask_file, delimiter=',', quotechar='"') + + for (mask, occurrence) in mask_reader: + + if not mask: + continue + + mask_occurrence = int(occurrence) + mask_length = len(mask) // 2 + mask_complexity = self.getcomplexity(mask) + mask_time = mask_complexity // self.pps + + self.total_occurrence += mask_occurrence + + # Apply filters based on occurrence, length, complexity and time + if (self.minoccurrence is None or mask_occurrence >= self.minoccurrence) and \ + (self.maxoccurrence is None or mask_occurrence <= self.maxoccurrence) and \ + (self.mincomplexity is None or mask_complexity >= self.mincomplexity) and \ + (self.maxcomplexity is None or mask_complexity <= self.maxcomplexity) and \ + (self.mintime is None or mask_time >= self.mintime) and \ + (self.maxtime is None or mask_time <= self.maxtime) and \ + (self.maxlength is None or mask_length <= self.maxlength) and \ + (self.minlength is None or mask_length >= self.minlength): + + self.masks[mask] = dict() + self.masks[mask]['length'] = mask_length + self.masks[mask]['occurrence'] = mask_occurrence + self.masks[mask]['complexity'] = 1 - mask_complexity + self.masks[mask]['time'] = mask_time + self.masks[mask]['optindex'] = 1 - (mask_complexity // mask_occurrence) + + def generate_masks(self, sorting_mode): """ Generate optimal password masks sorted by occurrence, complexity or optindex """ sample_count = 0 sample_time = 0 @@ -109,12 +122,16 @@ def generate_masks(self,sorting_mode): # Group by length 1,2,3,4,5,6,7,8,9,10.... # Group by occurrence 10%, 20%, 30%, 40%, 50%.... - if self.showmasks: print "[L:] Mask: [ Occ: ] [ Time: ]" - for mask in sorted(self.masks.keys(), key=lambda mask: self.masks[mask][sorting_mode], reverse=True): + if self.showmasks: + print("[L:] Mask: [ Occ: ] [ Time: ]") + + for mask in sorted(self.masks.keys(), key=lambda m: self.masks[m][sorting_mode], reverse=True): if self.showmasks: - time_human = ">1 year" if self.masks[mask]['time'] > 60*60*24*365 else str(datetime.timedelta(seconds=self.masks[mask]['time'])) - print "[{:>2}] {:<30} [{:<7}] [{:>8}] ".format(self.masks[mask]['length'], mask, self.masks[mask]['occurrence'], time_human) + time_human = ">1 year" if self.masks[mask]['time'] > 60*60*24*365 \ + else str(datetime.timedelta(seconds=self.masks[mask]['time'])) + print("[{:>2}] {:<30} [{:<7}] [{:>8}] ".format(self.masks[mask]['length'], mask, + self.masks[mask]['occurrence'], time_human)) if self.output_file: self.output_file.write("%s\n" % mask) @@ -124,14 +141,15 @@ def generate_masks(self,sorting_mode): sample_count += 1 if self.target_time and sample_time > self.target_time: - print "[!] Target time exceeded." + print("[!] Target time exceeded.") break - print "[*] Finished generating masks:" - print " Masks generated: %s" % sample_count - print " Masks coverage: %d%% (%d/%d)" % (sample_occurrence*100/self.total_occurrence,sample_occurrence,self.total_occurrence) + coverage = sample_occurrence * 100 // self.total_occurrence if self.total_occurrence else 0 + print("[*] Finished generating masks:") + print(" Masks generated: %s" % sample_count) + print(" Masks coverage: %d%% (%d/%d)" % (coverage, sample_occurrence, self.total_occurrence)) time_human = ">1 year" if sample_time > 60*60*24*365 else str(datetime.timedelta(seconds=sample_time)) - print " Masks runtime: %s" % time_human + print(" Masks runtime: %s" % time_human) def getmaskscoverage(self, checkmasks): @@ -140,7 +158,9 @@ def getmaskscoverage(self, checkmasks): total_complexity = 0 - if self.showmasks: print "[L:] Mask: [ Occ: ] [ Time: ]" + if self.showmasks: + print("[L:] Mask: [ Occ: ] [ Time: ]") + for mask in checkmasks: mask = mask.strip() mask_complexity = self.getcomplexity(mask) @@ -150,8 +170,10 @@ def getmaskscoverage(self, checkmasks): if mask in self.masks: if self.showmasks: - time_human = ">1 year" if self.masks[mask]['time'] > 60*60*24*365 else str(datetime.timedelta(seconds=self.masks[mask]['time'])) - print "[{:>2}] {:<30} [{:<7}] [{:>8}] ".format(self.masks[mask]['length'], mask, self.masks[mask]['occurrence'], time_human) + time_human = ">1 year" if self.masks[mask]['time'] > 60*60*24*365 \ + else str(datetime.timedelta(seconds=self.masks[mask]['time'])) + print("[{:>2}] {:<30} [{:<7}] [{:>8}] ".format(self.masks[mask]['length'], mask, + self.masks[mask]['occurrence'], time_human)) if self.output_file: self.output_file.write("%s\n" % mask) @@ -159,139 +181,163 @@ def getmaskscoverage(self, checkmasks): sample_occurrence += self.masks[mask]['occurrence'] sample_count += 1 - if self.target_time and total_complexity/self.pps > self.target_time: - print "[!] Target time exceeded." + if self.target_time and total_complexity / self.pps > self.target_time: + print("[!] Target time exceeded.") break # TODO: Something wrong here, complexity and time doesn't match with estimated from policygen - total_time = total_complexity/self.pps + total_time = total_complexity / self.pps time_human = ">1 year" if total_time > 60*60*24*365 else str(datetime.timedelta(seconds=total_time)) - print "[*] Finished matching masks:" - print " Masks matched: %s" % sample_count - print " Masks coverage: %d%% (%d/%d)" % (sample_occurrence*100/self.total_occurrence,sample_occurrence,self.total_occurrence) - print " Masks runtime: %s" % time_human - - -if __name__ == "__main__": - - header = " _ \n" - header += " MaskGen %s | |\n" % VERSION - header += " _ __ __ _ ___| | _\n" - header += " | '_ \ / _` |/ __| |/ /\n" - header += " | |_) | (_| | (__| < \n" - header += " | .__/ \__,_|\___|_|\_\\\n" - header += " | | \n" - header += " |_| iphelix@thesprawl.org\n" - header += "\n" - - parser = OptionParser("%prog pass0.masks [pass1.masks ...] [options]", version="%prog "+VERSION) - - parser.add_option("-t", "--targettime", dest="target_time", type="int", metavar="86400", help="Target time of all masks (seconds)") - parser.add_option("-o", "--outputmasks", dest="output_masks", metavar="masks.hcmask", help="Save masks to a file") - - filters = OptionGroup(parser, "Individual Mask Filter Options") - filters.add_option("--minlength", dest="minlength", type="int", metavar="8", help="Minimum password length") - filters.add_option("--maxlength", dest="maxlength", type="int", metavar="8", help="Maximum password length") - filters.add_option("--mintime", dest="mintime", type="int", metavar="3600", help="Minimum mask runtime (seconds)") - filters.add_option("--maxtime", dest="maxtime", type="int", metavar="3600", help="Maximum mask runtime (seconds)") - filters.add_option("--mincomplexity", dest="mincomplexity", type="int", metavar="1", help="Minimum complexity") - filters.add_option("--maxcomplexity", dest="maxcomplexity", type="int", metavar="100", help="Maximum complexity") - filters.add_option("--minoccurrence", dest="minoccurrence", type="int", metavar="1", help="Minimum occurrence") - filters.add_option("--maxoccurrence", dest="maxoccurrence", type="int", metavar="100", help="Maximum occurrence") - parser.add_option_group(filters) - - sorting = OptionGroup(parser, "Mask Sorting Options") - sorting.add_option("--optindex", action="store_true", dest="optindex", help="sort by mask optindex (default)", default=False) - sorting.add_option("--occurrence", action="store_true", dest="occurrence", help="sort by mask occurrence", default=False) - sorting.add_option("--complexity", action="store_true", dest="complexity", help="sort by mask complexity", default=False) - parser.add_option_group(sorting) - - coverage = OptionGroup(parser, "Check mask coverage") - coverage.add_option("--checkmasks", dest="checkmasks", help="check mask coverage", metavar="?u?l?l?l?l?l?d,?l?l?l?l?l?d?d") - coverage.add_option("--checkmasksfile", dest="checkmasks_file", help="check mask coverage in a file", metavar="masks.hcmask") - parser.add_option_group(coverage) - - parser.add_option("--showmasks", dest="showmasks",help="Show matching masks", action="store_true", default=False) - - custom = OptionGroup(parser, "Custom charater set options") - custom.add_option("--custom-charset1-len", dest="customcharset1len", type="int", metavar="26", help="Length of cutom character set 1") - custom.add_option("--custom-charset2-len", dest="customcharset2len", type="int", metavar="26", help="Length of cutom character set 2") - custom.add_option("--custom-charset3-len", dest="customcharset3len", type="int", metavar="26", help="Length of cutom character set 3") - custom.add_option("--custom-charset4-len", dest="customcharset4len", type="int", metavar="26", help="Length of cutom character set 4") - parser.add_option_group(custom) - - misc = OptionGroup(parser, "Miscellaneous options") - misc.add_option("--pps", dest="pps",help="Passwords per Second", type="int", metavar="1000000000") - misc.add_option("-q", "--quiet", action="store_true", dest="quiet", default=False, help="Don't show headers.") - parser.add_option_group(misc) - - (options, args) = parser.parse_args() + coverage = sample_occurrence * 100 // self.total_occurrence if self.total_occurrence else 0 + print("[*] Finished matching masks:") + print(" Masks matched: %s" % sample_count) + print(" Masks coverage: %d%% (%d/%d)" % (coverage, sample_occurrence, self.total_occurrence)) + print(" Masks runtime: %s" % time_human) + + +def main(): + + header = r""" _ + MaskGen %s | | + _ __ __ _ ___| | _ + | '_ \ / _` |/ __| |/ / + | |_) | (_| | (__| < + | .__/ \__,_|\___|_|\_\ + | | + |_| iphelix@thesprawl.org +""" % VERSION + + parser = argparse.ArgumentParser( + description="Generate optimal password masks from statsgen output.") + parser.add_argument("--version", action="version", version="%(prog)s " + VERSION) + parser.add_argument("masks_files", metavar="pass0.masks", nargs="+", + help="One or more statsgen mask files to analyze.") + + parser.add_argument("-t", "--targettime", dest="target_time", type=int, metavar="86400", + help="Target time of all masks (seconds)") + parser.add_argument("-o", "--outputmasks", dest="output_masks", metavar="masks.hcmask", + help="Save masks to a file") + + filters = parser.add_argument_group("Individual Mask Filter Options") + filters.add_argument("--minlength", type=int, metavar="8", help="Minimum password length") + filters.add_argument("--maxlength", type=int, metavar="8", help="Maximum password length") + filters.add_argument("--mintime", type=int, metavar="3600", help="Minimum mask runtime (seconds)") + filters.add_argument("--maxtime", type=int, metavar="3600", help="Maximum mask runtime (seconds)") + filters.add_argument("--mincomplexity", type=int, metavar="1", help="Minimum complexity") + filters.add_argument("--maxcomplexity", type=int, metavar="100", help="Maximum complexity") + filters.add_argument("--minoccurrence", type=int, metavar="1", help="Minimum occurrence") + filters.add_argument("--maxoccurrence", type=int, metavar="100", help="Maximum occurrence") + + sorting = parser.add_argument_group("Mask Sorting Options") + sorting.add_argument("--optindex", action="store_true", help="sort by mask optindex (default)") + sorting.add_argument("--occurrence", action="store_true", help="sort by mask occurrence") + sorting.add_argument("--complexity", action="store_true", help="sort by mask complexity") + + coverage = parser.add_argument_group("Check mask coverage") + coverage.add_argument("--checkmasks", metavar="?u?l?l?l?l?l?d,?l?l?l?l?l?d?d", + help="check mask coverage") + coverage.add_argument("--checkmasksfile", dest="checkmasks_file", metavar="masks.hcmask", + help="check mask coverage in a file") + + parser.add_argument("--showmasks", action="store_true", help="Show matching masks") + + custom = parser.add_argument_group("Custom character set options") + custom.add_argument("--custom-charset1-len", type=int, metavar="26", + help="Length of hashcat custom character set ?1") + custom.add_argument("--custom-charset2-len", type=int, metavar="26", + help="Length of hashcat custom character set ?2") + custom.add_argument("--custom-charset3-len", type=int, metavar="26", + help="Length of hashcat custom character set ?3") + custom.add_argument("--custom-charset4-len", type=int, metavar="26", + help="Length of hashcat custom character set ?4") + + misc = parser.add_argument_group("Miscellaneous options") + misc.add_argument("--pps", type=int, metavar="1000000000", help="Passwords per Second") + misc.add_argument("-q", "--quiet", action="store_true", help="Don't show headers.") + + options = parser.parse_args() + args = options.masks_files # Print program header if not options.quiet: - print header - - if len(args) < 1: - parser.error("no masks file specified! Please provide statsgen output.") - exit(1) + print(header) - print "[*] Analyzing masks in [%s]" % args[0] + print("[*] Analyzing masks in [%s]" % args[0]) maskgen = MaskGen() # Settings - if options.target_time: maskgen.target_time = options.target_time + if options.target_time: + maskgen.target_time = options.target_time if options.output_masks: - print "[*] Saving generated masks to [%s]" % options.output_masks + print("[*] Saving generated masks to [%s]" % options.output_masks) maskgen.output_file = open(options.output_masks, 'w') # Filters - if options.minlength: maskgen.minlength = options.minlength - if options.maxlength: maskgen.maxlength = options.maxlength - if options.mintime: maskgen.mintime = options.mintime - if options.maxtime: maskgen.maxtime = options.maxtime - if options.mincomplexity: maskgen.mincomplexity = options.mincomplexity - if options.maxcomplexity: maskgen.maxcomplexity = options.maxcomplexity - if options.minoccurrence: maskgen.minoccurrence = options.minoccurrence - if options.maxoccurrence: maskgen.maxoccurrence = options.maxoccurrence - - # Custom - if options.customcharset1len: maskgen.customcharset1len = options.customcharset1len - if options.customcharset2len: maskgen.customcharset2len = options.customcharset2len - if options.customcharset3len: maskgen.customcharset3len = options.customcharset3len - if options.customcharset4len: maskgen.customcharset4len = options.customcharset4len + if options.minlength: + maskgen.minlength = options.minlength + if options.maxlength: + maskgen.maxlength = options.maxlength + if options.mintime: + maskgen.mintime = options.mintime + if options.maxtime: + maskgen.maxtime = options.maxtime + if options.mincomplexity: + maskgen.mincomplexity = options.mincomplexity + if options.maxcomplexity: + maskgen.maxcomplexity = options.maxcomplexity + if options.minoccurrence: + maskgen.minoccurrence = options.minoccurrence + if options.maxoccurrence: + maskgen.maxoccurrence = options.maxoccurrence + + # Custom character set lengths + for number in range(1, 5): + length = getattr(options, "custom_charset%d_len" % number) + if length is not None: + setattr(maskgen, "customcharset%dlen" % number, length) # Misc - if options.pps: maskgen.pps = options.pps - if options.showmasks: maskgen.showmasks = options.showmasks - - print "[*] Using {:,d} keys/sec for calculations.".format(maskgen.pps) + if options.pps: + maskgen.pps = options.pps + if options.showmasks: + maskgen.showmasks = options.showmasks + print("[*] Using {:,d} keys/sec for calculations.".format(maskgen.pps)) + # Load masks for arg in args: maskgen.loadmasks(arg) - # Matching masks from the command-line - if options.checkmasks: - checkmasks = [m.strip() for m in options.checkmasks.split(',')] - print "[*] Checking coverage of the these masks [%s]" % ", ".join(checkmasks) - maskgen.getmaskscoverage(checkmasks) - - # Matching masks from a file - elif options.checkmasks_file: - checkmasks_file = open(options.checkmasks_file, 'r') - print "[*] Checking coverage of masks in [%s]" % options.checkmasks_file - maskgen.getmaskscoverage(checkmasks_file) - - # Printing masks in a file - else: - # Process masks according to specified sorting algorithm - if options.occurrence: - sorting_mode = "occurrence" - elif options.complexity: - sorting_mode = "complexity" + try: + # Matching masks from the command-line + if options.checkmasks: + checkmasks = [m.strip() for m in options.checkmasks.split(',')] + print("[*] Checking coverage of the these masks [%s]" % ", ".join(checkmasks)) + maskgen.getmaskscoverage(checkmasks) + + # Matching masks from a file + elif options.checkmasks_file: + print("[*] Checking coverage of masks in [%s]" % options.checkmasks_file) + with open(options.checkmasks_file, 'r') as checkmasks_file: + maskgen.getmaskscoverage(checkmasks_file) + + # Printing masks in a file else: - sorting_mode = "optindex" + # Process masks according to specified sorting algorithm + if options.occurrence: + sort_mode = "occurrence" + elif options.complexity: + sort_mode = "complexity" + else: + sort_mode = "optindex" + + print("[*] Sorting masks by their [%s]." % sort_mode) + maskgen.generate_masks(sort_mode) + finally: + if maskgen.output_file: + maskgen.output_file.close() - print "[*] Sorting masks by their [%s]." % sorting_mode - maskgen.generate_masks(sorting_mode) + +if __name__ == "__main__": + main() diff --git a/policygen.py b/policygen.py index 93378f2..5c524a5 100755 --- a/policygen.py +++ b/policygen.py @@ -1,54 +1,61 @@ -#!/usr/bin/python +#!/usr/bin/env python3 # PolicyGen - Analyze and Generate password masks according to a password policy # # This tool is part of PACK (Password Analysis and Cracking Kit) # -# VERSION 0.0.2 +# VERSION 0.0.3 # # Copyright (C) 2013 Peter Kacherginsky # All rights reserved. # # Please see the attached LICENSE file for additional licensing information. -import sys, string, random +import argparse import datetime -from optparse import OptionParser, OptionGroup import itertools -VERSION = "0.0.2" +VERSION = "0.0.3" -class PolicyGen: + +class PolicyGen: def __init__(self): self.output_file = None - self.minlength = 8 - self.maxlength = 8 - self.mindigit = None - self.minlower = None - self.minupper = None + self.minlength = 8 + self.maxlength = 8 + self.mindigit = None + self.minlower = None + self.minupper = None self.minspecial = None - self.maxdigit = None - self.maxlower = None - self.maxupper = None + self.maxdigit = None + self.maxlower = None + self.maxupper = None self.maxspecial = None # PPS (Passwords per Second) Cracking Speed self.pps = 1000000000 self.showmasks = False - def getcomplexity(self, mask): + @staticmethod + def getcomplexity(mask): """ Return mask complexity. """ count = 1 for char in mask[1:].split("?"): - if char == "l": count *= 26 - elif char == "u": count *= 26 - elif char == "d": count *= 10 - elif char == "s": count *= 33 - elif char == "a": count *= 95 - else: print "[!] Error, unknown mask ?%s in a mask %s" % (char,mask) + if char == "l": + count *= 26 + elif char == "u": + count *= 26 + elif char == "d": + count *= 10 + elif char == "s": + count *= 33 + elif char == "a": + count *= 95 + else: + print("[!] Error, unknown mask ?%s in a mask %s" % (char, mask)) return count - + def generate_masks(self, noncompliant): """ Generate all possible password masks matching the policy """ @@ -61,16 +68,15 @@ def generate_masks(self, noncompliant): sample_complexity = 0 # TODO: Randomize or even statistically arrange matching masks - for length in xrange(self.minlength, self.maxlength+1): - print "[*] Generating %d character password masks." % length + for length in range(self.minlength, self.maxlength + 1): + print("[*] Generating %d character password masks." % length) total_length_count = 0 sample_length_count = 0 - total_length_complexity = 0 sample_length_complexity = 0 - for masklist in itertools.product(['?d','?l','?u','?s'], repeat=length): + for masklist in itertools.product(['?d', '?l', '?u', '?s'], repeat=length): mask = ''.join(masklist) @@ -79,37 +85,47 @@ def generate_masks(self, noncompliant): digitcount = 0 specialcount = 0 - mask_complexity = self.getcomplexity(mask) - + mask_complexity = self.getcomplexity(mask) + total_length_count += 1 total_length_complexity += mask_complexity - # Count charachter types in a mask + # Count character types in a mask for char in mask[1:].split("?"): - if char == "l": lowercount += 1 - elif char == "u": uppercount += 1 - elif char == "d": digitcount += 1 - elif char == "s": specialcount += 1 - + if char == "l": + lowercount += 1 + elif char == "u": + uppercount += 1 + elif char == "d": + digitcount += 1 + elif char == "s": + specialcount += 1 + # Filter according to password policy # NOTE: Perform exact opposite (XOR) operation if noncompliant # flag was set when calling the function. - if ((self.minlower == None or lowercount >= self.minlower) and \ - (self.maxlower == None or lowercount <= self.maxlower) and \ - (self.minupper == None or uppercount >= self.minupper) and \ - (self.maxupper == None or uppercount <= self.maxupper) and \ - (self.mindigit == None or digitcount >= self.mindigit) and \ - (self.maxdigit == None or digitcount <= self.maxdigit) and \ - (self.minspecial == None or specialcount >= self.minspecial) and \ - (self.maxspecial == None or specialcount <= self.maxspecial)) ^ noncompliant : + if ((self.minlower is None or lowercount >= self.minlower) and + (self.maxlower is None or lowercount <= self.maxlower) and + (self.minupper is None or uppercount >= self.minupper) and + (self.maxupper is None or uppercount <= self.maxupper) and + (self.mindigit is None or digitcount >= self.mindigit) and + (self.maxdigit is None or digitcount <= self.maxdigit) and + (self.minspecial is None or specialcount >= self.minspecial) and + (self.maxspecial is None or specialcount <= self.maxspecial)) ^ noncompliant: sample_length_count += 1 sample_length_complexity += mask_complexity if self.showmasks: - mask_time = mask_complexity/self.pps - time_human = ">1 year" if mask_time > 60*60*24*365 else str(datetime.timedelta(seconds=mask_time)) - print "[{:>2}] {:<30} [l:{:>2} u:{:>2} d:{:>2} s:{:>2}] [{:>8}] ".format(length, mask, lowercount,uppercount,digitcount,specialcount, time_human) + mask_time = mask_complexity // self.pps + time_human = ">1 year" if mask_time > 60 * 60 * 24 * 365 \ + else str(datetime.timedelta(seconds=mask_time)) + print("[{:>2}] {:<30} [l:{:>2} u:{:>2} d:{:>2} s:{:>2}] [{:>8}] ".format(length, mask, + lowercount, + uppercount, + digitcount, + specialcount, + time_human)) if self.output_file: self.output_file.write("%s\n" % mask) @@ -120,87 +136,113 @@ def generate_masks(self, noncompliant): total_complexity += total_length_complexity sample_complexity += sample_length_complexity + total_time = total_complexity // self.pps + total_time_human = ">1 year" if total_time > 60 * 60 * 24 * 365 else str(datetime.timedelta(seconds=total_time)) + print("[*] Total Masks: %d Time: %s" % (total_count, total_time_human)) - total_time = total_complexity/self.pps - total_time_human = ">1 year" if total_time > 60*60*24*365 else str(datetime.timedelta(seconds=total_time)) - print "[*] Total Masks: %d Time: %s" % (total_count, total_time_human) + sample_time = sample_complexity // self.pps + sample_time_human = ">1 year" if sample_time > 60 * 60 * 24 * 365 else str( + datetime.timedelta(seconds=sample_time)) + print("[*] Policy Masks: %d Time: %s" % (sample_count, sample_time_human)) - sample_time = sample_complexity/self.pps - sample_time_human = ">1 year" if sample_time > 60*60*24*365 else str(datetime.timedelta(seconds=sample_time)) - print "[*] Policy Masks: %d Time: %s" % (sample_count, sample_time_human) +def main(): -if __name__ == "__main__": - - header = " _ \n" - header += " PolicyGen %s | |\n" % VERSION - header += " _ __ __ _ ___| | _\n" - header += " | '_ \ / _` |/ __| |/ /\n" - header += " | |_) | (_| | (__| < \n" - header += " | .__/ \__,_|\___|_|\_\\\n" - header += " | | \n" - header += " |_| iphelix@thesprawl.org\n" - header += "\n" + header = r""" _ + PolicyGen %s | | + _ __ __ _ ___| | _ + | '_ \ / _` |/ __| |/ / + | |_) | (_| | (__| < + | .__/ \__,_|\___|_|\_\ + | | + |_| iphelix@thesprawl.org +""" % VERSION # parse command line arguments - parser = OptionParser("%prog [options]\n\nType --help for more options", version="%prog "+VERSION) - parser.add_option("-o", "--outputmasks", dest="output_masks",help="Save masks to a file", metavar="masks.hcmask") - parser.add_option("--pps", dest="pps", help="Passwords per Second", type="int", metavar="1000000000") - parser.add_option("--showmasks", dest="showmasks", help="Show matching masks", action="store_true", default=False) - parser.add_option("--noncompliant", dest="noncompliant", help="Generate masks for noncompliant passwords", action="store_true", default=False) - - group = OptionGroup(parser, "Password Policy", "Define the minimum (or maximum) password strength policy that you would like to test") - group.add_option("--minlength", dest="minlength", type="int", metavar="8", default=8, help="Minimum password length") - group.add_option("--maxlength", dest="maxlength", type="int", metavar="8", default=8, help="Maximum password length") - group.add_option("--mindigit", dest="mindigit", type="int", metavar="1", help="Minimum number of digits") - group.add_option("--minlower", dest="minlower", type="int", metavar="1", help="Minimum number of lower-case characters") - group.add_option("--minupper", dest="minupper", type="int", metavar="1", help="Minimum number of upper-case characters") - group.add_option("--minspecial",dest="minspecial",type="int", metavar="1", help="Minimum number of special characters") - group.add_option("--maxdigit", dest="maxdigit", type="int", metavar="3", help="Maximum number of digits") - group.add_option("--maxlower", dest="maxlower", type="int", metavar="3", help="Maximum number of lower-case characters") - group.add_option("--maxupper", dest="maxupper", type="int", metavar="3", help="Maximum number of upper-case characters") - group.add_option("--maxspecial",dest="maxspecial",type="int", metavar="3", help="Maximum number of special characters") - parser.add_option_group(group) - - parser.add_option("-q", "--quiet", action="store_true", dest="quiet", default=False, help="Don't show headers.") - - (options, args) = parser.parse_args() + parser = argparse.ArgumentParser( + description="Generate password masks matching (or violating) a password policy.") + parser.add_argument("--version", action="version", version="%(prog)s " + VERSION) + parser.add_argument("-o", "--outputmasks", dest="output_masks", metavar="masks.hcmask", + help="Save masks to a file") + parser.add_argument("--pps", type=int, metavar="1000000000", help="Passwords per Second") + parser.add_argument("--showmasks", action="store_true", help="Show matching masks") + parser.add_argument("--noncompliant", action="store_true", + help="Generate masks for noncompliant passwords") + + group = parser.add_argument_group( + "Password Policy", + "Define the minimum (or maximum) password strength policy that you would like to test") + group.add_argument("--minlength", type=int, metavar="8", default=8, help="Minimum password length") + group.add_argument("--maxlength", type=int, metavar="8", default=8, help="Maximum password length") + group.add_argument("--mindigit", type=int, metavar="1", help="Minimum number of digits") + group.add_argument("--minlower", type=int, metavar="1", help="Minimum number of lower-case characters") + group.add_argument("--minupper", type=int, metavar="1", help="Minimum number of upper-case characters") + group.add_argument("--minspecial", type=int, metavar="1", help="Minimum number of special characters") + group.add_argument("--maxdigit", type=int, metavar="3", help="Maximum number of digits") + group.add_argument("--maxlower", type=int, metavar="3", help="Maximum number of lower-case characters") + group.add_argument("--maxupper", type=int, metavar="3", help="Maximum number of upper-case characters") + group.add_argument("--maxspecial", type=int, metavar="3", help="Maximum number of special characters") + + parser.add_argument("-q", "--quiet", action="store_true", help="Don't show headers.") + + options = parser.parse_args() # Print program header if not options.quiet: - print header + print(header) policygen = PolicyGen() # Settings if options.output_masks: - print "[*] Saving generated masks to [%s]" % options.output_masks + print("[*] Saving generated masks to [%s]" % options.output_masks) policygen.output_file = open(options.output_masks, 'w') - # Password policy - if options.minlength != None: policygen.minlength = options.minlength - if options.maxlength != None: policygen.maxlength = options.maxlength - if options.mindigit != None: policygen.mindigit = options.mindigit - if options.minlower != None: policygen.minlower = options.minlower - if options.minupper != None: policygen.minupper = options.minupper - if options.minspecial != None: policygen.minspecial = options.minspecial - if options.maxdigit != None: policygen.maxdigit = options.maxdigit - if options.maxlower != None: policygen.maxlower = options.maxlower - if options.maxupper != None: policygen.maxupper = options.maxupper - if options.maxspecial != None: policygen.maxspecial = options.maxspecial + if options.minlength is not None: + policygen.minlength = options.minlength + if options.maxlength is not None: + policygen.maxlength = options.maxlength + if options.mindigit is not None: + policygen.mindigit = options.mindigit + if options.minlower is not None: + policygen.minlower = options.minlower + if options.minupper is not None: + policygen.minupper = options.minupper + if options.minspecial is not None: + policygen.minspecial = options.minspecial + if options.maxdigit is not None: + policygen.maxdigit = options.maxdigit + if options.maxlower is not None: + policygen.maxlower = options.maxlower + if options.maxupper is not None: + policygen.maxupper = options.maxupper + if options.maxspecial is not None: + policygen.maxspecial = options.maxspecial # Misc - if options.pps: policygen.pps = options.pps - if options.showmasks: policygen.showmasks = options.showmasks + if options.pps: + policygen.pps = options.pps + if options.showmasks: + policygen.showmasks = options.showmasks - print "[*] Using {:,d} keys/sec for calculations.".format(policygen.pps) + print("[*] Using {:,d} keys/sec for calculations.".format(policygen.pps)) # Print current password policy - print "[*] Password policy:" - print " Pass Lengths: min:%d max:%d" % (policygen.minlength, policygen.maxlength) - print " Min strength: l:%s u:%s d:%s s:%s" % (policygen.minlower, policygen.minupper, policygen.mindigit, policygen.minspecial) - print " Max strength: l:%s u:%s d:%s s:%s" % (policygen.maxlower, policygen.maxupper, policygen.maxdigit, policygen.maxspecial) + print("[*] Password policy:") + print(" Pass Lengths: min:%d max:%d" % (policygen.minlength, policygen.maxlength)) + print(" Min strength: l:%s u:%s d:%s s:%s" % ( + policygen.minlower, policygen.minupper, policygen.mindigit, policygen.minspecial)) + print(" Max strength: l:%s u:%s d:%s s:%s" % ( + policygen.maxlower, policygen.maxupper, policygen.maxdigit, policygen.maxspecial)) + + print("[*] Generating [%s] masks." % ("compliant" if not options.noncompliant else "non-compliant")) + try: + policygen.generate_masks(options.noncompliant) + finally: + if policygen.output_file: + policygen.output_file.close() - print "[*] Generating [%s] masks." % ("compliant" if not options.noncompliant else "non-compliant") - policygen.generate_masks(options.noncompliant) \ No newline at end of file + +if __name__ == "__main__": + main() diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..740af65 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,38 @@ +[build-system] +requires = ["setuptools>=61.0"] +build-backend = "setuptools.build_meta" + +[project] +name = "pack-toolkit" +version = "0.0.5" +description = "PACK (Password Analysis and Cracking Kit) - analyze password lists and generate masks, rules and policies for hashcat." +readme = "README.md" +requires-python = ">=3.8" +license = { file = "LICENSE" } +authors = [{ name = "Peter Kacherginsky (iphelix)" }] +keywords = ["password", "hashcat", "masks", "rules", "security", "cracking"] +classifiers = [ + "Programming Language :: Python :: 3", + "Topic :: Security", + "Environment :: Console", +] + +# statsgen, maskgen and policygen have no third-party dependencies. +# rulegen additionally needs pyenchant (see the [project.optional-dependencies] +# 'rulegen' extra) plus the system enchant library and a dictionary. +dependencies = [] + +[project.optional-dependencies] +rulegen = ["pyenchant>=3.2"] + +[project.urls] +Homepage = "https://github.com/iphelix/pack" + +[project.scripts] +statsgen = "statsgen:main" +maskgen = "maskgen:main" +policygen = "policygen:main" +rulegen = "rulegen:main" + +[tool.setuptools] +py-modules = ["statsgen", "maskgen", "policygen", "rulegen"] diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..a6f3a83 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,6 @@ +# Only rulegen.py requires a third-party package. +# statsgen.py, maskgen.py and policygen.py use the standard library only. +# +# pyenchant also needs the system 'enchant' library and a dictionary, e.g. on +# Debian/Ubuntu: sudo apt install libenchant-2-2 aspell-en hunspell-en-us +pyenchant>=3.2 diff --git a/rulegen.py b/rulegen.py index 492f31b..8ca67c7 100755 --- a/rulegen.py +++ b/rulegen.py @@ -1,46 +1,63 @@ -#!/usr/bin/env python +#!/usr/bin/env python3 # Rulegen.py - Advanced automated password rule and wordlist generator for the # Hashcat password cracker using the Levenshtein Reverse Path # algorithm and Enchant spell checking library. # # This tool is part of PACK (Password Analysis and Cracking Kit) # -# VERSION 0.0.3 +# VERSION 0.0.5 # # Copyright (C) 2013 Peter Kacherginsky # All rights reserved. # # Please see the attached LICENSE file for additional licensing information. -import sys +import argparse +import multiprocessing import re +import subprocess +import sys import time -import operator -import enchant - -from optparse import OptionParser, OptionGroup - from collections import Counter -import subprocess +try: + import enchant +except ImportError: + enchant = None -import multiprocessing - -VERSION = "0.0.4" +VERSION = "0.0.5" # Testing rules with hashcat --stdout HASHCAT_PATH = "hashcat/" + +# Minimal queue-like sink that prints items instead of enqueueing them. Used by +# the single-password debugging mode so results are visible on stdout. +class _PrintCollector: + def __init__(self, prefix): + self.prefix = prefix + + def put(self, item): + print("%s %s" % (self.prefix, item)) + + # Rule Generator class responsible for the complete cycle of rule generation class RuleGen: - # Initialize Rule Generator class - def __init__(self,language="en",providers="aspell,myspell",basename='analysis',threads=multiprocessing.cpu_count()): + def __init__(self, language="en", providers="aspell,myspell", basename='analysis', + threads=multiprocessing.cpu_count()): + + if enchant is None: + raise ImportError( + "The 'pyenchant' package is required by rulegen. Install it with " + "'pip install pyenchant' (it also needs the system 'enchant' library " + "and a dictionary such as aspell-en or hunspell-en-us)." + ) self.threads = threads self.enchant_broker = enchant.Broker() - self.enchant_broker.set_ordering("*",providers) + self.enchant_broker.set_ordering("*", providers) self.enchant = enchant.Dict(language, self.enchant_broker) @@ -63,7 +80,7 @@ def __init__(self,language="en",providers="aspell,myspell",basename='analysis',t # Debugging options self.verbose = False self.debug = False - self.word = None # Custom word to use. + self.word = None # Custom word to use. self.quiet = False ######################################################################## @@ -75,69 +92,135 @@ def __init__(self,language="en",providers="aspell,myspell",basename='analysis',t ######################################################################## # Preanalysis Password Patterns self.password_pattern = dict() - self.password_pattern["insertion"] = re.compile('^[^a-z]*(?P.+?)[^a-z]*$', re.IGNORECASE) - self.password_pattern["email"] = re.compile('^(?P.+?)@[A-Z0-9.-]+\.[A-Z]{2,4}', re.IGNORECASE) - self.password_pattern["alldigits"] = re.compile('^(\d+)$', re.IGNORECASE) - self.password_pattern["allspecial"]= re.compile('^([^a-z0-9]+)$', re.IGNORECASE) + self.password_pattern["insertion"] = re.compile(r'^[^a-z]*(?P.+?)[^a-z]*$', re.IGNORECASE) + self.password_pattern["email"] = re.compile(r'^(?P.+?)@[A-Z0-9.-]+\.[A-Z]{2,4}', re.IGNORECASE) + self.password_pattern["alldigits"] = re.compile(r'^(\d+)$', re.IGNORECASE) + self.password_pattern["allspecial"] = re.compile(r'^([^a-z0-9]+)$', re.IGNORECASE) ######################################################################## # Hashcat Rules Engine self.hashcat_rule = dict() - # Dummy rule - self.hashcat_rule[':'] = lambda x: x # Do nothing - - # Case rules - self.hashcat_rule["l"] = lambda x: x.lower() # Lowercase all letters - self.hashcat_rule["u"] = lambda x: x.upper() # Capitalize all letters - self.hashcat_rule["c"] = lambda x: x.capitalize() # Capitalize the first letter - self.hashcat_rule["C"] = lambda x: x[0].lower() + x[1:].upper() # Lowercase the first found character, uppercase the rest - self.hashcat_rule["t"] = lambda x: x.swapcase() # Toggle the case of all characters in word - self.hashcat_rule["T"] = lambda x,y: x[:y] + x[y].swapcase() + x[y+1:] # Toggle the case of characters at position N - self.hashcat_rule["E"] = lambda x: " ".join([i[0].upper()+i[1:] for i in x.split(" ")]) # Upper case the first letter and every letter after a space - - # Rotation rules - self.hashcat_rule["r"] = lambda x: x[::-1] # Reverse the entire word - self.hashcat_rule["{"] = lambda x: x[1:]+x[0] # Rotate the word left - self.hashcat_rule["}"] = lambda x: x[-1]+x[:-1] # Rotate the word right - - # Duplication rules - self.hashcat_rule["d"] = lambda x: x+x # Duplicate entire word - self.hashcat_rule["p"] = lambda x,y: x*y # Duplicate entire word N times - self.hashcat_rule["f"] = lambda x: x+x[::-1] # Duplicate word reversed - self.hashcat_rule["z"] = lambda x,y: x[0]*y+x # Duplicate first character N times - self.hashcat_rule["Z"] = lambda x,y: x+x[-1]*y # Duplicate last character N times - self.hashcat_rule["q"] = lambda x: "".join([i+i for i in x]) # Duplicate every character - self.hashcat_rule["y"] = lambda x,y: x[:y]+x # Duplicate first N characters - self.hashcat_rule["Y"] = lambda x,y: x+x[-y:] # Duplicate last N characters - - # Cutting rules - self.hashcat_rule["["] = lambda x: x[1:] # Delete first character - self.hashcat_rule["]"] = lambda x: x[:-1] # Delete last character - self.hashcat_rule["D"] = lambda x,y: x[:y]+x[y+1:] # Deletes character at position N - self.hashcat_rule["'"] = lambda x,y: x[:y] # Truncate word at position N - self.hashcat_rule["x"] = lambda x,y,z: x[:y]+x[y+z:] # Delete M characters, starting at position N - self.hashcat_rule["@"] = lambda x,y: x.replace(y,'') # Purge all instances of X - - # Insertion rules - self.hashcat_rule["$"] = lambda x,y: x+y # Append character to end - self.hashcat_rule["^"] = lambda x,y: y+x # Prepend character to front - self.hashcat_rule["i"] = lambda x,y,z: x[:y]+z+x[y:] # Insert character X at position N - - # Replacement rules - self.hashcat_rule["o"] = lambda x,y,z: x[:y]+z+x[y+1:] # Overwrite character at position N with X - self.hashcat_rule["s"] = lambda x,y,z: x.replace(y,z) # Replace all instances of X with Y - self.hashcat_rule["L"] = lambda x,y: x[:y]+chr(ord(x[y])<<1)+x[y+1:] # Bitwise shift left character @ N - self.hashcat_rule["R"] = lambda x,y: x[:y]+chr(ord(x[y])>>1)+x[y+1:] # Bitwise shift right character @ N - self.hashcat_rule["+"] = lambda x,y: x[:y]+chr(ord(x[y])+1)+x[y+1:] # Increment character @ N by 1 ascii value - self.hashcat_rule["-"] = lambda x,y: x[:y]+chr(ord(x[y])-1)+x[y+1:] # Decrement character @ N by 1 ascii value - self.hashcat_rule["."] = lambda x,y: x[:y]+x[y+1]+x[y+1:] # Replace character @ N with value at @ N plus 1 - self.hashcat_rule[","] = lambda x,y: x[:y]+x[y-1]+x[y+1:] # Replace character @ N with value at @ N minus 1 - - # Swappping rules - self.hashcat_rule["k"] = lambda x: x[1]+x[0]+x[2:] # Swap first two characters - self.hashcat_rule["K"] = lambda x: x[:-2]+x[-1]+x[-2] # Swap last two characters - self.hashcat_rule["*"] = lambda x,y,z: x[:y]+x[z]+x[y+1:z]+x[y]+x[z+1:] if z > y else x[:z]+x[y]+x[z+1:y]+x[z]+x[y+1:] # Swap character X with Y + ###################### + # Dummy rule # + ###################### + + # Do nothing + self.hashcat_rule[':'] = lambda x: x + + ###################### + # Case rules # + ###################### + + # Lowercase all letters + self.hashcat_rule["l"] = lambda x: x.lower() + # Capitalize all letters + self.hashcat_rule["u"] = lambda x: x.upper() + # Capitalize the first letter + self.hashcat_rule["c"] = lambda x: x.capitalize() + # Lowercase the first found character, uppercase the rest + self.hashcat_rule["C"] = lambda x: x[0].lower() + x[1:].upper() + # Toggle the case of all characters in word + self.hashcat_rule["t"] = lambda x: x.swapcase() + # Toggle the case of characters at position N + self.hashcat_rule["T"] = lambda x, y: x[:y] + x[y].swapcase() + x[y + 1:] + # Upper case the first letter and every letter after a space + self.hashcat_rule["E"] = lambda x: " ".join([i[0].upper() + i[1:] for i in x.split(" ")]) + + ###################### + # Rotation rules # + ###################### + + # Reverse the entire word + self.hashcat_rule["r"] = lambda x: x[::-1] + # Rotate the word left + self.hashcat_rule["{"] = lambda x: x[1:] + x[0] + # Rotate the word right + self.hashcat_rule["}"] = lambda x: x[-1] + x[:-1] + + ###################### + # Duplication rules # + ###################### + + # Duplicate entire word + self.hashcat_rule["d"] = lambda x: x + x + # Duplicate entire word N times + self.hashcat_rule["p"] = lambda x, y: x * y + # Duplicate word reversed + self.hashcat_rule["f"] = lambda x: x + x[::-1] + # Duplicate first character N times + self.hashcat_rule["z"] = lambda x, y: x[0] * y + x + # Duplicate last character N times + self.hashcat_rule["Z"] = lambda x, y: x + x[-1] * y + # Duplicate every character + self.hashcat_rule["q"] = lambda x: "".join([i + i for i in x]) + # Duplicate first N characters + self.hashcat_rule["y"] = lambda x, y: x[:y] + x + # Duplicate last N characters + self.hashcat_rule["Y"] = lambda x, y: x + x[-y:] + + ###################### + # Cutting rules # + ###################### + + # Delete first character + self.hashcat_rule["["] = lambda x: x[1:] + # Delete last character + self.hashcat_rule["]"] = lambda x: x[:-1] + # Deletes character at position N + self.hashcat_rule["D"] = lambda x, y: x[:y] + x[y + 1:] + # Truncate word at position N + self.hashcat_rule["'"] = lambda x, y: x[:y] + # Delete M characters, starting at position N + self.hashcat_rule["O"] = lambda x, y, z: x[:y] + x[y + z:] + # Extracts M characters, starting at position N + self.hashcat_rule["x"] = lambda x, y, z: x[y:y + z] + # Purge all instances of X + self.hashcat_rule["@"] = lambda x, y: x.replace(y, '') + + ###################### + # Insertion rules # + ###################### + + # Append character to end + self.hashcat_rule["$"] = lambda x, y: x + y + # Prepend character to front + self.hashcat_rule["^"] = lambda x, y: y + x + # Insert character X at position N + self.hashcat_rule["i"] = lambda x, y, z: x[:y] + z + x[y:] + + ###################### + # Replacement rules # + ###################### + + # Overwrite character at position N with X + self.hashcat_rule["o"] = lambda x, y, z: x[:y] + z + x[y + 1:] + # Replace all instances of X with Y + self.hashcat_rule["s"] = lambda x, y, z: x.replace(y, z) + # Bitwise shift left character @ N + self.hashcat_rule["L"] = lambda x, y: x[:y] + chr(ord(x[y]) << 1) + x[y + 1:] + # Bitwise shift right character @ N + self.hashcat_rule["R"] = lambda x, y: x[:y] + chr(ord(x[y]) >> 1) + x[y + 1:] + # Increment character @ N by 1 ascii value + self.hashcat_rule["+"] = lambda x, y: x[:y] + chr(ord(x[y]) + 1) + x[y + 1:] + # Decrement character @ N by 1 ascii value + self.hashcat_rule["-"] = lambda x, y: x[:y] + chr(ord(x[y]) - 1) + x[y + 1:] + # Replace character @ N with value at @ N plus 1 + self.hashcat_rule["."] = lambda x, y: x[:y] + x[y + 1] + x[y + 1:] + # Replace character @ N with value at @ N minus 1 + self.hashcat_rule[","] = lambda x, y: x[:y] + x[y - 1] + x[y + 1:] + + ###################### + # Swapping rules # + ###################### + + # Swap first two characters + self.hashcat_rule["k"] = lambda x: x[1] + x[0] + x[2:] + # Swap last two characters + self.hashcat_rule["K"] = lambda x: x[:-2] + x[-1] + x[-2] + # Swap character X with Y + self.hashcat_rule["*"] = lambda x, y, z: x[:y] + x[z] + x[y + 1:z] + x[y] + x[z + 1:] if z > y \ + else x[:z] + x[y] + x[z + 1:y] + x[z] + x[y + 1:] ######################################################################## # Common numeric and special character substitutions (1337 5p34k) @@ -161,20 +244,21 @@ def __init__(self,language="en",providers="aspell,myspell",basename='analysis',t ######################################################################## # Preanalysis rules to bruteforce for each word self.preanalysis_rules = [] - self.preanalysis_rules.append(([],self.hashcat_rule[':'])) # Blank rule - self.preanalysis_rules.append((['r'],self.hashcat_rule['r'])) # Reverse rule - #self.preanalysis_rules.append((['{'],self.hashcat_rule['}'])) # Rotate left - #self.preanalysis_rules.append((['}'],self.hashcat_rule['{'])) # Rotate right + self.preanalysis_rules.append(([], self.hashcat_rule[':'])) # Blank rule + self.preanalysis_rules.append((['r'], self.hashcat_rule['r'])) # Reverse rule + # self.preanalysis_rules.append((['{'],self.hashcat_rule['}'])) # Rotate left + # self.preanalysis_rules.append((['}'],self.hashcat_rule['{'])) # Rotate right ############################################################################ # Calculate Levenshtein edit path matrix - def levenshtein(self,word,password): + @staticmethod + def levenshtein(word, password): matrix = [] # Generate and populate the initial matrix - for i in xrange(len(password) + 1): + for i in range(len(password) + 1): matrix.append([]) - for j in xrange(len(word) + 1): + for j in range(len(word) + 1): if i == 0: matrix[i].append(j) elif j == 0: @@ -183,14 +267,14 @@ def levenshtein(self,word,password): matrix[i].append(0) # Calculate edit distance for each substring - for i in xrange(1,len(password) + 1): - for j in xrange(1,len(word) + 1): - if password[i-1] == word[j-1]: - matrix[i][j] = matrix[i-1][j-1] + for i in range(1, len(password) + 1): + for j in range(1, len(word) + 1): + if password[i - 1] == word[j - 1]: + matrix[i][j] = matrix[i - 1][j - 1] else: - insertion = matrix[i-1][j] + 1 - deletion = matrix[i][j-1] + 1 - substitution = matrix[i-1][j-1] + 1 + insertion = matrix[i - 1][j] + 1 + deletion = matrix[i][j - 1] + 1 + substitution = matrix[i - 1][j - 1] + 1 matrix[i][j] = min(insertion, deletion, substitution) return matrix @@ -204,8 +288,8 @@ def levenshtein_distance(self, s1, s2): return self.levenshtein_distance(s2, s1) if not s1: return len(s2) - - previous_row = xrange(len(s2) + 1) + + previous_row = range(len(s2) + 1) for i, c1 in enumerate(s1): current_row = [i + 1] for j, c2 in enumerate(s2): @@ -214,16 +298,19 @@ def levenshtein_distance(self, s1, s2): substitutions = previous_row[j] + (c1 != c2) current_row.append(min(insertions, deletions, substitutions)) previous_row = current_row - + return previous_row[-1] - def levenshtein_print(self,matrix,word,password): + @staticmethod + def levenshtein_print(matrix, word, password): """ Print word X password matrix """ - print " %s" % " ".join(list(word)) - for i,row in enumerate(matrix): - if i == 0: print " ", - else: print password[i-1], - print " ".join("%2d" % col for col in row) + print(" %s" % " ".join(list(word))) + for i, row in enumerate(matrix): + if i == 0: + print(" ", end=' ') + else: + print(password[i - 1], end=' ') + print(" ".join("%2d" % col for col in row)) def generate_levenshtein_rules(self, word, password): """ Generates levenshtein rules. Returns a list of lists of levenshtein rules. """ @@ -232,12 +319,12 @@ def generate_levenshtein_rules(self, word, password): matrix = self.levenshtein(word, password) # 2) Trace reverse paths through the matrix. - paths = self.levenshtein_reverse_recursive(matrix,len(matrix)-1,len(matrix[0])-1,0) + paths = self.levenshtein_reverse_recursive(matrix, len(matrix) - 1, len(matrix[0]) - 1, 0) # 3) Return a collection of reverse paths. return [path for path in paths if len(path) <= matrix[-1][-1]] - def levenshtein_reverse_recursive(self,matrix,i,j,path_len): + def levenshtein_reverse_recursive(self, matrix, i, j, path_len): """ Calculate reverse Levenshtein paths. Recursive, Depth First, Short-circuited algorithm by Peter Kacherginsky Generates a list of edit operations necessary to transform a source word @@ -254,38 +341,46 @@ def levenshtein_reverse_recursive(self,matrix,i,j,path_len): cost = matrix[i][j] # Calculate minimum cost of each operation - cost_delete = cost_insert = cost_equal_or_replace = sys.maxint - if i > 0: cost_insert = matrix[i-1][j] - if j > 0: cost_delete = matrix[i][j-1] - if i > 0 and j > 0: cost_equal_or_replace = matrix[i-1][j-1] + cost_delete = cost_insert = cost_equal_or_replace = sys.maxsize + if i > 0: + cost_insert = matrix[i - 1][j] + if j > 0: + cost_delete = matrix[i][j - 1] + if i > 0 and j > 0: + cost_equal_or_replace = matrix[i - 1][j - 1] cost_min = min(cost_delete, cost_insert, cost_equal_or_replace) # Recurse through reverse path for each operation if cost_insert == cost_min: - insert_paths = self.levenshtein_reverse_recursive(matrix,i-1,j,path_len+1) - for insert_path in insert_paths: paths.append(insert_path + [('insert',i-1,j)]) + insert_paths = self.levenshtein_reverse_recursive(matrix, i - 1, j, path_len + 1) + for insert_path in insert_paths: + paths.append(insert_path + [('insert', i - 1, j)]) if cost_delete == cost_min: - delete_paths = self.levenshtein_reverse_recursive(matrix,i,j-1,path_len+1) - for delete_path in delete_paths: paths.append(delete_path + [('delete',i,j-1)]) + delete_paths = self.levenshtein_reverse_recursive(matrix, i, j - 1, path_len + 1) + for delete_path in delete_paths: + paths.append(delete_path + [('delete', i, j - 1)]) if cost_equal_or_replace == cost_min: if cost_equal_or_replace == cost: - equal_paths = self.levenshtein_reverse_recursive(matrix,i-1,j-1,path_len) - for equal_path in equal_paths: paths.append(equal_path) + equal_paths = self.levenshtein_reverse_recursive(matrix, i - 1, j - 1, path_len) + for equal_path in equal_paths: + paths.append(equal_path) else: - replace_paths = self.levenshtein_reverse_recursive(matrix,i-1,j-1,path_len+1) - for replace_path in replace_paths: paths.append(replace_path + [('replace',i-1,j-1)]) + replace_paths = self.levenshtein_reverse_recursive(matrix, i - 1, j - 1, path_len + 1) + for replace_path in replace_paths: + paths.append(replace_path + [('replace', i - 1, j - 1)]) return paths - def load_custom_wordlist(self,wordlist_file): + def load_custom_wordlist(self, wordlist_file): self.enchant = enchant.request_pwl_dict(wordlist_file) - def generate_words(self,password): + def generate_words(self, password): """ Generate source word candidates.""" - if self.debug: print "[*] Generating source words for %s" % password + if self.debug: + print("[*] Generating source words for %s" % password) words = list() words_collection = list() @@ -305,40 +400,41 @@ def generate_words(self,password): pre_password = pre_rule_lambda(password) # Generate word suggestions - if self.word: suggestions = [self.word] - elif self.simple_words: suggestions = self.generate_simple_words(pre_password) - else: suggestions = self.generate_advanced_words(pre_password) + if self.word: + suggestions = [self.word] + elif self.simple_words: + suggestions = self.generate_simple_words(pre_password) + else: + suggestions = self.generate_advanced_words(pre_password) # HACK: Perform some additional expansion on multi-word suggestions # TODO: May be I should split these two and see if I can generate # rules for each of the suggestions for suggestion in suggestions[:self.max_words]: - suggestion = suggestion.replace(' ','') - suggestion = suggestion.replace('-','') - if not suggestion in suggestions: + suggestion = suggestion.replace(' ', '') + suggestion = suggestion.replace('-', '') + if suggestion not in suggestions: suggestions.append(suggestion) if len(suggestions) != len(set(suggestions)): - print sorted(suggestions) - print sorted(set(suggestions)) - + print(sorted(suggestions)) + print(sorted(set(suggestions))) for suggestion in suggestions: - - distance = self.levenshtein_distance(suggestion,pre_password) + distance = self.levenshtein_distance(suggestion, pre_password) word = dict() word["suggestion"] = suggestion - word["distance"] = distance - word["password"] = pre_password - word["pre_rule"] = pre_rule + word["distance"] = distance + word["password"] = pre_password + word["pre_rule"] = pre_rule word["best_rule_length"] = 9999 words.append(word) ####################################################################### # Perform Optimization - for word in sorted(words, key=lambda word: word["distance"], reverse=False): + for word in sorted(words, key=lambda w: w["distance"], reverse=False): # Optimize for best distance if not self.more_words: @@ -346,35 +442,35 @@ def generate_words(self,password): best_found_distance = word["distance"] elif word["distance"] > best_found_distance: - if self.verbose: - print "[-] %s => {edit distance suboptimal: %d (%d)} => %s" % \ - (word["suggestion"], word["distance"], best_found_distance, word["password"]) - break + if self.verbose: + print("[-] %s => {edit distance suboptimal: %d (%d)} => %s" % + (word["suggestion"], word["distance"], best_found_distance, word["password"])) + break - # Filter words with too big edit distance + # Filter words with too big edit distance if word["distance"] <= self.max_word_dist: - if self.debug: - print "[+] %s => {edit distance: %d (%d)} = > %s" % \ - (word["suggestion"], word["distance"],best_found_distance, word["password"]) + if self.debug: + print("[+] %s => {edit distance: %d (%d)} = > %s" % + (word["suggestion"], word["distance"], best_found_distance, word["password"])) words_collection.append(word) else: - if self.verbose: - print "[-] %s => {max distance exceeded: %d (%d)} => %s" % \ - (word["suggestion"], word["distance"], self.max_word_dist, word["password"]) + if self.verbose: + print("[-] %s => {max distance exceeded: %d (%d)} => %s" % + (word["suggestion"], word["distance"], self.max_word_dist, word["password"])) - if self.max_words: + if self.max_words: words_collection = words_collection[:self.max_words] return words_collection - def generate_simple_words(self,password): + def generate_simple_words(self, password): """ Generate simple words. A simple spellcheck.""" return self.enchant.suggest(password) - def generate_advanced_words(self,password): + def generate_advanced_words(self, password): """ Generate advanced words. Perform some additional non-destructive cleaning to help spell-checkers: 1) Remove non-alpha prefixes and appendixes. @@ -395,23 +491,32 @@ def generate_advanced_words(self,password): # Replace common special character replacements (1337 5p34k) preanalysis_password = '' for c in password: - if c in self.leet: preanalysis_password += self.leet[c] - else: preanalysis_password += c + if c in self.leet: + preanalysis_password += self.leet[c] + else: + preanalysis_password += c password = preanalysis_password - if self.debug: "[*] Preanalysis Password: %s" % password + if self.debug: + print("[*] Preanalysis Password: %s" % password) return self.enchant.suggest(password) ############################################################################ # Hashcat specific offset definition 0-9,A-Z - def int_to_hashcat(self,N): - if N < 10: return N - else: return chr(65+N-10) + @staticmethod + def int_to_hashcat(n): + if n < 10: + return n + else: + return chr(65 + n - 10) - def hashcat_to_int(self,N): - if N.isdigit(): return int(N) - else: return ord(N)-65+10 + @staticmethod + def hashcat_to_int(n): + if n.isdigit(): + return int(n) + else: + return ord(n) - 65 + 10 def generate_hashcat_rules(self, suggestion, password): """ Generate hashcat rules. Returns a length sorted list of lists of hashcat rules.""" @@ -427,15 +532,15 @@ def generate_hashcat_rules(self, suggestion, password): # Generate hashcat rule for each levenshtein rule for lev_rule in lev_rules: - if self.simple_rules: + if self.simple_rules: hashcat_rule = self.generate_simple_hashcat_rules(suggestion, lev_rule, password) - else: + else: hashcat_rule = self.generate_advanced_hashcat_rules(suggestion, lev_rule, password) - if hashcat_rule == None: - print "[!] Processing FAILED: %s => ;( => %s" % (suggestion,password) - print " Sorry about that, please report this failure to" - print " the developer: iphelix [at] thesprawl.org" + if hashcat_rule is None: + print("[!] Processing FAILED: %s => ;( => %s" % (suggestion, password)) + print(" Sorry about that, please report this failure to") + print(" the developer: iphelix [at] thesprawl.org") else: hashcat_rules.append(hashcat_rule) @@ -444,7 +549,7 @@ def generate_hashcat_rules(self, suggestion, password): ####################################################################### # Perform Optimization - for hashcat_rule in sorted(hashcat_rules, key=lambda hashcat_rule: len(hashcat_rule)): + for hashcat_rule in sorted(hashcat_rules, key=lambda rule: len(rule)): rule_length = len(hashcat_rule) @@ -453,9 +558,9 @@ def generate_hashcat_rules(self, suggestion, password): best_found_rule_length = rule_length elif rule_length > best_found_rule_length: - if self.verbose: - print "[-] %s => {best rule length exceeded: %d (%d)} => %s" % \ - (suggestion, rule_length, best_found_rule_length, password) + if self.verbose: + print("[-] %s => {best rule length exceeded: %d (%d)} => %s" % + (suggestion, rule_length, best_found_rule_length, password)) break if rule_length <= self.max_rule_len: @@ -463,46 +568,52 @@ def generate_hashcat_rules(self, suggestion, password): return hashcat_rules_collection - def generate_simple_hashcat_rules(self,word,rules,password): + def generate_simple_hashcat_rules(self, word, rules, password): """ Generate basic hashcat rules using only basic insert,delete,replace rules. """ hashcat_rules = [] - if self.debug: print "[*] Simple Processing %s => %s" % (word,password) + if self.debug: + print("[*] Simple Processing %s => %s" % (word, password)) # Dynamically apply rules to the source word # NOTE: Special case were word == password this would work as well. word_rules = word - for (op,p,w) in rules: + for (op, p, w) in rules: - if self.debug: print "\t[*] Simple Processing Started: %s - %s" % (word_rules, " ".join(hashcat_rules)) + if self.debug: + print("\t[*] Simple Processing Started: %s - %s" % (word_rules, " ".join(hashcat_rules))) if op == 'insert': - hashcat_rules.append("i%s%s" % (self.int_to_hashcat(p),password[p])) - word_rules = self.hashcat_rule['i'](word_rules,p,password[p]) + hashcat_rules.append("i%s%s" % (self.int_to_hashcat(p), password[p])) + word_rules = self.hashcat_rule['i'](word_rules, p, password[p]) elif op == 'delete': hashcat_rules.append("D%s" % self.int_to_hashcat(p)) - word_rules = self.hashcat_rule['D'](word_rules,p) + word_rules = self.hashcat_rule['D'](word_rules, p) elif op == 'replace': - hashcat_rules.append("o%s%s" % (self.int_to_hashcat(p),password[p])) - word_rules = self.hashcat_rule['o'](word_rules,p,password[p]) + hashcat_rules.append("o%s%s" % (self.int_to_hashcat(p), password[p])) + word_rules = self.hashcat_rule['o'](word_rules, p, password[p]) - if self.debug: print "\t[*] Simple Processing Ended: %s => %s => %s" % (word_rules, " ".join(hashcat_rules),password) + if self.debug: + print("\t[*] Simple Processing Ended: %s => %s => %s" % (word_rules, " ".join(hashcat_rules), password)) # Check if rules result in the correct password if word_rules == password: return hashcat_rules else: - if self.debug: print "[!] Simple Processing FAILED: %s => %s => %s (%s)" % (word," ".join(hashcat_rules),password,word_rules) + if self.debug: + print("[!] Simple Processing FAILED: %s => %s => %s (%s)" % + (word, " ".join(hashcat_rules), password, word_rules)) return None - def generate_advanced_hashcat_rules(self,word,rules,password): + def generate_advanced_hashcat_rules(self, word, rules, password): """ Generate advanced hashcat rules using full range of available rules. """ hashcat_rules = [] - if self.debug: print "[*] Advanced Processing %s => %s" % (word,password) + if self.debug: + print("[*] Advanced Processing %s => %s" % (word, password)) # Dynamically apply and store rules in word_rules variable. # NOTE: Special case where word == password this would work as well. @@ -512,17 +623,18 @@ def generate_advanced_hashcat_rules(self,word,rules,password): password_lower = len([c for c in password if c.islower()]) password_upper = len([c for c in password if c.isupper()]) - for i,(op,p,w) in enumerate(rules): + for i, (op, p, w) in enumerate(rules): - if self.debug: print "\t[*] Advanced Processing Started: %s - %s" % (word_rules, " ".join(hashcat_rules)) + if self.debug: + print("\t[*] Advanced Processing Started: %s - %s" % (word_rules, " ".join(hashcat_rules))) if op == 'insert': - hashcat_rules.append("i%s%s" % (self.int_to_hashcat(p),password[p])) - word_rules = self.hashcat_rule['i'](word_rules,p,password[p]) + hashcat_rules.append("i%s%s" % (self.int_to_hashcat(p), password[p])) + word_rules = self.hashcat_rule['i'](word_rules, p, password[p]) elif op == 'delete': hashcat_rules.append("D%s" % self.int_to_hashcat(p)) - word_rules = self.hashcat_rule['D'](word_rules,p) + word_rules = self.hashcat_rule['D'](word_rules, p) elif op == 'replace': @@ -538,118 +650,133 @@ def generate_advanced_hashcat_rules(self,word,rules,password): # This rule was made obsolete by a prior global replacement if word_rules[p] == password[p]: - if self.debug: print "\t[*] Advanced Processing Obsolete Rule: %s - %s" % (word_rules, " ".join(hashcat_rules)) + if self.debug: + print("\t[*] Advanced Processing Obsolete Rule: %s - %s" % + (word_rules, " ".join(hashcat_rules))) # Swapping rules - elif p < len(password)-1 and p < len(word_rules)-1 and word_rules[p] == password[p+1] and word_rules[p+1] == password[p]: + elif p < len(password) - 1 and p < len(word_rules) - 1 \ + and word_rules[p] == password[p + 1] and word_rules[p + 1] == password[p]: # Swap first two characters - if p == 0 and self.generate_simple_hashcat_rules( self.hashcat_rule['k'](word_rules), rules[i+1:],password): + if p == 0 and self.generate_simple_hashcat_rules(self.hashcat_rule['k'](word_rules), rules[i + 1:], + password): hashcat_rules.append("k") word_rules = self.hashcat_rule['k'](word_rules) # Swap last two characters - elif p == len(word_rules)-2 and self.generate_simple_hashcat_rules( self.hashcat_rule['K'](word_rules), rules[i+1:],password): + elif p == len(word_rules) - 2 and self.generate_simple_hashcat_rules( + self.hashcat_rule['K'](word_rules), rules[i + 1:], password): hashcat_rules.append("K") word_rules = self.hashcat_rule['K'](word_rules) # Swap any two characters (only adjacent swapping is supported) - elif self.generate_simple_hashcat_rules( self.hashcat_rule['*'](word_rules,p,p+1), rules[i+1:],password): - hashcat_rules.append("*%s%s" % (self.int_to_hashcat(p),self.int_to_hashcat(p+1))) - word_rules = self.hashcat_rule['*'](word_rules,p,p+1) + elif self.generate_simple_hashcat_rules(self.hashcat_rule['*'](word_rules, p, p + 1), rules[i + 1:], + password): + hashcat_rules.append("*%s%s" % (self.int_to_hashcat(p), self.int_to_hashcat(p + 1))) + word_rules = self.hashcat_rule['*'](word_rules, p, p + 1) else: - hashcat_rules.append("o%s%s" % (self.int_to_hashcat(p),password[p])) - word_rules = self.hashcat_rule['o'](word_rules,p,password[p]) - + hashcat_rules.append("o%s%s" % (self.int_to_hashcat(p), password[p])) + word_rules = self.hashcat_rule['o'](word_rules, p, password[p]) + # Case Toggle: Uppercased a letter elif word_rules[p].islower() and word_rules[p].upper() == password[p]: # Toggle the case of all characters in word (mixed cases) - if password_upper and password_lower and self.generate_simple_hashcat_rules( self.hashcat_rule['t'](word_rules), rules[i+1:],password): + if password_upper and password_lower and self.generate_simple_hashcat_rules( + self.hashcat_rule['t'](word_rules), rules[i + 1:], password): hashcat_rules.append("t") word_rules = self.hashcat_rule['t'](word_rules) # Capitalize all letters - elif self.generate_simple_hashcat_rules( self.hashcat_rule['u'](word_rules), rules[i+1:],password): + elif self.generate_simple_hashcat_rules(self.hashcat_rule['u'](word_rules), rules[i + 1:], + password): hashcat_rules.append("u") word_rules = self.hashcat_rule['u'](word_rules) # Capitalize the first letter - elif p == 0 and self.generate_simple_hashcat_rules( self.hashcat_rule['c'](word_rules), rules[i+1:],password): + elif p == 0 and self.generate_simple_hashcat_rules(self.hashcat_rule['c'](word_rules), + rules[i + 1:], password): hashcat_rules.append("c") word_rules = self.hashcat_rule['c'](word_rules) # Toggle the case of characters at position N else: hashcat_rules.append("T%s" % self.int_to_hashcat(p)) - word_rules = self.hashcat_rule['T'](word_rules,p) + word_rules = self.hashcat_rule['T'](word_rules, p) # Case Toggle: Lowercased a letter elif word_rules[p].isupper() and word_rules[p].lower() == password[p]: # Toggle the case of all characters in word (mixed cases) - if password_upper and password_lower and self.generate_simple_hashcat_rules( self.hashcat_rule['t'](word_rules), rules[i+1:],password): + if password_upper and password_lower and self.generate_simple_hashcat_rules( + self.hashcat_rule['t'](word_rules), rules[i + 1:], password): hashcat_rules.append("t") word_rules = self.hashcat_rule['t'](word_rules) # Lowercase all letters - elif self.generate_simple_hashcat_rules( self.hashcat_rule['l'](word_rules), rules[i+1:],password): + elif self.generate_simple_hashcat_rules(self.hashcat_rule['l'](word_rules), rules[i + 1:], + password): hashcat_rules.append("l") word_rules = self.hashcat_rule['l'](word_rules) # Lowercase the first found character, uppercase the rest - elif p == 0 and self.generate_simple_hashcat_rules( self.hashcat_rule['C'](word_rules), rules[i+1:],password): + elif p == 0 and self.generate_simple_hashcat_rules(self.hashcat_rule['C'](word_rules), + rules[i + 1:], password): hashcat_rules.append("C") word_rules = self.hashcat_rule['C'](word_rules) # Toggle the case of characters at position N else: hashcat_rules.append("T%s" % self.int_to_hashcat(p)) - word_rules = self.hashcat_rule['T'](word_rules,p) + word_rules = self.hashcat_rule['T'](word_rules, p) # Special case substitution of 'all' instances (1337 $p34k) - elif word_rules[p].isalpha() and not password[p].isalpha() and self.generate_simple_hashcat_rules( self.hashcat_rule['s'](word_rules,word_rules[p],password[p]), rules[i+1:],password): + elif word_rules[p].isalpha() and not password[p].isalpha() and self.generate_simple_hashcat_rules( + self.hashcat_rule['s'](word_rules, word_rules[p], password[p]), rules[i + 1:], password): # If we have already detected this rule, then skip it thus # reducing total rule count. # BUG: Elisabeth => sE3 sl1 u o3Z sE3 => 31IZAB3TH - #if not "s%s%s" % (word_rules[p],password[p]) in hashcat_rules: - hashcat_rules.append("s%s%s" % (word_rules[p],password[p])) - word_rules = self.hashcat_rule['s'](word_rules,word_rules[p],password[p]) - + # if not "s%s%s" % (word_rules[p],password[p]) in hashcat_rules: + hashcat_rules.append("s%s%s" % (word_rules[p], password[p])) + word_rules = self.hashcat_rule['s'](word_rules, word_rules[p], password[p]) + # Replace next character with current - elif p < len(password)-1 and p < len(word_rules)-1 and password[p] == password[p+1] and password[p] == word_rules[p+1]: + elif p < len(password) - 1 and p < len(word_rules) - 1 and password[p] == password[p + 1] \ + and password[p] == word_rules[p + 1]: hashcat_rules.append(".%s" % self.int_to_hashcat(p)) - word_rules = self.hashcat_rule['.'](word_rules,p) + word_rules = self.hashcat_rule['.'](word_rules, p) # Replace previous character with current - elif p > 0 and w > 0 and password[p] == password[p-1] and password[p] == word_rules[p-1]: + elif p > 0 and w > 0 and password[p] == password[p - 1] and password[p] == word_rules[p - 1]: hashcat_rules.append(",%s" % self.int_to_hashcat(p)) - word_rules = self.hashcat_rule[','](word_rules,p) + word_rules = self.hashcat_rule[','](word_rules, p) # ASCII increment elif ord(word_rules[p]) + 1 == ord(password[p]): hashcat_rules.append("+%s" % self.int_to_hashcat(p)) - word_rules = self.hashcat_rule['+'](word_rules,p) + word_rules = self.hashcat_rule['+'](word_rules, p) # ASCII decrement elif ord(word_rules[p]) - 1 == ord(password[p]): hashcat_rules.append("-%s" % self.int_to_hashcat(p)) - word_rules = self.hashcat_rule['-'](word_rules,p) + word_rules = self.hashcat_rule['-'](word_rules, p) # SHIFT left elif ord(word_rules[p]) << 1 == ord(password[p]): hashcat_rules.append("L%s" % self.int_to_hashcat(p)) - word_rules = self.hashcat_rule['L'](word_rules,p) + word_rules = self.hashcat_rule['L'](word_rules, p) # SHIFT right elif ord(word_rules[p]) >> 1 == ord(password[p]): hashcat_rules.append("R%s" % self.int_to_hashcat(p)) - word_rules = self.hashcat_rule['R'](word_rules,p) + word_rules = self.hashcat_rule['R'](word_rules, p) - # Position based replacements. + # Position based replacements. else: - hashcat_rules.append("o%s%s" % (self.int_to_hashcat(p),password[p])) - word_rules = self.hashcat_rule['o'](word_rules,p,password[p]) + hashcat_rules.append("o%s%s" % (self.int_to_hashcat(p), password[p])) + word_rules = self.hashcat_rule['o'](word_rules, p, password[p]) - if self.debug: print "\t[*] Advanced Processing Ended: %s %s" % (word_rules, " ".join(hashcat_rules)) + if self.debug: + print("\t[*] Advanced Processing Ended: %s %s" % (word_rules, " ".join(hashcat_rules))) ######################################################################## # Prefix rules @@ -660,12 +787,12 @@ def generate_advanced_hashcat_rules(self,word,rules,password): prefix_rules.append("^%s" % hashcat_rule[2]) last_prefix += 1 elif len(prefix_rules): - hashcat_rules = prefix_rules[::-1]+hashcat_rules[len(prefix_rules):] + hashcat_rules = prefix_rules[::-1] + hashcat_rules[len(prefix_rules):] break else: break - else: - hashcat_rules = prefix_rules[::-1]+hashcat_rules[len(prefix_rules):] + else: + hashcat_rules = prefix_rules[::-1] + hashcat_rules[len(prefix_rules):] #################################################################### # Appendix rules @@ -674,14 +801,14 @@ def generate_advanced_hashcat_rules(self,word,rules,password): for hashcat_rule in hashcat_rules[::-1]: if hashcat_rule[0] == "i" and self.hashcat_to_int(hashcat_rule[1]) == last_appendix: appendix_rules.append("$%s" % hashcat_rule[2]) - last_appendix-= 1 + last_appendix -= 1 elif len(appendix_rules): - hashcat_rules = hashcat_rules[:-len(appendix_rules)]+appendix_rules[::-1] + hashcat_rules = hashcat_rules[:-len(appendix_rules)] + appendix_rules[::-1] break else: break else: - hashcat_rules = hashcat_rules[:-len(appendix_rules)]+appendix_rules[::-1] + hashcat_rules = hashcat_rules[:-len(appendix_rules)] + appendix_rules[::-1] #################################################################### # Truncate left rules @@ -691,67 +818,81 @@ def generate_advanced_hashcat_rules(self,word,rules,password): if hashcat_rule[0] == "D" and self.hashcat_to_int(hashcat_rule[1]) == last_precut: precut_rules.append("[") elif len(precut_rules): - hashcat_rules = precut_rules[::-1]+hashcat_rules[len(precut_rules):] + hashcat_rules = precut_rules[::-1] + hashcat_rules[len(precut_rules):] break else: break - else: - hashcat_rules = precut_rules[::-1]+hashcat_rules[len(precut_rules):] + else: + hashcat_rules = precut_rules[::-1] + hashcat_rules[len(precut_rules):] #################################################################### # Truncate right rules last_postcut = len(password) postcut_rules = list() for hashcat_rule in hashcat_rules[::-1]: - + if hashcat_rule[0] == "D" and self.hashcat_to_int(hashcat_rule[1]) >= last_postcut: postcut_rules.append("]") elif len(postcut_rules): - hashcat_rules = hashcat_rules[:-len(postcut_rules)]+postcut_rules[::-1] + hashcat_rules = hashcat_rules[:-len(postcut_rules)] + postcut_rules[::-1] break else: break else: - hashcat_rules = hashcat_rules[:-len(postcut_rules)]+postcut_rules[::-1] + hashcat_rules = hashcat_rules[:-len(postcut_rules)] + postcut_rules[::-1] # Check if rules result in the correct password if word_rules == password: return hashcat_rules else: - if self.debug: print "[!] Advanced Processing FAILED: %s => %s => %s (%s)" % (word," ".join(hashcat_rules),password,word_rules) + if self.debug: + print("[!] Advanced Processing FAILED: %s => %s => %s (%s)" % + (word, " ".join(hashcat_rules), password, word_rules)) return None - def check_reversible_password(self, password): """ Check whether the password is likely to be reversed successfuly. """ # Skip all numeric passwords - if password.isdigit(): - if self.verbose and not self.quiet: print "[!] %s => {skipping numeric} => %s" % (password,password) + if password.isdigit(): + if self.verbose and not self.quiet: + print("[!] %s => {skipping numeric} => %s" % (password, password)) self.numeric_stats_total += 1 return False # Skip passwords with less than 25% of alpha character # TODO: Make random word detection more reliable based on word entropy. - elif len([c for c in password if c.isalpha()]) < len(password)/4: - if self.verbose and not self.quiet:print "[!] %s => {skipping alpha less than 25%%} => %s" % (password,password) + elif len([c for c in password if c.isalpha()]) < len(password) // 4: + if self.verbose and not self.quiet: + print("[!] %s => {skipping alpha less than 25%%} => %s" % (password, password)) self.special_stats_total += 1 return False # Only check english ascii passwords for now # TODO: Add support for more languages. elif [c for c in password if ord(c) < 32 or ord(c) > 126]: - if self.verbose and not self.quiet: print "[!] %s => {skipping non ascii english} => %s" % (password,password) + if self.verbose and not self.quiet: + print("[!] %s => {skipping non ascii english} => %s" % (password, password)) self.foreign_stats_total += 1 return False else: return True - def analyze_password(self,password, rules_queue=multiprocessing.Queue(), words_queue=multiprocessing.Queue()): - """ Analyze a single password. """ + def analyze_password(self, password, rules_queue=None, words_queue=None): + """ Analyze a single password. - if self.verbose: print "[*] Analyzing password: %s" % password + When no queues are supplied (e.g. the ``--password`` debugging mode) the + generated rules and words are printed to stdout instead. + """ + + if rules_queue is None: + rules_queue = _PrintCollector("[rule]") + if words_queue is None: + words_queue = _PrintCollector("[word]") + + if self.verbose: + print("[*] Analyzing password: %s" % password) words = [] @@ -761,7 +902,7 @@ def analyze_password(self,password, rules_queue=multiprocessing.Queue(), words_q word = dict() word["password"] = password word["suggestion"] = password - word["hashcat_rules"] = [[],] + word["hashcat_rules"] = [[], ] word["pre_rule"] = [] word["best_rule_length"] = 9999 @@ -775,9 +916,8 @@ def analyze_password(self,password, rules_queue=multiprocessing.Queue(), words_q # Generate levenshtein reverse paths for each suggestion for word in words: - # Generate a collection of hashcat_rules lists - word["hashcat_rules"] = self.generate_hashcat_rules(word["suggestion"],word["password"]) + word["hashcat_rules"] = self.generate_hashcat_rules(word["suggestion"], word["password"]) self.print_hashcat_rules(words, password, rules_queue, words_queue) @@ -786,7 +926,7 @@ def print_hashcat_rules(self, words, password, rules_queue, words_queue): best_found_rule_length = 9999 # Sorted list based on rule length - for word in sorted(words, key=lambda word: len(word["hashcat_rules"][0])): + for word in sorted(words, key=lambda w: len(w["hashcat_rules"][0])): words_queue.put(word["suggestion"]) @@ -799,84 +939,95 @@ def print_hashcat_rules(self, words, password, rules_queue, words_queue): best_found_rule_length = rule_length elif rule_length > best_found_rule_length: - if self.verbose: - print "[-] %s => {best rule length exceeded: %d (%d)} => %s" % \ - (word["suggestion"], rule_length, best_found_rule_length, password) + if self.verbose: + print("[-] %s => {best rule length exceeded: %d (%d)} => %s" % + (word["suggestion"], rule_length, best_found_rule_length, password)) break if rule_length <= self.max_rule_len: - hashcat_rule_str = " ".join(hashcat_rule + word["pre_rule"] or [':']) - if self.verbose: print "[+] %s => %s => %s" % (word["suggestion"], hashcat_rule_str, password) + if self.verbose: + print("[+] %s => %s => %s" % (word["suggestion"], hashcat_rule_str, password)) rules_queue.put(hashcat_rule_str) - - def password_worker(self,i, passwords_queue, rules_queue, words_queue): - if self.debug: print "[*] Password analysis worker [%d] started." % i + def password_worker(self, i, passwords_queue, rules_queue, words_queue): + if self.debug: + print("[*] Password analysis worker [%d] started." % i) try: while True: password = passwords_queue.get() # Interrupted by a Death Pill - if password == None: break + if password is None: + break self.analyze_password(password, rules_queue, words_queue) except (KeyboardInterrupt, SystemExit): - if self.debug: print "[*] Password analysis worker [%d] terminated." % i + if self.debug: + print("[*] Password analysis worker [%d] terminated." % i) - if self.debug: print "[*] Password analysis worker [%d] stopped." % i + if self.debug: + print("[*] Password analysis worker [%d] stopped." % i) def rule_worker(self, rules_queue, output_rules_filename): """ Worker to store generated rules. """ - print "[*] Saving rules to %s" % output_rules_filename + print("[*] Saving rules to %s" % output_rules_filename) f = open(output_rules_filename, 'w') - if self.debug: print "[*] Rule worker started." + if self.debug: + print("[*] Rule worker started.") try: while True: rule = rules_queue.get() # Interrupted by a Death Pill - if rule == None: break + if rule is None: + break f.write("%s\n" % rule) f.flush() except (KeyboardInterrupt, SystemExit): - if self.debug: print "[*] Rule worker terminated." + if self.debug: + print("[*] Rule worker terminated.") f.close() - if self.debug: print "[*] Rule worker stopped." + if self.debug: + print("[*] Rule worker stopped.") def word_worker(self, words_queue, output_words_filename): """ Worker to store generated rules. """ - print "[*] Saving words to %s" % output_words_filename + print("[*] Saving words to %s" % output_words_filename) f = open(output_words_filename, 'w') - if self.debug: print "[*] Word worker started." + if self.debug: + print("[*] Word worker started.") try: while True: word = words_queue.get() # Interrupted by a Death Pill - if word == None: break + if word is None: + break f.write("%s\n" % word) f.flush() except (KeyboardInterrupt, SystemExit): - if self.debug: print "[*] Word worker terminated." + if self.debug: + print("[*] Word worker terminated.") f.close() - if self.debug: print "[*] Word worker stopped." + if self.debug: + print("[*] Word worker stopped.") # Analyze passwords file - def analyze_passwords_file(self,passwords_file): + def analyze_passwords_file(self, passwords_file): """ Analyze provided passwords file. """ - print "[*] Analyzing passwords file: %s:" % passwords_file - print "[*] Press Ctrl-C to end execution and generate statistical analysis." + print("[*] Analyzing passwords file: %s:" % passwords_file) + print("[*] Press Ctrl-C to end execution and generate statistical analysis.") # Setup queues passwords_queue = multiprocessing.Queue(self.threads) @@ -885,18 +1036,19 @@ def analyze_passwords_file(self,passwords_file): # Start workers for i in range(self.threads): - multiprocessing.Process(target=self.password_worker, args=(i, passwords_queue, rules_queue, words_queue)).start() + multiprocessing.Process(target=self.password_worker, + args=(i, passwords_queue, rules_queue, words_queue)).start() multiprocessing.Process(target=self.rule_worker, args=(rules_queue, "%s.rule" % self.basename)).start() multiprocessing.Process(target=self.word_worker, args=(words_queue, "%s.word" % self.basename)).start() # Continue with the main thread - f = open(passwords_file,'r') + f = open(passwords_file, 'r', encoding="latin-1", errors='ignore') password_count = 0 analysis_start = time.time() segment_start = analysis_start - try: + try: for password in f: password = password.rstrip('\r\n') if len(password) > 0: @@ -904,8 +1056,8 @@ def analyze_passwords_file(self,passwords_file): # Provide analysis time feedback to the user if not self.quiet and password_count != 0 and password_count % 5000 == 0: segment_time = time.time() - segment_start - print "[*] Processed %d passwords in %.2f seconds at the rate of %.2f p/sec" % \ - (password_count, segment_start - analysis_start, 5000/segment_time ) + print("[*] Processed %d passwords in %.2f seconds at the rate of %.2f p/sec" % + (password_count, segment_start - analysis_start, 5000 / segment_time)) segment_start = time.time() password_count += 1 @@ -915,14 +1067,14 @@ def analyze_passwords_file(self,passwords_file): passwords_queue.put(password) except (KeyboardInterrupt, SystemExit): - print "\n[!] Rulegen was interrupted." + print("\n[!] Rulegen was interrupted.") else: # Signal workers to stop. for i in range(self.threads): - passwords_queue.put(None) + passwords_queue.put(None) - # Wait for all of the queued passwords to finish. + # Wait for all of the queued passwords to finish. while not passwords_queue.empty(): time.sleep(1) @@ -933,159 +1085,176 @@ def analyze_passwords_file(self,passwords_file): f.close() analysis_time = time.time() - analysis_start - print "[*] Finished processing %d passwords in %.2f seconds at the rate of %.2f p/sec" % (password_count, analysis_time, float(password_count)/analysis_time ) + print("[*] Finished processing %d passwords in %.2f seconds at the rate of %.2f p/sec" % + (password_count, analysis_time, float(password_count) / analysis_time)) - print "[*] Generating statistics for [%s] rules and words." % self.basename - print "[-] Skipped %d all numeric passwords (%0.2f%%)" % \ - (self.numeric_stats_total, float(self.numeric_stats_total)*100.0/float(password_count)) - print "[-] Skipped %d passwords with less than 25%% alpha characters (%0.2f%%)" % \ - (self.special_stats_total, float(self.special_stats_total)*100.0/float(password_count)) - print "[-] Skipped %d passwords with non ascii characters (%0.2f%%)" % \ - (self.foreign_stats_total, float(self.foreign_stats_total)*100.0/float(password_count)) + print("[*] Generating statistics for [%s] rules and words." % self.basename) + print("[-] Skipped %d all numeric passwords (%0.2f%%)" % + (self.numeric_stats_total, float(self.numeric_stats_total) * 100.0 / float(password_count))) + print("[-] Skipped %d passwords with less than 25%% alpha characters (%0.2f%%)" % + (self.special_stats_total, float(self.special_stats_total) * 100.0 / float(password_count))) + print("[-] Skipped %d passwords with non ascii characters (%0.2f%%)" % + (self.foreign_stats_total, float(self.foreign_stats_total) * 100.0 / float(password_count))) # TODO: Counter breaks on large files. uniq -c | sort -rn is still the most # optimal way. - rules_file = open("%s.rule" % self.basename,'r') - rules_sorted_file = open("%s-sorted.rule" % self.basename, 'w') - rules_counter = Counter(rules_file) + with open("%s.rule" % self.basename, 'r') as rules_file: + rules_counter = Counter(rules_file) rule_counter_total = sum(rules_counter.values()) - print "\n[*] Top 10 rules" - rules_i = 0 - for (rule, count) in rules_counter.most_common(): - rules_sorted_file.write(rule) - if rules_i < 10: print "[+] %s - %d (%0.2f%%)" % (rule.rstrip('\r\n'), count, count*100/rule_counter_total) - rules_i += 1 - - rules_file.close() - rules_sorted_file.close() - + print("\n[*] Top 10 rules") + with open("%s-sorted.rule" % self.basename, 'w') as rules_sorted_file: + for rules_i, (rule, count) in enumerate(rules_counter.most_common()): + rules_sorted_file.write(rule) + if rules_i < 10: + print("[+] %s - %d (%0.2f%%)" % (rule.rstrip('\r\n'), count, count * 100 / rule_counter_total)) - words_file = open("%s.word" % self.basename,'r') - words_sorted_file = open("%s-sorted.word" % self.basename,'w') - words_counter = Counter(words_file) - word_counter_total = sum(rules_counter.values()) + with open("%s.word" % self.basename, 'r') as words_file: + words_counter = Counter(words_file) + word_counter_total = sum(words_counter.values()) - print "\n[*] Top 10 words" - words_i = 0 - for (word, count) in words_counter.most_common(): - words_sorted_file.write(word) - if words_i < 10: print "[+] %s - %d (%0.2f%%)" % (word.rstrip('\r\n'), count, count*100/word_counter_total) - words_i += 1 - - words_file.close() - words_sorted_file.close() + print("\n[*] Top 10 words") + with open("%s-sorted.word" % self.basename, 'w') as words_sorted_file: + for words_i, (word, count) in enumerate(words_counter.most_common()): + words_sorted_file.write(word) + if words_i < 10: + print("[+] %s - %d (%0.2f%%)" % (word.rstrip('\r\n'), count, count * 100 / word_counter_total)) ############################################################################ - def verify_hashcat_rules(self,word, rules, password): + def verify_hashcat_rules(self, word, rules, password): - f = open("%s/test.rule" % HASHCAT_PATH,'w') + f = open("%s/test.rule" % HASHCAT_PATH, 'w') f.write(" ".join(rules)) f.close() - f = open("%s/test.word" % HASHCAT_PATH,'w') + f = open("%s/test.word" % HASHCAT_PATH, 'w') f.write(word) f.close() - p = subprocess.Popen(["%s/hashcat-cli64.bin" % HASHCAT_PATH,"-r","%s/test.rule" % HASHCAT_PATH,"--stdout","%s/test.word" % HASHCAT_PATH], stdout=subprocess.PIPE) + p = subprocess.Popen(["%s/hashcat-cli64.bin" % HASHCAT_PATH, "-r", "%s/test.rule" % HASHCAT_PATH, "--stdout", + "%s/test.word" % HASHCAT_PATH], stdout=subprocess.PIPE) out, err = p.communicate() out = out.strip() if out == password: hashcat_rules_str = " ".join(rules or [':']) - if self.verbose: print "[+] %s => %s => %s" % (word, hashcat_rules_str, password) + if self.verbose: + print("[+] %s => %s => %s" % (word, hashcat_rules_str, password)) else: - print "[!] Hashcat Verification FAILED: %s => %s => %s (%s)" % (word," ".join(rules or [':']),password,out) - -if __name__ == "__main__": - - header = " _ \n" - header += " RuleGen %s | |\n" % VERSION - header += " _ __ __ _ ___| | _\n" - header += " | '_ \ / _` |/ __| |/ /\n" - header += " | |_) | (_| | (__| < \n" - header += " | .__/ \__,_|\___|_|\_\\\n" - header += " | | \n" - header += " |_| iphelix@thesprawl.org\n" - header += "\n" - - - parser = OptionParser("%prog [options] passwords.txt", version="%prog "+VERSION) - - parser.add_option("-b","--basename", help="Output base name. The following files will be generated: basename.words, basename.rules and basename.stats", default="analysis",metavar="rockyou") - parser.add_option("-w","--wordlist", help="Use a custom wordlist for rule analysis.", metavar="wiki.dict") - parser.add_option("-q", "--quiet", action="store_true", dest="quiet", default=False, help="Don't show headers.") - parser.add_option("--threads", type="int", default=multiprocessing.cpu_count(), help="Parallel threads to use for processing.") - - wordtune = OptionGroup(parser, "Fine tune source word generation:") - wordtune.add_option("--maxworddist", help="Maximum word edit distance (Levenshtein)", type="int", default=10, metavar="10") - wordtune.add_option("--maxwords", help="Maximum number of source word candidates to consider", type="int", default=5, metavar="5") - wordtune.add_option("--morewords", help="Consider suboptimal source word candidates", action="store_true", default=False) - wordtune.add_option("--simplewords", help="Generate simple source words for given passwords", action="store_true", default=False) - parser.add_option_group(wordtune) - - ruletune = OptionGroup(parser, "Fine tune rule generation:") - ruletune.add_option("--maxrulelen", help="Maximum number of operations in a single rule", type="int", default=10, metavar="10") - ruletune.add_option("--maxrules", help="Maximum number of rules to consider", type="int", default=5, metavar="5") - ruletune.add_option("--morerules", help="Generate suboptimal rules", action="store_true", default=False) - ruletune.add_option("--simplerules", help="Generate simple rules insert,delete,replace",action="store_true", default=False) - ruletune.add_option("--bruterules", help="Bruteforce reversal and rotation rules (slow)",action="store_true", default=False) - parser.add_option_group(ruletune) - - spelltune = OptionGroup(parser, "Fine tune spell checker engine:") - spelltune.add_option("--providers", help="Comma-separated list of provider engines", default="aspell,myspell", metavar="aspell,myspell") - parser.add_option_group(spelltune) - - debug = OptionGroup(parser, "Debuggin options:") - debug.add_option("-v","--verbose", help="Show verbose information.", action="store_true", default=False) - debug.add_option("-d","--debug", help="Debug rules.", action="store_true", default=False) - debug.add_option("--password", help="Process the last argument as a password not a file.", action="store_true", default=False) - debug.add_option("--word", help="Use a custom word for rule analysis", metavar="Password") - debug.add_option("--hashcat", help="Test generated rules with hashcat-cli", action="store_true", default=False) - parser.add_option_group(debug) - - (options, args) = parser.parse_args() + print("[!] Hashcat Verification FAILED: %s => %s => %s (%s)" % + (word, " ".join(rules or [':']), password, out)) + + +def main(): + + header = r""" _ + RuleGen %s | | + _ __ __ _ ___| | _ + | '_ \ / _` |/ __| |/ / + | |_) | (_| | (__| < + | .__/ \__,_|\___|_|\_\ + | | + |_| iphelix@thesprawl.org +""" % VERSION + + parser = argparse.ArgumentParser( + description="Advanced automated password rule and wordlist generator for hashcat.") + parser.add_argument("--version", action="version", version="%(prog)s " + VERSION) + parser.add_argument("passwords", metavar="passwords.txt", + help="Password file to analyze (or a single password with --password).") + + parser.add_argument("-b", "--basename", default="analysis", metavar="rockyou", + help="Output base name. The files basename.rule and basename.word " + "(plus their -sorted variants) are generated.") + parser.add_argument("-w", "--wordlist", metavar="wiki.dict", + help="Use a custom wordlist for rule analysis.") + parser.add_argument("-q", "--quiet", action="store_true", help="Don't show headers.") + parser.add_argument("--threads", type=int, default=multiprocessing.cpu_count(), + help="Parallel worker processes to use for processing.") + + wordtune = parser.add_argument_group("Fine tune source word generation") + wordtune.add_argument("--maxworddist", type=int, default=10, metavar="10", + help="Maximum word edit distance (Levenshtein)") + wordtune.add_argument("--maxwords", type=int, default=5, metavar="5", + help="Maximum number of source word candidates to consider") + wordtune.add_argument("--morewords", action="store_true", help="Consider suboptimal source word candidates") + wordtune.add_argument("--simplewords", action="store_true", help="Generate simple source words for given passwords") + + ruletune = parser.add_argument_group("Fine tune rule generation") + ruletune.add_argument("--maxrulelen", type=int, default=10, metavar="10", + help="Maximum number of operations in a single rule") + ruletune.add_argument("--maxrules", type=int, default=5, metavar="5", + help="Maximum number of rules to consider") + ruletune.add_argument("--morerules", action="store_true", help="Generate suboptimal rules") + ruletune.add_argument("--simplerules", action="store_true", help="Generate simple rules insert,delete,replace") + ruletune.add_argument("--bruterules", action="store_true", + help="Bruteforce reversal and rotation rules (slow)") + + spelltune = parser.add_argument_group("Fine tune spell checker engine") + spelltune.add_argument("--providers", default="aspell,hunspell", metavar="aspell,hunspell", + help="Comma-separated list of enchant provider engines") + + debug = parser.add_argument_group("Debugging options") + debug.add_argument("-v", "--verbose", action="store_true", help="Show verbose information.") + debug.add_argument("-d", "--debug", action="store_true", help="Debug rules.") + debug.add_argument("--password", action="store_true", + help="Process the argument as a single password rather than a file.") + debug.add_argument("--word", metavar="Password", help="Use a custom word for rule analysis") + debug.add_argument("--hashcat", action="store_true", help="Test generated rules with hashcat-cli") + + options = parser.parse_args() # Print program header if not options.quiet: - print header - - if len(args) < 1: - parser.error("no passwords file specified") - exit(1) - - rulegen = RuleGen(language="en", providers=options.providers, basename=options.basename, threads=options.threads) + print(header) + + try: + rulegen = RuleGen(language="en", providers=options.providers, basename=options.basename, + threads=options.threads) + except ImportError as error: + print("[-] %s" % error) + sys.exit(1) + except enchant.errors.DictNotFoundError: + print("[-] Cannot find a dictionary for specified language. Please install it and try again.") + print("[*] Hint: Usually this dictionary resides within an aspell / hunspell package.") + sys.exit(1) # Finetuning word generation - rulegen.max_word_dist=options.maxworddist - rulegen.max_words=options.maxwords - rulegen.more_words=options.morewords - rulegen.simple_words=options.simplewords + rulegen.max_word_dist = options.maxworddist + rulegen.max_words = options.maxwords + rulegen.more_words = options.morewords + rulegen.simple_words = options.simplewords # Finetuning rule generation - rulegen.max_rule_len=options.maxrulelen - rulegen.max_rules=options.maxrules - rulegen.more_rules=options.morerules - rulegen.simple_rules=options.simplerules - rulegen.brute_rules=options.bruterules - if rulegen.brute_rules: print "[!] Bruteforcing reversal and rotation rules. (slower)" + rulegen.max_rule_len = options.maxrulelen + rulegen.max_rules = options.maxrules + rulegen.more_rules = options.morerules + rulegen.simple_rules = options.simplerules + rulegen.brute_rules = options.bruterules + if rulegen.brute_rules: + print("[!] Bruteforcing reversal and rotation rules. (slower)") # Debugging options rulegen.word = options.word - rulegen.verbose=options.verbose + rulegen.verbose = options.verbose rulegen.debug = options.debug rulegen.hashcat = options.hashcat rulegen.quiet = options.quiet # Custom wordlist if not options.word: - if options.wordlist: rulegen.load_custom_wordlist(options.wordlist) - print "[*] Using Enchant '%s' module. For best results please install" % rulegen.enchant.provider.name - print " '%s' module language dictionaries." % rulegen.enchant.provider.name + if options.wordlist: + rulegen.load_custom_wordlist(options.wordlist) + print("[*] Using Enchant '%s' module. For best results please install" % rulegen.enchant.provider.name) + print(" '%s' module language dictionaries." % rulegen.enchant.provider.name) # Analyze a single password or several passwords in a file - if options.password: - rulegen.analyze_password(args[0]) + if options.password: + rulegen.analyze_password(options.passwords) else: - rulegen.analyze_passwords_file(args[0]) + rulegen.analyze_passwords_file(options.passwords) + + +if __name__ == "__main__": + main() diff --git a/statsgen.py b/statsgen.py index 312c49d..4adc804 100755 --- a/statsgen.py +++ b/statsgen.py @@ -1,39 +1,40 @@ -#!/usr/bin/env python +#!/usr/bin/env python3 # StatsGen - Password Statistical Analysis tool # # This tool is part of PACK (Password Analysis and Cracking Kit) # -# VERSION 0.0.3 +# VERSION 0.0.4 # # Copyright (C) 2013 Peter Kacherginsky # All rights reserved. # # Please see the attached LICENSE file for additional licensing information. -import sys -import re, operator, string -from optparse import OptionParser, OptionGroup -import time +import argparse +import operator +import string +from collections import Counter + +VERSION = "0.0.4" -VERSION = "0.0.3" class StatsGen: def __init__(self): self.output_file = None # Filters - self.minlength = None - self.maxlength = None + self.minlength = None + self.maxlength = None self.simplemasks = None - self.charsets = None + self.charsets = None self.quiet = False self.debug = True # Stats dictionaries - self.stats_length = dict() - self.stats_simplemasks = dict() - self.stats_advancedmasks = dict() - self.stats_charactersets = dict() + self.stats_length = Counter() + self.stats_simplemasks = Counter() + self.stats_advancedmasks = Counter() + self.stats_charactersets = Counter() # Ignore stats with less than 1% coverage self.hiderare = False @@ -42,17 +43,18 @@ def __init__(self): self.total_counter = 0 # Minimum password complexity counters - self.mindigit = None - self.minupper = None - self.minlower = None + self.mindigit = None + self.minupper = None + self.minlower = None self.minspecial = None - self.maxdigit = None - self.maxupper = None - self.maxlower = None + self.maxdigit = None + self.maxupper = None + self.maxlower = None self.maxspecial = None - def analyze_password(self, password): + @staticmethod + def analyze_password(password): # Password length pass_length = len(password) @@ -68,193 +70,229 @@ def analyze_password(self, password): # Detect simple and advanced masks for letter in password: - + if letter in string.digits: digit += 1 advancedmask_string += "?d" - if not simplemask or not simplemask[-1] == 'digit': simplemask.append('digit') + if not simplemask or not simplemask[-1] == 'digit': + simplemask.append('digit') - elif letter in string.lowercase: + elif letter in string.ascii_lowercase: lower += 1 advancedmask_string += "?l" - if not simplemask or not simplemask[-1] == 'string': simplemask.append('string') - + if not simplemask or not simplemask[-1] == 'string': + simplemask.append('string') - elif letter in string.uppercase: + elif letter in string.ascii_uppercase: upper += 1 advancedmask_string += "?u" - if not simplemask or not simplemask[-1] == 'string': simplemask.append('string') + if not simplemask or not simplemask[-1] == 'string': + simplemask.append('string') else: special += 1 advancedmask_string += "?s" - if not simplemask or not simplemask[-1] == 'special': simplemask.append('special') - + if not simplemask or not simplemask[-1] == 'special': + simplemask.append('special') # String representation of masks simplemask_string = ''.join(simplemask) if len(simplemask) <= 3 else 'othermask' # Policy - policy = (digit,lower,upper,special) + policy = (digit, lower, upper, special) # Determine character-set - if digit and not lower and not upper and not special: charset = 'numeric' - elif not digit and lower and not upper and not special: charset = 'loweralpha' - elif not digit and not lower and upper and not special: charset = 'upperalpha' - elif not digit and not lower and not upper and special: charset = 'special' - - elif not digit and lower and upper and not special: charset = 'mixedalpha' - elif digit and lower and not upper and not special: charset = 'loweralphanum' - elif digit and not lower and upper and not special: charset = 'upperalphanum' - elif not digit and lower and not upper and special: charset = 'loweralphaspecial' - elif not digit and not lower and upper and special: charset = 'upperalphaspecial' - elif digit and not lower and not upper and special: charset = 'specialnum' - - elif not digit and lower and upper and special: charset = 'mixedalphaspecial' - elif digit and not lower and upper and special: charset = 'upperalphaspecialnum' - elif digit and lower and not upper and special: charset = 'loweralphaspecialnum' - elif digit and lower and upper and not special: charset = 'mixedalphanum' - else: charset = 'all' - - return (pass_length, charset, simplemask_string, advancedmask_string, policy) + if digit and not lower and not upper and not special: + charset = 'numeric' + elif not digit and lower and not upper and not special: + charset = 'loweralpha' + elif not digit and not lower and upper and not special: + charset = 'upperalpha' + elif not digit and not lower and not upper and special: + charset = 'special' + elif not digit and lower and upper and not special: + charset = 'mixedalpha' + elif digit and lower and not upper and not special: + charset = 'loweralphanum' + elif digit and not lower and upper and not special: + charset = 'upperalphanum' + elif not digit and lower and not upper and special: + charset = 'loweralphaspecial' + elif not digit and not lower and upper and special: + charset = 'upperalphaspecial' + elif digit and not lower and not upper and special: + charset = 'specialnum' + elif not digit and lower and upper and special: + charset = 'mixedalphaspecial' + elif digit and not lower and upper and special: + charset = 'upperalphaspecialnum' + elif digit and lower and not upper and special: + charset = 'loweralphaspecialnum' + elif digit and lower and upper and not special: + charset = 'mixedalphanum' + else: + charset = 'all' + + return pass_length, charset, simplemask_string, advancedmask_string, policy def generate_stats(self, filename): """ Generate password statistics. """ - with open(filename, 'r') as f: - + with open(filename, 'r', encoding="latin-1", errors='ignore') as f: for password in f: password = password.rstrip('\r\n') - if len(password) == 0: continue + # if the password is empty, continue + if not password: + continue - self.total_counter += 1 + self.total_counter += 1 - (pass_length,characterset,simplemask,advancedmask, policy) = self.analyze_password(password) - (digit,lower,upper,special) = policy + (pass_length, characterset, simplemask, advancedmask, policy) = self.analyze_password(password) + (digit, lower, upper, special) = policy - if (self.charsets == None or characterset in self.charsets) and \ - (self.simplemasks == None or simplemask in self.simplemasks) and \ - (self.maxlength == None or pass_length <= self.maxlength) and \ - (self.minlength == None or pass_length >= self.minlength): + if (self.charsets is None or characterset in self.charsets) and \ + (self.simplemasks is None or simplemask in self.simplemasks) and \ + (self.maxlength is None or pass_length <= self.maxlength) and \ + (self.minlength is None or pass_length >= self.minlength): self.filter_counter += 1 - if self.mindigit == None or digit < self.mindigit: self.mindigit = digit - if self.maxdigit == None or digit > self.maxdigit: self.maxdigit = digit + if self.mindigit is None or digit < self.mindigit: + self.mindigit = digit + if self.maxdigit is None or digit > self.maxdigit: + self.maxdigit = digit - if self.minupper == None or upper < self.minupper: self.minupper = upper - if self.maxupper == None or upper > self.maxupper: self.maxupper = upper + if self.minupper is None or upper < self.minupper: + self.minupper = upper + if self.maxupper is None or upper > self.maxupper: + self.maxupper = upper - if self.minlower == None or lower < self.minlower: self.minlower = lower - if self.maxlower == None or lower > self.maxlower: self.maxlower = lower + if self.minlower is None or lower < self.minlower: + self.minlower = lower + if self.maxlower is None or lower > self.maxlower: + self.maxlower = lower - if self.minspecial == None or special < self.minspecial: self.minspecial = special - if self.maxspecial == None or special > self.maxspecial: self.maxspecial = special + if self.minspecial is None or special < self.minspecial: + self.minspecial = special + if self.maxspecial is None or special > self.maxspecial: + self.maxspecial = special - if pass_length in self.stats_length: - self.stats_length[pass_length] += 1 - else: - self.stats_length[pass_length] = 1 - - if characterset in self.stats_charactersets: - self.stats_charactersets[characterset] += 1 - else: - self.stats_charactersets[characterset] = 1 - - if simplemask in self.stats_simplemasks: - self.stats_simplemasks[simplemask] += 1 - else: - self.stats_simplemasks[simplemask] = 1 - - if advancedmask in self.stats_advancedmasks: - self.stats_advancedmasks[advancedmask] += 1 - else: - self.stats_advancedmasks[advancedmask] = 1 + self.stats_length[pass_length] += 1 + self.stats_charactersets[characterset] += 1 + self.stats_simplemasks[simplemask] += 1 + self.stats_advancedmasks[advancedmask] += 1 def print_stats(self): """ Print password statistics. """ - print "[+] Analyzing %d%% (%d/%d) of passwords" % (self.filter_counter*100/self.total_counter, self.filter_counter, self.total_counter) - print " NOTE: Statistics below is relative to the number of analyzed passwords, not total number of passwords" - print "\n[*] Length:" - for (length,count) in sorted(self.stats_length.iteritems(), key=operator.itemgetter(1), reverse=True): - if self.hiderare and not count*100/self.filter_counter > 0: continue - print "[+] %25d: %02d%% (%d)" % (length, count*100/self.filter_counter, count) - - print "\n[*] Character-set:" - for (char,count) in sorted(self.stats_charactersets.iteritems(), key=operator.itemgetter(1), reverse=True): - if self.hiderare and not count*100/self.filter_counter > 0: continue - print "[+] %25s: %02d%% (%d)" % (char, count*100/self.filter_counter, count) - - print "\n[*] Password complexity:" - print "[+] digit: min(%s) max(%s)" % (self.mindigit, self.maxdigit) - print "[+] lower: min(%s) max(%s)" % (self.minlower, self.maxlower) - print "[+] upper: min(%s) max(%s)" % (self.minupper, self.maxupper) - print "[+] special: min(%s) max(%s)" % (self.minspecial, self.maxspecial) - - print "\n[*] Simple Masks:" - for (simplemask,count) in sorted(self.stats_simplemasks.iteritems(), key=operator.itemgetter(1), reverse=True): - if self.hiderare and not count*100/self.filter_counter > 0: continue - print "[+] %25s: %02d%% (%d)" % (simplemask, count*100/self.filter_counter, count) - - print "\n[*] Advanced Masks:" - for (advancedmask,count) in sorted(self.stats_advancedmasks.iteritems(), key=operator.itemgetter(1), reverse=True): - if count*100/self.filter_counter > 0: - print "[+] %25s: %02d%% (%d)" % (advancedmask, count*100/self.filter_counter, count) + if self.total_counter == 0: + print("[!] No passwords were found to analyze.") + return + if self.filter_counter == 0: + print("[!] No passwords matched the specified filters (0/%d)." % self.total_counter) + return + + print("[+] Analyzing %d%% (%d/%d) of passwords" % (self.filter_counter*100//self.total_counter, + self.filter_counter, self.total_counter)) + print("[*] Statistics below is relative to the number of analyzed passwords, not total number of passwords") + print("\n[*] Length:") + for (length, count) in sorted(iter(self.stats_length.items()), key=operator.itemgetter(1), reverse=True): + if self.hiderare and not count*100//self.filter_counter > 0: + continue + print("[+] %25d: %02d%% (%d)" % (length, count*100/self.filter_counter, count)) + + print("\n[*] Character-set:") + for (char, count) in sorted(iter(self.stats_charactersets.items()), key=operator.itemgetter(1), reverse=True): + if self.hiderare and not count*100//self.filter_counter > 0: + continue + print("[+] %25s: %02d%% (%d)" % (char, count*100/self.filter_counter, count)) + + print("\n[*] Password complexity:") + print("[+] digit: min(%s) max(%s)" % (self.mindigit, self.maxdigit)) + print("[+] lower: min(%s) max(%s)" % (self.minlower, self.maxlower)) + print("[+] upper: min(%s) max(%s)" % (self.minupper, self.maxupper)) + print("[+] special: min(%s) max(%s)" % (self.minspecial, self.maxspecial)) + + print("\n[*] Simple Masks:") + for (simplemask, count) in sorted(iter(self.stats_simplemasks.items()), key=operator.itemgetter(1), + reverse=True): + if self.hiderare and not count*100//self.filter_counter > 0: + continue + print("[+] %25s: %02d%% (%d)" % (simplemask, count*100//self.filter_counter, count)) + + print("\n[*] Advanced Masks:") + for (advancedmask, count) in sorted(iter(self.stats_advancedmasks.items()), key=operator.itemgetter(1), + reverse=True): + if count*100//self.filter_counter > 0: + print("[+] %25s: %02d%% (%d)" % (advancedmask, count*100//self.filter_counter, count)) if self.output_file: - self.output_file.write("%s,%d\n" % (advancedmask,count)) - -if __name__ == "__main__": - - header = " _ \n" - header += " StatsGen %s | |\n" % VERSION - header += " _ __ __ _ ___| | _\n" - header += " | '_ \ / _` |/ __| |/ /\n" - header += " | |_) | (_| | (__| < \n" - header += " | .__/ \__,_|\___|_|\_\\\n" - header += " | | \n" - header += " |_| iphelix@thesprawl.org\n" - header += "\n" - - parser = OptionParser("%prog [options] passwords.txt\n\nType --help for more options", version="%prog "+VERSION) - - filters = OptionGroup(parser, "Password Filters") - filters.add_option("--minlength", dest="minlength", type="int", metavar="8", help="Minimum password length") - filters.add_option("--maxlength", dest="maxlength", type="int", metavar="8", help="Maximum password length") - filters.add_option("--charset", dest="charsets", help="Password charset filter (comma separated)", metavar="loweralpha,numeric") - filters.add_option("--simplemask", dest="simplemasks",help="Password mask filter (comma separated)", metavar="stringdigit,allspecial") - parser.add_option_group(filters) - - parser.add_option("-o", "--output", dest="output_file",help="Save masks and stats to a file", metavar="password.masks") - parser.add_option("--hiderare", action="store_true", dest="hiderare", default=False, help="Hide statistics covering less than 1% of the sample") - - parser.add_option("-q", "--quiet", action="store_true", dest="quiet", default=False, help="Don't show headers.") - (options, args) = parser.parse_args() + self.output_file.write("%s,%d\n" % (advancedmask, count)) + +def main(): + + header = r""" _ + StatsGen %s | | + _ __ __ _ ___| | _ + | '_ \ / _` |/ __| |/ / + | |_) | (_| | (__| < + | .__/ \__,_|\___|_|\_\ + | | + |_| iphelix@thesprawl.org +""" % VERSION + + parser = argparse.ArgumentParser(description="Password statistical analysis tool.") + parser.add_argument("--version", action="version", version="%(prog)s " + VERSION) + parser.add_argument("passwords", metavar="passwords.txt", help="Password file to analyze.") + + filters = parser.add_argument_group("Password Filters") + filters.add_argument("--minlength", type=int, metavar="8", help="Minimum password length") + filters.add_argument("--maxlength", type=int, metavar="8", help="Maximum password length") + filters.add_argument("--charset", dest="charsets", metavar="loweralpha,numeric", + help="Password charset filter (comma separated)") + filters.add_argument("--simplemask", dest="simplemasks", metavar="stringdigit,allspecial", + help="Password mask filter (comma separated)") + + parser.add_argument("-o", "--output", dest="output_file", metavar="password.masks", + help="Save masks and stats to a file") + parser.add_argument("--hiderare", action="store_true", + help="Hide statistics covering less than 1%% of the sample") + parser.add_argument("-q", "--quiet", action="store_true", help="Don't show headers.") + + options = parser.parse_args() # Print program header if not options.quiet: - print header + print(header) - if len(args) != 1: - parser.error("no passwords file specified") - exit(1) - - print "[*] Analyzing passwords in [%s]" % args[0] + print("[*] Analyzing passwords in [%s]" % options.passwords) statsgen = StatsGen() - if not options.minlength == None: statsgen.minlength = options.minlength - if not options.maxlength == None: statsgen.maxlength = options.maxlength - if not options.charsets == None: statsgen.charsets = [x.strip() for x in options.charsets.split(',')] - if not options.simplemasks == None: statsgen.simplemasks = [x.strip() for x in options.simplemasks.split(',')] + if options.minlength is not None: + statsgen.minlength = options.minlength + if options.maxlength is not None: + statsgen.maxlength = options.maxlength + if options.charsets is not None: + statsgen.charsets = [x.strip() for x in options.charsets.split(',')] + if options.simplemasks is not None: + statsgen.simplemasks = [x.strip() for x in options.simplemasks.split(',')] - if options.hiderare: statsgen.hiderare = options.hiderare + if options.hiderare: + statsgen.hiderare = options.hiderare if options.output_file: - print "[*] Saving advanced masks and occurrences to [%s]" % options.output_file + print("[*] Saving advanced masks and occurrences to [%s]" % options.output_file) statsgen.output_file = open(options.output_file, 'w') - statsgen.generate_stats(args[0]) - statsgen.print_stats() + try: + statsgen.generate_stats(options.passwords) + statsgen.print_stats() + finally: + if statsgen.output_file: + statsgen.output_file.close() + + +if __name__ == "__main__": + main()