rpgp
diff --git a/‎src/composed/message/reader/sym_encrypted.rs
Copy file name to clipboard
+4-23Lines changed: 4 additions & 23 deletions b/‎src/composed/message/reader/sym_encrypted.rs
Copy file name to clipboard
+4-23Lines changed: 4 additions & 23 deletions
diff --git a/‎src/composed/message/types.rs
Copy file name to clipboard
+1-2Lines changed: 1 addition & 2 deletions b/‎src/composed/message/types.rs
Copy file name to clipboard
+1-2Lines changed: 1 addition & 2 deletions
diff --git a/‎tests/fuzz/minimized-from-7585e756306047aba2218ebf70b24c6373e82e2a
Copy file name to clipboard
706 Bytes b/‎tests/fuzz/minimized-from-7585e756306047aba2218ebf70b24c6373e82e2a
Copy file name to clipboard
706 Bytes
diff --git a/‎tests/fuzz/minimized-from-82b02bbac39a10c7b98d020f78153ffb75c94607
Copy file name to clipboard
28 Bytes b/‎tests/fuzz/minimized-from-82b02bbac39a10c7b98d020f78153ffb75c94607
Copy file name to clipboard
28 Bytes
diff --git a/‎tests/message_test.rs
Copy file name to clipboard
+16Lines changed: 16 additions & 0 deletions b/‎tests/message_test.rs
Copy file name to clipboard
+16Lines changed: 16 additions & 0 deletions
@@ -15,9 +15,6 @@ pub enum SymEncryptedDataReader<R: BufRead> {
     Body {
         decryptor: MaybeDecryptor<PacketBodyReader<R>>,
     },
-    Done {
-        source: PacketBodyReader<R>,
-    },
     Error,
 }
 
@@ -30,34 +27,23 @@ impl<R: BufRead> SymEncryptedDataReader<R> {
         })
     }
 
-    pub(crate) fn new_done(source: PacketBodyReader<R>) -> Self {
-        Self::Done { source }
-    }
-
-    pub fn is_done(&self) -> bool {
-        matches!(self, Self::Done { .. })
-    }
-
     pub fn into_inner(self) -> PacketBodyReader<R> {
         match self {
             Self::Body { decryptor, .. } => decryptor.into_inner(),
-            Self::Done { source, .. } => source,
             Self::Error => panic!("SymEncryptedDataReader errored"),
         }
     }
 
     pub fn get_mut(&mut self) -> &mut PacketBodyReader<R> {
         match self {
             Self::Body { decryptor, .. } => decryptor.get_mut(),
-            Self::Done { source, .. } => source,
             Self::Error => panic!("SymEncryptedDataReader errored"),
         }
     }
 
     pub fn packet_header(&self) -> PacketHeader {
         match self {
             Self::Body { decryptor, .. } => decryptor.get_ref().packet_header(),
-            Self::Done { source, .. } => source.packet_header(),
             Self::Error => panic!("SymEncryptedDataReader errored"),
         }
     }
@@ -86,10 +72,6 @@ impl<R: BufRead> SymEncryptedDataReader<R> {
             } => {
                 bail!("already decrypting")
             }
-            Self::Done { source } => {
-                *self = Self::Done { source };
-                bail!("cannot decrypt after finishing to read")
-            }
             Self::Error => panic!("SymEncryptedDataReader errored"),
         }
     }
