Merge "Remove PasswordMetrics.validatePasswordMetrics isPin param" into sc-dev (3f716ff7) · Commits · e / os / android_frameworks_base

core/java/android/app/admin/PasswordMetrics.java

+3 −5

Original line number	Diff line number	Diff line
		@@ -531,7 +531,7 @@ public final class PasswordMetrics implements Parcelable {
		}

		final PasswordMetrics enteredMetrics = computeForPasswordOrPin(password, isPin);
		return validatePasswordMetrics(adminMetrics, minComplexity, isPin, enteredMetrics);
		return validatePasswordMetrics(adminMetrics, minComplexity, enteredMetrics);
		}

		/**
		@@ -539,15 +539,13 @@ public final class PasswordMetrics implements Parcelable {
		*
		* @param adminMetrics - minimum metrics to satisfy admin requirements.
		* @param minComplexity - minimum complexity imposed by the requester.
		* @param isPin - whether it is PIN that should be only digits
		* @param actualMetrics - metrics for password to validate.
		* @return a list of password validation errors. An empty list means the password is OK.
		*
		* TODO: move to PasswordPolicy
		*/
		public static List<PasswordValidationError> validatePasswordMetrics(
		PasswordMetrics adminMetrics, int minComplexity, boolean isPin,
		PasswordMetrics actualMetrics) {
		PasswordMetrics adminMetrics, int minComplexity, PasswordMetrics actualMetrics) {
		final ComplexityBucket bucket = ComplexityBucket.forComplexity(minComplexity);

		// Make sure credential type is satisfactory.
		@@ -561,7 +559,7 @@ public final class PasswordMetrics implements Parcelable {
		return Collections.emptyList(); // Nothing to check for pattern or none.
		}

		if (isPin && actualMetrics.nonNumeric > 0) {
		if (actualMetrics.credType == CREDENTIAL_TYPE_PIN && actualMetrics.nonNumeric > 0) {
		return Collections.singletonList(
		new PasswordValidationError(CONTAINS_INVALID_CHARACTERS, 0));
		}

core/tests/coretests/src/android/app/admin/PasswordMetricsTest.java

+19 −9

Original line number	Diff line number	Diff line
		@@ -30,6 +30,7 @@ import static android.app.admin.PasswordMetrics.validatePasswordMetrics;
		import static com.android.internal.widget.LockPatternUtils.CREDENTIAL_TYPE_NONE;
		import static com.android.internal.widget.LockPatternUtils.CREDENTIAL_TYPE_PASSWORD;
		import static com.android.internal.widget.LockPatternUtils.CREDENTIAL_TYPE_PATTERN;
		import static com.android.internal.widget.LockPatternUtils.CREDENTIAL_TYPE_PIN;

		import static org.junit.Assert.assertEquals;
		import static org.junit.Assert.assertTrue;
		@@ -284,33 +285,42 @@ public class PasswordMetricsTest {
		PasswordMetrics none = new PasswordMetrics(CREDENTIAL_TYPE_NONE);
		PasswordMetrics pattern = new PasswordMetrics(CREDENTIAL_TYPE_PATTERN);
		PasswordMetrics password = new PasswordMetrics(CREDENTIAL_TYPE_PASSWORD);
		PasswordMetrics pin = new PasswordMetrics(CREDENTIAL_TYPE_PIN);

		// To pass minimal length check.
		password.length = 4;
		pin.length = 4;

		// No errors expected, credential is of stronger or equal type.
		assertValidationErrors(
		validatePasswordMetrics(none, PASSWORD_COMPLEXITY_NONE, false, none));
		validatePasswordMetrics(none, PASSWORD_COMPLEXITY_NONE, none));
		assertValidationErrors(
		validatePasswordMetrics(none, PASSWORD_COMPLEXITY_NONE, false, pattern));
		validatePasswordMetrics(none, PASSWORD_COMPLEXITY_NONE, pattern));
		assertValidationErrors(
		validatePasswordMetrics(none, PASSWORD_COMPLEXITY_NONE, false, password));
		validatePasswordMetrics(none, PASSWORD_COMPLEXITY_NONE, password));
		assertValidationErrors(
		validatePasswordMetrics(pattern, PASSWORD_COMPLEXITY_NONE, false, pattern));
		validatePasswordMetrics(none, PASSWORD_COMPLEXITY_NONE, pin));
		assertValidationErrors(
		validatePasswordMetrics(pattern, PASSWORD_COMPLEXITY_NONE, false, password));
		validatePasswordMetrics(pattern, PASSWORD_COMPLEXITY_NONE, pattern));
		assertValidationErrors(
		validatePasswordMetrics(password, PASSWORD_COMPLEXITY_NONE, false, password));
		validatePasswordMetrics(pattern, PASSWORD_COMPLEXITY_NONE, password));
		assertValidationErrors(
		validatePasswordMetrics(password, PASSWORD_COMPLEXITY_NONE, password));
		assertValidationErrors(
		validatePasswordMetrics(pin, PASSWORD_COMPLEXITY_NONE, pin));

		// Now actual credential type is weaker than required:
		assertValidationErrors(
		validatePasswordMetrics(pattern, PASSWORD_COMPLEXITY_NONE, false, none),
		validatePasswordMetrics(pattern, PASSWORD_COMPLEXITY_NONE, none),
		PasswordValidationError.WEAK_CREDENTIAL_TYPE, 0);
		assertValidationErrors(
		validatePasswordMetrics(password, PASSWORD_COMPLEXITY_NONE, none),
		PasswordValidationError.WEAK_CREDENTIAL_TYPE, 0);
		assertValidationErrors(
		validatePasswordMetrics(password, PASSWORD_COMPLEXITY_NONE, false, none),
		validatePasswordMetrics(password, PASSWORD_COMPLEXITY_NONE, pattern),
		PasswordValidationError.WEAK_CREDENTIAL_TYPE, 0);
		assertValidationErrors(
		validatePasswordMetrics(password, PASSWORD_COMPLEXITY_NONE, false, pattern),
		validatePasswordMetrics(password, PASSWORD_COMPLEXITY_NONE, pin),
		PasswordValidationError.WEAK_CREDENTIAL_TYPE, 0);
		}

