Merge pull request #55 from betagouv/fix_header_decoder

Fix header decoder

Author: LeSim

src/decipher_type.rs

@@ -1,4 +1,4 @@
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub enum DecipherType {
     Encrypted { chunk_size: usize },
     Plaintext,

src/header_decoder.rs

@@ -39,7 +39,7 @@ where
             }
             Poll::Ready(None) => {
                 trace!("poll: over");
-                Poll::Ready((DecipherType::Plaintext, None))
+                Poll::Ready((DecipherType::Plaintext, Some(decoder.buffer.clone())))
             }
             Poll::Ready(Some(Err(e))) => {
                 error!("poll: error {:?}", e);
@@ -75,9 +75,32 @@ where
                         }
                     }
                 } else {
-                    Poll::Pending
+                    trace!("not enough byte to decide decypher type");
+                    Pin::new(decoder).poll(cx)
                 }
             }
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn header_decoder() {
+        use actix_web::Error;
+
+        let clear: &[u8] = b"something not encrypted";
+
+        let source: Result<Bytes, Error> = Ok(Bytes::from(&clear[..]));
+        let source_stream = futures::stream::once(Box::pin(async { source }));
+
+        let mut boxy: Box<dyn Stream<Item = Result<Bytes, _>> + Unpin> = Box::new(source_stream);
+
+        let result = futures::executor::block_on(HeaderDecoder::new(&mut boxy));
+
+        assert_eq!(DecipherType::Plaintext, result.0);
+        assert_eq!(Some(BytesMut::from(&clear[..])), result.1);
+    }
+}

src/proxy.rs

@@ -182,18 +182,12 @@ async fn fetch(
         let mut boxy: Box<dyn Stream<Item = Result<Bytes, _>> + Unpin> = Box::new(res);
         let header_decoder = HeaderDecoder::new(&mut boxy);
         let (cypher_type, buff) = header_decoder.await;
+        let fetch_length = original_length
+            .map(|content_length| decrypted_content_length(content_length, cypher_type));
 
         let decoder =
             Decoder::new_from_cypher_and_buffer(config.key.clone(), boxy, cypher_type, buff);
 
-        let fetch_length = original_length.map(|content_length| {
-            if config.noop {
-                content_length
-            } else {
-                decrypted_content_length(content_length, cypher_type)
-            }
-        });
-
         if let Some(length) = fetch_length {
             Ok(client_resp.no_chunking(length as u64).streaming(decoder))
         } else {