Skill: liningg/password-manager-pro (version 1.0.0)

--- name: password-manager description: 本地密码管理技能，支持添加、编辑、删除、搜索密码，支持分类管理、备注添加，数据存储在本地，支持导入导出和备份。当用户提到密码、账号、密码管理、保存密码、查找密码时使用此技能。 --- # 密码管理器 ## 概述 这是一个本地化的密码管理技能，帮助用户安全地存储和管理各种账号密码。所有数据存储在用户本地，支持分类管理、备注添加、搜索查找等功能，提供密码强度评估和安全建议。 ## 核心功能 ### 1. 密码管理 **添加密码** - 存储网站/应用名称 - 保存用户名/邮箱 - 保存密码 - 添加备注信息 - 选择分类标签 - 密码强度自动评估 - 创建时间记录 **编辑密码** - 修改用户名 - 更新密码 - 编辑备注 - 调整分类 - 更新修改时间 **删除密码** - 删除单个密码记录 - 批量删除密码 - 删除确认机制 **查看密码** - 查看完整密码信息 - 部分隐藏显示（如：a******b） - 查看密码详情 --- ### 2. 分类管理 **预设分类** - 社交媒体（微博、微信、QQ 等） - 邮箱（Gmail、Outlook、QQ邮箱 等） - 电商购物（淘宝、京东、亚马逊 等） - 金融银行（网银、支付宝、PayPal 等） - 工作相关（公司系统、Slack、钉钉 等） - 娱乐（Steam、Netflix、Spotify 等） - 其他 **自定义分类** - 创建新分类 - 重命名分类 - 删除分类 - 合并分类 **分类操作** - 按分类查看密码 - 分类统计 - 分类密码导出 --- ### 3. 备注管理 **备注内容** - 安全问题答案 - 额外登录信息 - 账户说明 - 重要提示 - 到期提醒 **备注格式** - 支持多行文本 - 支持列表格式 - 支持时间标记 **备注搜索** - 按备注关键词搜索 - 高亮显示匹配内容 --- ### 4. 搜索功能 **搜索方式** - 按网站/应用名称搜索 - 按用户名/邮箱搜索 - 按分类搜索 - 按备注搜索 - 全局搜索 **搜索结果** - 显示匹配的密码记录 - 高亮匹配关键词 - 按相关度排序 - 显示搜索结果数量 --- ### 5. 密码安全 **密码强度评估** - 长度检查（8位以上） - 复杂度检查（大小写、数字、特殊字符） - 重复字符检查 - 常见密码检测 - 强度评分（弱/中/强） **密码生成** - 随机密码生成 - 自定义长度（8-32位） - 自定义字符集 - 避免易混淆字符 **安全建议** - 密码定期更换提醒 - 弱密码警告 - 重复密码提示 - 密码泄露检测建议 --- ### 6. 数据管理 **本地存储** - 所有数据存储在本地文件 - 默认位置：`~/.workbuddy/data/passwords.json` - 支持自定义存储路径 **数据格式** - JSON 格式存储 - 结构化数据 - 易于编辑和备份 **备份与恢复** - 自动备份（每次修改） - 手动备份 - 数据恢复 - 备份文件管理 **导入导出** - 导出为 JSON - 导出为 CSV - 导入 JSON 文件 - 导入 CSV 文件 - 数据格式验证 --- ### 7. 统计报告 **数据统计** - 密码总数 - 各分类数量 - 密码强度分布 - 密码使用时长 **安全报告** - 弱密码列表 - 重复密码列表 - 长期未更改密码 - 安全评分 **使用分析** - 最常用的分类 - 最近添加的密码 - 最近修改的密码 --- ## 使用场景 ### 场景 1：添加新密码 ``` 用户：帮我保存一个密码 助手：🔐 添加密码记录 请提供以下信息： • 网站/应用名称： • 用户名/邮箱： • 密码： • 分类（可选）： • 备注（可选）： 输入完成后，我将为您保存密码记录。 ``` **示例：** ``` 用户：帮我保存我的淘宝账号 助手：🔐 添加密码记录 • 网站/应用名称：淘宝 • 用户名：[REDACTED_SECRET] • 密码：MyP@ssw0rd123 • 分类：电商购物 • 备注：常用购物账号，绑定了手机 ✅ 密码已保存！ • 密码强度：强 • 分类：电商购物 • 创建时间：2026-03-24 21:15 ``` --- ### 场景 2：查找密码 ``` 用户：查找我的 Gmail 密码 助手：🔍 查找密码 找到 1 条记录： 📧 Gmail • 用户名：[REDACTED_SECRET] • 密码：a******d • 分类：邮箱 • 备注：主要工作邮箱 • 创建时间：2026-01-15 需要查看完整密码吗？（回复"查看"或"取消"） ``` --- ### 场景 3：编辑密码 ``` 用户：修改我的淘宝密码 助手：✏️ 编辑密码 当前信息： • 网站/应用名称：淘宝 • 用户名：[REDACTED_SECRET] • 密码：MyP@ssw0rd123 • 分类：电商购物 请输入要修改的内容： 1. 用户名 2. 密码 3. 分类 4. 备注 （输入数字选择要修改的项目） ``` --- ### 场景 4：密码生成 ``` 用户：帮我生成一个强密码 助手：🎲 生成密码 密码设置： • 长度：16 位 • 包含：大小写字母 + 数字 + 特殊字符 生成的密码： X7#kL2$mP9!vR4@n 是否使用这个密码？（回复"使用"或"重新生成"） 💡 建议将此密码保存在密码管理器中 ``` --- ### 场景 5：分类管理 ``` 用户：查看我的所有分类 助手：📂 分类列表 当前分类： • 社交媒体 (5) • 邮箱 (3) • 电商购物 (8) • 金融银行 (4) • 工作相关 (6) • 娱乐 (2) • 其他 (3) 总计：31 个密码 需要查看某个分类的密码吗？ ``` --- ### 场景 6：导入导出 ``` 用户：导出我的所有密码 助手：📤 导出密码数据 导出格式： 1. JSON 格式（完整数据） 2. CSV 格式（适合 Excel 查看） （输入数字选择格式） 正在导出... ✅ 导出完成！ • 文件位置：~/.workbuddy/data/passwords_export_20260324.json • 包含记录：31 条 • 文件大小：12.5 KB ``` --- ### 场景 7：安全检查 ``` 用户：检查我的密码安全 助手：🔒 安全检查报告 🔴 发现的问题： 1. 弱密码（2个） - 测试账号：123456 - 临时账户：password 2. 重复密码（3组） - 密码 "abc123" 被 3 个账户使用 - 密码 "test123" 被 2 个账户使用 3. 长期未更改（5个） - Gmail 账号（180天未更改） - ...（其他4个） 💡 建议措施： 1. 修改所有弱密码 2. 为重复密码生成不同的密码 3. 定期更新长期使用的密码 需要为您生成强密码吗？ ``` --- ### 场景 8：批量操作 ``` 用户：删除所有测试账号 助手：🗑️ 批量删除 找到 3 条"测试账号"相关记录： 1. 测试账号 1 ([REDACTED_SECRET]) 2. 测试账号 2 ([REDACTED_SECRET]) 3. 临时测试账户 ([REDACTED_SECRET]) 确认删除这 3 条记录吗？ （回复"确认"或"取消"） ⚠️ 删除操作无法撤销，请谨慎操作 ``` --- ## 数据结构 ### 密码记录格式 ```json { "id": "unique-id", "name": "网站/应用名称", "username": "用户名或邮箱", "password": "加密后的密码", "category": "分类名称", "notes": "备注信息", "created_at": "2026-03-24T21:15:00", "updated_at": "2026-03-24T21:15:00", "strength": "强", "tags": ["标签1", "标签2"] } ``` ### 数据库结构 ```json { "version": "1.0", "created_at": "2026-03-24T00:00:00", "last_updated": "2026-03-24T21:15:00", "categories": [ "社交媒体", "邮箱", "电商购物", "金融银行", "工作相关", "娱乐", "其他" ], "passwords": [ { "id": "1", "name": "Gmail", "username": "[REDACTED_SECRET]", "password": "encrypted_password", "category": "邮箱", "notes": "主要工作邮箱", "created_at": "2026-01-15T10:30:00", "updated_at": "2026-01-15T10:30:00", "strength": "强" } ], "settings": { "auto_backup": true, "backup_interval": "daily", "password_length": 16, "password_complexity": "high" } } ``` --- ## 工作流程 ### 1. 初始化 - 首次使用时创建数据文件 - 设置默认分类 - 初始化设置 ### 2. 日常使用 - 添加密码记录 - 查找密码 - 编辑密码信息 - 备注管理 ### 3. 定期维护 - 安全检查 - 备份数据 - 导出密码 - 密码强度分析 ### 4. 数据迁移 - 导入旧数据 - 导出备份 - 数据格式转换 --- ## 使用建议 ### 密码安全 - ✅ 为每个账户使用不同的密码 - ✅ 使用强密码（至少12位，包含大小写字母、数字、特殊字符） - ✅ 定期更换密码（建议每3-6个月） - ✅ 不要使用个人信息作为密码 - ✅ 不要在多个平台使用相同密码 ### 数据安全 - ✅ 定期备份数据 - ✅ 将备份文件保存在安全位置 - ✅ 不要分享密码文件 - ✅ 使用加密存储（如果需要） - ✅ 定期检查安全报告 ### 最佳实践 - ✅ 为重要账户添加详细备注 - ✅ 合理使用分类管理 - ✅ 定期进行安全检查 - ✅ 及时删除不再使用的账户 - ✅ 为新账户生成强密码 --- ## 资源目录 ### scripts/ 脚本目录 **核心脚本** - `password_manager.py` - 密码管理核心逻辑 - `password_generator.py` - 密码生成器 - `password_analyzer.py` - 密码强度分析 - `backup_manager.py` - 备份管理 - `import_export.py` - 导入导出功能 **工具脚本** - `security_checker.py` - 安全检查工具 - `duplicate_detector.py` - 重复密码检测 - `category_manager.py` - 分类管理 ### references/ 参考资料 **安全指南** - `password_security_guide.md` - 密码安全指南 - `best_practices.md` - 最佳实践 - `common_mistakes.md` - 常见错误 **数据格式** - `data_schema.md` - 数据格式说明 - `csv_format.md` - CSV 格式说明 ### assets/ 资源文件 **模板** - `export_template.json` - 导出模板 - `export_template.csv` - CSV 导出模板 **示例** - `sample_data.json` - 示例数据 --- ## 重要说明 ### 数据安全 - ⚠️ 本技能默认不加密存储密码 - ⚠️ 建议配合系统的加密功能使用 - ⚠️ 不要将数据文件上传到云端 - ⚠️ 定期备份数据到安全位置 ### 密码安全 - ⚠️ 生成和存储的密码仅在本地 - ⚠️ 确保您的设备安全 - ⚠️ 不要分享密码文件 - ⚠️ 定期更换重要密码 ### 数据隐私 - ✅ 所有数据存储在本地 - ✅ 不向外部服务器传输数据 - ✅ 用户拥有完全的数据控制权 - ✅ 可随时导出或删除数据 --- ## 适用场景 **适用于需要安全存储密码的场景：** - 个人账号密码管理 - 工作账号密码管理 - 多平台密码管理 - 密码安全检查 - 密码备份和恢复 **不适用于：** - 团队密码共享（无权限管理） - 企业级密码管理（无审计功能） - 云端同步（仅本地存储）

