From: brain Date: Tue, 5 Dec 2006 18:17:23 +0000 (+0000) Subject: Seperate out sha256 into m_sha256.so. API is identical to MD5 except where the class... X-Git-Tag: v2.0.23~6521 X-Git-Url: https://git.netwichtig.de/gitweb/?a=commitdiff_plain;h=9591819654a80241874e9ce85c40e162d8c5ccbb;p=user%2Fhenk%2Fcode%2Finspircd.git Seperate out sha256 into m_sha256.so. API is identical to MD5 except where the class names are MD5 for MD5, these are SHA256... duh ;) Now we're left with a dialemma - is m_opersha256.cpp now pointless? Does anyone use both sha256 and md5 together? Should we just rename this to m_oper_hash, and have them pick their encryption in the config? :P git-svn-id: http://svn.inspircd.org/repository/trunk/inspircd@5858 e03df62e-2008-0410-955e-edbf42e46eb7 --- diff --git a/src/modules/m_opersha256.cpp b/src/modules/m_opersha256.cpp index 055c559ad..9ed6e65df 100644 --- a/src/modules/m_opersha256.cpp +++ b/src/modules/m_opersha256.cpp @@ -1,238 +1,40 @@ -/* m_opersha256 - Written by Special +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ * - * FIPS 180-2 SHA-224/256/384/512 implementation - * Last update: 05/23/2005 - * Issue date: 04/30/2005 + * InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev. + * E-mail: + * + * + * + * Written by Craig Edwards, Craig McLure, and others. + * This program is free but copyrighted software; see + * the file COPYING for details. * - * Copyright (C) 2005 Olivier Gay - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * 3. Neither the name of the project nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND - * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE - * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS - * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT - * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY - * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF - * SUCH DAMAGE. + * --------------------------------------------------- */ -/* $ModDesc: Allows for SHA-256 encrypted oper passwords */ +/* m_opersha256 - Originally written by Special + * Updated December 2006 by Craig Edwards + */ -using namespace std; +/* $ModDesc: Allows for SHA-256 encrypted oper passwords */ +/* $ModDep: m_sha256.h */ -#include #include "inspircd_config.h" -#ifdef HAS_STDINT -#include -#endif #include "users.h" #include "channels.h" #include "modules.h" - #include "inspircd.h" +#include "m_sha256.h" - -#define SHA256_DIGEST_SIZE (256 / 8) -#define SHA256_BLOCK_SIZE (512 / 8) - -#ifndef HAS_STDINT -typedef unsigned int uint32_t; -#endif - -/** An sha 256 context, used by m_opersha256 - */ -class SHA256Context : public classbase -{ - public: - unsigned int tot_len; - unsigned int len; - unsigned char block[2 * SHA256_BLOCK_SIZE]; - uint32_t h[8]; -}; - -void SHA256Init(struct SHA256Context *ctx); -void SHA256Transform(struct SHA256Context *ctx, unsigned char *message, unsigned int block_nb); -void SHA256Update(struct SHA256Context *ctx, unsigned char *message, unsigned int len); -void SHA256Final(struct SHA256Context *ctx, unsigned char *digest); -void SHA256(const char *src, char *dest, int len); - -#define SHFR(x, n) (x >> n) -#define ROTR(x, n) ((x >> n) | (x << ((sizeof(x) << 3) - n))) -#define ROTL(x, n) ((x << n) | (x >> ((sizeof(x) << 3) - n))) -#define CH(x, y, z) ((x & y) ^ (~x & z)) -#define MAJ(x, y, z) ((x & y) ^ (x & z) ^ (y & z)) - -#define SHA256_F1(x) (ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22)) -#define SHA256_F2(x) (ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25)) -#define SHA256_F3(x) (ROTR(x, 7) ^ ROTR(x, 18) ^ SHFR(x, 3)) -#define SHA256_F4(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ SHFR(x, 10)) - -#define UNPACK32(x, str) \ -{ \ - *((str) + 3) = (uint8_t) ((x) ); \ - *((str) + 2) = (uint8_t) ((x) >> 8); \ - *((str) + 1) = (uint8_t) ((x) >> 16); \ - *((str) + 0) = (uint8_t) ((x) >> 24); \ -} - -#define PACK32(str, x) \ -{ \ - *(x) = ((uint32_t) *((str) + 3) ) \ - | ((uint32_t) *((str) + 2) << 8) \ - | ((uint32_t) *((str) + 1) << 16) \ - | ((uint32_t) *((str) + 0) << 24); \ -} - -/* Macros used for loops unrolling */ - -#define SHA256_SCR(i) \ -{ \ - w[i] = SHA256_F4(w[i - 2]) + w[i - 7] \ - + SHA256_F3(w[i - 15]) + w[i - 16]; \ -} - -uint32_t sha256_h0[8] = -{ - 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, - 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 -}; - -uint32_t sha256_k[64] = -{ - 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, - 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, - 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, - 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, - 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, - 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, - 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, - 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, - 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, - 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, - 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, - 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, - 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, - 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, - 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, - 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 -}; - -void SHA256Init(struct SHA256Context *ctx) -{ - for (int i = 0; i < 8; i++) - ctx->h[i] = sha256_h0[i]; - ctx->len = 0; - ctx->tot_len = 0; -} - -void SHA256Transform(struct SHA256Context *ctx, unsigned char *message, unsigned int block_nb) -{ - uint32_t w[64]; - uint32_t wv[8]; - unsigned char *sub_block; - for (unsigned int i = 1; i <= block_nb; i++) - { - int j; - sub_block = message + ((i - 1) << 6); - - for (j = 0; j < 16; j++) - PACK32(&sub_block[j << 2], &w[j]); - for (j = 16; j < 64; j++) - SHA256_SCR(j); - for (j = 0; j < 8; j++) - wv[j] = ctx->h[j]; - for (j = 0; j < 64; j++) - { - uint32_t t1 = wv[7] + SHA256_F2(wv[4]) + CH(wv[4], wv[5], wv[6]) + sha256_k[j] + w[j]; - uint32_t t2 = SHA256_F1(wv[0]) + MAJ(wv[0], wv[1], wv[2]); - wv[7] = wv[6]; - wv[6] = wv[5]; - wv[5] = wv[4]; - wv[4] = wv[3] + t1; - wv[3] = wv[2]; - wv[2] = wv[1]; - wv[1] = wv[0]; - wv[0] = t1 + t2; - } - for (j = 0; j < 8; j++) - ctx->h[j] += wv[j]; - } -} - -void SHA256Update(struct SHA256Context *ctx, unsigned char *message, unsigned int len) -{ - unsigned int rem_len = SHA256_BLOCK_SIZE - ctx->len; - memcpy(&ctx->block[ctx->len], message, rem_len); - if (ctx->len + len < SHA256_BLOCK_SIZE) - { - ctx->len += len; - return; - } - unsigned int new_len = len - rem_len; - unsigned int block_nb = new_len / SHA256_BLOCK_SIZE; - unsigned char *shifted_message = message + rem_len; - SHA256Transform(ctx, ctx->block, 1); - SHA256Transform(ctx, shifted_message, block_nb); - rem_len = new_len % SHA256_BLOCK_SIZE; - memcpy(ctx->block, &shifted_message[block_nb << 6],rem_len); - ctx->len = rem_len; - ctx->tot_len += (block_nb + 1) << 6; -} - -void SHA256Final(struct SHA256Context *ctx, unsigned char *digest) -{ - unsigned int block_nb = (1 + ((SHA256_BLOCK_SIZE - 9) < (ctx->len % SHA256_BLOCK_SIZE))); - unsigned int len_b = (ctx->tot_len + ctx->len) << 3; - unsigned int pm_len = block_nb << 6; - memset(ctx->block + ctx->len, 0, pm_len - ctx->len); - ctx->block[ctx->len] = 0x80; - UNPACK32(len_b, ctx->block + pm_len - 4); - SHA256Transform(ctx, ctx->block, block_nb); - for (int i = 0 ; i < 8; i++) - UNPACK32(ctx->h[i], &digest[i << 2]); -} - -void SHA256(const char *src, char *dest, int len) -{ - // Generate the hash - unsigned char bytehash[SHA256_DIGEST_SIZE]; - struct SHA256Context ctx; - SHA256Init(&ctx); - SHA256Update(&ctx, (unsigned char *)src, (unsigned int)len); - SHA256Final(&ctx, bytehash); - // Convert it to hex - const char *hxc = "0123456789abcdef"; - for (int i = 0, j = 0; i < SHA256_DIGEST_SIZE; i++) - { - dest[j++] = hxc[bytehash[i] / 16]; - dest[j++] = hxc[bytehash[i] % 16]; - dest[j] = '\0'; - } -} - -/** Handle /MKSHA256 - */ class cmd_mksha256 : public command_t { -public: - cmd_mksha256 (InspIRCd* Instance) : command_t(Instance,"MKSHA256", 'o', 1) + Module* Source; + Module* SHA256Provider; + public: + cmd_mksha256 (InspIRCd* Instance, Module* Src, Module* SHA256) : command_t(Instance,"MKSHA256", 'o', 1), Source(Src), SHA256Provider(SHA256) { this->source = "m_opersha256.so"; syntax = ""; @@ -240,9 +42,8 @@ public: CmdResult Handle(const char** parameters, int pcnt, userrec *user) { - char buffer[SHA256_BLOCK_SIZE + 1]; - SHA256(parameters[0], buffer, strlen(parameters[0])); - user->WriteServ("NOTICE %s :SHA256 hashed password for %s is %s", user->nick, parameters[0], buffer); + SHA256ResetRequest(Source, SHA256Provider).Send(); + user->WriteServ("NOTICE %s :SHA256 hashed password for %s is %s", user->nick, parameters[0], SHA256SumRequest(Source, SHA256Provider, parameters[0]).Send() ); return CMD_SUCCESS; } }; @@ -250,12 +51,16 @@ public: class ModuleOperSHA256 : public Module { cmd_mksha256 *mksha256cmd; + Module* SHA256Provider; public: ModuleOperSHA256(InspIRCd* Me) : Module::Module(Me) { - - mksha256cmd = new cmd_mksha256(ServerInstance); + SHA256Provider = ServerInstance->FindModule("m_sha256.so"); + if (!SHA256Provider) + throw ModuleException("Can't find m_sha256.so. Please load m_sha256.so before m_opersha256.so."); + + mksha256cmd = new cmd_mksha256(ServerInstance, this, SHA256Provider); ServerInstance->AddCommand(mksha256cmd); } @@ -270,11 +75,10 @@ public: virtual int OnOperCompare(const std::string &data, const std::string &input) { + SHA256ResetRequest(this, SHA256Provider).Send(); if (data.length() == SHA256_BLOCK_SIZE) // If the data is as long as a hex sha256 hash, try it as that { - char buffer[SHA256_BLOCK_SIZE + 1]; - SHA256(input.c_str(), buffer, strlen(input.c_str())); - if (!strcasecmp(data.c_str(), buffer)) + if (!strcasecmp(data.c_str(), SHA256SumRequest(this, SHA256Provider, input.c_str()).Send() )) return 1; else return -1; diff --git a/src/modules/m_sha256.cpp b/src/modules/m_sha256.cpp new file mode 100644 index 000000000..f446633b6 --- /dev/null +++ b/src/modules/m_sha256.cpp @@ -0,0 +1,316 @@ +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev. + * E-mail: + * + * + * + * Written by Craig Edwards, Craig McLure, and others. + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +/* m_sha256 - Based on m_opersha256 written by Special + * Modified and improved by Craig Edwards, December 2006. + * + * + * FIPS 180-2 SHA-224/256/384/512 implementation + * Last update: 05/23/2005 + * Issue date: 04/30/2005 + * + * Copyright (C) 2005 Olivier Gay + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the project nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +/* $ModDesc: Allows for SHA-256 encrypted oper passwords */ +/* $ModDep: m_sha256.h */ + +#include "inspircd_config.h" +#ifdef HAS_STDINT +#include +#endif +#include "users.h" +#include "channels.h" +#include "modules.h" +#include "inspircd.h" + +#include "m_sha256.h" + +#ifndef HAS_STDINT +typedef unsigned int uint32_t; +#endif + +/** An sha 256 context, used by m_opersha256 + */ +class SHA256Context : public classbase +{ + public: + unsigned int tot_len; + unsigned int len; + unsigned char block[2 * SHA256_BLOCK_SIZE]; + uint32_t h[8]; +}; + +#define SHFR(x, n) (x >> n) +#define ROTR(x, n) ((x >> n) | (x << ((sizeof(x) << 3) - n))) +#define ROTL(x, n) ((x << n) | (x >> ((sizeof(x) << 3) - n))) +#define CH(x, y, z) ((x & y) ^ (~x & z)) +#define MAJ(x, y, z) ((x & y) ^ (x & z) ^ (y & z)) + +#define SHA256_F1(x) (ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22)) +#define SHA256_F2(x) (ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25)) +#define SHA256_F3(x) (ROTR(x, 7) ^ ROTR(x, 18) ^ SHFR(x, 3)) +#define SHA256_F4(x) (ROTR(x, 17) ^ ROTR(x, 19) ^ SHFR(x, 10)) + +#define UNPACK32(x, str) \ +{ \ + *((str) + 3) = (uint8_t) ((x) ); \ + *((str) + 2) = (uint8_t) ((x) >> 8); \ + *((str) + 1) = (uint8_t) ((x) >> 16); \ + *((str) + 0) = (uint8_t) ((x) >> 24); \ +} + +#define PACK32(str, x) \ +{ \ + *(x) = ((uint32_t) *((str) + 3) ) \ + | ((uint32_t) *((str) + 2) << 8) \ + | ((uint32_t) *((str) + 1) << 16) \ + | ((uint32_t) *((str) + 0) << 24); \ +} + +/* Macros used for loops unrolling */ + +#define SHA256_SCR(i) \ +{ \ + w[i] = SHA256_F4(w[i - 2]) + w[i - 7] \ + + SHA256_F3(w[i - 15]) + w[i - 16]; \ +} + +const unsigned int sha256_h0[8] = +{ + 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, + 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19 +}; + +uint32_t sha256_k[64] = +{ + 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, + 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, + 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, + 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, + 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, + 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, + 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, + 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, + 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, + 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, + 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, + 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, + 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, + 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, + 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, + 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2 +}; + +class ModuleSHA256 : public Module +{ + void SHA256Init(struct SHA256Context *ctx, const unsigned int* key) + { + if (key) + { + for (int i = 0; i < 8; i++) + ctx->h[i] = key[i]; + } + else + { + for (int i = 0; i < 8; i++) + ctx->h[i] = sha256_h0[i]; + } + ctx->len = 0; + ctx->tot_len = 0; + } + + void SHA256Transform(struct SHA256Context *ctx, unsigned char *message, unsigned int block_nb) + { + uint32_t w[64]; + uint32_t wv[8]; + unsigned char *sub_block; + for (unsigned int i = 1; i <= block_nb; i++) + { + int j; + sub_block = message + ((i - 1) << 6); + + for (j = 0; j < 16; j++) + PACK32(&sub_block[j << 2], &w[j]); + for (j = 16; j < 64; j++) + SHA256_SCR(j); + for (j = 0; j < 8; j++) + wv[j] = ctx->h[j]; + for (j = 0; j < 64; j++) + { + uint32_t t1 = wv[7] + SHA256_F2(wv[4]) + CH(wv[4], wv[5], wv[6]) + sha256_k[j] + w[j]; + uint32_t t2 = SHA256_F1(wv[0]) + MAJ(wv[0], wv[1], wv[2]); + wv[7] = wv[6]; + wv[6] = wv[5]; + wv[5] = wv[4]; + wv[4] = wv[3] + t1; + wv[3] = wv[2]; + wv[2] = wv[1]; + wv[1] = wv[0]; + wv[0] = t1 + t2; + } + for (j = 0; j < 8; j++) + ctx->h[j] += wv[j]; + } + } + + void SHA256Update(struct SHA256Context *ctx, unsigned char *message, unsigned int len) + { + unsigned int rem_len = SHA256_BLOCK_SIZE - ctx->len; + memcpy(&ctx->block[ctx->len], message, rem_len); + if (ctx->len + len < SHA256_BLOCK_SIZE) + { + ctx->len += len; + return; + } + unsigned int new_len = len - rem_len; + unsigned int block_nb = new_len / SHA256_BLOCK_SIZE; + unsigned char *shifted_message = message + rem_len; + SHA256Transform(ctx, ctx->block, 1); + SHA256Transform(ctx, shifted_message, block_nb); + rem_len = new_len % SHA256_BLOCK_SIZE; + memcpy(ctx->block, &shifted_message[block_nb << 6],rem_len); + ctx->len = rem_len; + ctx->tot_len += (block_nb + 1) << 6; + } + + void SHA256Final(struct SHA256Context *ctx, unsigned char *digest) + { + unsigned int block_nb = (1 + ((SHA256_BLOCK_SIZE - 9) < (ctx->len % SHA256_BLOCK_SIZE))); + unsigned int len_b = (ctx->tot_len + ctx->len) << 3; + unsigned int pm_len = block_nb << 6; + memset(ctx->block + ctx->len, 0, pm_len - ctx->len); + ctx->block[ctx->len] = 0x80; + UNPACK32(len_b, ctx->block + pm_len - 4); + SHA256Transform(ctx, ctx->block, block_nb); + for (int i = 0 ; i < 8; i++) + UNPACK32(ctx->h[i], &digest[i << 2]); + } + + void SHA256(const char *src, char *dest, int len, const char* hxc, const unsigned int* key = NULL) + { + // Generate the hash + unsigned char bytehash[SHA256_DIGEST_SIZE]; + struct SHA256Context ctx; + SHA256Init(&ctx, key); + SHA256Update(&ctx, (unsigned char *)src, (unsigned int)len); + SHA256Final(&ctx, bytehash); + // Convert it to hex + for (int i = 0, j = 0; i < SHA256_DIGEST_SIZE; i++) + { + dest[j++] = hxc[bytehash[i] / 16]; + dest[j++] = hxc[bytehash[i] % 16]; + dest[j] = '\0'; + } + } + + unsigned int* key; + char* chars; + + public: + + ModuleSHA256(InspIRCd* Me) : Module::Module(Me), key(NULL), chars(NULL) + { + } + + virtual ~ModuleSHA256() + { + } + + void Implements(char *List) + { + List[I_OnRequest] = 1; + } + + virtual char* OnRequest(Request* request) + { + SHA256Request* SHA = (SHA256Request*)request; + if (strcmp("SHA256_KEY", request->GetId()) == 0) + { + this->key = (unsigned int*)SHA->GetKeyData(); + } + else if (strcmp("SHA256_HEX", request->GetId()) == 0) + { + this->chars = (char*)SHA->GetOutputs(); + } + else if (strcmp("SHA256_SUM", request->GetId()) == 0) + { + static char data[MAXBUF]; + SHA256((const char*)SHA->GetHashData(), data, strlen(SHA->GetHashData()), chars ? chars : "0123456789abcdef", key); + return data; + } + else if (strcmp("SHA256_RESET", request->GetId()) == 0) + { + this->chars = NULL; + this->key = NULL; + } + return NULL; + } + + virtual Version GetVersion() + { + return Version(1, 1, 0, 1, VF_VENDOR, API_VERSION); + } +}; + + +class ModuleSHA256Factory : public ModuleFactory +{ +public: + ModuleSHA256Factory() + { + } + + ~ModuleSHA256Factory() + { + } + + virtual Module *CreateModule(InspIRCd* Me) + { + return new ModuleSHA256(Me); + } + +}; + +extern "C" void * init_module( void ) +{ + return new ModuleSHA256Factory; +} diff --git a/src/modules/m_sha256.h b/src/modules/m_sha256.h new file mode 100644 index 000000000..c15f67189 --- /dev/null +++ b/src/modules/m_sha256.h @@ -0,0 +1,180 @@ +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev. + * E-mail: + * + * + * + * Written by Craig Edwards, Craig McLure, and others. + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + +#ifndef __SHA256_H__ +#define __SHA256_H__ + +#include "modules.h" + +#define SHA256_DIGEST_SIZE (256 / 8) +#define SHA256_BLOCK_SIZE (512 / 8) + +/** SHA256Request is the base class used to send SHA256 requests to m_sha256.so. + * You should not instantiate classes of type SHA256Request directly, instead + * you should instantiate classes of type SHA256ResetRequest, SHA256SumRequest, + * SHA256KeyRequest and SHA256HexRequest, shown below. + */ +class SHA256Request : public Request +{ + /** The keys (IV) to use */ + unsigned int* keys; + /** The output characters (hex sequence) to use */ + const char* outputs; + /** The string to hash */ + std::string tohash; + public: + /** Initialize SHA256Request as an SHA256_RESET message */ + SHA256Request(Module* Me, Module* Target) : Request(Me, Target, "SHA256_RESET") + { + } + + /** Initialize SHA256Request as an SHA256_SUM message */ + SHA256Request(Module* Me, Module* Target, const std::string &hashable) : Request(Me, Target, "SHA256_SUM"), keys(NULL), outputs(NULL), tohash(hashable) + { + } + + /** Initialize SHA256Request as an SHA256_KEY message */ + SHA256Request(Module* Me, Module* Target, unsigned int* k) : Request(Me, Target, "SHA256_KEY"), keys(k), outputs(NULL), tohash("") + { + } + + /** Initialize SHA256Request as an SHA256_HEX message */ + SHA256Request(Module* Me, Module* Target, const char* out) : Request(Me, Target, "SHA256_HEX"), keys(NULL), outputs(out), tohash("") + { + } + + /** Get data to be hashed */ + const char* GetHashData() + { + return tohash.c_str(); + } + + /** Get keys (IVs) to be used */ + unsigned int* GetKeyData() + { + return keys; + } + + /** Get output characters (hex sequence) to be used */ + const char* GetOutputs() + { + return outputs; + } +}; + +/** Send this class to m_sha256.so to reset the SHA256 module to a known state. + * This will reset the IV to the defaults specified by the SHA256 spec, + * and reset the hex sequence to "0123456789abcdef". It should be sent before + * ANY other Request types. + * + * Example: + * \code + * // Reset the SHA256 module. + * SHA256ResetRequest(this, SHA256Module).Send(); + * \endcode + */ +class SHA256ResetRequest : public SHA256Request +{ + public: + /** Initialize SHA256ResetRequest for sending. + * @param Me A pointer to the sending module + * @param Target A pointer to the m_sha256.so module + */ + SHA256ResetRequest(Module* Me, Module* Target) : SHA256Request(Me, Target) + { + } +}; + +/** Send this class to m_sha256.so to SHA256SUM a std::string. + * You should make sure you know the state of the module before you send this + * class, e.g. by first sending an SHA256ResetRequest class. The hash will be + * returned when you call Send(). + * + * Example: + * \code + * // ALWAYS ALWAYS reset first, or set your own IV and hex chars. + * SHA256ResetRequest(this, SHA256Module).Send(); + * // Get the SHA256 sum of the string 'doodads'. + * std::string result = SHA256SumRequest(this, SHA256Module, "doodads").Send(); + * \endcode + */ +class SHA256SumRequest : public SHA256Request +{ + public: + /** Initialize SHA256SumRequest for sending. + * @param Me A pointer to the sending module + * @param Target A pointer to the m_sha256.so module + * @param data The data to be hashed + */ + SHA256SumRequest(Module* Me, Module* Target, const std::string &data) : SHA256Request(Me, Target, data) + { + } +}; + +/** Send this class to m_sha256.so to change the IVs (keys) to use for hashing. + * You should make sure you know the state of the module before you send this + * class, e.g. by first sending an SHA256ResetRequest class. The default values for + * the IV's are those specified in the SHA256 specification. Only in very special + * circumstances should you need to change the IV's (see for example m_cloaking.cpp) + * + * Example: + * \code + * unsigned int iv[] = { 0xFFFFFFFF, 0x00000000, 0xAAAAAAAA, 0xCCCCCCCC }; + * SHA256KeyRequest(this, SHA256Module, iv); + * \endcode + */ +class SHA256KeyRequest : public SHA256Request +{ + public: + /** Initialize SHA256KeyRequest for sending. + * @param Me A pointer to the sending module + * @param Target A pointer to the m_sha256.so module + * @param data The new IV's. This should be an array of exactly four 32 bit values. + * On 64-bit architectures, the upper 32 bits of the values will be discarded. + */ + SHA256KeyRequest(Module* Me, Module* Target, unsigned int* data) : SHA256Request(Me, Target, data) + { + } +}; + +/** Send this class to m_sha256.so to change the hex sequence to use for generating the returned value. + * You should make sure you know the state of the module before you send this + * class, e.g. by first sending an SHA256ResetRequest class. The default value for + * the hex sequence is "0123456789abcdef". Only in very special circumstances should + * you need to change the hex sequence (see for example m_cloaking.cpp). + * + * Example: + * \code + * static const char tab[] = "fedcba9876543210"; + * SHA256HexRequest(this, SHA256Module, tab); + * \endcode + */ +class SHA256HexRequest : public SHA256Request +{ + public: + /** Initialize SHA256HexRequest for sending. + * @param Me A pointer to the sending module + * @param Target A pointer to the m_sha256.so module + * @param data The hex sequence to use. This should contain exactly 16 ASCII characters, + * terminated by a NULL char. + */ + SHA256HexRequest(Module* Me, Module* Target, const char* data) : SHA256Request(Me, Target, data) + { + } +}; + +#endif +