Java 验证密码复杂度的正则表达式

最新推荐文章于 2022-08-29 20:32:40 发布
最新推荐文章于 2022-08-29 20:32:40 发布
阅读量1.2w 收藏 31
点赞数 13
分类专栏： Java 文章标签： 密码校验
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yk10010/article/details/87687285
版权

一 正则表达式

复杂（同时包含数字，字母，特殊符号）
"^^(?![a-zA-z]+$)(?!\\d+$)(?![!@#$%^&*_-]+$)(?![a-zA-z\\d]+$)(?![a-zA-z!@#$%^&*_-]+$)(?![\\d!@#$%^&*_-]+$)[a-zA-Z\\d!@#$%^&*_-]+$"

简单（只包含数字或字母）
"^(?:\\d+|[a-zA-Z]+|[!@#$%^&*]+)$"

中级（包含字母和数字）
"^(?![a-zA-z]+$)(?!\\d+$)(?![!@#$%^&*]+$)[a-zA-Z\\d!@#$%^&*]+$"

二 弱密码校验

package com.hm.platform.common.util;

import org.apache.commons.lang.StringUtils;

/**
 * 
 * @ClassName: PwdCheckUtil.java
 * @Description: 密码校验工具类
 */
public class PwdCheckUtil {
	
	 public static String[] KEYBOARD_SLOPE_ARR = {
			 "!qaz", "1qaz", "@wsx","2wsx", "#edc", "3edc", "$rfv", "4rfv", "%tgb", "5tgb",
	         "^yhn", "6yhn", "&ujm", "7ujm", "*ik,", "8ik,", "(ol.", "9ol.", ")p;/", "0p;/",
	         "+[;.", "=[;.",  "_pl,", "-pl,", ")okm", "0okm", "(ijn", "9ijn", "*uhb", "8uhb",
	         "&ygv", "7ygv", "^tfc", "6tfc", "%rdx","5rdx", "$esz","4esz"
	    };
	 public static String[] KEYBOARD_HORIZONTAL_ARR = {
	            "01234567890-=",
	            "!@#$%^&*()_+",
	            "qwertyuiop[]",
	            "QWERTYUIOP{}",
	            "asdfghjkl;'",
	            "ASDFGHJKL:",
	            "zxcvbnm,./",
	            "ZXCVBNM<>?",
	    };
	 
	 public static String DEFAULT_SPECIAL_CHAR="!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";
	 public static String SPECIAL_CHAR = "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";

	public static void main(String[] args) {
        //System.out.print(checkSequentialSameChars("AAAAA", 5));
        //System.out.print(checkSequentialChars("Abcks", 3, true));
		//System.out.print(checkKeyboardSlantSite("Qaz", 3, false));
		//System.out.print(checkLateralKeyboardSite("qwer", 3, false));
	}
	
    /**
     * @brief   检测密码中字符长度
     * @param[in] password            密码字符串
     * @return  符合长度要求 返回true
     */
    public static boolean checkPasswordLength(String password, String minNum, String maxNum) {
        boolean flag =false;
        if (StringUtils.isBlank(maxNum))  {
        	minNum = StringUtils.isBlank(minNum) == true ? "0":minNum;
        	 if (password.length() >= Integer.parseInt(minNum)) {
                 flag = true;
             }
        } else {
        	minNum = StringUtils.isBlank(minNum) == true ? "0":minNum;
        	 if (password.length() >= Integer.parseInt(minNum) &&
                     password.length() <= Integer.parseInt(maxNum)) {
                 flag = true;
             }
        }
        return flag;
    }
	
    /**
     * @brief   检测密码中是否包含数字
     * @param[in] password            密码字符串
     * @return  包含数字 返回true
     */
    public static boolean checkContainDigit(String password) {
        char[] chPass = password.toCharArray();
        boolean flag = false;
        int num_count = 0;
 
        for (int i = 0; i < chPass.length; i++) {
            if (Character.isDigit(chPass[i])) {
                num_count++;
            }
        }
        if (num_count >= 1){
            flag = true;
        }
        return flag;
    }
	
