别再用“大写+数字+感叹号”自欺欺人了！彻底搞懂密码学常识，教你设置“黑客绝望、小学生却背得下”的高强度密码

# ==============================================================================
# pass_guard.ps1 - Windows 11 Zero-Dependency Password Generator & Audit Tool
# 适用于 Windows 11 原生环境 (PowerShell 5.1 / PowerShell 7+)
# ==============================================================================
param(
    [ValidateSet("generate", "audit", "json")]
    [string]$Action = "generate",
    [string]$Mode = "passphrase",     # 'passphrase' 或 'complex'
    [int]$Words = 4,                  # 短语词数
    [int]$Length = 20,                # 复杂密码长度
    [string]$TargetPassword = ""      # 用于审计的密码
)

$WordList = @(
    "amber","anchor","apple","apron","archer","arctic","arrow","atlas","autumn","avalanche",
    "bacon","badger","baker","bamboo","banana","banner","beacon","beaver","beetle","breeze",
    "cactus","camera","candle","canyon","carpet","castle","cedar","clover","comet","compass",
    "dagger","dancer","dawn","desert","diamond","dolphin","dragon","dune","eagle","echo",
    "ember","emerald","falcon","feather","flame","forest","fossil","galaxy","garnet","glacier",
    "golden","granite","harbor","harvest","haven","hawk","hazel","horizon","hunter","iceberg",
    "island","ivory","jaguar","jungle","jupiter","kestrel","knight","lagoon","lantern","leopard",
    "lightning","lotus","lunar","magnet","marble","meadow","meteor","mirage","mountain","nebula",
    "nectar","nomad","oasis","ocean","orchid","panther","pebble","phoenix","planet","portal",
    "pyramid","quartz","radiant","rainbow","ranger","raven","ripple","river","rocket","ruby",
    "safari","sailor","salmon","sapphire","shadow","shield","silver","solstice","spark","spiral",
    "storm","summit","sunrise","sunset","talon","temple","thunder","tiger","titan","topaz",
    "tundra","turtle","twilight","valley","velvet","vessel","viking","voyage","walrus","willow",
    "winter","wizard","wolf","zenith","zephyr"
)

function Get-SecureRandomInt([int]$max) {
    $bytes = New-Object byte[] 4
    [System.Security.Cryptography.RandomNumberGenerator]::Create().GetBytes($bytes)
    $val = [BitConverter]::ToUInt32($bytes, 0)
    return [int]($val % [uint32]$max)
}

function New-SecurePassphrase([int]$numWords) {
    $chosen = @()
    for ($i = 0; $i -lt $numWords; $i++) {
        $idx = Get-SecureRandomInt $WordList.Count
        $chosen += $WordList[$idx]
    }
    $phrase = $chosen -join "-"
    $entropy = [Math]::Round($numWords * [Math]::Log($WordList.Count, 2), 1)
    return [PSCustomObject]@{
        Type = "Passphrase"
        Password = $phrase
        Length = $phrase.Length
        EntropyBits = $entropy
        Memorability = "Excellent"
    }
}

function New-SecureComplex([int]$len) {
    $lower = "abcdefghjkmnpqrstuvwxyz"
    $upper = "ABCDEFGHJKLMNPQRSTUVWXYZ"
    $digits = "23456789"
    $symbols = "!@#$%^&*-_=+"
    $all = $lower + $upper + $digits + $symbols

    $chars = @(
        $lower[(Get-SecureRandomInt $lower.Length)],
        $upper[(Get-SecureRandomInt $upper.Length)],
        $digits[(Get-SecureRandomInt $digits.Length)],
        $symbols[(Get-SecureRandomInt $symbols.Length)]
    )
    for ($i = 4; $i -lt $len; $i++) {
        $chars += $all[(Get-SecureRandomInt $all.Length)]
    }
    # 洗牌
    $shuffled = $chars | Sort-Object { Get-SecureRandomInt 10000 }
    $pwd = $shuffled -join ""
    $entropy = [Math]::Round($len * [Math]::Log($all.Length, 2), 1)
    return [PSCustomObject]@{
        Type = "Complex"
        Password = $pwd
        Length = $pwd.Length
        EntropyBits = $entropy
        Memorability = "Low (Use Password Manager)"
    }
}

