From 9c5bef9e50d90edffa4a17ee4e3bda315efcd691 Mon Sep 17 00:00:00 2001
From: Pierre-Antoine Haidar-Bachminska <hydraze@hydraze.org>
Date: Sun, 19 Jun 2016 00:29:27 +0200
Subject: [PATCH 01/29] Applied 2to3 to each python file

---
 maskgen.py   |  46 ++++++++--------
 policygen.py |  28 +++++-----
 rulegen.py   | 148 +++++++++++++++++++++++++--------------------------
 statsgen.py  |  44 +++++++--------
 4 files changed, 133 insertions(+), 133 deletions(-)

diff --git a/maskgen.py b/maskgen.py
index 2b9a592..131afa7 100755
--- a/maskgen.py
+++ b/maskgen.py
@@ -51,7 +51,7 @@ def getcomplexity(self, mask):
             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)
+            else: print("[!] Error, unknown mask ?%s in a mask %s" % (char,mask))
 
         return count
 
@@ -97,12 +97,12 @@ 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(list(self.masks.keys()), key=lambda mask: self.masks[mask][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)
+                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)
@@ -112,14 +112,14 @@ 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)
+        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))
         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):
 
@@ -128,7 +128,7 @@ 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)
@@ -139,7 +139,7 @@ def getmaskscoverage(self, checkmasks):
 
                 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)
+                    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)
@@ -148,16 +148,16 @@ def getmaskscoverage(self, checkmasks):
                 sample_count += 1
 
             if self.target_time and total_complexity/self.pps > self.target_time:
-                print "[!] Target time exceeded."
+                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
         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
+        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__":
@@ -210,20 +210,20 @@ def getmaskscoverage(self, checkmasks):
 
     # Print program header
     if not options.quiet: 
-        print header
+        print(header)
 
     if len(args) < 1:
         parser.error("no masks file specified! Please provide statsgen output.")
         exit(1)
 
-    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.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
@@ -240,7 +240,7 @@ def getmaskscoverage(self, checkmasks):
     if options.pps: maskgen.pps = options.pps
     if options.showmasks: maskgen.showmasks = options.showmasks
 
-    print "[*] Using {:,d} keys/sec for calculations.".format(maskgen.pps)
+    print("[*] Using {:,d} keys/sec for calculations.".format(maskgen.pps))
     
     # Load masks
     for arg in args:
@@ -249,13 +249,13 @@ def getmaskscoverage(self, checkmasks):
     # 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)
+        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
+        print("[*] Checking coverage of masks in [%s]" % options.checkmasks_file)
         maskgen.getmaskscoverage(checkmasks_file)
 
     # Printing masks in a file
@@ -268,5 +268,5 @@ def getmaskscoverage(self, checkmasks):
         else: 
             sorting_mode = "optindex"
 
-        print "[*] Sorting masks by their [%s]." % sorting_mode
+        print("[*] Sorting masks by their [%s]." % sorting_mode)
         maskgen.generate_masks(sorting_mode)
\ No newline at end of file
diff --git a/policygen.py b/policygen.py
index e96d5cf..65f2f5e 100755
--- a/policygen.py
+++ b/policygen.py
@@ -45,7 +45,7 @@ def getcomplexity(self, mask):
             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)
+            else: print("[!] Error, unknown mask ?%s in a mask %s" % (char,mask))
 
         return count
    
@@ -61,8 +61,8 @@ 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
 
@@ -109,7 +109,7 @@ def generate_masks(self, noncompliant):
                     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)
+                        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)
@@ -123,11 +123,11 @@ def generate_masks(self, noncompliant):
 
         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)
+        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)
+        print("[*] Policy Masks: %d Time: %s" % (sample_count, sample_time_human))
 
 
 if __name__ == "__main__":
@@ -168,13 +168,13 @@ def generate_masks(self, noncompliant):
 
     # 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')
 
 
@@ -194,13 +194,13 @@ def generate_masks(self, noncompliant):
     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")
+    print("[*] Generating [%s] masks." % ("compliant" if not options.noncompliant else "non-compliant"))
     policygen.generate_masks(options.noncompliant)
\ No newline at end of file
diff --git a/rulegen.py b/rulegen.py
index 389d578..21f549c 100755
--- a/rulegen.py
+++ b/rulegen.py
@@ -172,9 +172,9 @@ def levenshtein(self,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,8 +183,8 @@ 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):
+        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:
@@ -205,7 +205,7 @@ def levenshtein_distance(self, s1, s2):
         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):
@@ -219,11 +219,11 @@ def levenshtein_distance(self, s1, s2):
 
     def levenshtein_print(self,matrix,word,password):
         """ Print word X password matrix """
-        print "      %s" % "  ".join(list(word))
+        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)
+            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. """
@@ -254,7 +254,7 @@ 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
+            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]
@@ -285,7 +285,7 @@ def load_custom_wordlist(self,wordlist_file):
     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()
@@ -319,8 +319,8 @@ def generate_words(self,password):
                     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:
@@ -347,22 +347,22 @@ def generate_words(self,password):
 
                 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"])
+                        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
             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"])
+                    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"])
+                    print("[-] %s => {max distance exceeded: %d (%d)} => %s" % \
+                    (word["suggestion"], word["distance"], self.max_word_dist, word["password"]))
 
         if self.max_words: 
             words_collection = words_collection[:self.max_words]
@@ -433,9 +433,9 @@ def generate_hashcat_rules(self, suggestion, password):
                 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"
+                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)
@@ -454,8 +454,8 @@ def generate_hashcat_rules(self, suggestion, password):
 
                 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)
+                        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:
@@ -467,7 +467,7 @@ 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.
@@ -475,7 +475,7 @@ def generate_simple_hashcat_rules(self,word,rules,password):
 
         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]))
@@ -489,20 +489,20 @@ def generate_simple_hashcat_rules(self,word,rules,password):
                 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):
         """ 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.
@@ -514,7 +514,7 @@ def generate_advanced_hashcat_rules(self,word,rules,password):
 
         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]))
@@ -538,7 +538,7 @@ 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]:
@@ -649,7 +649,7 @@ def generate_advanced_hashcat_rules(self,word,rules,password):
                     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
@@ -718,7 +718,7 @@ def generate_advanced_hashcat_rules(self,word,rules,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
 
 
@@ -727,21 +727,21 @@ def check_reversible_password(self, password):
 
         # Skip all numeric passwords
         if password.isdigit(): 
-            if self.verbose and not self.quiet: print "[!] %s => {skipping numeric} => %s" % (password,password)
+            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)
+            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
 
@@ -751,7 +751,7 @@ def check_reversible_password(self, password):
     def analyze_password(self,password, rules_queue=multiprocessing.Queue(), words_queue=multiprocessing.Queue()):
         """ Analyze a single password. """
 
-        if self.verbose: print "[*] Analyzing password: %s" % password
+        if self.verbose: print("[*] Analyzing password: %s" % password)
 
         words = []
 
@@ -800,20 +800,20 @@ def print_hashcat_rules(self, words, password, rules_queue, words_queue):
 
                     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)