    /**
     * @brief   检测密码中是否包含字母（不区分大小写）
     * @param[in] password            密码字符串
     * @return  包含字母 返回true
     */
    public static boolean checkContainCase(String password) {
        char[] chPass = password.toCharArray();
        boolean flag = false;
        int char_count = 0;
 
        for (int i = 0; i < chPass.length; i++) {
            if (Character.isLetter(chPass[i])) {
                char_count++;
            }
        }
        if (char_count >= 1) {
            flag = true;
        }
        return flag;
    }
    
	
    /**
     * @brief   检测密码中是否包含小写字母
     * @param[in] password            密码字符串
     * @return  包含小写字母 返回true
     */
    public static boolean checkContainLowerCase(String password) {
        char[] chPass = password.toCharArray();
        boolean flag = false;
        int char_count = 0;
 
        for (int i = 0; i < chPass.length; i++) {
            if (Character.isLowerCase(chPass[i])) {
                char_count++;
            }
        }
        if (char_count >= 1) {
            flag = true;
        }
        return flag;
    }
    
    
    /**
     * @brief   检测密码中是否包含大写字母
     * @param[in] password            密码字符串
     * @return  包含大写字母 返回true
     */
    public static boolean checkContainUpperCase(String password) {
        char[] chPass = password.toCharArray();
        boolean flag = false;
        int char_count = 0;
 
        for (int i = 0; i < chPass.length; i++) {
            if (Character.isUpperCase(chPass[i])) {
                char_count++;
            }
        }
        if (char_count >= 1) {
            flag = true;
        }
        return flag;
    }
	
	
	/**
     * @brief   检测密码中是否包含特殊符号
     * @param[in] password            密码字符串
     * @return  包含特殊符号 返回true
     */
    public static boolean checkContainSpecialChar(String password) {
        char[] chPass = password.toCharArray();
        boolean flag = false;
        int special_count = 0;
 
        for (int i = 0; i < chPass.length; i++) {
            if (SPECIAL_CHAR.indexOf(chPass[i]) != -1) {
                special_count++;
            }
        }
 
        if (special_count >= 1){
            flag = true;
        }
        return flag;
    }
	
	
	/**
     * @brief   键盘规则匹配器 横向连续检测
     * @param[in] password            密码字符串
     * @return  含有横向连续字符串 返回true
     */
    public static boolean checkLateralKeyboardSite(String password, int repetitions, boolean isLower) {
        String t_password = new String(password);
        //将所有输入字符转为小写
        t_password = t_password.toLowerCase();
        int n = t_password.length();
        /**
         * 键盘横向规则检测
         */
        boolean flag = false;
        int arrLen = KEYBOARD_HORIZONTAL_ARR.length;
        int limit_num = repetitions ;
 
        for(int i=0; i+limit_num<=n; i++) {
            String str = t_password.substring(i, i+limit_num);
            String distinguishStr = password.substring(i, i+limit_num);
 
            for(int j=0; j<arrLen; j++) {
                String configStr = KEYBOARD_HORIZONTAL_ARR[j];
                String revOrderStr = new StringBuffer(KEYBOARD_HORIZONTAL_ARR[j]).reverse().toString();
 
                //检测包含字母(区分大小写)
                if (isLower) {
                    //考虑 大写键盘匹配的情况
                    String UpperStr = KEYBOARD_HORIZONTAL_ARR[j].toUpperCase();
                    if((configStr.indexOf(distinguishStr) != -1) || (UpperStr.indexOf(distinguishStr) != -1)) {
                        flag = true;
                        return flag;
                    }
                    //考虑逆序输入情况下 连续输入
                    String revUpperStr = new StringBuffer(UpperStr).reverse().toString();
                    if((revOrderStr.indexOf(distinguishStr) != -1) || (revUpperStr.indexOf(distinguishStr) != -1)) {
                        flag = true;
                        return flag;
                    }
                }else {
                    if(configStr.indexOf(str) != -1) {
                        flag = true;
                        return flag;
                    }
                    //考虑逆序输入情况下 连续输入
                    if(revOrderStr.indexOf(str) != -1) {
                        flag = true;
                        return flag;
                    }
                }
            }
        }
        return flag;
    }
    
    
	