path: README.md
content: # 密码管理器技能

## 📦 技能信息

**技能名称：** password-manager  
**版本：** 1.0.0  
**类型：** 用户技能  
**类别：** 工具/安全  
**语言：** 中文  
**适用范围：** 所有 WorkBuddy 项目  

---

## 🎯 技能简介

这是一个本地化的密码管理技能，帮助用户安全地存储和管理各种账号密码。所有数据存储在本地，支持分类管理、备注添加、搜索查找等功能，提供密码强度评估和安全建议。

**核心特性：**
- ✅ 本地存储，数据完全掌控
- ✅ 分类管理，井井有条
- ✅ 添加备注，记录详细信息
- ✅ 搜索查找，快速定位
- ✅ 密码生成，创建强密码
- ✅ 安全检查，发现隐患
- ✅ 导入导出，灵活管理
- ✅ 自动备份，数据安全

---

## 📚 核心功能

### 1. 密码管理
- 添加、编辑、删除密码
- 查看密码信息
- 密码强度自动评估
- 创建和修改时间记录

### 2. 分类管理
- 预设 7 种常用分类
- 自定义创建分类
- 按分类查看和统计

### 3. 备注管理
- 添加详细备注
- 支持多行文本
- 按备注搜索

### 4. 搜索功能
- 全局搜索
- 按字段搜索
- 高亮匹配

