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 struct SHA256Context
  59 {
  60         unsigned int tot_len;
  61         unsigned int len;
  62         unsigned char block[2 * SHA256_BLOCK_SIZE];
  63         uint32_t h[8];
  64 };
  65
  66 void SHA256Init(struct SHA256Context *ctx);
  67 void SHA256Transform(struct SHA256Context *ctx, unsigned char *message, unsigned int block_nb);
  68 void SHA256Update(struct SHA256Context *ctx, unsigned char *message, unsigned int len);
  69 void SHA256Final(struct SHA256Context *ctx, unsigned char *digest);
  70 void SHA256(const char *src, char *dest, int len);
  71
  72 #define SHFR(x, n)    (x >> n)
  73 #define ROTR(x, n)   ((x >> n) | (x << ((sizeof(x) << 3) - n)))
  74 #define ROTL(x, n)   ((x << n) | (x >> ((sizeof(x) << 3) - n)))
  75 #define CH(x, y, z)  ((x & y) ^ (~x & z))
  76 #define MAJ(x, y, z) ((x & y) ^ (x & z) ^ (y & z))
  77
  78 #define SHA256_F1(x) (ROTR(x,  2) ^ ROTR(x, 13) ^ ROTR(x, 22))
  79 #define SHA256_F2(x) (ROTR(x,  6) ^ ROTR(x, 11) ^ ROTR(x, 25))
  80 #define SHA256_F3(x) (ROTR(x,  7) ^ ROTR(x, 18) ^ SHFR(x,  3))
  81 #define SHA256_F4(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ SHFR(x, 10))
  82
  83 #define UNPACK32(x, str)                       \
  84 {                                              \
  85         *((str) + 3) = (uint8_t) ((x)      );      \
  86         *((str) + 2) = (uint8_t) ((x) >>  8);      \
  87         *((str) + 1) = (uint8_t) ((x) >> 16);      \
  88         *((str) + 0) = (uint8_t) ((x) >> 24);      \
  89 }
  90
  91 #define PACK32(str, x)                         \
  92 {                                              \
  93         *(x) = ((uint32_t) *((str) + 3)      )     \
  94         | ((uint32_t) *((str) + 2) <<  8)     \
  95         | ((uint32_t) *((str) + 1) << 16)     \
  96         | ((uint32_t) *((str) + 0) << 24);    \
  97 }
  98
  99 /* Macros used for loops unrolling */
 100
 101 #define SHA256_SCR(i)                          \
 102 {                                              \
 103         w[i] =  SHA256_F4(w[i - 2]) + w[i - 7]     \
 104         + SHA256_F3(w[i - 15]) + w[i - 16];  \
 105 }
 106
 107 uint32_t sha256_h0[8] =
 108 {
 109         0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
 110         0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
 111 };
 112
 113 uint32_t sha256_k[64] =
 114 {
 115         0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
 116         0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
 117         0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
 118         0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
 119         0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
 120         0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
 121         0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
 122         0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
 123         0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
 124         0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
 125         0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
 126         0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
 127         0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
 128         0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
 129         0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
 130         0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
 131 };
 132
 133 void SHA256Init(struct SHA256Context *ctx)
 134 {
 135         for (int i = 0; i < 8; i++)
 136                 ctx->h[i] = sha256_h0[i];
 137         ctx->len = 0;
 138         ctx->tot_len = 0;
 139 }
 140
 141 void SHA256Transform(struct SHA256Context *ctx, unsigned char *message, unsigned int block_nb)
 142 {
 143         uint32_t w[64];
 144         uint32_t wv[8];
 145         unsigned char *sub_block;
 146         for (unsigned int i = 1; i <= block_nb; i++)
 147         {
 148                 int j;
 149                 sub_block = message + ((i - 1) << 6);
 150
 151                 for (j = 0; j < 16; j++)
 152                         PACK32(&sub_block[j << 2], &w[j]);
 153                 for (j = 16; j < 64; j++)
 154                         SHA256_SCR(j);
 155                 for (j = 0; j < 8; j++)
 156                         wv[j] = ctx->h[j];
 157                 for (j = 0; j < 64; j++)
 158                 {
 159                         uint32_t t1 = wv[7] + SHA256_F2(wv[4]) + CH(wv[4], wv[5], wv[6]) + sha256_k[j] + w[j];
 160                         uint32_t t2 = SHA256_F1(wv[0]) + MAJ(wv[0], wv[1], wv[2]);
 161                         wv[7] = wv[6];
 162                         wv[6] = wv[5];
 163                         wv[5] = wv[4];
 164                         wv[4] = wv[3] + t1;
 165                         wv[3] = wv[2];
 166                         wv[2] = wv[1];
 167                         wv[1] = wv[0];
 168                         wv[0] = t1 + t2;
 169                 }
 170                 for (j = 0; j < 8; j++)
 171                         ctx->h[j] += wv[j];
 172         }
 173 }
 174
 175 void SHA256Update(struct SHA256Context *ctx, unsigned char *message, unsigned int len)
 176 {
 177         unsigned int rem_len = SHA256_BLOCK_SIZE - ctx->len;
 178         memcpy(&ctx->block[ctx->len], message, rem_len);
 179         if (ctx->len + len < SHA256_BLOCK_SIZE)
 180         {
 181                 ctx->len += len;
 182                 return;
 183         }
 184         unsigned int new_len = len - rem_len;
 185         unsigned int block_nb = new_len / SHA256_BLOCK_SIZE;
 186         unsigned char *shifted_message = message + rem_len;
 187         SHA256Transform(ctx, ctx->block, 1);
 188         SHA256Transform(ctx, shifted_message, block_nb);
 189         rem_len = new_len % SHA256_BLOCK_SIZE;
 190         memcpy(ctx->block, &shifted_message[block_nb << 6],rem_len);
 191         ctx->len = rem_len;
 192         ctx->tot_len += (block_nb + 1) << 6;
 193 }
 194
 195 void SHA256Final(struct SHA256Context *ctx, unsigned char *digest)
 196 {
 197         unsigned int block_nb = (1 + ((SHA256_BLOCK_SIZE - 9) < (ctx->len % SHA256_BLOCK_SIZE)));
 198         unsigned int len_b = (ctx->tot_len + ctx->len) << 3;
 199         unsigned int pm_len = block_nb << 6;
 200         memset(ctx->block + ctx->len, 0, pm_len - ctx->len);
 201         ctx->block[ctx->len] = 0x80;
 202         UNPACK32(len_b, ctx->block + pm_len - 4);
 203         SHA256Transform(ctx, ctx->block, block_nb);
 204         for (int i = 0 ; i < 8; i++)
 205                 UNPACK32(ctx->h[i], &digest[i << 2]);
 206 }
 207
 208 void SHA256(const char *src, char *dest, int len)
 209 {
 210         // Generate the hash
 211         unsigned char bytehash[SHA256_DIGEST_SIZE];
 212         struct SHA256Context ctx;
 213         SHA256Init(&ctx);
 214         SHA256Update(&ctx, (unsigned char *)src, (unsigned int)len);
 215         SHA256Final(&ctx, bytehash);
 216         // Convert it to hex
 217         const char *hxc = "0123456789abcdef";
 218         for (int i = 0, j = 0; i < SHA256_DIGEST_SIZE; i++)
 219         {
 220                 dest[j++] = hxc[bytehash[i] / 16];
 221                 dest[j++] = hxc[bytehash[i] % 16];
 222                 dest[j] = '\0';
 223         }
 224 }
 225
 226 class cmd_mksha256 : public command_t
 227 {
 228 public:
 229         cmd_mksha256() : command_t("MKSHA256", 'o', 1)
 230         {
 231                 this->source = "m_opersha256.so";
 232         }
 233
 234         void Handle(char **parameters, int pcnt, userrec *user)
 235         {
 236                 char buffer[SHA256_BLOCK_SIZE + 1];
 237                 SHA256(parameters[0], buffer, strlen(parameters[0]));
 238                 WriteServ(user->fd, "NOTICE %s :SHA256 hashed password for %s is %s", user->nick, parameters[0], buffer);
 239         }
 240 };
 241
 242 class ModuleOperSHA256 : public Module
 243 {
 244         cmd_mksha256 *mksha256cmd;
 245 public:
 246
 247         ModuleOperSHA256(Server *Me) : Module::Module(Me)
 248         {
 249                 Srv = Me;
 250                 mksha256cmd = new cmd_mksha256();
 251                 Srv->AddCommand(mksha256cmd);
 252         }
 253
 254         virtual ~ModuleOperSHA256()
 255         {
 256         }
 257
 258         void Implements(char *List)
 259         {
 260                 List[I_OnOperCompare] = 1;
 261         }
 262
 263         virtual int OnOperCompare(const std::string &data, const std::string &input)
 264         {
 265                 if (data.length() == SHA256_BLOCK_SIZE) // If the data is as long as a hex sha256 hash, try it as that
 266                 {
 267                         char buffer[SHA256_BLOCK_SIZE + 1];
 268                         SHA256(input.c_str(), buffer, strlen(input.c_str()));
 269                         if (!strcasecmp(data.c_str(), buffer))
 270                                 return 1;
 271                         else
 272                                 return -1;
 273                 }
 274                 return 0;
 275         }
 276
 277         virtual Version GetVersion()
 278         {
 279                 return Version(1, 0, 0, 1, 0);
 280         }
 281 };
 282
 283
 284 class ModuleOperSHA256Factory : public ModuleFactory
 285 {
 286 public:
 287         ModuleOperSHA256Factory()
 288         {
 289         }
 290
 291         ~ModuleOperSHA256Factory()
 292         {
 293         }
 294
 295         virtual Module *CreateModule(Server* Me)
 296         {
 297                 return new ModuleOperSHA256(Me);
 298         }
 299
 300 };
 301
 302 extern "C" void * init_module( void )
 303 {
 304         return new ModuleOperSHA256Factory;
 305 }