+                            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
+        if self.debug: print("[*] Password analysis worker [%d] started." % i)
         try:
             while True:
                 password = passwords_queue.get()
@@ -823,16 +823,16 @@ def password_worker(self,i, passwords_queue, rules_queue, words_queue):
 
                 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()
@@ -844,17 +844,17 @@ def rule_worker(self, rules_queue, output_rules_filename):
                 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()
@@ -866,17 +866,17 @@ def word_worker(self, words_queue, output_words_filename):
                 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):
         """ 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)
@@ -904,8 +904,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,7 +915,7 @@ 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.
@@ -933,15 +933,15 @@ 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.
@@ -950,11 +950,11 @@ def analyze_passwords_file(self,passwords_file):
         rules_counter = Counter(rules_file)
         rule_counter_total = sum(rules_counter.values())
 
-        print "\n[*] Top 10 rules"
+        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)
+            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()
@@ -966,11 +966,11 @@ def analyze_passwords_file(self,passwords_file):
         words_counter = Counter(words_file)
         word_counter_total = sum(rules_counter.values())
 
-        print "\n[*] Top 10 words"
+        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)
+            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()
@@ -993,10 +993,10 @@ def verify_hashcat_rules(self,word, rules, password):
 
         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)
+            print("[!] Hashcat Verification FAILED: %s => %s => %s (%s)" % (word," ".join(rules or [':']),password,out))
 
 if __name__ == "__main__":
 
@@ -1049,7 +1049,7 @@ def verify_hashcat_rules(self,word, rules, password):
 
     # Print program header
     if not options.quiet:
-        print header
+        print(header)
 
     if len(args) < 1:
         parser.error("no passwords file specified")
@@ -1069,7 +1069,7 @@ def verify_hashcat_rules(self,word, rules, password):
     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)"
+    if rulegen.brute_rules: print("[!] Bruteforcing reversal and rotation rules. (slower)")
 
     # Debugging options
     rulegen.word = options.word
@@ -1081,8 +1081,8 @@ def verify_hashcat_rules(self,word, rules, password):
     # 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
+        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: 
diff --git a/statsgen.py b/statsgen.py
index 6765f9e..b67a82f 100755
--- a/statsgen.py
+++ b/statsgen.py
@@ -177,33 +177,33 @@ def generate_stats(self, filename):
     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):
+        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(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("[+] %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):
+        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("[+] %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[*] 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):
+        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("[+] %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):
+        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)
+                print("[+] %25s: %02d%% (%d)" % (advancedmask, count*100/self.filter_counter, count))
 
             if self.output_file:
                 self.output_file.write("%s,%d\n" % (advancedmask,count))
@@ -237,13 +237,13 @@ def print_stats(self):
 
     # 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]" % args[0])
 
     statsgen = StatsGen()
 
@@ -255,7 +255,7 @@ def print_stats(self):
     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])

From 67ae93041d9a53b5f1736d34e9007b8cbd6a3a07 Mon Sep 17 00:00:00 2001
From: Haidar-Bachminska Pierre-Antoine <hydraze@hydraze.org>
Date: Sun, 19 Jun 2016 00:36:48 +0200
Subject: [PATCH 02/29] deleted unused imports

---
 maskgen.py   | 2 --
 policygen.py | 1 -
 rulegen.py   | 1 -
 statsgen.py  | 4 +---
 4 files changed, 1 insertion(+), 7 deletions(-)

diff --git a/maskgen.py b/maskgen.py
index 131afa7..5af494b 100755
--- a/maskgen.py
+++ b/maskgen.py
@@ -10,10 +10,8 @@
 #
 # Please see the attached LICENSE file for additional licensing information.
 
-import sys
 import csv
 import datetime
-from operator import itemgetter
 from optparse import OptionParser, OptionGroup
 
 VERSION = "0.0.3"
diff --git a/policygen.py b/policygen.py
index 65f2f5e..fd7b15f 100755
--- a/policygen.py
+++ b/policygen.py
@@ -10,7 +10,6 @@
 #
 # Please see the attached LICENSE file for additional licensing information.
 
-import sys, string, random
 import datetime
 from optparse import OptionParser, OptionGroup
 import itertools
diff --git a/rulegen.py b/rulegen.py
index 21f549c..8560ae5 100755
--- a/rulegen.py
+++ b/rulegen.py
@@ -15,7 +15,6 @@
 import sys
 import re
 import time
-import operator
 import enchant
 
 from optparse import OptionParser, OptionGroup
diff --git a/statsgen.py b/statsgen.py
index b67a82f..f378fb8 100755
--- a/statsgen.py
+++ b/statsgen.py
@@ -10,10 +10,8 @@
 #
 # Please see the attached LICENSE file for additional licensing information.
 
-import sys
-import re, operator, string
+import operator, string
 from optparse import OptionParser, OptionGroup
-import time
 
 VERSION = "0.0.3"
 

From 7b148df2d84c218d048951064e7b2a8d33dc82f1 Mon Sep 17 00:00:00 2001
From: Haidar-Bachminska Pierre-Antoine <hydraze@hydraze.org>
Date: Sun, 19 Jun 2016 01:46:08 +0200
Subject: [PATCH 03/29] fix statsgen.py's file opening mode and prints of masks

---
 statsgen.py | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/statsgen.py b/statsgen.py
index f378fb8..dc213c6 100755
--- a/statsgen.py
+++ b/statsgen.py
@@ -72,13 +72,13 @@ def analyze_password(self, password):
                 advancedmask_string += "?d"
                 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')
 
 
-            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')
@@ -119,8 +119,7 @@ def analyze_password(self, password):
     def generate_stats(self, filename):
         """ Generate password statistics. """
 
-        f = open(filename,'r')
-
+        f = open(filename, 'r', encoding="latin-1", errors='ignore')
         for password in f:
             password = password.rstrip('\r\n')
 
@@ -175,16 +174,16 @@ def generate_stats(self, filename):
     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("[+] 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(iter(self.stats_length.items()), key=operator.itemgetter(1), reverse=True):
-            if self.hiderare and not count*100/self.filter_counter > 0: continue
+            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
+            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:")
@@ -195,13 +194,13 @@ def print_stats(self):
 
         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))
+            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 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))

From 39620d461acd91f98ceab0005d5b2df79720cc04 Mon Sep 17 00:00:00 2001
From: Haidar-Bachminska Pierre-Antoine <hydraze@hydraze.org>
Date: Sun, 19 Jun 2016 02:16:01 +0200
Subject: [PATCH 04/29] fix divisions in maskgen

---
 maskgen.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/maskgen.py b/maskgen.py
index 5af494b..cacd0ff 100755
--- a/maskgen.py
+++ b/maskgen.py
@@ -62,9 +62,9 @@ def loadmasks(self, filename):
             if mask == "": continue
 
             mask_occurrence = int(occurrence)
-            mask_length = len(mask)/2
+            mask_length = len(mask)//2
             mask_complexity = self.getcomplexity(mask)
-            mask_time = mask_complexity/self.pps
+            mask_time = mask_complexity//self.pps
 
             self.total_occurrence += mask_occurrence
 
@@ -83,7 +83,7 @@ def loadmasks(self, filename):
                 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
+                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 """
@@ -115,7 +115,7 @@ def generate_masks(self,sorting_mode):
 
         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))
