From 4ed47777b5241f37a64f73bf9928a39c5eca51c5 Mon Sep 17 00:00:00 2001 From: iphelix Date: Wed, 24 Jul 2013 18:15:46 -0700 Subject: [PATCH] Standardized on speed, rewrote statsgen, many bug fixes. --- maskgen.py | 62 +++++++---- policygen.py | 18 ++-- rulegen.py | 8 +- statsgen.py | 286 +++++++++++++++++++++++++++++---------------------- 4 files changed, 215 insertions(+), 159 deletions(-) diff --git a/maskgen.py b/maskgen.py index 5578ee1..370e2d4 100755 --- a/maskgen.py +++ b/maskgen.py @@ -46,12 +46,15 @@ class MaskGen: self.minlength = None self.maxlength = None + self.mintime = None self.maxtime = None + self.mincomplexity = None self.maxcomplexity = None self.minoccurrence = None + self.maxoccurrence = None # PPS (Passwords per Second) Cracking Speed - self.pps = 10000000000 + self.pps = 1000000000 self.showmasks = False # Counter for total masks coverage @@ -81,20 +84,25 @@ class MaskGen: 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 (not self.minoccurrence or mask_occurrence >= self.minoccurrence) and \ - (not self.maxcomplexity or mask_complexity <= self.maxcomplexity) and \ - (not self.maxlength or mask_length <= self.maxlength) and \ - (not self.minlength or mask_length >= self.minlength): + if (self.minoccurrence == None or mask_occurrence >= self.minoccurrence) and \ + (self.maxoccurrence == None or mask_occurrence <= self.maxoccurrence) and \ + (self.mincomplexity == None or mask_complexity <= self.mincomplexity) and \ + (self.maxcomplexity == None or mask_complexity <= self.maxcomplexity) and \ + (self.mintime == None or mask_time <= self.mintime) and \ + (self.maxtime == None or mask_time <= self.maxtime) and \ + (self.maxlength == None or mask_length <= self.maxlength) and \ + (self.minlength == None or mask_length >= self.minlength): self.masks[mask] = dict() self.masks[mask]['length'] = mask_length self.masks[mask]['occurrence'] = mask_occurrence self.masks[mask]['complexity'] = 1 - mask_complexity - self.masks[mask]['time'] = mask_complexity/self.pps + self.masks[mask]['time'] = mask_time self.masks[mask]['optindex'] = 1 - mask_complexity/mask_occurrence def generate_masks(self,sorting_mode): @@ -132,13 +140,18 @@ class MaskGen: print " Masks runtime: %s" % time_human def getmaskscoverage(self, checkmasks): + sample_count = 0 - sample_time = 0 sample_occurrence = 0 + total_complexity = 0 + if self.showmasks: print "[L:] Mask: [ Occ: ] [ Time: ]" for mask in checkmasks: mask = mask.strip() + mask_complexity = self.getcomplexity(mask) + + total_complexity += mask_complexity if mask in self.masks: @@ -150,17 +163,18 @@ class MaskGen: self.output_file.write("%s\n" % mask) sample_occurrence += self.masks[mask]['occurrence'] - sample_time += self.masks[mask]['time'] sample_count += 1 - if self.target_time and sample_time > self.target_time: - print "[!] Target time exceeded." - break + 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 + 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) - time_human = ">1 year" if sample_time > 60*60*24*365 else str(datetime.timedelta(seconds=sample_time)) print " Masks runtime: %s" % time_human @@ -182,11 +196,14 @@ if __name__ == "__main__": 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("--maxtime", dest="maxtime", type="int", metavar="3600", help="Maximum runtime (seconds)") - filters.add_option("--maxcomplexity", dest="maxcomplexity", type="int", metavar="", help="Maximum complexity") - filters.add_option("--minoccurrence", dest="minoccurrence", type="int", metavar="", help="Minimum 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") @@ -228,15 +245,20 @@ if __name__ == "__main__": 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.maxtime: maskgen.maxtime = options.maxtime + 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 + + print "[*] Using {:,d} keys/sec for calculations.".format(maskgen.pps) # Load masks for arg in args: diff --git a/policygen.py b/policygen.py index 981b555..0f3d44b 100755 --- a/policygen.py +++ b/policygen.py @@ -35,13 +35,6 @@ import itertools VERSION = "0.0.2" -# PPS (Passwords per Second) Cracking Speed -pps = 1000000000 - -# Global Variables -sample_time = 0 -total_time = 0 - class PolicyGen: def __init__(self): self.output_file = None @@ -57,7 +50,6 @@ class PolicyGen: self.maxupper = None self.maxspecial = None - # PPS (Passwords per Second) Cracking Speed self.pps = 1000000000 self.showmasks = False @@ -82,7 +74,7 @@ class PolicyGen: sample_count = 0 # NOTE: It is better to collect total complexity - # in order not to lose precision when dividing by pps + # not to lose precision when dividing by pps total_complexity = 0 sample_complexity = 0 @@ -92,6 +84,7 @@ class PolicyGen: total_length_count = 0 sample_length_count = 0 + total_length_complexity = 0 sample_length_complexity = 0 @@ -177,11 +170,11 @@ if __name__ == "__main__": 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("--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("--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") @@ -202,6 +195,7 @@ if __name__ == "__main__": 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 @@ -218,6 +212,8 @@ if __name__ == "__main__": 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) diff --git a/rulegen.py b/rulegen.py index c5d34f7..5dfde33 100755 --- a/rulegen.py +++ b/rulegen.py @@ -5,7 +5,7 @@ # # This tool is part of PACK (Password Analysis and Cracking Kit) # -# VERSION 0.0.1 +# VERSION 0.0.2 # # Copyright (C) 2013 Peter Kacherginsky # All rights reserved. @@ -44,8 +44,7 @@ from optparse import OptionParser, OptionGroup VERSION = "0.0.1" # Testing rules with hashcat --stdout -import subprocess -HASHCAT_PATH = "hashcat-0.42/" +HASHCAT_PATH = "hashcat/" # Rule Generator class responsible for the complete cycle of rule generation class RuleGen: @@ -713,7 +712,6 @@ class RuleGen: if self.verbose: print "[*] Analyzing password: %s" % password if self.verbose: start_time = time.clock() - # Skip all numeric passwords if password.isdigit(): if self.verbose: print "[!] %s => {skipping numeric} => %s" % (password,password) @@ -836,7 +834,7 @@ class RuleGen: if __name__ == "__main__": header = " _ \n" - header += " RuleGen 0.0.1 | |\n" + header += " RuleGen %s | |\n" % VERSION header += " _ __ __ _ ___| | _\n" header += " | '_ \ / _` |/ __| |/ /\n" header += " | |_) | (_| | (__| < \n" diff --git a/statsgen.py b/statsgen.py index d011b34..b5789b5 100755 --- a/statsgen.py +++ b/statsgen.py @@ -30,79 +30,157 @@ import sys import re, operator, string -from optparse import OptionParser +from optparse import OptionParser, OptionGroup VERSION = "0.0.2" -password_counter = 0 +class StatsGen: + def __init__(self): + self.output_file = None -# Constants -chars_regex = list() -chars_regex.append(('numeric',re.compile('^[0-9]+$'))) -chars_regex.append(('loweralpha',re.compile('^[a-z]+$'))) -chars_regex.append(('upperalpha',re.compile('^[A-Z]+$'))) -chars_regex.append(('mixedalpha',re.compile('^[a-zA-Z]+$'))) -chars_regex.append(('loweralphanum',re.compile('^[a-z0-9]+$'))) -chars_regex.append(('upperalphanum',re.compile('^[A-Z0-9]+$'))) -chars_regex.append(('mixedalphanum',re.compile('^[a-zA-Z0-9]+$'))) -chars_regex.append(('special',re.compile('^[^a-zA-Z0-9]+$'))) -chars_regex.append(('loweralphaspecial',re.compile('^[^A-Z0-9]+$'))) -chars_regex.append(('upperalphaspecial',re.compile('^[^a-z0-9]+$'))) -chars_regex.append(('mixedalphaspecial',re.compile('^[^0-9]+$'))) -chars_regex.append(('loweralphaspecialnum',re.compile('^[^A-Z]+$'))) -chars_regex.append(('upperalphaspecialnum',re.compile('^[^a-z]+$'))) -chars_regex.append(('mixedalphaspecialnum',re.compile('.*'))) + # Filters + self.minlength = None + self.maxlength = None + self.simplemasks = None + self.charsets = None -masks_regex = list() -masks_regex.append(('alldigit',re.compile('^\d+$', re.IGNORECASE))) -masks_regex.append(('allstring',re.compile('^[a-z]+$', re.IGNORECASE))) -masks_regex.append(('stringdigit',re.compile('^[a-z]+\d+$', re.IGNORECASE))) -masks_regex.append(('digitstring',re.compile('^\d+[a-z]+$', re.IGNORECASE))) -masks_regex.append(('digitstringdigit',re.compile('^\d+[a-z]+\d+$', re.IGNORECASE))) -masks_regex.append(('stringdigitstring',re.compile('^[a-z]+\d+[a-z]+$', re.IGNORECASE))) -masks_regex.append(('allspecial',re.compile('^[^a-z0-9]+$', re.IGNORECASE))) -masks_regex.append(('stringspecial',re.compile('^[a-z]+[^a-z0-9]+$', re.IGNORECASE))) -masks_regex.append(('specialstring',re.compile('^[^a-z0-9]+[a-z]+$', re.IGNORECASE))) -masks_regex.append(('stringspecialstring',re.compile('^[a-z]+[^a-z0-9]+[a-z]+$', re.IGNORECASE))) -masks_regex.append(('stringspecialdigit',re.compile('^[a-z]+[^a-z0-9]+\d+$', re.IGNORECASE))) -masks_regex.append(('specialstringspecial',re.compile('^[^a-z0-9]+[a-z]+[^a-z0-9]+$', re.IGNORECASE))) + # Constants + self.chars_regex = list() + self.chars_regex.append(('numeric',re.compile('^[0-9]+$'))) + self.chars_regex.append(('loweralpha',re.compile('^[a-z]+$'))) + self.chars_regex.append(('upperalpha',re.compile('^[A-Z]+$'))) + self.chars_regex.append(('mixedalpha',re.compile('^[a-zA-Z]+$'))) + self.chars_regex.append(('loweralphanum',re.compile('^[a-z0-9]+$'))) + self.chars_regex.append(('upperalphanum',re.compile('^[A-Z0-9]+$'))) + self.chars_regex.append(('mixedalphanum',re.compile('^[a-zA-Z0-9]+$'))) + self.chars_regex.append(('special',re.compile('^[^a-zA-Z0-9]+$'))) + self.chars_regex.append(('loweralphaspecial',re.compile('^[^A-Z0-9]+$'))) + self.chars_regex.append(('upperalphaspecial',re.compile('^[^a-z0-9]+$'))) + self.chars_regex.append(('mixedalphaspecial',re.compile('^[^0-9]+$'))) + self.chars_regex.append(('loweralphaspecialnum',re.compile('^[^A-Z]+$'))) + self.chars_regex.append(('upperalphaspecialnum',re.compile('^[^a-z]+$'))) + self.chars_regex.append(('mixedalphaspecialnum',re.compile('.*'))) -def length_check(password): - return len(password) + self.masks_regex = list() + self.masks_regex.append(('alldigit',re.compile('^\d+$', re.IGNORECASE))) + self.masks_regex.append(('allstring',re.compile('^[a-z]+$', re.IGNORECASE))) + self.masks_regex.append(('stringdigit',re.compile('^[a-z]+\d+$', re.IGNORECASE))) + self.masks_regex.append(('digitstring',re.compile('^\d+[a-z]+$', re.IGNORECASE))) + self.masks_regex.append(('digitstringdigit',re.compile('^\d+[a-z]+\d+$', re.IGNORECASE))) + self.masks_regex.append(('stringdigitstring',re.compile('^[a-z]+\d+[a-z]+$', re.IGNORECASE))) + self.masks_regex.append(('allspecial',re.compile('^[^a-z0-9]+$', re.IGNORECASE))) + self.masks_regex.append(('stringspecial',re.compile('^[a-z]+[^a-z0-9]+$', re.IGNORECASE))) + self.masks_regex.append(('specialstring',re.compile('^[^a-z0-9]+[a-z]+$', re.IGNORECASE))) + self.masks_regex.append(('stringspecialstring',re.compile('^[a-z]+[^a-z0-9]+[a-z]+$', re.IGNORECASE))) + self.masks_regex.append(('stringspecialdigit',re.compile('^[a-z]+[^a-z0-9]+\d+$', re.IGNORECASE))) + self.masks_regex.append(('specialstringspecial',re.compile('^[^a-z0-9]+[a-z]+[^a-z0-9]+$', re.IGNORECASE))) -def masks_check(password): - for (name,regex) in masks_regex: - if regex.match(password): - return name - else: - return "othermask" + # Stats dictionaries + self.stats_length = dict() + self.stats_simplemasks = dict() + self.stats_advancedmasks = dict() + self.stats_charactersets = dict() -def chars_check(password): - for (name,regex) in chars_regex: - if regex.match(password): - return name - else: - return "otherchar" + self.hiderare = False -def advmask_check(password): - advmask = list() - for letter in password: - if letter in string.digits: advmask.append("?d") - elif letter in string.lowercase: advmask.append("?l") - elif letter in string.uppercase: advmask.append("?u") - else: advmask.append("?s") - return "".join(advmask) + self.filter_counter = 0 + self.total_counter = 0 -def main(): - password_length = dict() - masks = dict() - advmasks = dict() - chars = dict() - filter_counter = 0 - total_counter = 0 + def simplemasks_check(self, password): + for (name,regex) in self.masks_regex: + if regex.match(password): + return name + else: + return "othermask" + + def characterset_check(self, password): + for (name,regex) in self.chars_regex: + if regex.match(password): + return name + else: + return "otherchar" + + def advancedmask_check(self, password): + mask = list() + for letter in password: + if letter in string.digits: mask.append("?d") + elif letter in string.lowercase: mask.append("?l") + elif letter in string.uppercase: mask.append("?u") + else: mask.append("?s") + return "".join(mask) + + def generate_stats(self, filename): + + f = open(filename,'r') + + for password in f: + password = password.rstrip('\r\n') + self.total_counter += 1 + + pass_length = len(password) + characterset = self.characterset_check(password) + simplemask = self.simplemasks_check(password) + advancedmask = self.advancedmask_check(password) + + 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): + + self.filter_counter += 1 + + 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 "[+] 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[*] Line Count Statistics..." + for (length,count) in sorted(self.stats_length.iteritems(), key=operator.itemgetter(1), reverse=True): + if self.hiderare and not count*100/self.filter_counter > 0: continue + print "[+] %25d: %02d%% (%d)" % (length, count*100/self.filter_counter, count) + + print "\n[*] Charset statistics..." + for (char,count) in sorted(self.stats_charactersets.iteritems(), key=operator.itemgetter(1), reverse=True): + if self.hiderare and not count*100/self.filter_counter > 0: continue + print "[+] %25s: %02d%% (%d)" % (char, count*100/self.filter_counter, count) + + print "\n[*] Simple Mask statistics..." + for (simplemask,count) in sorted(self.stats_simplemasks.iteritems(), key=operator.itemgetter(1), reverse=True): + if self.hiderare and not count*100/self.filter_counter > 0: continue + print "[+] %25s: %02d%% (%d)" % (simplemask, count*100/self.filter_counter, count) + + print "\n[*] Advanced Mask statistics..." + for (advancedmask,count) in sorted(self.stats_advancedmasks.iteritems(), key=operator.itemgetter(1), reverse=True): + if count*100/self.filter_counter > 0: + print "[+] %25s: %02d%% (%d)" % (advancedmask, count*100/self.filter_counter, count) + + if self.output_file: + self.output_file.write("%s,%d\n" % (advancedmask,count)) + +if __name__ == "__main__": header = " _ \n" - header += " StatsGen 0.0.2 | |\n" + header += " StatsGen %s | |\n" % VERSION header += " _ __ __ _ ___| | _\n" header += " | '_ \ / _` |/ __| |/ /\n" header += " | |_) | (_| | (__| < \n" @@ -111,11 +189,18 @@ def main(): header += " |_| iphelix@thesprawl.org\n" header += "\n" - parser = OptionParser("%prog [options] passwords.txt", version="%prog "+VERSION) - parser.add_option("-l", "--length", dest="length_filter",help="Password length filter.",metavar="8") - parser.add_option("-c", "--charset", dest="char_filter", help="Password charset filter.", metavar="loweralpha") - parser.add_option("-m", "--mask", dest="mask_filter",help="Password mask filter", metavar="stringdigit") - parser.add_option("-o", "--masksoutput", dest="mask_output",help="Generate and save masks db to a file", metavar="masks.csv") + 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() @@ -126,66 +211,21 @@ def main(): if len(args) != 1: parser.error("no passwords file specified") exit(1) - - print "[*] Analyzing passwords: %s" % args[0] - f = open(args[0],'r') + print "[*] Analyzing passwords in [%s]" % args[0] - for password in f: - password = password.strip() - total_counter += 1 - - pass_len = length_check(password) - mask_set = masks_check(password) - char_set = chars_check(password) - advmask = advmask_check(password) + statsgen = StatsGen() - if (not options.length_filter or str(pass_len) in options.length_filter.split(',')) and \ - (not options.char_filter or char_set in options.char_filter.split(',')) and \ - (not options.mask_filter or mask_set in options.mask_filter.split(',')): - - filter_counter += 1 + 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(',')] - try: password_length[pass_len] += 1 - except: password_length[pass_len] = 1 + if options.hiderare: statsgen.hiderare = options.hiderare - try: masks[mask_set] += 1 - except: masks[mask_set] = 1 + if options.output_file: + print "[*] Saving advanced masks and occurrences to [%s]" % options.output_file + statsgen.output_file = open(options.output_file, 'w') - try: chars[char_set] += 1 - except: chars[char_set] = 1 - - try: advmasks[advmask] += 1 - except: advmasks[advmask] = 1 - - f.close() - - print "[+] Analyzing %d%% (%d/%d) passwords" % (filter_counter*100/total_counter, filter_counter, total_counter) - print " NOTE: Statistics below is relative to the number of analyzed passwords, not total number of passwords" - print "\n[*] Line Count Statistics..." - for (length,count) in sorted(password_length.iteritems(), key=operator.itemgetter(1), reverse=True): - if count*100/filter_counter > 0: - print "[+] %25d: %02d%% (%d)" % (length, count*100/filter_counter, count) - - print "\n[*] Charset statistics..." - for (char,count) in sorted(chars.iteritems(), key=operator.itemgetter(1), reverse=True): - print "[+] %25s: %02d%% (%d)" % (char, count*100/filter_counter, count) - - print "\n[*] Mask statistics..." - for (mask,count) in sorted(masks.iteritems(), key=operator.itemgetter(1), reverse=True): - print "[+] %25s: %02d%% (%d)" % (mask, count*100/filter_counter, count) - - print "\n[*] Advanced Mask statistics..." - for (advmask,count) in sorted(advmasks.iteritems(), key=operator.itemgetter(1), reverse=True): - if count*100/filter_counter > 0: - print "[+] %25s: %02d%% (%d)" % (advmask, count*100/filter_counter, count) - - if options.mask_output: - print "\n[*] Saving Mask statistics to %s" % options.mask_output - fmask = open(options.mask_output, "w") - for (advmask,count) in sorted(advmasks.iteritems(), key=operator.itemgetter(1), reverse=True): - fmask.write("%s,%d\n" % (advmask,count)) - fmask.close() - -if __name__ == "__main__": - main() + statsgen.generate_stats(args[0]) + statsgen.print_stats() \ No newline at end of file