¿Cuál es la mejor manera de verificar la fortaleza de una contraseña?

Dependiendo del idioma, generalmente uso expresiones regulares para verificar si tiene:

• Al menos una letra mayúscula y una minúscula
• Al menos un número
• Al menos un personaje especial
• Una longitud de al menos seis caracteres

Puede requerir todo lo anterior, o usar un tipo de script de medidor de fuerza. Para mi medidor de fuerza, si la contraseña tiene la longitud correcta, se evalúa de la siguiente manera:

• Una condición cumplida: contraseña débil
• Dos condiciones cumplidas: contraseña media
• Se cumplen todas las condiciones: contraseña segura

Puede ajustar lo anterior para satisfacer sus necesidades.

El enfoque orientado a objetos sería un conjunto de reglas. Asigne un peso a cada regla e itere a través de ellas. En psuedo-code:

abstract class Rule {

    float weight;

    float calculateScore( string password );

}

Cálculo de la puntuación total:

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;

}

Un algoritmo de regla de ejemplo, basado en el número de clases de caracteres presentes:

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;

}

Las dos métricas más simples para verificar son:

1. Longitud. Yo diría que 8 caracteres como mínimo.
2. Número de diferentes clases de caracteres que contiene la contraseña. Suelen ser letras minúsculas, letras mayúsculas, números y signos de puntuación y otros símbolos. Una contraseña segura contendrá caracteres de al menos tres de estas clases; Si fuerza un número u otro carácter no alfabético, reduce significativamente la efectividad de los ataques de diccionario.

Cracklib es excelente, y en los paquetes más nuevos hay un módulo Python disponible para él. Sin embargo, en sistemas que aún no lo tienen, como CentOS 5, he escrito un contenedor de tipos para el sistema cryptlib. Esto también funcionaría en un sistema que no puede instalar python-libcrypt. requiere requiere python con ctypes disponibles, por lo que para CentOS 5 debe instalar y usar el paquete python26.

También tiene la ventaja de que puede tomar el nombre de usuario y buscar contraseñas que lo contengan o sean sustancialmente similares, como la función libcrypt "FascistGecos" pero sin requerir que el usuario exista en/etc/passwd.

My la biblioteca ctypescracklib está disponible en github

Algunos ejemplos de usos:

>>> 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'

después de leer las otras respuestas útiles, esto es con lo que voy:

-1 igual que el nombre de usuario
+ 0 contiene nombre de usuario
+ 1 más de 7 caracteres
+ 1 más de 11 caracteres
+ 1 contiene dígitos
+ 1 mezcla de mayúsculas y minúsculas
+ 1 contiene puntuación
+ 1 char no imprimible

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

ejemplo de uso:

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

probablemente no sea el más eficiente, pero parece razonable. No estoy seguro de que FascistCheck => 'demasiado similar al nombre de usuario' valga la pena.

'abc123ABC! @ £' = puntaje 6/6 si no es un superconjunto de nombre de usuario

tal vez eso debería puntuar más bajo.

Existe el cracker de contraseña abierto y gratuito John the Ripper que es una excelente manera de verificar una base de datos de contraseñas existente.

Bueno, esto es lo que uso:

   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;
} 

Escribí una pequeña aplicación Javascript. Eche un vistazo: Sin embargo, otro medidor de contraseña . Puede descargar la fuente y usarla/modificarla bajo GPL. ¡Que te diviertas!

No sé si alguien encontrará esto útil, pero realmente me gustó la idea de un conjunto de reglas como lo sugiere phear, así que fui y escribí una regla Python 2.6 clase (aunque probablemente sea compatible con 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__()

¡Espero que alguien encuentre esto útil!

Ejemplo de uso:

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

DESCARGO DE RESPONSABILIDAD: No se ha probado la unidad

Además del enfoque estándar de mezclar alfa, numérico y símbolos, noté que cuando me registré con MyOpenId la semana pasada, el verificador de contraseñas le dice si su contraseña se basa en una palabra del diccionario, incluso si agrega números o reemplaza alfa con números similares. (usando cero en lugar de 'o', '1' en lugar de 'i', etc.).

Estaba muy impresionado.