]> git.stg.codes - stg.git/blob - stglibs/crypto.lib/bfstream.cpp
Merge remote-tracking branch 'origin/master' into ticket
[stg.git] / 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 }