+        print("    Masks coverage:  %d%% (%d/%d)" % (sample_occurrence*100//self.total_occurrence,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)
 

From 1f8243c81cd2609be22a1afecdb661d10c354044 Mon Sep 17 00:00:00 2001
From: Haidar-Bachminska Pierre-Antoine <hydraze@hydraze.org>
Date: Sun, 19 Jun 2016 02:33:10 +0200
Subject: [PATCH 05/29] fix divisions in policygen

---
 policygen.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/policygen.py b/policygen.py
index fd7b15f..df2c43c 100755
--- a/policygen.py
+++ b/policygen.py
@@ -106,7 +106,7 @@ def generate_masks(self, noncompliant):
                     sample_length_complexity += mask_complexity
 
                     if self.showmasks:
-                        mask_time = mask_complexity/self.pps      
+                        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))
 
@@ -120,11 +120,11 @@ def generate_masks(self, noncompliant):
             sample_complexity += sample_length_complexity
 
 
-        total_time = total_complexity/self.pps
+        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 = 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))
 

From 3c93ef6484f641845941502bab4ec0ad53caf1da Mon Sep 17 00:00:00 2001
From: Haidar-Bachminska Pierre-Antoine <hydraze@hydraze.org>
Date: Sun, 19 Jun 2016 02:34:01 +0200
Subject: [PATCH 06/29] fix small spelling typo

---
 policygen.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/policygen.py b/policygen.py
index df2c43c..711612e 100755
--- a/policygen.py
+++ b/policygen.py
@@ -83,7 +83,7 @@ def generate_masks(self, noncompliant):
                 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

From 1d73c2a753c7ddc72ffeb55701ac59bf68f96db6 Mon Sep 17 00:00:00 2001
From: Haidar-Bachminska Pierre-Antoine <hydraze@hydraze.org>
Date: Sun, 19 Jun 2016 02:43:21 +0200
Subject: [PATCH 07/29] first pass of cleanup: modified None comparisons to use
 the is keyword

---
 policygen.py | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/policygen.py b/policygen.py
index 711612e..36dff3b 100755
--- a/policygen.py
+++ b/policygen.py
@@ -93,14 +93,14 @@ def generate_masks(self, noncompliant):
                 # 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
@@ -119,7 +119,6 @@ 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))

From 1c94727d872337e7676fc428462f306fcd9f426d Mon Sep 17 00:00:00 2001
From: Pierre-Antoine Haidar-Bachminska <hydraze@hydraze.org>
Date: Tue, 21 Jun 2016 19:01:17 +0200
Subject: [PATCH 08/29] Add an exception handler in case the provider dict does
 not exist

---
 rulegen.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/rulegen.py b/rulegen.py
index 8560ae5..15a663f 100755
--- a/rulegen.py
+++ b/rulegen.py
@@ -1054,7 +1054,12 @@ def verify_hashcat_rules(self,word, rules, password):
         parser.error("no passwords file specified")
         exit(1)
 
-    rulegen = RuleGen(language="en", providers=options.providers, basename=options.basename, threads=options.threads)
+    try:
+        rulegen = RuleGen(language="en", providers=options.providers, basename=options.basename, threads=options.threads)
+    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 / myspell package.")
+        exit(-1)
 
     # Finetuning word generation
     rulegen.max_word_dist=options.maxworddist

From 602342d9cbdbe53380c3a264c41b6f2d05b8a4b0 Mon Sep 17 00:00:00 2001
From: Pierre-Antoine Haidar-Bachminska <hydraze@hydraze.org>
Date: Tue, 21 Jun 2016 19:16:37 +0200
Subject: [PATCH 09/29] Fix file opening to mimic old behaviour

---
 rulegen.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rulegen.py b/rulegen.py
index 15a663f..dc20a7a 100755
--- a/rulegen.py
+++ b/rulegen.py
@@ -890,7 +890,7 @@ def analyze_passwords_file(self,passwords_file):
 
         # 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()

From 6fc2ad815d5ceb43caea5218df660b44cd87977b Mon Sep 17 00:00:00 2001
From: Pierre-Antoine Haidar-Bachminska <hydraze@hydraze.org>
Date: Tue, 21 Jun 2016 19:47:54 +0200
Subject: [PATCH 10/29] Use a python3 integer division instead of the floating
 one

---
 rulegen.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rulegen.py b/rulegen.py
index dc20a7a..aadb249 100755
--- a/rulegen.py
+++ b/rulegen.py
@@ -732,7 +732,7 @@ def check_reversible_password(self, password):
 
         # 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:
+        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

From a208d84e86a4d71ea3b1661c076167ebe815572f Mon Sep 17 00:00:00 2001
From: Pierre-Antoine Haidar-Bachminska <hydraze@hydraze.org>
Date: Tue, 21 Jun 2016 20:36:52 +0200
Subject: [PATCH 11/29] PEP8 compliance for statsgen.py

---
 statsgen.py | 187 ++++++++++++++++++++++++++++++++--------------------
 1 file changed, 114 insertions(+), 73 deletions(-)

diff --git a/statsgen.py b/statsgen.py
index dc213c6..438d335 100755
--- a/statsgen.py
+++ b/statsgen.py
@@ -10,20 +10,22 @@
 #
 # Please see the attached LICENSE file for additional licensing information.
 
-import operator, string
+import operator
+import string
 from optparse import OptionParser, OptionGroup
 
 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
 
@@ -40,14 +42,14 @@ 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):
@@ -66,53 +68,68 @@ 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.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.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'
+        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)
 
@@ -123,31 +140,40 @@ def generate_stats(self, filename):
         for password in f:
             password = password.rstrip('\r\n')
 
-            if len(password) == 0: continue
+            if len(password) == 0:
+                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
@@ -174,16 +200,19 @@ def generate_stats(self, filename):
     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("[+] 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
+        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
+        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:")
@@ -193,22 +222,25 @@ def print_stats(self):
         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
+        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):
+        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))
+                self.output_file.write("%s,%d\n" % (advancedmask, count))
 
 if __name__ == "__main__":
 
-    header  = "                       _ \n"
-    header += "     StatsGen %s   | |\n"  % VERSION
+    header = "                       _ \n"
+    header += "     StatsGen %s   | |\n" % VERSION
     header += "      _ __   __ _  ___| | _\n"
     header += "     | '_ \ / _` |/ __| |/ /\n"
     header += "     | |_) | (_| | (__|   < \n"
@@ -222,12 +254,16 @@ def print_stats(self):
     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")
