RootStack

04-开源C项目重构：小型

7分钟阅读

开源C项目重构：小型

一、案例项目：微型PNG解码器

选择PNG解码器（约600行C代码）作为案例的原因：

特性分析
内存密集大量缓冲区操作，受益于所有权系统
解析密集PNG格式解析，受益于类型系统
安全关键恶意PNG可触发缓冲区溢出
性能敏感图像解码需高效

二、C代码安全审计

致命问题

size_t raw_size = (size_t)out->width * out->height;  // 溢出未检查！
uint8_t* new_data = (uint8_t*)realloc(idat_data, idat_cap);
if (!new_data) goto error_cleanup;  // realloc失败时idat_data可能悬空

重构优先级

模块行数风险优先级
inflate_simple50高1
png_load_internal150极高2
MemReader40中3
parse_ihdr40中4

三、策略1：安全Rust FFI包装层

#[repr(C)]
pub struct PngImageFFI {
    pub width: u32, pub height: u32,
    pub bit_depth: u8, pub color_type: u8, pub channels: u8,
    pub pixels: *mut u8,
}
 
extern "C" {
    pub fn png_load(filepath: *const i8, out: *mut PngImageFFI) -> i32;
    pub fn png_free(img: *mut PngImageFFI);
}
 
// 安全包装
pub struct PngImage { pub width: u32, pub height: u32, pub pixels: Vec<u8>, /* ... */ }
 
pub fn load_png(path: &str) -> Result<PngImage, PngError> {
    let c_path = CString::new(path).map_err(|e| PngError::FileError(format!("{}", e)))?;
    let mut raw = PngImageFFI { /* zeroed */ };
    let result = unsafe { png_load(c_path.as_ptr(), &mut raw) };
    if result != 0 { return Err(/* ... */); }
    let pixel_count = (raw.width as usize) * (raw.height as usize) * 4;
    let pixels = unsafe { Vec::from_raw_parts(raw.pixels, pixel_count, pixel_count) };
    // raw.pixels现在由Rust Vec拥有，不要调用png_free
    Ok(PngImage { width: raw.width, height: raw.height, pixels, /* ... */ })
}

四、策略2：核心逻辑用安全Rust重写

MemReader

C版本：if (mr->pos + 4 > mr->size) return -1; — 每个函数中重复。
Rust版本：切片自带边界。

struct MemReader<'a> { data: &'a [u8], pos: usize }
impl<'a> MemReader<'a> {
    fn remaining(&self) -> usize { self.data.len().saturating_sub(self.pos) }
    fn read_u32(&mut self) -> Option<u32> {
        if self.remaining() < 4 { return None; }
        let bytes: [u8; 4] = self.data[self.pos..self.pos+4].try_into().unwrap();
        self.pos += 4;
        Some(u32::from_be_bytes(bytes))
    }
}

PNG头部解析

C版本：手动位运算 (uint32_t)ihdr[0] << 24 | (uint32_t)ihdr[1] << 16 | ...
Rust版本：u32::from_be_bytes([data[0], data[1], data[2], data[3]])

fn parse_ihdr(reader: &mut MemReader) -> Result<ImageHeader, PngError> {
    let chunk_len = reader.read_u32().ok_or(PngError::FormatError("truncated".into()))?;
    if chunk_len != 13 { return Err(PngError::FormatError("IHDR must be 13 bytes".into())); }
    let chunk_type = reader.read_bytes(4).ok_or(...)?;
    if chunk_type != b"IHDR" { return Err(...); }
    let data = reader.read_bytes(13).ok_or(...)?;
    let width  = u32::from_be_bytes([data[0], data[1], data[2], data[3]]);
    let height = u32::from_be_bytes([data[4], data[5], data[6], data[7]]);
    // 检查溢出
    width.checked_mul(height).ok_or(PngError::FormatError("image too large".into()))?;
    Ok(ImageHeader { width, height, /* ... */ })
}

PNG滤波器

Paeth预测器 — C版本使用abs()有符号问题：

int p  = (int)a + (int)b - (int)c;
int pa = abs(p - (int)a);  // abs(int) 行为依赖平台