### 5. 密码生成
- 随机密码生成
- 自定义长度和复杂度
- 避免易混淆字符

### 6. 安全检查
- 弱密码检测
- 重复密码检测
- 长期未更改提醒
- 安全评分

### 7. 数据管理
- 本地 JSON 存储
- 自动备份
- 导入导出（JSON/CSV）
- 数据格式验证

---

## 📋 使用场景

### 场景 1：添加新密码
```
用户：帮我保存一个淘宝密码
助手：🔐 添加密码记录

      • 网站/应用名称：淘宝
      • 用户名：[REDACTED_SECRET]
      • 密码：MyP@ssw0rd123
      • 分类：电商购物
      • 备注：常用购物账号

      ✅ 密码已保存！密码强度：强
```

### 场景 2：查找密码
```
用户：查找我的 Gmail 密码
助手：🔍 查找密码

      找到 1 条记录：
      📧 Gmail
      • 用户名：[REDACTED_SECRET]
      • 密码：a******d
      • 分类：邮箱

      需要查看完整密码吗？
```

### 场景 3：密码生成
```
用户：帮我生成一个强密码
助手：🎲 生成密码

      生成的密码：
      X7#kL2$mP9!vR4@n

      需要保存这个密码吗？
```

### 场景 4：安全检查
```
用户：检查我的密码安全
助手：🔒 安全检查报告

      🔴 发现的问题：
      • 弱密码：2个
      • 重复密码：3组
      • 长期未更改：5个

      安全评分：65/100

      建议措施：
      1. 修改所有弱密码
      2. 为重复密码生成不同密码
```

---

## 📂 技能结构

```
password-manager/
├── SKILL.md                          # 技能主文件
├── README.md                         # 技能说明
├── scripts/                          # 脚本目录
│   ├── password_manager.py           # 密码管理核心
│   └── password_generator.py        # 密码生成器
└── references/                       # 参考资料
    └── password_security_guide.md   # 密码安全指南
```

---

## 🚀 安装方法

### 方法 1：手动安装
1. 下载 `password-manager.zip` 文件
2. 解压到 `~/.workbuddy/skills/` 目录
3. 重启 WorkBuddy
4. 技能自动加载完成

### 方法 2：通过 SkillHub 安装
1. 打开 WorkBuddy 技能市场
2. 搜索"密码管理器"
3. 点击安装
4. 安装完成即可使用

---

## 💡 使用方法

### 基本操作
```
"帮我保存一个密码"
"查找我的 Gmail 密码"
"修改我的淘宝密码"
"删除测试账号"
```

### 分类管理
```
"查看所有分类"
"添加新分类：游戏"
"删除测试分类"
"查看电商购物分类的所有密码"
```

### 密码生成
```
"帮我生成一个强密码"
"生成一个12位的密码"
"生成一个容易记住的密码"
```

### 安全检查
```
"检查我的密码安全"
"查看弱密码列表"
"检查重复密码"
```

### 数据管理
```
"导出我的密码"
"导入密码文件"
"查看统计信息"
```

---

## 📊 数据结构

### 密码记录格式
```json
{
  "id": "unique-id",
  "name": "网站/应用名称",
  "username": "用户名或邮箱",
  "password": "密码",
  "category": "分类名称",
  "notes": "备注信息",
  "created_at": "创建时间",
  "updated_at": "更新时间",
  "strength": "密码强度"
}
```

### 数据库结构
```json
{
  "version": "1.0",
  "created_at": "创建时间",
  "last_updated": "最后更新",
  "categories": ["分类列表"],
  "passwords": [密码记录数组],
  "settings": {
    "auto_backup": true,
    "backup_interval": "daily"
  }
}
```

---

## 🔒 安全建议

### 数据安全
- ✅ 所有数据存储在本地
- ✅ 定期备份数据
- ✅ 将备份文件保存在安全位置
- ❌ 不要分享密码文件
- ❌ 不要上传到云端