function Test-PasswordStrength([string]$pwd) {
    if ([string]::IsNullOrEmpty($pwd)) {
        return @{ Error = "Target password cannot be empty." }
    }
    $len = $pwd.Length
    $hasLower = $pwd -cmatch "[a-z]"
    $hasUpper = $pwd -cmatch "[A-Z]"
    $hasDigit = $pwd -match "[0-9]"
    $hasSymbol = $pwd -match "[^a-zA-Z0-9]"

    $pool = 0
    if ($hasLower) { $pool += 26 }
    if ($hasUpper) { $pool += 26 }
    if ($hasDigit) { $pool += 10 }
    if ($hasSymbol) { $pool += 32 }

    $theoretical = if ($pool -gt 0) { [Math]::Round($len * [Math]::Log($pool, 2), 1) } else { 0 }
    $penalty = 0
    $issues = @()

    $low = $pwd.ToLower()
    $common = @("password", "admin", "root", "123456", "qwerty", "welcome", "login", "888888")
    foreach ($c in $common) {
        if ($low.Contains($c)) {
            $penalty += 25
            $issues += "Contains high-risk predictable root: '$c'"
        }
    }
    if ($pwd -match "(19\d\d|20\d\d)") {
        $penalty += 20
        $issues += "Contains 4-digit year pattern (e.g. 19xx/20xx)"
    }

    $effective = [Math]::Max(5.0, ($theoretical - $penalty))
    $risk = "SECURE"
    $crackTime = "Millions of Years"
    if ($effective -lt 35) {
        $risk = "CRITICAL"
        $crackTime = "< 1 Second (Instant Breach)"
    } elseif ($effective -lt 50) {
        $risk = "HIGH"
        $crackTime = "Few Minutes to Hours"
    } elseif ($effective -lt 65) {
        $risk = "MEDIUM"
        $crackTime = "Days to Months"
    }

    return [PSCustomObject]@{
        PasswordLength = $len
        EffectiveEntropyBits = $effective
        TheoreticalEntropyBits = $theoretical
        RiskLevel = $risk
        EstimatedCrackTime = $crackTime
        DetectedVulnerabilities = $issues
    }
}

# --- 执行入口 ---
if ($Action -eq "audit") {
    $res = Test-PasswordStrength $TargetPassword
    $res | Format-List
} elseif ($Action -eq "json") {
    $gen = if ($Mode -eq "passphrase") { New-SecurePassphrase $Words } else { New-SecureComplex $Length }
    $gen | ConvertTo-Json -Compress
} else {
    Write-Host "=== Windows 11 安全密码生成工具 ===" -ForegroundColor Cyan
    $p = New-SecurePassphrase $Words
    Write-Host "【推荐短语密码】 $($p.Password)" -ForegroundColor Green
    Write-Host "  信息熵: $($p.EntropyBits) bits | 长度: $($p.Length) 字符 | 记忆度: $($p.Memorability)" -ForegroundColor Gray
    Write-Host ""
    $c = New-SecureComplex $Length
    Write-Host "【复杂随机密码】 $($c.Password)" -ForegroundColor Yellow
    Write-Host "  信息熵: $($c.EntropyBits) bits | 长度: $($c.Length) 字符" -ForegroundColor Gray
}

#!/usr/bin/env python3
# ==============================================================================
# pass_guard.py - Ubuntu 26.04 / macOS 26 Zero-Dependency Security Toolkit
# 100% 依赖 Python3 标准库，原生纯净无污染
# ==============================================================================
import sys
import math
import secrets
import string
import json
import re
import argparse

