Index: forgon-tools/src/main/java/com/forgon/tools/util/ConfigUtils.java =================================================================== diff -u -r41110 -r41176 --- forgon-tools/src/main/java/com/forgon/tools/util/ConfigUtils.java (.../ConfigUtils.java) (revision 41110) +++ forgon-tools/src/main/java/com/forgon/tools/util/ConfigUtils.java (.../ConfigUtils.java) (revision 41176) @@ -16,6 +16,8 @@ import java.util.Properties; import java.util.Scanner; import java.util.Set; +import java.util.regex.Matcher; +import java.util.regex.Pattern; import java.util.stream.Collectors; import org.apache.commons.collections4.CollectionUtils; @@ -643,5 +645,149 @@ } return configList; } + + /** + * 判断密码复杂度是否满足规则 + * @param userName 用户名 + * @param password 密码 + * @return true/false + */ + public static boolean userPasswordMeetPwdComplexityReq(String userName, String password){ + String needBeStrongPwdWhenModifyPwd = ConfigUtils.getSystemSetConfigByName("needBeStrongPwdWhenModifyPwd"); + if(StringUtils.isNotBlank(needBeStrongPwdWhenModifyPwd)){ + if(StringUtils.isBlank(userName)){ + throw new SystemException("用户名不能为空！"); + } + if(StringUtils.isBlank(password)){ + throw new SystemException("密码不能为空！"); + } + JSONObject needBeStrongPwdWhenModifyPwdJson = JSONObject.fromObject(needBeStrongPwdWhenModifyPwd); + try { + return userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwdJson); + } catch (Exception e) { + e.printStackTrace(); + } + return false; + } + return true; + } + + /** + * 判断密码复杂度是否满足规则 + * @param userName 用户名 + * @param password 密码 + * @param needBeStrongPwdWhenModifyPwdJson 配置项 + * @return true/false + */ + public static boolean userPasswordMeetPwdComplexityReq(String userName, String password, JSONObject needBeStrongPwdWhenModifyPwd){ + if(StringUtils.isBlank(userName)){ + throw new SystemException("用户名不能为空！"); + } + if(StringUtils.isBlank(password)){ + throw new SystemException("密码不能为空！"); + } + if(needBeStrongPwdWhenModifyPwd == null){ + return true; + } + + int minPwdLength = needBeStrongPwdWhenModifyPwd.optInt("minPwdLength"); + Boolean containNumber = needBeStrongPwdWhenModifyPwd.optBoolean("containNumber"); + Boolean containLetter = needBeStrongPwdWhenModifyPwd.optBoolean("containLetter"); + Boolean containUppercaseLetter = needBeStrongPwdWhenModifyPwd.optBoolean("containUppercaseLetter"); + Boolean containLowerCaseLetter = needBeStrongPwdWhenModifyPwd.optBoolean("containLowerCaseLetter"); + Boolean containSpecialChar = needBeStrongPwdWhenModifyPwd.optBoolean("containSpecialChar"); + // passwordNotContainLoginName（密码包含账号）：值为true密码不可以包含账号，值为false时可以包含账号 + Boolean passwordNotContainLoginName = needBeStrongPwdWhenModifyPwd.optBoolean("passwordNotContainLoginName", false); + // passwordComplexityReq1：值为true则检查密码至少包含英文字母、数字、特殊字符的其中两种 + Boolean passwordComplexityReq1 = needBeStrongPwdWhenModifyPwd.optBoolean("passwordComplexityReq1", false); + // windowsPasswordComplexityReq:true：值为true则检查密码至少包含大写字母，小写字母、数字、特殊字符的其中三种 + Boolean windowsPasswordComplexityReq = needBeStrongPwdWhenModifyPwd.optBoolean("windowsPasswordComplexityReq", false); + // blacklistPatterns：数组元素，可以定义弱密码黑名单及禁用的连续字符；ZSYY-441 + JSONArray blacklistPatterns = needBeStrongPwdWhenModifyPwd.optJSONArray("blacklistPatterns"); + // customRegex（自定义正则校验表达式）：可以设置自定义的正则校验表达式ZSYY-441 + String customRegex = needBeStrongPwdWhenModifyPwd.optString("customRegex"); + + //包含数字 + String numberExp = ".*[0-9].*"; + //包含特殊符号 + String specialCharExp = ".*[^a-zA-Z0-9].*"; + //包含大写字母 + String upperCaseExp = ".*[A-Z].*"; + //包含小写字母 + String lowerCaseExp = ".*[a-z].*"; + // 包含大小写字母 + String upperAndLowerCaseExp = ".*[a-zA-Z].*"; + + if(password.length() < minPwdLength){ + throw new SystemException("密码长度最小为" + minPwdLength + "位!"); + } + if(containNumber && !match(password, numberExp)){ + throw new SystemException("密码必须包含数字!"); + } + if(containLetter && !match(password, upperAndLowerCaseExp)){ + throw new SystemException("密码必须包含字母!"); + } + if(containUppercaseLetter && !match(password, upperCaseExp)){ + throw new SystemException("密码必须包含大写字母!"); + } + if(containLowerCaseLetter && !match(password, lowerCaseExp)){ + throw new SystemException("密码必须包含小写字母!"); + } + if(containSpecialChar && !match(password, specialCharExp)){ + throw new SystemException("密码必须包含特殊字符!"); + } + if(passwordNotContainLoginName && password.toLowerCase().indexOf(userName.toLowerCase()) != -1){ + throw new SystemException("密码不可以包含账号!"); + } + + if(windowsPasswordComplexityReq){ + //包含数字，大写，小写 + boolean b1 = match(password, numberExp) && match(password, upperCaseExp) && match(password, lowerCaseExp); + //包含数字，大写，特殊符号 + boolean b2 = match(password, numberExp) && match(password, upperCaseExp) && match(password, specialCharExp); + //包含数字，小写，特殊符号 + boolean b3 = match(password, numberExp) && match(password, lowerCaseExp) && match(password, specialCharExp); + //包含大写，小写，特殊符号 + boolean b4 = match(password, upperCaseExp) && match(password, lowerCaseExp) && match(password, specialCharExp); + if(!b1 && !b2 && !b3 && !b4){ + throw new SystemException("密码强度不够，至少包含大写字母，小写字母、数字、特殊字符的其中三种!"); + } + } + + if(passwordComplexityReq1){ + //包含数字，英文字母 + boolean b1 = match(password, numberExp) && match(password, upperAndLowerCaseExp); + //包含数字，特殊符号 + boolean b2 = match(password, numberExp) && match(password, specialCharExp); + //包含英文字母，特殊符号 + boolean b3 = match(password, upperAndLowerCaseExp) && match(password, specialCharExp); + if(!b1 && !b2 && !b3){ + throw new SystemException("密码强度不够，至少包含英文字母、数字、特殊字符的其中两种!"); + } + } + + //blacklistPatterns：数组元素，可以定义弱密码黑名单及禁用的连续字符；ZSYY-441 + if(blacklistPatterns != null && blacklistPatterns.size() > 0){ + for (Object object : blacklistPatterns) { + String blacklistPattern = (String)object; + if(password.contains(blacklistPattern)){ + throw new SystemException("密码不可以包含" + blacklistPattern + "!"); + } + } + } + + //customRegex（自定义正则校验表达式）：可以设置自定义的正则校验表达式 ，满足正则表达式才是合法密码ZSYY-441 + if(StringUtils.isNotBlank(customRegex) && !match(password, customRegex)){ + throw new SystemException("密码不满足自定义正则表达式!"); + } + + return true; + } + + private static boolean match(String str, String regex) { + Pattern pattern = Pattern.compile(regex); + Matcher matcher = pattern.matcher(str); + return matcher.matches(); + } } Index: forgon-core/src/main/java/com/forgon/security/service/UserManagerImpl.java =================================================================== diff -u -r40918 -r41176 --- forgon-core/src/main/java/com/forgon/security/service/UserManagerImpl.java (.../UserManagerImpl.java) (revision 40918) +++ forgon-core/src/main/java/com/forgon/security/service/UserManagerImpl.java (.../UserManagerImpl.java) (revision 41176) @@ -863,93 +863,9 @@ if(StringUtils.isNotBlank(barcode) && barcode.matches("^01[0-9]{7,10}$")){ return true; } - String needBeStrongPwdWhenModifyPwd = ConfigUtils.getSystemSetConfigByName("needBeStrongPwdWhenModifyPwd"); - if(StringUtils.isNotBlank(needBeStrongPwdWhenModifyPwd)){ - JSONObject json = JSONObject.fromObject(needBeStrongPwdWhenModifyPwd); - // - int minPwdLength = json.optInt("minPwdLength"); - Boolean containNumber = json.optBoolean("containNumber"); - Boolean containLetter = json.optBoolean("containLetter"); - Boolean containUppercaseLetter = json.optBoolean("containUppercaseLetter"); - Boolean containLowerCaseLetter = json.optBoolean("containLowerCaseLetter"); - Boolean containSpecialChar = json.optBoolean("containSpecialChar"); - // passwordNotContainLoginName（密码包含账号）：值为true密码不可以包含账号，值为false时可以包含账号 - Boolean passwordNotContainLoginName = json.optBoolean("passwordNotContainLoginName", false); - // passwordComplexityReq1：值为true则检查密码至少包含英文字母、数字、特殊字符的其中两种 - Boolean passwordComplexityReq1 = json.optBoolean("passwordComplexityReq1", false); - // windowsPasswordComplexityReq:true：值为true则检查密码至少包含大写字母，小写字母、数字、特殊字符的其中三种 - Boolean windowsPasswordComplexityReq = json.optBoolean("windowsPasswordComplexityReq", false); - - //包含数字 - String numberExp = ".*[0-9].*"; - //包含特殊符号 - String specialCharExp = ".*[^a-zA-Z0-9].*"; - //包含大写字母 - String upperCaseExp = ".*[A-Z].*"; - //包含小写字母 - String lowerCaseExp = ".*[a-z].*"; - // 包含大小写字母 - String upperAndLowerCaseExp = ".*[a-zA-Z].*"; - - if(password.length() < minPwdLength){ - return false; - } - if(containNumber && !match(password, numberExp)){ - return false; - } - if(containLetter && !match(password, upperAndLowerCaseExp)){ - return false; - } - if(containUppercaseLetter && !match(password, upperCaseExp)){ - return false; - } - if(containLowerCaseLetter && !match(password, lowerCaseExp)){ - return false; - } - if(containSpecialChar && !match(password, specialCharExp)){ - return false; - } - if(passwordNotContainLoginName && password.toLowerCase().indexOf(userName.toLowerCase()) != -1){ - return false; - } - - if(windowsPasswordComplexityReq){ - //包含数字，大写，小写 - boolean b1 = match(password, numberExp) && match(password, upperCaseExp) && match(password, lowerCaseExp); - //包含数字，大写，特殊符号 - boolean b2 = match(password, numberExp) && match(password, upperCaseExp) && match(password, specialCharExp); - //包含数字，小写，特殊符号 - boolean b3 = match(password, numberExp) && match(password, lowerCaseExp) && match(password, specialCharExp); - //包含大写，小写，特殊符号 - boolean b4 = match(password, upperCaseExp) && match(password, lowerCaseExp) && match(password, specialCharExp); - if(!b1 && !b2 && !b3 && !b4){ - return false; - } - } - - if(passwordComplexityReq1){ - //包含数字，英文字母 - boolean b1 = match(password, numberExp) && match(password, upperAndLowerCaseExp); - //包含数字，特殊符号 - boolean b2 = match(password, numberExp) && match(password, specialCharExp); - //包含英文字母，特殊符号 - boolean b3 = match(password, upperAndLowerCaseExp) && match(password, specialCharExp); - if(!b1 && !b2 && !b3){ - return false; - } - } - - } - return true; + return ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password); } - private static boolean match(String str, String regex) { - Pattern pattern = Pattern.compile(regex); - Matcher matcher = pattern.matcher(str); - return matcher.matches(); - } - - @Override public void releaseLogonLock(String userId) { User user = this.get(userId); Index: forgon-core/src/main/java/com/forgon/directory/service/PersonalSettingManagerImpl.java =================================================================== diff -u -r40912 -r41176 --- forgon-core/src/main/java/com/forgon/directory/service/PersonalSettingManagerImpl.java (.../PersonalSettingManagerImpl.java) (revision 40912) +++ forgon-core/src/main/java/com/forgon/directory/service/PersonalSettingManagerImpl.java (.../PersonalSettingManagerImpl.java) (revision 41176) @@ -55,18 +55,12 @@ String needBeStrongPwdWhenModifyPwd = ConfigUtils.getSystemSetConfigByName("needBeStrongPwdWhenModifyPwd"); if(StringUtils.isNotBlank(needBeStrongPwdWhenModifyPwd)){ JSONObject json = JSONObject.fromObject(needBeStrongPwdWhenModifyPwd); - // passwordNotContainLoginName（密码包含账号）：值为true密码不可以包含账号，值为false时可以包含账号 - Boolean passwordNotContainLoginName = json.optBoolean("passwordNotContainLoginName", false); - // passwordComplexityReq1：值为true则检查密码是否包含英文字母、0 个基本数字(0 到 9)、非字母字符(例如 !、$、#、%)中的两类字符，不检查是否包含账号 - Boolean passwordComplexityReq1 = json.optBoolean("passwordComplexityReq1", false); - // windowsPasswordComplexityReq:true：值为true则检查密码是否包含英文大写字母(A 到 Z)、英文小写字母(a 到 z)、0 个基本数字(0 到 9)、非字母字符(例如 !、$、#、%)中的两类字符，不检查是否包含账号 - Boolean windowsPasswordComplexityReq = json.optBoolean("windowsPasswordComplexityReq", false); //修改密码前需要校验验证码ZSYY-438 if(smsVerificationCodeManager != null){ smsVerificationCodeManager.validateVerificationCode(user.getName(), user.getSmsVerificationCode(), SmsVerificationCode.SCENE_RESET_PWD); } - if(!passwordComplexityReq1 && !windowsPasswordComplexityReq && passwordNotContainLoginName && user.getPasswd().toLowerCase().indexOf(user.getName().toLowerCase()) != -1){ - throw new SystemException("密码不可以包含账号!"); + if(!ConfigUtils.userPasswordMeetPwdComplexityReq(user.getName(), user.getPasswd(), json)){ + throw new SystemException("密码不符合复杂度要求!"); } } if (remoteManagerClient != null) { Index: ssts-web/src/test/java/test/forgon/tools/AllTests.java =================================================================== diff -u -r26155 -r41176 --- ssts-web/src/test/java/test/forgon/tools/AllTests.java (.../AllTests.java) (revision 26155) +++ ssts-web/src/test/java/test/forgon/tools/AllTests.java (.../AllTests.java) (revision 41176) @@ -4,7 +4,6 @@ import org.junit.runners.Suite; import org.junit.runners.Suite.SuiteClasses; -import test.forgon.tools.concurrent.ConcurrentTest; import test.forgon.tools.crypto.coder.CoderEncryptionTests; import test.forgon.tools.date.DateToolsTests; import test.forgon.tools.format.FormatStringTest; @@ -15,6 +14,7 @@ import test.forgon.tools.json.JsonObjectTest; import test.forgon.tools.json.JsonUtilsTests; import test.forgon.tools.util.BarcodeOperatorsTests; +import test.forgon.tools.util.ConfigUtilsTest; import test.forgon.tools.util.DateUtilTests; import test.forgon.tools.util.ForgonNumberUtilsTest; import test.forgon.tools.util.SqlUtilsTest; @@ -36,7 +36,8 @@ HardWareUtilsTest.class, FormatStringTest.class, DateToolsTests.class, - CoderEncryptionTests.class + CoderEncryptionTests.class, + ConfigUtilsTest.class }) public class AllTests { Index: ssts-web/src/test/java/test/forgon/tools/util/ConfigUtilsTest.java =================================================================== diff -u --- ssts-web/src/test/java/test/forgon/tools/util/ConfigUtilsTest.java (revision 0) +++ ssts-web/src/test/java/test/forgon/tools/util/ConfigUtilsTest.java (revision 41176) @@ -0,0 +1,314 @@ +package test.forgon.tools.util; + +import static org.junit.Assert.*; +import net.sf.json.JSONObject; + +import org.junit.Test; + +import com.forgon.tools.util.ConfigUtils; + +public class ConfigUtilsTest { + + /** + * 密码最小长度 + */ + @Test + public void testUserPasswordMeetPwdComplexityReqMinPwdLength(){ + JSONObject needBeStrongPwdWhenModifyPwd = new JSONObject(); + int minPwdLength = 8; + needBeStrongPwdWhenModifyPwd.put("minPwdLength", minPwdLength); + String userName = "testUserName"; + String password = "12345678"; + assertTrue(ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwd)); + + String msg = null; + try { + userName = "testUserName"; + password = "123"; + ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwd); + } catch (Exception e) { + msg = e.getMessage(); + } + assertEquals(msg, "密码长度最小为" + minPwdLength + "位!"); + } + + /** + * 包含数字 + */ + @Test + public void testUserPasswordMeetPwdComplexityReqContainNumber(){ + JSONObject needBeStrongPwdWhenModifyPwd = new JSONObject(); + needBeStrongPwdWhenModifyPwd.put("containNumber", true); + String userName = "testUserName"; + String password = "abc12345678"; + assertTrue(ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwd)); + + String msg = null; + try { + userName = "testUserName"; + password = "abcdefg"; + ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwd); + } catch (Exception e) { + msg = e.getMessage(); + } + assertEquals(msg, "密码必须包含数字!"); + } + + /** + * 包含包含大小写字母 + */ + @Test + public void testUserPasswordMeetPwdComplexityReqContainLetter(){ + JSONObject needBeStrongPwdWhenModifyPwd = new JSONObject(); + needBeStrongPwdWhenModifyPwd.put("containLetter", true); + String userName = "testUserName"; + String password = "abc12345678"; + assertTrue(ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwd)); + + String msg = null; + try { + + userName = "testUserName"; + password = "12345678"; + ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwd); + } catch (Exception e) { + msg = e.getMessage(); + } + assertEquals(msg, "密码必须包含字母!"); + } + + /** + * 包含包含大写字母 + */ + @Test + public void testUserPasswordMeetPwdComplexityReqContainUppercaseLetter(){ + JSONObject needBeStrongPwdWhenModifyPwd = new JSONObject(); + needBeStrongPwdWhenModifyPwd.put("containUppercaseLetter", true); + String userName = "testUserName"; + String password = "Abc12345678"; + assertTrue(ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwd)); + + String msg = null; + try { + userName = "testUserName"; + password = "abc12345678"; + ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwd); + } catch (Exception e) { + msg = e.getMessage(); + } + assertEquals(msg, "密码必须包含大写字母!"); + } + + /** + * 包含包含小写字母 + */ + @Test + public void testUserPasswordMeetPwdComplexityReqContainLowerCaseLetter(){ + JSONObject needBeStrongPwdWhenModifyPwd = new JSONObject(); + needBeStrongPwdWhenModifyPwd.put("containLowerCaseLetter", true); + String userName = "testUserName"; + String password = "abc12345678"; + assertTrue(ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwd)); + + String msg = null; + try { + userName = "testUserName"; + password = "ABC12345678"; + ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwd); + } catch (Exception e) { + msg = e.getMessage(); + } + assertEquals(msg, "密码必须包含小写字母!"); + } + + /** + * 包含特殊符号 + */ + @Test + public void testUserPasswordMeetPwdComplexityReqContainSpecialChar(){ + JSONObject needBeStrongPwdWhenModifyPwd = new JSONObject(); + needBeStrongPwdWhenModifyPwd.put("containSpecialChar", true); + String userName = "testUserName"; + String password = "abc12345678!"; + assertTrue(ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwd)); + + String msg = null; + try { + userName = "testUserName"; + password = "abc12345678"; + ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwd); + } catch (Exception e) { + msg = e.getMessage(); + } + assertEquals(msg, "密码必须包含特殊字符!"); + } + + /** + * 密码不可以包含账号 + */ + @Test + public void testUserPasswordMeetPwdComplexityReqPasswordNotContainLoginName(){ + JSONObject needBeStrongPwdWhenModifyPwd = new JSONObject(); + needBeStrongPwdWhenModifyPwd.put("passwordNotContainLoginName", true); + String userName = "testUserName"; + String password = "abc12345678!"; + assertTrue(ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwd)); + + String msg = null; + try { + userName = "testUserName"; + password = "abc12345678testUserName"; + ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwd); + } catch (Exception e) { + msg = e.getMessage(); + } + assertEquals(msg, "密码不可以包含账号!"); + } + + /** + * passwordComplexityReq1：值为true则检查密码至少包含英文字母、数字、特殊字符的其中两种 + */ + @Test + public void testUserPasswordMeetPwdComplexityReqPasswordComplexityReq1(){ + JSONObject needBeStrongPwdWhenModifyPwd = new JSONObject(); + needBeStrongPwdWhenModifyPwd.put("passwordComplexityReq1", true); + //包含数字，英文字母 + String userName = "testUserName"; + String password = "abc12345678"; + assertTrue(ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwd)); + + //包含数字，特殊符号 + userName = "testUserName"; + password = "12345678!"; + assertTrue(ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwd)); + + //包含英文字母，特殊符号 + userName = "testUserName"; + password = "abc!"; + assertTrue(ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwd)); + + //只包含数字 + String msg = null; + try { + userName = "testUserName"; + password = "12345678"; + ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwd); + } catch (Exception e) { + msg = e.getMessage(); + } + assertEquals(msg, "密码强度不够，至少包含英文字母、数字、特殊字符的其中两种!"); + } + + /** + * windowsPasswordComplexityReq:true：值为true则检查密码至少包含大写字母，小写字母、数字、特殊字符的其中三种 + */ + @Test + public void testUserPasswordMeetPwdComplexityReqWindowsPasswordComplexityReq(){ + JSONObject needBeStrongPwdWhenModifyPwd = new JSONObject(); + needBeStrongPwdWhenModifyPwd.put("windowsPasswordComplexityReq", true); + //包含数字，大写，小写 + String userName = "testUserName"; + String password = "123ABCabc"; + assertTrue(ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwd)); + + //包含数字，大写，特殊符号 + userName = "testUserName"; + password = "123ABC!"; + assertTrue(ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwd)); + + //包含大写，小写，特殊符号 + userName = "testUserName"; + password = "ABCabc!"; + assertTrue(ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwd)); + + //只包含数字 + String msg = null; + try { + userName = "testUserName"; + password = "12345678"; + ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwd); + } catch (Exception e) { + msg = e.getMessage(); + } + assertEquals(msg, "密码强度不够，至少包含大写字母，小写字母、数字、特殊字符的其中三种!"); + } + + /** + * blacklistPatterns：数组元素，可以定义弱密码黑名单及禁用的连续字符； + */ + @Test + public void testUserPasswordMeetPwdComplexityReqBlacklistPatterns(){ + JSONObject needBeStrongPwdWhenModifyPwd = new JSONObject(); + String blacklistPattern = "123456"; + needBeStrongPwdWhenModifyPwd.put("blacklistPatterns", "['" + blacklistPattern + "', 'admin', 'test']"); + //不包含禁用的连续字符 + String userName = "testUserName"; + String password = "123ABCabc"; + assertTrue(ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwd)); + + //包含禁用的连续字符 + String msg = null; + try { + userName = "testUserName"; + password = blacklistPattern + "78"; + ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwd); + } catch (Exception e) { + msg = e.getMessage(); + } + assertEquals(msg, "密码不可以包含" + blacklistPattern + "!"); + } + + /** + * customRegex（自定义正则校验表达式）：可以设置自定义的正则校验表达式 + */ + @Test + public void testUserPasswordMeetPwdComplexityReqCustomRegex(){ + JSONObject needBeStrongPwdWhenModifyPwd = new JSONObject(); + //口令不能包含123456、admin、test、qweasd、qwezxc、147258、13579、zsyy、Zsyy、ZSYY、abc、123、qwe相关连续字符。 + needBeStrongPwdWhenModifyPwd.put("customRegex", "^((?!.*(?:123|admin|test|qwe|asd|zxc|abc|147|258|13579|zsyy|Zsyy|ZSYY)).)*$"); + //满足自定义正则校验表达式 + String userName = "testUserName"; + String password = "p2ssword"; + assertTrue(ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwd)); + + //不满足自定义正则校验表达式 + String msg = null; + try { + userName = "testUserName"; + password = "admin123"; + ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwd); + } catch (Exception e) { + msg = e.getMessage(); + } + assertEquals(msg, "密码不满足自定义正则表达式!"); + } + + /** + * customRegex（自定义正则校验表达式）：可以设置自定义的正则校验表达式 + */ + @Test + public void testUserPasswordMeetPwdComplexityReqCustomRegex2(){ + JSONObject needBeStrongPwdWhenModifyPwd = new JSONObject(); + //口令长度不低于10位，需要包含字母（不区分大小写）、数字、特殊字符三种 + //^(?=.*[0-9])(?=.*[a-zA-Z])(?=.*[^a-zA-Z0-9]).{10,}$ + //^(?=.*[a-zA-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{10,}$ + needBeStrongPwdWhenModifyPwd.put("customRegex", "^(?=.*[a-zA-Z])(?=.*[0-9])(?=.*[@$!%*?&])[A-Za-z0-9@$!%*?&]{10,}$"); + //needBeStrongPwdWhenModifyPwd.put("customRegex", "^(?=.*[0-9])(?=.*[a-zA-Z])(?=.*[^a-zA-Z0-9]).{10,}$"); + //满足自定义正则校验表达式 + String userName = "testUserName"; + String password = "1234567890a!"; + assertTrue(ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwd)); + + //不满足自定义正则校验表达式 + String msg = null; + try { + userName = "testUserName"; + password = "1234567890"; + ConfigUtils.userPasswordMeetPwdComplexityReq(userName, password, needBeStrongPwdWhenModifyPwd); + } catch (Exception e) { + msg = e.getMessage(); + } + assertEquals(msg, "密码不满足自定义正则表达式!"); + } + +}