Каков наилучший способ проверить силу пароля?

См. также Как вы вычисляете сложность пароля?

Каков наилучший способ гарантировать, что пароль, предоставленный пользователем, является надежным паролем в форме регистрации или изменения пароля?

EDIT: одна идея у меня (в python)

def validate_password(passwd):
    conditions_met = 0
    conditions_total = 3
    if len(passwd) >= 6: 
        if passwd.lower() != passwd: conditions_met += 1
        if len([x for x in passwd if x.isdigit()]) > 0: conditions_met += 1
        if len([x for x in passwd if not x.isalnum()]) > 0: conditions_met += 1
    result = False
    print conditions_met
    if conditions_met >= 2: result = True
    return result

Ответы

Ответ 1

В зависимости от языка я обычно использую регулярные выражения, чтобы проверить, имеет ли он:

Как минимум один верхний регистр и один строчная буква
Как минимум одно число
Как минимум один специальный символ
Длина не менее шести символов

Вы можете потребовать все вышеперечисленное или использовать тип измерителя прочности script. Для моего измерителя силы, если пароль имеет правильную длину, он оценивается следующим образом:

Выполнено одно условие: слабый пароль
Два условия: средний пароль
Все условия выполнены: надежный пароль

Вы можете настроить вышеуказанное, чтобы удовлетворить ваши потребности.

Ответ 2

http://webtecker.com/2008/03/26/collection-of-password-strength-scripts/

Ответ 3

Объектно-ориентированный подход будет набором правил. Назначьте вес каждому правилу и проведите через них. В psuedo-коде:

abstract class Rule {

    float weight;

    float calculateScore( string password );

}

Вычисление общей оценки:

float getPasswordStrength( string password ) {     

    float totalWeight = 0.0f;
    float totalScore  = 0.0f;

    foreach ( rule in rules ) {

       totalWeight += weight;
       totalScore  += rule.calculateScore( password ) * rule.weight;

    }

    return (totalScore / totalWeight) / rules.count;

}

Пример алгоритма правила, основанного на количестве присутствующих классов символов:

float calculateScore( string password ) {

    float score = 0.0f;

    // NUMBER_CLASS is a constant char array { '0', '1', '2', ... }
    if ( password.contains( NUMBER_CLASS ) )
        score += 1.0f;

    if ( password.contains( UPPERCASE_CLASS ) )
        score += 1.0f;

    if ( password.contains( LOWERCASE_CLASS ) )
        score += 1.0f;

    // Sub rule as private method
    if ( containsPunctuation( password ) )
        score += 1.0f;

    return score / 4.0f;

}

Ответ 4

Общий алгоритм описан на странице wikipedia в http://en.wikipedia.org/wiki/Random_password_generator#Stronger_methods. Я также нашел здесь несколько скриптов - http://webtecker.com/2008/03/26/collection-of-password-strength-scripts/. Некоторые из них находятся под лицензией MIT, поэтому вы можете посмотреть на код и выяснить, как они вычисляют силу. Я также нашел вход в wikipedia.

Ответ 5

Две простейшие метрики для проверки:

Длина. Я бы сказал, что минимум 8 символов.
Число различных классов символов, содержащихся в пароле. Это, как правило, строчные буквы, прописные буквы, цифры и знаки препинания и другие символы. Сильный пароль будет содержать символы не менее трех из этих классов; если вы вынуждаете число или другой неалфавитный символ, вы значительно снижаете эффективность атак со словарем.

Ответ 6

Если они не ошибаются, по крайней мере, один раз в неделю, при попытке войти в систему, то он слишком слаб.

Ответ 7

после прочтения других полезных ответов, вот что я собираюсь:

-1, так же как и имя пользователя
+0 содержит имя пользователя
+1 больше 7 символов
+1 больше 11 символов
+1 содержит цифры
+1 сочетание нижнего и верхнего регистров
+1 содержит пунктуацию
+1 непечатаемый char

pwscore.py:

import re
import string
max_score = 6
def score(username,passwd):
    if passwd == username:
        return -1
    if username in passwd:
        return 0
    score = 0
    if len(passwd) > 7:
        score+=1
    if len(passwd) > 11:
        score+=1
    if re.search('\d+',passwd):
        score+=1
    if re.search('[a-z]',passwd) and re.search('[A-Z]',passwd):
        score+=1
    if len([x for x in passwd if x in string.punctuation]) > 0:
        score+=1
    if len([x for x in passwd if x not in string.printable]) > 0:
        score+=1
    return score

пример использования:

import pwscore
    score = pwscore(username,passwd)
    if score < 3:
        return "weak password (score=" 
             + str(score) + "/"
             + str(pwscore.max_score)
             + "), try again."

вероятно, не самый эффективный, но кажется разумным. не уверен, что FascistCheck = > 'слишком похоже на имя пользователя' стоит того.

'abc123ABC! @£' = оценка 6/6, если не надмножество имени пользователя

возможно, это должно быть ниже.

Ответ 8

Там есть открытый и бесплатный John the Ripper, который отлично подходит для проверки существующей базы паролей.

Ответ 9