### 密码安全
- ✅ 为每个账户使用不同的密码
- ✅ 使用强密码（12+字符）
- ✅ 定期更换密码
- ❌ 不要使用个人信息
- ❌ 不要使用常见密码

### 最佳实践
- ✅ 为重要账户添加详细备注
- ✅ 合理使用分类管理
- ✅ 定期进行安全检查
- ✅ 及时删除不再使用的账户

---

## ⚠️ 重要说明

### 数据安全
- ⚠️ 本技能默认不加密存储密码
- ⚠️ 建议配合系统的加密功能使用
- ⚠️ 不要将数据文件上传到云端
- ⚠️ 定期备份数据到安全位置

### 适用范围
- ✅ 个人账号密码管理
- ✅ 工作账号密码管理
- ✅ 多平台密码管理
- ❌ 团队密码共享（无权限管理）
- ❌ 企业级密码管理（无审计功能）

---

## 📞 技术支持

### 常见问题

**Q: 数据保存在哪里？**
A: 默认保存在 `~/.workbuddy/data/passwords.json`

**Q: 如何备份数据？**
A: 技能会自动备份，也可以手动导出

**Q: 密码会被加密吗？**
A: 默认不加密，建议配合系统加密功能使用

**Q: 能否导入其他密码管理器的数据？**
A: 支持 JSON 和 CSV 格式的数据导入

**Q: 忘记主密码怎么办？**
A: 数据存储在本地，可以直接查看数据文件

---

## 📄 许可证

本技能为开源项目，遵循 MIT 许可证。

---

## 🙏 致谢

感谢您使用密码管理器技能！

如果您觉得这个技能有用，欢迎：
- ⭐ 给技能打分
- 💬 提供反馈和建议
- 🔗 分享给其他人

**让我们一起让密码管理更安全、更便捷！** 🔐


path: scripts/password_generator.py
content: #!/usr/bin/env python3
"""
密码生成器模块

功能：
- 生成随机强密码
- 自定义密码长度
- 自定义字符集
- 避免易混淆字符
"""

import random
import string
from typing import List


class PasswordGenerator:
    """密码生成器类"""

    def __init__(self):
        """初始化密码生成器"""
        self.lowercase = string.ascii_lowercase
        self.uppercase = string.ascii_uppercase
        self.digits = string.digits
        self.special = "!@#$%^&*()_+-=[]{}|;:,.<>?"

        # 易混淆字符
        self.confusing_chars = "0O1lI"

    def generate_password(
        self,
        length: int = 16,
        use_lowercase: bool = True,
        use_uppercase: bool = True,
        use_digits: bool = True,
        use_special: bool = True,
        avoid_confusing: bool = True
    ) -> str:
        """生成随机密码

        Args:
            length: 密码长度（8-32）
            use_lowercase: 是否包含小写字母
            use_uppercase: 是否包含大写字母
            use_digits: 是否包含数字
            use_special: 是否包含特殊字符
            avoid_confusing: 是否避免易混淆字符

        Returns:
            生成的密码
        """
        # 验证长度
        if length < 8:
            length = 8
        elif length > 32:
            length = 32

        # 构建字符集
        charset = ""

        if use_lowercase:
            chars = self.lowercase
            if avoid_confusing:
                chars = chars.translate(str.maketrans('', '', 'lo'))
            charset += chars

        if use_uppercase:
            chars = self.uppercase
            if avoid_confusing:
                chars = chars.translate(str.maketrans('', '', 'IO'))
            charset += chars

        if use_digits:
            chars = self.digits
            if avoid_confusing:
                chars = chars.translate(str.maketrans('', '', '01'))
            charset += chars

        if use_special:
            charset += self.special

        # 如果字符集为空，使用默认设置
        if not charset:
            charset = self.lowercase + self.digits

        # 生成密码
        password = ''.join(random.choice(charset) for _ in range(length))

        return password

    def generate_memorable_password(
        self,
        word_count: int = 4,
        separator: str = "-"
    ) -> str:
        """生成易记密码（单词组合）

        Args:
            word_count: 单词数量（3-6）
            separator: 分隔符

        Returns:
            生成的密码
        """
        # 验证单词数量
        if word_count < 3:
            word_count = 3
        elif word_count > 6:
            word_count = 6

        # 常用单词列表
        common_words = [
            "apple", "brave", "cloud", "dream", "eagle", "flame",
            "green", "happy", "ice", "jump", "kite", "lion",
            "moon", "night", "ocean", "power", "queen", "rain",
            "star", "tiger", "unity", "victory", "wave", "xray",
            "yellow", "zebra", "bold", "calm", "dark", "fast"
        ]

        # 随机选择单词
        words = random.sample(common_words, word_count)

        # 组合密码
        [REDACTED_SECRET]) for word in words)

        return password

    def generate_pin(self, length: int = 6) -> str:
        """生成 PIN 码

        Args:
            length: PIN 码长度（4-8）

        Returns:
            生成的 PIN 码
        """
        if length < 4:
            length = 4
        elif length > 8:
            length = 8

        return ''.join(random.choice(self.digits) for _ in range(length))

    def generate_passphrase(
        self,
        word_count: int = 5,
        use_numbers: bool = True
    ) -> str:
        """生成密码短语（更安全的单词组合）

        Args:
            word_count: 单词数量（4-8）
            use_numbers: 是否添加数字

        Returns:
            生成的密码短语
        """
        # 更长的单词列表
        words = [
            "correct", "horse", "battery", "staple", "genuine",
            "purple", "orange", "monkey", "banana", "galaxy",
            "planet", "cosmic", "energy", "future", "history",
            "moment", "nature", "ocean", "people", "quiet",
            "reason", "system", "travel", "unique", "vision",
            "weather", "yellow", "zebra", "active", "brave",
            "crystal", "diamond", "emerald", "forest", "golden"
        ]

        if word_count < 4:
            word_count = 4
        elif word_count > 8:
            word_count = 8

        selected_words = random.sample(words, word_count)

        passphrase = ' '.join(word.capitalize() for word in selected_words)

        if use_numbers:
            passphrase += str(random.randint(10, 99))

        return passphrase