    /**
     * 
     * @Title: checkKeyboardSlantSite  
     * @Description: 物理键盘，斜向连接校验， 如1qaz,4rfv, !qaz,@WDC,zaq1 返回true
     * @param password	字符串
     * @param repetitions	重复次数
     * @param isLower		是否区分大小写 true:区分大小写， false:不区分大小写	
     * @return boolean    如1qaz,4rfv, !qaz,@WDC,zaq1 返回true
     * @throws
     */
    public static boolean checkKeyboardSlantSite(String password, int repetitions, boolean isLower) {
        String t_password = new String(password);
        t_password = t_password.toLowerCase();
        int n = t_password.length();
        /**
         * 键盘斜线方向规则检测
         */
        boolean flag = false;
        int arrLen = KEYBOARD_SLOPE_ARR.length;
        int limit_num = repetitions;
 
        for(int i=0; i+limit_num<=n; i++) {
            String str = t_password.substring(i, i+limit_num);
            String distinguishStr = password.substring(i, i+limit_num);
            for(int j=0; j<arrLen; j++) {
                String configStr = KEYBOARD_SLOPE_ARR[j];
                String revOrderStr = new StringBuffer(KEYBOARD_SLOPE_ARR[j]).reverse().toString();
                //检测包含字母(区分大小写)
                if (isLower) {
                    //考虑 大写键盘匹配的情况
                    String UpperStr = KEYBOARD_SLOPE_ARR[j].toUpperCase();
                    if((configStr.indexOf(distinguishStr) != -1) || (UpperStr.indexOf(distinguishStr) != -1)) {
                        flag = true;
                        return flag;
                    }
                    //考虑逆序输入情况下 连续输入
                    String revUpperStr = new StringBuffer(UpperStr).reverse().toString();
                    if((revOrderStr.indexOf(distinguishStr) != -1) || (revUpperStr.indexOf(distinguishStr) != -1)) {
                        flag = true;
                        return flag;
                    }
                }else {
                    if(configStr.indexOf(str) != -1) {
                        flag = true;
                        return flag;
                    }
                    //考虑逆序输入情况下 连续输入
                    if(revOrderStr.indexOf(str) != -1) {
                        flag = true;
                        return flag;
                    }
                }
            }
        }
        return flag;
    }
	
	/**
	 * @Title: checkSequentialChars  
	 * @Description: 评估a-z,z-a这样的连续字符, 
	 * @param password	字符串
	 * @param repetitions	连续个数
	 * @param isLower		是否区分大小写 true:区分大小写， false:不区分大小写
	 * @return boolean    含有a-z,z-a连续字符串 返回true
	 * @throws
	 */
    public static boolean checkSequentialChars(String password, int repetitions, boolean isLower) {
        String t_password = new String(password);
        boolean flag = false;
        int limit_num = repetitions;
        int normal_count = 0;
        int reversed_count = 0;
        //检测包含字母(区分大小写)
        if (!isLower) {
        	 t_password = t_password.toLowerCase();
        }
        int n = t_password.length();
        char[] pwdCharArr = t_password.toCharArray();
 
        for (int i=0; i+limit_num<=n; i++) {
            normal_count = 0;
            reversed_count = 0;
            for (int j=0; j<limit_num-1; j++) {
                if (pwdCharArr[i+j+1]-pwdCharArr[i+j]==1) {
                    normal_count++;
                    if(normal_count == limit_num -1){
                        return true;
                    }
                }
 
                if (pwdCharArr[i+j]-pwdCharArr[i+j+1]==1) {
                    reversed_count++;
                    if(reversed_count == limit_num -1){
                        return true;
                    }
                }
            }
        }
        return flag;
    }
 
