Java实现--密码强度检测--的工具类代码

最新推荐文章于 2023-09-21 19:14:25 发布

龙吟在天

最新推荐文章于 2023-09-21 19:14:25 发布

阅读量1.8w

点赞数 8

分类专栏： java 文章标签：密码强度检测 java密码检测

本文链接：https://blog.csdn.net/u010156024/article/details/45673581

版权

java 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

介绍

做项目过程中，需要使用java来检测用户设置的密码强度问题，网上说的也比较多，但是对于密码到底什么样算是好的密码，并没有一个统一的标准。我这里借鉴网上的一个密码强度检测的办法，进行一个简单的说明，当然，我这里只是借鉴，并不能说非常好，只是个人觉得这个标准已经非常好了。
参考的网址链接：http://password.mx500.com/
该网址打开界面如下：
这里写图片描述

该网址里面详细说明了一个密码的各个项目的标准，有加分标准和扣分标准，最后综合分数，给出一个密码的评语，评语分为五个等级，每20分一个等级，20，40，60，80，100，这个五个等级，最高分100分，超过最高分100分的也算作100分计。最低分0分，负分也算0分计。

标准

在给出的密码中有五项最低标准，密码设置应该最少满足四项，五项最低标准为：

密碼最低要求8字元
最少符合下列四項中三項規則:
大寫英文字元
小寫英文字元
數字字元
符號字元

下面的表格中，有两大分类，加分项目和扣分项目，加分项目7条，扣分项目8条，每一项都有相应的分值计算方法，所以代码中就是按照这样的标准实现的。

补充说明

• Flat: 均一的加/扣分比例.
• Incr: 出現次數越多，加/扣分比例越大.
• Cond: 根據增加的字元數調整加/扣分比例.
• n: 出現次數.
• len: 密碼字串長度.
• 增加字元的變化能提高分數.
• 最後的分數為加分項目和減分項目的總和.
• 分數的範圍為0~100分.
• 分數不需達到最低字元即可計算.

该密码标准算法说明：

這個程式是設計用來評估密碼強度. 提供即時回饋機制，讓使用者可以改善密碼強度, 用固定的規則改善典型有缺點的密碼公式. 我們創造自己的公式來評估特定密碼的強度. 請註記, 這個程式不是標準的 “days-to-crack” 強度測定. 這個程式不是十分完美也不能保證產生完全安全的密碼, 只有針對密碼創造過程做簡單的檢測.

代码

下面给出整个工具类的代码：

/**
 * 密碼最低要求8字元
    最少符合下列四項中三項規則:
    大寫英文字元
    小寫英文字元
    數字字元
    符號字元

    增加字元的變化能提高分數.
    最後的分數為加分項目和減分項目的總和.
    分數的範圍為0~100分.
    分數不需達到最低字元即可計算.

    本人博客地址：http://blog.csdn.net/u010156024
    有什么问题 请留言或评论，我会及时回复。
 * 参考链接：
 * http://password.mx500.com/
 *
 */
public class CheckPswMeter {
    private String psw;
    private int length;//密码长度
    private int upperAlp = 0;//大写字母长度
    private int lowerAlp = 0;//小写字母长度
    private int num = 0;//数字长度
    private int charlen = 0;//特殊字符长度

    public CheckPswMeter(String psw){
        this.psw = psw.replaceAll("\\s", "");
        this.length = psw.length();
    }

    //密码长度积分
    public int CheckPswLength(){
        return this.length*4;
    }

    //大写字母积分
    public int CheckPswUpper() {
        String reg = "[A-Z]";
        Pattern pattern = Pattern.compile(reg);
        Matcher matcher = pattern.matcher(psw);
        int j = 0;
        while (matcher.find()) {
            j++;
        }
        this.upperAlp = j;
        if (j<=0) {
            return 0;
        }
        return (this.length-j)*2;
    }
    //测试小写字母字元
    public int CheckPwsLower(){
        String reg = "[a-z]";
        Pattern pattern = Pattern.compile(reg);
        Matcher matcher = pattern.matcher(this.psw);
        int j = 0;
        while (matcher.find()) {
            j++;
        }
        this.lowerAlp = j;
        if (j<=0) {
            return 0;
        }
        return (this.length-j)*2;
    }

    //测试数字字元
    public int checkNum(){
        String reg = "[0-9]";
        Pattern pattern = Pattern.compile(reg);
        Matcher matcher = pattern.matcher(this.psw);
        int j = 0;
        while (matcher.find()) {
            j++;
        }
        this.num = j;
        if (this.num == this.length) {
            return 0;
        }
        return j*4;
    }
    //测试符号字元
    public int checkChar(){
        charlen = this.length -this.upperAlp
                -this.lowerAlp - this.num;
        return this.charlen*6;
    }

