最强密码规则效验（java后台版和javascript版）

最新推荐文章于 2024-07-14 03:09:25 发布
置顶 最新推荐文章于 2024-07-14 03:09:25 发布
阅读量5.6k 收藏 19
点赞数 8
文章标签： java密码弱口令效验 java密码正则表达式验证 java键盘连续3位正则 java不能连续字符（如123、abc）连续3位或3位以上 java正则是否包含电话是否包含手机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28322319/article/details/90699307
版权

java密码规则效验（java后台版和javascript版）

最强密码规则效验:（java后台版和javascript版）
需求如下：
（一）口令至少由8位及以上大小写字母、数字及特殊字符等混合、随机组成（至少包括数字、小写字母、大写字母和特殊符号中的三种）。
同时严禁在口令中包含以下情况：

  1. 连续数字或重复数字：如“678”或“AAA”等；
  2. 英文单词或拼音：如“oper”或“admin”等；
  3. 含有与账号名、主机名、系统名、厂商名相同或相似的字符串；
  4. 含有与局房、人员姓名、生日、证件号码、电话号码、手机号码及门牌号码等相同或相似的字符串；
  5. 位于键盘相邻位置的字符超过2位，例如“2wsx@WSX”或“2we4@WE$”等；
  6. 使用系统或应用的默认口令，例如“ftp@ftp.net”等；
  7. 属于弱口令库中的常见口令。
    （二）应以HASH或者加密技术保存口令，不得以明文方式保存或者传输；
    （三）账号使用者至少每90天对口令更换一次，5次以内不得设置相同的口令。修改口令时，须保留口令修改记录以备审计（具体格式参见附件1）；
    （四）重要系统应采用短信动态口令、证书等强认证登录方式。
    （五）由于员工离职等原因，原账号不能删除或者需要重新赋予另一个人时，应修改相应账号的口令。

前段版：

function checkProv(val) {
	var pattern = /^[1-9][0-9]/;
	var provs = {11:"北京",12:"天津",13:"河北",14:"山西",15:"内蒙古",21:"辽宁",22:"吉林",23:"黑龙江 ",31:"上海",32:"江苏",33:"浙江",34:"安徽",35:"福建",36:"江西",37:"山东",41:"河南",42:"湖北 ",43:"湖南",44:"广东",45:"广西",46:"海南",50:"重庆",51:"四川",52:"贵州",53:"云南",54:"西藏 ",61:"陕西",62:"甘肃",63:"青海",64:"宁夏",65:"新疆",71:"台湾",81:"香港",82:"澳门"};
	if(pattern.test(val)) {
		if(provs[val]) {
			return true;
		}
	}
	return false;

}

function checkDate(val) {
	var pattern = /^(18|19|20)\d{2}((0[1-9])|(1[0-2]))(([0-2][1-9])|10|20|30|31)$/;
	if(pattern.test(val)) {
		var year = val.substring(0, 4);
		var month = val.substring(4, 6);
		var date = val.substring(6, 8);
		var date2 = new Date(year+"-"+month+"-"+date);
		if(date2 && date2.getMonth() == (parseInt(month) - 1)) {
			return true;
		}
	}
	return false;
}
function checkCode(val) {
	var p = /^[1-9]\d{5}(18|19|20)\d{2}((0[1-9])|(1[0-2]))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]$/;
	var factor = [ 7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2 ];
	var parity = [ 1, 0, 'X', 9, 8, 7, 6, 5, 4, 3, 2 ];
	var code = val.substring(17);
	if(p.test(val)) {
		var sum = 0;
		for(var i=0;i<17;i++) {
			sum += val[i]*factor[i];
		}
		if(parity[sum % 11] == code.toUpperCase()) {
			return true;
		}
	}
	return false;
}


//检测密码是否是身份证
function checkID(val) {
	if (checkCode(val)) {
		var date = val.substring(6, 14);
		if (checkDate(date)) {
			if (checkProv(val.substring(0, 2))) {
				return true;
			}
		}
	}
	return false;
}

