25124 enforcing password requirements

java/code/src/com/redhat/rhn/common/conf/UserDefaults.java

@@ -20,8 +20,6 @@
  */
 public class UserDefaults {
     private static UserDefaults instance = new UserDefaults();
-    public static final String MAX_PASSWORD_LENGTH = "max_passwd_len";
-    public static final String MIN_PASSWORD_LENGTH = "min_passwd_len";
     public static final String MAX_USER_LENGTH = "max_user_len";
     public static final String MIN_USER_LENGTH = "min_user_len";
     public static final String MAX_EMAIL_LENGTH = "min_email_len";
@@ -33,20 +31,6 @@ public static UserDefaults get() {
         return instance;
     }
 
-    /**
-     * @return the max password length
-     */
-    public int getMaxPasswordLength() {
-        return Config.get().getInt(MAX_PASSWORD_LENGTH, 32);
-    }
-
-    /**
-     * @return the min password length
-     */
-    public int getMinPasswordLength() {
-        return Config.get().getInt(MIN_PASSWORD_LENGTH, 5);
-    }
-
     /**
      * @return the max login name length
      */

java/code/src/com/redhat/rhn/common/util/CryptHelper.java

@@ -16,6 +16,7 @@
 package com.redhat.rhn.common.util;
 
 import com.redhat.rhn.common.conf.UserDefaults;
+import com.redhat.rhn.domain.common.SatConfigFactory;
 
 import org.apache.commons.lang3.RandomStringUtils;
 
@@ -122,7 +123,7 @@ public static String getRandomPasswordForPamAuth() {
         // we set use pam authentication, yet the password field
         // in the database is NOT NULL.  So we have to create this
         // stupid HACK!  Actually this is beyond HACK.
-        return RandomStringUtils.random(UserDefaults.get().getMaxPasswordLength(), 0, 0,
+        return RandomStringUtils.random(SatConfigFactory.getPswCheckLengthMax(), 0, 0,
                 true, true, null, new SecureRandom());
     }
 }

java/code/src/com/redhat/rhn/common/util/validation/password/PasswordPolicy.java

@@ -0,0 +1,108 @@
+package com.redhat.rhn.common.util.validation.password;
+
+import com.redhat.rhn.domain.common.SatConfigFactory;
+
+public class PasswordPolicy {
+    private final boolean upperCharFlag;
+    private final boolean lowerCharFlag;
+    private final boolean digitFlag;
+    private final boolean specialCharFlag;
+    private final String specialChars;
+    private final boolean consecutiveCharsFlag;
+    private final boolean restrictedOccurrenceFlag;
+    private final int maxCharacterOccurrence;
+    private final int minLength;
+    private final int maxLength;
+
+    /**
+     * Class that holds the settings for the user password checks
+     * @param upperCharFlagIn check upper char in password
+     * @param lowerCharFlagIn check lower char in password
+     * @param digitFlagIn check digit in password
+     * @param specialCharFlagIn check special char in password
+     * @param specialCharsIn string with special chars
+     * @param consecutiveCharsFlagIn check consecutive characters
+     * @param restrictedOccurrenceFlagIn check restricted occurrence
+     * @param maxCharacterOccurrenceIn max number of occurrence
+     * @param minLengthIn minimum password length
+     * @param maxLengthIn maximum password length
+     */
+    public PasswordPolicy(
+            boolean upperCharFlagIn, boolean lowerCharFlagIn,
+            boolean digitFlagIn, boolean specialCharFlagIn,
+            String specialCharsIn, boolean consecutiveCharsFlagIn,
+            boolean restrictedOccurrenceFlagIn, int maxCharacterOccurrenceIn,
+            int minLengthIn, int maxLengthIn
+    ) {
+        upperCharFlag = upperCharFlagIn;
+        lowerCharFlag = lowerCharFlagIn;
+        digitFlag = digitFlagIn;
+        specialCharFlag = specialCharFlagIn;
+        specialChars = specialCharsIn;
+        consecutiveCharsFlag = consecutiveCharsFlagIn;
+        restrictedOccurrenceFlag = restrictedOccurrenceFlagIn;
+        maxCharacterOccurrence = maxCharacterOccurrenceIn;
+        minLength = minLengthIn;
+        maxLength = maxLengthIn;
+    }
+
+    public boolean isUpperCharFlag() {
+        return upperCharFlag;
+    }
+
+    public boolean isLowerCharFlag() {
+        return lowerCharFlag;
+    }
+
+    public boolean isDigitFlag() {
+        return digitFlag;
+    }
+
+    public boolean isSpecialCharFlag() {
+        return specialCharFlag;
+    }
+
+    public String getSpecialChars() {
+        return specialChars;
+    }
+
+    public boolean isConsecutiveCharsFlag() {
+        return consecutiveCharsFlag;
+    }
+
+    public boolean isRestrictedOccurrenceFlag() {
+        return restrictedOccurrenceFlag;
+    }
+
+    public int getMaxCharacterOccurrence() {
+        return maxCharacterOccurrence;
+    }
+
+    public int getMinLength() {
+        return minLength;
+    }
+
+    public int getMaxLength() {
+        return maxLength;
+    }
+
+    /**
+     * Helper method to build checks settings from SatConfiguration
+     * @return the settings for the user password settings
+     */
+    public static PasswordPolicy buildPasswordPolicyFromSatFactory() {
+        return new PasswordPolicy(
+                SatConfigFactory.getSatConfigBooleanValue(SatConfigFactory.PSW_CHECK_UPPER_CHAR_FLAG),
+                SatConfigFactory.getSatConfigBooleanValue(SatConfigFactory.PSW_CHECK_LOWER_CHAR_FLAG),
+                SatConfigFactory.getSatConfigBooleanValue(SatConfigFactory.PSW_CHECK_DIGIT_FLAG),
+                SatConfigFactory.getSatConfigBooleanValue(SatConfigFactory.PSW_CHECK_SPECIAL_CHAR_FLAG),
+                SatConfigFactory.getSatConfigValue(SatConfigFactory.PSW_CHECK_SPECIAL_CHARACTERS),
+                SatConfigFactory.getSatConfigBooleanValue(SatConfigFactory.PSW_CHECK_CONSECUTIVE_CHAR_FLAG),
+                SatConfigFactory.getSatConfigBooleanValue(SatConfigFactory.PSW_CHECK_RESTRICTED_OCCURRENCE_FLAG),
+                SatConfigFactory.getSatConfigIntValue(SatConfigFactory.PSW_CHECK_MAX_OCCURRENCE, 2),
+                SatConfigFactory.getSatConfigIntValue(SatConfigFactory.PSW_CHECK_LENGTH_MIN, 4),
+                SatConfigFactory.getSatConfigIntValue(SatConfigFactory.PSW_CHECK_LENGTH_MAX, 32)
+        );
+    }
+
+}

java/code/src/com/redhat/rhn/common/util/validation/password/PasswordPolicyCheckFail.java

@@ -0,0 +1,35 @@
+package com.redhat.rhn.common.util.validation.password;
+
+import com.redhat.rhn.common.localization.LocalizationService;
+import com.redhat.rhn.common.validator.ValidatorError;
+
+public class PasswordPolicyCheckFail {
+    private final String localizedMessageId;
+    private final String configurationParameter;
+
+    protected PasswordPolicyCheckFail(String localizedMessageIdIn, String configurationParameterIn) {
+        localizedMessageId = localizedMessageIdIn;
+        configurationParameter = configurationParameterIn;
+    }
+
+    public String getLocalizedMessageId() {
+        return localizedMessageId;
+    }
+
+    public String getConfigurationParameter() {
+        return configurationParameter;
+    }
+
+    public String getLocalizedErrorMessage() {
+        return LocalizationService.getInstance().getMessage(getLocalizedMessageId(), getConfigurationParameter());
+    }
+
+    /**
+     * Helper method for converting to ValidatorError for UserCommands
+     * @return the validator error
+     */
+    public ValidatorError toValidatorError() {
+        return new ValidatorError(getLocalizedMessageId(), getConfigurationParameter());
+    }
+
+}

java/code/src/com/redhat/rhn/common/util/validation/password/PasswordValidationException.java

@@ -0,0 +1,27 @@
+package com.redhat.rhn.common.util.validation.password;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class PasswordValidationException extends IllegalArgumentException {
+    private final List<PasswordPolicyCheckFail> validationErrors;
+
+    /**
+     * Exception class for password validation
+     * @param validationErrorsIn a list of validation errors
+     */
+    public PasswordValidationException(List<PasswordPolicyCheckFail> validationErrorsIn) {
+        validationErrors = validationErrorsIn;
+    }
+
+    public List<PasswordPolicyCheckFail> getValidationErrors() {
+        return validationErrors;
+    }
+
+    @Override
+    public String getMessage() {
+        return "Password validation errors: " + getValidationErrors().stream()
+                .map(PasswordPolicyCheckFail::getLocalizedMessageId)
+                .collect(Collectors.joining("; "));
+    }
+}