/** * Create an instance of {@link StringPolicyType } * */ public StringPolicyType createStringPolicyType() { return new StringPolicyType(); }
public LimitationsType beginLimitations() { LimitationsType value = new LimitationsType(); limitations(value); return value; }
public StringPolicyType characterClass(CharacterClassType value) { setCharacterClass(value); return this; }
public StringPolicyType clone() { StringPolicyType object = new StringPolicyType(); PrismContainerValue value = asPrismContainerValue().clone(); object.setupContainerValue(value); return object; }
public static StringPolicyType normalize(StringPolicyType sp) { if (null == sp) { throw new IllegalArgumentException("Providide string policy cannot be null"); } if (null == sp.getLimitations()) { LimitationsType sl = new LimitationsType(); sl.setCheckAgainstDictionary(false); sl.setCheckPattern(""); sl.setMaxLength(Integer.MAX_VALUE); sl.setMinLength(0); sl.setMinUniqueChars(0); sp.setLimitations(sl); } // Add default char class if (null == sp.getCharacterClass()) { CharacterClassType cct = new CharacterClassType(); cct.setValue(ASCII7_CHARS); sp.setCharacterClass(cct); } return sp; }
policy = new ValuePolicyType().stringPolicy(new StringPolicyType().limitations(new LimitationsType().maxLength(defaultLength).minLength(defaultLength))); if (stringPolicy.getLimitations() != null && stringPolicy.getLimitations().getMaxAttempts() != null) { maxAttempts = stringPolicy.getLimitations().getMaxAttempts();
private boolean isNotEmptyMinLength(ValuePolicyType policy) { StringPolicyType stringPolicy = policy.getStringPolicy(); if (stringPolicy == null) { return false; } Integer minLength = stringPolicy.getLimitations().getMinLength(); if (minLength != null) { if (minLength.intValue() == 0) { return false; } return true; } return false; }
int unique = defaultLength / 2; if (stringPolicy != null) { for (StringLimitType l : stringPolicy.getLimitations().getLimit()) { if (null != l.getCharacterClass().getValue()) { lims.put(l, StringPolicyUtils.stringTokenizer(l.getCharacterClass().getValue())); } else { lims.put(l, StringPolicyUtils.stringTokenizer(StringPolicyUtils.collectCharacterClass( stringPolicy.getCharacterClass(), l.getCharacterClass().getRef()))); minLen = defaultIfNull(stringPolicy.getLimitations().getMinLength(), 0); if (minLen != 0 && minLen > defaultLength) { defaultLength = minLen; maxLen = defaultIfNull(stringPolicy.getLimitations().getMaxLength(), 0); unique = defaultIfNull(stringPolicy.getLimitations().getMinUniqueChars(), minLen); result.recordFatalError( "No intersection for required first character sets in value policy:" + stringPolicy.getDescription()); + stringPolicy.getDescription() + "] following character limitation and sets are used:"); for (StringLimitType l : mustBeFirst.keySet()) {
@Test public void stringPolicyUtilsMinimalTest() throws JAXBException, SchemaException, IOException { File file = new File(TEST_DIR, "password-policy-minimal.xml"); ValuePolicyType pp = (ValuePolicyType) PrismTestUtil.parseObject(file).asObjectable(); StringPolicyType sp = pp.getStringPolicy(); StringPolicyUtils.normalize(sp); AssertJUnit.assertNotNull(sp.getCharacterClass()); AssertJUnit.assertNotNull(sp.getLimitations().getLimit()); AssertJUnit.assertTrue(Integer.MAX_VALUE == sp.getLimitations().getMaxLength()); AssertJUnit.assertTrue(0 == sp.getLimitations().getMinLength()); AssertJUnit.assertTrue(0 == " !\"#$%&'()*+,-.01234567890:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~" .compareTo(sp.getCharacterClass().getValue())); }
@Override public boolean equals(Object object) { if (!(object instanceof StringPolicyType)) { return false; } StringPolicyType other = ((StringPolicyType) object); return asPrismContainerValue().equivalent(other.asPrismContainerValue()); }
public StringPolicyType limitations(LimitationsType value) { setLimitations(value); return this; }
private HashSet<String> getValidCharacters(CharacterClassType characterClassType, ValuePolicyType passwordPolicy) { if (null != characterClassType.getValue()) { return new HashSet<>(StringPolicyUtils.stringTokenizer(characterClassType.getValue())); } else { return new HashSet<>(StringPolicyUtils.stringTokenizer(StringPolicyUtils .collectCharacterClass(passwordPolicy.getStringPolicy().getCharacterClass(), characterClassType.getRef()))); } }
private void assertGeneratedValue(String value, ValuePolicyType valuePolicy, String pattern, boolean ignoreMin, boolean ignoreMax) { StringPolicyType stringPolicy = valuePolicy.getStringPolicy(); if (stringPolicy == null) { assertEquals("Unexpected generated value length", GenerateExpressionEvaluator.DEFAULT_LENGTH, value.length()); } else { if (!ignoreMin) { assertTrue("Value '"+value+"' too short, minLength="+stringPolicy.getLimitations().getMinLength()+", length="+value.length(), value.length() >= stringPolicy.getLimitations().getMinLength()); } if (!ignoreMax) { assertTrue("Value '"+value+"' too long, maxLength="+stringPolicy.getLimitations().getMaxLength()+", length="+value.length(), value.length() <= stringPolicy.getLimitations().getMaxLength()); } // TODO: better validation } if (pattern != null) { assertTrue("Value '"+value+"' does not match pattern '"+pattern+"'", value.matches(pattern)); } }
@Override public int hashCode() { return asPrismContainerValue().hashCode(); }
/** * Create an instance of {@link StringPolicyType } * */ public StringPolicyType createStringPolicyType() { return new StringPolicyType(); }
private <O extends ObjectType> boolean checkAttempt(String generatedValue, ValuePolicyType policy, AbstractValuePolicyOriginResolver<O> originResolver, String shortDesc, Task task, OperationResult result) throws SchemaException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { StringPolicyType stringPolicy = policy.getStringPolicy(); if (stringPolicy != null) { LimitationsType limitationsType = stringPolicy.getLimitations(); if (limitationsType != null) { List<CheckExpressionType> checkExpressionTypes = limitationsType.getCheckExpression(); if (!checkExpressions(generatedValue, checkExpressionTypes, originResolver, shortDesc, task, result)) { LOGGER.trace("Check expression returned false for generated value in {}", shortDesc); return false; } } } if (!checkProhibitedValues(generatedValue, policy.getProhibitedValues(), originResolver, null, shortDesc, task, result)) { LOGGER.trace("Generated value is prohibited in {}", shortDesc); return false; } // TODO Check pattern return true; }
@XmlElement(name = "limitations") public LimitationsType getLimitations() { return PrismForJAXBUtil.getPropertyValue(asPrismContainerValue(), F_LIMITATIONS, LimitationsType.class); }
/** * Create an instance of {@link StringPolicyType } * */ public StringPolicyType createStringPolicyType() { return new StringPolicyType(); }
LimitationsType lims = pp.getStringPolicy().getLimitations();
@XmlElement(name = "description") public String getDescription() { return PrismForJAXBUtil.getPropertyValue(asPrismContainerValue(), F_DESCRIPTION, String.class); }