欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

java弱口令檢測(cè)機(jī)制解析

 更新時(shí)間:2021年09月17日 09:27:04   作者:天天water  
這篇文章主要介紹了java弱口令檢測(cè)機(jī)制,具有很好的參考價(jià)值,希望對(duì)大家有所幫助。如有錯(cuò)誤或未考慮完全的地方,望不吝賜教

java弱口令檢測(cè)機(jī)制

1. 設(shè)計(jì)要求

  • 應(yīng)具備檢測(cè)口令的長(zhǎng)度和是否在指定字符集合內(nèi)的能力。
  • 應(yīng)具備檢測(cè)口令字符邏輯相鄰的能力,如aBc,abC等。
  • 應(yīng)具備檢測(cè)口令字符鍵盤(pán)物理位置相鄰的能力,包括橫向和左右斜線方向的相鄰,如qwer 1qaz 0okm等。
  • 應(yīng)具備檢測(cè)口令是否出現(xiàn)在弱口令庫(kù)中的能力。
  • 應(yīng)具備檢測(cè)口令中是否包含用戶名(不區(qū)分大小寫(xiě))。
  • 應(yīng)具備相鄰單字符多次重復(fù)檢測(cè)。

2. 二級(jí)系統(tǒng)配置要求

  • 口令應(yīng)為字母(區(qū)分大小寫(xiě))+數(shù)字的組合,長(zhǎng)度不小于8位,數(shù)字個(gè)數(shù)必須大于等于1,小寫(xiě)或大寫(xiě)字母?jìng)€(gè)數(shù)大于等于1。
  • 口令字符在鍵盤(pán)物理位置上橫向不允許有連續(xù)4個(gè)及以上的相鄰,物理橫向字符集包含“qwertyuiop asdfghjkl zxcvbnm 01234567890”。
  • 口令中的字符在鍵盤(pán)物理位置上斜線方向不允許有連續(xù)4個(gè)及以上的相鄰,物理斜線方向字符集包含“1qaz 2wsx 3edc 4rfv 5tgb 6yhn 7ujm 8ik, 9ol. 0p;/ =[;. -pl, 0okm 9ijn 8uhb 7ygv 6tfc 5rdx 4esz”。
  • 口令中的字符在邏輯位置上不允許有連續(xù)4個(gè)及以上相鄰,例如abcd,1234等,必須是嚴(yán)格意義上的邏輯相鄰abcD、aBcd、Abcd也屬于邏輯相鄰;邏輯字符集為“abcdefghijklmnopqrstuvwxyz 0123456789”。
  • 相鄰單字符重復(fù)次數(shù)不得超過(guò)4次。

3. 三級(jí)系統(tǒng)配置要求

  • 口令應(yīng)為英文字母(區(qū)分大小寫(xiě))+數(shù)字+特殊字符三者的組合,長(zhǎng)度不小于8位;數(shù)字個(gè)數(shù)必須大于等于1,小寫(xiě)或大寫(xiě)字母?jìng)€(gè)數(shù)大于等于1,特殊字符個(gè)數(shù)大于等于1。
  • 口令中的字符在鍵盤(pán)物理位置上橫向不允許有連續(xù)3個(gè)及以上相鄰,物理橫向字符集包含“qwertyuiop asdfghjkl zxcvbnm 01234567890”。
  • 口令中字符在鍵盤(pán)物理位置上斜線方向不允許有連續(xù)3個(gè)及以上相鄰,物理斜線方向字符集包含“1qaz 2wsx 3edc 4rfv 5tgb 6yhn 7ujm 8ik, 9ol. 0p;/ =[;.、-pl,、0okm、9ijn、8uhb、7ygv 6tfc、5rdx 4esz”。
  • 口令中字符在邏輯位置上不允許有連續(xù)3個(gè)及以上相鄰的,例如abc,123等,必須是嚴(yán)格意義上的邏輯相鄰abC、aBc、Abc也屬于邏輯相鄰;邏輯字符集為“abcdefghijklmnopqrstuvwxyz 0123456789”。
  • 口令中的特殊字符集為“!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~” 不包含兩邊引號(hào)共32位字符。
  • 相鄰單字符重復(fù)次數(shù)不得超過(guò)3次。

4. java編碼

package com.security.weakpassword; 
import java.lang.String; 
public class CheckPWD {
    /**
     * @brief   檢測(cè)密碼中字符長(zhǎng)度
     * @param[in] password            密碼字符串
     * @return  符合長(zhǎng)度要求 返回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   檢測(cè)密碼中是否包含數(shù)字
     * @param[in] password            密碼字符串
     * @return  包含數(shù)字 返回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   檢測(cè)密碼中是否包含字母(不區(qū)分大小寫(xiě))
     * @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   檢測(cè)密碼中是否包含小寫(xiě)字母
     * @param[in] password            密碼字符串
     * @return  包含小寫(xiě)字母 返回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   檢測(cè)密碼中是否包含大寫(xiě)字母
     * @param[in] password            密碼字符串
     * @return  包含大寫(xiě)字母 返回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   檢測(cè)密碼中是否包含特殊符號(hào)
     * @param[in] password            密碼字符串
     * @return  包含特殊符號(hào) 返回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   鍵盤(pán)規(guī)則匹配器 橫向連續(xù)檢測(cè)
     * @param[in] password            密碼字符串
     * @return  含有橫向連續(xù)字符串 返回true
     */
    public static boolean checkLateralKeyboardSite(String password) {
        String t_password = new String(password);
        //將所有輸入字符轉(zhuǎn)為小寫(xiě)
        t_password = t_password.toLowerCase();
        int n = t_password.length();
        /**
         * 鍵盤(pán)橫向規(guī)則檢測(cè)
         */
        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();
 
                //檢測(cè)包含字母(區(qū)分大小寫(xiě))
                if ("enable".equals(config.CHECK_DISTINGGUISH_CASE)) {
                    //考慮 大寫(xiě)鍵盤(pán)匹配的情況
                    String UpperStr = config.KEYBOARD_HORIZONTAL_ARR[j].toUpperCase();
                    if((configStr.indexOf(distinguishStr) != -1) || (UpperStr.indexOf(distinguishStr) != -1)) {
                        flag = true;
                        return flag;
                    }
                    //考慮逆序輸入情況下 連續(xù)輸入
                    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;
                    }
                    //考慮逆序輸入情況下 連續(xù)輸入
                    if(revOrderStr.indexOf(str) != -1) {
                        flag = true;
                        return flag;
                    }
                }
            }
        }
        return flag;
    }
 
    /**
     * @brief   鍵盤(pán)規(guī)則匹配器 斜向規(guī)則檢測(cè)
     * @param[in] password            密碼字符串
     * @return  含有斜向連續(xù)字符串 返回true
     */
    public static boolean checkKeyboardSlantSite(String password) {
        String t_password = new String(password);
        t_password = t_password.toLowerCase();
        int n = t_password.length();
        /**
         * 鍵盤(pán)斜線方向規(guī)則檢測(cè)
         */
        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();
                //檢測(cè)包含字母(區(qū)分大小寫(xiě))
                if ("enable".equals(config.CHECK_DISTINGGUISH_CASE)) {
 
                    //考慮 大寫(xiě)鍵盤(pán)匹配的情況
                    String UpperStr = config.KEYBOARD_SLOPE_ARR[j].toUpperCase();
                    if((configStr.indexOf(distinguishStr) != -1) || (UpperStr.indexOf(distinguishStr) != -1)) {
                        flag = true;
                        return flag;
                    }
                    //考慮逆序輸入情況下 連續(xù)輸入
                    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;
                    }
                    //考慮逆序輸入情況下 連續(xù)輸入
                    if(revOrderStr.indexOf(str) != -1) {
                        flag = true;
                        return flag;
                    }
                }
            }
        }
        return flag;
    }
 
    /**
     * @brief   評(píng)估a-z,z-a這樣的連續(xù)字符
     * @param[in] password            密碼字符串
     * @return  含有a-z,z-a連續(xù)字符串 返回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;
 
        //檢測(cè)包含字母(區(qū)分大小寫(xiě))
        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   評(píng)估aaaa,1111這樣的相同連續(xù)字符
     * @param[in] password            密碼字符串
     * @return  含有aaaa,1111等連續(xù)字符串 返回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   評(píng)估密碼中包含的字符類(lèi)型是否符合要求
     * @param[in] password            密碼字符串
     * @return  符合要求 返回true
     */
    public static boolean EvalPWD(String password) {
        if (password == null || "".equals(password)) {
            return false;
        }
        boolean flag = false;
 
        /**
         * 檢測(cè)長(zhǎng)度
         */
        if ("enable".equals(config.CHECK_PASSWORD_LENGTH)){
            flag = checkPasswordLength(password);
            if (!flag) {
                return false;
            }
        }
 
        /**
         * 檢測(cè)包含數(shù)字
         */
        if ("enable".equals(config.CHECK_CONTAIN_DIGIT)){
            flag = checkContainDigit(password);
            if (!flag) {
                return false;
            }
        }
 
        /**
         * 檢測(cè)包含字母(區(qū)分大小寫(xiě))
         */
        if ("enable".equals(config.CHECK_DISTINGGUISH_CASE)){
            //檢測(cè)包含小寫(xiě)字母
            if ("enable".equals(config.CHECK_LOWER_CASE)){
                flag = checkContainLowerCase(password);
                if (!flag) {
                    return false;
                }
            }
 
            //檢測(cè)包含大寫(xiě)字母
            if ("enable".equals(config.CHECK_UPPER_CASE)){
                flag = checkContainUpperCase(password);
                if (!flag) {
                    return false;
                }
            }
        }else {
            flag = checkContainCase(password);
            if (!flag) {
                return false;
            }
        }
 
        /**
         * 檢測(cè)包含特殊符號(hào)
         */
        if ("enable".equals(config.CHECK_CONTAIN_SPECIAL_CHAR)){
            flag = checkContainSpecialChar(password);
            if (!flag) {
                return false;
            }
        }
 
        /**
         * 檢測(cè)鍵盤(pán)橫向連續(xù)
         */
        if ("enable".equals(config.CHECK_HORIZONTAL_KEY_SEQUENTIAL)){
            flag = checkLateralKeyboardSite(password);
            if (flag) {
                return false;
            }
        }
 
        /**
         * 檢測(cè)鍵盤(pán)斜向連續(xù)
         */
        if ("enable".equals(config.CHECK_SLOPE_KEY_SEQUENTIAL)){
            flag = checkKeyboardSlantSite(password);
            if (flag) {
                return false;
            }
        }
 
        /**
         * 檢測(cè)邏輯位置連續(xù)
         */
        if ("enable".equals(config.CHECK_LOGIC_SEQUENTIAL)){
            flag = checkSequentialChars(password);
            if (flag) {
                return false;
            }
        }
 
        /**
         * 檢測(cè)相鄰字符是否相同
         */
        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 {
    /**
     * 密碼口令檢測(cè)對(duì)應(yīng)系統(tǒng)等級(jí)
     */
    public static String SYSTEM_GRADE;
 
    /**
     * 是否檢測(cè)密碼口令長(zhǎng)度標(biāo)識(shí)
     */
    public static String CHECK_PASSWORD_LENGTH;
    /**
     * 密碼最小長(zhǎng)度,默認(rèn)為8
     */
    public static String MIN_LENGTH;
    /**
     * 密碼最大長(zhǎng)度,默認(rèn)為20
     */
    public static String MAX_LENGTH;
 
    /**
     * 是否包含數(shù)字
     */
    public static String CHECK_CONTAIN_DIGIT;
    /**
     * 是否區(qū)分大小寫(xiě)
     */
    public static String CHECK_DISTINGGUISH_CASE;
    /**
     * 是否包含小寫(xiě)字母
     */
    public static String CHECK_LOWER_CASE;
    /**
     * 是否包含大寫(xiě)字母
     */
    public static String CHECK_UPPER_CASE;
    /**
     * 是否包含特殊符號(hào)
     */
    public static String CHECK_CONTAIN_SPECIAL_CHAR;
    /**
     * 特殊符號(hào)集合
     */
    public static String DEFAULT_SPECIAL_CHAR="!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";
    public static String SPECIAL_CHAR;
 
    /**
     * 是否檢測(cè)鍵盤(pán)按鍵橫向連續(xù)
     */
    public static String CHECK_HORIZONTAL_KEY_SEQUENTIAL;
    /**
     * 鍵盤(pán)物理位置橫向不允許最小的連續(xù)個(gè)數(shù)
     */
    public static String LIMIT_HORIZONTAL_NUM_KEY;
    /**
     * 是否檢測(cè)鍵盤(pán)按鍵斜向連續(xù)
     */
    public static String CHECK_SLOPE_KEY_SEQUENTIAL;
    /**
     * 鍵盤(pán)物理位置斜向不允許最小的連續(xù)個(gè)數(shù)
     */
    public static String LIMIT_SLOPE_NUM_KEY;
 
    /**
     * 是否檢測(cè)邏輯位置連續(xù)
     */
    public static String CHECK_LOGIC_SEQUENTIAL;
    /**
     * 密碼口令中字符在邏輯位置上不允許最小的連續(xù)個(gè)數(shù)
     */
    public static String LIMIT_LOGIC_NUM_CHAR;
 
    /**
     * 是否檢測(cè)連續(xù)字符相同
     */
    public static String CHECK_SEQUENTIAL_CHAR_SAME;
    /**
     * 密碼口令中相同字符不允許最小的連續(xù)個(gè)數(shù)
     */
    public static String LIMIT_NUM_SAME_CHAR;
 
    /**
     * 鍵盤(pán)橫向方向規(guī)則
     */
    public static String[] KEYBOARD_HORIZONTAL_ARR = {
            "01234567890",
            "qwertyuiop",
            "asdfghjkl",
            "zxcvbnm",
    };
    /**
     * 鍵盤(pán)斜線方向規(guī)則
     */
    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. 配置文件

#保護(hù)系統(tǒng)級(jí)別 系統(tǒng)級(jí)別分為二級(jí)系統(tǒng)和三級(jí)系統(tǒng)
#當(dāng)systemGrade不為2或者3時(shí),系統(tǒng)默認(rèn)使用系統(tǒng)級(jí)別2的規(guī)則
#當(dāng)systemGrade設(shè)置為2或者3時(shí),其他選項(xiàng)若未配置,則按照默認(rèn)值處理,具體默認(rèn)值信息見(jiàn)每一項(xiàng)說(shuō)明
systemGrade=2
 
#檢測(cè)密碼口令長(zhǎng)度
#當(dāng)checkPasswordLength為disable時(shí),下面兩項(xiàng)設(shè)置無(wú)效
#其他檢測(cè)功能設(shè)置為disable時(shí),對(duì)應(yīng)設(shè)置項(xiàng)設(shè)置數(shù)據(jù)無(wú)效
#當(dāng)系統(tǒng)級(jí)別為2或3時(shí),checkPasswordLength默認(rèn)為enable
#當(dāng)系統(tǒng)級(jí)別為2或3時(shí),limitPassMinLength默認(rèn)為8,limitPassMaxLength默認(rèn)為20
#是否檢測(cè)密碼口令長(zhǎng)度,如為enable則檢測(cè),如為disable則不檢測(cè),如為空,
checkPasswordLength=enable
#允許密碼口令最小長(zhǎng)度
limitPassMinLength=8
#允許密碼口令最大長(zhǎng)度,如為空,則不設(shè)置上限
limitPassMaxLength=20
 
#是否包含數(shù)字、小寫(xiě)字母、大寫(xiě)字母、特殊符號(hào)
#當(dāng)設(shè)置checkContainUpperLowerCase為enable時(shí),區(qū)分大小寫(xiě)
#當(dāng)系統(tǒng)級(jí)別為2時(shí):checkContainDigit默認(rèn)為enable,checkContainUpperLowerCase默認(rèn)為disable
#當(dāng)系統(tǒng)級(jí)別為2時(shí),checkContainLowerCase默認(rèn)為disable,checkContainUpperCase默認(rèn)為disable
#當(dāng)系統(tǒng)級(jí)別為2時(shí),checkContainSpecialChar默認(rèn)為disable
#當(dāng)系統(tǒng)級(jí)別為3時(shí):checkContainDigit默認(rèn)為enable,checkContainUpperLowerCase默認(rèn)為disable
#當(dāng)系統(tǒng)級(jí)別為3時(shí),checkContainLowerCase默認(rèn)為disable,checkContainUpperCase默認(rèn)為disable
#當(dāng)系統(tǒng)級(jí)別為3時(shí),checkContainSpecialChar默認(rèn)為enable
#是否檢測(cè)包含數(shù)字
checkContainDigit=enable
#是否檢測(cè)包含大小寫(xiě)字母,區(qū)分密碼口令大小寫(xiě)
checkContainUpperLowerCase = disable
#是否檢測(cè)包含小寫(xiě)字母
checkContainLowerCase = enable
#是否檢測(cè)包含大寫(xiě)字母
checkContainUpperCase = enable
#是否檢測(cè)包含特殊符號(hào)
checkContainSpecialChar=disable
#支持自定義特殊符號(hào)集合
specialCharSet="!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
 
#檢測(cè)鍵盤(pán)按鍵連續(xù) 比如qwer、1qaz、0okm等
#允許橫向最大連續(xù)num為7,最小為3
#允許斜向最大連續(xù)num為4,最小為3
#當(dāng)系統(tǒng)級(jí)別為2時(shí):checkHorizontalKeySequential默認(rèn)為enable,horizontalKeyLimitNum默認(rèn)為4
#當(dāng)系統(tǒng)級(jí)別為2時(shí),checkSlopeKeySequential默認(rèn)為enable,slopeKeyLimitNum默認(rèn)為4
#當(dāng)系統(tǒng)級(jí)別為3時(shí):checkHorizontalKeySequential默認(rèn)為enable,horizontalKeyLimitNum默認(rèn)為3
#當(dāng)系統(tǒng)級(jí)別為3時(shí),checkSlopeKeySequential默認(rèn)為enable,slopeKeyLimitNum默認(rèn)為3
#是否檢測(cè)鍵盤(pán)橫向連續(xù) 
checkHorizontalKeySequential=enable
#允許鍵盤(pán)橫向連續(xù)最小數(shù)值,如為空,則設(shè)置為默認(rèn)值
horizontalKeyLimitNum=4
#是否檢測(cè)鍵盤(pán)斜向連續(xù)
checkSlopeKeySequential=enable
#允許鍵盤(pán)斜向連續(xù)最小數(shù)值,如為空,則設(shè)置為默認(rèn)值
slopeKeyLimitNum=4
 
#檢測(cè)邏輯位置連續(xù) 比如1234、abcd等
#當(dāng)系統(tǒng)級(jí)別為2時(shí),checkLogicSequential默認(rèn)為enable,logicLimitNum默認(rèn)為4
#當(dāng)系統(tǒng)級(jí)別為3時(shí),checkLogicSequential默認(rèn)為enable,logicLimitNum默認(rèn)為3
#是否檢測(cè)邏輯位置連續(xù)
checkLogicSequential=enable
#允許邏輯位置連續(xù)最小數(shù)值,如為空,則設(shè)置為默認(rèn)值
logicLimitNum=4
 
#檢測(cè)相鄰字符相同 比如aaaa、2222、@@@@等
#當(dāng)系統(tǒng)級(jí)別為2時(shí),checkSequentialCharSame默認(rèn)為enable,sequentialCharNum默認(rèn)為4
#當(dāng)系統(tǒng)級(jí)別為3時(shí),checkSequentialCharSame默認(rèn)為enable,sequentialCharNum默認(rèn)為3
#是否檢測(cè)相鄰字符相同
checkSequentialCharSame=enable
#允許相鄰位置相同最小連續(xù)數(shù),如為空,則設(shè)置為默認(rèn)值
sequentialCharNum=4
 

以上為個(gè)人經(jīng)驗(yàn),希望能給大家一個(gè)參考,也希望大家多多支持腳本之家。

相關(guān)文章

  • Java面試必備之AQS阻塞隊(duì)列和條件隊(duì)列

    Java面試必備之AQS阻塞隊(duì)列和條件隊(duì)列

    我們大概知道AQS就是一個(gè)框架,把很多功能都給實(shí)現(xiàn)了(比如入隊(duì)規(guī)則,喚醒節(jié)點(diǎn)中的線程等),我們?nèi)绻褂玫脑捴恍枰獙?shí)現(xiàn)其中的一些方法(比如tryAcquire等)就行了!這次主要說(shuō)說(shuō)AQS中阻塞隊(duì)列的的入隊(duì)規(guī)則還有條件變量,需要的朋友可以參考下
    2021-06-06
  • java異步執(zhí)行代碼處理方法(先返回結(jié)果,后執(zhí)行代碼)

    java異步執(zhí)行代碼處理方法(先返回結(jié)果,后執(zhí)行代碼)

    這篇文章主要給大家介紹了關(guān)于java異步執(zhí)行代碼處理方法的相關(guān)資料,先返回結(jié)果,后執(zhí)行代碼,文中通過(guò)實(shí)例代碼介紹的非常詳細(xì),對(duì)大家的學(xué)習(xí)或者工作具有一定的參考借鑒價(jià)值,需要的朋友可以參考下
    2023-07-07
  • java返回的List進(jìn)行add操作報(bào)錯(cuò)

    java返回的List進(jìn)行add操作報(bào)錯(cuò)

    本文主要介紹了java返回的List進(jìn)行add操作報(bào)錯(cuò),文中通過(guò)示例代碼介紹的非常詳細(xì),對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值,需要的朋友們下面隨著小編來(lái)一起學(xué)習(xí)學(xué)習(xí)吧
    2023-06-06
  • Java工廠模式優(yōu)雅地創(chuàng)建對(duì)象以及提高代碼復(fù)用率和靈活性

    Java工廠模式優(yōu)雅地創(chuàng)建對(duì)象以及提高代碼復(fù)用率和靈活性

    Java工廠模式是一種創(chuàng)建型設(shè)計(jì)模式,通過(guò)定義一個(gè)工廠類(lèi)來(lái)封裝對(duì)象的創(chuàng)建過(guò)程,將對(duì)象的創(chuàng)建和使用分離,提高代碼的可維護(hù)性和可擴(kuò)展性,同時(shí)可以實(shí)現(xiàn)更好的代碼復(fù)用和靈活性
    2023-05-05
  • java開(kāi)發(fā)hutool HttpUtil網(wǎng)絡(luò)請(qǐng)求工具使用demo

    java開(kāi)發(fā)hutool HttpUtil網(wǎng)絡(luò)請(qǐng)求工具使用demo

    這篇文章主要為大家介紹了hutool之HttpUtil網(wǎng)絡(luò)請(qǐng)求工具使用示例詳解,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進(jìn)步,早日升職加薪
    2023-07-07
  • java實(shí)現(xiàn)web實(shí)時(shí)消息推送的七種方案

    java實(shí)現(xiàn)web實(shí)時(shí)消息推送的七種方案

    這篇文章主要為大家介紹了java實(shí)現(xiàn)web實(shí)時(shí)消息推送的七種方案示例詳解,有需要的朋友可以借鑒參考下,希望能夠有所幫助,祝大家多多進(jìn)步,早日升職加薪
    2022-07-07
  • Java計(jì)算兩個(gè)時(shí)間相差的秒數(shù)怎么算

    Java計(jì)算兩個(gè)時(shí)間相差的秒數(shù)怎么算

    這篇文章主要介紹了Java計(jì)算兩個(gè)時(shí)間相差的秒數(shù),通過(guò)實(shí)例代碼補(bǔ)充介紹了Java 獲取兩個(gè)時(shí)間的時(shí)間差(時(shí)、分、秒)問(wèn)題,感興趣的朋友跟隨小編一起看看吧
    2024-03-03
  • java啟動(dòng)如何設(shè)置JAR包內(nèi)存大小

    java啟動(dòng)如何設(shè)置JAR包內(nèi)存大小

    這篇文章主要介紹了java啟動(dòng)如何設(shè)置JAR包內(nèi)存大小問(wèn)題,具有很好的參考價(jià)值,希望對(duì)大家有所幫助。如有錯(cuò)誤或未考慮完全的地方,望不吝賜教
    2023-02-02
  • mybatis if test條件判斷語(yǔ)句中的判斷問(wèn)題分析

    mybatis if test條件判斷語(yǔ)句中的判斷問(wèn)題分析

    這篇文章主要介紹了mybatis if test條件判斷語(yǔ)句中的判斷問(wèn)題,具有很好的參考價(jià)值,希望對(duì)大家有所幫助。如有錯(cuò)誤或未考慮完全的地方,望不吝賜教
    2022-03-03
  • MyBatis多表連接查詢的實(shí)例教程

    MyBatis多表連接查詢的實(shí)例教程

    這篇文章主要給大家介紹了關(guān)于MyBatis多表連接查詢的相關(guān)資料,文中通過(guò)示例代碼介紹的非常詳細(xì),對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值,需要的朋友們下面隨著小編來(lái)一起學(xué)習(xí)學(xué)習(xí)吧
    2020-12-12

最新評(píng)論