src/modules/m_sha1.cpp

   1 /*
   2  * InspIRCd -- Internet Relay Chat Daemon
   3  *
   4  *   Copyright (C) 2017, 2020 Sadie Powell <sadie@witchery.services>
   5  *   Copyright (C) 2016 Attila Molnar <attilamolnar@hush.com>
   6  *
   7  * This file is part of InspIRCd.  InspIRCd is free software: you can
   8  * redistribute it and/or modify it under the terms of the GNU General Public
   9  * License as published by the Free Software Foundation, version 2.
  10  *
  11  * This program is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  13  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  14  * details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 /*
  21 SHA-1 in C
  22 By Steve Reid <steve@edmweb.com>
  23 100% Public Domain
  24 */
  25
  26 #include "inspircd.h"
  27 #include "modules/hash.h"
  28
  29 union CHAR64LONG16
  30 {
  31         unsigned char c[64];
  32         uint32_t l[16];
  33 };
  34
  35 inline static uint32_t rol(uint32_t value, uint32_t bits) { return (value << bits) | (value >> (32 - bits)); }
  36
  37 // blk0() and blk() perform the initial expand.
  38 // I got the idea of expanding during the round function from SSLeay
  39 static bool big_endian;
  40 inline static uint32_t blk0(CHAR64LONG16& block, uint32_t i)
  41 {
  42         if (big_endian)
  43                 return block.l[i];
  44         else
  45                 return block.l[i] = (rol(block.l[i], 24) & 0xFF00FF00) | (rol(block.l[i], 8) & 0x00FF00FF);
  46 }
  47 inline static uint32_t blk(CHAR64LONG16 &block, uint32_t i) { return block.l[i & 15] = rol(block.l[(i + 13) & 15] ^ block.l[(i + 8) & 15] ^ block.l[(i + 2) & 15] ^ block.l[i & 15],1); }
  48
  49 // (R0+R1), R2, R3, R4 are the different operations used in SHA1
  50 inline static void R0(CHAR64LONG16& block, uint32_t v, uint32_t &w, uint32_t x, uint32_t y, uint32_t &z, uint32_t i) { z += ((w & (x ^ y)) ^ y) + blk0(block, i) + 0x5A827999 + rol(v, 5); w = rol(w, 30); }
  51 inline static void R1(CHAR64LONG16& block, uint32_t v, uint32_t &w, uint32_t x, uint32_t y, uint32_t &z, uint32_t i) { z += ((w & (x ^ y)) ^ y) + blk(block, i) + 0x5A827999 + rol(v, 5); w = rol(w, 30); }
  52 inline static void R2(CHAR64LONG16& block, uint32_t v, uint32_t &w, uint32_t x, uint32_t y, uint32_t &z, uint32_t i) { z += (w ^ x ^ y) + blk(block, i) + 0x6ED9EBA1 + rol(v, 5); w = rol(w, 30); }
  53 inline static void R3(CHAR64LONG16& block, uint32_t v, uint32_t &w, uint32_t x, uint32_t y, uint32_t &z, uint32_t i) { z += (((w | x) & y) | (w & x)) + blk(block, i) + 0x8F1BBCDC + rol(v, 5); w = rol(w, 30); }
  54 inline static void R4(CHAR64LONG16& block, uint32_t v, uint32_t &w, uint32_t x, uint32_t y, uint32_t &z, uint32_t i) { z += (w ^ x ^ y) + blk(block, i) + 0xCA62C1D6 + rol(v, 5); w = rol(w, 30); }
  55
  56 static const uint32_t sha1_iv[5] =
  57 {
  58         0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0
  59 };
  60
  61 class SHA1Context
  62 {
  63         uint32_t state[5];
  64         uint32_t count[2];
  65         unsigned char buffer[64];
  66         unsigned char digest[20];
  67
  68         void Transform(const unsigned char buf[64])
  69         {
  70                 uint32_t a, b, c, d, e;
  71
  72                 CHAR64LONG16 block;
  73                 memcpy(block.c, buf, 64);
  74
  75                 // Copy state[] to working vars
  76                 a = this->state[0];
  77                 b = this->state[1];
  78                 c = this->state[2];
  79                 d = this->state[3];
  80                 e = this->state[4];
  81
  82                 // 4 rounds of 20 operations each. Loop unrolled.
  83                 R0(block, a, b, c, d, e, 0); R0(block, e, a, b, c, d, 1); R0(block, d, e, a, b, c, 2); R0(block, c, d, e, a, b, 3);
  84                 R0(block, b, c, d, e, a, 4); R0(block, a, b, c, d, e, 5); R0(block, e, a, b, c, d, 6); R0(block, d, e, a, b, c, 7);
  85                 R0(block, c, d, e, a, b, 8); R0(block, b, c, d, e, a, 9); R0(block, a, b, c, d, e, 10); R0(block, e, a, b, c, d, 11);
  86                 R0(block, d, e, a, b, c, 12); R0(block, c, d, e, a, b, 13); R0(block, b, c, d, e, a, 14); R0(block, a, b, c, d, e, 15);
  87                 R1(block, e, a, b, c, d, 16); R1(block, d, e, a, b, c, 17); R1(block, c, d, e, a, b, 18); R1(block, b, c, d, e, a, 19);
  88                 R2(block, a, b, c, d, e, 20); R2(block, e, a, b, c, d, 21); R2(block, d, e, a, b, c, 22); R2(block, c, d, e, a, b, 23);
  89                 R2(block, b, c, d, e, a, 24); R2(block, a, b, c, d, e, 25); R2(block, e, a, b, c, d, 26); R2(block, d, e, a, b, c, 27);
  90                 R2(block, c, d, e, a, b, 28); R2(block, b, c, d, e, a, 29); R2(block, a, b, c, d, e, 30); R2(block, e, a, b, c, d, 31);
  91                 R2(block, d, e, a, b, c, 32); R2(block, c, d, e, a, b, 33); R2(block, b, c, d, e, a, 34); R2(block, a, b, c, d, e, 35);
  92                 R2(block, e, a, b, c, d, 36); R2(block, d, e, a, b, c, 37); R2(block, c, d, e, a, b, 38); R2(block, b, c, d, e, a, 39);
  93                 R3(block, a, b, c, d, e, 40); R3(block, e, a, b, c, d, 41); R3(block, d, e, a, b, c, 42); R3(block, c, d, e, a, b, 43);
  94                 R3(block, b, c, d, e, a, 44); R3(block, a, b, c, d, e, 45); R3(block, e, a, b, c, d, 46); R3(block, d, e, a, b, c, 47);
  95                 R3(block, c, d, e, a, b, 48); R3(block, b, c, d, e, a, 49); R3(block, a, b, c, d, e, 50); R3(block, e, a, b, c, d, 51);
  96                 R3(block, d, e, a, b, c, 52); R3(block, c, d, e, a, b, 53); R3(block, b, c, d, e, a, 54); R3(block, a, b, c, d, e, 55);
  97                 R3(block, e, a, b, c, d, 56); R3(block, d, e, a, b, c, 57); R3(block, c, d, e, a, b, 58); R3(block, b, c, d, e, a, 59);
  98                 R4(block, a, b, c, d, e, 60); R4(block, e, a, b, c, d, 61); R4(block, d, e, a, b, c, 62); R4(block, c, d, e, a, b, 63);
  99                 R4(block, b, c, d, e, a, 64); R4(block, a, b, c, d, e, 65); R4(block, e, a, b, c, d, 66); R4(block, d, e, a, b, c, 67);
 100                 R4(block, c, d, e, a, b, 68); R4(block, b, c, d, e, a, 69); R4(block, a, b, c, d, e, 70); R4(block, e, a, b, c, d, 71);
 101                 R4(block, d, e, a, b, c, 72); R4(block, c, d, e, a, b, 73); R4(block, b, c, d, e, a, 74); R4(block, a, b, c, d, e, 75);
 102                 R4(block, e, a, b, c, d, 76); R4(block, d, e, a, b, c, 77); R4(block, c, d, e, a, b, 78); R4(block, b, c, d, e, a, 79);
 103                 // Add the working vars back into state[]
 104                 this->state[0] += a;
 105                 this->state[1] += b;
 106                 this->state[2] += c;
 107                 this->state[3] += d;
 108                 this->state[4] += e;
 109         }
 110
 111  public:
 112         SHA1Context()
 113         {
 114                 for (int i = 0; i < 5; ++i)
 115                         this->state[i] = sha1_iv[i];
 116
 117                 this->count[0] = this->count[1] = 0;
 118                 memset(this->buffer, 0, sizeof(this->buffer));
 119                 memset(this->digest, 0, sizeof(this->digest));
 120         }
 121
 122         void Update(const unsigned char* data, size_t len)
 123         {
 124                 uint32_t i, j;
 125
 126                 j = (this->count[0] >> 3) & 63;
 127                 if ((this->count[0] += len << 3) < (len << 3))
 128                         ++this->count[1];
 129                 this->count[1] += len >> 29;
 130                 if (j + len > 63)
 131                 {
 132                         memcpy(&this->buffer[j], data, (i = 64 - j));
 133                         this->Transform(this->buffer);
 134                         for (; i + 63 < len; i += 64)
 135                                 this->Transform(&data[i]);
 136                         j = 0;
 137                 }
 138                 else
 139                         i = 0;
 140                 memcpy(&this->buffer[j], &data[i], len - i);
 141         }
 142
 143         void Finalize()
 144         {
 145                 uint32_t i;
 146                 unsigned char finalcount[8];
 147
 148                 for (i = 0; i < 8; ++i)
 149                         finalcount[i] = static_cast<unsigned char>((this->count[i >= 4 ? 0 : 1] >> ((3 - (i & 3)) * 8)) & 255); /* Endian independent */
 150                 this->Update(reinterpret_cast<const unsigned char *>("\200"), 1);
 151                 while ((this->count[0] & 504) != 448)
 152                         this->Update(reinterpret_cast<const unsigned char *>("\0"), 1);
 153                 this->Update(finalcount, 8); // Should cause a SHA1Transform()
 154                 for (i = 0; i < 20; ++i)
 155                         this->digest[i] = static_cast<unsigned char>((this->state[i>>2] >> ((3 - (i & 3)) * 8)) & 255);
 156
 157                 this->Transform(this->buffer);
 158         }
 159
 160         std::string GetRaw() const
 161         {
 162                 return std::string((const char*)digest, sizeof(digest));
 163         }
 164 };
 165
 166 class SHA1HashProvider : public HashProvider
 167 {
 168  public:
 169         SHA1HashProvider(Module* mod)
 170                 : HashProvider(mod, "sha1", 20, 64)
 171         {
 172         }
 173
 174         std::string GenerateRaw(const std::string& data) CXX11_OVERRIDE
 175         {
 176                 SHA1Context ctx;
 177                 ctx.Update(reinterpret_cast<const unsigned char*>(data.data()), data.length());
 178                 ctx.Finalize();
 179                 return ctx.GetRaw();
 180         }
 181 };
 182
 183 class ModuleSHA1 : public Module
 184 {
 185         SHA1HashProvider sha1;
 186
 187  public:
 188         ModuleSHA1()
 189                 : sha1(this)
 190         {
 191                 big_endian = (htonl(1337) == 1337);
 192         }
 193
 194         Version GetVersion() CXX11_OVERRIDE
 195         {
 196                 return Version("Allows other modules to generate SHA-1 hashes.", VF_VENDOR);
 197         }
 198 };
 199
 200 MODULE_INIT(ModuleSHA1)