+    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("-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()
@@ -244,12 +280,17 @@ def print_stats(self):
 
     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.hiderare: statsgen.hiderare = options.hiderare
+    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.output_file:
         print("[*] Saving advanced masks and occurrences to [%s]" % options.output_file)

From 996fdf844cce51050993756cadf5d4d8f6acb663 Mon Sep 17 00:00:00 2001
From: Pierre-Antoine Haidar-Bachminska <hydraze@hydraze.org>
Date: Tue, 21 Jun 2016 20:37:55 +0200
Subject: [PATCH 12/29] make analyze_password a static method

---
 statsgen.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/statsgen.py b/statsgen.py
index 438d335..a230602 100755
--- a/statsgen.py
+++ b/statsgen.py
@@ -52,7 +52,8 @@ def __init__(self):
         self.maxlower = None
         self.maxspecial = None
 
-    def analyze_password(self, password):
+    @staticmethod
+    def analyze_password(password):
 
         # Password length
         pass_length = len(password)

From 8f7ccfcab0e1271bf814613f09cf5bafe55bf816 Mon Sep 17 00:00:00 2001
From: Pierre-Antoine Haidar-Bachminska <hydraze@hydraze.org>
Date: Tue, 21 Jun 2016 23:24:28 +0200
Subject: [PATCH 13/29] remove an useless call to len()

---
 statsgen.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/statsgen.py b/statsgen.py
index a230602..d1d4376 100755
--- a/statsgen.py
+++ b/statsgen.py
@@ -141,7 +141,8 @@ def generate_stats(self, filename):
         for password in f:
             password = password.rstrip('\r\n')
 
-            if len(password) == 0:
+            # if the password is empty, continue
+            if not password:
                 continue
 
             self.total_counter += 1

From 8abf9a2a764e667b92311ec96f998edd72b7b4b3 Mon Sep 17 00:00:00 2001
From: Pierre-Antoine Haidar-Bachminska <hydraze@hydraze.org>
Date: Tue, 21 Jun 2016 23:51:29 +0200
Subject: [PATCH 14/29] cleanup of maskgen.py (PEP8 compliance)

---
 maskgen.py | 177 ++++++++++++++++++++++++++++++++---------------------
 1 file changed, 107 insertions(+), 70 deletions(-)

diff --git a/maskgen.py b/maskgen.py
index cacd0ff..9844d71 100755
--- a/maskgen.py
+++ b/maskgen.py
@@ -16,6 +16,7 @@
 
 VERSION = "0.0.3"
 
+
 class MaskGen:
     def __init__(self):
         # Masks collections with meta data
@@ -24,10 +25,10 @@ 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
@@ -44,48 +45,55 @@ 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
-            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 loadmasks(self, filename):
         """ Load masks and apply filters. """
-        maskReader = csv.reader(open(args[0],'r'), delimiter=',', quotechar='"')
+        mask_reader = csv.reader(open(args[0], 'r'), delimiter=',', quotechar='"')
 
-        for (mask,occurrence) in maskReader:
+        for (mask, occurrence) in mask_reader:
 
-            if mask == "": continue
+            if not mask:
+                continue
 
             mask_occurrence = int(occurrence)
-            mask_length = len(mask)//2
+            mask_length = len(mask) // 2
             mask_complexity = self.getcomplexity(mask)
-            mask_time = mask_complexity//self.pps
+            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):
+            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)
+                self.masks[mask]['optindex'] = 1 - (mask_complexity // mask_occurrence)
 
-    def generate_masks(self,sorting_mode):
+    def generate_masks(self, sorting_mode):
         """ Generate optimal password masks sorted by occurrence, complexity or optindex """
         sample_count = 0
         sample_time = 0
@@ -95,12 +103,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(list(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(list(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)
@@ -115,7 +127,8 @@ def generate_masks(self,sorting_mode):
 
         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))
+        print("    Masks coverage:  %d%% (%d/%d)" % (sample_occurrence * 100 // self.total_occurrence,
+                                                     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)
 
@@ -126,7 +139,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)
@@ -136,8 +151,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)
@@ -145,22 +162,23 @@ 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:
+            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 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 = "                       _ \n"
     header += "     MaskGen %s    | |\n" % VERSION
     header += "      _ __   __ _  ___| | _\n"
     header += "     | '_ \ / _` |/ __| |/ /\n"
@@ -172,35 +190,42 @@ def getmaskscoverage(self, checkmasks):
 
     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")
+    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")
+    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)
+    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")
+    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)
+    parser.add_option("--showmasks", dest="showmasks", help="Show matching masks", action="store_true", default=False)
 
     misc = OptionGroup(parser, "Miscellaneous options")
-    misc.add_option("--pps", dest="pps",help="Passwords per Second", type="int", metavar="1000000000")
+    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)
 
@@ -219,24 +244,35 @@ def getmaskscoverage(self, checkmasks):
     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)
         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
+    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
 
     # Misc
-    if options.pps: maskgen.pps = options.pps
-    if options.showmasks: maskgen.showmasks = options.showmasks
+    if options.pps:
+        maskgen.pps = options.pps
+    if options.showmasks:
+        maskgen.showmasks = options.showmasks
 
     print("[*] Using {:,d} keys/sec for calculations.".format(maskgen.pps))
     
@@ -260,11 +296,12 @@ def getmaskscoverage(self, checkmasks):
     else:
         # Process masks according to specified sorting algorithm
         if options.occurrence: 
-            sorting_mode = "occurrence"
+            sort_mode = "occurrence"
         elif options.complexity: 
-            sorting_mode = "complexity"
+            sort_mode = "complexity"
         else: 
-            sorting_mode = "optindex"
+            sort_mode = "optindex"
 
-        print("[*] Sorting masks by their [%s]." % sorting_mode)
-        maskgen.generate_masks(sorting_mode)
\ No newline at end of file
+        print("[*] Sorting masks by their [%s]." % sort_mode)
+        maskgen.generate_masks(sort_mode)
+        
\ No newline at end of file

From 20e2136e70587f75c64d61492bc1742f746b9ead Mon Sep 17 00:00:00 2001
From: Pierre-Antoine Haidar-Bachminska <hydraze@hydraze.org>
Date: Tue, 21 Jun 2016 23:58:55 +0200
Subject: [PATCH 15/29] fix a typo in loadmasks where the opened file was
 arg[0] instead of the method's argument

---
 maskgen.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/maskgen.py b/maskgen.py
index 9844d71..3f6a732 100755
--- a/maskgen.py
+++ b/maskgen.py
@@ -62,7 +62,7 @@ def getcomplexity(self, mask):
 
     def loadmasks(self, filename):
         """ Load masks and apply filters. """
-        mask_reader = csv.reader(open(args[0], 'r'), delimiter=',', quotechar='"')
+        mask_reader = csv.reader(open(filename, 'r'), delimiter=',', quotechar='"')
 
         for (mask, occurrence) in mask_reader:
 
@@ -304,4 +304,3 @@ def getmaskscoverage(self, checkmasks):
 
         print("[*] Sorting masks by their [%s]." % sort_mode)
         maskgen.generate_masks(sort_mode)
-        
\ No newline at end of file

