прочее Парсер user:pass из логов

[corax]

use regex::Regex;
use walkdir::WalkDir;
use zip;

fn main() {
    let mut clear = false;
    let mut em_only = false;
    let mut dirs: Vec<String> = Vec::new();

    let pargs = std::env::args().skip(1);
    for arg in pargs {
        if arg.contains("-clear") || arg.contains("--clear") {
            clear = true;
        } else if arg.contains("-email") || arg.contains("--email") {
            em_only = true;
        } else {
            let meta = std::fs::metadata(&arg).unwrap();
            if meta.is_dir() {
                dirs.push(arg);
            }
        }
    }

    for dir in &dirs {
        for entry in WalkDir::new(dir).into_iter().filter_map(|e| e.ok()) {
            if entry.path().is_file() {
                let filename = entry.path().file_name().unwrap().to_str().unwrap();
                if filename.contains("assword") && filename.ends_with("txt") {
                    let data = std::fs::read_to_string(&entry.path()).unwrap();
                    collect_passwords(data, em_only);
                } else if filename.ends_with("zip") {
                    let reader = std::fs::OpenOptions::new()
                        .read(true)
                        .open(&entry.path())
                        .unwrap();
                    let mut z_file = zip::ZipArchive::new(reader).unwrap();
                    for i in 0..z_file.len() {
                        let mut file = z_file.by_index(i).unwrap();
                        if file.is_file()
                            && file.name().contains("assword")
                            && file.name().ends_with("txt")
                        {
                            let mut data: Vec<u8> = Vec::new();
                            std::io::copy(&mut file, &mut data).unwrap();
                            collect_passwords(
                                std::str::from_utf8_mut(&mut data).unwrap().to_string(),
                                em_only,
                            );
                        }
                    }
                }
            }
        }
    }
    if clear {
        for dir in dirs {
            std::fs::remove_dir_all(dir).unwrap();
        }
    }
}

fn collect_passwords(data: String, em: bool) {
    let re = Regex::new(
        r"^([a-z0-9_+]([a-z0-9_+.]*[a-z0-9_+])?)@([a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,6})",
    )
    .unwrap();
    let mut buf = String::new();
    let lines: Vec<&str> = data.split("\r\n").collect();
    for line in lines {
        if line.starts_with("Username") {
            let u: Vec<&str> = line.split(": ").collect();
            if u.len() != 2 {
                continue;
            }
            buf.push_str(u[1].to_lowercase().as_str());
        } else if line.starts_with("Password") {
            let p: Vec<&str> = line.split(": ").collect();
            if p.len() != 2 {
                continue;
            }
            buf.push_str(":");
            buf.push_str(p[1]);
            buf.push_str("\n");
        }
    }
    let mut creds: Vec<&str> = buf.split("\n").collect();
    creds.dedup();
    creds.pop();
    for i in creds {
        if em {
            if re.is_match(i) {
                println!("{}", i)
            }
        } else {
            println!("{}", i)
        }
    }
}