def main():
    """主函数 - 用于测试"""
    generator = PasswordGenerator()

    # 测试生成密码
    print("1. 生成随机密码（16位）：")
    print(f"   {generator.generate_password(length=16)}")
    print()

    print("2. 生成易记密码（4个单词）：")
    print(f"   {generator.generate_memorable_password(word_count=4)}")
    print()

    print("3. 生成 PIN 码（6位）：")
    print(f"   {generator.generate_pin(length=6)}")
    print()

    print("4. 生成密码短语（5个单词+数字）：")
    print(f"   {generator.generate_passphrase(word_count=5, use_numbers=True)}")


if __name__ == "__main__":
    main()


path: scripts/password_manager.py
content: #!/usr/bin/env python3
"""
密码管理器 - 核心功能模块

功能：
- 添加、编辑、删除密码
- 搜索和查找密码
- 分类管理
- 数据导入导出
- 备份管理
"""

import json
import os
import uuid
from datetime import datetime
from pathlib import Path
from typing import Dict, List, Optional, Any


class PasswordManager:
    """密码管理器主类"""

    def __init__(self, data_path: Optional[str] = None):
        """初始化密码管理器

        Args:
            data_path: 数据文件路径，默认为 ~/.workbuddy/data/passwords.json
        """
        if data_path is None:
            home = Path.home()
            data_dir = home / ".workbuddy" / "data"
            data_dir.mkdir(parents=True, exist_ok=True)
            self.data_path = data_dir / "passwords.json"
        else:
            self.data_path = Path(data_path)

        self.backup_dir = self.data_path.parent / "backups"
        self.backup_dir.mkdir(parents=True, exist_ok=True)

        self.data = self._load_data()

    def _load_data(self) -> Dict[str, Any]:
        """加载数据文件"""
        if not self.data_path.exists():
            return self._create_empty_data()

        try:
            with open(self.data_path, 'r', encoding='utf-8') as f:
                return json.load(f)
        except Exception as e:
            print(f"加载数据文件失败: {e}")
            return self._create_empty_data()

    def _create_empty_data(self) -> Dict[str, Any]:
        """创建空数据结构"""
        return {
            "version": "1.0",
            "created_at": datetime.now().isoformat(),
            "last_updated": datetime.now().isoformat(),
            "categories": [
                "社交媒体",
                "邮箱",
                "电商购物",
                "金融银行",
                "工作相关",
                "娱乐",
                "其他"
            ],
            "passwords": [],
            "settings": {
                "auto_backup": True,
                "backup_interval": "daily",
                "password_length": 16,
                "password_complexity": "high"
            }
        }

    def _save_data(self) -> bool:
        """保存数据文件"""
        try:
            self.data["last_updated"] = datetime.now().isoformat()

            # 自动备份
            if self.data.get("settings", {}).get("auto_backup", True):
                self._create_backup()

            with open(self.data_path, 'w', encoding='utf-8') as f:
                json.dump(self.data, f, indent=2, ensure_ascii=False)
            return True
        except Exception as e:
            print(f"保存数据文件失败: {e}")
            return False

    def _create_backup(self) -> bool:
        """创建备份文件"""
        try:
            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
            backup_path = self.backup_dir / f"passwords_backup_{timestamp}.json"

            with open(backup_path, 'w', encoding='utf-8') as f:
                json.dump(self.data, f, indent=2, ensure_ascii=False)

            return True
        except Exception as e:
            print(f"创建备份失败: {e}")
            return False

    def add_password(
        self,
        name: str,
        username: str,
        password: str,
        category: str = "其他",
        notes: str = ""
    ) -> Optional[Dict[str, Any]]:
        """添加密码记录

        Args:
            name: 网站/应用名称
            username: 用户名/邮箱
            password: 密码
            category: 分类
            notes: 备注

        Returns:
            添加的密码记录，失败返回 None
        """
        try:
            # 评估密码强度
            strength = self._evaluate_strength(password)

            # 检查分类是否存在
            if category not in self.data["categories"]:
                self.data["categories"].append(category)

            password_entry = {
                "id": str(uuid.uuid4()),
                "name": name,
                "username": username,
                "password": password,
                "category": category,
                "notes": notes,
                "created_at": datetime.now().isoformat(),
                "updated_at": datetime.now().isoformat(),
                "strength": strength
            }

            self.data["passwords"].append(password_entry)

            if self._save_data():
                return password_entry
            return None

        except Exception as e:
            print(f"添加密码失败: {e}")
            return None

    def get_password(self, password_id: str) -> Optional[Dict[str, Any]]:
        """获取密码记录

        Args:
            password_id: 密码记录 ID

        Returns:
            密码记录，不存在返回 None
        """
        for pwd in self.data["passwords"]:
            if pwd["id"] == password_id:
                return pwd
        return None

    def update_password(
        self,
        password_id: str,
        **kwargs
    ) -> bool:
        """更新密码记录

        Args:
            password_id: 密码记录 ID
            **kwargs: 要更新的字段（name, username, password, category, notes）

        Returns:
            是否成功
        """
        try:
            password_entry = self.get_password(password_id)
            if password_entry is None:
                return False

            # 更新字段
            for key, value in kwargs.items():
                if key in password_entry and value is not None:
                    if key == "password":
                        password_entry["strength"] = self._evaluate_strength(value)
                    password_entry[key] = value

            password_entry["updated_at"] = datetime.now().isoformat()

            return self._save_data()

        except Exception as e:
            print(f"更新密码失败: {e}")
            return False

    def delete_password(self, password_id: str) -> bool:
        """删除密码记录

        Args:
            password_id: 密码记录 ID

        Returns:
            是否成功
        """
        try:
            self.data["passwords"] = [
                pwd for pwd in self.data["passwords"]
                if pwd["id"] != password_id
            ]
            return self._save_data()
        except Exception as e:
            print(f"删除密码失败: {e}")
            return False

    def search_passwords(
        self,
        keyword: str,
        search_field: str = "all"
    ) -> List[Dict[str, Any]]:
        """搜索密码记录

        Args:
            keyword: 搜索关键词
            search_field: 搜索字段（all, name, username, category, notes）

        Returns:
            匹配的密码记录列表
        """
        results = []

        for pwd in self.data["passwords"]:
            if search_field == "all":
                # 全局搜索
                search_text = f"{pwd['name']} {pwd['username']} {pwd['category']} {pwd.get('notes', '')}"
                if keyword.lower() in search_text.lower():
                    results.append(pwd)
            else:
                # 按字段搜索
                if search_field in pwd and keyword.lower() in str(pwd[search_field]).lower():
                    results.append(pwd)

        return results

    def get_passwords_by_category(self, category: str) -> List[Dict[str, Any]]:
        """按分类获取密码记录

        Args:
            category: 分类名称

        Returns:
            该分类下的密码记录列表
        """
        return [
            pwd for pwd in self.data["passwords"]
            if pwd["category"] == category
        ]

    def get_all_categories(self) -> List[str]:
        """获取所有分类"""
        return self.data["categories"]

    def add_category(self, category: str) -> bool:
        """添加分类

        Args:
            category: 分类名称

        Returns:
            是否成功
        """
        if category not in self.data["categories"]:
            self.data["categories"].append(category)
            return self._save_data()
        return True

    def delete_category(self, category: str) -> bool:
        """删除分类

        Args:
            category: 分类名称

        Returns:
            是否成功
        """
        try:
            # 将该分类下的密码移动到"其他"分类
            for pwd in self.data["passwords"]:
                if pwd["category"] == category:
                    pwd["category"] = "其他"

            # 删除分类
            self.data["categories"].remove(category)

            return self._save_data()

        except Exception as e:
            print(f"删除分类失败: {e}")
            return False

    def get_statistics(self) -> Dict[str, Any]:
        """获取统计信息

        Returns:
            统计信息字典
        """
        total_passwords = len(self.data["passwords"])
        category_counts = {}
        strength_counts = {"强": 0, "中": 0, "弱": 0}

        for pwd in self.data["passwords"]:
            # 分类统计
            category = pwd["category"]
            category_counts[category] = category_counts.get(category, 0) + 1

            # 强度统计
            strength = pwd.get("strength", "未知")
            if strength in strength_counts:
                strength_counts[strength] += 1

        return {
            "total_passwords": total_passwords,
            "total_categories": len(self.data["categories"]),
            "category_counts": category_counts,
            "strength_counts": strength_counts,
            "last_updated": self.data["last_updated"]
        }

    def _evaluate_strength(self, password: str) -> str:
        """评估密码强度

        Args:
            password: 密码

        Returns:
            强度（强/中/弱）
        """
        score = 0

        # 长度
        if len(password) >= 8:
            score += 1
        if len(password) >= 12:
            score += 1

        # 字符类型
        has_lower = any(c.islower() for c in password)
        has_upper = any(c.isupper() for c in password)
        has_digit = any(c.isdigit() for c in password)
        has_special = any(c in "!@#$%^&*()_+-=[]{}|;:,.<>?" for c in password)

        if has_lower:
            score += 1
        if has_upper:
            score += 1
        if has_digit:
            score += 1
        if has_special:
            score += 1

        # 常见弱密码
        weak_passwords = ["123456", "password", "12345678", "abc123", "111111"]
        if password.lower() in weak_passwords:
            return "弱"

        # 评估
        if score >= 5:
            return "强"
        elif score >= 3:
            return "中"
        else:
            return "弱"

    def export_to_json(self, export_path: str) -> bool:
        """导出为 JSON

        Args:
            export_path: 导出文件路径

        Returns:
            是否成功
        """
        try:
            with open(export_path, 'w', encoding='utf-8') as f:
                json.dump(self.data, f, indent=2, ensure_ascii=False)
            return True
        except Exception as e:
            print(f"导出失败: {e}")
            return False

    def export_to_csv(self, export_path: str) -> bool:
        """导出为 CSV

        Args:
            export_path: 导出文件路径

        Returns:
            是否成功
        """
        try:
            import csv

            with open(export_path, 'w', newline='', encoding='utf-8') as f:
                writer = csv.writer(f)

                # 写入表头
                writer.writerow([
                    "名称",
                    "用户名",
                    "密码",
                    "分类",
                    "备注",
                    "密码强度",
                    "创建时间",
                    "更新时间"
                ])

                # 写入数据
                for pwd in self.data["passwords"]:
                    writer.writerow([
                        pwd["name"],
                        pwd["username"],
                        pwd["password"],
                        pwd["category"],
                        pwd.get("notes", ""),
                        pwd.get("strength", ""),
                        pwd["created_at"],
                        pwd["updated_at"]
                    ])

            return True

        except Exception as e:
            print(f"导出CSV失败: {e}")
            return False

    def import_from_json(self, import_path: str) -> bool:
        """从 JSON 导入

        Args:
            import_path: 导入文件路径

        Returns:
            是否成功
        """
        try:
            with open(import_path, 'r', encoding='utf-8') as f:
                imported_data = json.load(f)

            # 验证数据格式
            if "passwords" not in imported_data:
                print("数据格式错误：缺少 passwords 字段")
                return False

            # 合并数据
            for pwd in imported_data["passwords"]:
                if "id" not in pwd:
                    pwd["id"] = str(uuid.uuid4())

            self.data["passwords"].extend(imported_data["passwords"])

            # 合并分类
            for category in imported_data.get("categories", []):
                if category not in self.data["categories"]:
                    self.data["categories"].append(category)

            return self._save_data()

        except Exception as e:
            print(f"导入失败: {e}")
            return False

    def check_security(self) -> Dict[str, Any]:
        """检查密码安全

        Returns:
            安全检查结果
        """
        weak_passwords = []
        duplicate_passwords = {}
        old_passwords = []

        # 检查弱密码
        for pwd in self.data["passwords"]:
            if pwd.get("strength") == "弱":
                weak_passwords.append(pwd)

        # 检查重复密码
        password_map = {}
        for pwd in self.data["passwords"]:
            password = pwd["password"]
            if password not in password_map:
                password_map[password] = []
            password_map[password].append(pwd["name"])

        for password, names in password_map.items():
            if len(names) > 1:
                duplicate_passwords[password] = names

        # 检查长期未更改（超过90天）
        now = datetime.now()
        for pwd in self.data["passwords"]:
            try:
                updated_at = datetime.fromisoformat(pwd["updated_at"])
                days_old = (now - updated_at).days
                if days_old > 90:
                    old_passwords.append({
                        "name": pwd["name"],
                        "days_old": days_old
                    })
            except:
                pass

        return {
            "weak_passwords": weak_passwords,
            "duplicate_passwords": duplicate_passwords,
            "old_passwords": old_passwords,
            "score": self._calculate_security_score(
                len(weak_passwords),
                len(duplicate_passwords),
                len(old_passwords)
            )
        }

    def _calculate_security_score(
        self,
        weak_count: int,
        duplicate_count: int,
        old_count: int
    ) -> int:
        """计算安全评分（0-100）

        Args:
            weak_count: 弱密码数量
            duplicate_count: 重复密码组数
            old_count: 长期未更改密码数量

        Returns:
            安全评分
        """
        total = len(self.data["passwords"])
        if total == 0:
            return 100

        penalty = 0
        penalty += weak_count * 20  # 每个弱密码扣20分
        penalty += duplicate_count * 15  # 每组重复密码扣15分
        penalty += old_count * 10  # 每个长期未更改密码扣10分

        score = 100 - penalty
        return max(0, score)


