Что лучший способ состоит в том, чтобы проверить силу пароля? [закрытый]

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

• по крайней мере 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/

Средства проверки надежности пароля, и если у Вас есть time+resources (ее выровненный по ширине, только если Вы проверяете на больше, чем несколько паролей) используют Таблицы Радуги.

Если Вы имеете время, выполняете взломщика пароля против него.

Я записал маленькое приложение JavaScript. Смотрите: еще один Метр Пароля . Можно загрузить источник и использовать/изменять его под GPL.развлекайтесь!

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

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

Существует открытое и свободное John Превосходный человек взломщик пароля, который является отличным способом проверить базу данных текущего пароля.

Две самых простых метрики для проверки на:

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

Объектно-ориентированный подход был бы рядом правил. Присвойте вес каждому правилу и выполните итерации через них. В 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;

}

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

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

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

• Одно условие, которое соблюдают: слабый пароль
• Соблюдают два условия: средний пароль
• Все условия, которые соблюдают: сильный пароль

Можно скорректировать вышеупомянутое для удовлетворения потребностей.

Я не знаю, найдет ли это кто-нибудь полезным, но мне очень понравилась идея набора правил, предложенная 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's 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

ОТКАЗ ОТ ОТВЕТСТВЕННОСТИ: не тестировалось модулем