//密码不得包含键盘上任意连续的三个字符或shift转换字符
function validateKey(str) {
	//定义横向穷举
	var keyCode = [
		["`~·", "1=", "2@@", "3#", "4$￥", "5%", "6^……", "7&", "8*", "9(（", "0）)", "-_", "=+"],
		[" ","qQ", "wW", "eE", "rR", "tT", "yY", "uU", "iI", "oO", "pP", "[{【", "]}】", "\\|、"],
		[" ","aA", "sS", "dD", "fF", "gG", "hH", "jJ", "kK", "lL", ";:", "\'\"’“"],
		[" ","zZ", "xX", "cC", "vV", "bB", "nN", "mM", ",《<", ".>》", "/?？"]
	];

	//找出给出的字符串，每个字符，在坐标系中的位置。
	var c = str.split("");
	console.log(c)
	var x = new Array();
	var y = new Array();
	for (var i = 0; i < c.length; i++) {
		var temp = c[i];
		toHere:
				for (var j = 0; j < keyCode.length; j++) {
					for (var k = 0; k < keyCode[j].length; k++) {
						var jk = keyCode[j][k];
						if (jk.indexOf(temp)!=-1) {
							x.push(j);
							y.push(k);
							break toHere;
						}
					}
				}
	}
	var flag = false;
	for (var i = 0; i < x.length - 2; i++) {
		// 如果X一致，那么就是在一排
		if (x[i] == x[i + 1] && x[i + 1] == x[i + 2]) {//四者在同一行上
			if (y[i] > y[i + 2]) {
				if (y[i] - 1 == y[i + 1] && y[i] - 2 == y[i + 2]) {
					flag = true;
					break;
				}
			} else {
				if (y[i] + 1 == y[i + 1] && y[i] + 2 == y[i + 2]) {
					flag = true;
					break;
				}
			}
		} else if (x[i] != x[i + 1]
				&& x[i + 1] != x[i + 2]
				&& x[i] != x[i + 2]
		) {//四者均不在同一行上,但是如果y相同，说明是一列
			if (y[i] == y[i + 1] && y[i + 1] == y[i + 2]) {
				flag = true;
				break;
			}
		}
	}
	return flag;
}


//不能相同字符（如111、aaa）连续3位或3位以上
function checkSame(str) {
	var re = /(\w)*(\w)\2{2}(\w)*/g;
	if(re.test(str)){
		return true;
	}else{
		return false;
	}
}

//不能连续字符（如123、abc）连续3位或3位以上
function checkRepeat(str){
	var arr = str.split('');
	var flag = false;
	for (var i = 1; i < arr.length-1; i++) {
		var firstIndex = arr[i-1].charCodeAt();
		var secondIndex = arr[i].charCodeAt();
		var thirdIndex = arr[i+1].charCodeAt();
		thirdIndex - secondIndex == 1;
		secondIndex - firstIndex==1;
		if((thirdIndex - secondIndex == 1)&&(secondIndex - firstIndex==1)){
			flag =  true;
		}
	}
	if(!flag){
		return flag;
	}
	return flag;
}

后台：
package com.cmcc.system.util;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.lang.StringUtils;