def main():
    """主函数 - 用于测试"""
    # 创建密码管理器实例
    pm = PasswordManager()

    # 示例：添加密码
    # pm.add_password(
    #     name="Gmail",
    #     username="[REDACTED_SECRET]",
    #     [REDACTED_SECRET]",
    #     category="邮箱",
    #     notes="主要工作邮箱"
    # )

    # 示例：获取统计信息
    stats = pm.get_statistics()
    print("统计信息：")
    print(f"  总密码数：{stats['total_passwords']}")
    print(f"  分类数：{stats['total_categories']}")
    print(f"  分类统计：{stats['category_counts']}")
    print(f"  强度统计：{stats['strength_counts']}")


if __name__ == "__main__":
    main()


path: references/password_security_guide.md
content: # 密码安全指南

## 密码安全的重要性

在数字化时代，密码是保护我们在线账户和个人信息安全的第一道防线。一个强密码可以有效防止黑客攻击、身份盗窃和数据泄露。

---

## 强密码标准

### 密码长度
- ✅ 最少 12 个字符
- ✅ 推荐 16 个字符或更长
- ❌ 避免 8 个字符以下的密码

### 密码复杂度
一个强密码应该包含：
- ✅ 大写字母（A-Z）
- ✅ 小写字母（a-z）
- ✅ 数字（0-9）
- ✅ 特殊字符（!@#$%^&* 等）