WORD_LIST = [
    "amber", "anchor", "apple", "apron", "archer", "arctic", "arrow", "atlas", "autumn", "avalanche",
    "bacon", "badger", "baker", "bamboo", "banana", "banner", "beacon", "beaver", "beetle", "breeze",
    "cactus", "camera", "candle", "canyon", "carpet", "castle", "cedar", "clover", "comet", "compass",
    "dagger", "dancer", "dawn", "desert", "diamond", "dolphin", "dragon", "dune", "eagle", "echo",
    "ember", "emerald", "falcon", "feather", "flame", "forest", "fossil", "galaxy", "garnet", "glacier",
    "golden", "granite", "harbor", "harvest", "haven", "hawk", "hazel", "horizon", "hunter", "iceberg",
    "island", "ivory", "jaguar", "jungle", "jupiter", "kestrel", "knight", "lagoon", "lantern", "leopard",
    "lightning", "lotus", "lunar", "magnet", "marble", "meadow", "meteor", "mirage", "mountain", "nebula",
    "nectar", "nomad", "oasis", "ocean", "orchid", "panther", "pebble", "phoenix", "planet", "portal",
    "pyramid", "quartz", "radiant", "rainbow", "ranger", "raven", "ripple", "river", "rocket", "ruby",
    "safari", "sailor", "salmon", "sapphire", "shadow", "shield", "silver", "solstice", "spark", "spiral",
    "storm", "summit", "sunrise", "sunset", "talon", "temple", "thunder", "tiger", "titan", "topaz",
    "tundra", "turtle", "twilight", "valley", "velvet", "vessel", "viking", "voyage", "walrus", "willow",
    "winter", "wizard", "wolf", "zenith", "zephyr"
]

def generate_passphrase(words=4, separator='-'):
    chosen = [secrets.choice(WORD_LIST) for _ in range(words)]
    phrase = separator.join(chosen)
    entropy = round(words * math.log2(len(WORD_LIST)), 1)
    return {
        "type": "passphrase",
        "password": phrase,
        "length": len(phrase),
        "entropy_bits": entropy,
        "memorability": "high"
    }

def generate_complex(length=20):
    lower = string.ascii_lowercase
    upper = string.ascii_uppercase
    digits = string.digits
    symbols = "!@#$%^&*-_=+"
    all_chars = lower + upper + digits + symbols

    # 强制包含各字符集至少1个，避免极小概率遗漏
    pwd = [
        secrets.choice(lower),
        secrets.choice(upper),
        secrets.choice(digits),
        secrets.choice(symbols)
    ]
    pwd += [secrets.choice(all_chars) for _ in range(length - 4)]
    secrets.SystemRandom().shuffle(pwd)
    password = ''.join(pwd)
    entropy = round(length * math.log2(len(all_chars)), 1)
    return {
        "type": "complex",
        "password": password,
        "length": len(password),
        "entropy_bits": entropy,
        "memorability": "low (manager required)"
    }

