buffered-reader: Require Cookies to be Send and Sync.

- This way the entire `BufferedReader<C>` will be `Send` and `Sync`.

- Modify all other crates accordingly.

- See #615.

12 files changed, 46 insertions, 45 deletions

diff --git a/openpgp/src/armor.rs b/openpgp/src/armor.rs
index 686ea939..88b31a6c 100644
--- a/openpgp/src/armor.rs
+++ b/openpgp/src/armor.rs
@@ -486,6 +486,7 @@ struct IoReader<'a> {
     prefix_len: usize,
     prefix_remaining: usize,
 }
+assert_send_and_sync!(IoReader<'_>);
 
 impl Default for ReaderMode {
     fn default() -> Self {
@@ -563,7 +564,7 @@ impl<'a> Reader<'a> {
     /// # }
     /// ```
     pub fn new<R, M>(inner: R, mode: M) -> Self
-        where R: 'a + Read,
+        where R: 'a + Read + Send + Sync,
               M: Into<Option<ReaderMode>>
     {
         Self::from_buffered_reader(
@@ -574,7 +575,7 @@ impl<'a> Reader<'a> {
 
     /// Creates a `Reader` from an `io::Read`er.
     pub fn from_reader<R, M>(reader: R, mode: M) -> Self
-        where R: 'a + Read,
+        where R: 'a + Read + Send + Sync,
               M: Into<Option<ReaderMode>>
     {
         Self::from_buffered_reader(
diff --git a/openpgp/src/cert.rs b/openpgp/src/cert.rs
index 7acf8e4e..bb2970fc 100644
--- a/openpgp/src/cert.rs
+++ b/openpgp/src/cert.rs
@@ -740,7 +740,7 @@ impl std::str::FromStr for Cert {
 
 impl<'a> Parse<'a, Cert> for Cert {
     /// Returns the first Cert encountered in the reader.
-    fn from_reader<R: io::Read>(reader: R) -> Result<Self> {
+    fn from_reader<R: io::Read + Send + Sync>(reader: R) -> Result<Self> {
         Cert::try_from(PacketParser::from_reader(reader)?)
     }
 
@@ -752,7 +752,7 @@ impl<'a> Parse<'a, Cert> for Cert {
     /// Returns the first Cert found in `buf`.
     ///
     /// `buf` must be an OpenPGP-encoded message.
-    fn from_bytes<D: AsRef<[u8]> + ?Sized>(data: &'a D) -> Result<Self> {
+    fn from_bytes<D: AsRef<[u8]> + ?Sized + Send + Sync>(data: &'a D) -> Result<Self> {
         Cert::try_from(PacketParser::from_bytes(data)?)
     }
 }
diff --git a/openpgp/src/cert/parser/mod.rs b/openpgp/src/cert/parser/mod.rs
index 5538bbf1..48b340c9 100644
--- a/openpgp/src/cert/parser/mod.rs
+++ b/openpgp/src/cert/parser/mod.rs
@@ -610,7 +610,7 @@ impl<'a> From<Vec<Packet>> for CertParser<'a> {
 impl<'a> Parse<'a, CertParser<'a>> for CertParser<'a>
 {
     /// Initializes a `CertParser` from a `Read`er.
-    fn from_reader<R: 'a + io::Read>(reader: R) -> Result<Self> {
+    fn from_reader<R: 'a + io::Read + Send + Sync>(reader: R) -> Result<Self> {
         Ok(Self::from(PacketParser::from_reader(reader)?))
     }
 
@@ -620,7 +620,7 @@ impl<'a> Parse<'a, CertParser<'a>> for CertParser<'a>
     }
 
     /// Initializes a `CertParser` from a byte string.
-    fn from_bytes<D: AsRef<[u8]> + ?Sized>(data: &'a D) -> Result<Self> {
+    fn from_bytes<D: AsRef<[u8]> + ?Sized + Send + Sync>(data: &'a D) -> Result<Self> {
         Ok(Self::from(PacketParser::from_bytes(data)?))
     }
 }
diff --git a/openpgp/src/crypto/aead.rs b/openpgp/src/crypto/aead.rs
index fb95b087..5e9b5eeb 100644
--- a/openpgp/src/crypto/aead.rs
+++ b/openpgp/src/crypto/aead.rs
@@ -121,7 +121,7 @@ impl<'a> Decryptor<'a> {
     /// Instantiate a new AEAD decryptor.
     ///
     /// `source` is the source to wrap.
-    pub fn new<R: io::Read>(version: u8, sym_algo: SymmetricAlgorithm,
+    pub fn new<R: io::Read + Send + Sync>(version: u8, sym_algo: SymmetricAlgorithm,
                             aead: AEADAlgorithm, chunk_size: usize,
                             iv: &[u8], key: &SessionKey, source: R)
         -> Result<Self>
diff --git a/openpgp/src/crypto/symmetric.rs b/openpgp/src/crypto/symmetric.rs
index 0a022cc3..381cbe95 100644
--- a/openpgp/src/crypto/symmetric.rs
+++ b/openpgp/src/crypto/symmetric.rs
@@ -194,11 +194,11 @@ impl<R: io::Read> io::Read for Decryptor<R> {
 
 /// A `BufferedReader` that decrypts symmetrically-encrypted data as
 /// it is read.
-pub(crate) struct BufferedReaderDecryptor<R: BufferedReader<C>, C: fmt::Debug> {
+pub(crate) struct BufferedReaderDecryptor<R: BufferedReader<C>, C: fmt::Debug + Send + Sync> {
     reader: buffered_reader::Generic<Decryptor<R>, C>,
 }
 
-impl <R: BufferedReader<C>, C: fmt::Debug> BufferedReaderDecryptor<R, C> {
+impl <R: BufferedReader<C>, C: fmt::Debug + Send + Sync> BufferedReaderDecryptor<R, C> {
     /// 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.
@@ -213,19 +213,19 @@ impl <R: BufferedReader<C>, C: fmt::Debug> BufferedReaderDecryptor<R, C> {
     }
 }
 
-impl<R: BufferedReader<C>, C: fmt::Debug> io::Read for BufferedReaderDecryptor<R, C> {
+impl<R: BufferedReader<C>, C: fmt::Debug + Send + Sync> io::Read for BufferedReaderDecryptor<R, C> {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         self.reader.read(buf)
     }
 }
 
-impl<R: BufferedReader<C>, C: fmt::Debug> fmt::Display for BufferedReaderDecryptor<R, C> {
+impl<R: BufferedReader<C>, C: fmt::Debug + Send + Sync> fmt::Display for BufferedReaderDecryptor<R, C> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "BufferedReaderDecryptor")
     }
 }
 
-impl<R: BufferedReader<C>, C: fmt::Debug> fmt::Debug for BufferedReaderDecryptor<R, C> {
+impl<R: BufferedReader<C>, C: fmt::Debug + Send + Sync> fmt::Debug for BufferedReaderDecryptor<R, C> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("BufferedReaderDecryptor")
             .field("reader", &self.get_ref().unwrap())
@@ -233,7 +233,7 @@ impl<R: BufferedReader<C>, C: fmt::Debug> fmt::Debug for BufferedReaderDecryptor
     }
 }
 
-impl<R: BufferedReader<C>, C: fmt::Debug> BufferedReader<C>
+impl<R: BufferedReader<C>, C: fmt::Debug + Send + Sync> BufferedReader<C>
         for BufferedReaderDecryptor<R, C> {
     fn buffer(&self) -> &[u8] {
         return self.reader.buffer();
diff --git a/openpgp/src/message/mod.rs b/openpgp/src/message/mod.rs
index e92581a5..2fb0daa3 100644
--- a/openpgp/src/message/mod.rs
+++ b/openpgp/src/message/mod.rs
@@ -363,7 +363,7 @@ impl<'a> Parse<'a, Message> for Message {
     /// See [`Message::try_from`] for more details.
     ///
     ///   [`Message::try_from`]: #method.try_from
-    fn from_reader<R: 'a + io::Read>(reader: R) -> Result<Self> {
+    fn from_reader<R: 'a + io::Read + Send + Sync>(reader: R) -> Result<Self> {
         Self::try_from(PacketPile::from_reader(reader)?)
     }
 
@@ -381,7 +381,7 @@ impl<'a> Parse<'a, Message> for Message {
     /// See [`Message::try_from`] for more details.
     ///
     ///   [`Message::try_from`]: #method.try_from
-    fn from_bytes<D: AsRef<[u8]> + ?Sized>(data: &'a D) -> Result<Self> {
+    fn from_bytes<D: AsRef<[u8]> + ?Sized + Send + Sync>(data: &'a D) -> Result<Self> {
         Self::try_from(PacketPile::from_bytes(data)?)
     }
 }
diff --git a/openpgp/src/packet_pile.rs b/openpgp/src/packet_pile.rs
index 09a432b2..330d02cf 100644
--- a/openpgp/src/packet_pile.rs
+++ b/openpgp/src/packet_pile.rs
@@ -137,7 +137,7 @@ impl<'a> Parse<'a, PacketPile> for PacketPile {
     ///
     ///   [`PacketParser`]: parse/struct.PacketParser.html
     ///   [`PacketPileParser`]: parse/struct.PacketPileParser.html
-    fn from_reader<R: 'a + io::Read>(reader: R) -> Result<PacketPile> {
+    fn from_reader<R: 'a + io::Read + Send + Sync>(reader: R) -> Result<PacketPile> {
         let bio = buffered_reader::Generic::with_cookie(
             reader, None, Cookie::default());
         PacketPile::from_buffered_reader(Box::new(bio))
diff --git a/openpgp/src/parse.rs b/openpgp/src/parse.rs
index 5840436c..e557850e 100644
--- a/openpgp/src/parse.rs
+++ b/openpgp/src/parse.rs
@@ -270,7 +270,7 @@ const TRACE : bool = false;
 /// related data structures.
 pub trait Parse<'a, T> {
     /// Reads from the given reader.
-    fn from_reader<R: 'a + Read>(reader: R) -> Result<T>;
+    fn from_reader<R: 'a + Read + Send + Sync>(reader: R) -> Result<T>;
 
     /// Reads from the given file.
     ///
@@ -289,7 +289,7 @@ pub trait Parse<'a, T> {
     /// implementations can provide their own specialized version.
     ///
     /// [`from_reader(..)`]: #tymethod.from_reader
-    fn from_bytes<D: AsRef<[u8]> + ?Sized>(data: &'a D) -> Result<T> {
+    fn from_bytes<D: AsRef<[u8]> + ?Sized + Send + Sync>(data: &'a D) -> Result<T> {
         Self::from_reader(io::Cursor::new(data))
     }
 }
@@ -297,7 +297,7 @@ pub trait Parse<'a, T> {
 macro_rules! impl_parse_generic_packet {
     ($typ: ident) => {
         impl<'a> Parse<'a, $typ> for $typ {
-            fn from_reader<R: 'a + Read>(reader: R) -> Result<Self> {
+            fn from_reader<R: 'a + Read + Send + Sync>(reader: R) -> Result<Self> {
                 let bio = buffered_reader::Generic::with_cookie(
                     reader, None, Cookie::default());
                 let parser = PacketHeaderParser::new_naked(bio);
@@ -1082,7 +1082,7 @@ impl S2K {
 
 impl<'a> Parse<'a, S2K> for S2K {
     /// Reads an S2K from `reader`.
-    fn from_reader<R: 'a + Read>(reader: R) -> Result<Self> {
+    fn from_reader<R: 'a + Read + Send + Sync>(reader: R) -> Result<Self> {
         let bio = buffered_reader::Generic::with_cookie(
             reader, None, Cookie::default());
         let mut parser = PacketHeaderParser::new_naked(bio);
@@ -1091,7 +1091,7 @@ impl<'a> Parse<'a, S2K> for S2K {
 }
 
 impl Header {
-    pub(crate) fn parse<R: BufferedReader<C>, C: fmt::Debug> (bio: &mut R)
+    pub(crate) fn parse<R: BufferedReader<C>, C: fmt::Debug + Send + Sync> (bio: &mut R)
         -> Result<Header>
     {
         let ctb = CTB::try_from(bio.data_consume_hard(1)?[0])?;
@@ -1109,7 +1109,7 @@ impl<'a> Parse<'a, Header> for Header {
     /// of RFC 4880].
     ///
     ///   [Section 4.2 of RFC 4880]: https://tools.ietf.org/html/rfc4880#section-4.2
-    fn from_reader<R: 'a + Read>(reader: R) -> Result<Self>
+    fn from_reader<R: 'a + Read + Send + Sync>(reader: R) -> Result<Self>
     {
         let mut reader = buffered_reader::Generic::with_cookie(
             reader, None, Cookie::default());
@@ -1122,7 +1122,7 @@ impl BodyLength {
     /// 4.2.2 of RFC 4880].
     ///
     ///   [Section 4.2.2 of RFC 4880]: https://tools.ietf.org/html/rfc4880#section-4.2.2
-    pub(crate) fn parse_new_format<T: BufferedReader<C>, C: fmt::Debug> (bio: &mut T)
+    pub(crate) fn parse_new_format<T: BufferedReader<C>, C: fmt::Debug + Send + Sync> (bio: &mut T)
         -> io::Result<BodyLength>
     {
         let octet1 : u8 = bio.data_consume_hard(1)?[0];
@@ -1145,7 +1145,7 @@ impl BodyLength {
     /// 4.2.1 of RFC 4880].
     ///
     ///   [Section 4.2.1 of RFC 4880]: https://tools.ietf.org/html/rfc4880#section-4.2.1
-    pub(crate) fn parse_old_format<T: BufferedReader<C>, C: fmt::Debug>
+    pub(crate) fn parse_old_format<T: BufferedReader<C>, C: fmt::Debug + Send + Sync>
         (bio: &mut T, length_type: PacketLengthType)
          -> Result<BodyLength>
     {
@@ -1230,7 +1230,7 @@ impl Unknown {
 // Note: we only need this function for testing purposes in a
 // different module.
 #[cfg(test)]
-pub(crate) fn to_unknown_packet<R: Read>(reader: R) -> Result<Unknown>
+pub(crate) fn to_unknown_packet<R: Read + Send + Sync>(reader: R) -> Result<Unknown>
 {
     let mut reader = buffered_reader::Generic::with_cookie(
         reader, None, Cookie::default());
@@ -1732,7 +1732,7 @@ impl Subpacket {
 
 impl SubpacketLength {
     /// Parses a subpacket length.
-    fn parse<R: BufferedReader<C>, C: fmt::Debug>(bio: &mut R) -> Result<Self> {
+    fn parse<R: BufferedReader<C>, C: fmt::Debug + Send + Sync>(bio: &mut R) -> Result<Self> {
         let octet1 = bio.data_consume_hard(1)?[0];
         if octet1 < 192 {
             // One octet.
@@ -1964,7 +1964,7 @@ fn one_pass_sig_parser_test () {
 }
 
 impl<'a> Parse<'a, OnePassSig3> for OnePassSig3 {
-    fn from_reader<R: 'a + Read>(reader: R) -> Result<Self> {
+    fn from_reader<R: 'a + Read + Send + Sync>(reader: R) -> Result<Self> {
         OnePassSig::from_reader(reader).and_then(|p| match p {
             OnePassSig::V3(p) => Ok(p),
             // XXX: Once we have a second variant.
@@ -2238,7 +2238,7 @@ impl Key4<key::UnspecifiedParts, key::UnspecifiedRole>
 }
 
 impl<'a> Parse<'a, key::UnspecifiedKey> for key::UnspecifiedKey {
-    fn from_reader<R: 'a + Read>(reader: R) -> Result<Self> {
+    fn from_reader<R: 'a + Read + Send + Sync>(reader: R) -> Result<Self> {
         let bio = buffered_reader::Generic::with_cookie(
             reader, None, Cookie::default());
         let parser = PacketHeaderParser::new_naked(bio);
@@ -2863,7 +2863,7 @@ impl MPI {
 
 impl<'a> Parse<'a, MPI> for MPI {
     // Reads an MPI from `reader`.
-    fn from_reader<R: io::Read>(reader: R) -> Result<Self> {
+    fn from_reader<R: io::Read + Send + Sync>(reader: R) -> Result<Self> {
         let bio = buffered_reader::Generic::with_cookie(
             reader, None, Cookie::default());
         let mut parser = PacketHeaderParser::new_naked(bio);
@@ -2904,7 +2904,7 @@ impl PKESK3 {
 }
 
 impl<'a> Parse<'a, PKESK3> for PKESK3 {
-    fn from_reader<R: 'a + Read>(reader: R) -> Result<Self> {
+    fn from_reader<R: 'a + Read + Send + Sync>(reader: R) -> Result<Self> {
         PKESK::from_reader(reader).and_then(|p| match p {
             PKESK::V3(p) => Ok(p),
             // XXX: Once we have a second variant.
@@ -2916,7 +2916,7 @@ impl<'a> Parse<'a, PKESK3> for PKESK3 {
 }
 
 impl<'a> Parse<'a, Packet> for Packet {
-    fn from_reader<R: 'a + Read>(reader: R) -> Result<Self> {
+    fn from_reader<R: 'a + Read + Send + Sync>(reader: R) -> Result<Self> {
         let ppr =
             PacketParserBuilder::from_reader(reader)
             ?.buffer_unread_content().build()?;
@@ -3676,7 +3676,7 @@ impl<'a> Parse<'a, PacketParserResult<'a>> for PacketParser<'a> {
     ///
     /// This function returns a `PacketParser` for the first packet in
     /// the stream.
-    fn from_reader<R: io::Read + 'a>(reader: R)
+    fn from_reader<R: io::Read + 'a + Send + Sync>(reader: R)
             -> Result<PacketParserResult<'a>> {
         PacketParserBuilder::from_reader(reader)?.build()
     }
@@ -3694,7 +3694,7 @@ impl<'a> Parse<'a, PacketParserResult<'a>> for PacketParser<'a> {
     ///
     /// This function returns a `PacketParser` for the first packet in
     /// the stream.
-    fn from_bytes<D: AsRef<[u8]> + ?Sized>(data: &'a D)
+    fn from_bytes<D: AsRef<[u8]> + ?Sized + Send + Sync>(data: &'a D)
             -> Result<PacketParserResult<'a>> {
         PacketParserBuilder::from_bytes(data)?.build()
     }
diff --git a/openpgp/src/parse/mpis.rs b/openpgp/src/parse/mpis.rs
index b7ca51da..35537c0f 100644
--- a/openpgp/src/parse/mpis.rs
+++ b/openpgp/src/parse/mpis.rs
@@ -22,7 +22,7 @@ impl mpi::PublicKey {
     /// See [Section 3.2 of RFC 4880] for details.
     ///
     ///   [Section 3.2 of RFC 4880]: https://tools.ietf.org/html/rfc4880#section-3.2
-    pub fn parse<R: Read>(algo: PublicKeyAlgorithm, reader: R) -> Result<Self>
+    pub fn parse<R: Read + Send + Sync>(algo: PublicKeyAlgorithm, reader: R) -> Result<Self>
     {
         let bio = buffered_reader::Generic::with_cookie(
             reader, None, Cookie::default());
@@ -151,7 +151,7 @@ impl mpi::SecretKeyMaterial {
     /// Parses secret key MPIs for `algo` plus their SHA1 checksum.
     ///
     /// Fails if the checksum is wrong.
-    pub fn parse_with_checksum<R: Read>(algo: PublicKeyAlgorithm,
+    pub fn parse_with_checksum<R: Read + Send + Sync>(algo: PublicKeyAlgorithm,
                                         reader: R,
                                         checksum: mpi::SecretKeyChecksum)
                                         -> Result<Self> {
@@ -166,7 +166,7 @@ impl mpi::SecretKeyMaterial {
     /// See [Section 3.2 of RFC 4880] for details.
     ///
     ///   [Section 3.2 of RFC 4880]: https://tools.ietf.org/html/rfc4880#section-3.2
-    pub fn parse<R: Read>(algo: PublicKeyAlgorithm, reader: R) -> Result<Self>
+    pub fn parse<R: Read + Send + Sync>(algo: PublicKeyAlgorithm, reader: R) -> Result<Self>
     {
         let bio = buffered_reader::Generic::with_cookie(
             reader, None, Cookie::default());
@@ -305,7 +305,7 @@ impl mpi::Ciphertext {
     /// See [Section 3.2 of RFC 4880] for details.
     ///
     ///   [Section 3.2 of RFC 4880]: https://tools.ietf.org/html/rfc4880#section-3.2
-    pub fn parse<R: Read>(algo: PublicKeyAlgorithm, reader: R) -> Result<Self>
+    pub fn parse<R: Read + Send + Sync>(algo: PublicKeyAlgorithm, reader: R) -> Result<Self>
     {
         let bio = buffered_reader::Generic::with_cookie(
             reader, None, Cookie::default());
@@ -384,7 +384,7 @@ impl mpi::Signature {
     /// See [Section 3.2 of RFC 4880] for details.
     ///
     ///   [Section 3.2 of RFC 4880]: https://tools.ietf.org/html/rfc4880#section-3.2
-    pub fn parse<R: Read>(algo: PublicKeyAlgorithm, reader: R) -> Result<Self>
+    pub fn parse<R: Read + Send + Sync>(algo: PublicKeyAlgorithm, reader: R) -> Result<Self>
     {
         let bio = buffered_reader::Generic::with_cookie(
             reader, None, Cookie::default());
diff --git a/openpgp/src/parse/packet_parser_builder.rs b/openpgp/src/parse/packet_parser_builder.rs
index a5617a04..56ea6067 100644
--- a/openpgp/src/parse/packet_parser_builder.rs
+++ b/openpgp/src/parse/packet_parser_builder.rs
@@ -100,7 +100,7 @@ pub struct PacketParserBuilder<'a> {
 impl<'a> Parse<'a, PacketParserBuilder<'a>> for PacketParserBuilder<'a> {
     /// Creates a `PacketParserBuilder` for an OpenPGP message stored
     /// in a `std::io::Read` object.
-    fn from_reader<R: io::Read + 'a>(reader: R) -> Result<Self> {
+    fn from_reader<R: io::Read + 'a + Send + Sync>(reader: R) -> Result<Self> {
         PacketParserBuilder::from_buffered_reader(
             Box::new(buffered_reader::Generic::with_cookie(
                 reader, None, Cookie::default())))
diff --git a/openpgp/src/parse/packet_pile_parser.rs b/openpgp/src/parse/packet_pile_parser.rs
index fe1e989c..4b04fab9 100644
--- a/openpgp/src/parse/packet_pile_parser.rs
+++ b/openpgp/src/parse/packet_pile_parser.rs
@@ -220,7 +220,7 @@ impl<'a> TryFrom<PacketParserBuilder<'a>> for PacketPileParser<'a> {
 impl<'a> Parse<'a, PacketPileParser<'a>> for PacketPileParser<'a> {
     /// Creates a `PacketPileParser` to parse the OpenPGP message stored
     /// in the `io::Read` object.
-    fn from_reader<R: io::Read + 'a>(reader: R)
+    fn from_reader<R: io::Read + 'a + Send + Sync>(reader: R)
              -> Result<PacketPileParser<'a>> {
         let bio = Box::new(buffered_reader::Generic::with_cookie(
             reader, None, Cookie::default()));
@@ -237,7 +237,7 @@ impl<'a> Parse<'a, PacketPileParser<'a>> for PacketPileParser<'a> {
 
     /// Creates a `PacketPileParser` to parse the OpenPGP message stored
     /// in the provided buffer.
-    fn from_bytes<D: AsRef<[u8]> + ?Sized>(data: &'a D)
+    fn from_bytes<D: AsRef<[u8]> + ?Sized + Send + Sync>(data: &'a D)
             -> Result<PacketPileParser<'a>> {
         let bio = Box::new(buffered_reader::Memory::with_cookie(
             data.as_ref(), Cookie::default()));
diff --git a/openpgp/src/parse/stream.rs b/openpgp/src/parse/stream.rs
index a55f263f..7fc2eafb 100644
--- a/openpgp/src/parse/stream.rs
+++ b/openpgp/src/parse/stream.rs
@@ -1004,7 +1004,7 @@ impl<'a> Parse<'a, VerifierBuilder<'a>>
     for VerifierBuilder<'a>
 {
     fn from_reader<R>(reader: R) -> Result<VerifierBuilder<'a>>
-        where R: io::Read + 'a,
+        where R: io::Read + 'a + Send + Sync,
     {
         VerifierBuilder::new(buffered_reader::Generic::with_cookie(
             reader, None, Default::default()))
@@ -1412,7 +1412,7 @@ impl<'a> Parse<'a, DetachedVerifierBuilder<'a>>
     for DetachedVerifierBuilder<'a>
 {
     fn from_reader<R>(reader: R) -> Result<DetachedVerifierBuilder<'a>>
-        where R: io::Read + 'a,
+        where R: io::Read + 'a + Send + Sync,
     {
         DetachedVerifierBuilder::new(buffered_reader::Generic::with_cookie(
             reader, None, Default::default()))
@@ -1575,7 +1575,7 @@ impl<'a> DetachedVerifierBuilder<'a> {
 
 impl<'a, H: VerificationHelper> DetachedVerifier<'a, H> {
     /// Verifies the given data.
-    pub fn verify_reader<R: io::Read>(&mut self, reader: R) -> Result<()> {
+    pub fn verify_reader<R: io::Read + Send + Sync>(&mut self, reader: R) -> Result<()> {
         self.verify(buffered_reader::Generic::with_cookie(
             reader, None, Default::default()).as_boxed())
     }
@@ -1767,7 +1767,7 @@ impl<'a> Parse<'a, DecryptorBuilder<'a>>
     for DecryptorBuilder<'a>
 {
     fn from_reader<R>(reader: R) -> Result<DecryptorBuilder<'a>>
-        where R: io::Read + 'a,
+        where R: io::Read + 'a + Send + Sync,
     {
         DecryptorBuilder::new(buffered_reader::Generic::with_cookie(
             reader, None, Default::default()))