1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108

use crate::api::PasswordGeneratorCharsParam;
use rand::seq::SliceRandom;
use rand::{thread_rng, Rng};

const LOWERS: &[u8] = b"abcdefghijklmnopqrstuvwxyz";
const UPPERS: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const NUMBERS: &[u8] = b"0123456789";
const SYMBOLS: &[u8] = b"!-+*#_$%&/()=?{}[]()/\\'\"`-,;:.<>";
const AMBIGOUS_CHARS: &[u8] = b"{}[]()/\\'\"`-,;:.<>";
const SIMILAR_CHARS: &[u8] = b"QO01lIB8S5G62ZUV";

pub fn generate_chars(params: &PasswordGeneratorCharsParam) -> String {
  let mut rng = thread_rng();
  let mut pool = Vec::with_capacity(params.num_chars as usize);

  if params.require_upper {
    pool.push(pick_char_from(&mut rng, UPPERS, params));
  }
  if params.require_number {
    pool.push(pick_char_from(&mut rng, NUMBERS, params));
  }
  if params.require_symbol {
    pool.push(pick_char_from(&mut rng, SYMBOLS, params));
  }
  let candidates = create_base_set(params);
  while pool.len() < params.num_chars as usize {
    pool.push(*candidates.choose(&mut rng).unwrap());
  }

  pool.shuffle(&mut rng);

  String::from_utf8(pool).unwrap()
}

fn create_base_set(params: &PasswordGeneratorCharsParam) -> Vec<u8> {
  let mut candidates = Vec::with_capacity(LOWERS.len() + UPPERS.len() + NUMBERS.len() + SYMBOLS.len());

  filter_set(&mut candidates, LOWERS, params);
  if params.include_uppers {
    filter_set(&mut candidates, UPPERS, params);
  }
  if params.include_numbers {
    filter_set(&mut candidates, NUMBERS, params);
  }
  if params.include_symbols {
    filter_set(&mut candidates, SYMBOLS, params);
  }

  candidates
}

fn filter_set(candidates: &mut Vec<u8>, set: &[u8], params: &PasswordGeneratorCharsParam) {
  for ch in set {
    if params.exclude_similar && SIMILAR_CHARS.contains(ch) {
      continue;
    }
    if params.exclude_ambiguous && AMBIGOUS_CHARS.contains(ch) {
      continue;
    }
    candidates.push(*ch);
  }
}

fn pick_char_from<R: Rng>(rng: &mut R, set: &[u8], params: &PasswordGeneratorCharsParam) -> u8 {
  let mut candidates = Vec::with_capacity(set.len());
  filter_set(&mut candidates, set, params);

  *candidates.choose(rng).unwrap()
}

#[cfg(test)]
mod tests {
  use super::*;
  use spectral::prelude::*;

  #[test]
  fn test_generate_chars() {
    let pw1 = generate_chars(&PasswordGeneratorCharsParam {
      num_chars: 14,
      include_uppers: false,
      include_numbers: false,
      include_symbols: false,
      require_number: false,
      require_upper: false,
      require_symbol: false,
      exclude_similar: false,
      exclude_ambiguous: false,
    });

    assert_that(&pw1.len()).is_equal_to(14);
    assert_that(&pw1.chars().all(|ch| ch.is_lowercase())).is_true();

    let pw2: String = generate_chars(&PasswordGeneratorCharsParam {
      num_chars: 20,
      include_uppers: true,
      include_numbers: false,
      include_symbols: false,
      require_number: false,
      require_upper: true,
      require_symbol: false,
      exclude_similar: false,
      exclude_ambiguous: false,
    });

    assert_that(&pw2.len()).is_equal_to(20);
    assert_that(&pw2.chars().any(|ch| ch.is_uppercase())).is_true();
  }
}