Struct LengthComplexityRule 

pub struct LengthComplexityRule { /* private fields */ }

Rule for determining if a password contains the desired complexity for a certain length. In order to meet the criteria of this rule, passwords must meet all the supplied rules for a given password length.

Example

 use passay_rs::rule::PasswordData;
 use passay_rs::rule::illegal_sequence::IllegalSequenceRule;
 use passay_rs::rule::sequence_data::EnglishSequenceData;
 use passay_rs::rule::character::CharacterRule;
 use passay_rs::rule::character_data::EnglishCharacterData;
 use passay_rs::rule::character_characteristics::CharacterCharacteristics;
 use passay_rs::rule::length_complexity::LengthComplexityRule;
 use passay_rs::rule::length::LengthRule;
 use passay_rs::rule::repeat_character::RepeatCharacterRule;
 use passay_rs::rule::username::UsernameRule;
 use passay_rs::rule::Rule;

  let char_rules = vec![
     CharacterRule::new(Box::new(EnglishCharacterData::Digit), 1).unwrap(),
     CharacterRule::new(Box::new(EnglishCharacterData::Special), 1).unwrap(),
     CharacterRule::new(Box::new(EnglishCharacterData::UpperCase), 1).unwrap(),
     CharacterRule::new(Box::new(EnglishCharacterData::LowerCase), 1).unwrap(),
 ];

 let rules: Vec<Box<dyn Rule>> = vec![
     Box::new(LengthRule::new(8, 64)),
     Box::new(
         CharacterCharacteristics::with_rules_and_characteristics(char_rules, 4).unwrap(),
     ),
     Box::new(UsernameRule::with_match_backwards_and_ignore_case(
         true, true,
     )),
     Box::new(IllegalSequenceRule::with_sequence_data(
         EnglishSequenceData::Alphabetical,
     )),
     Box::new(IllegalSequenceRule::with_sequence_data(
         EnglishSequenceData::Numerical,
     )),
     Box::new(IllegalSequenceRule::with_sequence_data(
         EnglishSequenceData::USQwerty,
     )),
     Box::new(RepeatCharacterRule::default()),
 ];
 let mut rule = LengthComplexityRule::default();
 let _ = rule.add_rules(0..12, rules);

 let char_rules = vec![
     CharacterRule::new(Box::new(EnglishCharacterData::Digit), 1).unwrap(),
     CharacterRule::new(Box::new(EnglishCharacterData::UpperCase), 1).unwrap(),
     CharacterRule::new(Box::new(EnglishCharacterData::LowerCase), 1).unwrap(),
 ];
 let rules: Vec<Box<dyn Rule>> = vec![
     Box::new(LengthRule::new(8, 64)),
     Box::new(
         CharacterCharacteristics::with_rules_and_characteristics(char_rules, 3).unwrap(),
     ),
     Box::new(UsernameRule::with_match_backwards_and_ignore_case(
         true, true,
     )),
     Box::new(IllegalSequenceRule::with_sequence_data(
         EnglishSequenceData::Alphabetical,
     )),
     Box::new(IllegalSequenceRule::with_sequence_data(
         EnglishSequenceData::Numerical,
     )),
     Box::new(IllegalSequenceRule::with_sequence_data(
         EnglishSequenceData::USQwerty,
     )),
     Box::new(RepeatCharacterRule::default()),
 ];
 let _ = rule.add_rules(12..16, rules);

 let char_rules = vec![
     CharacterRule::new(Box::new(EnglishCharacterData::UpperCase), 1).unwrap(),
     CharacterRule::new(Box::new(EnglishCharacterData::LowerCase), 1).unwrap(),
 ];
 let rules: Vec<Box<dyn Rule>> = vec![
     Box::new(LengthRule::new(8, 64)),
     Box::new(
         CharacterCharacteristics::with_rules_and_characteristics(char_rules, 2).unwrap(),
     ),
     Box::new(UsernameRule::with_match_backwards_and_ignore_case(
         true, true,
     )),
     Box::new(IllegalSequenceRule::with_sequence_data(
         EnglishSequenceData::Alphabetical,
     )),
     Box::new(IllegalSequenceRule::with_sequence_data(
         EnglishSequenceData::Numerical,
     )),
     Box::new(IllegalSequenceRule::with_sequence_data(
         EnglishSequenceData::USQwerty,
     )),
     Box::new(RepeatCharacterRule::default()),
 ];
 let _ = rule.add_rules(16..20, rules);

 let rules: Vec<Box<dyn Rule>> = vec![
     Box::new(LengthRule::new(8, 64)),
     Box::new(UsernameRule::with_match_backwards_and_ignore_case(
         true, true,
     )),
     Box::new(IllegalSequenceRule::with_sequence_data(
         EnglishSequenceData::Alphabetical,
     )),
     Box::new(IllegalSequenceRule::with_sequence_data(
         EnglishSequenceData::Numerical,
     )),
     Box::new(IllegalSequenceRule::with_sequence_data(
         EnglishSequenceData::USQwerty,
     )),
     Box::new(RepeatCharacterRule::default()),
 ];
 let _ = rule.add_rules(20..128, rules);

 let password = PasswordData::with_password_and_user(
     "rPscvEW2e".to_string(),
     Some("alfred".to_string()),
 );
 let result = rule.validate(&password);
 assert!(!result.valid());

Implementations

impl LengthComplexityRule

pub fn new( rules: HashMap<Range<usize>, Vec<Box<dyn Rule>>>, report_failure: bool, report_rule_failures: bool, ) -> Self

pub fn rules_mut(&mut self) -> &mut HashMap<Range<usize>, Vec<Box<dyn Rule>>>

pub fn add_rules( &mut self, interval: Range<usize>, rules: Vec<Box<dyn Rule>>, ) -> Result<(), String>

Trait Implementations

impl Default for LengthComplexityRule

fn default() -> Self

Returns the “default value” for a type.

impl Rule for LengthComplexityRule

fn validate(&self, password_data: &PasswordData) -> RuleResult

fn as_has_characters(&self) -> Option<&dyn HasCharacters>

fn as_dictionary_rule(&self) -> Option<&dyn DictionaryRuleTrait>