### 密码示例

**弱密码示例：**
```
❌ 123456
❌ password
❌ abc123
❌ qwerty
❌ 123456789
```

**中等密码示例：**
```
⚠️ MyPassword123
⚠️ John@2024
⚠️ Welcome1!
```

**强密码示例：**
```
✅ X7#kL2$mP9!vR4@n
✅ Tr0ub4dor&3
✅ correct-horse-battery-staple
✅ Purple!Elephant99$Rainbow
```

---

## 密码最佳实践

### 1. 为每个账户使用唯一密码
- ✅ 不要在不同平台使用相同密码
- ✅ 每个网站/应用都应该有独立密码
- ❌ 避免使用"万能密码"

### 2. 定期更换密码
- ✅ 重要账户每 3-6 个月更换一次
- ✅ 如果怀疑密码泄露，立即更换
- ✅ 系统提示更换时及时处理

### 3. 避免个人信息
- ❌ 不要使用生日、电话号码
- ❌ 不要使用姓名、昵称
- ❌ 不要使用宠物名字
- ❌ 不要使用常用单词

### 4. 避免常见模式
- ❌ 避免键盘连续（如：qwerty, 123456）
- ❌ 避免重复字符（如：aaaaaa, 111111）
- ❌ 避免简单序列（如：abc123, password1）

### 5. 使用密码管理器
- ✅ 使用本密码管理器存储密码
- ✅ 使用密码管理器生成强密码
- ✅ 定期备份密码数据

---

## 密码强度评估