	/**
	 * 
	 * @Title: checkSequentialSameChars  
	 * @Description: 验证键盘上是否存在多个连续重复的字符， 如！！！！, qqqq, 1111, ====, AAAA返回true
	 * @param password	字符串
	 * @param repetitions	重复次数
	 * @return    参数  
	 * @return boolean    返回类型  
	 * @throws
	 */
    public static boolean checkSequentialSameChars(String password, int repetitions) {
        String t_password = new String(password);
        int n = t_password.length();
        char[] pwdCharArr = t_password.toCharArray();
        boolean flag = false;
        int limit_num = repetitions;
        int count = 0;
        for (int i=0; i+limit_num<=n; i++) {
            count=0;
            for (int j=0; j<limit_num-1; j++) {
                if(pwdCharArr[i+j] == pwdCharArr[i+j+1]) {
                    count++;
                    if (count == limit_num -1){
                        return true;
                    }
                }
            }
        }
        return flag;
    }
}

 

yk10010
关注
专栏目录
java正则表达式判断密码是否包含大小写、数字、特殊字符
01-28
随机产生字符串，字符串中的字符只能由特殊字符(&@#$%*),大写字母(A-Z)，小写字母(a-z)以及数字(0-9)组成，且每种字符至少出现一次。这样产生字符串的方式可以应用到如下场景，比如，我们有一个应用就是添加用户完毕之后，发邮件给指定用户包括一个长度为11位的初始化密码。
Java密码复杂度实现
最新发布
m0_72958694的博客
06-03 443
Java密码复杂度实现的方法。
java 密码复杂度_Javascript校验密码复杂度的正则表达式
weixin_39567013的博客
02-21 366
目前使用的正则表达式如下：(?=.*\d)(?=.*[a-zA-Z])(?=.*[^a-zA-Z0-9]).{8,30}对应的验证规则是：密码中必须包含字母、数字、特称字符，至少8个字符，最多30个字符。这个正则表达式在C#可以正常使用，但是在Javascript中却有问题。请问是在js中如何写这样的正则表达式？测试字符串：a123456-解决方法如下所示：把\d改为[0-9]问题就解决了，正则表...
Java 密码复杂度校验正则表达式
gltncx11的博客
07-25 1516
代码】Java密码复杂度校验正则表达式。
java 正则验证密码_001-Java 验证密码复杂度的正则表达式
weixin_33957089的博客
02-12 373
packagecom.hm.platform.common.util;importorg.apache.commons.lang.StringUtils;/**** @ClassName: PwdCheckUtil.java* @Description: 密码校验工具类*/public classPwdCheckUtil {public static String[] KEYBOARD_SLOPE...
java密码复杂度 正则校验
夜一
08-29 2248
密码复杂度正则验证
正则表达式校验密码复杂性的规则
zfr_xuexiao66的博客
07-05 4072
最近做一个项目，需要校验密码复杂性，想了想还是用正则表达式来判断方便快捷； 因密码是数字+字母组成，就只校验数字和字母是否存在； 例： private String checkDataValid(String account, String pwd, String pwd_confirm) { //正则表达式判断字母数字同时存在并不包含特殊字符 String reg...
正则表达式判断密码强度
05-25
总结来说，正则表达式是评估和验证密码强度的有效工具，但需要结合其他安全措施，以确保密码策略的全面性和安全性。同时，对密码周期的管理也是保护账户安全的重要一环，这通常通过后台管理系统来实现。
Java常用正则表达式验证类完整实例【邮箱、URL、IP、电话、身份证等】
08-26
本篇文章主要讲述Java中如何使用正则表达式进行邮箱、URL、IP地址、电话号码、身份证等信息的验证。 邮箱验证是通过isEmail方法实现的，它需要一个正则表达式来定义邮箱的格式。通常邮箱地址包括用户名和域名两部分...
js:校验IPv6地址的正则表达式
01-21
jquery 正整数数字校验正则表达式JavaScript正则表达式校验非零的正整数实例利用js正则表达式校验正数、负数、和小数Javascript校验密码复杂度的正则表达式最全的常用正则表达式大全——包括校验数字、字符、一些...
Javascript校验密码复杂度的正则表达式
12-13
目前使用的正则表达式如下： 代码如下: (?=.*\d)(?=.*[a-zA-Z])(?=.*[^a-zA-Z0-9]).{8,30} 对应的验证规则是：密码中必须包含字母、数字、特称字符，至少8个字符，最多30个字符。 这个正则表达式在C#可以正常使用，但是在Javascript中却有问题。 请问是在js中如何写这样的正则表达式？ 测试字符串：a123456- 解决方法如下所示： 把\d改为[0-9]问题就解决了，正则表达式如下： 代码如下: var regex = new RegExp(‘(?=.*[0-9])(?=.*[a-zA-Z])(?=.*[^a-zA-Z0-9])
ReDoS-checker:检查您的正则表达式是否存在ReDoS漏洞
05-18
当一个正则表达式包含可以无限重复的部分，如`.*`或`\w*`，并且这些部分后面跟着一个具有高复杂度的模式时，就可能出现ReDoS问题。 **ReDoS-checker工作方式：** ReDoS-checker通过模拟正则表达式的匹配过程，对...
java正则表达式实例(邮箱，车牌，密码，url，IP，身份证，车牌等等)
08-10
- **解析**：该正则表达式用于匹配具有一定复杂度的密码。 - `(?=.*\\d)` 表示密码中必须包含至少一个数字。 - `(?=.*[a-z])` 表示密码中必须包含至少一个小写字母。 - `(?=.*[A-Z])` 表示密码中必须包含至少一个...
java 密码复杂度 正则_密码复杂度检查的正则表达式
weixin_42531779的博客
03-07 943
一， 密码最少长度为 6位 ，并至少包含3种复杂类别的字符 (如 Abc134 或者 abc12# 符合 如abc123 123 <>( 就不符合)二 密码最少长度为 8位 ，并至少包含2种复杂类别的字符 (如 Abc21334 或者 abcd1234 符合 如12345678 abcdefg就不符合)三， 密码的复杂类别由拉丁、西里尔或希腊字母组成复杂类别说明1 大写字母 如:A ...
强口令检测(使用正则表达式)
weixin_34377065的博客
10-04 2694
强口令检测 写一个函数，它使用正则表达式，确保传入的口令字符串是强口令。强口令的定义是：长度不少于 8 个字符，同时包含大写和小写字符，至少有一位数字。你可能需要用多个正则表达式来测试该字符串，以保证它的强度。 1 import re 2 3 def check(order): 4 if len(order) < 8 : 5 retu...
正则表达式-匹配密码验证（密码强弱等级，不能匹配中文，匹配数字 字母 字符）
McDull的博客
10-12 7031
分享一下我前段时间写的匹配密码强度的正则表达式，目前测试没有bug。 弱     6-16位    数字，字母，字符其中一种      或       6-7位    数字，字母，字符其中两种         或         6-7位    数字，字母，字符其中三种 中     8-16位    数字，字母，字符其中两种 强     8-14位    数字，字母，字符其中三种
**自用 正则表达式**
FormalName1的博客
09-09 157
包含数字、字母、特殊字符中的两种 正则表达式 6-20位，包含字母、数字、特殊字符中的任意两者或以上 ^(?![\d]+$)(?![a-zA-Z]+$)(?![^\da-zA-Z]+$).{6,20}$ ^(?![a-zA-Z]+$)(?!\d+$)(?![\W_]+$)\S{6,20}$
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值