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

validar la complejidad de las contraseñas c# (16)

Además del enfoque estándar de mezclar alfa, numéricos y símbolos, me di cuenta cuando me registré en MyOpenId la semana pasada, el comprobador de contraseñas te dice si tu contraseña se basa en una palabra del diccionario, incluso si agregas números o reemplazas alfas con números similares (usando cero en lugar de ''o'', ''1'' en lugar de ''i'', etc.).

Estaba bastante impresionado.

Ver también ¿Cómo se computa la complejidad de la contraseña?

¿Cuál es la mejor manera de garantizar que una contraseña proporcionada por el usuario sea una contraseña segura en un formulario de registro o cambio de contraseña?

EDITAR: una idea que tenía (en 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

Bueno, esto es lo que uso:

Con una serie de controles para garantizar que cumple con los criterios mínimos:

Al menos 8 caracteres de longitud
contiene al menos un símbolo no alfanumérico
no coincide o contiene nombre de usuario / correo electrónico / etc.
etc

Aquí hay un plugin de jQuery que informa la fortaleza de la contraseña (no lo he probado yo mismo): http://phiras.wordpress.com/2007/04/08/password-strength-meter-a-jquery-plugin/

Y lo mismo portado a PHP: http://www.alixaxel.com/wordpress/2007/06/09/php-password-strength-algorithm/

Cracklib es genial, y en los paquetes más nuevos hay un módulo de Python disponible para él. Sin embargo, en los sistemas que aún no lo tienen, como CentOS 5, he escrito un contenedor de tipo ctypes para el sistema cryptlib. Esto también funcionaría en un sistema que no puede instalar python-libcrypt. Requiere python con tipos 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 que sean sustancialmente similares, como la función libcrypt "FascistGecos" pero sin requerir que el usuario exista en / etc / passwd.

Mi biblioteca ctypescracklib está disponible en github

Algunos usos de ejemplo:

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

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 utilizar un tipo de secuencia de comandos de resistencia de secuencia de comandos. 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 mediana
Todas las condiciones cumplidas: 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 código psuedo:

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

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

Está el cracker de contraseñas de John the Ripper, abierto y gratuito, que es una gran manera de verificar una base de datos de contraseñas existente.

Las dos medidas más simples para verificar son:

Longitud. Diría 8 caracteres como mínimo.
Número de clases de caracteres diferentes que contiene la contraseña. Estos son generalmente 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.

Los inspectores de fuerza de contraseñas, y si tiene tiempo + recursos (se justifica solo si está buscando más de unas pocas contraseñas), use tablas de arco iris.

No sé si a alguien le resultará útil esto, pero realmente me gustó la idea de un conjunto de reglas como lo sugirió phear, así que fui y escribí una regla de la clase Python 2.6 (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 probado en unidades

Se describe un algoritmo general en la página de wikipedia en http://en.wikipedia.org/wiki/Random_password_generator#Stronger_methods . También encontré un par de guiones aquí: http://webtecker.com/2008/03/26/collection-of-password-strength-scripts/ . Algunos de ellos están bajo la Licencia MIT, por lo que puede ver el código y averiguar cómo calculan la fortaleza. Encontré la entrada de wikipedia útil también.

Si tiene tiempo, ejecute un cracker de contraseñas.

después de leer las otras respuestas útiles, esto es a lo que me refiero:

-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

uso de ejemplo:

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 => ''too similar to username'' lo valga.

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

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

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

1: eliminar las contraseñas de uso frecuente
Compruebe las contraseñas introducidas en una lista de contraseñas de uso frecuente (consulte, por ejemplo, las 100.000 contraseñas más importantes en la lista de contraseñas filtradas de LinkedIn: http://www.adeptus-mechanicus.com/codex/linkhap/combo_not.zip ), asegúrese de incluir sustituciones de leetspeek : A @, E3, B8, S5, etc.
Quite las partes de la contraseña que golpea contra esta lista de la frase ingresada, antes de ir a la parte 2 a continuación.

2: no fuerce ninguna regla en el usuario

La regla de oro de las contraseñas es que más tiempo es mejor.
Olvídese del uso forzado de mayúsculas, números y símbolos porque (la gran mayoría de) los usuarios: - Convertirán la primera letra en mayúscula; - Pon el número 1 al final; - Pon un ! después de eso si se requiere un símbolo.

En su lugar, compruebe la fortaleza

Para un punto de partida decente ver: http://www.passwordmeter.com/

Sugiero como mínimo las siguientes reglas:

Additions (better passwords) ----------------------------- - Number of Characters Flat +(n*4) - Uppercase Letters Cond/Incr +((len-n)*2) - Lowercase Letters Cond/Incr +((len-n)*2) - Numbers Cond +(n*4) - Symbols Flat +(n*6) - Middle Numbers or Symbols Flat +(n*2) - Shannon Entropy Complex *EntropyScore Deductions (worse passwords) ----------------------------- - Letters Only Flat -n - Numbers Only Flat -(n*16) - Repeat Chars (Case Insensitive) Complex - - Consecutive Uppercase Letters Flat -(n*2) - Consecutive Lowercase Letters Flat -(n*2) - Consecutive Numbers Flat -(n*2) - Sequential Letters (3+) Flat -(n*3) - Sequential Numbers (3+) Flat -(n*3) - Sequential Symbols (3+) Flat -(n*3) - Repeated words Complex - - Only 1st char is uppercase Flat -n - Last (non symbol) char is number Flat -n - Only last char is symbol Flat -n

¡Seguir solo el contador de http://www.passwordmeter.com/ no es suficiente, porque su algoritmo ingenuo ve Password1! tan bueno, mientras que es excepcionalmente débil. Asegúrese de ignorar las letras mayúsculas iniciales cuando califique, así como los números y símbolos finales (según las últimas 3 reglas).

Cálculo de la entropía de Shannon
Ver: la forma más rápida de calcular la entropía en Python

3: no permita contraseñas que sean demasiado débiles
En lugar de obligar al usuario a ceder a las reglas contraproducentes, permita cualquier cosa que le dé una puntuación lo suficientemente alta. Qué tan alto depende de tu caso de uso.

Y más importante
Cuando aceptes la contraseña y la almacenes en una base de datos, asegúrate de usar sal y hash. .