public class CheckPassword {

/**
 * 三个或者三个以上相同
 * @return
 */
public static String  check3(String pwd) {

	String regx = "^.*(.)\\1{2}.*$";
	Matcher m = null;
	Pattern p = null;
	p = Pattern.compile(regx);
	m = p.matcher(pwd);
	if(m.matches()) {
		return "包含三个或者三个以上相同";
	}else {
		return "ok";

	}
	
}


/**
 * 验证生日 、身份证
 * @return
 */
public static String  checkBirthday(String pwd) {
	String birthday = "(([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]{1}[1-9][0-9]{2}|[1-9][0-9]{3})(((0[13578]|1[02])(0[1-9]|[12][0-9]|3[01]))|((0[469]|11)(0[1-9]|[12][0-9]|30))|(02-(0[1-9]|[1][0-9]|2[0-8]))))|((([0-9]{2})(0[48]|[2468][048]|[13579][26])|((0[48]|[2468][048]|[3579][26])00))0229)";

    Pattern pattern = Pattern.compile(birthday);
    Matcher matcher = pattern.matcher(pwd);
	
	if (matcher.find()) {
		return "包含生日或者身份证";
	}else {
    	return "ok";
	}

}




/**
 * 密码规则
 * @return
 */
public static String  checkp(String pwd) {
	String str = "^(?![a-zA-Z]+$)(?![A-Z0-9]+$)(?![A-Z\\W_!@#$%^&*`~()-+=]+$)(?![a-z0-9]+$)(?![a-z\\W_!@#$%^&*`~()-+=]+$)(?![0-9\\W_!@#$%^&*`~()-+=]+$)[a-zA-Z0-9\\W_!@#$%^&*`~()-+=]{8,30}$";
	if (!pwd.matches(str)) {
		return "口令至少由8位及以上大小写字母、数字及特殊字符等混合、随机组成（至少包括数字、小写字母、大写字母和特殊符号中的三种";
	}else {
    	return "ok";
	}

}



/**
 * 验证密码
 * @param pwd
 * @return
 */
public static String checkPwd(String pwd) {
	//密码规则
	String checkp = checkp(pwd);
	//键盘上连续3位或者以上
	String rsThree = validateKey(pwd);
	
	String repeat = checkRepeat(pwd);
	//包含生日
	String checkBirthday = checkBirthday(pwd);
	//三个或者三个以上相同
	String check3 = check3(pwd);
	//包含手机号
	String checkMobile = checkMobile(pwd);
	//包含固定电话
	String checkPhone = checkPhone(pwd);

	
	if (!"ok".equals(checkp)) {
		return checkp;
	}else if(!"ok".equals(rsThree)) {
		return rsThree;
	}else if(!"ok".equals(repeat)) {
		return repeat;
	}else if(!"ok".equals(checkBirthday)) {
		return checkBirthday;
	}else if(!"ok".equals(check3)) {
		return check3;
	}else if(!"ok".equals(checkMobile)) {
		return checkMobile;
	}else if(!"ok".equals(checkPhone)) {
		return checkPhone;
	}else {
		return "true";
	}
	
}







/**
 * 包含手机号
 * @param sParam
 * @return
 */
public static String checkMobile(String sParam){

	if(sParam.length()<=0)
	return "";
	Pattern pattern = Pattern.compile("(1|861)(3|4|5|6||7|8|9)\\d{9}$*");
	Matcher matcher = pattern.matcher(sParam);
	StringBuffer bf = new StringBuffer();
	while (matcher.find()) {
	bf.append(matcher.group()).append(",");
	}
	int len = bf.length();
	if (len > 0) {
	bf.deleteCharAt(len - 1);
	}
	if (StringUtils.isNotBlank(bf.toString())) {
		return "包含手机号";
	}else {
		return "ok";
	}
	}


/**
 * 包含固定电话
 * @param content
 * @return
 */
public static String checkPhone(String content) {
   List<String> list = new ArrayList<>();
    Pattern p = Pattern.compile("\\d{3}-\\d{8}|\\d{4}-\\d{6}|\\d{7}|\\d{8}");
    Matcher matcher = p.matcher(content);
    while (matcher.find()) {
        String n = matcher.group(0).toString();
        list.add(n);
    }
    if (!list.isEmpty()) {
		return "包含固定电话";
	}else {
		return "ok";
	}
}



//密码不得包含键盘上任意连续的三个字符或shift转换字符
public static String validateKey(String str) {

    //定义横向穷举
    String[][] keyCode = {
            {"`~·", "1=", "2@@", "3#", "4$￥", "5%", "6^……", "7&", "8*", "9(（", "0）)", "-_", "=+"},
            {" ","qQ", "wW", "eE", "rR", "tT", "yY", "uU", "iI", "oO", "pP", "[{【", "]}】", "\\|、"},
            {" ","aA", "sS", "dD", "fF", "gG", "hH", "jJ", "kK", "lL", ";:", "\'\"’“"},
            {" ","zZ", "xX", "cC", "vV", "bB", "nN", "mM", ",《<", ".>》", "/?？"}
    };

    //找出给出的字符串，每个字符，在坐标系中的位置。
    char[] c = str.toCharArray();
    List<Integer> x = new ArrayList<Integer>();
    List<Integer> y = new ArrayList<Integer>();
    for (int i = 0; i < c.length; i++) {
        char temp = c[i];
        toHere:
        for (int j = 0; j < keyCode.length; j++) {
            for (int k = 0; k < keyCode[j].length; k++) {
                String jk = keyCode[j][k];
                if (jk.contains(String.valueOf(temp))) {
                    x.add(j);
                    y.add(k);
                    break toHere;
                }
            }
        }
    }
    boolean flag = false;
    for (int i = 0; i < x.size() - 2; i++) {
        // 如果X一致，那么就是在一排
        if (x.get(i) == x.get(i + 1) && x.get(i + 1) == x.get(i + 2) ) {//四者在同一行上
            if (y.get(i) > y.get(i + 2)) {
                if (y.get(i) - 1 == y.get(i + 1) && y.get(i) - 2 == y.get(i + 2) ) {
                    flag = true;
                    break;
                }
            } else {
                if (y.get(i) + 1 == y.get(i + 1) && y.get(i) + 2 == y.get(i + 2) ) {
                    flag = true;
                    break;
                }
            }

        } else if (x.get(i) != x.get(i + 1)
                && x.get(i + 1) != x.get(i + 2)
                && x.get(i) != x.get(i + 2)
               ) {//四者均不在同一行上,但是如果y相同，说明是一列
                if (y.get(i) == y.get(i + 1) && y.get(i + 1) == y.get(i + 2)) {
                    flag = true;
                    break;
            }
        }

    }
	if (flag) {
    	return "不能连续三个或者三个以上字符";

	}else {
		return "ok";
	}
}

//转码
public static int getUnicode(char c){
	String returnUniCode=null;
	returnUniCode=String.valueOf((int)c); 
	return  Integer.parseInt(returnUniCode);
}
 //不能连续字符（如123、abc）连续3位或3位以上
public static String checkRepeat(String str){
	String[] arr = str.split("");
	boolean flag = false;
	for (int i = 1; i < arr.length-1; i++) {
		int firstIndex = getUnicode(arr[i-1].charAt(0));
		int secondIndex = getUnicode(arr[i].charAt(0));
		int thirdIndex = getUnicode (arr[i+1].charAt(0));
		if((thirdIndex - secondIndex == 1)&&(secondIndex - firstIndex==1)){
			flag =  true;
		}
	}
	if (flag) {
    	return "不能连续3字母";

	}else {
		return "ok";
	}
}

}

