rust - 当我写入随机内存地址时会发生什么？

Question

extern crate core;
use core::ops::{Deref, DerefMut};

struct MutPtr<T>{
    ptr: *mut T
}
impl<T> MutPtr<T>{
    fn new(value: &mut T) -> MutPtr<T>{
        MutPtr{ptr: value} 
    }
}
impl<T> Deref for MutPtr<T>{
    type Target = T;
    fn deref(&self) -> &T{
        unsafe{
            &(*self.ptr)
        }
    }
}
impl<T> DerefMut for MutPtr<T>{
    fn deref_mut(&mut self) -> &mut T{
        unsafe{
            &mut (*self.ptr)
        }
    }
}
struct Bar{
    v: i32
}

fn error()-> MutPtr<Bar> {
    let mut b = Bar{v:42};
    let ptr_b =  MutPtr::new(&mut b);
    ptr_b
}

fn main(){
    let mut b      = Bar{v:42};
    let mut ptr_b  = MutPtr::new(&mut b);
    let mut ptr_b1 = MutPtr::new(&mut b);

    ptr_b.v = 10;
    println!("{}",b.v);
    ptr_b1.v = 21;
    println!("{}",b.v);

    let mut err = error();
    println!("{}",err.v);
    err.v = 42; // what happens here?
    println!("{}",err.v);
}

在第 49 行我要写入一些内存地址

err.v = 42;

我知道这很糟糕，但我想知道到底发生了什么？起初我预计它会崩溃，但后来我希望我能够更改 err.v 地址处的值。但是写没有做任何事情。

内存似乎被写保护了？

我只是“幸运地”写入没有改变任何东西吗？

Answer 1

Was I just "lucky" that the write didn't change anything?

是的，只是幸运。

写入随机内存是undefined behaviour :编译器假设它永远不会发生并优化假设。如果它确实发生了，那么人们对由此产生的行为没有任何限制或保证。例如。它可以 change the return address在下一个函数调用结束时使用，使 CPU 跳转到某个“随机”内存块。这通常非常糟糕，这样的事情很可能是一个可利用的安全漏洞。

在您所写的情况下，没有可怕的程序死亡可能是因为 err 指向堆栈下方，程序在写入发生时未使用它。如果在使用堆栈的那个区域时发生写入，则很容易发生将指针修改为指向无意义的事情:

use std::mem;

#[inline(never)]
fn bad() -> &'static mut u32 {
    let mut x = 0u32;
    unsafe { mem::transmute(&mut x) }
}

#[inline(never)]
fn innocent(x: &mut u32) {
    println!("{:p}", &*x);
    *x = 0xDEADBEEF;

    println!("{:p}", x);
    *x = 0;
}

fn main() {
    let ptr = bad();
    innocent(ptr);
}

关于 playpen使用 -O2，此刻，它打印:

0x7fff03dbae84
0xdeadbeef03dbae84
playpen: application terminated abnormally with signal 4 (Illegal instruction)

第一行是x的真实值。下一行是 *x = 0xDEADBEEF; 之后的 x... 也就是说，写入直接写入了存储 x 的堆栈部分> 本身，将上半部分更改为 0xDEADBEEF。此时，x 是一个无意义的值，因此 *x = 0 导致段错误(表现为中止，因为 Rust 默认覆盖了一些信号处理程序) .

我说“目前”是因为程序的行为对确切的编译器版本/优化级别/源代码非常敏感，例如更改第一个 print 以删除 &* 使程序打印 0x7fff03dbae84 两次然后中止(可能是因为返回地址被修改而不是x).

如果攻击者对写入无效指针的内容有任何控制，他们可能/很可能能够修改写入指针，使程序跳转到 piece of shellcode。并 pwn 你的应用程序。我看到可能是因为even the smallest "unexploitable" problems已被证明是可利用的。