eric: comparison Utilities/PasswordChecker.py

-:9986ec0e559a
+:10516539f238
 # Copyright (c) 2011 - 2013 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
-Module implementing a checker for password strength
+Module implementing a checker for password strength.
 """
 from __future__ import unicode_literals    # __IGNORE_WARNING__
 import re
 # how much redundancy is permitted, if the password is
 # long enough. we will skip the redudancy penalty if this
 # number is not exceeded (meaning redundancy < this number)
 self.redundancy = {
-"value": 1,         # 1 means, not double characters, default to start
+"value": 1,         # 1 means, not double characters,
-"permitted": 2.0,   # 2 means, in average every character can occur twice
+# default to start
+"permitted": 2.0,   # 2 means, in average every character
+# can occur twice
 "status": self.Status_Failed,
 "rating": 0,
 }
 # number of uppercase letters, such as A-Z
 uniqueCharacters.append(password[index1])
 # calculate a redundancy number
 self.redundancy["value"] = len(password) / len(uniqueCharacters)
-# Check for sequential alpha string patterns (forward and reverse) but only,
+# Check for sequential alpha string patterns (forward and reverse)
-# if the string has already a length to check for, does not make sense to check
+# but only, if the string has already a length to check for, does
-# the password "ab" for the sequential data "abc"
+# not make sense to check the password "ab" for the sequential data
+# "abc"
 lowercasedPassword = password.lower()
 if self.passwordLength["count"] >= self.sequentialLetters["length"]:
 for index in range(len(self.sequentialLetters["data"]) - \
 self.sequentialLetters["length"] + 1):
 # Check common keyboard patterns
 patternsMatched = []
 if self.passwordLength["count"] >= self.keyboardPatterns["length"]:
 for pattern in self.keyboardPatterns["data"]:
-for index in range(len(pattern) - self.keyboardPatterns["length"] + 1):
+for index in range(
-fwd = pattern[index:index + self.keyboardPatterns["length"]]
+len(pattern) - self.keyboardPatterns["length"] + 1):
+fwd = pattern[index:index +
+self.keyboardPatterns["length"]]
 rev = self.__strReverse(fwd)
 if lowercasedPassword.find(fwd) != -1:
 if fwd not in patternsMatched:
 self.keyboardPatterns["count"] += 1
 patternsMatched.append(fwd)
 # Try to find repeated sequences of characters.
 if self.passwordLength["count"] >= self.repeatedSequences["length"]:
 for index in range(len(lowercasedPassword) - \
 self.repeatedSequences["length"] + 1):
-fwd = lowercasedPassword[index:index + self.repeatedSequences["length"]]
+fwd = lowercasedPassword[
+index:index + self.repeatedSequences["length"]]
 if lowercasedPassword.find(
 fwd, index + self.repeatedSequences["length"]) != -1:
 self.repeatedSequences["count"] += 1
 # Try to find mirrored sequences of characters.
 if self.passwordLength["count"] >= self.mirroredSequences["length"]:
 for index in range(len(lowercasedPassword) - \
 self.mirroredSequences["length"] + 1):
-fwd = lowercasedPassword[index:index + self.mirroredSequences["length"]]
+fwd = lowercasedPassword[
+index:index + self.mirroredSequences["length"]]
 rev = self.__strReverse(fwd)
 if lowercasedPassword.find(
 fwd, index + self.mirroredSequences["length"]) != -1:
 self.mirroredSequences["count"] += 1
 # Initial score based on length
-self.score["count"] = self.passwordLength["count"] * self.passwordLength["factor"]
+self.score["count"] = self.passwordLength["count"] * \
+self.passwordLength["factor"]
 # passwordLength
 # credit additional length or punish "under" length
 if self.passwordLength["count"] >= self.passwordLength["minimum"]:
 # credit additional characters over minimum
 self.passwordLength["rating"] = self.passwordLength["bonus"] + \
-(self.passwordLength["count"] - self.passwordLength["minimum"]) * \
+(self.passwordLength["count"] -
+self.passwordLength["minimum"]) * \
 self.passwordLength["factor"]
 else:
 self.passwordLength["rating"] = self.passwordLength["penalty"]
 self.score["count"] += self.passwordLength["rating"]
 # recommendedPasswordLength
 # Credit reaching the recommended password length or put a
 # penalty on it
-if self.passwordLength["count"] >= self.recommendedPasswordLength["minimum"]:
+if self.passwordLength["count"] >= \
+self.recommendedPasswordLength["minimum"]:
 self.recommendedPasswordLength["rating"] = \
 self.recommendedPasswordLength["bonus"] + \
 (self.passwordLength["count"] - \
 self.recommendedPasswordLength["minimum"]) * \
 self.recommendedPasswordLength["factor"]
 self.score["count"] += self.recommendedPasswordLength["rating"]
 # lowercaseLetters
 # Honor or punish the lowercase letter use
 if self.lowercaseLetters["count"] > 0:
-self.lowercaseLetters["rating"] = self.lowercaseLetters["bonus"] + \
+self.lowercaseLetters["rating"] = \
-self.lowercaseLetters["count"] * self.lowercaseLetters["factor"]
+self.lowercaseLetters["bonus"] + \
+self.lowercaseLetters["count"] * \
+self.lowercaseLetters["factor"]
 else:
 self.lowercaseLetters["rating"] = self.lowercaseLetters["penalty"]
 self.score["count"] += self.lowercaseLetters["rating"]
 # uppercaseLetters
 # Honor or punish the lowercase letter use
 if self.uppercaseLetters["count"] > 0:
-self.uppercaseLetters["rating"] = self.uppercaseLetters["bonus"] + \
+self.uppercaseLetters["rating"] = \
-self.uppercaseLetters["count"] * self.uppercaseLetters["factor"]
+self.uppercaseLetters["bonus"] + \
+self.uppercaseLetters["count"] * \
+self.uppercaseLetters["factor"]
 else:
 self.uppercaseLetters["rating"] = self.uppercaseLetters["penalty"]
 self.score["count"] += self.uppercaseLetters["rating"]
 # numerics
 self.score["count"] += self.middleNumerics["rating"]
 # sequentialLetters
 # Honor or punish the sequential letter use
 if self.sequentialLetters["count"] == 0:
-self.sequentialLetters["rating"] = self.sequentialLetters["bonus"] + \
+self.sequentialLetters["rating"] = \
-self.sequentialLetters["count"] * self.sequentialLetters["factor"]
+self.sequentialLetters["bonus"] + \
-else:
+self.sequentialLetters["count"] * \
-self.sequentialLetters["rating"] = self.sequentialLetters["penalty"]
+self.sequentialLetters["factor"]
+else:
+self.sequentialLetters["rating"] = \
+self.sequentialLetters["penalty"]
 self.score["count"] += self.sequentialLetters["rating"]
 # sequentialNumerics
 # Honor or punish the sequential numerics use
 if self.sequentialNumerics["count"] == 0:
-self.sequentialNumerics["rating"] = self.sequentialNumerics["bonus"] + \
+self.sequentialNumerics["rating"] = \
-self.sequentialNumerics["count"] * self.sequentialNumerics["factor"]
+self.sequentialNumerics["bonus"] + \
-else:
+self.sequentialNumerics["count"] * \
-self.sequentialNumerics["rating"] = self.sequentialNumerics["penalty"]
+self.sequentialNumerics["factor"]
+else:
+self.sequentialNumerics["rating"] = \
+self.sequentialNumerics["penalty"]
 self.score["count"] += self.sequentialNumerics["rating"]
 # keyboardPatterns
 # Honor or punish the keyboard patterns use
 if self.keyboardPatterns["count"] == 0:
-self.keyboardPatterns["rating"] = self.keyboardPatterns["bonus"] + \
+self.keyboardPatterns["rating"] = \
-self.keyboardPatterns["count"] * self.keyboardPatterns["factor"]
+self.keyboardPatterns["bonus"] + \
+self.keyboardPatterns["count"] * \
+self.keyboardPatterns["factor"]
 else:
 self.keyboardPatterns["rating"] = self.keyboardPatterns["penalty"]
 self.score["count"] += self.keyboardPatterns["rating"]
 # Count our basicRequirements and set the status
 # requirement met
 self.basicRequirements["count"] += 1
 # judge the requirement status
 self.basicRequirements["status"] = self.__determineStatus(
-self.basicRequirements["count"] - self.basicRequirements["minimum"])
+self.basicRequirements["count"] -
+self.basicRequirements["minimum"])
 if self.basicRequirements["status"] != self.Status_Failed:
 self.basicRequirements["rating"] = \
 self.basicRequirements["bonus"] + \
-self.basicRequirements["factor"] * self.basicRequirements["count"]
+self.basicRequirements["factor"] * \
-else:
+self.basicRequirements["count"]
-self.basicRequirements["rating"] = self.basicRequirements["penalty"]
+else:
+self.basicRequirements["rating"] = \
+self.basicRequirements["penalty"]
 self.score["count"] += self.basicRequirements["rating"]
 # beyond basic requirements
 self.recommendedPasswordLength["status"] = self.__determineStatus(
 self.recommendedPasswordLength["count"] - \
 # we apply them only, if the length is not awesome
 if self.recommendedPasswordLength["status"] != self.Status_Exceeded:
 # repeatedSequences
 # Honor or punish the use of repeated sequences
 if self.repeatedSequences["count"] == 0:
-self.repeatedSequences["rating"] = self.repeatedSequences["bonus"]
+self.repeatedSequences["rating"] = \
+self.repeatedSequences["bonus"]
 else:
-self.repeatedSequences["rating"] = self.repeatedSequences["penalty"] + \
+self.repeatedSequences["rating"] = \
+self.repeatedSequences["penalty"] + \
 self.repeatedSequences["count"] * \
 self.repeatedSequences["factor"]
 # mirroredSequences
 # Honor or punish the use of mirrored sequences
 if self.mirroredSequences["count"] == 0:
-self.mirroredSequences["rating"] = self.mirroredSequences["bonus"]
+self.mirroredSequences["rating"] = \
+self.mirroredSequences["bonus"]
 else:
-self.mirroredSequences["rating"] = self.mirroredSequences["penalty"] + \
+self.mirroredSequences["rating"] = \
+self.mirroredSequences["penalty"] + \
 self.mirroredSequences["count"] * \
 self.mirroredSequences["factor"]
 # save value before redundancy
 self.score["beforeRedundancy"] = self.score["count"]
 # apply the redundancy
 # is the password length requirement fulfilled?
 if self.recommendedPasswordLength["status"] != self.Status_Exceeded:
-# full penalty, because password is not long enough, only for a positive score
+# full penalty, because password is not long enough, only for
+# a positive score
 if self.score["count"] > 0:
 self.score["count"] *= 1.0 / self.redundancy["value"]
 # level it out
 if self.score["count"] > 100:

Mercurial Repositories > eric / file comparison

comparison: Utilities/PasswordChecker.py

Utilities/PasswordChecker.py