qq_28322319
关注
  • 8
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
密码校验规则(不能包含3个及以上字典、键盘连续字符)[Java版]
Waria的博客
12-03 1万+
参考文章：https://blog.csdn.net/sjdjjd6466446/article/details/108991554 最近做用户注册密码校验，需求： 1、长度大于8，且小于32 2、不能包含用户名 3、不能包含连续3位及以上相同字母或数字 4、不能包含3个及以上字典连续字符 4、数字、小写字母、大写字母、特殊字符，至少包含三种 因为没做过字典连续字符的判断，正则表达式好像也做不到，一时没有思路，参考了开篇提到的那篇博客（键盘连续字符的判断），所以有了以下工具方法，并把键盘连续字符的判
几个比较实用的JavaScript 测试及效验工具
10-29
本文将介绍一些实用的JavaScript测试和效验工具。 JSLint是一款基于Web的JavaScript代码验证工具，用于检查JavaScript代码中的错误。它允许开发者进行特定的设置，以便自定义验证算法，从而满足不同的需求。JSLint...
密码校验规则(不能包含3个及以上字典、键盘连续字符)
yy1209357299的博客
03-13 1453
4、数字、小写字母、大写字母、特殊字符，至少包含三种。3、不能包含连续3位及以上相同字母或数字。4、不能包含3个及以上字典连续字符。1、长度大于8，且小于32。
java后端校验弱密码
weixin_33838896的博客
07-14 182
Java后端校验弱密码 在现代的互联网应用中，用户密码是重要的安全措施之一，但是很多用户在设置密码时并不够安全，导致密码容易被破解。为了保护用户数据的安全，我们需要在后端对用户设置的密码进行强度校验，避免使用弱密码。本文将介绍如何在Java后端进行弱密码校验，并提供代码示例。 什么是弱密码？ 弱密码是指容易被猜测或者破解的...
密码规则校验
meser88的博客
11-24 638
密码正则表达式记录，min：最短长度；max：最长长度 数字：^[0-9]{"+min+","+max+"}$ 小写字母：^[a-z]{"+min+","+max+"}$ 大写字母：^[A-Z]{"+min+","+max+"}$ 特殊符号：^(\\W){"+min+","+max+"}$ 数字+小写字母：^(?![0-9]+$)(?!a-zA-Z]+$)[0-9a-z]{"+min+","+max+"}$ 数字+大写字母：^(?![0-9]+$)(?!a-zA-Z]+$)[0-9A-Z]{"+
密码校验规则(不能包含3个及以上键盘连续字符)PHP
zyh2468的博客
11-10 9203
密码校验规则(不能包含3个及以上键盘连续字符)PHP
确认密码校验规则
m0_60746035的博客
10-26 263
callback(new Error("两次输入密码不一致!message: '两次输入密码不一致',message: '请输入确认密码',
java ip首部效验和
12-07
大学生网络实验课 （1）在界面上，用户能够输入或编辑IP协议包各字段数据，例如，“协议”字段应该是下拉选择 方式; （2）程序能够自动检查IP地址的合法性，且主机可用；...检验“首部校验和”字段的计算结果：
cs.rar_效验和
09-20
在IT领域，效验和（Checksum）是一种广泛用于数据校验的技术，它的目的是检测数据传输或存储过程中可能发生的错误。16位效验和是指通过特定算法计算出的一个16位的数值，用来验证文件的完整性和一致性。下面将详细...
java累加和校验实现方式16进制(推荐)
09-01
java累加和校验实现方式16进制(推荐) 在信息技术领域，数据校验是确保数据完整性和准确性的关键环节。本文将重点介绍如何使用Java语言实现16进制累加和校验的一种有效方式。Java作为一种广泛使用的编程语言，它在...
注册密码复杂度校验适用联通规则
11-19
口令不能为空 口令长度应大于等于8个字符 口令应由大写字母、小写字母、数字、特殊符号中的3种及以上类型组成 口令不得使用一串相同的数字或字母作为口令 口令不能含有与账号名称相同的英文单词、汉语拼音或其简写 口令中不应含有明确意义的英文单词或汉语拼音 口令不得使用看似符合要求，实为连续键盘序列组合作为口令
VC.rar_伪造_报文格式_效验和
09-21
"VC.rar_伪造_报文格式_效验和"这个主题涉及了几个关键概念，我们将逐一探讨。 首先，"VC"很可能指的是Visual C++，这是一个由Microsoft开发的集成开发环境，广泛用于创建Windows应用程序，包括涉及到网络通信的...
el-input密码校验规则
Nefertar的博客
05-22 1152
密码必须为长度必须8位以上，需至少包含数字、大写字母、小写字母、特殊字符中的三种。
密码规则验证
衣乌安、随笔
10-21 616
// 要求：6-18位，必须同时包含小写字母、大写字母、数字和特殊字符 // 特殊字符： `~!@#$%^&*()-_=+\|[\{}];:'",<.>/? const test = /^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[`~!@#\$%\^&\*\(\)\\\-_=\+\|\[\{\}\];:'",<\.>\...
密码强度校验(密码不能包含账号名及相似字符数字如2-z,1-l,0-o)
weixin_44246694的博客
11-08 5150
密码强度校验(密码不能包含账号名及相似字符数字如2-z,1-l,0-o) 记一次坑爹现场提出的刁钻问题： 对密码强度进行校验，应符合以下条件： 1.口令长度应至少10位； 2.口令应包括数字、小写字母、大写字母、特殊符号4类中至少3类； 3.口令应与用户名无相关性，口令中不得包含用户名的完整字符串、大小写变位或形似变换的字符串； 4.应更换系统或设备的出厂默认口令； 5.口令设置应避免键盘排序密码...
Java密码校验（正则表达式）：密码由这四种元素组成（数字、大写字母、小写字母、特殊字符），且必须包含全部四种元素；密码长度大于等于8个字符。
热门推荐
宋冠巡的博客
07-15 1万+
# 1. 需求 对用户密码的强度进行校验，要求用户密码达到一定的强度，符合安全性要求。 ## 1.1. 基础版需求 密码必须由字母和数字组成（同时包括数字和数字）；密码长度大于等于8个字符。 ## 1.2. 进阶版需求 密码由这四种元素组成（数字、大写字母、小写字母、特殊字符），且必须包含全部四种元素；密码长度大于等于8个字符。
密码校验规则的一些思考
天行健，君子以自强不息；地势坤，君子以厚德载物。
10-25 375
阅读文本大概需要3分钟。虽然现在第三方登录微信、QQ、GitHub等大行其道，但是账密登录依然是一个系统最核心、最主要的功能之一。登录功能的好坏直接影响到系统的安全，而登...
npm 忽略版本效验
最新发布
07-24
`npm (Node.js Package Manager)` 是 Node.js 的官方包管理工具和依赖管理器。当您在项目中安装或更新依赖库时，默认会检查版本信息，确保安装的是与您的项目兼容的版本。 `npm 忽略版本效验` 主要是通过在 `package.json` 文件中的 `"save"` 或 `"save-dev"` 属性进行控制。`save` 关键字用于管理常规生产环境所需的依赖，而 `save-dev` 则用于非必需的开发依赖。默认情况下，如果在安装命令前不添加特定版本号，那么 `npm install` 会自动尝试安装最新稳定版本的依赖项。然而，在某些情况下，您可能需要忽略这种行为并安装指定版本的依赖。 为了实现这一功能，您可以按照以下步骤操作： ### 使用 `^` 符号 对于生产依赖，如果您想允许 `npm` 安装更高或同等版本的依赖，可以使用 `^` 符号，例如： ```json "dependencies": { "lodash": "^4.17.20" } ``` 这表示您允许安装从 `4.17.20` 开始的所有版本的 lodash，并且不会强制安装确切版本。 ### 使用固定版本号 如果你想精确指定一个版本，可以使用具体的版本号，例如： ```json "dependencies": { "lodash": "4.17.20" } ``` 这样就确保了安装 lodash 的版本始终为 `4.17.20`，不受后续更新的影响。 ### 使用星号 `*` 如果你想让 `npm` 自动安装最新可用版本的依赖，可以在 `package.json` 中删除版本号： ```json "dependencies": { "lodash": "*" } ``` 请注意，使用 `*` 可能会导致依赖库频繁更新，影响应用的稳定性，因此仅适用于测试环境或者明确了解其风险的情况。 ### 环境变量 `npmignore` 除了直接修改 `package.json`，还可以使用环境变量如 `NODE_VERSION`, `NODE_ENV`, 和其他自定义变量来自定义安装过程。虽然这不是直接忽略版本验证的方式，但它提供了一种更动态的方式来适应不同场景的需求。 ### 综上所述 `npm` 本身并不直接提供“完全忽略版本”选项，而是通过上述方法让你有更大的灵活性去选择或限制依赖库的版本。根据项目的实际需求，合理地配置依赖版本可以帮助保持软件的稳定性和兼容性。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值