dyule / rdiff

For comparing the differences between files over time

rdiff

rdiff is a package for comparing versions of a file over time. It is written is Rust, and expects version > 1.17.

To the extent possible under law, rdiff contributors have waived all copyright and related or neighboring rights to rdiff.

Documentation

Usage

in Cargo.toml:

[dependencies]
rdiff = "0.1"

In your rust file (taken from examples/predefined.rs):

extern crate rdiff;

use rdiff::BlockHashes;
use std::fs::File;

pub fn example() {
    let file = File::open("examples/filev1.txt").unwrap();
    let mut hashes = BlockHashes::new(file, 8).unwrap();
    let file = File::open("examples/filev2.txt").unwrap();
    let difference = hashes.diff_and_update(file).unwrap();
    println!("Inserts: {:?}", difference.inserts().collect::<Vec<_>>());
    println!("Deletes: {:?}", difference.deletes().collect::<Vec<_>>());
}

This will output

Inserts: [Insert(8, 'widely understood '), Insert(90, ' absolutely'), Insert(381, 'hters, or sons if the family was progressive.\n'), Insert(572, 'not, even though he had been following the news quite closely.\n\n'), Insert(734, '\nMr. Ben')]
Deletes: [Delete(34, 24), Delete(428, 8), Delete(638, 8), Delete(742, 8)]

rdiff's Issues

Broken Read implementations can cause uninitialized memory read

Hi there, we (Rust group @sslab-gatech) are scanning crates on crates.io for potential soundness bugs. We noticed that in Window::new, the bytes read returned from the reader are used to set_len:

rdiff/src/window.rs

Lines 9 to 18 in 6680843

	let mut front = vec!(0;block_size);
	let mut back = vec!(0;block_size);
	let size = try!(reader.read(front.as_mut_slice()));
	unsafe {
	front.set_len(size);
	}
	let size = try!(reader.read(back.as_mut_slice()));
	unsafe {
	back.set_len(size);
	}

This means that a buggy Read implementation that returns more bytes than the buf size can cause front and back to contain initialized memory. See this example:

#![forbid(unsafe_code)]

use rdiff::BlockHashes;
use std::io::{Cursor, Read};

struct MyRead {
    first: bool,
}

impl MyRead {
    pub fn new() -> Self {
        MyRead { first: false }
    }
}

impl Read for MyRead {
    fn read(&mut self, _buf: &mut [u8]) -> std::io::Result<usize> {
        if !self.first {
            self.first = true;
            // First iteration: return more than the buffer size
            Ok(256)
        } else {
            // Second iteration: indicate that we are done
            Ok(0)
        }
    }
}

fn main() {
    let mut hashes = BlockHashes::new(Cursor::new("Hello"), 32).unwrap();
    let diff = hashes.diff_and_update(MyRead::new()).unwrap();

    for insert in diff.inserts() {
        println!("{:?}", insert);
    }
}

This outputs:

Insert(0, '1���� =�>�U��X���������������X�q')

I think there should be an assert in Window::new to ensure that the number of bytes are <= block_size

Serializing and deserializing diffs

I'd love to be able to serialize diffs to a file and then at a later point deserialize them again. I've checked the public API and while it is possible to obtain the list of operations, there is no way to create a diff object from such a list, nor to serialize and deserialize operations.