include/library/sha256.hpp

   1 #ifndef _library__sha256__hpp__included__
   2 #define _library__sha256__hpp__included__
   3
   4 #include "hex.hpp"
   5 #include <cstdint>
   6 #include <cstring>
   7 #include <vector>
   8 #include <string>
   9
  10 /**
  11  * This class implements interface to SHA-256.
  12  */
  13 class sha256
  14 {
  15 public:
  16 /**
  17  * Creates new SHA-256 context, initially containing empty data.
  18  */
  19         sha256() throw(std::bad_alloc)
  20         {
  21                 real_init();
  22                 finished = false;
  23         }
  24
  25 /**
  26  * Destructor
  27  */
  28         ~sha256() throw()
  29         {
  30                 real_destroy();
  31         }
  32
  33 /**
  34  * This function appends specified data to be hashed. Don't call after calling read().
  35  *
  36  * Parameter data: The data to write.
  37  * Parameter datalen: The length of data written.
  38  */
  39         void write(const uint8_t* data, size_t datalen) throw()
  40         {
  41                 if(finished)
  42                         return;
  43                 real_write(data, datalen);
  44         }
  45
  46 /**
  47  * Reads the hash of data written. Can be called multiple times, but after the first call, data can't be appended
  48  * anymore.
  49  *
  50  * Parameter hashout: 32-byte buffer to store the hash to.
  51  */
  52         void read(uint8_t* hashout) throw()
  53         {
  54                 if(!finished) {
  55                         real_finish(finalhash);
  56                         finished = true;
  57                 }
  58                 memcpy(hashout, finalhash, 32);
  59         }
  60
  61 /**
  62  * Reads 32-byte binary hash from hashout and returns 64-hex hexadecimal hash.
  63  *
  64  * Parameter hashout: The binary hash
  65  * Returns: Hexadecimal hash
  66  * Throws std::bad_alloc: Not enough memory.
  67  */
  68         static std::string tostring(const uint8_t* hashout) throw(std::bad_alloc)
  69         {
  70                 return hex::b_to(hashout, 32);
  71         }
  72
  73 /**
  74  * This function appends specified data to be hashed. Don't call after calling read().
  75  *
  76  * Parameter data: The data to write.
  77  * Parameter datalen: The length of data written.
  78  */
  79         void write(const char* data, size_t datalen) throw()
  80         {
  81                 write(reinterpret_cast<const uint8_t*>(data), datalen);
  82         }
  83
  84 /**
  85  * Similar to read(uint8_t*) but instead returns the hash as hexadecimal string.
  86  *
  87  * Returns: The hash in hex form.
  88  * Throws std::bad_alloc: Not enough memory.
  89  */
  90         std::string read() throw(std::bad_alloc)
  91         {
  92                 uint8_t x[32];
  93                 read(x);
  94                 return tostring(x);
  95         }
  96
  97 /**
  98  * Hashes block of data.
  99  *
 100  * Parameter hashout: 32-byte buffer to write the hash to.
 101  * Parameter data: The data to hash.
 102  * Parameter datalen: The length of data hashed.
 103  */
 104         static void hash(uint8_t* hashout, const uint8_t* data, size_t datalen) throw()
 105         {
 106                 sha256 i;
 107                 i.write(data, datalen);
 108                 i.read(hashout);
 109         }
 110
 111 /**
 112  * Hashes block of data.
 113  *
 114  * Parameter hashout: 32-byte buffer to write the hash to.
 115  * Parameter data: The data to hash.
 116  */
 117         static void hash(uint8_t* hashout, const std::vector<uint8_t>& data) throw()
 118         {
 119                 hash(hashout, &data[0], data.size());
 120         }
 121
 122 /**
 123  * Hashes block of data.
 124  *
 125  * Parameter hashout: 32-byte buffer to write the hash to.
 126  * Parameter data: The data to hash.
 127  */
 128         static void hash(uint8_t* hashout, const std::vector<char>& data) throw()
 129         {
 130                 hash(hashout, reinterpret_cast<const uint8_t*>(&data[0]), data.size());
 131         }
 132
 133 /**
 134  * Hashes block of data.
 135  *
 136  * Parameter data: The data to hash.
 137  * Parameter datalen: The length of data hashed.
 138  * Returns: Hexadecimal hash of the data.
 139  * Throws std::bad_alloc: Not enough memory.
 140  */
 141         static std::string hash(const uint8_t* data, size_t datalen) throw(std::bad_alloc)
 142         {
 143                 uint8_t hashout[32];
 144                 hash(hashout, data, datalen);
 145                 return tostring(hashout);
 146         }
 147
 148 /**
 149  * Hashes block of data.
 150  *
 151  * Parameter data: The data to hash.
 152  * Returns: Hexadecimal hash of the data.
 153  * Throws std::bad_alloc: Not enough memory.
 154  */
 155         static std::string hash(const std::vector<uint8_t>& data) throw(std::bad_alloc)
 156         {
 157                 uint8_t hashout[32];
 158                 hash(hashout, &data[0], data.size());
 159                 return tostring(hashout);
 160         }
 161
 162 /**
 163  * Hashes block of data.
 164  *
 165  * Parameter data: The data to hash.
 166  * Returns: Hexadecimal hash of the data.
 167  * Throws std::bad_alloc: Not enough memory.
 168  */
 169         static std::string hash(const std::vector<char>& data) throw(std::bad_alloc)
 170         {
 171                 uint8_t hashout[32];
 172                 hash(hashout, reinterpret_cast<const uint8_t*>(&data[0]), data.size());
 173                 return tostring(hashout);
 174         }
 175 private:
 176         uint32_t state[8];
 177         uint32_t datablock[16];
 178         unsigned blockbytes;
 179         uint64_t totalbytes;
 180         bool finished;
 181         uint8_t finalhash[32];
 182         void real_init();
 183         void real_destroy();
 184         void real_finish(uint8_t* hash);
 185         void real_write(const uint8_t* data, size_t datalen);
 186 };
 187
 188 #endif