From b2ee991c96698043f922b2b2d2dea77436db7549 Mon Sep 17 00:00:00 2001 From: Justus Winter Date: Mon, 18 Jun 2018 19:18:56 +0200 Subject: openpgp, buffered-reader: Make compression an optional feature. - This helps to reduce the trusted computing base if compression is not needed. - This makes it easier to fuzz Sequoia, previously the fuzzer was doing a great job creating compression bombs that triggered the fuzzers timeout. - Currently, the cargo workspace feature does not propagate --no-default-features, but it is possible to depend on the openpgp crate with `default-features = false`. - Unfortunately, a lot of test cases include compressed packages. This change conditionally disables these tests. --- buffered-reader/Cargo.toml | 12 +- buffered-reader/src/decompress.rs | 411 ----------------- buffered-reader/src/decompress_bzip2.rs | 118 +++++ buffered-reader/src/decompress_deflate.rs | 299 +++++++++++++ buffered-reader/src/lib.rs | 16 +- openpgp/Cargo.toml | 14 +- openpgp/src/lib.rs | 2 + openpgp/src/packet_pile.rs | 9 +- openpgp/src/parse/packet_pile_parser.rs | 2 + openpgp/src/parse/parse.rs | 23 +- openpgp/src/parse/subpacket.rs | 1 + openpgp/src/serialize/mod.rs | 1 + openpgp/src/serialize/stream.rs | 4 + openpgp/src/serialize/writer.rs | 586 ------------------------- openpgp/src/serialize/writer/mod.rs | 409 +++++++++++++++++ openpgp/src/serialize/writer/writer_bzip2.rs | 68 +++ openpgp/src/serialize/writer/writer_deflate.rs | 129 ++++++ openpgp/src/signature.rs | 12 +- 18 files changed, 1102 insertions(+), 1014 deletions(-) delete mode 100644 buffered-reader/src/decompress.rs create mode 100644 buffered-reader/src/decompress_bzip2.rs create mode 100644 buffered-reader/src/decompress_deflate.rs delete mode 100644 openpgp/src/serialize/writer.rs create mode 100644 openpgp/src/serialize/writer/mod.rs create mode 100644 openpgp/src/serialize/writer/writer_bzip2.rs create mode 100644 openpgp/src/serialize/writer/writer_deflate.rs diff --git a/buffered-reader/Cargo.toml b/buffered-reader/Cargo.toml index 68f4c60d..1702ac97 100644 --- a/buffered-reader/Cargo.toml +++ b/buffered-reader/Cargo.toml @@ -4,5 +4,13 @@ version = "0.1.0" authors = ["Neal H. Walfield "] [dependencies] -bzip2 = "0.3.2" -flate2 = "1.0.1" +bzip2 = { version = "0.3.2", optional = true } +flate2 = { version = "1.0.1", optional = true } + +[features] +default = ["compression"] + +# The compression algorithms. +compression = ["compression-deflate", "compression-bzip2"] +compression-deflate = ["flate2"] +compression-bzip2 = ["bzip2"] diff --git a/buffered-reader/src/decompress.rs b/buffered-reader/src/decompress.rs deleted file mode 100644 index 376edd06..00000000 --- a/buffered-reader/src/decompress.rs +++ /dev/null @@ -1,411 +0,0 @@ -use std::io; -use std::fmt; - -use flate2::read::DeflateDecoder; -use flate2::read::ZlibDecoder; -use bzip2::read::BzDecoder; - -use super::*; - -pub struct BufferedReaderDeflate, C> { - reader: BufferedReaderGeneric, C>, -} - -impl > BufferedReaderDeflate { - /// Instantiate a new deflate decompression reader. `reader` is - /// the source to wrap. - pub fn new(reader: R) -> Self { - Self::with_cookie(reader, ()) - } -} - -impl , C> BufferedReaderDeflate { - /// Like `new()`, but sets a cookie, which can be retrieved using - /// the `cookie_ref` and `cookie_mut` methods, and set using - /// the `cookie_set` method. - pub fn with_cookie(reader: R, cookie: C) -> Self { - BufferedReaderDeflate { - reader: BufferedReaderGeneric::with_cookie( - DeflateDecoder::new(reader), None, cookie), - } - } -} - -impl, C> io::Read for BufferedReaderDeflate { - fn read(&mut self, buf: &mut [u8]) -> Result { - self.reader.read(buf) - } -} - -impl , C> fmt::Debug for BufferedReaderDeflate { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("BufferedReaderDeflate") - .field("reader", &self.get_ref().unwrap()) - .finish() - } -} - -impl, C> BufferedReader - for BufferedReaderDeflate { - fn buffer(&self) -> &[u8] { - return self.reader.buffer(); - } - - fn data(&mut self, amount: usize) -> Result<&[u8], io::Error> { - return self.reader.data(amount); - } - - fn data_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> { - return self.reader.data_hard(amount); - } - - fn data_eof(&mut self) -> Result<&[u8], io::Error> { - return self.reader.data_eof(); - } - - fn consume(&mut self, amount: usize) -> &[u8] { - return self.reader.consume(amount); - } - - fn data_consume(&mut self, amount: usize) - -> Result<&[u8], io::Error> { - return self.reader.data_consume(amount); - } - - fn data_consume_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> { - return self.reader.data_consume_hard(amount); - } - - fn read_be_u16(&mut self) -> Result { - return self.reader.read_be_u16(); - } - - fn read_be_u32(&mut self) -> Result { - return self.reader.read_be_u32(); - } - - fn steal(&mut self, amount: usize) -> Result, io::Error> { - return self.reader.steal(amount); - } - - fn steal_eof(&mut self) -> Result, io::Error> { - return self.reader.steal_eof(); - } - - fn get_mut(&mut self) -> Option<&mut BufferedReader> { - Some(self.reader.reader.get_mut()) - } - - fn get_ref(&self) -> Option<&BufferedReader> { - Some(self.reader.reader.get_ref()) - } - - fn into_inner<'b>(self: Box) - -> Option + 'b>> where Self: 'b { - // Strip the outer box. - Some(Box::new(self.reader.reader.into_inner())) - } - - fn cookie_set(&mut self, cookie: C) -> C { - self.reader.cookie_set(cookie) - } - - fn cookie_ref(&self) -> &C { - self.reader.cookie_ref() - } - - fn cookie_mut(&mut self) -> &mut C { - self.reader.cookie_mut() - } -} - -pub struct BufferedReaderZlib, C> { - reader: BufferedReaderGeneric, C>, -} - -impl > BufferedReaderZlib { - /// Instantiate a new zlib decompression reader. `reader` is - /// the source to wrap. - pub fn new(reader: R) -> Self { - Self::with_cookie(reader, ()) - } -} - -impl , C> BufferedReaderZlib { - /// Like `new()`, but sets a cookie, which can be retrieved using - /// the `cookie_ref` and `cookie_mut` methods, and set using - /// the `cookie_set` method. - pub fn with_cookie(reader: R, cookie: C) -> Self { - BufferedReaderZlib { - reader: BufferedReaderGeneric::with_cookie( - ZlibDecoder::new(reader), None, cookie), - } - } -} - -impl, C> io::Read for BufferedReaderZlib { - fn read(&mut self, buf: &mut [u8]) -> Result { - self.reader.read(buf) - } -} - -impl , C> fmt::Debug for BufferedReaderZlib { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("BufferedReaderZlib") - .field("reader", &self.get_ref().unwrap()) - .finish() - } -} - -impl, C> BufferedReader - for BufferedReaderZlib { - fn buffer(&self) -> &[u8] { - return self.reader.buffer(); - } - - fn data(&mut self, amount: usize) -> Result<&[u8], io::Error> { - return self.reader.data(amount); - } - - fn data_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> { - return self.reader.data_hard(amount); - } - - fn data_eof(&mut self) -> Result<&[u8], io::Error> { - return self.reader.data_eof(); - } - - fn consume(&mut self, amount: usize) -> &[u8] { - return self.reader.consume(amount); - } - - fn data_consume(&mut self, amount: usize) - -> Result<&[u8], io::Error> { - return self.reader.data_consume(amount); - } - - fn data_consume_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> { - return self.reader.data_consume_hard(amount); - } - - fn read_be_u16(&mut self) -> Result { - return self.reader.read_be_u16(); - } - - fn read_be_u32(&mut self) -> Result { - return self.reader.read_be_u32(); - } - - fn steal(&mut self, amount: usize) -> Result, io::Error> { - return self.reader.steal(amount); - } - - fn steal_eof(&mut self) -> Result, io::Error> { - return self.reader.steal_eof(); - } - - fn get_mut(&mut self) -> Option<&mut BufferedReader> { - Some(self.reader.reader.get_mut()) - } - - fn get_ref(&self) -> Option<&BufferedReader> { - Some(self.reader.reader.get_ref()) - } - - fn into_inner<'b>(self: Box) - -> Option + 'b>> where Self: 'b { - // Strip the outer box. - Some(Box::new(self.reader.reader.into_inner())) - } - - fn cookie_set(&mut self, cookie: C) -> C { - self.reader.cookie_set(cookie) - } - - fn cookie_ref(&self) -> &C { - self.reader.cookie_ref() - } - - fn cookie_mut(&mut self) -> &mut C { - self.reader.cookie_mut() - } -} - -pub struct BufferedReaderBzip, C> { - reader: BufferedReaderGeneric, C>, -} - -impl > BufferedReaderBzip { - /// Instantiate a new bzip decompression reader. `reader` is - /// the source to wrap. - pub fn new(reader: R) -> Self { - Self::with_cookie(reader, ()) - } -} - -impl , C> BufferedReaderBzip { - /// Like `new()`, but sets a cookie, which can be retrieved using - /// the `cookie_ref` and `cookie_mut` methods, and set using - /// the `cookie_set` method. - pub fn with_cookie(reader: R, cookie: C) -> Self { - BufferedReaderBzip { - reader: BufferedReaderGeneric::with_cookie( - BzDecoder::new(reader), None, cookie), - } - } -} - -impl, C> io::Read for BufferedReaderBzip { - fn read(&mut self, buf: &mut [u8]) -> Result { - self.reader.read(buf) - } -} - -impl , C> fmt::Debug for BufferedReaderBzip { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("BufferedReaderBzip") - .field("reader", &self.get_ref().unwrap()) - .finish() - } -} - -impl, C> BufferedReader for BufferedReaderBzip { - fn buffer(&self) -> &[u8] { - return self.reader.buffer(); - } - - fn data(&mut self, amount: usize) -> Result<&[u8], io::Error> { - return self.reader.data(amount); - } - - fn data_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> { - return self.reader.data_hard(amount); - } - - fn data_eof(&mut self) -> Result<&[u8], io::Error> { - return self.reader.data_eof(); - } - - fn consume(&mut self, amount: usize) -> &[u8] { - return self.reader.consume(amount); - } - - fn data_consume(&mut self, amount: usize) - -> Result<&[u8], io::Error> { - return self.reader.data_consume(amount); - } - - fn data_consume_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> { - return self.reader.data_consume_hard(amount); - } - - fn read_be_u16(&mut self) -> Result { - return self.reader.read_be_u16(); - } - - fn read_be_u32(&mut self) -> Result { - return self.reader.read_be_u32(); - } - - fn steal(&mut self, amount: usize) -> Result, io::Error> { - return self.reader.steal(amount); - } - - fn steal_eof(&mut self) -> Result, io::Error> { - return self.reader.steal_eof(); - } - - fn get_mut(&mut self) -> Option<&mut BufferedReader> { - Some(self.reader.reader.get_mut()) - } - - fn get_ref(&self) -> Option<&BufferedReader> { - Some(self.reader.reader.get_ref()) - } - - fn into_inner<'b>(self: Box) - -> Option + 'b>> where Self: 'b { - // Strip the outer box. - Some(Box::new(self.reader.reader.into_inner())) - } - - fn cookie_set(&mut self, cookie: C) -> C { - self.reader.cookie_set(cookie) - } - - fn cookie_ref(&self) -> &C { - self.reader.cookie_ref() - } - - fn cookie_mut(&mut self) -> &mut C { - self.reader.cookie_mut() - } -} - -#[cfg(test)] -mod test { - use super::*; - - // Test that buffer() returns the same data as data(). - #[test] - fn buffer_test() { - use flate2::write::DeflateEncoder; - use flate2::Compression; - use std::io::prelude::*; - - // Test vector. - let size = 10 * DEFAULT_BUF_SIZE; - let mut input_raw = Vec::with_capacity(size); - let mut v = 0u8; - for _ in 0..size { - input_raw.push(v); - if v == std::u8::MAX { - v = 0; - } else { - v += 1; - } - } - - // Compress the raw input. - let mut input = Vec::new(); - { - let mut encoder = - DeflateEncoder::new(&mut input, Compression::default()); - encoder.write(&input_raw[..]).unwrap(); - encoder.try_finish().unwrap(); - } - - let mut reader = BufferedReaderDeflate::new( - BufferedReaderGeneric::new(&input[..], None)); - - // Gather some stats to make it easier to figure out whether - // this test is working. - let stats_count = 2 * DEFAULT_BUF_SIZE; - let mut stats = vec![0usize; stats_count]; - - for i in 0..input_raw.len() { - let data = reader.data(DEFAULT_BUF_SIZE + 1).unwrap().to_vec(); - assert!(data.len() > 0); - assert_eq!(data, reader.buffer()); - // And, we may as well check to make sure we read the - // right data. - assert_eq!(data, &input_raw[i..i+data.len()]); - - stats[cmp::min(data.len(), stats_count - 1)] += 1; - - // Consume one byte and see what happens. - reader.consume(1); - } - - if false { - for i in 0..stats.len() { - if stats[i] > 0 { - if i == stats.len() - 1 { - eprint!(">="); - } - eprintln!("{}: {}", i, stats[i]); - } - } - } - } -} diff --git a/buffered-reader/src/decompress_bzip2.rs b/buffered-reader/src/decompress_bzip2.rs new file mode 100644 index 00000000..41fba37a --- /dev/null +++ b/buffered-reader/src/decompress_bzip2.rs @@ -0,0 +1,118 @@ +use std::io; +use std::fmt; + +use bzip2::read::BzDecoder; + +use super::*; + + +pub struct BufferedReaderBzip, C> { + reader: BufferedReaderGeneric, C>, +} + +impl > BufferedReaderBzip { + /// Instantiate a new bzip decompression reader. `reader` is + /// the source to wrap. + pub fn new(reader: R) -> Self { + Self::with_cookie(reader, ()) + } +} + +impl , C> BufferedReaderBzip { + /// Like `new()`, but sets a cookie, which can be retrieved using + /// the `cookie_ref` and `cookie_mut` methods, and set using + /// the `cookie_set` method. + pub fn with_cookie(reader: R, cookie: C) -> Self { + BufferedReaderBzip { + reader: BufferedReaderGeneric::with_cookie( + BzDecoder::new(reader), None, cookie), + } + } +} + +impl, C> io::Read for BufferedReaderBzip { + fn read(&mut self, buf: &mut [u8]) -> Result { + self.reader.read(buf) + } +} + +impl , C> fmt::Debug for BufferedReaderBzip { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.debug_struct("BufferedReaderBzip") + .field("reader", &self.get_ref().unwrap()) + .finish() + } +} + +impl, C> BufferedReader for BufferedReaderBzip { + fn buffer(&self) -> &[u8] { + return self.reader.buffer(); + } + + fn data(&mut self, amount: usize) -> Result<&[u8], io::Error> { + return self.reader.data(amount); + } + + fn data_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> { + return self.reader.data_hard(amount); + } + + fn data_eof(&mut self) -> Result<&[u8], io::Error> { + return self.reader.data_eof(); + } + + fn consume(&mut self, amount: usize) -> &[u8] { + return self.reader.consume(amount); + } + + fn data_consume(&mut self, amount: usize) + -> Result<&[u8], io::Error> { + return self.reader.data_consume(amount); + } + + fn data_consume_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> { + return self.reader.data_consume_hard(amount); + } + + fn read_be_u16(&mut self) -> Result { + return self.reader.read_be_u16(); + } + + fn read_be_u32(&mut self) -> Result { + return self.reader.read_be_u32(); + } + + fn steal(&mut self, amount: usize) -> Result, io::Error> { + return self.reader.steal(amount); + } + + fn steal_eof(&mut self) -> Result, io::Error> { + return self.reader.steal_eof(); + } + + fn get_mut(&mut self) -> Option<&mut BufferedReader> { + Some(self.reader.reader.get_mut()) + } + + fn get_ref(&self) -> Option<&BufferedReader> { + Some(self.reader.reader.get_ref()) + } + + fn into_inner<'b>(self: Box) + -> Option + 'b>> where Self: 'b { + // Strip the outer box. + Some(Box::new(self.reader.reader.into_inner())) + } + + fn cookie_set(&mut self, cookie: C) -> C { + self.reader.cookie_set(cookie) + } + + fn cookie_ref(&self) -> &C { + self.reader.cookie_ref() + } + + fn cookie_mut(&mut self) -> &mut C { + self.reader.cookie_mut() + } +} diff --git a/buffered-reader/src/decompress_deflate.rs b/buffered-reader/src/decompress_deflate.rs new file mode 100644 index 00000000..c46b9eea --- /dev/null +++ b/buffered-reader/src/decompress_deflate.rs @@ -0,0 +1,299 @@ +use std::io; +use std::fmt; + +use flate2::read::DeflateDecoder; +use flate2::read::ZlibDecoder; + +use super::*; + +pub struct BufferedReaderDeflate, C> { + reader: BufferedReaderGeneric, C>, +} + +impl > BufferedReaderDeflate { + /// Instantiate a new deflate decompression reader. `reader` is + /// the source to wrap. + pub fn new(reader: R) -> Self { + Self::with_cookie(reader, ()) + } +} + +impl , C> BufferedReaderDeflate { + /// Like `new()`, but sets a cookie, which can be retrieved using + /// the `cookie_ref` and `cookie_mut` methods, and set using + /// the `cookie_set` method. + pub fn with_cookie(reader: R, cookie: C) -> Self { + BufferedReaderDeflate { + reader: BufferedReaderGeneric::with_cookie( + DeflateDecoder::new(reader), None, cookie), + } + } +} + +impl, C> io::Read for BufferedReaderDeflate { + fn read(&mut self, buf: &mut [u8]) -> Result { + self.reader.read(buf) + } +} + +impl , C> fmt::Debug for BufferedReaderDeflate { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.debug_struct("BufferedReaderDeflate") + .field("reader", &self.get_ref().unwrap()) + .finish() + } +} + +impl, C> BufferedReader + for BufferedReaderDeflate { + fn buffer(&self) -> &[u8] { + return self.reader.buffer(); + } + + fn data(&mut self, amount: usize) -> Result<&[u8], io::Error> { + return self.reader.data(amount); + } + + fn data_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> { + return self.reader.data_hard(amount); + } + + fn data_eof(&mut self) -> Result<&[u8], io::Error> { + return self.reader.data_eof(); + } + + fn consume(&mut self, amount: usize) -> &[u8] { + return self.reader.consume(amount); + } + + fn data_consume(&mut self, amount: usize) + -> Result<&[u8], io::Error> { + return self.reader.data_consume(amount); + } + + fn data_consume_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> { + return self.reader.data_consume_hard(amount); + } + + fn read_be_u16(&mut self) -> Result { + return self.reader.read_be_u16(); + } + + fn read_be_u32(&mut self) -> Result { + return self.reader.read_be_u32(); + } + + fn steal(&mut self, amount: usize) -> Result, io::Error> { + return self.reader.steal(amount); + } + + fn steal_eof(&mut self) -> Result, io::Error> { + return self.reader.steal_eof(); + } + + fn get_mut(&mut self) -> Option<&mut BufferedReader> { + Some(self.reader.reader.get_mut()) + } + + fn get_ref(&self) -> Option<&BufferedReader> { + Some(self.reader.reader.get_ref()) + } + + fn into_inner<'b>(self: Box) + -> Option + 'b>> where Self: 'b { + // Strip the outer box. + Some(Box::new(self.reader.reader.into_inner())) + } + + fn cookie_set(&mut self, cookie: C) -> C { + self.reader.cookie_set(cookie) + } + + fn cookie_ref(&self) -> &C { + self.reader.cookie_ref() + } + + fn cookie_mut(&mut self) -> &mut C { + self.reader.cookie_mut() + } +} + +pub struct BufferedReaderZlib, C> { + reader: BufferedReaderGeneric, C>, +} + +impl > BufferedReaderZlib { + /// Instantiate a new zlib decompression reader. `reader` is + /// the source to wrap. + pub fn new(reader: R) -> Self { + Self::with_cookie(reader, ()) + } +} + +impl , C> BufferedReaderZlib { + /// Like `new()`, but sets a cookie, which can be retrieved using + /// the `cookie_ref` and `cookie_mut` methods, and set using + /// the `cookie_set` method. + pub fn with_cookie(reader: R, cookie: C) -> Self { + BufferedReaderZlib { + reader: BufferedReaderGeneric::with_cookie( + ZlibDecoder::new(reader), None, cookie), + } + } +} + +impl, C> io::Read for BufferedReaderZlib { + fn read(&mut self, buf: &mut [u8]) -> Result { + self.reader.read(buf) + } +} + +impl , C> fmt::Debug for BufferedReaderZlib { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.debug_struct("BufferedReaderZlib") + .field("reader", &self.get_ref().unwrap()) + .finish() + } +} + +impl, C> BufferedReader + for BufferedReaderZlib { + fn buffer(&self) -> &[u8] { + return self.reader.buffer(); + } + + fn data(&mut self, amount: usize) -> Result<&[u8], io::Error> { + return self.reader.data(amount); + } + + fn data_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> { + return self.reader.data_hard(amount); + } + + fn data_eof(&mut self) -> Result<&[u8], io::Error> { + return self.reader.data_eof(); + } + + fn consume(&mut self, amount: usize) -> &[u8] { + return self.reader.consume(amount); + } + + fn data_consume(&mut self, amount: usize) + -> Result<&[u8], io::Error> { + return self.reader.data_consume(amount); + } + + fn data_consume_hard(&mut self, amount: usize) -> Result<&[u8], io::Error> { + return self.reader.data_consume_hard(amount); + } + + fn read_be_u16(&mut self) -> Result { + return self.reader.read_be_u16(); + } + + fn read_be_u32(&mut self) -> Result { + return self.reader.read_be_u32(); + } + + fn steal(&mut self, amount: usize) -> Result, io::Error> { + return self.reader.steal(amount); + } + + fn steal_eof(&mut self) -> Result, io::Error> { + return self.reader.steal_eof(); + } + + fn get_mut(&mut self) -> Option<&mut BufferedReader> { + Some(self.reader.reader.get_mut()) + } + + fn get_ref(&self) -> Option<&BufferedReader> { + Some(self.reader.reader.get_ref()) + } + + fn into_inner<'b>(self: Box) + -> Option + 'b>> where Self: 'b { + // Strip the outer box. + Some(Box::new(self.reader.reader.into_inner())) + } + + fn cookie_set(&mut self, cookie: C) -> C { + self.reader.cookie_set(cookie) + } + + fn cookie_ref(&self) -> &C { + self.reader.cookie_ref() + } + + fn cookie_mut(&mut self) -> &mut C { + self.reader.cookie_mut() + } +} + +#[cfg(test)] +mod test { + use super::*; + + // Test that buffer() returns the same data as data(). + #[test] + fn buffer_test() { + use flate2::write::DeflateEncoder; + use flate2::Compression; + use std::io::prelude::*; + + // Test vector. + let size = 10 * DEFAULT_BUF_SIZE; + let mut input_raw = Vec::with_capacity(size); + let mut v = 0u8; + for _ in 0..size { + input_raw.push(v); + if v == std::u8::MAX { + v = 0; + } else { + v += 1; + } + } + + // Compress the raw input. + let mut input = Vec::new(); + { + let mut encoder = + DeflateEncoder::new(&mut input, Compression::default()); + encoder.write(&input_raw[..]).unwrap(); + encoder.try_finish().unwrap(); + } + + let mut reader = BufferedReaderDeflate::new( + BufferedReaderGeneric::new(&input[..], None)); + + // Gather some stats to make it easier to figure out whether + // this test is working. + let stats_count = 2 * DEFAULT_BUF_SIZE; + let mut stats = vec![0usize; stats_count]; + + for i in 0..input_raw.len() { + let data = reader.data(DEFAULT_BUF_SIZE + 1).unwrap().to_vec(); + assert!(data.len() > 0); + assert_eq!(data, reader.buffer()); + // And, we may as well check to make sure we read the + // right data. + assert_eq!(data, &input_raw[i..i+data.len()]); + + stats[cmp::min(data.len(), stats_count - 1)] += 1; + + // Consume one byte and see what happens. + reader.consume(1); + } + + if false { + for i in 0..stats.len() { + if stats[i] > 0 { + if i == stats.len() - 1 { + eprint!(">="); + } + eprintln!("{}: {}", i, stats[i]); + } + } + } + } +} diff --git a/buffered-reader/src/lib.rs b/buffered-reader/src/lib.rs index ab19fa37..9619e0de 100644 --- a/buffered-reader/src/lib.rs +++ b/buffered-reader/src/lib.rs @@ -1,6 +1,8 @@ //! An improved `BufRead` interface. +#[cfg(feature = "compression-deflate")] extern crate flate2; +#[cfg(feature = "compression-bzip2")] extern crate bzip2; use std::io; @@ -13,16 +15,22 @@ mod memory; mod limitor; mod dup; mod eof; -mod decompress; +#[cfg(feature = "compression-deflate")] +mod decompress_deflate; +#[cfg(feature = "compression-bzip2")] +mod decompress_bzip2; pub use self::generic::BufferedReaderGeneric; pub use self::memory::BufferedReaderMemory; pub use self::limitor::BufferedReaderLimitor; pub use self::dup::BufferedReaderDup; pub use self::eof::BufferedReaderEOF; -pub use self::decompress::BufferedReaderDeflate; -pub use self::decompress::BufferedReaderZlib; -pub use self::decompress::BufferedReaderBzip; +#[cfg(feature = "compression-deflate")] +pub use self::decompress_deflate::BufferedReaderDeflate; +#[cfg(feature = "compression-deflate")] +pub use self::decompress_deflate::BufferedReaderZlib; +#[cfg(feature = "compression-bzip2")] +pub use self::decompress_bzip2::BufferedReaderBzip; // The default buffer size. const DEFAULT_BUF_SIZE: usize = 8 * 1024; diff --git a/openpgp/Cargo.toml b/openpgp/Cargo.toml index 3d2d4c31..acf33a3c 100644 --- a/openpgp/Cargo.toml +++ b/openpgp/Cargo.toml @@ -4,11 +4,19 @@ version = "0.1.0" authors = ["Neal H. Walfield "] [dependencies] -buffered-reader = { path = "../buffered-reader" } +buffered-reader = { path = "../buffered-reader", default-features = false } base64 = "0.9.0" -bzip2 = "0.3.2" +bzip2 = { version = "0.3.2", optional = true } failure = "0.1.1" -flate2 = "1.0.1" +flate2 = { version = "1.0.1", optional = true } nettle = { git = "https://gitlab.com/sequoia-pgp/nettle-rs.git" } quickcheck = "0.6" time = "0.1.38" + +[features] +default = ["compression"] + +# The compression algorithms. +compression = ["compression-deflate", "compression-bzip2"] +compression-deflate = ["flate2", "buffered-reader/compression-deflate"] +compression-bzip2 = ["bzip2", "buffered-reader/compression-bzip2"] diff --git a/openpgp/src/lib.rs b/openpgp/src/lib.rs index 8bfd504e..af011720 100644 --- a/openpgp/src/lib.rs +++ b/openpgp/src/lib.rs @@ -45,7 +45,9 @@ extern crate buffered_reader; extern crate nettle; +#[cfg(feature = "compression-deflate")] extern crate flate2; +#[cfg(feature = "compression-bzip2")] extern crate bzip2; #[cfg(test)] diff --git a/openpgp/src/packet_pile.rs b/openpgp/src/packet_pile.rs index 55851fb1..65ca1b79 100644 --- a/openpgp/src/packet_pile.rs +++ b/openpgp/src/packet_pile.rs @@ -27,6 +27,7 @@ macro_rules! bytes { use std::path::PathBuf; #[cfg(test)] +#[allow(dead_code)] fn path_to(artifact: &str) -> PathBuf { [env!("CARGO_MANIFEST_DIR"), "tests", "data", "messages", artifact] .iter().collect() @@ -434,8 +435,6 @@ mod message_test { use SEIP; use packet::Tag; - use std::io::Read; - #[test] fn deserialize_test_1 () { // XXX: This test should be more thorough. Right now, we mostly @@ -456,6 +455,7 @@ mod message_test { assert_eq!(count, 61); } + #[cfg(feature = "compression-deflate")] #[test] fn deserialize_test_2 () { // A message containing a compressed packet that contains a @@ -474,6 +474,7 @@ mod message_test { assert_eq!(count, 2); } + #[cfg(feature = "compression-deflate")] #[test] fn deserialize_test_3 () { let path = path_to("signed.gpg"); @@ -526,6 +527,7 @@ mod message_test { assert_eq!(pile.children().len(), 77); } + #[cfg(feature = "compression-deflate")] #[test] fn compression_quine_test_1 () { // Use the PacketPile::from_file interface to parse an OpenPGP @@ -547,6 +549,7 @@ mod message_test { assert_eq!(count, 1 + max_recursion_depth); } + #[cfg(feature = "compression-deflate")] #[test] fn compression_quine_test_2 () { // Use the iterator interface to parse an OpenPGP quine. @@ -577,8 +580,10 @@ mod message_test { assert_eq!(count, 1 + max_recursion_depth as usize); } + #[cfg(feature = "compression-deflate")] #[test] fn consume_content_1 () { + use std::io::Read; // A message containing a compressed packet that contains a // literal packet. When we read some of the compressed // packet, we expect recurse() to not recurse. diff --git a/openpgp/src/parse/packet_pile_parser.rs b/openpgp/src/parse/packet_pile_parser.rs index 3d48a8b0..f19deb81 100644 --- a/openpgp/src/parse/packet_pile_parser.rs +++ b/openpgp/src/parse/packet_pile_parser.rs @@ -13,6 +13,7 @@ use buffered_reader::{BufferedReader, BufferedReaderGeneric, BufferedReaderMemory}; #[cfg(test)] +#[allow(unused_macros)] macro_rules! bytes { ( $x:expr ) => { include_bytes!(concat!("../../tests/data/messages/", $x)) }; } @@ -282,6 +283,7 @@ fn message_parser_test() { // Check that we can use the read interface to stream the contents of // a packet. +#[cfg(feature = "compression-deflate")] #[test] fn message_parser_reader_interface() { use std::io::Read; diff --git a/openpgp/src/parse/parse.rs b/openpgp/src/parse/parse.rs index 1b431b3d..145ace09 100644 --- a/openpgp/src/parse/parse.rs +++ b/openpgp/src/parse/parse.rs @@ -1122,11 +1122,19 @@ impl CompressedData { php.recursion_depth); } + #[allow(unreachable_patterns)] match algo { + CompressionAlgorithm::Uncompressed => (), + #[cfg(feature = "compression-deflate")] + CompressionAlgorithm::Zip + | CompressionAlgorithm::Zlib => (), + #[cfg(feature = "compression-bzip2")] + CompressionAlgorithm::BZip2 => (), CompressionAlgorithm::Unknown(_) | CompressionAlgorithm::Private(_) => return php.fail("unknown compression algorithm"), - _ => (), + _ => + return php.fail("unsupported compression algorithm"), } let recursion_depth = php.recursion_depth as usize; @@ -1143,14 +1151,18 @@ impl CompressedData { for a compression filter: this is an \ \"uncompressed compression packet\"."); } + let _ = recursion_depth; reader }, + #[cfg(feature = "compression-deflate")] CompressionAlgorithm::Zip => Box::new(BufferedReaderDeflate::with_cookie( reader, Cookie::new(recursion_depth))), + #[cfg(feature = "compression-deflate")] CompressionAlgorithm::Zlib => Box::new(BufferedReaderZlib::with_cookie( reader, Cookie::new(recursion_depth))), + #[cfg(feature = "compression-bzip2")] CompressionAlgorithm::BZip2 => Box::new(BufferedReaderBzip::with_cookie( reader, Cookie::new(recursion_depth))), @@ -1162,11 +1174,19 @@ impl CompressedData { } } +#[cfg(any(feature = "compression-deflate", feature = "compression-bzip2"))] #[test] fn compressed_data_parser_test () { let expected = bytes!("a-cypherpunks-manifesto.txt"); for i in 1..4 { + match CompressionAlgorithm::from(i) { + #[cfg(feature = "compression-deflate")] + CompressionAlgorithm::Zip | CompressionAlgorithm::Zlib => (), + #[cfg(feature = "compression-bzip2")] + CompressionAlgorithm::BZip2 => (), + _ => continue, + } let path = path_to(&format!("compressed-data-algo-{}.gpg", i)[..]); let mut pp = PacketParser::from_file(path).unwrap().unwrap(); @@ -2591,6 +2611,7 @@ impl<'a> BufferedReader for PacketParser<'a> { // Check that we can use the read interface to stream the contents of // a packet. +#[cfg(feature = "compression-deflate")] #[test] fn packet_parser_reader_interface() { // We need the Read trait. diff --git a/openpgp/src/parse/subpacket.rs b/openpgp/src/parse/subpacket.rs index 3d8b612a..0c58d76c 100644 --- a/openpgp/src/parse/subpacket.rs +++ b/openpgp/src/parse/subpacket.rs @@ -1480,6 +1480,7 @@ impl Signature { } } +#[cfg(feature = "compression-deflate")] #[test] fn subpacket_test_1 () { use PacketPile; diff --git a/openpgp/src/serialize/mod.rs b/openpgp/src/serialize/mod.rs index 298536a2..01d51479 100644 --- a/openpgp/src/serialize/mod.rs +++ b/openpgp/src/serialize/mod.rs @@ -1034,6 +1034,7 @@ mod serialize_test { } + #[cfg(feature = "compression-deflate")] #[test] fn serialize_test_2() { // Given a packet in serialized form: diff --git a/openpgp/src/serialize/stream.rs b/openpgp/src/serialize/stream.rs index 1434b677..012ceca8 100644 --- a/openpgp/src/serialize/stream.rs +++ b/openpgp/src/serialize/stream.rs @@ -542,10 +542,13 @@ impl<'a> Compressor<'a> { let inner: writer::Stack<'a, Cookie> = match algo { CompressionAlgorithm::Uncompressed => writer::Identity::new(inner, Cookie::new(level)), + #[cfg(feature = "compression-deflate")] CompressionAlgorithm::Zip => writer::ZIP::new(inner, Cookie::new(level)), + #[cfg(feature = "compression-deflate")] CompressionAlgorithm::Zlib => writer::ZLIB::new(inner, Cookie::new(level)), + #[cfg(feature = "compression-bzip2")] CompressionAlgorithm::BZip2 => writer::BZ::new(inner, Cookie::new(level)), _ => unimplemented!(), @@ -1045,6 +1048,7 @@ mod test { } } + #[cfg(feature = "compression-deflate")] #[test] fn stream_big() { let mut zeros = Vec::::new(); diff --git a/openpgp/src/serialize/writer.rs b/openpgp/src/serialize/writer.rs deleted file mode 100644 index 628187d1..00000000 --- a/openpgp/src/serialize/writer.rs +++ /dev/null @@ -1,586 +0,0 @@ -//! Stackable writers. - -use bzip2::Compression as BzCompression; -use bzip2::write::BzEncoder; -use flate2::Compression as FlateCompression; -use flate2::write::{DeflateEncoder, ZlibEncoder}; -use std::fmt; -use std::io; - -use symmetric; -use { - Result, - SymmetricAlgorithm, -}; - -/// A stack of writers. -/// -/// We use trait objects as the unit of composition. This is a -/// compiler limitation, we may use impl trait in the future. -pub type Stack<'a, C> = Box<'a + Stackable<'a, C>>; - -/// Makes a writer stackable and provides convenience functions. -pub trait Stackable<'a, C> : io::Write + fmt::Debug { - /// Recovers the inner stackable. - /// - /// This can fail if the current `Stackable` has buffered data - /// that hasn't been written to the underlying `Stackable`. - fn into_inner(self: Box) -> Result>>; - - /// Pops the stackable from the stack, detaching it. - /// - /// Returns the detached stack. - fn pop(&mut self) -> Result>>; - - /// Sets the inner stackable. - fn mount(&mut self, new: Stack<'a, C>); - - /// Returns a mutable reference to the inner `Writer`, if - /// any. - /// - /// It is a very bad idea to write any data from the inner - /// `Writer`, but it can sometimes be useful to get the cookie. - fn inner_mut(&mut self) -> Option<&mut Stackable<'a, C>>; - - /// Returns a reference to the inner `Writer`. - fn inner_ref(&self) -> Option<&Stackable<'a, C>>; - - /// Sets the cookie and returns the old value. - fn cookie_set(&mut self, cookie: C) -> C; - - /// Returns a reference to the cookie. - fn cookie_ref(&self) -> &C; - - /// Returns a mutable reference to the cookie. - fn cookie_mut(&mut self) -> &mut C; - - /// Writes a byte. - fn write_u8(&mut self, b: u8) -> io::Result<()> { - let b : [u8; 1] = [b; 1]; - self.write_all(&b[..]) - } - - /// Writes a big endian `u16`. - fn write_be_u16(&mut self, n: u16) -> io::Result<()> { - let b : [u8; 2] = [ ((n >> 8) & 0xFF) as u8, (n & 0xFF) as u8 ]; - self.write_all(&b[..]) - } - - /// Writes a big endian `u32`. - fn write_be_u32(&mut self, n: u32) -> io::Result<()> { - let b : [u8; 4] = [ (n >> 24) as u8, ((n >> 16) & 0xFF) as u8, - ((n >> 8) & 0xFF) as u8, (n & 0xFF) as u8 ]; - self.write_all(&b[..]) - } -} - -/// Make a `Box` look like a Stackable. -impl <'a, C> Stackable<'a, C> for Stack<'a, C> { - fn into_inner(self: Box) -> Result>> { - (*self).into_inner() - } - /// Recovers the inner stackable. - fn pop(&mut self) -> Result>> { - self.as_mut().pop() - } - /// Sets the inner stackable. - fn mount(&mut self, new: Stack<'a, C>) { - self.as_mut().mount(new); - } - fn inner_mut(&mut self) -> Option<&mut Stackable<'a, C>> { - self.as_mut().inner_mut() - } - fn inner_ref(&self) -> Option<&Stackable<'a, C>> { - self.as_ref().inner_ref() - } - fn cookie_set(&mut self, cookie: C) -> C { - self.as_mut().cookie_set(cookie) - } - fn cookie_ref(&self) -> &C { - self.as_ref().cookie_ref() - } - fn cookie_mut(&mut self) -> &mut C { - self.as_mut().cookie_mut() - } -} - -/// Maps a function over the stack of writers. -#[allow(dead_code)] -pub fn map(head: &Stackable, mut fun: F) - where F: FnMut(&Stackable) -> bool { - let mut ow = Some(head); - while let Some(w) = ow { - if ! fun(w) { - break; - } - ow = w.inner_ref() - } -} - -/// Maps a function over the stack of mutable writers. -#[allow(dead_code)] -pub fn map_mut(head: &mut Stackable, mut fun: F) - where F: FnMut(&mut Stackable) -> bool { - let mut ow = Some(head); - while let Some(w) = ow { - if ! fun(w) { - break; - } - ow = w.inner_mut() - } -} - -/// Dumps the writer stack. -#[allow(dead_code)] -pub fn dump(head: &Stackable) { - let mut depth = 0; - map(head, |w| { - eprintln!("{}: {:?}", depth, w); - depth += 1; - true - }); -} - -pub struct Identity<'a, C> { - inner: Option>, - cookie: C, -} - -impl<'a, C: 'a> Identity<'a, C> { - pub fn new(inner: Stack<'a, C>, cookie: C) - -> Stack<'a, C> { - Box::new(Self{inner: Some(inner), cookie: cookie}) - } -} - -impl<'a, C> fmt::Debug for Identity<'a, C> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("Identity") - .field("inner", &self.inner) - .finish() - } -} - -impl<'a, C> io::Write for Identity<'a, C> { - fn write(&mut self, buf: &[u8]) -> io::Result { - let writer = self.inner.as_mut() - .ok_or_else(|| io::Error::new(io::ErrorKind::BrokenPipe, - "Writer is finalized."))?; - writer.write(buf) - } - - fn flush(&mut self) -> io::Result<()> { - let writer = self.inner.as_mut() - .ok_or_else(|| io::Error::new(io::ErrorKind::BrokenPipe, - "Writer is finalized."))?; - writer.flush() - } -} - -impl<'a, C> Stackable<'a, C> for Identity<'a, C> { - /// Recovers the inner stackable. - fn into_inner(self: Box) -> Result>> { - Ok(self.inner) - } - /// Recovers the inner stackable. - fn pop(&mut self) -> Result>> { - Ok(self.inner.take()) - } - /// Sets the inner stackable. - fn mount(&mut self, new: Stack<'a, C>) { - self.inner = Some(new); - } - fn inner_ref(&self) -> Option<&Stackable<'a, C>> { - if let Some(ref i) = self.inner { - Some(i) - } else { - None - } - } - fn inner_mut(&mut self) -> Option<&mut Stackable<'a, C>> { - if let Some(ref mut i) = self.inner { - Some(i) - } else { - None - } - } - fn cookie_set(&mut self, cookie: C) -> C { - ::std::mem::replace(&mut self.cookie, cookie) - } - fn cookie_ref(&self) -> &C { - &self.cookie - } - fn cookie_mut(&mut self) -> &mut C { - &mut self.cookie - } -} - -/// Generic writer wrapping `io::Write`. -pub struct Generic { - inner: W, - cookie: C, -} - -impl<'a, W: 'a + io::Write, C: 'a> Generic { - pub fn new(inner: W, cookie: C) -> Stack<'a, C> { - Box::new(Self::new_unboxed(inner, cookie)) - } - - fn new_unboxed(inner: W, cookie: C) -> Self { - Generic { - inner: inner, - cookie: cookie, - } - } -} - -impl fmt::Debug for Generic { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("writer::Generic") - .finish() - } -} - -impl io::Write for Generic { - fn write(&mut self, bytes: &[u8]) -> io::Result { - self.inner.write(bytes) - } - - fn flush(&mut self) -> io::Result<()> { - self.inner.flush() - } -} - -impl<'a, W: io::Write, C> Stackable<'a, C> for Generic { - /// Recovers the inner stackable. - fn into_inner(self: Box) -> Result>> { - Ok(None) - } - /// Recovers the inner stackable. - fn pop(&mut self) -> Result>> { - Ok(None) - } - /// Sets the inner stackable. - fn mount(&mut self, _new: Stack<'a, C>) { - } - fn inner_mut(&mut self) -> Option<&mut Stackable<'a, C>> { - None - } - fn inner_ref(&self) -> Option<&Stackable<'a, C>> { - None - } - fn cookie_set(&mut self, cookie: C) -> C { - ::std::mem::replace(&mut self.cookie, cookie) - } - fn cookie_ref(&self) -> &C { - &self.cookie - } - fn cookie_mut(&mut self) -> &mut C { - &mut self.cookie - } -} - -/// ZIPing writer. -pub struct ZIP<'a, C> { - inner: Generic>, C>, -} - -impl<'a, C> ZIP<'a, C> { - pub fn new(inner: Stack<'a, C>, cookie: C) -> Box { - Box::new(ZIP { - inner: Generic::new_unboxed( - DeflateEncoder::new(inner, FlateCompression::default()), - cookie), - }) - } -} - -impl<'a, C:> fmt::Debug for ZIP<'a, C> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("writer::ZIP") - .field("inner", &self.inner) - .finish() - } -} - -impl<'a, C> io::Write for ZIP<'a, C> { - fn write(&mut self, bytes: &[u8]) -> io::Result { - self.inner.write(bytes) - } - - fn flush(&mut self) -> io::Result<()> { - self.inner.flush() - } -} - -impl<'a, C> Stackable<'a, C> for ZIP<'a, C> { - fn into_inner(self: Box) -> Result>> { - let inner = self.inner.inner.finish()?; - Ok(Some(inner)) - } - fn pop(&mut self) -> Result>> { - unimplemented!() - } - fn mount(&mut self, _new: Stack<'a, C>) { - unimplemented!() - } - fn inner_mut(&mut self) -> Option<&mut Stackable<'a, C>> { - self.inner.inner_mut() - } - fn inner_ref(&self) -> Option<&Stackable<'a, C>> { - self.inner.inner_ref() - } - fn cookie_set(&mut self, cookie: C) -> C { - self.inner.cookie_set(cookie) - } - fn cookie_ref(&self) -> &C { - self.inner.cookie_ref() - } - fn cookie_mut(&mut self) -> &mut C { - self.inner.cookie_mut() - } -} - -/// ZLIBing writer. -pub struct ZLIB<'a, C> { - inner: Generic>, C>, -} - -impl<'a, C> ZLIB<'a, C> { - pub fn new(inner: Stack<'a, C>, cookie: C) -> Box { - Box::new(ZLIB { - inner: Generic::new_unboxed( - ZlibEncoder::new(inner, FlateCompression::default()), - cookie), - }) - } -} - -impl<'a, C:> fmt::Debug for ZLIB<'a, C> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("writer::ZLIB") - .field("inner", &self.inner) - .finish() - } -} - -impl<'a, C> io::Write for ZLIB<'a, C> { - fn write(&mut self, bytes: &[u8]) -> io::Result { - self.inner.write(bytes) - } - - fn flush(&mut self) -> io::Result<()> { - self.inner.flush() - } -} - -impl<'a, C> Stackable<'a, C> for ZLIB<'a, C> { - fn into_inner(self: Box) -> Result>> { - let inner = self.inner.inner.finish()?; - Ok(Some(inner)) - } - fn pop(&mut self) -> Result>> { - unimplemented!() - } - fn mount(&mut self, _new: Stack<'a, C>) { - unimplemented!() - } - fn inner_mut(&mut self) -> Option<&mut Stackable<'a, C>> { - self.inner.inner_mut() - } - fn inner_ref(&self) -> Option<&Stackable<'a, C>> { - self.inner.inner_ref() - } - fn cookie_set(&mut self, cookie: C) -> C { - self.inner.cookie_set(cookie) - } - fn cookie_ref(&self) -> &C { - self.inner.cookie_ref() - } - fn cookie_mut(&mut self) -> &mut C { - self.inner.cookie_mut() - } -} - -/// BZing writer. -pub struct BZ<'a, C> { - inner: Generic>, C>, -} - -impl<'a, C> BZ<'a, C> { - pub fn new(inner: Stack<'a, C>, cookie: C) -> Box { - Box::new(BZ { - inner: Generic::new_unboxed( - BzEncoder::new(inner, BzCompression::Default), - cookie), - }) - } -} - -impl<'a, C:> fmt::Debug for BZ<'a, C> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("writer::BZ") - .field("inner", &self.inner) - .finish() - } -} - -impl<'a, C> io::Write for BZ<'a, C> { - fn write(&mut self, bytes: &[u8]) -> io::Result { - self.inner.write(bytes) - } - - fn flush(&mut self) -> io::Result<()> { - self.inner.flush() - } -} - -impl<'a, C> Stackable<'a, C> for BZ<'a, C> { - fn into_inner(self: Box) -> Result>> { - let inner = self.inner.inner.finish()?; - Ok(Some(inner)) - } - fn pop(&mut self) -> Result>> { - unimplemented!() - } - fn mount(&mut self, _new: Stack<'a, C>) { - unimplemented!() - } - fn inner_mut(&mut self) -> Option<&mut Stackable<'a, C>> { - self.inner.inner_mut() - } - fn inner_ref(&self) -> Option<&Stackable<'a, C>> { - self.inner.inner_ref() - } - fn cookie_set(&mut self, cookie: C) -> C { - self.inner.cookie_set(cookie) - } - fn cookie_ref(&self) -> &C { - self.inner.cookie_ref() - } - fn cookie_mut(&mut self) -> &mut C { - self.inner.cookie_mut() - } -} - -/// Encrypting writer. -pub struct Encryptor<'a, C> { - inner: Generic>, C>, -} - -impl<'a, C> Encryptor<'a, C> { - pub fn new(inner: Stack<'a, C>, cookie: C, algo: SymmetricAlgorithm, - key: &[u8]) - -> Result> - { - Ok(Box::new(Encryptor { - inner: Generic::new_unboxed( - symmetric::Encryptor::new(algo, key, inner)?, - cookie), - })) - } -} - -impl<'a, C:> fmt::Debug for Encryptor<'a, C> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("writer::Encryptor") - .field("inner", &self.inner) - .finish() - } -} - -impl<'a, C> io::Write for Encryptor<'a, C> { - fn write(&mut self, bytes: &[u8]) -> io::Result { - self.inner.write(bytes) - } - - fn flush(&mut self) -> io::Result<()> { - self.inner.flush() - } -} - -impl<'a, C> Stackable<'a, C> for Encryptor<'a, C> { - fn into_inner(mut self: Box) -> Result>> { - let inner = self.inner.inner.finish()?; - Ok(Some(inner)) - } - fn pop(&mut self) -> Result>> { - unimplemented!() - } - fn mount(&mut self, _new: Stack<'a, C>) { - unimplemented!() - } - fn inner_mut(&mut self) -> Option<&mut Stackable<'a, C>> { - self.inner.inner_mut() - } - fn inner_ref(&self) -> Option<&Stackable<'a, C>> { - self.inner.inner_ref() - } - fn cookie_set(&mut self, cookie: C) -> C { - self.inner.cookie_set(cookie) - } - fn cookie_ref(&self) -> &C { - self.inner.cookie_ref() - } - fn cookie_mut(&mut self) -> &mut C { - self.inner.cookie_mut() - } -} - -#[cfg(test)] -mod test { - use std::io::Write; - use super::*; - - #[derive(Debug)] - struct Cookie { - state: &'static str, - } - - #[test] - fn generic_writer() { - let mut inner = Vec::new(); - { - let mut w = Generic::new(&mut inner, Cookie { state: "happy" }); - assert_eq!(w.cookie_ref().state, "happy"); - dump(&w); - - w.cookie_mut().state = "sad"; - assert_eq!(w.cookie_ref().state, "sad"); - - w.write_all(b"be happy").unwrap(); - let mut count = 0; - map_mut(&mut w, |g| { - let new = Cookie { state: "happy" }; - let old = g.cookie_set(new); - assert_eq!(old.state, "sad"); - count += 1; - true - }); - assert_eq!(count, 1); - assert_eq!(w.cookie_ref().state, "happy"); - } - assert_eq!(&inner, b"be happy"); - } - - #[test] - fn stack() { - let mut inner = Vec::new(); - { - let w = Generic::new(&mut inner, Cookie { state: "happy" }); - dump(&w); - - let w = Identity::new(w, Cookie { state: "happy" }); - dump(&w); - - let mut count = 0; - map(&w, |g| { - assert_eq!(g.cookie_ref().state, "happy"); - count += 1; - true - }); - assert_eq!(count, 2); - } - } - -} diff --git a/openpgp/src/serialize/writer/mod.rs b/openpgp/src/serialize/writer/mod.rs new file mode 100644 index 00000000..39d21bcd --- /dev/null +++ b/openpgp/src/serialize/writer/mod.rs @@ -0,0 +1,409 @@ +//! Stackable writers. + +#[cfg(feature = "compression-bzip2")] +mod writer_bzip2; +#[cfg(feature = "compression-bzip2")] +pub use self::writer_bzip2::BZ; +#[cfg(feature = "compression-deflate")] +mod writer_deflate; +#[cfg(feature = "compression-deflate")] +pub use self::writer_deflate::{ZIP, ZLIB}; + +use std::fmt; +use std::io; + +use symmetric; +use { + Result, + SymmetricAlgorithm, +}; + +/// A stack of writers. +/// +/// We use trait objects as the unit of composition. This is a +/// compiler limitation, we may use impl trait in the future. +pub type Stack<'a, C> = Box<'a + Stackable<'a, C>>; + +/// Makes a writer stackable and provides convenience functions. +pub trait Stackable<'a, C> : io::Write + fmt::Debug { + /// Recovers the inner stackable. + /// + /// This can fail if the current `Stackable` has buffered data + /// that hasn't been written to the underlying `Stackable`. + fn into_inner(self: Box) -> Result>>; + + /// Pops the stackable from the stack, detaching it. + /// + /// Returns the detached stack. + fn pop(&mut self) -> Result>>; + + /// Sets the inner stackable. + fn mount(&mut self, new: Stack<'a, C>); + + /// Returns a mutable reference to the inner `Writer`, if + /// any. + /// + /// It is a very bad idea to write any data from the inner + /// `Writer`, but it can sometimes be useful to get the cookie. + fn inner_mut(&mut self) -> Option<&mut Stackable<'a, C>>; + + /// Returns a reference to the inner `Writer`. + fn inner_ref(&self) -> Option<&Stackable<'a, C>>; + + /// Sets the cookie and returns the old value. + fn cookie_set(&mut self, cookie: C) -> C; + + /// Returns a reference to the cookie. + fn cookie_ref(&self) -> &C; + + /// Returns a mutable reference to the cookie. + fn cookie_mut(&mut self) -> &mut C; + + /// Writes a byte. + fn write_u8(&mut self, b: u8) -> io::Result<()> { + let b : [u8; 1] = [b; 1]; + self.write_all(&b[..]) + } + + /// Writes a big endian `u16`. + fn write_be_u16(&mut self, n: u16) -> io::Result<()> { + let b : [u8; 2] = [ ((n >> 8) & 0xFF) as u8, (n & 0xFF) as u8 ]; + self.write_all(&b[..]) + } + + /// Writes a big endian `u32`. + fn write_be_u32(&mut self, n: u32) -> io::Result<()> { + let b : [u8; 4] = [ (n >> 24) as u8, ((n >> 16) & 0xFF) as u8, + ((n >> 8) & 0xFF) as u8, (n & 0xFF) as u8 ]; + self.write_all(&b[..]) + } +} + +/// Make a `Box` look like a Stackable. +impl <'a, C> Stackable<'a, C> for Stack<'a, C> { + fn into_inner(self: Box) -> Result>> { + (*self).into_inner() + } + /// Recovers the inner stackable. + fn pop(&mut self) -> Result>> { + self.as_mut().pop() + } + /// Sets the inner stackable. + fn mount(&mut self, new: Stack<'a, C>) { + self.as_mut().mount(new); + } + fn inner_mut(&mut self) -> Option<&mut Stackable<'a, C>> { + self.as_mut().inner_mut() + } + fn inner_ref(&self) -> Option<&Stackable<'a, C>> { + self.as_ref().inner_ref() + } + fn cookie_set(&mut self, cookie: C) -> C { + self.as_mut().cookie_set(cookie) + } + fn cookie_ref(&self) -> &C { + self.as_ref().cookie_ref() + } + fn cookie_mut(&mut self) -> &mut C { + self.as_mut().cookie_mut() + } +} + +/// Maps a function over the stack of writers. +#[allow(dead_code)] +pub fn map(head: &Stackable, mut fun: F) + where F: FnMut(&Stackable) -> bool { + let mut ow = Some(head); + while let Some(w) = ow { + if ! fun(w) { + break; + } + ow = w.inner_ref() + } +} + +/// Maps a function over the stack of mutable writers. +#[allow(dead_code)] +pub fn map_mut(head: &mut Stackable, mut fun: F) + where F: FnMut(&mut Stackable) -> bool { + let mut ow = Some(head); + while let Some(w) = ow { + if ! fun(w) { + break; + } + ow = w.inner_mut() + } +} + +/// Dumps the writer stack. +#[allow(dead_code)] +pub fn dump(head: &Stackable) { + let mut depth = 0; + map(head, |w| { + eprintln!("{}: {:?}", depth, w); + depth += 1; + true + }); +} + +pub struct Identity<'a, C> { + inner: Option>, + cookie: C, +} + +impl<'a, C: 'a> Identity<'a, C> { + pub fn new(inner: Stack<'a, C>, cookie: C) + -> Stack<'a, C> { + Box::new(Self{inner: Some(inner), cookie: cookie}) + } +} + +impl<'a, C> fmt::Debug for Identity<'a, C> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.debug_struct("Identity") + .field("inner", &self.inner) + .finish() + } +} + +impl<'a, C> io::Write for Identity<'a, C> { + fn write(&mut self, buf: &[u8]) -> io::Result { + let writer = self.inner.as_mut() + .ok_or_else(|| io::Error::new(io::ErrorKind::BrokenPipe, + "Writer is finalized."))?; + writer.write(buf) + } + + fn flush(&mut self) -> io::Result<()> { + let writer = self.inner.as_mut() + .ok_or_else(|| io::Error::new(io::ErrorKind::BrokenPipe, + "Writer is finalized."))?; + writer.flush() + } +} + +impl<'a, C> Stackable<'a, C> for Identity<'a, C> { + /// Recovers the inner stackable. + fn into_inner(self: Box) -> Result>> { + Ok(self.inner) + } + /// Recovers the inner stackable. + fn pop(&mut self) -> Result>> { + Ok(self.inner.take()) + } + /// Sets the inner stackable. + fn mount(&mut self, new: Stack<'a, C>) { + self.inner = Some(new); + } + fn inner_ref(&self) -> Option<&Stackable<'a, C>> { + if let Some(ref i) = self.inner { + Some(i) + } else { + None + } + } + fn inner_mut(&mut self) -> Option<&mut Stackable<'a, C>> { + if let Some(ref mut i) = self.inner { + Some(i) + } else { + None + } + } + fn cookie_set(&mut self, cookie: C) -> C { + ::std::mem::replace(&mut self.cookie, cookie) + } + fn cookie_ref(&self) -> &C { + &self.cookie + } + fn cookie_mut(&mut self) -> &mut C { + &mut self.cookie + } +} + +/// Generic writer wrapping `io::Write`. +pub struct Generic { + inner: W, + cookie: C, +} + +impl<'a, W: 'a + io::Write, C: 'a> Generic { + pub fn new(inner: W, cookie: C) -> Stack<'a, C> { + Box::new(Self::new_unboxed(inner, cookie)) + } + + fn new_unboxed(inner: W, cookie: C) -> Self { + Generic { + inner: inner, + cookie: cookie, + } + } +} + +impl fmt::Debug for Generic { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.debug_struct("writer::Generic") + .finish() + } +} + +impl io::Write for Generic { + fn write(&mut self, bytes: &[u8]) -> io::Result { + self.inner.write(bytes) + } + + fn flush(&mut self) -> io::Result<()> { + self.inner.flush() + } +} + +impl<'a, W: io::Write, C> Stackable<'a, C> for Generic { + /// Recovers the inner stackable. + fn into_inner(self: Box) -> Result>> { + Ok(None) + } + /// Recovers the inner stackable. + fn pop(&mut self) -> Result>> { + Ok(None) + } + /// Sets the inner stackable. + fn mount(&mut self, _new: Stack<'a, C>) { + } + fn inner_mut(&mut self) -> Option<&mut Stackable<'a, C>> { + None + } + fn inner_ref(&self) -> Option<&Stackable<'a, C>> { + None + } + fn cookie_set(&mut self, cookie: C) -> C { + ::std::mem::replace(&mut self.cookie, cookie) + } + fn cookie_ref(&self) -> &C { + &self.cookie + } + fn cookie_mut(&mut self) -> &mut C { + &mut self.cookie + } +} + + +/// Encrypting writer. +pub struct Encryptor<'a, C> { + inner: Generic>, C>, +} + +impl<'a, C> Encryptor<'a, C> { + pub fn new(inner: Stack<'a, C>, cookie: C, algo: SymmetricAlgorithm, + key: &[u8]) + -> Result> + { + Ok(Box::new(Encryptor { + inner: Generic::new_unboxed( + symmetric::Encryptor::new(algo, key, inner)?, + cookie), + })) + } +} + +impl<'a, C:> fmt::Debug for Encryptor<'a, C> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.debug_struct("writer::Encryptor") + .field("inner", &self.inner) + .finish() + } +} + +impl<'a, C> io::Write for Encryptor<'a, C> { + fn write(&mut self, bytes: &[u8]) -> io::Result { + self.inner.write(bytes) + } + + fn flush(&mut self) -> io::Result<()> { + self.inner.flush() + } +} + +impl<'a, C> Stackable<'a, C> for Encryptor<'a, C> { + fn into_inner(mut self: Box) -> Result>> { + let inner = self.inner.inner.finish()?; + Ok(Some(inner)) + } + fn pop(&mut self) -> Result>> { + unimplemented!() + } + fn mount(&mut self, _new: Stack<'a, C>) { + unimplemented!() + } + fn inner_mut(&mut self) -> Option<&mut Stackable<'a, C>> { + self.inner.inner_mut() + } + fn inner_ref(&self) -> Option<&Stackable<'a, C>> { + self.inner.inner_ref() + } + fn cookie_set(&mut self, cookie: C) -> C { + self.inner.cookie_set(cookie) + } + fn cookie_ref(&self) -> &C { + self.inner.cookie_ref() + } + fn cookie_mut(&mut self) -> &mut C { + self.inner.cookie_mut() + } +} + +#[cfg(test)] +mod test { + use std::io::Write; + use super::*; + + #[derive(Debug)] + struct Cookie { + state: &'static str, + } + + #[test] + fn generic_writer() { + let mut inner = Vec::new(); + { +