stglibs/crypto.lib/bfstream.cpp

   1 #include "stg/bfstream.h"
   2
   3 #include "stg/blowfish.h"
   4
   5 #include <cstring>
   6
   7 namespace
   8 {
   9
  10 #ifndef BFSTREAM_BUF_SIZE
  11 const size_t BUFFER_SIZE = 1024;
  12 #else
  13 const size_t BUFFER_SIZE = BFSTREAM_BUF_SIZE;
  14 #endif
  15
  16 class COMMON
  17 {
  18     public:
  19         typedef bool (* CALLBACK)(const void * block, size_t size, void * data);
  20         typedef void (* PROC)(void * dest, const void * source, size_t length, const BLOWFISH_CTX * ctx);
  21
  22         COMMON(const std::string & key, CALLBACK callback, void * data, PROC proc)
  23             : m_ptr(m_buffer),
  24               m_callback(callback),
  25               m_data(data),
  26               m_proc(proc),
  27               m_ok(true)
  28         {
  29         InitContext(key.c_str(), key.length(), &m_ctx);
  30         memset(m_buffer, 0, sizeof(m_buffer));
  31         }
  32
  33         void Put(const void * data, size_t size, bool last)
  34         {
  35         size_t dataSize = m_ptr - m_buffer;
  36         while (dataSize + size > sizeof(m_buffer))
  37             {
  38             memcpy(m_ptr, data, sizeof(m_buffer) - dataSize); // Fill buffer
  39             size -= sizeof(m_buffer) - dataSize; // Adjust size
  40             data = static_cast<const char *>(data) + sizeof(m_buffer) - dataSize; // Adjust data pointer
  41             m_proc(m_buffer, m_buffer, sizeof(m_buffer), &m_ctx); // Process
  42             m_ok = m_ok && m_callback(m_buffer, sizeof(m_buffer), m_data); // Consume
  43             m_ptr = m_buffer;
  44             dataSize = 0;
  45             }
  46         if (!m_ok)
  47             return;
  48         memcpy(m_ptr, data, size);
  49         m_ptr += size;
  50         m_tryConsume(last);
  51         }
  52
  53         bool IsOk() const { return m_ok; }
  54
  55     private:
  56         char m_buffer[BUFFER_SIZE];
  57         char * m_ptr;
  58         CALLBACK m_callback;
  59         void * m_data;
  60         BLOWFISH_CTX m_ctx;
  61         PROC m_proc;
  62         bool m_ok;
  63
  64         void m_tryConsume(bool last)
  65         {
  66         size_t dataSize = (m_ptr - m_buffer) & ~7;
  67         size_t remainder = m_ptr - m_buffer - dataSize;
  68         if (last && remainder > 0)
  69             {
  70             dataSize += 8;
  71             remainder = 0;
  72             }
  73         if (!last && dataSize == 0) // Allow to call callback with 0 data on last call.
  74             return;
  75         m_proc(m_buffer, m_buffer, dataSize, &m_ctx);
  76         m_ok = m_ok && m_callback(m_buffer, dataSize, m_data);
  77         if (!m_ok)
  78             return;
  79         if (remainder > 0)
  80             memmove(m_buffer, m_buffer + dataSize, remainder);
  81         m_ptr = m_buffer + remainder;
  82         }
  83 };
  84
  85 } // namespace anonymous
  86
  87 using STG::ENCRYPT_STREAM;
  88 using STG::DECRYPT_STREAM;
  89
  90 class ENCRYPT_STREAM::IMPL : public COMMON
  91 {
  92     public:
  93         IMPL(const std::string & key, CALLBACK callback, void * data)
  94             : COMMON(key, callback, data, EncryptString)
  95         {}
  96 };
  97
  98 class DECRYPT_STREAM::IMPL : public COMMON
  99 {
 100     public:
 101         IMPL(const std::string & key, CALLBACK callback, void * data)
 102             : COMMON(key, callback, data, DecryptString)
 103         {}
 104 };
 105
 106 ENCRYPT_STREAM::ENCRYPT_STREAM(const std::string & key, CALLBACK callback, void * data)
 107     : m_impl(new IMPL(key, callback, data))
 108 {}
 109
 110 ENCRYPT_STREAM::~ENCRYPT_STREAM()
 111 {
 112 delete m_impl;
 113 }
 114
 115 void ENCRYPT_STREAM::Put(const void * data, size_t size, bool last)
 116 {
 117 m_impl->Put(data, size, last);
 118 }
 119
 120 bool ENCRYPT_STREAM::IsOk() const
 121 {
 122 return m_impl->IsOk();
 123 }
 124
 125 DECRYPT_STREAM::DECRYPT_STREAM(const std::string & key, CALLBACK callback, void * data)
 126     : m_impl(new IMPL(key, callback, data))
 127 {}
 128
 129 DECRYPT_STREAM::~DECRYPT_STREAM()
 130 {
 131 delete m_impl;
 132 }
 133
 134 void DECRYPT_STREAM::Put(const void * data, size_t size, bool last)
 135 {
 136 m_impl->Put(data, size, last);
 137 }
 138
 139 bool DECRYPT_STREAM::IsOk() const
 140 {
 141 return m_impl->IsOk();
 142 }