src/modules/m_opersha256.cpp

   1 /* m_opersha256 - Written by Special <john@yarbbles.com>
   2  *
   3  * FIPS 180-2 SHA-224/256/384/512 implementation
   4  * Last update: 05/23/2005
   5  * Issue date:  04/30/2005
   6  *
   7  * Copyright (C) 2005 Olivier Gay <olivier.gay@a3.epfl.ch>
   8  * All rights reserved.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 3. Neither the name of the project nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34
  35 /* $ModDesc: Allows for SHA-256 encrypted oper passwords */
  36
  37 using namespace std;
  38
  39 #include <stdio.h>
  40 #include "inspircd_config.h"
  41 #ifdef HAS_STDINT
  42 #include <stdint.h>
  43 #endif
  44 #include "users.h"
  45 #include "channels.h"
  46 #include "modules.h"
  47 #include "helperfuncs.h"
  48
  49 static Server *Srv;
  50
  51 #define SHA256_DIGEST_SIZE (256 / 8)
  52 #define SHA256_BLOCK_SIZE  (512 / 8)
  53
  54 #ifndef HAS_STDINT
  55 typedef unsigned int uint32_t;
  56 #endif
  57
  58 class SHA256Context : public classbase
  59 {
  60  public:
  61         unsigned int tot_len;
  62         unsigned int len;
  63         unsigned char block[2 * SHA256_BLOCK_SIZE];
  64         uint32_t h[8];
  65 };
  66
  67 void SHA256Init(struct SHA256Context *ctx);
  68 void SHA256Transform(struct SHA256Context *ctx, unsigned char *message, unsigned int block_nb);
  69 void SHA256Update(struct SHA256Context *ctx, unsigned char *message, unsigned int len);
  70 void SHA256Final(struct SHA256Context *ctx, unsigned char *digest);
  71 void SHA256(const char *src, char *dest, int len);
  72
  73 #define SHFR(x, n)    (x >> n)
  74 #define ROTR(x, n)   ((x >> n) | (x << ((sizeof(x) << 3) - n)))
  75 #define ROTL(x, n)   ((x << n) | (x >> ((sizeof(x) << 3) - n)))
  76 #define CH(x, y, z)  ((x & y) ^ (~x & z))
  77 #define MAJ(x, y, z) ((x & y) ^ (x & z) ^ (y & z))
  78
  79 #define SHA256_F1(x) (ROTR(x,  2) ^ ROTR(x, 13) ^ ROTR(x, 22))
  80 #define SHA256_F2(x) (ROTR(x,  6) ^ ROTR(x, 11) ^ ROTR(x, 25))
  81 #define SHA256_F3(x) (ROTR(x,  7) ^ ROTR(x, 18) ^ SHFR(x,  3))
  82 #define SHA256_F4(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ SHFR(x, 10))
  83
  84 #define UNPACK32(x, str)                       \
  85 {                                              \
  86         *((str) + 3) = (uint8_t) ((x)      );      \
  87         *((str) + 2) = (uint8_t) ((x) >>  8);      \
  88         *((str) + 1) = (uint8_t) ((x) >> 16);      \
  89         *((str) + 0) = (uint8_t) ((x) >> 24);      \
  90 }
  91
  92 #define PACK32(str, x)                         \
  93 {                                              \
  94         *(x) = ((uint32_t) *((str) + 3)      )     \
  95         | ((uint32_t) *((str) + 2) <<  8)     \
  96         | ((uint32_t) *((str) + 1) << 16)     \
  97         | ((uint32_t) *((str) + 0) << 24);    \
  98 }
  99
 100 /* Macros used for loops unrolling */
 101
 102 #define SHA256_SCR(i)                          \
 103 {                                              \
 104         w[i] =  SHA256_F4(w[i - 2]) + w[i - 7]     \
 105         + SHA256_F3(w[i - 15]) + w[i - 16];  \
 106 }
 107
 108 uint32_t sha256_h0[8] =
 109 {
 110         0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
 111         0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
 112 };
 113
 114 uint32_t sha256_k[64] =
 115 {
 116         0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
 117         0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
 118         0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
 119         0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
 120         0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
 121         0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
 122         0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
 123         0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
 124         0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
 125         0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
 126         0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
 127         0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
 128         0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
 129         0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
 130         0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
 131         0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
 132 };
 133
 134 void SHA256Init(struct SHA256Context *ctx)
 135 {
 136         for (int i = 0; i < 8; i++)
 137                 ctx->h[i] = sha256_h0[i];
 138         ctx->len = 0;
 139         ctx->tot_len = 0;
 140 }
 141
 142 void SHA256Transform(struct SHA256Context *ctx, unsigned char *message, unsigned int block_nb)
 143 {
 144         uint32_t w[64];
 145         uint32_t wv[8];
 146         unsigned char *sub_block;
 147         for (unsigned int i = 1; i <= block_nb; i++)
 148         {
 149                 int j;
 150                 sub_block = message + ((i - 1) << 6);
 151
 152                 for (j = 0; j < 16; j++)
 153                         PACK32(&sub_block[j << 2], &w[j]);
 154                 for (j = 16; j < 64; j++)
 155                         SHA256_SCR(j);
 156                 for (j = 0; j < 8; j++)
 157                         wv[j] = ctx->h[j];
 158                 for (j = 0; j < 64; j++)
 159                 {
 160                         uint32_t t1 = wv[7] + SHA256_F2(wv[4]) + CH(wv[4], wv[5], wv[6]) + sha256_k[j] + w[j];
 161                         uint32_t t2 = SHA256_F1(wv[0]) + MAJ(wv[0], wv[1], wv[2]);
 162                         wv[7] = wv[6];
 163                         wv[6] = wv[5];
 164                         wv[5] = wv[4];
 165                         wv[4] = wv[3] + t1;
 166                         wv[3] = wv[2];
 167                         wv[2] = wv[1];
 168                         wv[1] = wv[0];
 169                         wv[0] = t1 + t2;
 170                 }
 171                 for (j = 0; j < 8; j++)
 172                         ctx->h[j] += wv[j];
 173         }
 174 }
 175
 176 void SHA256Update(struct SHA256Context *ctx, unsigned char *message, unsigned int len)
 177 {
 178         unsigned int rem_len = SHA256_BLOCK_SIZE - ctx->len;
 179         memcpy(&ctx->block[ctx->len], message, rem_len);
 180         if (ctx->len + len < SHA256_BLOCK_SIZE)
 181         {
 182                 ctx->len += len;
 183                 return;
 184         }
 185         unsigned int new_len = len - rem_len;
 186         unsigned int block_nb = new_len / SHA256_BLOCK_SIZE;
 187         unsigned char *shifted_message = message + rem_len;
 188         SHA256Transform(ctx, ctx->block, 1);
 189         SHA256Transform(ctx, shifted_message, block_nb);
 190         rem_len = new_len % SHA256_BLOCK_SIZE;
 191         memcpy(ctx->block, &shifted_message[block_nb << 6],rem_len);
 192         ctx->len = rem_len;
 193         ctx->tot_len += (block_nb + 1) << 6;
 194 }
 195
 196 void SHA256Final(struct SHA256Context *ctx, unsigned char *digest)
 197 {
 198         unsigned int block_nb = (1 + ((SHA256_BLOCK_SIZE - 9) < (ctx->len % SHA256_BLOCK_SIZE)));
 199         unsigned int len_b = (ctx->tot_len + ctx->len) << 3;
 200         unsigned int pm_len = block_nb << 6;
 201         memset(ctx->block + ctx->len, 0, pm_len - ctx->len);
 202         ctx->block[ctx->len] = 0x80;
 203         UNPACK32(len_b, ctx->block + pm_len - 4);
 204         SHA256Transform(ctx, ctx->block, block_nb);
 205         for (int i = 0 ; i < 8; i++)
 206                 UNPACK32(ctx->h[i], &digest[i << 2]);
 207 }
 208
 209 void SHA256(const char *src, char *dest, int len)
 210 {
 211         // Generate the hash
 212         unsigned char bytehash[SHA256_DIGEST_SIZE];
 213         struct SHA256Context ctx;
 214         SHA256Init(&ctx);
 215         SHA256Update(&ctx, (unsigned char *)src, (unsigned int)len);
 216         SHA256Final(&ctx, bytehash);
 217         // Convert it to hex
 218         const char *hxc = "0123456789abcdef";
 219         for (int i = 0, j = 0; i < SHA256_DIGEST_SIZE; i++)
 220         {
 221                 dest[j++] = hxc[bytehash[i] / 16];
 222                 dest[j++] = hxc[bytehash[i] % 16];
 223                 dest[j] = '\0';
 224         }
 225 }
 226
 227 class cmd_mksha256 : public command_t
 228 {
 229 public:
 230         cmd_mksha256() : command_t("MKSHA256", 'o', 1)
 231         {
 232                 this->source = "m_opersha256.so";
 233         }
 234
 235         void Handle(const char** parameters, int pcnt, userrec *user)
 236         {
 237                 char buffer[SHA256_BLOCK_SIZE + 1];
 238                 SHA256(parameters[0], buffer, strlen(parameters[0]));
 239                 WriteServ(user->fd, "NOTICE %s :SHA256 hashed password for %s is %s", user->nick, parameters[0], buffer);
 240         }
 241 };
 242
 243 class ModuleOperSHA256 : public Module
 244 {
 245         cmd_mksha256 *mksha256cmd;
 246 public:
 247
 248         ModuleOperSHA256(Server *Me) : Module::Module(Me)
 249         {
 250                 Srv = Me;
 251                 mksha256cmd = new cmd_mksha256();
 252                 Srv->AddCommand(mksha256cmd);
 253         }
 254
 255         virtual ~ModuleOperSHA256()
 256         {
 257         }
 258
 259         void Implements(char *List)
 260         {
 261                 List[I_OnOperCompare] = 1;
 262         }
 263
 264         virtual int OnOperCompare(const std::string &data, const std::string &input)
 265         {
 266                 if (data.length() == SHA256_BLOCK_SIZE) // If the data is as long as a hex sha256 hash, try it as that
 267                 {
 268                         char buffer[SHA256_BLOCK_SIZE + 1];
 269                         SHA256(input.c_str(), buffer, strlen(input.c_str()));
 270                         if (!strcasecmp(data.c_str(), buffer))
 271                                 return 1;
 272                         else
 273                                 return -1;
 274                 }
 275                 return 0;
 276         }
 277
 278         virtual Version GetVersion()
 279         {
 280                 return Version(1, 0, 0, 1, 0);
 281         }
 282 };
 283
 284
 285 class ModuleOperSHA256Factory : public ModuleFactory
 286 {
 287 public:
 288         ModuleOperSHA256Factory()
 289         {
 290         }
 291
 292         ~ModuleOperSHA256Factory()
 293         {
 294         }
 295
 296         virtual Module *CreateModule(Server* Me)
 297         {
 298                 return new ModuleOperSHA256(Me);
 299         }
 300
 301 };
 302
 303 extern "C" void * init_module( void )
 304 {
 305         return new ModuleOperSHA256Factory;
 306 }