### 弱密码特征
- 长度少于 8 个字符
- 只包含一种字符类型
- 使用常见单词或模式
- 容易猜测

### 中等密码特征
- 长度 8-12 个字符
- 包含 2-3 种字符类型
- 不使用常见模式
- 混合大小写

### 强密码特征
- 长度 12 个字符以上
- 包含 4 种字符类型
- 随机组合
- 难以猜测

---

## 常见密码攻击方式

### 1. 暴力破解
黑客使用自动化工具尝试所有可能的密码组合。

**防御方法：**
- 使用长密码（12+ 字符）
- 使用复杂字符组合
- 增加密码复杂度

### 2. 字典攻击
黑客使用常用密码列表进行尝试。

**防御方法：**
- 避免使用常见单词
- 避免使用常见组合
- 使用随机字符

### 3. 钓鱼攻击
黑客伪造登录页面，诱骗用户输入密码。

**防御方法：**
- 验证网站 URL
- 使用 HTTPS
- 不要点击可疑链接

### 4. 中间人攻击
黑客拦截用户和服务器之间的通信。

**防御方法：**
- 使用 HTTPS
- 使用 VPN
- 避免公共 Wi-Fi 输入密码

### 5. 社会工程学
黑客通过欺骗手段获取密码。

**防御方法：**
- 不要分享密码
- 警惕可疑请求
- 验证请求者身份

---

## 密码保护建议

### 在线账户
- 为每个账户使用唯一密码
- 启用双重认证（2FA）
- 定期检查账户活动
- 及时更新密码

### 重要账户
- 使用最强密码
- 启用所有安全功能
- 定期更换密码
- 使用密码管理器

### 工作账户
- 遵循公司密码策略
- 不要与个人账户混用
- 离职时及时更改
- 定期更新密码

### 临时账户
- 使用简单密码（如果允许）
- 使用后及时删除
- 不要存储重要信息
- 定期清理

---

## 密码管理技巧

### 记忆密码
- 使用密码短语（如：correct-horse-battery-staple）
- 使用助记符
- 不要写在显眼位置
- 不要分享密码

### 存储密码
- 使用密码管理器
- 不要明文存储
- 定期备份数据
- 加密存储文件

### 更改密码
- 定期更换密码
- 使用强密码替换弱密码
- 更新密码后及时备份
- 通知相关服务

---

## 密码泄漏应对

### 发现密码泄漏后立即采取的行动

1. **立即更换密码**
   - 更改被泄漏账户的密码
   - 更改使用相同密码的其他账户

2. **检查账户活动**
   - 查看登录记录
   - 检查交易记录
   - 查看个人信息

3. **启用安全功能**
   - 启用双重认证（2FA）
   - 设置登录提醒
   - 检查安全设置

4. **通知相关方**
   - 通知银行或支付平台
   - 通知邮件服务商
   - 通知社交平台

5. **监控账户**
   - 持续关注账户活动
   - 检查信用报告
   - 留意可疑邮件

---

## 特殊账户密码建议

### 银行账户
- 使用最强密码
- 定期更换（每 3 个月）
- 启用双重认证
- 不要与其他账户共用密码

### 邮箱账户
- 邮箱通常是其他账户的恢复方式
- 使用强密码
- 启用双重认证
- 定期检查邮箱安全

### 社交媒体
- 定期更换密码
- 启用登录通知
- 检查应用权限
- 不要过度分享个人信息

### 工作账户
- 遵循公司政策
- 使用复杂密码
- 不要与个人账户混用
- 离职时更改密码

---

## 密码管理器使用建议

### 1. 主密码
- 使用最强的密码
- 容易记忆但难以猜测
- 不要与其他密码相同
- 定期更换

### 2. 备份
- 定期备份数据
- 备份到安全位置
- 测试备份文件
- 多重备份

### 3. 更新
- 及时更新软件
- 使用最新版本
- 关注安全公告
- 应用安全补丁

### 4. 访问控制
- 保护密码管理器访问
- 使用自动锁定
- 不要在公共设备使用
- 安全退出

---

## 密码安全检查清单

- [ ] 所有密码都是唯一的
- [ ] 所有密码都是强密码
- [ ] 重要账户启用了双重认证
- [ ] 定期更换密码
- [ ] 密码不包含个人信息
- [ ] 使用密码管理器
- [ ] 定期备份数据
- [ ] 检查密码安全报告
- [ ] 了解常见攻击方式
- [ ] 知道如何应对密码泄漏

---

## 常见问题

**Q: 我记不住那么多强密码怎么办？**
A: 使用密码管理器，只需记住一个主密码即可。

**Q: 双重认证有必要吗？**
A: 非常有必要，即使密码被破解，攻击者仍无法访问账户。

**Q: 定期更换密码真的有用吗？**
A: 有用，特别是在怀疑密码被泄漏的情况下。

**Q: 密码越长越好吗？**
A: 不是，需要在长度和可记忆性之间找到平衡。

**Q: 可以把密码写在纸上吗？**
A: 可以，但要放在安全的地方，不要放在显眼位置。

---

## 总结

密码安全是网络安全的重要组成部分。通过遵循以上指南，您可以大大提高账户安全性：

1. ✅ 使用强密码
2. ✅ 为每个账户使用唯一密码
3. ✅ 定期更换密码
4. ✅ 使用密码管理器
5. ✅ 启用双重认证
6. ✅ 定期检查账户安全
7. ✅ 了解安全威胁
8. ✅ 及时应对安全事件

**记住：您的安全从强密码开始！**


Security scan verdicts — ClawScan: suspicious | static analysis: clean | VirusTotal: clean | SkillSpector: suspicious (CRITICAL)