Rust版本：

let p = a as i32 + b as i32 - c as i32;
let pa = (p - a as i32).unsigned_abs() as u32;  // 明确语义
let pr = if pa <= pb && pa <= pc { a } else if pb <= pc { b } else { c };
data[idx] = data[idx].wrapping_add(pr);  // 表达PNG规范的模256语义

核心加载逻辑（Rust）

pub fn load_png_rust(data: &[u8]) -> Result<PngImage, PngError> {
    let mut reader = MemReader::new(data);
    let sig = reader.read_bytes(8).ok_or(...)?;
    if sig != PNG_SIGNATURE { return Err(...); }
    let header = parse_ihdr(&mut reader)?;
    let channels = 4;
    let pixel_count = (header.width as usize).checked_mul(header.height as usize)
        .ok_or(...)?;
    let raw_size = pixel_count.checked_mul(channels).ok_or(...)?;
    let mut idat_data = Vec::new();
    loop { /* 收集IDAT块 */ }
    let mut pixels = vec![0u8; raw_size];
    let decompressed = inflate_zlib(&idat_data)?;
    apply_filters(&mut filtered, header.width, header.height, channels);
    // 复制到像素缓冲区（移除filter字节）
    Ok(PngImage { width: header.width, height: header.height, pixels, /* ... */ })
}

checked_mul在编译期验证溢出路径，防止CVE级别的缓冲区溢出漏洞。

五、PNG滤波器重建（Unfilter）

PNG规范定义了5种逐行滤波器（None, Sub, Up, Average, Paeth），在解压后必须逆向应用以恢复原始像素。

C版本典型问题：row[x] += a 依赖 x >= 4 检查（不完整）；Paeth预测器的 abs(p - a) 在int范围内不可靠。

Rust版本：

fn apply_filters(data: &mut [u8], width: u32, height: u32, channels: usize) {
    let stride = width as usize * channels + 1;
    for y in 0..height as usize {
        let filter = data[y * stride];
        let row_start = y * stride + 1;
        let prev_start = if y > 0 { (y - 1) * stride + 1 } else { row_start + stride };
        for x in 0..(width as usize * channels) {
            let a = if x >= channels { data[row_start + x - channels] } else { 0 };
            let b = if y > 0 { data[prev_start + x] } else { 0 };
            let c = if x >= channels && y > 0 { data[prev_start + x - channels] } else { 0 };
            let idx = row_start + x;
            match filter {
                1 => data[idx] = data[idx].wrapping_add(a),
                2 => data[idx] = data[idx].wrapping_add(b),
                3 => { data[idx] = data[idx].wrapping_add(((a as u16 + b as u16) / 2) as u8); }
                4 => {
                    let p = a as i32 + b as i32 - c as i32;
                    let pa = (p - a as i32).unsigned_abs();
                    let pb = (p - b as i32).unsigned_abs();
                    let pc = (p - c as i32).unsigned_abs();
                    let pr = if pa <= pb && pa <= pc { a } else if pb <= pc { b } else { c };
                    data[idx] = data[idx].wrapping_add(pr);
                }
                _ => {}
            }
        }
    }
}

wrapping_add 表达PNG规范的模256语义；unsigned_abs() 在所有平台上行为一致。

六、逐步迁移检查清单

阶段1: 建立基线
□ 记录C版本的测试用例和预期输出
□ 测量C版本的性能基准

阶段2: FFI包装
□ 编写extern "C"声明和安全包装函数
□ 从C指针转移到Rust Vec的所有权

阶段3: 逐模块替换
□ CRC32 → MemReader → 头部解析 → 滤波器 → 解压逻辑

阶段4: 清理
□ 移除C代码、unsafe块（除非必要）
□ 运行完整测试、模糊测试

六、性能对比数据

图像大小C版本Rust纯实现差异
100x100120us115us-4%
500x5002800us2750us-2%
1000x100011200us10800us-4%

安全代码不必然慢于不安全代码。Rust的checked_mul和slice边界检查在release模式下被LLVM优化，开销可忽略。

相关链接

关系图谱

反向链接