From 901ac05a5ac4a442f3d84560d9051fbb6f3d9cc0 Mon Sep 17 00:00:00 2001
From: Pierre-Antoine Haidar-Bachminska <hydraze@hydraze.org>
Date: Wed, 22 Jun 2016 00:01:12 +0200
Subject: [PATCH 16/29] add a static decorator to getcomplexity

---
 maskgen.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/maskgen.py b/maskgen.py
index 3f6a732..6a70624 100755
--- a/maskgen.py
+++ b/maskgen.py
@@ -41,7 +41,8 @@ def __init__(self):
         # Counter for total masks coverage
         self.total_occurrence = 0
 
-    def getcomplexity(self, mask):
+    @staticmethod
+    def getcomplexity(mask):
         """ Return mask complexity. """
         count = 1
         for char in mask[1:].split("?"):

From 17f27f1582ea4ee5aa5f2a336c9b58d6c0c348a0 Mon Sep 17 00:00:00 2001
From: Pierre-Antoine Haidar-Bachminska <hydraze@hydraze.org>
Date: Wed, 22 Jun 2016 00:15:38 +0200
Subject: [PATCH 17/29] improved PEP8 compliance for policygen.py and code
 cleanup

---
 policygen.py | 188 +++++++++++++++++++++++++++++++--------------------
 1 file changed, 114 insertions(+), 74 deletions(-)

diff --git a/policygen.py b/policygen.py
index 36dff3b..77dee73 100755
--- a/policygen.py
+++ b/policygen.py
@@ -16,19 +16,20 @@
 
 VERSION = "0.0.2"
 
-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
@@ -39,15 +40,21 @@ 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
-            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 """
 
@@ -60,16 +67,15 @@ def generate_masks(self, noncompliant):
         sample_complexity = 0
 
         # TODO: Randomize or even statistically arrange matching masks
-        for length in range(self.minlength, self.maxlength+1):
+        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)
 
@@ -78,37 +84,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 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   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:
+                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)
@@ -119,19 +135,20 @@ 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))
+        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))
+        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))
 
 
 if __name__ == "__main__":
 
-    header  = "                       _ \n"
-    header += "     PolicyGen %s  | |\n"  % VERSION
+    header = "                       _ \n"
+    header += "     PolicyGen %s  | |\n" % VERSION
     header += "      _ __   __ _  ___| | _\n"
     header += "     | '_ \ / _` |/ __| |/ /\n"
     header += "     | |_) | (_| | (__|   < \n"
@@ -141,23 +158,33 @@ def generate_masks(self, noncompliant):
     header += "\n"
 
     # 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 = 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("--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.")
@@ -175,30 +202,43 @@ def generate_masks(self, noncompliant):
         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.maxdigits  = 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.maxdigits = 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 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("    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"))
-    policygen.generate_masks(options.noncompliant)
\ No newline at end of file
+    policygen.generate_masks(options.noncompliant)

From 0b229173c15214af23f2154b4680360697c91743 Mon Sep 17 00:00:00 2001
From: Pierre-Antoine Haidar-Bachminska <hydraze@hydraze.org>
Date: Wed, 22 Jun 2016 00:16:17 +0200
Subject: [PATCH 18/29] add the staticmethod decorator for getcomplexity method

---
 policygen.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/policygen.py b/policygen.py
index 77dee73..ac86de9 100755
--- a/policygen.py
+++ b/policygen.py
@@ -36,7 +36,8 @@ def __init__(self):
         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("?"):

From 15e77efd6a075fbfabd4770586fd84f076ee0d6a Mon Sep 17 00:00:00 2001
From: Pierre-Antoine Haidar-Bachminska <hydraze@hydraze.org>
Date: Wed, 22 Jun 2016 02:51:06 +0200
Subject: [PATCH 19/29] clean up and PEP8 compliance for rulegen.py

---
 rulegen.py | 735 +++++++++++++++++++++++++++++++----------------------
 1 file changed, 437 insertions(+), 298 deletions(-)

diff --git a/rulegen.py b/rulegen.py
index aadb249..485ddef 100755
--- a/rulegen.py
+++ b/rulegen.py
@@ -15,31 +15,29 @@
 import sys
 import re
 import time
-import enchant
 
+import multiprocessing
+import subprocess
+import enchant
 from optparse import OptionParser, OptionGroup
-
 from collections import Counter
 
-import subprocess
-
-import multiprocessing
-
 VERSION = "0.0.4"
 
 # Testing rules with hashcat --stdout
 HASHCAT_PATH = "hashcat/"
 
+
 # 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()):
 
         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)
 
@@ -62,7 +60,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
 
         ########################################################################
@@ -77,66 +75,130 @@ def __init__(self,language="en",providers="aspell,myspell",basename='analysis',t
         self.password_pattern["insertion"] = re.compile('^[^a-z]*(?P<password>.+?)[^a-z]*$', re.IGNORECASE)
         self.password_pattern["email"] = re.compile('^(?P<password>.+?)@[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["allspecial"] = re.compile('^([^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["x"] = lambda x, y, z: x[:y] + x[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)
@@ -160,14 +222,14 @@ 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):
+    def levenshtein(self, word, password):
         matrix = []
 
         # Generate and populate the initial matrix
@@ -182,14 +244,14 @@ def levenshtein(self,word,password):
                     matrix[i].append(0)
 
         # Calculate edit distance for each substring
-        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]
+        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
@@ -203,7 +265,7 @@ def levenshtein_distance(self, s1, s2):
             return self.levenshtein_distance(s2, s1)
         if not s1:
             return len(s2)
-     
+
         previous_row = range(len(s2) + 1)
         for i, c1 in enumerate(s1):
             current_row = [i + 1]
@@ -213,15 +275,17 @@ 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):
+    def levenshtein_print(self, matrix, word, password):
         """ Print word X password matrix """
         print("      %s" % "  ".join(list(word)))
-        for i,row in enumerate(matrix):
-            if i == 0: print(" ", end=' ')
-            else:      print(password[i-1], end=' ')
+        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):
@@ -231,12 +295,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,37 +318,45 @@ def levenshtein_reverse_recursive(self,matrix,i,j,path_len):
 
             # Calculate minimum cost of each operation
             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]
+            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()
@@ -304,40 +376,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)))
 
-
             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:
@@ -345,35 +418,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.
@@ -394,23 +467,30 @@ 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:
+            "[*] 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)
+    def int_to_hashcat(self, 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
+    def hashcat_to_int(self, 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."""
@@ -426,13 +506,13 @@ 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))
+            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")
 
@@ -443,7 +523,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)
 
@@ -452,9 +532,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:
@@ -462,46 +542,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.
@@ -511,17 +597,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':
 
@@ -537,118 +624,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
@@ -659,12 +761,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
@@ -673,14 +775,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
@@ -690,67 +792,72 @@ 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()):
+    def analyze_password(self, password, rules_queue=multiprocessing.Queue(), words_queue=multiprocessing.Queue()):
         """ Analyze a single password. """
 
-        if self.verbose: print("[*] Analyzing password: %s" % password)
+        if self.verbose:
+            print("[*] Analyzing password: %s" % password)
 
         words = []
 
