path: root/rust/src/main.rs

use clap::{value_parser, Arg, ArgAction, Command};
use rand::{seq::SliceRandom, Rng};
use std::env;
use std::fs::File;
use std::io::prelude::*;
use std::io::BufReader;
use std::path::Path;
use std::process;
use terminal_size::{terminal_size, Width};

const MAX: u8 = 255;
const RANGE_MAX: u8 = 42;
const RANGE_MIN: u8 = 8;
const PASS_WORDS: u8 = 8;

const LOWER: &str = "abcdefghijklmnopqrstuvwxyz";
const UPPER: &str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const DIGIT: &str = "0123456789";
const OTHER: &str = "!$%&#/()=?+-_,.;:<>[]{}|@*";
const EXTRA: &str = "-_";

const DEF_LENGTH: u8 = 0;
const DEF_NUMBER: u8 = 10;
const DEF_WORDLIST: &str = "/usr/share/dict/words";

struct CommonPrintData<'a> {
    length: u8,
    alpha: &'a Vec<char>,
    alnum: &'a Vec<char>,
    printlen: u8,
    col_width: u8,
    col_num: u16,
}

fn main() {
    let lower = LOWER.chars().collect::<Vec<_>>();
    let upper = UPPER.chars().collect::<Vec<_>>();
    let digit = DIGIT.chars().collect::<Vec<_>>();
    let other = OTHER.chars().collect::<Vec<_>>();
    let extra = EXTRA.chars().collect::<Vec<_>>();
    let alpha = [&lower[..], &upper[..]].concat();
    let alnum = [&alpha[..], &digit[..]].concat();
    let every = [&alnum[..], &other[..]].concat();

    let mut normal = [&alnum[..], &extra[..]].concat();
    let mut special = every;

    let mut length = DEF_LENGTH;
    let mut number = DEF_NUMBER;

    let mut wordlist = DEF_WORDLIST.to_string();

    //
    // env
    // Deal with env before cli-args, because cli-args take precedence.
    //
    let env_length = env::var("MAKEPASS_LENGTH").unwrap_or_default();
    let env_number = env::var("MAKEPASS_NUMBER").unwrap_or_default();
    let env_wordlist = env::var("MAKEPASS_WORDLIST").unwrap_or_default();
    let env_normal = env::var("MAKEPASS_NORMAL").unwrap_or_default();
    let env_special = env::var("MAKEPASS_SPECIAL").unwrap_or_default();

    if !env_length.is_empty() {
        length = env_length.parse().unwrap_or_else(|_| {
            eprintln!(
                "Error: MAKEPASS_LENGTH is not a valid number. Valid numbers are between 0 and 255"
            );
            process::exit(1);
        });
    }
    if !env_number.is_empty() {
        match env_number.parse::<u8>() {
            Ok(n) if n >= 1 => number = n,
            _ => {
                eprintln!("Error: MAKEPASS_NUMBER is not a valid number. Valid numbers are between 1 and 255");
                process::exit(1);
            }
        }
    }
    if !env_wordlist.is_empty() {
        wordlist = env_wordlist;
    }
    if !env_normal.is_empty() {
        normal = env_number.chars().collect::<Vec<_>>();
    }
    if !env_special.is_empty() {
        special = env_special.chars().collect::<Vec<_>>();
    }

    //
    // Args
    //

    let opts = Command::new("makepass")
        .arg(
            Arg::new("length_flag")
                .short('l')
                .value_name("length")
                .help(format!("Length of passwords (0..={MAX}). 0 = random."))
                .value_parser(value_parser!(u8).range(0..)),
        )
        .arg(
            Arg::new("number")
                .short('n')
                .help(format!("Number of passwords (1..={MAX}). [default: 10]"))
                .value_parser(value_parser!(u8).range(1..)),
        )
        .arg(
            Arg::new("printlen")
                .short('p')
                .help("Print length")
                .action(ArgAction::SetTrue),
        )
        .arg(
            Arg::new("length")
                .help(format!(
                    "Length of passwords (0..={MAX}). 0 = random length."
                ))
                .value_parser(value_parser!(u8).range(0..)),
        )
        .get_matches();

    match opts.get_one::<u8>("length_flag") {
        Some(n) => length = *n,
        _ => (),
    }
    match opts.get_one::<u8>("number") {
        Some(n) => number = *n,
        _ => (),
    }
    match opts.get_one::<u8>("length") {
        Some(n) => length = *n,
        _ => (),
    }
    let printbool = if opts.get_flag("printlen") {
        true
    } else {
        false
    };

    //
    // Other logic
    //
    let printlen: u8 = if printbool && length < 100 {
        3
    } else if printbool {
        4
    } else {
        0
    };

    let size = terminal_size();
    let term_width: u16 = match size {
        Some((Width(w), _)) => w,
        None => 1,
    };

    let col_width: u8 = match length {
        0 => RANGE_MAX + 2,
        _ => length + 2,
    };

    let col_num: u16 = match term_width / (col_width + printlen) as u16 {
        0 => 1,
        n => n,
    };

    let data = CommonPrintData {
        length: length,
        alpha: &alpha,
        alnum: &alnum,
        printlen: printlen,
        col_width: col_width,
        col_num: col_num,
    };

    //
    // Do the dirty!
    //

    print_columns("Normal passwords", number, &normal, &data);

    println!("");

    print_columns(
        "Passwords with special characters",
        number / 3 * 2 + 1,
        &special,
        &data,
    );

    if Path::new(&wordlist).exists() {
        println!("");
        println!("Passphrases:");
        let words = read_file(&wordlist);

        for _ in 0..number / 2 {
            println!("{}", passphrase(&words));
        }
    }
}

fn print_columns(title: &str, num: u8, chars: &Vec<char>, data: &CommonPrintData) {
    let mut strings: Vec<String> = Vec::new();
    for _ in 0..num {
        strings.push(randstring(data.length, chars, data.alpha, data.alnum));
    }

    println!("{}:", title);

    let mut i: u16 = 0;
    for s in &strings {
        i = i + 1;

        if data.printlen > 0 {
            print!("{1:00$} ", (data.printlen - 1) as usize, s.len());
        }
        print!("{1:<0$}", data.col_width as usize, s);
        if (i % data.col_num == 0) || (i == num as u16 && i % data.col_num > 0) {
            println!("");
        }
    }
}

fn randstring(len: u8, chars: &Vec<char>, alpha: &Vec<char>, alnum: &Vec<char>) -> String {
    let mut rng = rand::thread_rng();
    let length = if len == 0 {
        rng.gen_range(RANGE_MIN..RANGE_MAX)
    } else {
        len
    };

    let mut s = String::with_capacity(length as usize);
    for i in 0..length {
        if i == 0 {
            s.push(*alpha.choose(&mut rng).unwrap());
        } else if i == length - 1 {
            s.push(*alnum.choose(&mut rng).unwrap());
        } else {
            s.push(*chars.choose(&mut rng).unwrap());
        }
    }
    s
}

fn read_file(filename: &str) -> Vec<String> {
    let file = File::open(filename).unwrap();
    let reader = BufReader::new(file);

    reader.lines().map(|l| l.unwrap()).collect()
}

fn passphrase(wordlist: &Vec<String>) -> String {
    let mut rng = rand::thread_rng();
    (0..PASS_WORDS)
        .map(|_| wordlist.choose(&mut rng).unwrap())
        .cloned()
        .collect::<Vec<_>>()
        .join("-")
}