java弱口令检测机制解析

2024-04-02 19:04:59 335人浏览安东尼

Python 官方文档：入门教程 => 点击学习

摘要

目录java弱口令检测机制1. 设计要求2. 二级系统配置要求3. 三级系统配置要求4. java编码5. 配置文件java弱口令检测机制 1. 设计要求应具备检测口令的

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 {
    
    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;
    }
 
    
    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;
    }
 
    
    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;
    }
 
    
    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;
    }
 
    
    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;
    }
 
    
    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;
    }
 
    
    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;
    }
 
    
    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;
    }
 
    
    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;
    }
 
    
    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;
    }
 
    
    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;
    
    public static String MIN_LENGTH;
    
    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; 

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

以上为个人经验，希望能给大家一个参考，也希望大家多多支持编程网。

您可能感兴趣的文档:

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: java弱口令检测机制解析

本文链接: https://www.lsjlt.com/news/135995.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

java弱口令检测机制解析

目录java弱口令检测机制1. 设计要求2. 二级系统配置要求3. 三级系统配置要求4. java编码5. 配置文件java弱口令检测机制 1. 设计要求应具备检测口令的...

99+

2024-04-02
阿里云服务器端口检测命令详解

本文主要介绍阿里云服务器端口检测命令的使用方法，帮助用户更好地管理和维护服务器。阿里云服务器端口检测命令是阿里云推出的一款用于检测服务器端口开放情况的工具，它可以帮助用户快速、准确地检查服务器的端口是否开放，从而确保服务器的稳定运行。使用...

99+

2023-12-11

阿里端口详解
浅析Angular变更检测中的DOM更新机制

变更检测是Angular中很重要的一部分，也就是模型和视图之间保持同步。在日常开发过程中，我们无需了解变更检测，因为Angular都帮我们完成了这一部分工作，让开发人员更加专注于业务实现，提高开发效率和开发体验。但是如果想要深入使用框架，或...

99+

2023-05-14

DOM更新机制变更检测前端 Angular.js
怎么解析基于微信官方接口开发的域名检测接口API

这期内容当中小编将会给大家带来有关怎么解析基于微信官方接口开发的域名检测接口API，文章内容丰富且以专业的角度为大家分析和叙述，阅读完这篇文章希望大家可以有所收获。域名检测接口是腾讯发布的微信域名状态查询接口，可实时查询域名在微信中的状态，...

99+

2023-06-04
Java和Dubbo的SPI机制原理解析

SPI: 简单理解就是，你一个接口有多种实现，然后在代码运行时候，具体选用那个实现，这时候我们就可以通过一些特定的方式来告诉程序寻用那个实现类，这就是SPI。 JAVA的SPI 全称...

99+

2024-04-02
解析Java的多线程机制（1）(转)

解析Java的多线程机制（1）(转)[@more@]进程与应用程序的区别　　　　进程（Process）是最初定义在Unix等多用户、多任务操作系统环境下用于表示应用程序在内存环境中基本执行单元的概念。以Unix操作系统为例，进程是Unix操...

99+

2023-06-03
Java深入分析讲解反射机制

目录反射的概述获取Class对象的三种方式通过反射机制获取类的属性通过反射机制访问Java对象的属性反射机制与属性配置文件的配合使用资源绑定器配合使用样例通过反射机制获取类中方法通过...

99+

2024-04-02
Java高级－解析Java中的多线程机制(转)

Java高级－解析Java中的多线程机制(转)[@more@]进程与应用程序的区别进程（Process）是最初定义在Unix等多用户、多任务操作系统环境下用于表示应用程序在内存环境中基本执行单元的概念。以Unix操作系统为例，进程是Unix...

99+

2023-06-03
Java CGLib动态代理机制(全面解析)

