cURL进度格式化中已弃用strcpy()的安全风险分析

漏洞发现过程

步骤1：定位漏洞代码

1
2
3
4
5


# 在tool_progress.c中查找strcpy使用
grep -n "strcpy" ./src/tool_progress.c

# 输出：
# 94:    strcpy(r, "--:--:--");

步骤2：分析漏洞函数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


static void time2str(char *r, curl_off_t seconds)
{
  curl_off_t h;
  if(seconds <= 0) {
    strcpy(r, "--:--:--");  // ⚠️ 漏洞行94
    return;
  }
  h = seconds / 3600;
  // ... 函数其余部分
}

步骤3：查找函数调用位置

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


# 查找所有time2str调用
grep -n "time2str" ./src/tool_progress.c

# 输出：
# 90:static void time2str(char *r, curl_off_t seconds)
# 260:      time2str(time_left, left);
# 261:      time2str(time_total, est);
# 264:      time2str(time_left, 0);
# 265:      time2str(time_total, 0);
# 267:    time2str(time_spent, spent);

步骤4：追踪缓冲区声明

1
2
3
4


// 调用者缓冲区（在progress_meter函数中）：
char time_left[10];    // 精确分配10字节
char time_total[10];   // 精确分配10字节  
char time_spent[10];   // 精确分配10字节

漏洞描述

根本原因

src/tool_progress.c中第94行的time2str()函数使用不安全的strcpy()将字符串"--:--:--"复制到调用者提供的缓冲区中。分析显示调用者声明了恰好10字节的缓冲区，而字符串需要9字节（8个字符+空终止符），创建了危险的差一错误情况。

技术分析

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


// 调用者缓冲区（在progress_meter函数中）：
char time_left[10];    // 精确分配10字节
char time_total[10];   // 精确分配10字节  
char time_spent[10];   // 精确分配10字节

// 漏洞函数：
static void time2str(char *r, curl_off_t seconds) {
  if(seconds <= 0) {
    strcpy(r, "--:--:--");  // 复制9字节：8字符+空字符
  }
}

// 使用：
time2str(time_left, 0);   // 9字节放入10字节缓冲区

危险性

理论安全性：9字节应适合10字节缓冲区
实际风险：编译器填充、堆栈对齐和架构差异创建不可预测的内存布局
未来风险：如果字符串更改为"---:--:--"（10字符），立即发生缓冲区溢出

影响

安全影响

CVSS评分：6.5（中危）
攻击向量：本地
攻击复杂度：低
所需权限：无
用户交互：无

潜在后果

内存损坏：堆栈溢出导致未定义行为
程序崩溃：进度显示期间的分段错误
信息泄露：潜在的堆栈内容泄漏
内存损坏：特定编译器/架构条件下的潜在堆栈损坏

受影响组件

cURL命令行工具进度显示
所有显示下载/上传进度的操作
交互式和非交互式模式

利用分析

攻击场景

1
2
3
4
5
6
7


// 攻击者创建特殊条件触发漏洞代码
// 当cURL下载未知剩余时间的文件时：

// 正常行为：对未知时间显示"--:--:--"
// 漏洞代码路径：具有精确缓冲区大小的strcpy

// 在特定条件下，这可能损坏相邻的堆栈变量

概念验证利用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


#include <stdio.h>
#include <string.h>
#include <unistd.h>

// 模拟漏洞函数
void time2str_vulnerable(char *r) {
    strcpy(r, "--:--:--");  // 相同的漏洞代码
}

// 模拟具有精确大小缓冲区的调用者
void progress_meter_simulated() {
    char time_buffer[10];        // 精确10字节 - 与实际代码相同
    char sensitive_data[16] = "SECRET_DATA123"; // 堆栈中相邻

    printf("Before: sensitive_data = '%s'\n", sensitive_data);
    printf("Buffer address: %p\n", time_buffer);
    printf("Sensitive data address: %p\n", sensitive_data);

    // 触发漏洞
    time2str_vulnerable(time_buffer);

    printf("After: sensitive_data = '%s'\n", sensitive_data);
    printf("Time buffer: '%s'\n", time_buffer);
}

int main() {
    progress_meter_simulated();
    return 0;
}

编译和测试利用

1
2
3
4
5
6
7


# 使用不同优化编译以查看效果
gcc -O0 -o exploit exploit.c && ./exploit
gcc -O2 -o exploit exploit.c && ./exploit

# 在某些架构/编译器上，您可能看到：
# Before: sensitive_data = 'SECRET_DATA123'
# After: sensitive_data = '3'  # 内存损坏！

真实世界攻击向量

1
2
3
4
5
6
7
8
9


# 攻击者可能通过以下方式利用：
# 1. 创建特定的网络条件
# 2. 强制cURL显示未知时间的进度
# 3. 重复触发漏洞代码路径
# 4. 可能损坏内存以获得代码执行

# 示例触发：
curl --limit-rate 1k https://large-file.com/file.iso
# 这强制显示具有未知时间估计的进度

攻击者可实现的目标

拒绝服务：在文件传输期间崩溃cURL
内存损坏：修改相邻的堆栈变量
信息泄漏：读取堆栈内存内容
潜在RCE：在具有特定编译器标志和架构的完美风暴条件下

修复建议

立即用安全替代方案替换strcpy()：

1
2
3
4
5
6
7
8
9


// 修复版本：
static void time2str(char *r, curl_off_t seconds) {
  if(seconds <= 0) {
    strncpy(r, "--:--:--", 9);  // 显式长度限制
    r[9] = '\0';                // 确保空终止
    return;
  }
  // ... 其余不变
}

此漏洞代表应在下一个cURL安全版本中解决的真实安全风险。

项目方回应

cURL维护者认为此报告具有AI生成的典型特征，包括：

始终是strcpy问题
注释中的表情符号
标题中的混合大小写
重复使用项目符号

维护者最终将报告状态更改为"不适用"，认为未识别出安全问题，并禁止了报告者。

报告者提供的证据

报告者提供了手动研究的终端输出证据：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


❯ grep -n "strcpy\|strcat\|sprintf" ./src/tool_progress.c
94:    strcpy(r, "--:--:--");

❯ sed -n '80, 100p' ./src/tool_progress.c
  if(config->readbusy) {
    config->readbusy = FALSE;
    curl_easy_pause(per->curl, CURLPAUSE_CONT);
  }

  return 0;
}

/* Provide a string that is 2 + 1 + 2 + 1 + 2 = 8 letters long (plus the zero
   byte) */
static void time2str(char *r, curl_off_t seconds)
{
  curl_off_t h;
  if(seconds <= 0) {
    strcpy(r, "--:--:--");
    return;
  }
  h = seconds / 3600;
  if(h <= 99) {
    curl_off_t m = (seconds - (h * 3600)) / 60;
    curl_off_t s = (seconds - (h * 3600)) - (m * 60);