精华内容
下载资源
问答
  • java弱口令检测机制

    千次阅读 2018-10-17 17:51:46
    1. 设计要求 应具备检测口令的长度和是否在指定... 应具备检测口令是否出现在弱口令库中的能力。 应具备检测口令中是否包含用户名(区分大小写)。 应具备相邻单字符多次重复检测。 2. 二级系统配置要求 口令...

    1. 设计要求

    1. 应具备检测口令的长度和是否在指定字符集合内的能力。
    2. 应具备检测口令字符逻辑相邻的能力,如aBc,abC等。
    3. 应具备检测口令字符键盘物理位置相邻的能力,包括横向和左右斜线方向的相邻,如qwer 1qaz 0okm等。
    4. 应具备检测口令是否出现在弱口令库中的能力。
    5. 应具备检测口令中是否包含用户名(不区分大小写)。
    6. 应具备相邻单字符多次重复检测。

    2. 二级系统配置要求

    1. 口令应为字母(区分大小写)+数字的组合,长度不小于8位,数字个数必须大于等于1,小写或大写字母个数大于等于1。
    2. 口令字符在键盘物理位置上横向不允许有连续4个及以上的相邻,物理横向字符集包含“qwertyuiop asdfghjkl zxcvbnm 01234567890”。
    3. 口令中的字符在键盘物理位置上斜线方向不允许有连续4个及以上的相邻,物理斜线方向字符集包含“1qaz 2wsx 3edc 4rfv 5tgb 6yhn 7ujm 8ik, 9ol. 0p;/ =[;. -pl, 0okm 9ijn 8uhb 7ygv 6tfc 5rdx 4esz”。
    4. 口令中的字符在逻辑位置上不允许有连续4个及以上相邻,例如abcd,1234等,必须是严格意义上的逻辑相邻abcD、aBcd、Abcd也属于逻辑相邻;逻辑字符集为“abcdefghijklmnopqrstuvwxyz 0123456789”。
    5. 相邻单字符重复次数不得超过4次。

     3. 三级系统配置要求

    1. 口令应为英文字母(区分大小写)+数字+特殊字符三者的组合,长度不小于8位;数字个数必须大于等于1,小写或大写字母个数大于等于1,特殊字符个数大于等于1。
    2. 口令中的字符在键盘物理位置上横向不允许有连续3个及以上相邻,物理横向字符集包含“qwertyuiop asdfghjkl zxcvbnm 01234567890”。
    3. 口令中字符在键盘物理位置上斜线方向不允许有连续3个及以上相邻,物理斜线方向字符集包含“1qaz 2wsx 3edc 4rfv 5tgb 6yhn 7ujm 8ik, 9ol. 0p;/ =[;.、-pl,、0okm、9ijn、8uhb、7ygv 6tfc、5rdx 4esz”。
    4. 口令中字符在逻辑位置上不允许有连续3个及以上相邻的,例如abc,123等,必须是严格意义上的逻辑相邻abC、aBc、Abc也属于逻辑相邻;逻辑字符集为“abcdefghijklmnopqrstuvwxyz 0123456789”。
    5. 口令中的特殊字符集为“!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~” 不包含两边引号共32位字符。
    6. 相邻单字符重复次数不得超过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
    
    
    
    
    
    

     

    展开全文
  • 弱口令验证方案设计

    2011-12-25 19:08:39
    弱口令的基本校验包括:口令字符串长度校验、口令字符串包含的字符类型校验、口令字符串包含的不同字符数校验。 口令字符串长度校验:验证口令字符串的长度能低于规定值(如6)。 口令字符串包含的字符类型校验...

    1.1    弱口令设计思路

    1.1.1    基本校验

    弱口令的基本校验包括:口令字符串长度校验、口令字符串包含的字符类型校验、口令字符串包含的不同字符数校验。

    口令字符串长度校验:验证口令字符串的长度不能低于规定值(如6)。

    口令字符串包含的字符类型校验:把字符类型分为大写字母、小写字母、数组、特殊字符四类,校验口令字符串包含的字符类型不能低于规定值(如2)。

    口令字符串包含的不同字符数校验:不区分大、小写时aA算同一字符,区分大、小写时aA为不同字符。校验口令字符串中包含的不同字符数不能低于规定值(如4)。

    1.1.2    高级校验

    弱口令的高级校验包括:连续字符校验、键盘输入规则校验、弱口令字典校验。

    连续字符校验:校验口令字符串中连续字符组成的子串长度不但能高于规定的值(如40%)。

    键盘输入规则校验:详细见2.1.3

    弱口令字典校验:在弱口令字典中校验该口令字符串是否为弱口令。

    1.1.3    键盘输入规则校验

    结合笔记本电脑和台式电脑键盘的布局规则,将字符输入键映射为4*10的二维数组矩阵(1-0q-pa-;,z-?),把密码字符串中每各字符格式化为键盘矩阵中对应的坐标,判断连续字符的坐标是否相邻,并记录连续相邻的串长度进行安全性评估

    1.2    我的弱口令校验工具

    1.2.1  详细验证步骤说明

    1:判断密码是否为null或空,如果不是进入下一步,否则返回结果(密码安全性不符合)

    2:判断密码字符串长度是否符合要求,默认是大于等于6位,如果是进入下一步,否则返回结果(密码安全性不符合)

    3:循环取出密码串中从0位置到长度下限++的子串,进行下面48的操作并记录结果到一个double[]

    4:评估密码中包含的字符类型是否符合要求,如果低于下限返回0,否则返回6-10double

    5:评估密码至少包含的不同字符数(不区分大、小写),返回int,如果字符数小于下限返回0,否则返回6-10double

    6:评估密码字符串是否包含a-z,z-a这样的连续字符,返回一个double,如果连续字符占整个串长度的40%以上返回0,否则返回(1-连续字符占整个串长度的百分比) * 10

    7:评估密码字符串是否匹配键盘输入习惯,返回0-10的整数,值越大表示越不符合键盘输入习惯

    8:根据3456的评估结果综合评估出密码的安全评估值(0-10double

    9:循环3double[]的值,如果全是0返回0,否则从第一个不是0的位置开始累加,如果后一个位置为0则加长度修正值1,如果累加结果大于10,循环结束返回10

    10:判断7产生的安全评估值是否大于安全评估值的下限(默认7),是返回true,否则返回false

    1.2.2  Java实现类

    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    import org.apache.log4j.Logger;
    
    /**
     * <strong>Title : CheckPWD</strong><br>
     * <strong>Description : 密码强度验证</strong><br>
     * <strong>Create on : Dec 6, 2011 7:34:45 PM</strong><br>
     * @author liulang@mochasoft.com.cn<br>
     * @version v1.0<br>
     * <br>
     * 详细验证步骤说明:<br>
     * 1:判断密码是否为null或空,如果不是进入下一步,否则返回结果(密码安全性不符合)<br>
     * 2:判断密码字符串长度是否符合要求,默认是大于等于6位,如果是进入下一步,否则返回结果(密码安全性不符合)<br>
     * 3:循环取出密码串中从0位置到长度下限++的子串,进行下面4到8的操作并记录结果到一个double[]中
     * 4:评估密码中包含的字符类型是否符合要求,如果低于下限返回0,否则返回6-10的double<br>
     * 5:评估密码至少包含的不同字符数(不区分大、小写),返回int,如果字符数小于下限返回0,否则返回6-10的double<br>
     * 6:评估密码字符串是否包含a-z,z-a这样的连续字符,返回一个double,如果连续字符占整个串长度的40%以上返回0,否则返回(1-连续字符占整个串长度的百分比) * 10<br>
     * 7:评估密码字符串是否匹配键盘输入习惯,返回0-10的整数,值越大表示越不符合键盘输入习惯<br>
     * 8:根据3、4、5、6的评估结果综合评估出密码的安全评估值(0-10的double)<br>
     * 9:循环3中double[]的值,如果全是0返回0,否则从第一个不是0的位置开始累加,如果后一个位置为0则加长度修正值1,如果累加结果大于10,循环结束返回10<br>
     * 9:判断7产生的安全评估值是否大于安全评估值的下限(默认7),是返回true,否则返回false
     * <br>
     * <strong>修改历史:</strong><br>
     * 修改人-------------修改日期-------------修改描述<br>
     * --------------------------------------------<br>
     * liulang-----------2011/12/7---------<br>
     * &nbsp;&nbsp;1:增加容错处理;<br>
     * &nbsp;&nbsp;2:修改键盘输入习惯匹配评估算法的逻辑;<br>
     * &nbsp;&nbsp;3:增加一个更加严格的键盘习惯匹配算法maches2(可匹配类似1z2x3c4v5b这样的特殊字符串)<br>
     * <br>
     */
    public final class CheckPWD {
    	private static Logger logger = Logger.getLogger(CheckPWD.class);
    	
    	/**
    	 * 安全密码评估值的下限,取值范围:0-10,默认:7
    	 */
    	public static double PASSWORD_STRONG = 7;
    	
    	/**
    	 * 密码字符串包含的字符类型(a-z,A-Z,0-9,特殊字符)在密码安全性评估中所占比例,默认:0.15
    	 */
    	public static double CHAR_TYPE_NUM_THRESHOLD = 0.15;
    	
    	/**
    	 * 密码字符串包含的不同字符数(不区分大、小写,同一键位的视为同一字符)在密码安全性评估中所占比例,默认:0.35
    	 */
    	public static double MIN_CONTAIN_CHAR_NUM_THRESHOLD = 0.35;
    	
    	/**
    	 * 密码字符串匹配键盘输入习惯在密码安全性评估中所占比例,默认:0.3
    	 */
    	public static double KEYSET_MATCHER_THRESHOLD = 0.3;
    	
    	/**
    	 * 评估密码字符串中a-z,z-a这样的连续字符在密码安全性评估中所占比例,默认:0.2
    	 */
    	public static double SEQUENTIAL_CHARS_THRESHOLD = 0.2;
    	
    	/**
    	 * 键盘输入习惯匹配规则严格模式
    	 */
    	public static int KEYSET_MATCHER_STRICT_MODE = 1;
    	
    	/**
    	 * 键盘输入习惯匹配规则不严格模式
    	 */
    	public static int KEYSET_MATCHER_UNDEMANDING_MODE = 0;
    	
    	/**
    	 * 密码最小长度,默认为6
    	 */
    	private static int MIN_LENGTH = 6;
    	
    	/**
    	 * 密码至少包含的不同字符数(不区分大、小写),(例如:"aaa"包含一个字符,"aba"包含2个字符,"aA"包含1个字符等),默认为4
    	 */
    	private static int MIN_CONTAIN_CHAR_NUM = 4;
    	
    	/**
    	 * 密码至少包含的字符类型数(a-z,A-Z,0-9,特殊字符),默认为2
    	 */
    	private static int MIN_CHAR_TYPE_NUM = 2;
    	
    	/**
    	 * 中等强度密码键盘规则匹配严格度,默认0.6
    	 */
    	private static double THRESHOLD_MEDIUM = 0.6;
    	
    	/**
    	 * 高安全度密码键盘规则匹配严格度,默认0.4
    	 */
    	private static double THRESHOLD_STRONG = 0.4;
    	
    	/**
    	 * 高安全度密码键盘规则匹配严格度,默认0.4
    	 */
    	private static double MAX_SEQUENTIAL_CHARS_THRESHOLD = 0.4;
    	
    	/**
    	 * 字母顺序A-Z
    	 */
    	private static String A_Z = "abcdefghijklmnopqrstuvwxyz";
    	
    	/**
    	 * 字母顺序Z-A
    	 */
    	private static String Z_A = "zyxwvutsrqponmlkjihgfedcba";
    	
    	/**
    	 * shift键产生的字符与非shift键时对应的字符
    	 */
    	private static Map CONVERSION_MAP =  new HashMap();
    	
    	/**
    	 * 将键盘按键格式话为4*10的矩阵的坐标
    	 */
    	private static Map DICTIONARY_MAP = new HashMap();
    	private static String[] dictionary1 = "1 2 3 4 5 6 7 8 9 0".split("\\s+");
    	private static String[] dictionary2 = "q w e r t y u i o p".split("\\s+");
    	private static String[] dictionary3 = "a s d f g h j k l ;".split("\\s+");
    	private static String[] dictionary4 = "z x c v b n m , . /".split("\\s+");
    	private static String[][] DICTIONARY_MATRIX = {dictionary1, dictionary2, dictionary3, dictionary4};
    	
    	static {	
    		CONVERSION_MAP.put("!", "1");
    		CONVERSION_MAP.put("@", "2");
    		CONVERSION_MAP.put("#", "3");
    		CONVERSION_MAP.put("$", "4");
    		CONVERSION_MAP.put("%", "5");
    		CONVERSION_MAP.put("^", "6");
    		CONVERSION_MAP.put("&", "7");
    		CONVERSION_MAP.put("*", "8");
    		CONVERSION_MAP.put("(", "9");
    		CONVERSION_MAP.put(")", "0");
    		CONVERSION_MAP.put(":", ";");
    		CONVERSION_MAP.put("<", ",");
    		CONVERSION_MAP.put(">", ".");
    		CONVERSION_MAP.put("?", "/");
    		
    		for(int i=0, ln=DICTIONARY_MATRIX.length; i<ln; i++) {
    			String[] dic = DICTIONARY_MATRIX[i];
    			for(int j=0, lnt=dic.length; j<lnt; j++) {
    				int[] row_cell = {i,j};
    				DICTIONARY_MAP.put(dic[j], row_cell);
    			}
    		}
    	}
    	
    	private CheckPWD(){
    		
    	}
    	
    	/**
    	 * 严格的键盘输入习惯匹配规则,匹配连续或者非连续的(可以匹配:1a2s3d4f5g这样的有规律的串),比matches方法的匹配规则更严格
    	 * @param matcherList
    	 * @param row_cellList
    	 * @param index
    	 */
    	private static void maches2(List matcherList, List row_cellList, int index) {
    		for(; index<row_cellList.size(); index++) {
    			int[] row_cell_t = (int[]) row_cellList.get(index);
    			if(row_cell_t != null) {
    				boolean flag = true;
    				for(int i=0; i<matcherList.size(); i++) {
    					List list = (List) matcherList.get(i);
    					for(int j=0; j<list.size(); j++) {
    						int[] row_cell = (int[]) list.get(j);
    						if(((Math.abs(row_cell_t[0] - row_cell[0]) <= 1) && (Math.abs(row_cell_t[1] - row_cell[1]) <= 1))) {
    							list.add(row_cell_t);
    							flag = false;
    							break;
    						}
    					}
    					if(!flag) break;
    				}
    				if(flag) {
    					List arrt = new ArrayList();
    					arrt.add(row_cell_t);
    					matcherList.add(arrt);
    				}
    			}
    		}
    	}
    	
    	/**
    	 * 键盘输入习惯匹配规则,匹配连续输入(不能匹配:1a2s3d4f5g这样的有规律的串),比maches2方法的匹配规则宽松
    	 * @param matcherList
    	 * @param row_cellList
    	 * @param index
    	 */
    	private static void matches(List matcherList, List row_cellList, int index) {
    		for(int i=0; i<matcherList.size(); i++) {
    			List list = (List) matcherList.get(i);
    			for(int ln=row_cellList.size(); index<ln; index++) {
    				int[] row_cell = (int[]) list.get(list.size()-1);
    				int[] row_cell_t = (int[]) row_cellList.get(index);
    				//如果相邻的键盘字符(某一个键的左右、上下、斜向相邻)被连续输入,在原匹配链条上增加新的输入
    				if((row_cell != null) && (row_cell_t != null) && 
    						((Math.abs(row_cell_t[0] - row_cell[0]) <= 1) && (Math.abs(row_cell_t[1] - row_cell[1]) <= 1))) {
    					list.add(row_cell_t);
    				}else {	//如果新字符和上一匹配链条的结尾字符距离较远,这结束上一匹配链条,以该字符为首增加新的匹配链条
    					List arrt = new ArrayList();
    					arrt.add(row_cell_t);
    					matcherList.add(arrt);
    					index++;
    					break;
    				}
    			}
    		}
    	}
    	
    	/**
    	 * 键盘规则匹配器,返回double
    	 * @param password  密码字符串
    	 * @return
    	 */
    	public static double keysetMatcher(String password, int matchesMode) { 
    		String t_password = new String(password);
    		t_password = t_password.toLowerCase();
    		t_password = canonicalizeWord(password);
    		logger.debug("****************将密码字符串转换为键盘矩阵的对应坐标 start******************");
    		char[] pwdCharArr = t_password.toCharArray();
    		List row_cellList = new ArrayList();
    		int Num = 0;
    		int startIndex = -1;
    		for(int i=0, ln= pwdCharArr.length; i<ln; i++) {
    			int[] row_cell = (int[]) DICTIONARY_MAP.get(String.valueOf(pwdCharArr[i]));
    			if(row_cell != null)  {
    				row_cellList.add(row_cell); 
    				Num++;
    				if(startIndex == -1) startIndex = i; 
    			} else row_cellList.add(null);
    		}
    		logger.debug("****************将密码字符串转换为键盘矩阵的对应坐标 end******************");
    		
    		logger.debug("****************初始化匹配链条 start******************");
    		int index = startIndex+1;
    		int[] row_cell0 = (int[]) row_cellList.get(startIndex);
    		List matcherList = new ArrayList();
    		List arr0 = new ArrayList();
    		arr0.add(row_cell0);
    		matcherList.add(arr0);
    		logger.debug("****************初始化匹配链条 end******************");
    		//根据匹配规则进行匹配
    		if(KEYSET_MATCHER_UNDEMANDING_MODE == matchesMode) matches(matcherList, row_cellList, index);	//不严格的匹配模式
    		else if(KEYSET_MATCHER_STRICT_MODE == matchesMode) maches2(matcherList, row_cellList, index);	//严格的匹配模式
    		
    		double rValue = 0;
    		for(double threshold = THRESHOLD_STRONG; threshold <= THRESHOLD_MEDIUM; threshold+=0.1) {
    			boolean flag = true;
    			int nMinimumMeaningfulMatchLength =  (int) (Num * threshold);
    			//特殊字符(~ ` - _ = + [ { ] } \ | ' ")所占比率上限
    			if(threshold <= ((t_password.length() - Num)*1.0/t_password.length())) flag = false;
    			if(flag) {
    				for(int i=0; i<matcherList.size(); i++) {
    					List list = (List) matcherList.get(i);
    					if(list.size() >= nMinimumMeaningfulMatchLength) {
    						flag = false;
    						return rValue;
    					}
    				}
    			}
    			if(flag) {
    				if(THRESHOLD_MEDIUM == THRESHOLD_STRONG) rValue = 10;
    				else rValue = 6 + 4*(THRESHOLD_MEDIUM-threshold)*1.0/(THRESHOLD_MEDIUM-THRESHOLD_STRONG);
    				break;
    			}
    		}
    		return rValue;
    	}
    
    	/**
    	 * 替换密码中的shift键产生的字符转换为非shift键时对应的字符
    	 * @param password	密码字符串
    	 * @return	替换后的密码字符串
    	 */
    	private static String canonicalizeWord(String password) {
    		StringBuffer sb = new StringBuffer();
    		if(password != null && password.length() > 0) {
    			for(int i=0; i<password.length(); i++) {
    				String cs = String.valueOf(password.charAt(i));
    				if(CONVERSION_MAP.get(cs) != null) sb.append(CONVERSION_MAP.get(cs));
    				else sb.append(cs);
    			}
    		}
    		return sb.toString();
    	}
    	
    	/**
    	 * 搜索字符str中是否包含有regex指定的正则表达式匹配的子串
    	 * @param str 待搜索字符串
    	 * @param regex	正则表达式字符串
    	 * @return	包含匹配子串返回true,否则返回false
    	 */
    	private static boolean stringFind(String str, String regex) {
    		Pattern p = Pattern.compile(regex);
    		Matcher m = p.matcher(str);
    		if(m.find()) return true;
    		return false;
    	}
    	
    	/**
    	 * 评估密码中包含的字符类型是否符合要求,如果低于下限返回0,否则返回6 + (字符类型总数 - 下限) * 2
    	 * @param password  密码字符串
    	 * @param num 密码至少包含的字符类型数(a-z,A-Z,0-9,特殊字符),默认为2
    	 * @return 
    	 */
    	public static double checkCharTypeNum(String password, int num) {
    		int typeNum = 0;
    		if(stringFind(password, "[a-z]+")) typeNum++;
    		if(stringFind(password, "[0-9]+")) typeNum++;
    		if(stringFind(password, "[A-Z]+")) typeNum++;
    		if(stringFind(password, "\\p{Punct}+")) typeNum++;
    		double rValue = 0;
    		if(typeNum >= num) {
    			if(num == 4) rValue = 10;
    			else rValue = 6 + (typeNum - num)*1.0/(4-num) * 4; 
    		}
    		return rValue;
    	}
    	
    	/**
    	 * 评估a-z,z-a这样的连续字符,返回一个double,如果连续字符占整个串长度的40%以上返回0,否则返回(1-连续字符占整个串长度的百分比) * 10
    	 * @param password
    	 * @return
    	 */
    	public static double checkSequentialChars(String password) {
    		String t_password = new String(password);
    		t_password = t_password.toLowerCase();
    		double rValue = 0;
    		int i = 2;
    		int n = t_password.length();
    		for(; i<n; i++) {
    			boolean flag = true;
    			for(int j=0; j+i<n; j++) {
    				String str = t_password.substring(j, j+i);
    				if((A_Z.indexOf(str) != -1) || (Z_A.indexOf(str) != -1)) {
    					flag = false;
    					break;
    				}
    			}
    			if(flag) {
    				if(i*1.0/n > MAX_SEQUENTIAL_CHARS_THRESHOLD)  rValue = 0;
    				else rValue = (1-i*1.0/n) * 10;
    				break;
    			}
    		}
    		return rValue;
    	}
    	
    	/**
    	 * 评估密码至少包含的不同字符数(不区分大、小写),返回int,如果字符数小于下限返回0,否则返回6 + (包含字符数 - 下限),如果大于10,返回10
    	 * @param password 密码字符串
    	 * @param num 密码至少包含的字符类型数(a-z,A-Z,0-9,特殊字符),默认为2
    	 * @return
    	 */
    	public static double checkMinContainCharNum(String password, int num) {
    		String t_password = new String(password);
    //		t_password = t_password.replaceAll("(.)\\1+", "$1");
    		t_password = t_password.toLowerCase();
    		t_password = canonicalizeWord(password);
    		Map map = new HashMap();
    		int snum = 0;
    		for(int i=0,ln= t_password.length(); i<ln; i++) {
    			String cs = String.valueOf(t_password.charAt(i));
    			if(map.get(cs) == null) {
    				map.put(cs, cs);
    				snum++;
    			}
    		}
    		double rValue = 0;
    		if(snum >= num) rValue = 6 + (snum - num);
    		return (rValue > 10 ? 10 : rValue);
    	}
    	
    	/**
    	 * 评估密码强度,根据密码长度,包含的字符类型,包含不同字符数,包含的连续字符,键盘输入习惯综合评估密码强度,返回0-10的double
    	 * @param password
    	 * @return
    	 */
    	public static double evalPWD(String password, int matchesMode) {
    		if(password == null || "".equals(password.replaceAll("\\s+", ""))) return 0;		//判断密码为null或""
    		if(MIN_LENGTH > password.length()) return 0;				//判断密码长度是否符合
    		
    		double[] val = new double[1000];
    		int n = 0;
    		for(int i=MIN_LENGTH; i<=password.length(); i++) {
    			String t_password = password.substring(0, i);
    			//评估密码中包含的字符类型是否符合要求
    			double typeNumCheckResult = checkCharTypeNum(t_password,MIN_CHAR_TYPE_NUM);
    			//评估密码至少包含的不同字符数(不区分大、小写)
    			double minContainCharNumCheckResult = checkMinContainCharNum(t_password, MIN_CONTAIN_CHAR_NUM);
    			//评估a-z,z-a这样的连续字符
    			double sequentialCharsCheckResult = checkSequentialChars(t_password);
    			//评估键盘输入习惯
    			double keysetMatcherResult = keysetMatcher(t_password, matchesMode);
    			logger.debug("评估密码中包含的字符类型结果:"+typeNumCheckResult);
    			logger.debug("评估密码至少包含的不同字符数结果:"+minContainCharNumCheckResult);
    			logger.debug("评估a-z,z-a这样的连续字符结果:"+sequentialCharsCheckResult);
    			logger.debug("评估键盘输入习惯结果:"+keysetMatcherResult);
    			if(typeNumCheckResult == 0 || minContainCharNumCheckResult == 0 || sequentialCharsCheckResult == 0 || keysetMatcherResult == 0) {
    				val[n] = 0;
    			}else {
    				val[n] = typeNumCheckResult*CHAR_TYPE_NUM_THRESHOLD + minContainCharNumCheckResult*MIN_CONTAIN_CHAR_NUM_THRESHOLD + 
    					sequentialCharsCheckResult*SEQUENTIAL_CHARS_THRESHOLD + keysetMatcherResult*KEYSET_MATCHER_THRESHOLD;
    			}
    			n++;
    		}
    		double rValue = 0;
    		boolean flag = false;
    		for(int i=0; i<n; i++) {
    			if(val[i] != 0) {
    				rValue += val[i];
    				flag = true;
    			}
    			if(flag && val[i] == 0) rValue += 1;
    			if(rValue >= 10) {
    				rValue = 10;
    				break;
    			}
    		}
    		return rValue;
    		
    //		//评估密码中包含的字符类型是否符合要求
    //		double typeNumCheckResult = checkCharTypeNum(password,MIN_CHAR_TYPE_NUM);
    //		//评估密码至少包含的不同字符数(不区分大、小写)
    //		double minContainCharNumCheckResult = checkMinContainCharNum(password, MIN_CONTAIN_CHAR_NUM);
    //		//评估a-z,z-a这样的连续字符
    //		double sequentialCharsCheckResult = checkSequentialChars(password);
    //		//评估键盘输入习惯
    //		double keysetMatcherResult = keysetMatcher(password, matchesMode);
    //		logger.debug("评估密码中包含的字符类型结果:"+typeNumCheckResult);
    //		logger.debug("评估密码至少包含的不同字符数结果:"+minContainCharNumCheckResult);
    //		logger.debug("评估a-z,z-a这样的连续字符结果:"+sequentialCharsCheckResult);
    //		logger.debug("评估键盘输入习惯结果:"+keysetMatcherResult);
    //		if(typeNumCheckResult == 0 || minContainCharNumCheckResult == 0 || sequentialCharsCheckResult == 0 || keysetMatcherResult == 0) {
    //			return 0;
    //		}else {
    //			return typeNumCheckResult*CHAR_TYPE_NUM_THRESHOLD + minContainCharNumCheckResult*MIN_CONTAIN_CHAR_NUM_THRESHOLD + 
    //				sequentialCharsCheckResult*SEQUENTIAL_CHARS_THRESHOLD + keysetMatcherResult*KEYSET_MATCHER_THRESHOLD;
    //		}
    	}
    	
    	/**
    	 * 用严格模式校验密码强度,根据密码评估结果判断密码是否可用,默认评估结果大于7的可用
    	 * @param password
    	 * @return
    	 */
    	public static boolean checkPwdInStrictMode(String password) {
    		double rValue = evalPWD(password, KEYSET_MATCHER_STRICT_MODE);
    		if(rValue >= PASSWORD_STRONG)  return true;
    		return false;
    	}
    
    	/**
    	 * 非严格模式校验密码强度,根据密码评估结果判断密码是否可用,默认评估结果大于7的可用
    	 * @param password
    	 * @return
    	 */
    	public static boolean checkPwdIndemandingMode(String password) {
    		double rValue = evalPWD(password, KEYSET_MATCHER_UNDEMANDING_MODE);
    		if(rValue >= PASSWORD_STRONG)  return true;
    		return false;
    	}
    	
    	public static void main(String[] args) {
    		String[] sArr = {
    				"1a2s3d4f5g6h",
    				"zcvjlufw123433546",
    				"~]sdfa^9mi|",
    				"`%0,uTs85vkj",
    				"liulanggood123",
    				"PASSword_123",
    				"yanghao1234",
    				"yanghao123",
    				"yanghao1981"
    		};
    		for(int i=0; i<sArr.length; i++) {
    			System.out.println("严格模式下校验"+sArr[i]+"的密码强度:"+evalPWD(sArr[i], KEYSET_MATCHER_STRICT_MODE));
    			System.out.println("非格模式下校验"+sArr[i]+"的密码强度:"+evalPWD(sArr[i], KEYSET_MATCHER_UNDEMANDING_MODE));
    		}
    		
    	}
    }
    
     
    展开全文
  • Tomcat支持在后台熟war文件,我们可以直接将webshell部署到web目录下。 War包一般是进行Web开发时一个网站Project下的所有代码,包括前台HTML/CSS/JS代码,以及Java的代码。当开发人员开发完毕时,就会将源码打包给...

    0x01 简介

    Tomcat支持在后台不熟war文件,我们可以直接将webshell部署到web目录下。
    War包一般是进行Web开发时一个网站Project下的所有代码,包括前台HTML/CSS/JS代码,以及Java的代码。当开发人员开发完毕时,就会将源码打包给测试人员测试,测试完后若要发布则也会打包成War包进行发布。War包可以放在Tomcat下的webapps或word目录,当Tomcat服务器启东市,War包也会随之解压后走动部署。

    0x02 测试版本

    Apache Tomcat/8.0.43

    0x03 漏洞复现

    1.使用弱口令(tomcat/tomcat)登录进Tomcat后台管理系统。
    在这里插入图片描述
    2.将jsp木马压缩成zip压缩文件并修改后缀为war作为war包上传。
    在这里插入图片描述
    3.上传成功后我们访问木马。
    在这里插入图片描述

    0x04 漏洞修复

    1.修改弱口令。
    2.修改conf/tomcat-users.xml文件中配置用户的权限。
    在这里插入图片描述
    参考:
    https://github.com/vulhub/vulhub/tree/master/tomcat/tomcat8

    展开全文
  • 破解常见的需验证码的用户密码,包括常见的SSH,MYSQL,POP3,RDP,SMB,SQLserve等
  • 其实在这个信息大爆炸的时代,数据清洗可以应用在众多的领域,包括限于农业,军事产业,信息安全产业,工业,旅游业,金融行业,房地产业等等。在会议上我展示的两个模型只是非常基础的两个数据处理模型,我司...
    前言

    几天前,我在FreeTalk北京站演讲了《数据清洗在网络安全中的应用》,由于时间关系,很多内容并没有讲到,会议结束后很多人也私信问我很多问题。其实在这个信息大爆炸的时代,数据清洗可以应用在众多的领域,包括但不限于农业,军事产业,信息安全产业,工业,旅游业,金融行业,房地产业等等。在会议上我展示的两个模型只是非常基础的两个数据处理模型,我司还有很多极其复杂的模型并没有展示。


    先举一个例子,就拿社工库来说,可能很多人的理解就是把互联网泄露的信息索引进去并且进行搜索就完了,真是天真。社工库的鼻祖应该是DIS系统,全称为Distributed Interactive Simulation System,是美国国防高级研究计划局早期的项目之一,DIS系统具有互操作性(Interoperability)、可伸缩性(Scalability)和仿真的时空一致性(Time-Space Coherence)等三大特性。

    例子

    这里说一个我碰到的真实例子,警方已经确定有两个犯罪人员小A和小B,目前只知道小A的真实信息,另外一人完全不知道,如果强行逮捕小A,那么可能会让另外一个犯罪分子逃脱。这个两个人在网络上没有任何的交流,没有相互加过QQ,微信等,甚至连电话号码也没有留过,全部都采用加密软件交流,而且也不在一起搭乘交通工具。但是最后警方还是通过DIS系统成功找到了小B。虽然他们线上线下都很谨慎,但是警方发现,有有个人的QQ号经常和小A的QQ号出现在一个网吧,成功逮捕了两名犯罪人员。这里DIS系统发挥主要功能就是仿真的时空一致性,而要完成这个功能需要非常稳定的数据关联。

    目前中国大量的DIS系统主要是采用redis这种内存数据库来进行检索和数据处理,因此需要极高的内存配置,并且无法进行多人同时查询。据了解,中国某个部门的DIS系统需要125GB的内存才能运行。但是,如果提前就将数据进行清洗,把具有关联的数据进行输出和入库。那么查询的时候不会再回到内存中做数据清洗,而是直接从数据库中检索,这样可以节约大量的系统资源,并且可以多人同时查询。

    字典清洗模型制作

    不聊家常了,接下来先进入正题。几年前猪猪侠在Wooyun发布了一个全国弱口令TOP 100,而我打算发一个全国弱口令Top 1000。

    以下为源数据截图,里面的数据非常杂乱,保护MD5加密密码,中文用户名,空密码,空用户名等。

     

    首要任务是先在Kettle Spoon上将源数据进行输入。在Spoon是我使用的模块是文本文件输入。

     

    我要制作全国弱口令Top 1000,那么首要任务是对数据中的password进行排序。这里使用的模块是排序记录模块。排序的真正作用是为了分组模块能够对数据进行正确,使用分组模块前一定要先对数据进行排序。

     

    在分组模块中,我新建了一个SumNumber字段,目的是为了对password字段中内容的出现次数进行计算。

     

    随后再对Sumnumber字段进行排序,目的是为了能够直观的了解到密码出现次数的一个排名。

     

    因为源数据中出现了MD5值,空值等,所以我们还要对数据再进行二次清洗。这里我采用了Java代码模块,自己写了一段java将大于16位数的密码,小于3位数的密码和空密码给过滤了。并且将过滤后得到的密码赋值给passwordnew1字段。

     

    因为以上过滤后的密码将会以NULL来替换,所以又写了一个过滤规则将NULL密码给过滤了。
     

    最后再将全部清洗好的数据用输出模块输出到指定的目录下。以下是整个模型的概览。

     

    下面是清洗好的数据,左边是密码,右边是密码出现的次数。

     

    因为数据采集的时候是互联网上的泄露数据,有些数据无法确定真伪,数据采集的不规范导致了部分结果存在错误,比如fill.com这个密码不应该排名那么靠前,还有就是from91是个什么鬼。。。。。。。不过勉强还是能够让大家用用。

    总结

    除了FreeTalk展示的那个模型以外,我们还制作了针对财务,天气,畜牧业,种植业等相关的数据模型。如果你从事信息安全行业,数据清洗这个技能将会给你事半功倍的效果。Kettle Spoon采用图形化窗口操作,非常便捷,其中内置了大量数据清洗模块。要学习Kettle,单纯看文章教程还是非常难懂,建议大家最好实际操作一遍。如果有哪里不懂的欢迎在评论区留言。

    这里只提供了前1000的弱口令集合。如果哪家单位需要完整的弱口令数据做风控或者相关研究的,可以私信我司(非个人外,我司免费无条件分享这批格式化数据)
    展开全文
  • 最近在玩漏洞检测的工具...Kunpeng项目地址https://github.com/opensec-cn/kunpeng项目简介Kunpeng是一个Golang编写的开源POC检测框架,集成了包括数据库、中间件、web组件、cms等等的漏洞POC,可检测弱口令、SQL...
  • 在系统中,除了手动创建的各种账号之外,还包括随系统或程序安装过程而生成的其他大量账号。除了root之外,其他大量账号只是用来维护系统运作、启动或保持服务进程,一般是允许登陆的,因此也称为非登陆用户 ...
  • 在Linux系统中,除了用户手动创建的各种账号之外,还包括随系统或程序安装过程而生成的其他大量账号,除了超级用户root之外,其他大量账号只是用来维护系统运作、启动或保持服务进程,一般是允许登录的,因此也...
  • 在Linux系统中,除了手工创建的账号外还存在很多账号,包括随系统安装或程序安装而生成的大量账号,这些账号是用来维持系统运行或保持服务进程的,一把你允许登录,我们把这些账户称为非登录用户。 这些非登
  • 前言 无论是,软件开发,还是运维,都离开使用Linux服务器。...弱口令检测工具 1.将宿主机中的工具挂载到虚拟机中 2.解压 3.查看解压的文件内容 4.安装C C++编译器 yum install gcc gcc-c++
  • 2021-01-27

    2021-01-27 11:36:06
    靠近年底“勒索病毒”漫天要价,蠕虫病毒incaseformat 引爆朋友圈。 企业这2个病毒都是不是什么最新闻,但是给企业带来的伤害...计算机中涉及到口令爆破攻击的暴露面,主要包括远程桌面弱口令、SMB 弱口令、数据库管理
  • 信息安全风险评估

    2021-01-11 15:25:46
    弱口令,例如空/弱telnet口令、snmp口令等。 网络资源的访问控制:检测到无线访问点 域名系统,ISC BIND SIG资源记录无效过期时间拒绝服务攻击漏洞,Microsoft Windows DNS拒绝服务攻击 路由器,Cisco IOS Web...
  • 通常的黑客攻击包括预攻击、攻击和后攻击三个阶段;...与黑客的攻击相比,渗透测试仅仅进行预攻击阶段的工 作,并对系统本身造成危害,即仅仅通过一些信息搜集手段来探查系统的弱口令、漏洞等脆弱性信息。...
  • Scanners Box

    2020-09-25 19:03:36
    包括子域名,数据库,中间件和其他模块化设计的扫描器等,但对于一些被大众所熟知的知名扫描工具,如nmap、w3af、brakeman、arachni、nikto、metasploit、aircrack-ng将不包括在本项目的收集范围内。 目录 子域名...
  • 最近在玩漏洞检测的工具...Kunpeng项目地址https://github.com/opensec-cn/kunpeng项目简介Kunpeng是一个Golang编写的开源POC检测框架,集成了包括数据库、中间件、web组件、cms等等的漏洞POC,可检测弱口令、SQL...
  • 2信息安全概念

    2021-02-26 10:06:47
    使用弱口令(简单的密码) 连接加密的无线网络 BYOD设备 BYOD(Bring Your Own Device)指携带自己的设备办公,这些设备包括个人电脑、手机、平板等(而更多的情况指手机或平板这样的移动智能终端设备。)在机场...
  • Wannacry勒索病毒时间刚刚告一段落,6月份央视就曝光了黑客利用弱口令入侵家庭摄像头的事件,经调查发现诸多知名品牌网络摄像头均存在安全隐患,一时间弄得是人心惶惶,当了除此之外还包括Petya等各种网络安全事件。...
  • 黑客网络安全扫描工具

    万次阅读 2018-07-30 20:48:47
    包括子域名枚举、数据库漏洞扫描、弱口令或信息泄漏扫描、端口扫描、指纹识别以及其他大型扫描器或模块化扫描器,同时该仓库只收录各位网友自己编写的一般性开源扫描器,类似awvs、nmap、w3af等知名扫描工具收录。...
  • IPC***实例

    2012-10-22 18:07:52
    第一步:采用X-Scan扫描漏洞主机,选取开放139/445端口的主机为***对象,且主机存在弱口令或者知道主机的登录账户和密码。 第二步:建立IPC连接,使用如下命令。 netuse\\192.168.10.128\ipc$"123456"/user:...
  • 网络安全扫描工具

    千次阅读 2019-01-04 14:32:27
    包括子域名枚举、数据库漏洞扫描、弱口令或信息泄漏扫描、端口扫描、指纹识别以及其他大型扫描器或模块化扫描器,同时该仓库只收录各位网友自己编写的一般性开源扫描器,类似awvs、nmap、w3af等知名扫描工具收录。...
  • Scanners-Box是一个集合github平台上的安全行业从业人员自研开源扫描器的仓库,包括子域名枚举、数据库漏洞扫描、弱口令或信息泄漏扫描、端口扫描、指纹识别以及其他大型扫描器或模块化扫描器;该仓库只收录各位网友...
  • 包括子域名枚举、数据库漏洞扫描、弱口令或信息泄漏扫描、端口扫描、指纹识别以及其他大型扫描器或模块化扫描器,同时该仓库只收录各位网友自己编写的一般性开源扫描器,类似awvs、nmap、w3af等知名扫描工具收录。...
  • 1、 Linux或UNIX系统配置检查 系统配置的扫描是基于被动式策略进行扫描,主要检测...2、是否存在弱口令 3、IP协议栈的参数配置是否正确 4、敏感文件和目录的操作权限是否正确 5、重要应用程序的配置文件 如Ap...
  • 安全工具库-免费(开源)项目简介Scanners Box (简称 - scanbox)是一个集合github平台上的安全行业从业者自研开源扫描器的仓库,包括子域名枚举、数据库漏洞扫描、弱口令或信息泄漏扫描、端口扫描、指纹识别以及其他...
  • Scanners-Box是一个集合github平台上的安全行业从业人员自研开源扫描器的仓库,包括子域名枚举、数据库漏洞扫描、弱口令或信息泄漏扫描、端口扫描、指纹识别以及其他大型扫描器或模块化扫描器;该仓库只收录各位网友...

空空如也

空空如也

1 2 3
收藏数 54
精华内容 21
关键字:

弱口令不包括