services/core/java/com/android/server/locksettings/LockSettingsShellCommand.java

+1 −1

Original line number	Diff line number	Diff line
		@@ -311,7 +311,7 @@ class LockSettingsShellCommand extends ShellCommand {
		PasswordMetrics metrics = new PasswordMetrics(
		credential.isPattern() ? CREDENTIAL_TYPE_PATTERN : CREDENTIAL_TYPE_NONE);
		errors = PasswordMetrics.validatePasswordMetrics(
		requiredMetrics, requiredComplexity, false /* isPin */, metrics);
		requiredMetrics, requiredComplexity, metrics);
		}
		if (!errors.isEmpty()) {
		getOutPrintWriter().println(

services/devicepolicy/java/com/android/server/devicepolicy/DevicePolicyManagerService.java

+4 −7

Original line number	Diff line number	Diff line
		@@ -4507,8 +4507,7 @@ public class DevicePolicyManagerService extends BaseIDevicePolicyManager {

		PasswordMetrics metrics = mLockSettingsInternal.getUserPasswordMetrics(parentUser);
		final List<PasswordValidationError> passwordValidationErrors =
		PasswordMetrics.validatePasswordMetrics(
		minMetrics, complexity, false, metrics);
		PasswordMetrics.validatePasswordMetrics(minMetrics, complexity, metrics);
		isSufficient = passwordValidationErrors.isEmpty();
		}
		DevicePolicyEventLogger
		@@ -4585,7 +4584,7 @@ public class DevicePolicyManagerService extends BaseIDevicePolicyManager {
		maxRequiredComplexity = Math.max(maxRequiredComplexity, admin.mPasswordComplexity);
		}
		return PasswordMetrics.validatePasswordMetrics(PasswordMetrics.merge(adminMetrics),
		maxRequiredComplexity, false, metrics).isEmpty();
		maxRequiredComplexity, metrics).isEmpty();
		}
		}

		@@ -4621,8 +4620,7 @@ public class DevicePolicyManagerService extends BaseIDevicePolicyManager {
		final int complexity = getAggregatedPasswordComplexityLocked(userId);
		PasswordMetrics minMetrics = getPasswordMinimumMetricsUnchecked(userId);
		final List<PasswordValidationError> passwordValidationErrors =
		PasswordMetrics.validatePasswordMetrics(
		minMetrics, complexity, false, metrics);
		PasswordMetrics.validatePasswordMetrics(minMetrics, complexity, metrics);
		return passwordValidationErrors.isEmpty();
		}

		@@ -4969,8 +4967,7 @@ public class DevicePolicyManagerService extends BaseIDevicePolicyManager {
		// TODO: Consider changing validation API to take LockscreenCredential.
		if (password.isEmpty()) {
		validationErrors = PasswordMetrics.validatePasswordMetrics(
		minMetrics, complexity, isPin,
		new PasswordMetrics(CREDENTIAL_TYPE_NONE));
		minMetrics, complexity, new PasswordMetrics(CREDENTIAL_TYPE_NONE));
		} else {
		// TODO(b/120484642): remove getBytes() below
		validationErrors = PasswordMetrics.validatePassword(