在注册或更改密码表单中,确保用户提供密码的最佳方法是什么?

我有一个想法(在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 票数:17

根据语言,我通常使用正则表达式来检查它是否具有:

  • 至少一个大写和一个小写字母
  • 至少一个号码
  • 至少有一个特殊字符
  • 长度至少为六个字符

您可以要求以上所有,或使用强度计类型的脚本。 对于我的力量计,如果密码长度合适,则评估如下:

  • 满足一个条件:弱密码
  • 满足两个条件:中密码
  • 满足所有条件:强密码

您可以调整以上内容以满足您的需求。

===============>>#2 票数:10

面向对象的方法是一组规则。 为每个规则分配权重并迭代它们。 在伪代码中:

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;

}

===============>>#3 票数:4 已采纳

1:消除经常使用的密码
根据常用密码列表检查输入的密码(请参阅泄露的LinkedIn密码列表中的前100,000个密码: http//www.adeptus-mechanicus.com/codex/linkhap/combo_not.zip ),确保包括leetspeek换人 :A,E3,B8,S5等
在转到下面的第2部分之前,从输入的短语中删除针对此列表的部分密码。

2:不要对用户强制执行任何规则

密码的黄金法则是越长越好。
忘记强制使用大写字母,数字和符号,因为(绝大多数)用户将: - 将第一个字母作为资本; - 把数字1放在最后; - 放一个! 之后如果需要符号。

而是检查密码强度

如果有一个不错的起点,请参阅: http//www.passwordmeter.com/

我建议至少遵守以下规则:

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

只是跟着密码计是不够的,因为它的天真算法确实看到了Password1! 同样好,但它特别弱。 确保在评分时忽略首字母大写字母以及尾随数字和符号(根据最后3条规则)。

计算香农熵
请参阅: 在Python中计算熵的最快方法

3:不要允许任何太弱的密码
而不是强迫用户屈服于自我挫败的规则,允许任何能够给出足够高分的东西。 多高取决于您的使用案例。

最重要的是
当您接受密码并将其存储在数据库中时,请确保对其进行加盐和哈希!

===============>>#4 票数:3

要检查的两个最简单的指标是:

  1. 长度。 我要说最少8个字符。
  2. 密码包含的不同字符类的数量。 这些通常是小写字母,大写字母,数字和标点符号以及其他符号。 强密码将包含至少三个类中的字符; 如果强制使用数字或其他非字母字符,则会显着降低字典攻击的有效性。

===============>>#5 票数:2

Cracklib很棒,在较新的软件包中有一个Python模块可用。 但是,在尚未拥有它的系统上,例如CentOS 5,我已经为系统cryptlib编写了一个ctypes包装器。 这也适用于无法安装python-libcrypt的系统。 确实需要带有ctypes的python,因此对于CentOS 5,你必须安装并使用python26包。

它还具有以下优点:它可以使用用户名并检查包含它的密码或基本相似的密码,例如libcrypt“FascistGecos”函数,但不要求用户存在于/ etc / passwd中。

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

===============>>#6 票数:2

在阅读其他有用的答案之后,这就是我要去的地方:

-1与用户名相同
+0包含用户名
+1超过7个字符
+1超过11个字符
+1包含数字
+1大小写混合
+1包含标点符号
+1不可打印的字符

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,如果不是用户名的超集

也许这应该得分较低。

===============>>#7 票数:1

这就是我使用的:

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

===============>>#8 票数:1

有开放和免费的John the Ripper密码破解程序,这是检查现有密码数据库的好方法。

===============>>#9 票数:0

我不知道是否有人会发现这有用,但我真的很喜欢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

免责声明:未经过单元测试

===============>>#10 票数:0

我写了一个小的Javascript应用程序。 看看: 又一个密码计 您可以下载源代码并在GPL下使用/修改它。 玩得开心!

===============>>#11 票数:0

除了混合字母,数字和符号的标准方法之外,我注意到上周我在MyOpenId上注册时,密码检查器会告诉您密码是否基于字典单词,即使您添加数字或替换具有相似数字的alpha (使用零而不是'o','1'而不是'i'等)。

我印象非常深刻。

===============>>#12 票数:-1

如果你有时间,请对它运行密码破解程序。

===============>>#13 票数:-1

密码强度检查器,如果你有时间+资源(只有在检查多个密码时才合理)使用Rainbow Tables。

===============>>#14 票数:-1

通过一系列检查以确保其符合最低标准:

  • 至少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/

===============>>#15 票数:-2

在注册或更改密码表单中,确保用户提供密码的最佳方法是什么?

不评估复杂性和/或强度,用户会找到一种方法来欺骗你的系统或让他们感到非常沮丧以至于他们会离开。 这只会让你的情况是这样 只需要一定的长度,不使用泄露的密码。 加分:确保您实施的任何内容都允许使用密码管理器和/或2FA。

  ask by Ed L translate from so

未解决问题?本站智能推荐:

3回复

存储安全信息以供进一步使用的最佳方法是什么?

我的桌面应用程序要求用户提供代理服务器凭据以便以后使用它。 但是,存储此安全信息以供进一步使用的最佳方法是什么?
1回复

重置密码算法

对于那些忘记了我正在编写的iPhone应用程序的密码(基本上是4位密码)的用户,我想实现某种密码重置功能,但我不想让任何用户只能简单地禁用它。 我正在考虑进行某种验证,并想知道这种事情的最佳实践是什么。 我正在计划这样的事情: 用户联系我说他们忘记了密码 我通过电子邮件
4回复

如何计算密码复杂度

某些应用程序(或网站)在您键入时会计算密码的复杂性。 它们通常显示一个红色的条,该条变成橙色,然后变为绿色,然后随着您的密码变长而变绿,并且包含更多类别的字符(例如,小写,大写,标点符号,数字)。 如何可靠地计算密码的复杂度? 我想出了以下算法,但令我感到担忧的是它对Passw
8回复

防止密码提示正确输入密码

我正在实现密码+密码提示代码我想要阻止用户提示密码提示立即显示实际密码。 以下是我想要阻止的方案: 让我们说密码是: foob​​ar123 然后密码提示不能是: “foobar123” “密码是:foobar123” “foobar-1-2-3”(或
2回复

替代使用哈希在数据库中存储密码

我需要一些使用逆算法在数据库中安全存储密码的机制(这就是为什么哈希很不适合)。 有谁知道这样的algorythms以及如何在PostgreSQL中实现其中一个? 可能是任何秘密密钥加密?
2回复

选择更能抵抗暴力攻击的密码

为了增加成功进行暴力攻击所需的尝试次数,是否最好选择不仅长而且对高价值的数字字符和接近字母结尾的字母字符加权的密码? 还是蛮力攻击经常使用不按字母数字递增(近似)的算法?
3回复

帮助密码熵的计算(和有用性)

这是一个两部分问题: 第1部分 首先,处理在PHP中计算密码的熵。 我一直无法找到任何经验合理的代码示例,并且非常希望能够找到计算最终数字的“正确”方法。 网上的很多人都有他们自己的家庭烘焙加权算法,但我真的在寻找科学的答案。 我将使用密码熵作为更大安全系统的一部分,并根据
1回复

用于数据库持久性的多算法密码哈希结构

几年前,我使用了一个Java(弹簧)框架来散列密码并将其存储在数据库中。 但是我不记得这个名字了。 好处是,它不仅存储了带有salt等的哈希值,而且还存储了有关所用算法和配置的信息,例如{'alg':'bcrypt', { 'salt':'dsjhjdsfh', 'iter':'3561
3回复

密码哈希算法即使在超级计算机中也能确保密码安全?

我正在研究如何知道MD5发生冲突,因此它不够安全。 我正在寻找某种哈希算法,即使是超级计算机也要花费一些时间才能破解。所以你能告诉我什么样的哈希算法将使我的密码在未来20年的超级计算发展中保持安全。
17回复

语音难忘的密码生成算法

背景 前几天在健身房,我正在使用我的密码锁,并意识到一些对我作为程序员有用的东西。 也就是说,我的组合是三个单独的数字组合,听起来相似,或者有一些其他关系,使它们易于记忆。 例如,5-15-25,7-17-2,6-24-5。 这些例子似乎很容易记住。 题 我如何实现类似的