    //密碼中間穿插數字或符號字元
    public int checkNumOrCharInStr(){
        int j = this.num + this.charlen -1;
        if (j<0) {
            j=0;
        }
        if (this.num+this.charlen == this.length) {
            j = this.length - 2;
        }
        return j*2;
    }
    /**
     * 最低要求标准
     * 该方法需要在以上加分方法使用后才可以使用
     * @return
     */
    public int LowerQuest(){
        int j = 0;
        if (this.length>=8) {
            j++;
        }
        if (this.upperAlp>0) {
            j++;
        }
        if (this.lowerAlp > 0) {
            j++;
        }
        if (this.num>0) {
            j++;
        }
        if (this.charlen >0 ) {
            j++;
        }
        if (j>=4) {

        }else {
            j = 0;
        }
        return j*2;
    }
    /**=================分割线===扣分项目=====================**/
    //只包含英文字母
    public int OnlyHasAlp(){
        if (this.length == (this.upperAlp+this.lowerAlp)) {
            return -this.length;
        }
        return 0;
    }

    //只包含数字
    public int OnlyHasNum(){
        if (this.length == this.num) {
            return -this.length;
        }
        return 0;
    }
    //重复字元扣分
    public int repeatDex(){
        char[] c = this.psw.toLowerCase().toCharArray();
        HashMap<Character, Integer> hashMap =
                new HashMap<Character, Integer>();
        for (int i = 0; i < c.length; i++) {
            if (hashMap.containsKey(c[i])) {
                hashMap.put(c[i], hashMap.get(c[i])+1);
            }else {
                hashMap.put(c[i], 1);
            }
        }
        int sum = 0;
        Iterator<Entry<Character, Integer>> iterator =
                hashMap.entrySet().iterator();
        while (iterator.hasNext()) {
            int j = iterator.next().getValue();
            if(j>0){
                sum = sum + j*(j-1);
            }
        }
        return -sum;
    }

    //连续英文大写字元
    public int seriseUpperAlp(){
        int j=0;
        char[] c = this.psw.toCharArray();
        for (int i = 0; i < c.length-1; i++) {
            if(Pattern.compile("[A-Z]").matcher(c[i]+"").find()){
                if (Pattern.compile("[A-Z]").matcher(c[i+1]+"").find()) {
                    j++;
                }
            }
        }
        return -2*j;
    }

    //连续英文小写字元
    public int seriseLowerAlp(){
        String reg = "[a-z]";
        int j=0;
        char[] c = this.psw.toCharArray();
        for (int i = 0; i < c.length-1; i++) {
            if (Pattern.compile(reg).matcher(c[i]+"").find()
                &&c[i]+1==c[i+1]) {
                j++;
            }
        }
        return -2*j;
    }

    //连续数字字元
    public int seriseNum(){
        String reg = "[0-9]";
        Pattern pattern = Pattern.compile(reg);
        char[] c = this.psw.toCharArray();
        int j=0;
        for (int i = 0; i < c.length-1; i++) {
            if (pattern.matcher(c[i]+"").matches()
                &&pattern.matcher(c[i+1]+"").matches()) {
                j++;
            }
        }
        return -2*j;
    }
    //连续字母abc def之类超过3个扣分  不区分大小写字母
    public int seriesAlp2Three(){
        int j=0;
        char[] c = this.psw.toLowerCase(Locale.CHINA).toCharArray();
        for (int i = 0; i < c.length-2; i++) {
            if (Pattern.compile("[a-z]").matcher(c[i]+"").find()) {
                if ((c[i+1]==c[i]+1) && (c[i+2]==c[i]+2)) {
                    j++;
                }
            }
        }
        return -3*j;
    }

    //连续数字123 234之类超过3个扣分  
    public int seriesNum2Three(){
        int j=0;
        char[] c = this.psw.toLowerCase(Locale.CHINA).toCharArray();
        for (int i = 0; i < c.length-2; i++) {
            if (Pattern.compile("[0-9]").matcher(c[i]+"").find()) {
                if ((c[i+1]==c[i]+1) && (c[i+2]==c[i]+2)) {
                    j++;
                }
            }
        }
        return -3*j;
    }

    public int jiafen(){
        System.out.println("密碼字數="+CheckPswLength());
        System.out.println("大寫英文字元="+CheckPswUpper());
        System.out.println("小寫英文字元="+CheckPwsLower());
        System.out.println("數字字元="+checkNum());
        System.out.println("符號字元="+checkChar());
        System.out.println("密碼中間穿插數字或符號字元="+checkNumOrCharInStr());
        System.out.println("已達密碼最低要求項目="+LowerQuest());
        return 0;
    }