@@ -760,7 +867,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
 
@@ -774,9 +881,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)
 
@@ -785,7 +891,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"])
 
@@ -798,80 +904,91 @@ 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)
 
         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)
 
         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)
@@ -884,7 +1001,8 @@ 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()
 
@@ -895,7 +1013,7 @@ def analyze_passwords_file(self,passwords_file):
         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:
@@ -903,8 +1021,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
@@ -919,9 +1037,9 @@ def analyze_passwords_file(self,passwords_file):
         else:
             # Signal workers to stop.
             for i in range(multiprocessing.cpu_count()):
-                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)
 
@@ -932,19 +1050,20 @@ 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("[-] 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_file = open("%s.rule" % self.basename, 'r')
         rules_sorted_file = open("%s-sorted.rule" % self.basename, 'w')
         rules_counter = Counter(rules_file)
         rule_counter_total = sum(rules_counter.values())
@@ -953,15 +1072,15 @@ def analyze_passwords_file(self,passwords_file):
         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))
+            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()
 
-
-        words_file = open("%s.word" % self.basename,'r')
-        words_sorted_file = open("%s-sorted.word" % self.basename,'w')
+        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())
 
@@ -969,38 +1088,43 @@ def analyze_passwords_file(self,passwords_file):
         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))
+            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()
 
     ############################################################################
-    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))
+            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 += "     RuleGen %s    | |\n" % VERSION
     header += "      _ __   __ _  ___| | _\n"
     header += "     | '_ \ / _` |/ __| |/ /\n"
     header += "     | |_) | (_| | (__|   < \n"
@@ -1009,37 +1133,49 @@ def verify_hashcat_rules(self,word, rules, password):
     header += "     |_| iphelix@thesprawl.org\n"
     header += "\n"
 
+    parser = OptionParser("%prog [options] passwords.txt", version="%prog " + VERSION)
 
-    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("-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.")
+    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)
+    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("--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)
+    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")
+    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("-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)
@@ -1055,41 +1191,44 @@ def verify_hashcat_rules(self,word, rules, password):
         exit(1)
 
     try:
-        rulegen = RuleGen(language="en", providers=options.providers, basename=options.basename, threads=options.threads)
+        rulegen = RuleGen(language="en", providers=options.providers, basename=options.basename,
+                          threads=options.threads)
     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 / myspell package.")
         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)
+        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: 
+    if options.password:
         rulegen.analyze_password(args[0])
     else:
         rulegen.analyze_passwords_file(args[0])

From 7492eb64100461faa2f6ec1ed3ddc44985893641 Mon Sep 17 00:00:00 2001
From: Pierre-Antoine Haidar-Bachminska <hydraze@hydraze.org>
Date: Wed, 22 Jun 2016 12:57:54 +0200
Subject: [PATCH 20/29] make some methods static in rulegen

---
 rulegen.py | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/rulegen.py b/rulegen.py
index 485ddef..c9e3841 100755
--- a/rulegen.py
+++ b/rulegen.py
@@ -229,7 +229,8 @@ def __init__(self, language="en", providers="aspell,myspell", basename='analysis
 
     ############################################################################
     # Calculate Levenshtein edit path matrix
-    def levenshtein(self, word, password):
+    @staticmethod
+    def levenshtein(word, password):
         matrix = []
 
         # Generate and populate the initial matrix
@@ -278,7 +279,8 @@ def levenshtein_distance(self, s1, s2):
 
         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):
@@ -480,13 +482,15 @@ def generate_advanced_words(self, password):
 
     ############################################################################
     # Hashcat specific offset definition 0-9,A-Z
-    def int_to_hashcat(self, n):
+    @staticmethod
+    def int_to_hashcat(n):
         if n < 10:
             return n
         else:
             return chr(65 + n - 10)
 
-    def hashcat_to_int(self, n):
+    @staticmethod
+    def hashcat_to_int(n):
         if n.isdigit():
             return int(n)
         else:

From e3ed4a87598a1576db060802342c097c1c550675 Mon Sep 17 00:00:00 2001
From: Pierre-Antoine Haidar-Bachminska <hydraze@hydraze.org>
Date: Wed, 22 Jun 2016 14:54:46 +0200
Subject: [PATCH 21/29] small style in statsgen.py

---
 statsgen.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/statsgen.py b/statsgen.py
index d1d4376..81139c0 100755
--- a/statsgen.py
+++ b/statsgen.py
@@ -132,7 +132,7 @@ def analyze_password(password):
         else:
             charset = 'all'
 
-        return (pass_length, charset, simplemask_string, advancedmask_string, policy)
+        return pass_length, charset, simplemask_string, advancedmask_string, policy
 
     def generate_stats(self, filename):
         """ Generate password statistics. """
@@ -287,7 +287,7 @@ def print_stats(self):
     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(',')]
+        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(',')]
 

From 5d3ace966d63535aaf5b69e70a959ff3f65c60fb Mon Sep 17 00:00:00 2001
From: Pierre-Antoine Haidar-Bachminska <hydraze@hydraze.org>
Date: Mon, 8 Aug 2016 21:54:09 +0200
Subject: [PATCH 22/29] Delete an useless list() added by 2to3

Reported by wolfy1339 here:
https://github.com/Hydraze/pack/commit/9c5bef9e50d90edffa4a17ee4e3bda315efcd691#commitcomment-18462108
---
 maskgen.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/maskgen.py b/maskgen.py
index 6a70624..a92c9ba 100755
--- a/maskgen.py
+++ b/maskgen.py
@@ -107,7 +107,7 @@ def generate_masks(self, sorting_mode):
         if self.showmasks:
             print("[L:] Mask:                          [ Occ:  ] [ Time:  ]")
 
-        for mask in sorted(list(self.masks.keys()), key=lambda m: self.masks[m][sorting_mode], reverse=True):
+        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 \

From ef1c21048cb99bdcc9f592637f598b0d02cbf519 Mon Sep 17 00:00:00 2001
From: Pierre-Antoine Haidar-Bachminska <hydraze@hydraze.org>
Date: Mon, 8 Aug 2016 21:57:32 +0200
Subject: [PATCH 23/29] policygen.py now handles maxdigit directive correctly.