def audit_password(pwd):
    length = len(pwd)
    has_lower = bool(re.search(r'[a-z]', pwd))
    has_upper = bool(re.search(r'[A-Z]', pwd))
    has_digits = bool(re.search(r'[0-9]', pwd))
    has_symbols = bool(re.search(r'[^a-zA-Z0-9]', pwd))

    charset_size = 0
    if has_lower: charset_size += 26
    if has_upper: charset_size += 26
    if has_digits: charset_size += 10
    if has_symbols: charset_size += 32

    theoretical_entropy = round(length * math.log2(charset_size), 1) if charset_size > 0 else 0
    penalty = 0
    issues = []

    low = pwd.lower()
    common_roots = ['password', 'admin', 'root', 'qwerty', '123456', 'welcome', 'login', '888888']
    for root in common_roots:
        if root in low:
            penalty += 25
            issues.append(f'包含高危可预测词根: "{root}"')

    # 简易黑客语变形检测 (Leetspeak)
    leet_map = str.maketrans({'@': 'a', '0': 'o', '1': 'i', '3': 'e', '$': 's', '5': 's', '7': 't'})
    de_leet = low.translate(leet_map)
    for root in common_roots:
        if root in de_leet and root not in low:
            penalty += 20
            issues.append(f'包含可预测黑客语伪装词根: "{root}"')

    if re.search(r'(19\d\d|20\d\d)', pwd):
        penalty += 20
        issues.append('包含 4 位年份规律 (如 19xx / 20xx)')

    effective_entropy = round(max(5.0, theoretical_entropy - penalty), 1)

    if effective_entropy < 35:
        risk = "CRITICAL"
        crack_time = "< 1 秒 (多卡 GPU 集群瞬时秒破)"
    elif effective_entropy < 50:
        risk = "HIGH"
        crack_time = "数分钟至数小时"
    elif effective_entropy < 65:
        risk = "MEDIUM"
        crack_time = "数天至数月"
    else:
        risk = "SECURE"
        crack_time = "数万至数亿年 (数学不可破)"

    return {
        "password_length": length,
        "effective_entropy_bits": effective_entropy,
        "theoretical_entropy_bits": theoretical_entropy,
        "risk_level": risk,
        "estimated_crack_time": crack_time,
        "issues_found": issues
    }

def main():
    parser = argparse.ArgumentParser(description="Zero-Dependency Security Toolkit")
    parser.add_argument("--action", choices=["generate", "audit"], default="generate")
    parser.add_argument("--mode", choices=["passphrase", "complex"], default="passphrase")
    parser.add_argument("--words", type=int, default=4)
    parser.add_argument("--length", type=int, default=20)
    parser.add_argument("--target", type=str, default="", help="Password to audit")
    parser.add_argument("--json", action="store_true", help="Output pure JSON for AI Agent")

    args = parser.parse_args()

    if args.action == "audit":
        res = audit_password(args.target)
        if args.json:
            print(json.dumps(res, ensure_ascii=False))
        else:
            print(f"\n[密码安全审计报告] 目标: {args.target}")
            print(f"• 密码长度: {res['password_length']} 位")
            print(f"• 理论熵值: {res['theoretical_entropy_bits']} bits | 实际有效熵值: {res['effective_entropy_bits']} bits")
            print(f"• 风险等级: {res['risk_level']} | 算力破解耗时: {res['estimated_crack_time']}")
            if res['issues_found']:
                print("• 发现的规律缺陷:")
                for issue in res['issues_found']:
                    print(f"   - {issue}")
            print()
    else:
        if args.mode == "passphrase":
            res = generate_passphrase(args.words)
        else:
            res = generate_complex(args.length)

        if args.json:
            print(json.dumps(res, ensure_ascii=False))
        else:
            print("\n=== 安全密码生成器 (Zero-Dependency) ===")
            print(f"生成的密码 : \033[92m{res['password']}\033[0m")
            print(f"类型       : {res['type']} | 长度: {res['length']} 字符")
            print(f"数学信息熵 : {res['entropy_bits']} bits | 记忆度: {res['memorability']}\n")

if __name__ == "__main__":
    main()

#!/usr/bin/env bash
# ==============================================================================
# pass_guard.sh - One-Click Launcher for Ubuntu 26.04 and macOS 26
# ==============================================================================
set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
PYTHON_BIN="$(command -v python3 || command -v python || true)"

if [ -z "$PYTHON_BIN" ]; then
    echo "[ERROR] Python 3 is required but not installed." >&2
    exit 1
fi

exec "$PYTHON_BIN" "${SCRIPT_DIR}/pass_guard.py" "$@"

chmod +x pass_guard.sh
./pass_guard.sh --mode passphrase --words 4