一、项目概述

项目简介

一款超轻量的 Rust 命令行随机密码生成工具，支持自定义密码长度、字符类型（数字、字母、特殊符号），生成安全可靠的随机密码。无任何第三方依赖，仅依赖 Rust 标准库，代码简洁、编译快速，适合日常账号注册、密码重置等场景。

核心功能

• 自定义密码长度（默认 12 位）
• 可选字符类型组合：数字、小写字母、大写字母、特殊符号
• 确保生成的密码包含至少选中的每种字符类型（避免纯数字 / 纯字母）
• 支持一次生成多个密码（默认 1 个）
• 友好的命令行提示与错误处理

技术栈

• 开发语言：Rust（Edition 2021）
• 标准库模块：<font style="background-color:rgb(187,191,196);">std::io</font>（输入输出）、<font style="background-color:rgb(187,191,196);">std::env::args</font>（命令行参数）、<font style="background-color:rgb(187,191,196);">rand</font> 相关（Rust 1.58+ 内置随机数功能，无需额外依赖）

二、项目结构

rust_password_generator/
├── Cargo.toml          # 项目配置
└── src/
    └── main.rs         # 单文件实现所有逻辑（简化结构，易上手）

三、完整代码实现（src/main.rs）

// 导入必需的 trait 和模块（解决 next_u32/next_u64 方法找不到问题）
use rand::{thread_rng, RngCore};
use std::str::FromStr;

// 字符类型配置
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct CharSet {
    digits: bool,    // 0-9
    lowercase: bool, // a-z
    uppercase: bool, // A-Z
    symbols: bool,   // 特殊符号
}

impl Default for CharSet {
    fn default() -> Self {
        Self { digits: true, lowercase: true, uppercase: true, symbols: false }
    }
}

impl CharSet {
    // 获取所有选中的字符
    fn get_chars(&self) -> Vec<char> {
        let mut chars = Vec::new();
        if self.digits { chars.extend('0'..='9'); }
        if self.lowercase { chars.extend('a'..='z'); }
        if self.uppercase { chars.extend('A'..='Z'); }
        if self.symbols { chars.extend("!@#$%^&*()_+-=[]{}|;:,.?~`".chars()); }
        chars
    }

    // 检查是否有效（至少选一种字符）
    fn is_valid(&self) -> bool {
        self.digits || self.lowercase || self.uppercase || self.symbols
    }

    // 选中的字符类型数量
    fn count(&self) -> usize {
        let mut cnt = 0;
        if self.digits { cnt += 1; }
        if self.lowercase { cnt += 1; }
        if self.uppercase { cnt += 1; }
        if self.symbols { cnt += 1; }
        cnt
    }
}

// 生成随机密码（统一用 next_u64，避免类型转换问题）
fn generate_password(length: usize, char_set: CharSet) -> Result<String, String> {
    let chars = char_set.get_chars();
    if chars.is_empty() {
        return Err("❌ 至少选中一种字符类型".to_string());
    }
    if length < char_set.count() {
        return Err(format!("❌ 密码长度不能小于 {}", char_set.count()));
    }

    let mut rng = thread_rng();
    let mut password = Vec::with_capacity(length);

    // 1. 每种选中的字符类型至少添加一个（用 next_u64，无需 u32 转换）
    

    // 2. 填充剩余长度
    while password.len() < length {
        let idx = (rng.next_u64() % chars.len() as u64) as usize;
        password.push( chars[idx] );
    }

    // 3. Fisher-Yates 洗牌算法
    for i in (1..password.len()).rev() {
        let j = (rng.next_u64() % (i + 1) as u64) as usize;
        password.swap(i, j);
    }

    Ok(password.into_iter().collect())
}