Reported and fixed by philsmd here: https://github.com/iphelix/pack/issues/1
(I couldn't just pull his fix due to my modifications)
---
 policygen.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/policygen.py b/policygen.py
index ac86de9..b935b47 100755
--- a/policygen.py
+++ b/policygen.py
@@ -217,7 +217,7 @@ def generate_masks(self, noncompliant):
     if options.minspecial is not None:
         policygen.minspecial = options.minspecial
     if options.maxdigit is not None:
-        policygen.maxdigits = options.maxdigit
+        policygen.maxdigit = options.maxdigit
     if options.maxlower is not None:
         policygen.maxlower = options.maxlower
     if options.maxupper is not None:

From 92f073a75b57fb46b17d4d489449ce23f2d00c0f Mon Sep 17 00:00:00 2001
From: Matlink <matlink_github@matlink.fr>
Date: Fri, 17 Mar 2017 13:39:21 +0100
Subject: [PATCH 24/29] Fix bug when threads != cpu_count

When using the --threads flag, the script doesn't end, because it is waiting for cpu_count() threads (which is never satisfied).
---
 rulegen.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rulegen.py b/rulegen.py
index c9e3841..a8832f7 100755
--- a/rulegen.py
+++ b/rulegen.py
@@ -1040,7 +1040,7 @@ def analyze_passwords_file(self, passwords_file):
 
         else:
             # Signal workers to stop.
-            for i in range(multiprocessing.cpu_count()):
+            for i in range(self.threads):
                 passwords_queue.put(None)
 
                 # Wait for all of the queued passwords to finish.

From ba885da89031ef2053aea22f72dfdeaffe18347f Mon Sep 17 00:00:00 2001
From: Mathieu Valois <mathieu.valois@unicaen.fr>
Date: Fri, 18 Aug 2017 00:10:18 +0200
Subject: [PATCH 25/29] shabang python3

---
 maskgen.py   | 2 +-
 policygen.py | 2 +-
 rulegen.py   | 2 +-
 statsgen.py  | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/maskgen.py b/maskgen.py
index a92c9ba..563f2e3 100755
--- a/maskgen.py
+++ b/maskgen.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python
+#!/usr/bin/python3
 # MaskGen - Generate Password Masks
 #
 # This tool is part of PACK (Password Analysis and Cracking Kit)
diff --git a/policygen.py b/policygen.py
index b935b47..6599a77 100755
--- a/policygen.py
+++ b/policygen.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python
+#!/usr/bin/python3
 # PolicyGen - Analyze and Generate password masks according to a password policy
 #
 # This tool is part of PACK (Password Analysis and Cracking Kit)
diff --git a/rulegen.py b/rulegen.py
index a8832f7..8ff0524 100755
--- a/rulegen.py
+++ b/rulegen.py
@@ -1,4 +1,4 @@
-#!/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.
diff --git a/statsgen.py b/statsgen.py
index 81139c0..d6f174a 100755
--- a/statsgen.py
+++ b/statsgen.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 # StatsGen - Password Statistical Analysis tool
 #
 # This tool is part of PACK (Password Analysis and Cracking Kit)

From 9f63259bc2505ee99f0d9f5d7cc7b513e1b65c39 Mon Sep 17 00:00:00 2001
From: Matlink <matlink@matlink.fr>
Date: Fri, 18 Aug 2017 00:16:04 +0200
Subject: [PATCH 26/29] fix python3 env

---
 maskgen.py   | 2 +-
 policygen.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/maskgen.py b/maskgen.py
index 563f2e3..2147a87 100755
--- a/maskgen.py
+++ b/maskgen.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python3
+#!/usr/bin/env python3
 # MaskGen - Generate Password Masks
 #
 # This tool is part of PACK (Password Analysis and Cracking Kit)
diff --git a/policygen.py b/policygen.py
index 6599a77..108d759 100755
--- a/policygen.py
+++ b/policygen.py
@@ -1,4 +1,4 @@
-#!/usr/bin/python3
+#!/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)

From 78c931f24d5ef817b1637e74a3aefe251419a4f3 Mon Sep 17 00:00:00 2001
From: Chick3nman <admin@chick3nman.com>
Date: Mon, 5 Feb 2018 11:24:01 -0600
Subject: [PATCH 27/29] Fixed 'x' and 'O' rules

'x' has been replaced with 'O' and the new functionality of 'x' has been added.
---
 rulegen.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/rulegen.py b/rulegen.py
index a8832f7..4e51960 100755
--- a/rulegen.py
+++ b/rulegen.py
@@ -152,7 +152,9 @@ def __init__(self, language="en", providers="aspell,myspell", basename='analysis
         # Truncate word at position N
         self.hashcat_rule["'"] = lambda x, y: x[:y]
         # Delete M characters, starting at position N
-        self.hashcat_rule["x"] = lambda x, y, z: x[:y] + x[y + z:]
+        self.hashcat_rule["O"] = lambda x, y, z: x[:y] + x[y + z:]
+        # Extracts M characters, starting at position N
+        self.hashcat_rule["'"] = lambda x, y, z: x[y:y+z]
         # Purge all instances of X
         self.hashcat_rule["@"] = lambda x, y: x.replace(y, '')
 

From 3d3a07069b600cb729b257e9913a0ac6e67daff9 Mon Sep 17 00:00:00 2001
From: sn0 <sn0@Debian>
Date: Tue, 28 Jul 2026 08:20:31 +0100
Subject: [PATCH 28/29] Modernize PACK toolkit for current Python 3

Update all four tools (statsgen, maskgen, policygen, rulegen) and add
packaging, with the biggest focus on rulegen.

CLI / dependencies:
- Port all tools from deprecated optparse to argparse.
- rulegen: make pyenchant optional with a clear install message instead of
  a raw ImportError; default providers aspell,myspell -> aspell,hunspell
  (enchant-2, since myspell no longer exists there).

Bug fixes:
- rulegen: word-frequency percentages summed the rules counter instead of
  the words counter.
- rulegen: extract rule 'x' collided with truncate rule "'"; a debug branch
  was a no-op string literal instead of a print.
- rulegen --password now prints the generated word and rule instead of
  silently discarding them.
- statsgen/maskgen: guard division-by-zero on empty/fully-filtered input.
- statsgen/maskgen/policygen: output files were never closed; now closed
  via try/finally.

Cleanups:
- Wrap file access in context managers; raw strings for regexes and the
  ASCII-art banners (no more invalid-escape warnings on Python 3.12+).
- Wrap each CLI in a main() so the tools install as console scripts.

Packaging:
- Add pyproject.toml (console entry points, optional [rulegen] extra),
  requirements.txt, .gitignore.
- Replace the plain-text README with a modern README.md.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
---
 .gitignore       |  27 ++
 README           | 677 -----------------------------------------------
 README.md        | 165 ++++++++++++
 maskgen.py       | 243 ++++++++---------
 policygen.py     |  95 +++----
 pyproject.toml   |  38 +++
 requirements.txt |   6 +
 rulegen.py       | 238 +++++++++--------
 statsgen.py      | 178 ++++++-------
 9 files changed, 624 insertions(+), 1043 deletions(-)
 create mode 100644 .gitignore
 delete mode 100644 README
 create mode 100644 README.md
 create mode 100644 pyproject.toml
 create mode 100644 requirements.txt

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 2147a87..aa20da3 100755
--- a/maskgen.py
+++ b/maskgen.py
@@ -3,18 +3,18 @@
 #
 # 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 argparse
 import csv
 import datetime
-from optparse import OptionParser, OptionGroup
 
-VERSION = "0.0.3"
+VERSION = "0.0.4"
 
 
 class MaskGen:
@@ -63,36 +63,37 @@ def getcomplexity(mask):
 
     def loadmasks(self, filename):
         """ Load masks and apply filters. """
-        mask_reader = csv.reader(open(filename, 'r'), 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)
+        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 """
@@ -126,10 +127,10 @@ def generate_masks(self, sorting_mode):
                 print("[!] Target time exceeded.")
                 break
 
+        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)" % (sample_occurrence * 100 // self.total_occurrence,
-                                                     sample_occurrence, self.total_occurrence))
+        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)
 
@@ -170,76 +171,70 @@ def getmaskscoverage(self, checkmasks):
         # TODO: Something wrong here, complexity and time doesn't match with estimated from policygen
         total_time = total_complexity / self.pps
         time_human = ">1 year" if total_time > 60*60*24*365 else str(datetime.timedelta(seconds=total_time))
+        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)" % (sample_occurrence * 100 / self.total_occurrence,
-                                                     sample_occurrence, self.total_occurrence))
+        print("    Masks coverage:  %d%% (%d/%d)" % (coverage, 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)
-
-    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()
+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")
+
+    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: 
+    if not options.quiet:
         print(header)
 
-    if len(args) < 1:
-        parser.error("no masks file specified! Please provide statsgen output.")
-        exit(1)
-
     print("[*] Analyzing masks in [%s]" % args[0])
 
     maskgen = MaskGen()
@@ -281,27 +276,35 @@ def getmaskscoverage(self, checkmasks):
     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: 
-            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)
+    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:
+            # 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()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/policygen.py b/policygen.py
index 108d759..5c524a5 100755
--- a/policygen.py
+++ b/policygen.py
@@ -3,18 +3,18 @@
 #
 # 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 argparse
 import datetime
-from optparse import OptionParser, OptionGroup
 import itertools
 
-VERSION = "0.0.2"
+VERSION = "0.0.3"
 
 
 class PolicyGen:
@@ -146,51 +146,46 @@ def generate_masks(self, noncompliant):
         print("[*] Policy Masks: %d Time: %s" % (sample_count, sample_time_human))
 
 
-if __name__ == "__main__":
+def 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:
@@ -242,4 +237,12 @@ def generate_masks(self, noncompliant):
         policygen.maxlower, policygen.maxupper, policygen.maxdigit, policygen.maxspecial))
 
     print("[*] Generating [%s] masks." % ("compliant" if not options.noncompliant else "non-compliant"))
-    policygen.generate_masks(options.noncompliant)
+    try:
+        policygen.generate_masks(options.noncompliant)
+    finally:
+        if policygen.output_file:
+            policygen.output_file.close()
+
+
+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 29397f4..8ca67c7 100755
--- a/rulegen.py
+++ b/rulegen.py
@@ -5,35 +5,55 @@
 #
 # 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 re
-import time
-
+import argparse
 import multiprocessing
+import re
 import subprocess
-import enchant
-from optparse import OptionParser, OptionGroup
+import sys
+import time
 from collections import Counter
 
-VERSION = "0.0.4"
+try:
+    import enchant
+except ImportError:
+    enchant = None
+
+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()):
 
+        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()
@@ -72,10 +92,10 @@ def __init__(self, language="en", providers="aspell,myspell", basename='analysis
         ########################################################################
         # Preanalysis Password Patterns
         self.password_pattern = dict()
-        self.password_pattern["insertion"] = re.compile('^[^a-z]*(?P<password>.+?)[^a-z]*$', re.IGNORECASE)
-        self.password_pattern["email"] = re.compile('^(?P<password>.+?)@[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<password>.+?)[^a-z]*$', re.IGNORECASE)
+        self.password_pattern["email"] = re.compile(r'^(?P<password>.+?)@[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
@@ -154,7 +174,7 @@ def __init__(self, language="en", providers="aspell,myspell", basename='analysis
         # 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["'"] = lambda x, y, z: x[y:y+z]
+        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, '')
 
@@ -478,7 +498,7 @@ def generate_advanced_words(self, password):
         password = preanalysis_password
 
         if self.debug:
-            "[*] Preanalysis Password: %s" % password
+            print("[*] Preanalysis Password: %s" % password)
 
         return self.enchant.suggest(password)
 
@@ -859,8 +879,17 @@ def check_reversible_password(self, password):
         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.
+
+        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)
@@ -1069,37 +1098,27 @@ def analyze_passwords_file(self, passwords_file):
 
         # 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
+        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))
 
-        rules_file.close()
-        rules_sorted_file.close()
-
-        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()
+        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):
@@ -1127,82 +1146,79 @@ def verify_hashcat_rules(self, word, rules, password):
                   (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()
+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)
-
     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 / myspell package.")
-        exit(-1)
+        print("[*] Hint: Usually this dictionary resides within an aspell / hunspell package.")
+        sys.exit(1)
 
     # Finetuning word generation
     rulegen.max_word_dist = options.maxworddist
@@ -1235,6 +1251,10 @@ def verify_hashcat_rules(self, word, rules, password):
 
     # Analyze a single password or several passwords in a file
     if options.password:
-        rulegen.analyze_password(args[0])
+        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 d6f174a..d002cca 100755
--- a/statsgen.py
+++ b/statsgen.py
@@ -3,18 +3,19 @@
 #
 # 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 argparse
 import operator
 import string
-from optparse import OptionParser, OptionGroup
+from collections import Counter
 
-VERSION = "0.0.3"
+VERSION = "0.0.4"
 
 
 class StatsGen:
@@ -30,10 +31,10 @@ def __init__(self):
         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
@@ -137,71 +138,61 @@ def analyze_password(password):
     def generate_stats(self, filename):
         """ Generate password statistics. """
 
-        f = open(filename, 'r', encoding="latin-1", errors='ignore')
-        for password in f:
-            password = password.rstrip('\r\n')
+        with open(filename, 'r', encoding="latin-1", errors='ignore') as f:
+            for password in f:
+                password = password.rstrip('\r\n')
 
-            # if the password is empty, continue
-            if not password:
-                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 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):
+                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
+                    self.filter_counter += 1
 
-                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.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 is None or upper < self.minupper:
-                    self.minupper = upper
-                if self.maxupper is 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 is None or lower < self.minlower:
-                    self.minlower = lower
-                if self.maxlower is 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 is None or special < self.minspecial:
-                    self.minspecial = special
-                if self.maxspecial is 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
-
-        f.close()
 
     def print_stats(self):
         """ Print password statistics. """
 
+        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")
@@ -239,46 +230,43 @@ def print_stats(self):
             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()
+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)
 
-    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()
 
@@ -298,5 +286,13 @@ def print_stats(self):
         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()

From 9f79c96b5554d735feb1020e0b0140aa79494ef3 Mon Sep 17 00:00:00 2001
From: sn0 <sn0@Debian>
Date: Tue, 28 Jul 2026 08:29:28 +0100
Subject: [PATCH 29/29] Fix StatsGen help output

---
 statsgen.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/statsgen.py b/statsgen.py
index d002cca..4adc804 100755
--- a/statsgen.py
+++ b/statsgen.py
@@ -257,7 +257,7 @@ def main():
     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")
+                        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()