add hashed streams

Author: jube

include/gf2/core/Streams.h

@@ -12,6 +12,7 @@
 #include <zlib.h>
 
 #include "CoreApi.h"
+#include "SecureHash.h"
 #include "Stream.h"
 
 namespace gf {
@@ -93,6 +94,22 @@ namespace gf {
     std::size_t m_offset = 0;
   };
 
+  class GF_CORE_API HashedInputStream : public InputStream {
+  public:
+    HashedInputStream(InputStream* stream);
+
+    SecureHash::Hash hash();
+
+    std::size_t read(Span<uint8_t> buffer) override;
+    void seek(std::ptrdiff_t position) override;
+    void skip(std::ptrdiff_t position) override;
+    bool finished() override;
+
+  private:
+    InputStream* m_stream = nullptr;
+    SecureHash m_hash;
+  };
+
   class GF_CORE_API FileOutputStream : public OutputStream {
   public:
     enum class Mode : uint8_t {
@@ -163,6 +180,20 @@ namespace gf {
     std::vector<uint8_t>* m_bytes;
   };
 
+  class GF_CORE_API HashedOutputStream : public OutputStream {
+  public:
+    HashedOutputStream(OutputStream* stream);
+
+    SecureHash::Hash hash();
+
+    std::size_t write(Span<const uint8_t> buffer) override;
+    std::size_t written_bytes() const override;
+
+  private:
+    OutputStream* m_stream;
+    SecureHash m_hash;
+  };
+
 } // namespace gf
 
 #endif // GF_STREAMS_H

library/core/Streams.cc

@@ -296,6 +296,42 @@ namespace gf {
     return m_offset == m_bytes->size();
   }
 
+  /*
+   * HashedInputStream
+   */
+
+  HashedInputStream::HashedInputStream(InputStream* stream)
+  : m_stream(stream)
+  {
+  }
+
+  SecureHash::Hash HashedInputStream::hash()
+  {
+    return m_hash.result();
+  }
+
+  std::size_t HashedInputStream::read(Span<uint8_t> buffer)
+  {
+    auto result = m_stream->read(buffer);
+    m_hash.input(buffer);
+    return result;
+  }
+
+  void HashedInputStream::seek([[maybe_unused]] std::ptrdiff_t position)
+  {
+    Log::fatal("Not supported");
+  }
+
+  void HashedInputStream::skip([[maybe_unused]] std::ptrdiff_t position)
+  {
+    Log::fatal("Not supported");
+  }
+
+  bool HashedInputStream::finished()
+  {
+    return m_stream->finished();
+  }
+
   /*
    * FileOutputStream
    */
@@ -513,4 +549,29 @@ namespace gf {
     return m_bytes->size();
   }
 
+  /*
+   * HashedOutputStream
+   */
+
+  HashedOutputStream::HashedOutputStream(OutputStream* stream)
+  : m_stream(stream)
+  {
+  }
+
+  SecureHash::Hash HashedOutputStream::hash()
+  {
+    return m_hash.result();
+  }
+
+  std::size_t HashedOutputStream::write(Span<const uint8_t> buffer)
+  {
+    m_hash.input(buffer);
+    return m_stream->write(buffer);
+  }
+
+  std::size_t HashedOutputStream::written_bytes() const
+  {
+    return m_stream->written_bytes();
+  }
+
 } // namespace gf

tests/tests_core_Serialization.cc

@@ -22,18 +22,26 @@ namespace {
   void save_and_load(const T& in, T& out)
   {
     std::vector<uint8_t> bytes;
+    gf::SecureHash::Hash input_hash;
+    gf::SecureHash::Hash output_hash;
 
     {
       gf::BufferOutputStream ostream(&bytes);
-      gf::Serializer serializer(&ostream);
+      gf::HashedOutputStream hashed_ostream(&ostream);
+      gf::Serializer serializer(&hashed_ostream);
       serializer | in;
+      input_hash = hashed_ostream.hash();
     }
 
     {
       gf::BufferInputStream istream(&bytes);
-      gf::Deserializer deserializer(&istream);
+      gf::HashedInputStream hashed_istream(&istream);
+      gf::Deserializer deserializer(&hashed_istream);
       deserializer | out;
+      output_hash = hashed_istream.hash();
     }
+
+    EXPECT_EQ(input_hash, output_hash);
   }
 
   struct SizeWrapper {