一、首先说一下JDK中的动态代理：JDK中的动态代理是通过反射类Proxy以及InvocationHandler回调接口实现的但是，JDK中所要进行动态代理的类必须要实现一个接口，也就是说只能对该类所实现接口中定义的方法进行代理，这在实际编...

99+

2023-05-31

java 动态代理 cglib
怎样解析Java的异常处理机制

这期内容当中小编将会给大家带来有关怎样解析Java的异常处理机制，文章内容丰富且以专业的角度为大家分析和叙述，阅读完这篇文章希望大家可以有所收获。你觉得自己是一个Java专家吗是否肯定自己已经全面掌握了Java的异常处理机制在下面这段代码中...

99+

2023-06-17
java中的类型自动转换机制解析

目录类型自动转换机制解析概述数据类型只会自动提升,不能自动降低Java中整数默认的数据类型是int类型自动类型转换 & 强制类型转换什么时候会发生类型转换类型转换分类自动类型...

99+

2024-04-02
Java ActiveMQ：全面解析消息持久化机制

一、消息持久化的重要性消息持久化是消息中间件的核心功能之一，它确保了消息在传输过程中不会丢失。在Java ActiveMQ中，消息持久化机制可以保证即使在消息代理或网络故障的情况下，消息也不会丢失。二、消息持久化的机制 Active...

99+

2024-02-08

Java ActiveMQ 消息持久化策略性能
Java键盘事件处理及监听机制解析

文章目录概念KeyEventKeyListener代码演示总结概念 Java事件处理采用了委派事件模型。在这个模型中，当事件发生时，产生事件的对象将事件信息传递给事件的监听者进行处理。在Java中，事件源是产生事件的对象，...

99+

2023-08-20

java 计算机外设 jvm 开发语言
Java 多线程同步锁机制与synchronized深入解析

打个比方：一个object就像一个大房子，大门永远打开。房子里有很多房间（也就是方法）。这些房间有上锁的（synchronized方法），和不上锁之分（普通方法）。房门口放着一把钥...

99+

2022-11-15

Java 多线程同步锁机制
Java事件处理机制和适配器全面解析

目录Java事件处理机制和适配器处理事件示意图java常用的监听接口Java事件适配器的作用适配器Java事件处理机制和适配器最重要的是理解事件源，监视器，处理事件的接口的概念。 ...

99+

2024-04-02
Java SpringMVC拦截器与异常处理机制详解分析

目录拦截器（interceptor）的作用拦截器快速入门案例：用户登录权限控制拦截器方法说明SpringMVC异常处理异常处理的思路异常处理两种方式拦截器（interceptor）的...

99+

2024-04-02
java框架基础之SPI机制实现及源码解析

目录1 定义2 案例实现标准接口厂商的具体接口实现3 SPI机制源码分析3.1 load加载过程3.2 实例化过程1 定义 SPI 的全名为 Service Pr...

99+

2024-04-02
【华为OD机试真题】165、核酸总最快检测效率 | 机试真题+思路参考+代码解析（C语言、C++、Java、Py、JS）

文章目录一、题目 🎃题目描述 🎃输入输出 🎃样例1 🎃样例2 🎃样例3 🎃样例4 二、代码与思路参考 ...

99+

2023-08-17

c语言 c++ 华为OD机试真题 javascript java python 核酸总最快检测效率
java重试机制使用RPC必须考虑幂等性原理解析

目录文章概述1 为什么重试2 怎么做重试2.1 集群容错策略(1) Failover(2) Failfast(3) Failsafe(4) Failback(5) Forking(6...

99+

2023-03-19

java重试机制RPC幂等性 RPC幂等性原理
Java注解机制之Spring自动装配实现原理的示例分析

小编给大家分享一下Java注解机制之Spring自动装配实现原理的示例分析，希望大家阅读完这篇文章之后都有所收获，下面让我们一起去探讨吧！ Java中使用注解的情况主要在SpringMVC（Spring Boot等），注解实际上相...

99+

2023-05-31

java spring