pluto  1
Small utility library for UUIDs, SHA1, and Encryption
TinySHA1.h
Go to the documentation of this file.
1 #pragma once
2 
11 #include <cstdio>
12 #include <cstdlib>
13 #include <cstring>
14 #include <stdint.h>
15 
16 
17 namespace plt {
18 
24  class SHA1 {
25 
26  public:
27 
31  typedef uint32_t digest32_t[5];
32 
36  typedef uint8_t digest8_t[20];
37 
42  inline static uint32_t LeftRotate(uint32_t value, size_t count) {
43  return (value << count) ^ (value >> (32-count));
44  }
45 
49  SHA1(){ reset(); }
50 
51  virtual ~SHA1() {}
52 
56  SHA1(const SHA1& s) { *this = s; }
57 
62  const SHA1& operator = (const SHA1& s) {
63  memcpy(m_digest, s.m_digest, 5 * sizeof(uint32_t));
64  memcpy(m_block, s.m_block, 64);
65  m_blockByteIndex = s.m_blockByteIndex;
66  m_byteCount = s.m_byteCount;
67  return *this;
68  }
69 
74  SHA1& reset() {
75  m_digest[0] = 0x67452301;
76  m_digest[1] = 0xEFCDAB89;
77  m_digest[2] = 0x98BADCFE;
78  m_digest[3] = 0x10325476;
79  m_digest[4] = 0xC3D2E1F0;
80  m_blockByteIndex = 0;
81  m_byteCount = 0;
82  return *this;
83  }
84 
88  SHA1& processByte(uint8_t octet) {
89  this->m_block[this->m_blockByteIndex++] = octet;
90  ++this->m_byteCount;
91  if(m_blockByteIndex == 64) {
92  this->m_blockByteIndex = 0;
93  processBlock();
94  }
95  return *this;
96  }
97 
101  SHA1& processBlock(const void* const start, const void* const end) {
102  const uint8_t* begin = static_cast<const uint8_t*>(start);
103  const uint8_t* finish = static_cast<const uint8_t*>(end);
104  while(begin != finish) {
105  processByte(*begin);
106  begin++;
107  }
108  return *this;
109  }
110 
114  SHA1& processBytes(const void* const data, size_t len) {
115  const uint8_t* block = static_cast<const uint8_t*>(data);
116  processBlock(block, block + len);
117  return *this;
118  }
119 
123  const uint32_t* getDigest(digest32_t digest) {
124  size_t bitCount = this->m_byteCount * 8;
125  processByte(0x80);
126  if (this->m_blockByteIndex > 56) {
127  while (m_blockByteIndex != 0) {
128  processByte(0);
129  }
130  while (m_blockByteIndex < 56) {
131  processByte(0);
132  }
133  } else {
134  while (m_blockByteIndex < 56) {
135  processByte(0);
136  }
137  }
138  processByte(0);
139  processByte(0);
140  processByte(0);
141  processByte(0);
142  processByte( static_cast<unsigned char>((bitCount>>24) & 0xFF));
143  processByte( static_cast<unsigned char>((bitCount>>16) & 0xFF));
144  processByte( static_cast<unsigned char>((bitCount>>8 ) & 0xFF));
145  processByte( static_cast<unsigned char>((bitCount) & 0xFF));
146 
147  memcpy(digest, m_digest, 5 * sizeof(uint32_t));
148  return digest;
149  }
150 
154  const uint8_t* getDigestBytes(digest8_t digest) {
155  digest32_t d32;
156  getDigest(d32);
157  size_t di = 0;
158  digest[di++] = ((d32[0] >> 24) & 0xFF);
159  digest[di++] = ((d32[0] >> 16) & 0xFF);
160  digest[di++] = ((d32[0] >> 8) & 0xFF);
161  digest[di++] = ((d32[0]) & 0xFF);
162 
163  digest[di++] = ((d32[1] >> 24) & 0xFF);
164  digest[di++] = ((d32[1] >> 16) & 0xFF);
165  digest[di++] = ((d32[1] >> 8) & 0xFF);
166  digest[di++] = ((d32[1]) & 0xFF);
167 
168  digest[di++] = ((d32[2] >> 24) & 0xFF);
169  digest[di++] = ((d32[2] >> 16) & 0xFF);
170  digest[di++] = ((d32[2] >> 8) & 0xFF);
171  digest[di++] = ((d32[2]) & 0xFF);
172 
173  digest[di++] = ((d32[3] >> 24) & 0xFF);
174  digest[di++] = ((d32[3] >> 16) & 0xFF);
175  digest[di++] = ((d32[3] >> 8) & 0xFF);
176  digest[di++] = ((d32[3]) & 0xFF);
177 
178  digest[di++] = ((d32[4] >> 24) & 0xFF);
179  digest[di++] = ((d32[4] >> 16) & 0xFF);
180  digest[di++] = ((d32[4] >> 8) & 0xFF);
181  digest[di++] = ((d32[4]) & 0xFF);
182  return digest;
183  }
184 
185  protected:
186 
190  void processBlock() {
191  uint32_t w[80];
192  for (size_t i = 0; i < 16; i++) {
193  w[i] = (m_block[i*4 + 0] << 24);
194  w[i] |= (m_block[i*4 + 1] << 16);
195  w[i] |= (m_block[i*4 + 2] << 8);
196  w[i] |= (m_block[i*4 + 3]);
197  }
198  for (size_t i = 16; i < 80; i++) {
199  w[i] = LeftRotate((w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16]), 1);
200  }
201 
202  uint32_t a = m_digest[0];
203  uint32_t b = m_digest[1];
204  uint32_t c = m_digest[2];
205  uint32_t d = m_digest[3];
206  uint32_t e = m_digest[4];
207 
208  for (std::size_t i=0; i<80; ++i) {
209  uint32_t f = 0;
210  uint32_t k = 0;
211 
212  if (i<20) {
213  f = (b & c) | (~b & d);
214  k = 0x5A827999;
215  } else if (i<40) {
216  f = b ^ c ^ d;
217  k = 0x6ED9EBA1;
218  } else if (i<60) {
219  f = (b & c) | (b & d) | (c & d);
220  k = 0x8F1BBCDC;
221  } else {
222  f = b ^ c ^ d;
223  k = 0xCA62C1D6;
224  }
225  uint32_t temp = LeftRotate(a, 5) + f + e + k + w[i];
226  e = d;
227  d = c;
228  c = LeftRotate(b, 30);
229  b = a;
230  a = temp;
231  }
232 
233  m_digest[0] += a;
234  m_digest[1] += b;
235  m_digest[2] += c;
236  m_digest[3] += d;
237  m_digest[4] += e;
238  }
239  private:
240  digest32_t m_digest;
241  uint8_t m_block[64];
242  size_t m_blockByteIndex;
243  size_t m_byteCount;
244  };
245 }
const uint32_t * getDigest(digest32_t digest)
gets digest of SHA1
Definition: TinySHA1.h:123
SHA1 & processBytes(const void *const data, size_t len)
processes the bytes of a SHA1
Definition: TinySHA1.h:114
void processBlock()
processes block of SHA1
Definition: TinySHA1.h:190
Do not use these functions.
Definition: FileDataReader.h:16
SHA1()
Default Constructor of SHA1.
Definition: TinySHA1.h:49
uint32_t digest32_t[5]
digest32
Definition: TinySHA1.h:31
uint8_t digest8_t[20]
digest8
Definition: TinySHA1.h:36
const SHA1 & operator=(const SHA1 &s)
equals operator
Definition: TinySHA1.h:62
SHA1 & processByte(uint8_t octet)
processes byte of SHA1sum
Definition: TinySHA1.h:88
static uint32_t LeftRotate(uint32_t value, size_t count)
equals operator
Definition: TinySHA1.h:42
SHA1 & reset()
reset the SHA1
Definition: TinySHA1.h:74
SHA1 functionality of Pluto.
Definition: TinySHA1.h:24
const uint8_t * getDigestBytes(digest8_t digest)
gets the digests bytes of the SHA1
Definition: TinySHA1.h:154
SHA1(const SHA1 &s)
Copy Constructor of SHA1.
Definition: TinySHA1.h:56
SHA1 & processBlock(const void *const start, const void *const end)
processes block of SHA1sum
Definition: TinySHA1.h:101