    public int jianfen(){
        System.out.println("只有英文字元="+OnlyHasAlp());
        System.out.println("只有數字字元="+OnlyHasNum());
        System.out.println("重複字元 (Case Insensitive)="+repeatDex());
        System.out.println("連續英文大寫字元="+seriseUpperAlp());
        System.out.println("連續英文小寫字元="+seriseLowerAlp());
        System.out.println("連續數字字元="+seriseNum());
        System.out.println("連續字母超過三個(如abc,def)="+seriesAlp2Three());
        System.out.println("連續數字超過三個(如123,234)="+seriesNum2Three());
        return 0;
    }
}

整个代码中的方法和网页中的每一项积分标准一一对应，最后，jiafen() 和jianfen()方法打印出来各个方法的分值，使用单元测试方法，测试之后控制台打印结果如下：
这里写图片描述

最后在将密码输入网址框中结果图如下：
这里写图片描述

对比两个结果，是不是代码中完全实现了上面图示所实现的密码强度检测的功能！！！哈哈~~
还不赶快复制粘贴下来~~~~！！！！！

给我点个赞吧，最好评论给个赞！！^_^

更新

2017年1月3日更新

需要注意的是，计算过程中，n这个参数代表出现次数，对于在评论中给出的一个问题，密码是OOTNia!x5#gn
我以这个密码为例，进行说明。
这里写图片描述

加分项

第一个：密碼字數
n代表密码字数，此处n代表密码字符个数，n=12。根据计算公式+(n*4)，得到结果48。

第二个：大寫英文字元
n代表大写英文字符个数，n=4，len=12，根据计算公式 +((len-n)*2) 得到结果16。

第三个：小寫英文字元
n代表小写英文字符个数，n=5，len=12，根据计算公式 +((len-n)*2) ，得到结果14。

第四个：數字字元
n代表数字字符个数，n=1，根据计算公式，+(n*4) ，得到4。

第五个：符號字元
n代表特殊符号个数，n=2，根据计算公式，+(n*6) ，得到12。

第六个：密碼中間穿插數字或符號字元
n代表密码中间穿插数字或符号，n=3，根据公式 +(n*2) ，得到6。
此处的n=3，是因为数字5，符号！、#分别都属于插入密码中间，所以有三次。则n=3。

第七个：已達密碼最低要求項目
n代表已达到密码最低要求项目，n=5，根据公式 +(n*2) ，得到10。
此处的n=5，是因为满足了以下五条要求，所以等于5。如果密码满足四条，则n=4。

密碼最低要求8字元
最少符合下列四項中三項規則:
- 大寫英文字元
- 小寫英文字元
- 數字字元
- 符號字元

扣分项

第一条：重複字元 (Case Insensitive)
n表示重复字符个数，n=2，根据公式-(n(n-1)) ，得到-2。但是这个计算起来很特殊。
OOTNia!x5#gn密码中出现重复字符有：OO Nn。
对于OO来说，n=2，根据公式计算得到-2。
同样Nn来说，n=2，根据公式计算得到-2。
所以最终该项结果为-2+（-2）=-4。

对于这一个再举个例子：OONn333
该实例的结果为-10=-2-2-6。

第二条：連續英文大寫字元
n表示连续英文大写字符个数，n=3，根据公式-(n*2) ，得到-6。
OOTNia!x5#gn密码中的OO OT TN这三次属于连续英文大写，故n=3。

第三条：連續英文小寫字元
n表示连续小写英文字符个数，n=2，根据公式-(n*2) ，得到-4。
OOTNia!x5#gn密码中的ia gn这两次属于连续英文小写，故n=2。

对于其他扣分项，OOTNia!x5#gn密码都是0。所以也不加说明了。
相信大家看了上面的实例，已经懂得怎么计算了。

经过上面的结果，原网页中会给出密码的分数84%。
这个分数我不知道怎么计算得到的。所以没法没大家说明。有知道的朋友，可以在评论中说明一下。

PS:
我提交的代码仍然存在错误情况。
对于密码OOTNia!x5#gn的运行结果如下：
这里写图片描述

里面有两条结果出现错误：
密码中间穿插数字和字符：正确值6，代码计算值4。
连续英文小写字符：正确值-4，代码计算值0
这两条出现错误。大家如果在使用的时候，需要更正一下代码。

龙吟在天

关注

8
点赞
踩
18

收藏

觉得还不错? 一键收藏
10
评论
Java实现--密码强度检测--的工具类代码

介绍做项目过程中，需要使用java来检测用户设置的密码强度问题，网上说的也比较多，但是对于密码到底什么样算是好的密码，并没有一个统一的标准。我这里借鉴网上的一个密码强度检测的办法，进行一个简单的说明，当然，我这里只是借鉴，并不能说非常好，只是个人觉得这个标准已经非常好了。参考的网址链接：http://password.mx500.com/ 该网址打开界面如下：该网址里面详细说明了一个密码的
复制链接

扫一扫