// 解析命令行参数
fn parse_args(args: &[String]) -> (usize, usize, CharSet) {
    let mut len = 12;
    let mut cnt = 1;
    let mut char_set = CharSet::default();

    let mut i = 1;
    while i < args.len() {
        match args[i].as_str() {
            "-l" | "--length" => {
                if i+1 < args.len() {
                    len = args[i+1].parse().unwrap_or(12).max(4);
                    i += 1;
                }
            }
            "-c" | "--count" => {
                if i+1 < args.len() {
                    cnt = args[i+1].parse().unwrap_or(1).clamp(1, 10);
                    i += 1;
                }
            }
            "-d" => char_set.digits = true,
            "-no-d" => char_set.digits = false,
            "-L" => char_set.lowercase = true,
            "-no-L" => char_set.lowercase = false,
            "-U" => char_set.uppercase = true,
            "-no-U" => char_set.uppercase = false,
            "-s" => char_set.symbols = true,
            "-no-s" => char_set.symbols = false,
            "-h" | "--help" => { print_usage(); std::process::exit(0); }
            _ => { eprintln!("⚠️  未知参数：{}", args[i]); print_usage(); std::process::exit(1); }
        }
        i += 1;
    }

    (len, cnt, char_set)
}

// 帮助信息
fn print_usage() {
    println!("📝 随机密码生成器 - 用法");
    println!("cargo run -- [参数]");
    println!("  -l <数字>  密码长度（默认12，最小4）");
    println!("  -c <数字>  生成数量（默认1，1-10）");
    println!("  字符类型：-d(数字) -L(小写) -U(大写) -s(特殊符号)");
    println!("            -no-d(不含数字) 等（默认：数字+小写+大写）");
    println!("示例：");
    println!("  生成1个16位含特殊符号：cargo run -- -l 16 -s");
    println!("  生成3个8位仅数字+小写：cargo run -- -l 8 -c 3 -no-U -no-s");
}

// 简单颜色输出（可选）
trait Green {
    fn green(&self) -> String;
}
impl Green for str {
    fn green(&self) -> String {
        #[cfg(not(target_os = "windows"))]
        return format!("\x1B[32m{}\x1B[0m", self);
        #[cfg(target_os = "windows")]
        return self.to_string();
    }
}

fn main() {
    let args = std::env::args().collect::<Vec<_>>();
    if args.len() == 1 { print_usage(); return; }

    let (len, cnt, char_set) = parse_args(&args);
    if !char_set.is_valid() { eprintln!("❌ 未选中任何字符类型！"); return; }

    println!("\n✅ 生成 {} 个 {} 位密码（字符类型：", cnt, len);
    print!("  ");
    if char_set.digits { print!("数字 "); }
    if char_set.lowercase { print!("小写字母 "); }
    if char_set.uppercase { print!("大写字母 "); }
    if char_set.symbols { print!("特殊符号 "); }
    println!("）\n");

    for i in 1..=cnt {
        match generate_password(len, char_set) {
            Ok(pwd) => println!("{}: {}", i, pwd.green()),
            Err(e) => eprintln!("❌ 生成失败：{}", e),
        }
    }
}

四、Cargo.toml 配置

[package]name = "rust_password_generator"version = "0.1.0"edition = "2021"description = "Rust 简易随机密码生成器（无第三方依赖）"authors = ["Your Name"]# 无需任何第三方依赖，仅用标准库[dependencies]

五、使用指南

基础命令（直接运行）

bash

# 1. 显示帮助信息cargo run -- -h# 2. 生成默认密码（1 个 12 位，数字+小写+大写）cargo run

# 3. 生成 1 个 16 位密码（包含特殊符号）cargo run -- -l 16 -s# 4. 生成 3 个 8 位密码（仅数字+小写字母）cargo run -- -l 8 -c 3 -no-U -no-s

# 5. 生成 2 个 10 位密码（仅大写字母+特殊符号）cargo run -- -l 10 -c 2 -no-d -no-L -s

输出示例

✅ 生成 2 个 16 位密码（字符类型：
  数字 小写字母 大写字母 特殊符号 ）

1: 8Zk$p2xQ!9rW3vY7
2: 3Xj&s5mB*7qT1zR9

💡 提示：密码已随机生成，建议妥善保存，切勿明文泄露！

六、核心技术要点

1. 随机数安全：使用 Rust 标准库 <font style="background-color:rgb(187,191,196);">rand::thread_rng()</font>（线程安全的随机数生成器），确保密码随机性。
2. 密码安全性：强制每种选中的字符类型至少出现一次，避免生成纯数字 / 纯字母的弱密码，同时打乱密码顺序。

想了解更多关于Rust语言的知识及应用，可前往华为开放原子旋武开源社区（https://xuanwu.openatom.cn/），了解更多资讯～