java弱口令检测机制解析
目录
- java弱口令检测机制
- 1. 设计要求
- 2. 二级系统配置要求
- 3. 三级系统配置要求
- 4. java编码
- 5. 配置文件
java弱口令检测机制
1. 设计要求
- 应具备检测口令的长度和是否在指定字符集合内的能力。
- 应具备检测口令字符逻辑相邻的能力，如aBc，abC等。
- 应具备检测口令字符键盘物理位置相邻的能力，包括横向和左右斜线方向的相邻，如qwer 1qaz 0okm等。
- 应具备检测口令是否出现在弱口令库中的能力。
- 应具备检测口令中是否包含用户名（不区分大小写）。
- 应具备相邻单字符多次重复检测。
2. 二级系统配置要求
- 口令应为字母（区分大小写）+数字的组合，长度不小于8位，数字个数必须大于等于1，小写或大写字母个数大于等于1。
- 口令字符在键盘物理位置上横向不允许有连续4个及以上的相邻，物理横向字符集包含“qwertyuiop asdfghjkl zxcvbnm 01234567890”。
- 口令中的字符在键盘物理位置上斜线方向不允许有连续4个及以上的相邻，物理斜线方向字符集包含“1qaz 2wsx 3edc 4rfv 5tgb 6yhn 7ujm 8ik, 9ol. 0p;/ =[;. -pl, 0okm 9ijn 8uhb 7ygv 6tfc 5rdx 4esz”。
- 口令中的字符在逻辑位置上不允许有连续4个及以上相邻，例如abcd，1234等，必须是严格意义上的逻辑相邻abcD、aBcd、Abcd也属于逻辑相邻；逻辑字符集为“abcdefghijklmnopqrstuvwxyz 0123456789”。
- 相邻单字符重复次数不得超过4次。
3. 三级系统配置要求
- 口令应为英文字母（区分大小写）+数字+特殊字符三者的组合，长度不小于8位；数字个数必须大于等于1，小写或大写字母个数大于等于1，特殊字符个数大于等于1。
- 口令中的字符在键盘物理位置上横向不允许有连续3个及以上相邻，物理横向字符集包含“qwertyuiop asdfghjkl zxcvbnm 01234567890”。
- 口令中字符在键盘物理位置上斜线方向不允许有连续3个及以上相邻，物理斜线方向字符集包含“1qaz 2wsx 3edc 4rfv 5tgb 6yhn 7ujm 8ik, 9ol. 0p;/ =[;.、-pl,、0okm、9ijn、8uhb、7ygv 6tfc、5rdx 4esz”。
- 口令中字符在逻辑位置上不允许有连续3个及以上相邻的，例如abc，123等，必须是严格意义上的逻辑相邻abC、aBc、Abc也属于逻辑相邻；逻辑字符集为“abcdefghijklmnopqrstuvwxyz 0123456789”。
- 口令中的特殊字符集为“!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~” 不包含两边引号共32位字符。
- 相邻单字符重复次数不得超过3次。
4. java编码
package com.security.weakpassword;
import java.lang.String;
public class CheckPWD {
/**
* @brief 检测密码中字符长度
* @param[in] password 密码字符串
* @return 符合长度要求 返回true
*/
public static boolean checkPasswordLength(String password) {
boolean flag =false;
if("".equals(config.MAX_LENGTH)) {
if (password.length() >= Integer.parseInt(config.MIN_LENGTH)) {
flag = true;
}
}else{
if (password.length() >= Integer.parseInt(config.MIN_LENGTH) &&
password.length() <= Integer.parseInt(config.MAX_LENGTH)) {
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 (config.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) {
String t_password = new String(password);
//将所有输入字符转为小写
t_password = t_password.toLowerCase();
int n = t_password.length();
/**
* 键盘横向规则检测
*/
boolean flag = false;
int arrLen = config.KEYBOARD_HORIZONTAL_ARR.length;
int limit_num = Integer.parseInt(config.LIMIT_HORIZONTAL_NUM_KEY) ;
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 = config.KEYBOARD_HORIZONTAL_ARR[j];
String revOrderStr = new StringBuffer(config.KEYBOARD_HORIZONTAL_ARR[j]).reverse().toString();
//检测包含字母(区分大小写)
if ("enable".equals(config.CHECK_DISTINGGUISH_CASE)) {
//考虑 大写键盘匹配的情况
String UpperStr = config.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;
}
/**
* @brief 键盘规则匹配器 斜向规则检测
* @param[in] password 密码字符串
* @return 含有斜向连续字符串 返回true
*/
public static boolean checkKeyboardSlantSite(String password) {
String t_password = new String(password);
t_password = t_password.toLowerCase();
int n = t_password.length();
/**
* 键盘斜线方向规则检测
*/
boolean flag = false;
int arrLen = config.KEYBOARD_SLOPE_ARR.length;
int limit_num = Integer.parseInt(config.LIMIT_SLOPE_NUM_KEY);
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 = config.KEYBOARD_SLOPE_ARR[j];
String revOrderStr = new StringBuffer(config.KEYBOARD_SLOPE_ARR[j]).reverse().toString();
//检测包含字母(区分大小写)
if ("enable".equals(config.CHECK_DISTINGGUISH_CASE)) {
//考虑 大写键盘匹配的情况
String UpperStr = config.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;
}
/**
* @brief 评估a-z,z-a这样的连续字符
* @param[in] password 密码字符串
* @return 含有a-z,z-a连续字符串 返回true
*/
public static boolean checkSequentialChars(String password) {
String t_password = new String(password);
boolean flag = false;
int limit_num = Integer.parseInt(config.LIMIT_LOGIC_NUM_CHAR);
int normal_count = 0;
int reversed_count = 0;
//检测包含字母(区分大小写)
if ("enable".equals(config.CHECK_DISTINGGUISH_CASE)) {
}else{
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;
}
/**
* @brief 评估aaaa,1111这样的相同连续字符
* @param[in] password 密码字符串
* @return 含有aaaa,1111等连续字符串 返回true
*/
public static boolean checkSequentialSameChars(String password) {
String t_password = new String(password);
int n = t_password.length();
char[] pwdCharArr = t_password.toCharArray();
boolean flag = false;
int limit_num = Integer.parseInt(config.LIMIT_NUM_SAME_CHAR);
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;
}
/**
* @brief 评估密码中包含的字符类型是否符合要求
* @param[in] password 密码字符串
* @return 符合要求 返回true
*/
public static boolean EvalPWD(String password) {
if (password == null || "".equals(password)) {
return false;
}
boolean flag = false;
/**
* 检测长度
*/
if ("enable".equals(config.CHECK_PASSWORD_LENGTH)){
flag = checkPasswordLength(password);
if (!flag) {
return false;
}
}
/**
* 检测包含数字
*/
if ("enable".equals(config.CHECK_CONTAIN_DIGIT)){
flag = checkContainDigit(password);
if (!flag) {
return false;
}
}
/**
* 检测包含字母(区分大小写)
*/
if ("enable".equals(config.CHECK_DISTINGGUISH_CASE)){
//检测包含小写字母
if ("enable".equals(config.CHECK_LOWER_CASE)){
flag = checkContainLowerCase(password);
if (!flag) {
return false;
}
}
//检测包含大写字母
if ("enable".equals(config.CHECK_UPPER_CASE)){
flag = checkContainUpperCase(password);
if (!flag) {
return false;
}
}
}else {
flag = checkContainCase(password);
if (!flag) {
return false;
}
}
/**
* 检测包含特殊符号
*/
if ("enable".equals(config.CHECK_CONTAIN_SPECIAL_CHAR)){
flag = checkContainSpecialChar(password);
if (!flag) {
return false;
}
}
/**
* 检测键盘横向连续
*/
if ("enable".equals(config.CHECK_HORIZONTAL_KEY_SEQUENTIAL)){
flag = checkLateralKeyboardSite(password);
if (flag) {
return false;
}
}
/**
* 检测键盘斜向连续
*/
if ("enable".equals(config.CHECK_SLOPE_KEY_SEQUENTIAL)){
flag = checkKeyboardSlantSite(password);
if (flag) {
return false;
}
}
/**
* 检测逻辑位置连续
*/
if ("enable".equals(config.CHECK_LOGIC_SEQUENTIAL)){
flag = checkSequentialChars(password);
if (flag) {
return false;
}
}
/**
* 检测相邻字符是否相同
*/
if ("enable".equals(config.CHECK_SEQUENTIAL_CHAR_SAME)){
flag = checkSequentialSameChars(password);
if (flag) {
return false;
}
}
return true;
}
}
package com.security.weakpassword;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.Iterator;
import java.util.Properties;
public class config {
/**
* 密码口令检测对应系统等级
*/
public static String SYSTEM_GRADE;
/**
* 是否检测密码口令长度标识
*/
public static String CHECK_PASSWORD_LENGTH;
/**
* 密码最小长度，默认为8
*/
public static String MIN_LENGTH;
/**
* 密码最大长度，默认为20
*/
public static String MAX_LENGTH;
/**
* 是否包含数字
*/
public static String CHECK_CONTAIN_DIGIT;
/**
* 是否区分大小写
*/
public static String CHECK_DISTINGGUISH_CASE;
/**
* 是否包含小写字母
*/
public static String CHECK_LOWER_CASE;
/**
* 是否包含大写字母
*/
public static String CHECK_UPPER_CASE;
/**
* 是否包含特殊符号
*/
public static String CHECK_CONTAIN_SPECIAL_CHAR;
/**
* 特殊符号集合
*/
public static String DEFAULT_SPECIAL_CHAR="!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";
public static String SPECIAL_CHAR;
/**
* 是否检测键盘按键横向连续
*/
public static String CHECK_HORIZONTAL_KEY_SEQUENTIAL;
/**
* 键盘物理位置横向不允许最小的连续个数
*/
public static String LIMIT_HORIZONTAL_NUM_KEY;
/**
* 是否检测键盘按键斜向连续
*/
public static String CHECK_SLOPE_KEY_SEQUENTIAL;
/**
* 键盘物理位置斜向不允许最小的连续个数
*/
public static String LIMIT_SLOPE_NUM_KEY;
/**
* 是否检测逻辑位置连续
*/
public static String CHECK_LOGIC_SEQUENTIAL;
/**
* 密码口令中字符在逻辑位置上不允许最小的连续个数
*/
public static String LIMIT_LOGIC_NUM_CHAR;
/**
* 是否检测连续字符相同
*/
public static String CHECK_SEQUENTIAL_CHAR_SAME;
/**
* 密码口令中相同字符不允许最小的连续个数
*/
public static String LIMIT_NUM_SAME_CHAR;
/**
* 键盘横向方向规则
*/
public static String[] KEYBOARD_HORIZONTAL_ARR = {
"01234567890",
"qwertyuiop",
"asdfghjkl",
"zxcvbnm",
};
/**
* 键盘斜线方向规则
*/
public static String[] KEYBOARD_SLOPE_ARR = {
"1qaz",
"2wsx",
"3edc",
"4rfv",
"5tgb",
"6yhn",
"7ujm",
"8ik,",
"9ol.",
"0p;/",
"=[;.",
"-pl,",
"0okm",
"9ijn",
"8uhb",
"7ygv",
"6tfc",
"5rdx",
"4esz"
};
static {
Properties prop = new Properties();
try{
//读取属性文件enc.properties
InputStream in = new BufferedInputStream(new FileInputStream("password.properties"));
prop.load(in);
Iterator<String> it=prop.stringPropertyNames().iterator();
while(it.hasNext()) {
String key = it.next();
if (key.equals("systemGrade")) {
SYSTEM_GRADE = prop.getProperty(key);
}
if (key.equals("checkPasswordLength")) {
CHECK_PASSWORD_LENGTH = prop.getProperty(key);
}
if (key.equals("limitPassMinLength")) {
MIN_LENGTH = prop.getProperty(key);
}
if (key.equals("limitPassMaxLength")) {
MAX_LENGTH = prop.getProperty(key);
}
if (key.equals("checkContainDigit")) {
CHECK_CONTAIN_DIGIT = prop.getProperty(key);
}
if (key.equals("checkContainUpperLowerCase")) {
CHECK_DISTINGGUISH_CASE = prop.getProperty(key);
}
if (key.equals("checkContainLowerCase")) {
CHECK_LOWER_CASE = prop.getProperty(key);
}
if (key.equals("checkContainUpperCase")) {
CHECK_UPPER_CASE = prop.getProperty(key);
}
if (key.equals("checkContainSpecialChar")) {
CHECK_CONTAIN_SPECIAL_CHAR = prop.getProperty(key);
}
if (key.equals("specialCharSet")) {
SPECIAL_CHAR = prop.getProperty(key);
}
if (key.equals("checkHorizontalKeySequential")) {
CHECK_HORIZONTAL_KEY_SEQUENTIAL = prop.getProperty(key);
}
if (key.equals("horizontalKeyLimitNum")) {
LIMIT_HORIZONTAL_NUM_KEY = prop.getProperty(key);
}
if (key.equals("checkSlopeKeySequential")) {
CHECK_SLOPE_KEY_SEQUENTIAL = prop.getProperty(key);
}
if (key.equals("slopeKeyLimitNum")) {
LIMIT_SLOPE_NUM_KEY = prop.getProperty(key);
}
if (key.equals("checkLogicSequential")) {
CHECK_LOGIC_SEQUENTIAL = prop.getProperty(key);
}
if (key.equals("logicLimitNum")) {
LIMIT_LOGIC_NUM_CHAR = prop.getProperty(key);
}
if (key.equals("checkSequentialCharSame")) {
CHECK_SEQUENTIAL_CHAR_SAME = prop.getProperty(key);
}
if (key.equals("sequentialCharNum")) {
LIMIT_NUM_SAME_CHAR = prop.getProperty(key);
}
}
in.close();
if("2".equals(SYSTEM_GRADE) || "3".equals(SYSTEM_GRADE) ) {
if("".equals(CHECK_PASSWORD_LENGTH)){
CHECK_PASSWORD_LENGTH = "enable";
MIN_LENGTH = "8";
MAX_LENGTH = "20";
}
if("".equals(CHECK_CONTAIN_DIGIT)) {
CHECK_CONTAIN_DIGIT = "enable";
}
if("".equals(CHECK_DISTINGGUISH_CASE)) {
CHECK_DISTINGGUISH_CASE = "disable";
}
if("".equals(CHECK_LOWER_CASE)) {
CHECK_LOWER_CASE = "enable";
}
if("".equals(CHECK_UPPER_CASE)) {
CHECK_UPPER_CASE = "enable";
}
if("".equals(CHECK_CONTAIN_SPECIAL_CHAR)) {
if("2".equals(SYSTEM_GRADE)) {
CHECK_CONTAIN_SPECIAL_CHAR = "disable";
}else{
CHECK_CONTAIN_SPECIAL_CHAR = "enable";
if("".equals(SPECIAL_CHAR)) {
SPECIAL_CHAR = DEFAULT_SPECIAL_CHAR;
}
}
}
if("".equals(CHECK_HORIZONTAL_KEY_SEQUENTIAL)) {
CHECK_HORIZONTAL_KEY_SEQUENTIAL = "enable";
if("2".equals(SYSTEM_GRADE)) {
LIMIT_HORIZONTAL_NUM_KEY = "4";
}else{
LIMIT_HORIZONTAL_NUM_KEY = "3";
}
}
if("".equals(CHECK_SLOPE_KEY_SEQUENTIAL)) {
CHECK_SLOPE_KEY_SEQUENTIAL = "enable";
if("2".equals(SYSTEM_GRADE)) {
LIMIT_SLOPE_NUM_KEY = "4";
}else{
LIMIT_SLOPE_NUM_KEY = "3";
}
}
if("".equals(CHECK_LOGIC_SEQUENTIAL)) {
CHECK_LOGIC_SEQUENTIAL = "enable";
if("2".equals(SYSTEM_GRADE)) {
LIMIT_LOGIC_NUM_CHAR = "4";
}else{
LIMIT_LOGIC_NUM_CHAR = "3";
}
}
if("".equals(CHECK_SEQUENTIAL_CHAR_SAME)) {
CHECK_SEQUENTIAL_CHAR_SAME = "enable";
if("2".equals(SYSTEM_GRADE)) {
LIMIT_NUM_SAME_CHAR = "4";
}else{
LIMIT_NUM_SAME_CHAR = "3";
}
}
}else{
SYSTEM_GRADE = "3";
CHECK_PASSWORD_LENGTH = "enable";
MIN_LENGTH = "8";
MAX_LENGTH = "20";
CHECK_CONTAIN_DIGIT = "enable";
CHECK_LOWER_CASE = "enable";
CHECK_UPPER_CASE = "enable";
CHECK_CONTAIN_SPECIAL_CHAR = "enable";
CHECK_HORIZONTAL_KEY_SEQUENTIAL = "enable";
LIMIT_HORIZONTAL_NUM_KEY = "3";
CHECK_SLOPE_KEY_SEQUENTIAL = "enable";
LIMIT_SLOPE_NUM_KEY = "3";
CHECK_LOGIC_SEQUENTIAL = "enable";
LIMIT_LOGIC_NUM_CHAR = "3";
CHECK_SEQUENTIAL_CHAR_SAME = "enable";
LIMIT_NUM_SAME_CHAR = "3";
}
}
catch(Exception e){
System.out.println(e);
}
}
}
import com.security.weakpassword.CheckPWD;
/**
* Created by xianbin
*/
public class TestDemo {
public static void main(String[] args) {
System.out.println("this is a test code");
boolean flag = false;
String[] testPass = {
null,
"",
"123456",
"12345678",
"abcdefgh",
"123abc456",
"1231adf@",
"12341adf@",
"fdahuier243335ddfa#$*&",
"aBcd1859d4!@",
"zaq13edfgt#",
"Bgt5sj4#"
};
for (int i = 0; i < testPass.length; i++) {
System.out.printf("testpass[%d] = %s\n", i,testPass[i]);
flag = CheckPWD.EvalPWD(testPass[i]);
if (flag) {
System.out.println("secret pass.\n");
} else {
System.out.println("secret failed.\n");
}
}
}
}
5. 配置文件
#保护系统级别 系统级别分为二级系统和三级系统
#当systemGrade不为2或者3时，系统默认使用系统级别2的规则
#当systemGrade设置为2或者3时，其他选项若未配置，则按照默认值处理，具体默认值信息见每一项说明
systemGrade=2
#检测密码口令长度
#当checkPasswordLength为disable时，下面两项设置无效
#其他检测功能设置为disable时，对应设置项设置数据无效
#当系统级别为2或3时，checkPasswordLength默认为enable
#当系统级别为2或3时，limitPassMinLength默认为8，limitPassMaxLength默认为20
#是否检测密码口令长度，如为enable则检测，如为disable则不检测，如为空，
checkPasswordLength=enable
#允许密码口令最小长度
limitPassMinLength=8
#允许密码口令最大长度，如为空，则不设置上限
limitPassMaxLength=20
#是否包含数字、小写字母、大写字母、特殊符号
#当设置checkContainUpperLowerCase为enable时，区分大小写
#当系统级别为2时：checkContainDigit默认为enable，checkContainUpperLowerCase默认为disable
#当系统级别为2时，checkContainLowerCase默认为disable，checkContainUpperCase默认为disable
#当系统级别为2时，checkContainSpecialChar默认为disable
#当系统级别为3时：checkContainDigit默认为enable，checkContainUpperLowerCase默认为disable
#当系统级别为3时，checkContainLowerCase默认为disable，checkContainUpperCase默认为disable
#当系统级别为3时，checkContainSpecialChar默认为enable
#是否检测包含数字
checkContainDigit=enable
#是否检测包含大小写字母，区分密码口令大小写
checkContainUpperLowerCase = disable
#是否检测包含小写字母
checkContainLowerCase = enable
#是否检测包含大写字母
checkContainUpperCase = enable
#是否检测包含特殊符号
checkContainSpecialChar=disable
#支持自定义特殊符号集合
specialCharSet="!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
#检测键盘按键连续 比如qwer、1qaz、0okm等
#允许横向最大连续num为7，最小为3
#允许斜向最大连续num为4，最小为3
#当系统级别为2时：checkHorizontalKeySequential默认为enable，horizontalKeyLimitNum默认为4
#当系统级别为2时，checkSlopeKeySequential默认为enable，slopeKeyLimitNum默认为4
#当系统级别为3时：checkHorizontalKeySequential默认为enable，horizontalKeyLimitNum默认为3
#当系统级别为3时，checkSlopeKeySequential默认为enable，slopeKeyLimitNum默认为3
#是否检测键盘横向连续
checkHorizontalKeySequential=enable
#允许键盘横向连续最小数值，如为空，则设置为默认值
horizontalKeyLimitNum=4
#是否检测键盘斜向连续
checkSlopeKeySequential=enable
#允许键盘斜向连续最小数值，如为空，则设置为默认值
slopeKeyLimitNum=4
#检测逻辑位置连续 比如1234、abcd等
#当系统级别为2时，checkLogicSequential默认为enable，logicLimitNum默认为4
#当系统级别为3时，checkLogicSequential默认为enable，logicLimitNum默认为3
#是否检测逻辑位置连续
checkLogicSequential=enable
#允许逻辑位置连续最小数值，如为空，则设置为默认值
logicLimitNum=4
#检测相邻字符相同 比如aaaa、2222、@@@@等
#当系统级别为2时，checkSequentialCharSame默认为enable，sequentialCharNum默认为4
#当系统级别为3时，checkSequentialCharSame默认为enable，sequentialCharNum默认为3
#是否检测相邻字符相同
checkSequentialCharSame=enable
#允许相邻位置相同最小连续数，如为空，则设置为默认值
sequentialCharNum=4
以上为个人经验，希望能给大家一个参考，也希望大家多多支持我们。
赞 (0)
相关推荐
-
java动态口令登录实现过程详解
1.实现一个ItsClient 客户端用来实例化调用验证功能 public class ItsClient { private static final String routing = "/v1.0/sectoken/otp_validation"; // ! HTTPS消息验证地址 private String httpsVerifyUrl = ""; // ! otp ipAddr private String ipAddr = ""; /
-
java实现的密码强度检测功能完整示例
本文实例讲述了java实现的密码强度检测功能.分享给大家供大家参考,具体如下: CheckStrength.java文件: package com.wx.pwd; /** * 检测密码强度 * * @author venshine */ public class CheckStrength { public enum LEVEL { EASY, MIDIUM, STRONG, VERY_STRONG, EXTREMELY_STRONG } /** * NUM 数字 * SMALL_LETTER
-
java检测redis是否可用的方法示例
1.最近,做项目,需要检测下redis 是否可以用. 直接上代码: package com.shopping.test; import redis.clients.jedis.Jedis; /** * 测试redis缓存 */ public class RedisTest { /** * 检查redis是否存活 * @param url 服务器地址 * @param port 端口 * @return */ public static Integer getRedisIsOk(String ur
-
java弱口令检测机制解析
目录 java弱口令检测机制 1. 设计要求 2. 二级系统配置要求 3. 三级系统配置要求 4. java编码 5. 配置文件 java弱口令检测机制 1. 设计要求 应具备检测口令的长度和是否在指定字符集合内的能力. 应具备检测口令字符逻辑相邻的能力,如aBc,abC等. 应具备检测口令字符键盘物理位置相邻的能力,包括横向和左右斜线方向的相邻,如qwer 1qaz 0okm等. 应具备检测口令是否出现在弱口令库中的能力. 应具备检测口令中是否包含用户名(不区分大小写). 应具备相邻单字符多次
-
Java CGLib动态代理机制(全面解析)
一.首先说一下JDK中的动态代理: JDK中的动态代理是通过反射类Proxy以及InvocationHandler回调接口实现的 但是,JDK中所要进行动态代理的类必须要实现一个接口,也就是说只能对该类所实现接口中定义的方法进行代理,这在实际编程中具有一定的局限性,而且使用反射的效率也并不是很高. 二.使用CGLib实现: 使用CGLib实现动态代理,完全不受代理类必须实现接口的限制,而且CGLib底层采用ASM字节码生成框架,使用字节码技术生成代理类,比使用Java反射效率要高.唯一需要注意的
-
java实现上传文件类型检测过程解析
这篇文章主要介绍了java实现上传文件类型检测过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 在进行文件上传时,特别是向普通用户开放文件上传功能时,需要对上传文件的格式进行控制,以防止黑客将病毒脚本上传.单纯的将文件名的类型进行截取的方式非常容易遭到破解,上传者只需要将病毒改换文件名便可以完成上传. 可以读取文件的十六进制的文件头,来判断文件真正的格式. 读取文件的二进制数据并将其转换为十六进制时,同类型文件的文件头数据是相同的,即使改
-
Rabbitmq heartbea心跳检测机制原理解析
前言 使用rabbitmq的时候,当你客户端与rabbitmq服务器之间一段时间没有流量,服务器将会断开与客户端之间tcp连接. 而你将在服务器上看这样的日志: missed heartbeats from client, timeout: xxs 这个间隔时间就是心跳间隔. heartbeat通常用来检测通信的对端是否存活(未正常关闭socket连接而异常crash).其基本原理是检测对应的socket连接上数据的收发是否正常,如果一段时间内没有收发数据,则向对端发送一个心跳检测包,如果一段时
-
java中的类型自动转换机制解析
目录 类型自动转换机制解析 概述 数据类型只会自动提升,不能自动降低 Java中整数默认的数据类型是int类型 自动类型转换&强制类型转换 什么时候会发生类型转换 类型转换分类 自动类型转换(隐式类型转换) 强制类型转换(显式类型转换) 类型自动转换机制解析 概述 自动类型转换也叫隐式类型转换 表达式的数据类型自动提升 所有的byte型.short型和char的值将被提升到int型. 如果一个操作数是long型,计算结果就是long型: 如果一个操作数是float型,计算结果就是float型:
-
windows下FTP匿名登录或弱口令漏洞及服务加固
漏洞描述 FTP 弱口令或匿名登录漏洞,一般指使用 FTP 的用户启用了匿名登录功能,或系统口令的长度太短.复杂度不够.仅包含数字.或仅包含字母等,容易被黑客攻击,发生恶意文件上传或更严重的入侵行为. 漏洞危害 黑客利用弱口令或匿名登录漏洞直接登录 FTP 服务,上传恶意文件,从而获取系统权限,并可能造成数据泄露. 加固方案 不同 FTP 服务软件可能有不同的防护程序,本修复方案以 Windows server 2008 中自带的 FTP 服务和 Linux 中的vsftpd服务为例,您可参考以
-
Java类加载器ClassLoader用法解析
这篇文章主要介绍了Java类加载器ClassLoader用法解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 正文 当程序主动使用某个类时,如果该类还未被加载到内存中,则JVM会通过加载.连接.初始化3个步骤来对该类进行初始化.如果没有意外,JVM将会连续完成3个步骤,所以有时也把这个3个步骤统称为类加载或类初始化. 一.类加载过程 1.加载 加载指的是将类的class文件读入到内存,并为之创建一个java.lang.Class对象,也就是说
-
Java基础之面向对象机制（多态、继承）底层实现
一.Java的前世 为什么会产生Java?Java的特点是什么? 从C语言开始讲,C语言是一种结构化语言,模块化编程,便于程序的调试,依靠非常全面的运算符和多样的数据类型,可以轻易完成各种数据结构的构建,通过指针类型更可对内存直接寻址以及对硬件进行直接操作,因此既能够用于开发系统程序,也可用于开发应用软件.其缺点就是封装性弱,程序的安全性上不是很好.C语言的异常处理一般使用setjmp()与longjmp(),在捕获到异常时进行跳转:或者使用abort()和exit()两个函数,强行终止程序的运
-
Java异常的处理机制
图片解析: 1.生成字节码文件的过程可能产生编译时异常(checked),由字节码文件到在内存中加载.运行类此过程可能产生运行时异常(unchecked), 2.JAVA程序在执行过程中所发生的异常事件可分为两类: > Error: Java虚拟机无法解决的的严重问题.如:JVM系统内部错误.资源耗尽等严重情况.比如:StackOverflowError和OOM.一般不编写针对性的代码进行处理. > Exception: 其他因编程错误或偶然的外在因素导致的一般性问题,可以使用针对性的代码进行
-
Java Mybatis框架由浅入深全解析上篇
目录 学习路线 什么是三层架构 常用的SSM框架(了解) 什么是框架 什么是Mybatis框架 添加框架的步骤 1.新建库建表 2.新建maven项目 3.修改目录 4.修改pom.xml文件 5.修改pom.xml文件 总结 学习路线 什么是三层架构 在项目开发中,遵循一种形式模式,分为三层. 界面层: 用来接收客 户端的输入,调用业务逻辑层进行功能处理,返回结果给客户端.过去的servlet就是界面层的功能. **业务逻辑层:**用来进行整个项目的业务逻辑处理,向上为界面层提供处理结果,向下