@@ -98,16 +80,16 @@ impl<R: BufRead> SymEncryptedDataReader<R> {
 impl<R: BufRead> BufRead for SymEncryptedDataReader<R> {
     fn fill_buf(&mut self) -> io::Result<&[u8]> {
         match self {
-            Self::Body { decryptor } => decryptor.fill_buf(),
-            Self::Done { .. } => Ok(&[][..]),
-            Self::Error => Err(io::Error::other("SymEncryptedDataReader errored")),
+            Self::Body { ref mut decryptor } => decryptor.fill_buf(),
+            Self::Error => {
+                panic!("SymEncryptedDataReader errored")
+            }
         }
     }
 
     fn consume(&mut self, amt: usize) {
         match self {
             Self::Body { decryptor } => decryptor.consume(amt),
-            Self::Done { .. } => {}
             Self::Error => panic!("SymEncryptedDataReader errored"),
         }
     }
@@ -117,7 +99,6 @@ impl<R: BufRead> Read for SymEncryptedDataReader<R> {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         match self {
             Self::Body { decryptor } => decryptor.read(buf),
-            Self::Done { .. } => Ok(0),
             Self::Error => Err(io::Error::other("SymEncryptedDataReader errored")),
         }
     }
 
@@ -291,7 +291,6 @@ impl<'a> Message<'a> {
             } => match edata {
                 Edata::SymEncryptedData { reader } => {
                     let packet_header = reader.packet_header();
-                    assert!(reader.is_done());
                     (
                         reader.into_inner().into_inner(),
                         MessageParts::Encrypted {
@@ -390,7 +389,7 @@ impl MessageParts {
                     let reader = SymEncryptedProtectedDataReader::new_done(config, reader);
                     Edata::SymEncryptedProtectedData { reader }
                 } else {
-                    let reader = SymEncryptedDataReader::new_done(reader);
+                    let reader = SymEncryptedDataReader::new(reader).expect("used before");
                     Edata::SymEncryptedData { reader }
                 };
                 Message::Encrypted {
 
@@ -972,3 +972,19 @@ fn test_mock_pq_cert_leniency_ecdh_opaque() {
         SignedPublicKey::from_armor_file("./tests/mock_pq/ecdh_opaque_small.pub.asc").unwrap();
     dbg!(key);
 }
+
+#[test]
+fn fuzz_msg_reader() {
+    // those are fuzzer-generated "messages" that each contain a nonsensical series of packets
+    // (surely with nonsensical package contents, as well)
+    pretty_env_logger::try_init().ok();
+
+    for file in [
+        // OPS SIG PKESK SED BAD
+        "./tests/fuzz/minimized-from-7585e756306047aba2218ebf70b24c6373e82e2a",
+        // OPS SKESK SED
+        "./tests/fuzz/minimized-from-82b02bbac39a10c7b98d020f78153ffb75c94607",
+    ] {
+        let _ = Message::from_file(file).unwrap().as_data_vec();
+    }
+}
Original file line number	Diff line number	Diff line change
`@@ -15,9 +15,6 @@ pub enum SymEncryptedDataReader<R: BufRead> {`
`15`	`15`	`Body {`
`16`	`16`	`decryptor: MaybeDecryptor<PacketBodyReader<R>>,`
`17`	`17`	`},`
`18`		`- Done {`
`19`		`- source: PacketBodyReader<R>,`
`20`		`- },`
`21`	`18`	`Error,`
`22`	`19`	`}`
`23`	`20`
`@@ -30,34 +27,23 @@ impl<R: BufRead> SymEncryptedDataReader<R> {`
`30`	`27`	`})`
`31`	`28`	`}`
`32`	`29`
`33`		`- pub(crate) fn new_done(source: PacketBodyReader<R>) -> Self {`
`34`		`- Self::Done { source }`
`35`		`- }`
`36`		`-`
`37`		`- pub fn is_done(&self) -> bool {`
`38`		`- matches!(self, Self::Done { .. })`
`39`		`- }`
`40`		`-`
`41`	`30`	`pub fn into_inner(self) -> PacketBodyReader<R> {`
`42`	`31`	`match self {`
`43`	`32`	`Self::Body { decryptor, .. } => decryptor.into_inner(),`
`44`		`- Self::Done { source, .. } => source,`
`45`	`33`	`Self::Error => panic!("SymEncryptedDataReader errored"),`
`46`	`34`	`}`
`47`	`35`	`}`
`48`	`36`
`49`	`37`	`pub fn get_mut(&mut self) -> &mut PacketBodyReader<R> {`
`50`	`38`	`match self {`
`51`	`39`	`Self::Body { decryptor, .. } => decryptor.get_mut(),`
`52`		`- Self::Done { source, .. } => source,`
`53`	`40`	`Self::Error => panic!("SymEncryptedDataReader errored"),`
`54`	`41`	`}`
`55`	`42`	`}`
`56`	`43`
`57`	`44`	`pub fn packet_header(&self) -> PacketHeader {`
`58`	`45`	`match self {`
`59`	`46`	`Self::Body { decryptor, .. } => decryptor.get_ref().packet_header(),`
`60`		`- Self::Done { source, .. } => source.packet_header(),`
`61`	`47`	`Self::Error => panic!("SymEncryptedDataReader errored"),`
`62`	`48`	`}`
`63`	`49`	`}`
`@@ -86,10 +72,6 @@ impl<R: BufRead> SymEncryptedDataReader<R> {`
`86`	`72`	`} => {`
`87`	`73`	`bail!("already decrypting")`
`88`	`74`	`}`
`89`		`- Self::Done { source } => {`
`90`		`- *self = Self::Done { source };`
`91`		`- bail!("cannot decrypt after finishing to read")`
`92`		`- }`
`93`	`75`	`Self::Error => panic!("SymEncryptedDataReader errored"),`
`94`	`76`	`}`
`95`	`77`	`}`
`@@ -98,16 +80,16 @@ impl<R: BufRead> SymEncryptedDataReader<R> {`
`98`	`80`	`impl<R: BufRead> BufRead for SymEncryptedDataReader<R> {`
`99`	`81`	`fn fill_buf(&mut self) -> io::Result<&[u8]> {`
`100`	`82`	`match self {`
`101`		`- Self::Body { decryptor } => decryptor.fill_buf(),`
`102`		`- Self::Done { .. } => Ok(&[][..]),`
`103`		`- Self::Error => Err(io::Error::other("SymEncryptedDataReader errored")),`
	`83`	`+ Self::Body { ref mut decryptor } => decryptor.fill_buf(),`
	`84`	`+ Self::Error => {`
	`85`	`+ panic!("SymEncryptedDataReader errored")`
	`86`	`+ }`
`104`	`87`	`}`
`105`	`88`	`}`
`106`	`89`
`107`	`90`	`fn consume(&mut self, amt: usize) {`
`108`	`91`	`match self {`
`109`	`92`	`Self::Body { decryptor } => decryptor.consume(amt),`
`110`		`- Self::Done { .. } => {}`
`111`	`93`	`Self::Error => panic!("SymEncryptedDataReader errored"),`
`112`	`94`	`}`
`113`	`95`	`}`
`@@ -117,7 +99,6 @@ impl<R: BufRead> Read for SymEncryptedDataReader<R> {`
`117`	`99`	`fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {`
`118`	`100`	`match self {`
`119`	`101`	`Self::Body { decryptor } => decryptor.read(buf),`
`120`		`- Self::Done { .. } => Ok(0),`
`121`	`102`	`Self::Error => Err(io::Error::other("SymEncryptedDataReader errored")),`
`122`	`103`	`}`
`123`	`104`	`}`