Rust 安全编程:从所有权到 unsafe 边界的防御性编码实践

一、Rust 的安全不是"不会出错",是"出错的地方你看得见"
学 Rust 之前,我以为"安全"就是编译通过就不会出问题。学了一段时间才发现,Rust 的安全保证是有边界的:所有权和借用检查器保证内存安全,但 unsafe 块、FFI 调用、并发数据竞争(Send/Sync 不当实现)仍然可能出问题。Rust 的真正价值不是"消灭 Bug",而是"把 Bug 限制在你明确标注 unsafe 的地方"——出错的地方你看得见。
这篇文章记录我在 Rust 安全编程方面的踩坑和理解,从所有权的核心规则到 unsafe 的正确使用姿势,都是实战中碰到的真问题。
二、Rust 安全体系的层次与边界
flowchart TB
A[Rust 安全体系] --> B[编译期安全<br/>所有权 + 借用检查]
A --> C[类型系统安全<br/>Send/Sync + 生命周期]
A --> D[运行时安全<br/>panic + Result + unwrap]
B --> B1[内存安全<br/>无悬垂指针/双重释放]
B --> B2[线程安全<br/>数据竞争编译期拒绝]
C --> C1[Send 标记<br/>可跨线程转移]
C --> C2[Sync 标记<br/>可跨线程共享引用]
D --> D1[panic!<br/>不可恢复错误]
D --> D2[Result<T, E><br/>可恢复错误]
A --> E[unsafe 边界<br/>手动安全保证]
E --> E1[裸指针解引用]
E --> E2[FFI 调用]
E --> E3[可变静态变量]
E --> E4[unsafe trait 实现]
E --> F[安全封装<br/>最小化 unsafe 范围]
style B fill:#e8f5e9
style E fill:#ffebee
style F fill:#e3f2fd
Rust 的安全体系分三层:编译期安全(所有权和借用检查器)、类型系统安全(Send/Sync 自动推导)、运行时安全(panic 和 Result)。unsafe 是安全体系的边界——它不关闭安全检查,只是在特定操作上让你绕过编译器的某些检查,由你手动保证安全。关键原则是:unsafe 块要尽可能小,安全封装要尽可能完整。
三、代码实现与分析
3.1 所有权与借用的常见坑
use std::collections::HashMap;
/// 坑1:在遍历时修改集合
fn iteration_mutation_pitfall() {
let mut scores = HashMap::new();
scores.insert("alice", 10);
scores.insert("bob", 20);
// 编译错误:不能在遍历时修改
// for (name, &score) in &scores {
// if score < 15 {
// scores.insert(name, 30); // ❌ 不能同时有不可变引用和可变引用
// }
// }
// 正确做法1:收集需要修改的 key,遍历后再修改
let to_update: Vec<String> = scores
.iter()
.filter(|(_, &score)| score < 15)
.map(|(name, _)| name.to_string())
.collect();
for name in to_update {
scores.insert(&name, 30);
}
// 正确做法2:使用 entry API
for name in ["alice", "bob", "charlie"] {
scores.entry(name).or_insert(0);
}
}
/// 坑2:生命周期不够长——悬垂引用的经典场景
struct Parser<'a> {
input: &'a str,
position: usize,
}
impl<'a> Parser<'a> {
fn new(input: &'a str) -> Self {
Self { input, position: 0 }
}
fn peek(&self) -> Option<&'a str> {
// ✅ 返回的引用生命周期与 input 绑定,而非 self
self.input.get(self.position..self.position + 1)
}
// ❌ 错误写法:返回的引用生命周期与 self 绑定
// fn peek_wrong(&self) -> Option<&str> {
// // 如果返回 &self.input[...],生命周期与 self 绑定
// // 当 self 丢弃后,引用失效
// }
}
/// 坑3:RefCell 的运行时借用检查
use std::cell::RefCell;
use std::rc::Rc;
struct Graph {
nodes: RefCell<Vec<String>>,
}
impl Graph {
fn add_node(&self, name: String) {
// 运行时检查:如果当前有不可变借用,这里会 panic
self.nodes.borrow_mut().push(name);
}
fn get_nodes(&self) -> std::cell::Ref<'_, Vec<String>> {
// 运行时检查:如果当前有可变借用,这里会 panic
self.nodes.borrow()
}
// ❌ 危险模式:持有不可变引用的同时尝试可变借用
// fn dangerous(&self) {
// let nodes = self.nodes.borrow(); // 不可变借用
// self.nodes.borrow_mut(); // 💥 panic! 运行时崩溃
// }
}
3.2 unsafe 的正确使用姿势
use std::ptr;
/// 安全封装的 unsafe:Vec 的简化实现
pub struct SimpleVec<T> {
ptr: *mut T,
len: usize,
capacity: usize,
}
impl<T> SimpleVec<T> {
pub fn new() -> Self {
Self {
ptr: ptr::null_mut(),
len: 0,
capacity: 0,
}
}
pub fn push(&mut self, value: T) {
if self.len == self.capacity {
self.grow();
}
// unsafe 块尽可能小:只包含必须 unsafe 的操作
unsafe {
ptr::write(self.ptr.add(self.len), value);
}
self.len += 1;
}
pub fn get(&self, index: usize) -> Option<&T> {
if index < self.len {
// unsafe 块返回安全引用
Some(unsafe { &*self.ptr.add(index) })
} else {
None
}
}
fn grow(&mut self) {
let new_capacity = if self.capacity == 0 { 4 } else { self.capacity * 2 };
let new_layout = std::alloc::Layout::array::<T>(new_capacity)
.expect("allocation layout error");
let new_ptr = if self.capacity == 0 {
unsafe { std::alloc::alloc(new_layout) as *mut T }
} else {
let old_layout = std::alloc::Layout::array::<T>(self.capacity)
.expect("old layout error");
unsafe {
std::alloc::realloc(
self.ptr as *mut u8,
old_layout,
new_layout.size(),
) as *mut T
}
};
if new_ptr.is_null() {
std::alloc::handle_alloc_error(new_layout);
}
self.ptr = new_ptr;
self.capacity = new_capacity;
}
}
impl<T> Drop for SimpleVec<T> {
fn drop(&mut self) {
if self.capacity > 0 {
// 先 drop 所有元素
for i in 0..self.len {
unsafe {
ptr::drop_in_place(self.ptr.add(i));
}
}
// 再释放内存
let layout = std::alloc::Layout::array::<T>(self.capacity)
.expect("layout error");
unsafe {
std::alloc::dealloc(self.ptr as *mut u8, layout);
}
}
}
}
// ✅ 安全封装的关键:所有 unsafe 操作都在私有方法中
// 公有 API 只暴露安全的接口
// 调用者不需要知道内部用了 unsafe
3.3 Send/Sync 与线程安全
use std::sync::{Arc, Mutex};
use std::thread;
/// 线程安全的共享计数器
pub struct SafeCounter {
value: Mutex<i64>,
}
// ✅ SafeCounter 自动实现 Send + Sync(因为 Mutex<i64> 是 Send + Sync)
impl SafeCounter {
pub fn new(start: i64) -> Self {
Self {
value: Mutex::new(start),
}
}
pub fn increment(&self) {
let mut guard = self.value.lock().unwrap();
*guard += 1;
// guard 自动释放锁
}
pub fn get(&self) -> i64 {
*self.value.lock().unwrap()
}
}
fn demo_thread_safety() {
let counter = Arc::new(SafeCounter::new(0));
let mut handles = vec![];
for _ in 0..10 {
let counter_clone = Arc::clone(&counter);
handles.push(thread::spawn(move || {
for _ in 0..1000 {
counter_clone.increment();
}
}));
}
for handle in handles {
handle.join().unwrap();
}
assert_eq!(counter.get(), 10000); // ✅ 数据竞争不可能发生
}
/// ❌ 反面案例:手动实现 Send 导致数据竞争
// struct BadCounter {
// value: *mut i64, // 裸指针不是 Send
// }
//
// unsafe impl Send for BadCounter {} // ❌ 危险!裸指针跨线程不安全
//
// 这样做编译能通过,但运行时可能数据竞争
// Rust 的哲学:如果你手动实现 Send/Sync,你就要为安全性负责
四、安全编程的边界与权衡
unsafe 不是"不安全",是"你负责":unsafe 块内的操作不会被借用检查器检查,但其他安全检查仍然生效。unsafe 的正确用法是:在最小范围内使用,用安全封装包裹,确保外部调用者无法触发未定义行为。每写一行 unsafe,都要写注释说明为什么这行是安全的。
RefCell 的 panic 风险:RefCell 把借用检查从编译期推迟到运行期,如果违反借用规则会 panic。在库代码中使用 RefCell 要格外小心——调用者可能不知道某个方法会触发 panic。建议在文档中明确标注 RefCell 的使用位置和可能的 panic 场景。
FFI 是安全漏洞的重灾区:调用 C 库时,Rust 的安全保证全部失效——C 代码可能越界访问、双重释放、数据竞争。FFI 封装的原则是:在 Rust 侧做完整的参数校验,将 C 的错误码转换为 Result,确保 C 的未定义行为不会泄漏到 Rust 侧。
unwrap() 不是"不安全",但生产代码要谨慎:unwrap() 在 None 或 Err 时 panic,适合原型开发和测试代码。生产代码中,应该用 ? 传播错误或用 unwrap_or / unwrap_or_else 提供默认值。唯一的例外是"逻辑上不可能失败"的场景(如 HashMap::get 后立即 unwrap,因为刚插入过),这时加注释说明为什么安全。
五、总结
Rust 的安全保证是有边界的:所有权和借用检查器保证内存安全和线程安全,unsafe 是安全体系的边界而非漏洞。本文的关键实践为:理解所有权的核心规则避免编译错误、用最小范围的 unsafe 块和安全封装保证未定义行为不泄漏、用 Mutex 和 Arc 实现线程安全共享、谨慎使用 RefCell 和 unwrap。Rust 的安全不是"不会出错",是"出错的地方你看得见"——这正是它的价值所在。
492



被折叠的 条评论
为什么被折叠?