Хорошо, вот что я использую:

   var getStrength = function (passwd) {
    intScore = 0;
    intScore = (intScore + passwd.length);
    if (passwd.match(/[a-z]/)) {
        intScore = (intScore + 1);
    }
    if (passwd.match(/[A-Z]/)) {
        intScore = (intScore + 5);
    }
    if (passwd.match(/\d+/)) {
        intScore = (intScore + 5);
    }
    if (passwd.match(/(\d.*\d)/)) {
        intScore = (intScore + 5);
    }
    if (passwd.match(/[!,@#$%^&*?_~]/)) {
        intScore = (intScore + 5);
    }
    if (passwd.match(/([!,@#$%^&*?_~].*[!,@#$%^&*?_~])/)) {
        intScore = (intScore + 5);
    }
    if (passwd.match(/[a-z]/) && passwd.match(/[A-Z]/)) {
        intScore = (intScore + 2);
    }
    if (passwd.match(/\d/) && passwd.match(/\D/)) {
        intScore = (intScore + 2);
    }
    if (passwd.match(/[a-z]/) && passwd.match(/[A-Z]/) && passwd.match(/\d/) && passwd.match(/[!,@#$%^&*?_~]/)) {
        intScore = (intScore + 2);
    }
    return intScore;
}

Ответ 10

Мне нравится использовать Microsoft password checker

Ответ 11

Если у вас есть время, запустите с ним взломщик паролей.

Ответ 12

С серией проверок, чтобы обеспечить соответствие минимальным критериям:

не менее 8 символов
содержит по крайней мере один символ без буквенно-цифровых символов
не соответствует или содержит имя пользователя/адрес электронной почты и т.д.
и т.д.

Здесь плагин jQuery, который сообщает о силе пароля (не пробовал сам): http://phiras.wordpress.com/2007/04/08/password-strength-meter-a-jquery-plugin/

И то же самое портировано на PHP: http://www.alixaxel.com/wordpress/2007/06/09/php-password-strength-algorithm/

Ответ 13

В дополнение к стандартным подходам к смешиванию альфа, числовых символов и символов, я заметил, что когда я зарегистрировался в MyOpenId на прошлой неделе, программа проверки пароля сообщает вам, основан ли ваш пароль на словарном словаре, даже если вы добавляете номера или заменяете альфа с аналогичными числами (вместо нуля, вместо "i" и т.д. вместо нуля, "1" ).

Я был очень впечатлен.

Ответ 14

Я написал небольшое приложение Javascript. Посмотрите: Еще один измеритель пароля. Вы можете загрузить исходный код и использовать/изменить его под GPL. Получайте удовольствие!

Ответ 15

Я не знаю, найдет ли кто-нибудь это полезное, но мне очень понравилась идея набора правил, предложенная phear, поэтому я пошел и написал правило Python 2.6 (хотя он, вероятно, совместим с 2.5):

import re

class SecurityException(Exception):
    pass

class Rule:
    """Creates a rule to evaluate against a string.
    Rules can be regex patterns or a boolean returning function.
    Whether a rule is inclusive or exclusive is decided by the sign
    of the weight. Positive weights are inclusive, negative weights are
    exclusive. 


    Call score() to return either 0 or the weight if the rule 
    is fufilled. 

    Raises a SecurityException if a required rule is violated.
    """

    def __init__(self,rule,weight=1,required=False,name=u"The Unnamed Rule"):
        try:
            getattr(rule,"__call__")
        except AttributeError:
            self.rule = re.compile(rule) # If a regex, compile
        else:
            self.rule = rule  # Otherwise it a function and it should be scored using it

        if weight == 0:
            return ValueError(u"Weights can not be 0")

        self.weight = weight
        self.required = required
        self.name = name

    def exclusive(self):
        return self.weight < 0
    def inclusive(self):
        return self.weight >= 0
    exclusive = property(exclusive)
    inclusive = property(inclusive)

    def _score_regex(self,password):
        match = self.rule.search(password)
        if match is None:
            if self.exclusive: # didn't match an exclusive rule
                return self.weight
            elif self.inclusive and self.required: # didn't match on a required inclusive rule
                raise SecurityException(u"Violation of Rule: %s by input \"%s\"" % (self.name.title(), password))
            elif self.inclusive and not self.required:
                return 0
        else:
            if self.inclusive:
                return self.weight
            elif self.exclusive and self.required:
                raise SecurityException(u"Violation of Rule: %s by input \"%s\"" % (self.name,password))
            elif self.exclusive and not self.required:
                return 0

        return 0

    def score(self,password):
        try:
            getattr(self.rule,"__call__")
        except AttributeError:
            return self._score_regex(password)
        else:
            return self.rule(password) * self.weight

    def __unicode__(self):
        return u"%s (%i)" % (self.name.title(), self.weight)

    def __str__(self):
        return self.__unicode__()

Я надеюсь, что кто-то найдет это полезным!

Пример использования:

rules = [ Rule("^foobar",weight=20,required=True,name=u"The Fubared Rule"), ]
try:
    score = 0
    for rule in rules:
        score += rule.score()
except SecurityException e:
    print e 
else:
    print score

ОТКАЗ ОТ ОТВЕТСТВЕННОСТИ: Не тестировалось в блоке

Ответ 16

Cracklib отлично, а в более новых пакетах имеется доступный для него модуль Python. Тем не менее, в системах, которые еще не имеют его, например CentOS 5, я написал ctypes-обертку для системного cryptlib. Это также будет работать на системе, которую вы не можете установить python-libcrypt. Для этого требуется python с доступными ctypes, поэтому для CentOS 5 вам необходимо установить и использовать пакет python26.

У него также есть то преимущество, что он может принимать имя пользователя и проверять пароли, которые его содержат или, по сути, похожи, например, функция libcrypt "FascistGecos", но не требует, чтобы пользователь существовал в /etc/passwd.

My Библиотека ctypescracklib доступна на github

В некотором примере используется:

>>> FascistCheck('jafo1234', 'jafo')
'it is based on your username'
>>> FascistCheck('myofaj123', 'jafo')
'it is based on your username'
>>> FascistCheck('jxayfoxo', 'jafo')
'it is too similar to your username'
>>> FascistCheck('cretse')
'it is based on a dictionary word'

Ответ 17

Проверки силы пароля, и если у вас есть время + ресурсы (его оправдано, только если вы проверяете более нескольких паролей), используйте таблицы Rainbow.