mirror of
https://github.com/anope/anope.git
synced 2026-07-04 19:53:13 +02:00
Rewrote the example configurations and split them
up into seperate files for each pseudo client. Also reorganized how the modules are stored, and made most of the old "extra" modules "core"
This commit is contained in:
Adam
@@ -0,0 +1,372 @@
|
||||
/* Module for encryption using MD5.
|
||||
*
|
||||
* Modified for Anope.
|
||||
* (C) 2003-2011 Anope Team
|
||||
* Contact us at team@anope.org
|
||||
*
|
||||
* Taken from IRC Services and is copyright (c) 1996-2002 Andrew Church.
|
||||
* E-mail: <achurch@achurch.org>
|
||||
* Parts written by Andrew Kempe and others.
|
||||
* This program is free but copyrighted software; see the file COPYING for
|
||||
* details.
|
||||
*/
|
||||
|
||||
#include "module.h"
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
|
||||
rights reserved.
|
||||
|
||||
License to copy and use this software is granted provided that it
|
||||
is identified as the "RSA Data Security, Inc. MD5 Message-Digest
|
||||
Algorithm" in all material mentioning or referencing this software
|
||||
or this function.
|
||||
|
||||
License is also granted to make and use derivative works provided
|
||||
that such works are identified as "derived from the RSA Data
|
||||
Security, Inc. MD5 Message-Digest Algorithm" in all material
|
||||
mentioning or referencing the derived work.
|
||||
|
||||
RSA Data Security, Inc. makes no representations concerning either
|
||||
the merchantability of this software or the suitability of this
|
||||
software for any particular purpose. It is provided "as is"
|
||||
without express or implied warranty of any kind.
|
||||
|
||||
These notices must be retained in any copies of any part of this
|
||||
documentation and/or software.
|
||||
*/
|
||||
|
||||
/* MD5 context. */
|
||||
struct MD5_CTX
|
||||
{
|
||||
unsigned state[4]; /* state (ABCD) */
|
||||
unsigned count[2]; /* number of bits, modulo 2^64 (lsb first) */
|
||||
unsigned char buffer[64]; /* input buffer */
|
||||
};
|
||||
|
||||
/* MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm
|
||||
*/
|
||||
|
||||
/* Constants for MD5Transform routine.
|
||||
*/
|
||||
enum
|
||||
{
|
||||
S11 = 7,
|
||||
S12 = 12,
|
||||
S13 = 17,
|
||||
S14 = 22,
|
||||
S21 = 5,
|
||||
S22 = 9,
|
||||
S23 = 14,
|
||||
S24 = 20,
|
||||
S31 = 4,
|
||||
S32 = 11,
|
||||
S33 = 16,
|
||||
S34 = 23,
|
||||
S41 = 6,
|
||||
S42 = 10,
|
||||
S43 = 15,
|
||||
S44 = 21
|
||||
};
|
||||
|
||||
void MD5Transform(unsigned [4], const unsigned char [64]);
|
||||
void Encode(unsigned char *, unsigned *, unsigned);
|
||||
void Decode(unsigned *, const unsigned char *, unsigned);
|
||||
|
||||
static unsigned char PADDING[64] = {
|
||||
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
|
||||
};
|
||||
|
||||
/* F, G, H and I are basic MD5 functions.
|
||||
*/
|
||||
inline static unsigned F(unsigned x, unsigned y, unsigned z) { return (x & y) | (~x & z); }
|
||||
inline static unsigned G(unsigned x, unsigned y, unsigned z) { return (x & z) | (y & ~z); }
|
||||
inline static unsigned H(unsigned x, unsigned y, unsigned z) { return x ^ y ^ z; }
|
||||
inline static unsigned I(unsigned x, unsigned y, unsigned z) { return y ^ (x | ~z); }
|
||||
|
||||
/* ROTATE_LEFT rotates x left n bits.
|
||||
*/
|
||||
inline static unsigned ROTATE_LEFT(unsigned x, unsigned n) { return (x << n) | (x >> (32 - n)); }
|
||||
|
||||
/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
|
||||
* Rotation is separate from addition to prevent recomputation.
|
||||
*/
|
||||
inline static void FF(unsigned &a, unsigned b, unsigned c, unsigned d, unsigned x, unsigned s, unsigned ac)
|
||||
{
|
||||
a += F(b, c, d) + x + ac;
|
||||
a = ROTATE_LEFT(a, s);
|
||||
a += b;
|
||||
}
|
||||
inline static void GG(unsigned &a, unsigned b, unsigned c, unsigned d, unsigned x, unsigned s, unsigned ac)
|
||||
{
|
||||
a += G(b, c, d) + x + ac;
|
||||
a = ROTATE_LEFT(a, s);
|
||||
a += b;
|
||||
}
|
||||
inline static void HH(unsigned &a, unsigned b, unsigned c, unsigned d, unsigned x, unsigned s, unsigned ac)
|
||||
{
|
||||
a += H(b, c, d) + x + ac;
|
||||
a = ROTATE_LEFT(a, s);
|
||||
a += b;
|
||||
}
|
||||
inline static void II(unsigned &a, unsigned b, unsigned c, unsigned d, unsigned x, unsigned s, unsigned ac)
|
||||
{
|
||||
a += I(b, c, d) + x + ac;
|
||||
a = ROTATE_LEFT(a, s);
|
||||
a += b;
|
||||
}
|
||||
|
||||
/* MD5 initialization. Begins an MD5 operation, writing a new context.
|
||||
*/
|
||||
void MD5Init(MD5_CTX *context)
|
||||
{
|
||||
context->count[0] = context->count[1] = 0;
|
||||
/* Load magic initialization constants. */
|
||||
context->state[0] = 0x67452301;
|
||||
context->state[1] = 0xefcdab89;
|
||||
context->state[2] = 0x98badcfe;
|
||||
context->state[3] = 0x10325476;
|
||||
}
|
||||
|
||||
/* MD5 block update operation. Continues an MD5 message-digest
|
||||
* operation, processing another message block, and updating the
|
||||
* context.
|
||||
*/
|
||||
void MD5Update(MD5_CTX *context, const unsigned char *input, unsigned inputLen)
|
||||
{
|
||||
unsigned i, index, partLen;
|
||||
|
||||
/* Compute number of bytes mod 64 */
|
||||
index = (context->count[0] >> 3) & 0x3F;
|
||||
|
||||
/* Update number of bits */
|
||||
if ((context->count[0] += inputLen << 3) < (inputLen << 3))
|
||||
++context->count[1];
|
||||
context->count[1] += inputLen >> 29;
|
||||
|
||||
partLen = 64 - index;
|
||||
|
||||
/* Transform as many times as possible. */
|
||||
if (inputLen >= partLen)
|
||||
{
|
||||
memcpy(&context->buffer[index], input, partLen);
|
||||
MD5Transform(context->state, context->buffer);
|
||||
|
||||
for (i = partLen; i + 63 < inputLen; i += 64)
|
||||
MD5Transform(context->state, &input[i]);
|
||||
|
||||
index = 0;
|
||||
}
|
||||
else
|
||||
i = 0;
|
||||
|
||||
/* Buffer remaining input */
|
||||
memcpy(&context->buffer[index], &input[i], inputLen - i);
|
||||
}
|
||||
|
||||
/* MD5 finalization. Ends an MD5 message-digest operation, writing the
|
||||
* the message digest and zeroizing the context.
|
||||
*/
|
||||
void MD5Final(unsigned char digest[17], MD5_CTX *context)
|
||||
{
|
||||
unsigned char bits[8];
|
||||
unsigned index, padLen;
|
||||
|
||||
/* Save number of bits */
|
||||
Encode(bits, context->count, 8);
|
||||
|
||||
/* Pad out to 56 mod 64. */
|
||||
index = (context->count[0] >> 3) & 0x3f;
|
||||
padLen = index < 56 ? 56 - index : 120 - index;
|
||||
MD5Update(context, PADDING, padLen);
|
||||
|
||||
/* Append length (before padding) */
|
||||
MD5Update(context, bits, 8);
|
||||
/* Store state in digest */
|
||||
Encode(digest, context->state, 16);
|
||||
|
||||
/* Zeroize sensitive information. */
|
||||
memset(context, 0, sizeof(*context));
|
||||
}
|
||||
|
||||
/* MD5 basic transformation. Transforms state based on block.
|
||||
*/
|
||||
void MD5Transform(unsigned state[4], const unsigned char block[64])
|
||||
{
|
||||
unsigned a = state[0], b = state[1], c = state[2], d = state[3], x[16];
|
||||
|
||||
Decode(x, block, 64);
|
||||
|
||||
/* Round 1 */
|
||||
FF(a, b, c, d, x[0], S11, 0xd76aa478); /* 1 */
|
||||
FF(d, a, b, c, x[1], S12, 0xe8c7b756); /* 2 */
|
||||
FF(c, d, a, b, x[2], S13, 0x242070db); /* 3 */
|
||||
FF(b, c, d, a, x[3], S14, 0xc1bdceee); /* 4 */
|
||||
FF(a, b, c, d, x[4], S11, 0xf57c0faf); /* 5 */
|
||||
FF(d, a, b, c, x[5], S12, 0x4787c62a); /* 6 */
|
||||
FF(c, d, a, b, x[6], S13, 0xa8304613); /* 7 */
|
||||
FF(b, c, d, a, x[7], S14, 0xfd469501); /* 8 */
|
||||
FF(a, b, c, d, x[8], S11, 0x698098d8); /* 9 */
|
||||
FF(d, a, b, c, x[9], S12, 0x8b44f7af); /* 10 */
|
||||
FF(c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
|
||||
FF(b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
|
||||
FF(a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
|
||||
FF(d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
|
||||
FF(c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
|
||||
FF(b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
|
||||
|
||||
/* Round 2 */
|
||||
GG(a, b, c, d, x[1], S21, 0xf61e2562); /* 17 */
|
||||
GG(d, a, b, c, x[6], S22, 0xc040b340); /* 18 */
|
||||
GG(c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
|
||||
GG(b, c, d, a, x[0], S24, 0xe9b6c7aa); /* 20 */
|
||||
GG(a, b, c, d, x[5], S21, 0xd62f105d); /* 21 */
|
||||
GG(d, a, b, c, x[10], S22, 0x2441453); /* 22 */
|
||||
GG(c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
|
||||
GG(b, c, d, a, x[4], S24, 0xe7d3fbc8); /* 24 */
|
||||
GG(a, b, c, d, x[9], S21, 0x21e1cde6); /* 25 */
|
||||
GG(d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
|
||||
GG(c, d, a, b, x[3], S23, 0xf4d50d87); /* 27 */
|
||||
GG(b, c, d, a, x[8], S24, 0x455a14ed); /* 28 */
|
||||
GG(a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
|
||||
GG(d, a, b, c, x[2], S22, 0xfcefa3f8); /* 30 */
|
||||
GG(c, d, a, b, x[7], S23, 0x676f02d9); /* 31 */
|
||||
GG(b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
|
||||
|
||||
/* Round 3 */
|
||||
HH(a, b, c, d, x[5], S31, 0xfffa3942); /* 33 */
|
||||
HH(d, a, b, c, x[8], S32, 0x8771f681); /* 34 */
|
||||
HH(c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
|
||||
HH(b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
|
||||
HH(a, b, c, d, x[1], S31, 0xa4beea44); /* 37 */
|
||||
HH(d, a, b, c, x[4], S32, 0x4bdecfa9); /* 38 */
|
||||
HH(c, d, a, b, x[7], S33, 0xf6bb4b60); /* 39 */
|
||||
HH(b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
|
||||
HH(a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
|
||||
HH(d, a, b, c, x[0], S32, 0xeaa127fa); /* 42 */
|
||||
HH(c, d, a, b, x[3], S33, 0xd4ef3085); /* 43 */
|
||||
HH(b, c, d, a, x[6], S34, 0x4881d05); /* 44 */
|
||||
HH(a, b, c, d, x[9], S31, 0xd9d4d039); /* 45 */
|
||||
HH(d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
|
||||
HH(c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
|
||||
HH(b, c, d, a, x[2], S34, 0xc4ac5665); /* 48 */
|
||||
|
||||
/* Round 4 */
|
||||
II(a, b, c, d, x[0], S41, 0xf4292244); /* 49 */
|
||||
II(d, a, b, c, x[7], S42, 0x432aff97); /* 50 */
|
||||
II(c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
|
||||
II(b, c, d, a, x[5], S44, 0xfc93a039); /* 52 */
|
||||
II(a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
|
||||
II(d, a, b, c, x[3], S42, 0x8f0ccc92); /* 54 */
|
||||
II(c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
|
||||
II(b, c, d, a, x[1], S44, 0x85845dd1); /* 56 */
|
||||
II(a, b, c, d, x[8], S41, 0x6fa87e4f); /* 57 */
|
||||
II(d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
|
||||
II(c, d, a, b, x[6], S43, 0xa3014314); /* 59 */
|
||||
II(b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
|
||||
II(a, b, c, d, x[4], S41, 0xf7537e82); /* 61 */
|
||||
II(d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
|
||||
II(c, d, a, b, x[2], S43, 0x2ad7d2bb); /* 63 */
|
||||
II(b, c, d, a, x[9], S44, 0xeb86d391); /* 64 */
|
||||
|
||||
state[0] += a;
|
||||
state[1] += b;
|
||||
state[2] += c;
|
||||
state[3] += d;
|
||||
|
||||
/* Zeroize sensitive information. */
|
||||
memset(x, 0, sizeof(x));
|
||||
}
|
||||
|
||||
/* Encodes input (unsigned) into output (unsigned char). Assumes len is
|
||||
* a multiple of 4.
|
||||
*/
|
||||
void Encode(unsigned char *output, unsigned *input, unsigned len)
|
||||
{
|
||||
unsigned i, j;
|
||||
|
||||
for (i = 0, j = 0; j < len; ++i, j += 4)
|
||||
{
|
||||
output[j] = static_cast<unsigned char>(input[i] & 0xff);
|
||||
output[j + 1] = static_cast<unsigned char>((input[i] >> 8) & 0xff);
|
||||
output[j + 2] = static_cast<unsigned char>((input[i] >> 16) & 0xff);
|
||||
output[j + 3] = static_cast<unsigned char>((input[i] >> 24) & 0xff);
|
||||
}
|
||||
}
|
||||
|
||||
/* Decodes input (unsigned char) into output (unsigned). Assumes len is
|
||||
* a multiple of 4.
|
||||
*/
|
||||
void Decode(unsigned *output, const unsigned char *input, unsigned len)
|
||||
{
|
||||
unsigned i, j;
|
||||
|
||||
for (i = 0, j = 0; j < len; ++i, j += 4)
|
||||
output[i] = static_cast<unsigned>(input[j]) | (static_cast<unsigned>(input[j + 1]) << 8) | (static_cast<unsigned>(input[j + 2]) << 16) | (static_cast<unsigned>(input[j + 3]) << 24);
|
||||
}
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
/* Module stuff. */
|
||||
|
||||
class EMD5 : public Module
|
||||
{
|
||||
public:
|
||||
EMD5(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, ENCRYPTION)
|
||||
{
|
||||
this->SetAuthor("Anope");
|
||||
|
||||
Implementation i[] = { I_OnEncrypt, I_OnCheckAuthentication };
|
||||
ModuleManager::Attach(i, this, sizeof(i) / sizeof(Implementation));
|
||||
}
|
||||
|
||||
EventReturn OnEncrypt(const Anope::string &src, Anope::string &dest)
|
||||
{
|
||||
MD5_CTX context;
|
||||
char digest[17] = "";
|
||||
Anope::string buf = "md5:";
|
||||
|
||||
MD5Init(&context);
|
||||
MD5Update(&context, reinterpret_cast<const unsigned char *>(src.c_str()), src.length());
|
||||
MD5Final(reinterpret_cast<unsigned char *>(digest), &context);
|
||||
|
||||
buf += Anope::Hex(digest, 16);
|
||||
Log(LOG_DEBUG_2) << "(enc_md5) hashed password from [" << src << "] to [" << buf << "]";
|
||||
dest = buf;
|
||||
return EVENT_ALLOW;
|
||||
}
|
||||
|
||||
EventReturn OnCheckAuthentication(Command *c, CommandSource *source, const std::vector<Anope::string> ¶ms, const Anope::string &account, const Anope::string &password)
|
||||
{
|
||||
NickAlias *na = findnick(account);
|
||||
NickCore *nc = na ? na->nc : NULL;
|
||||
if (na == NULL)
|
||||
return EVENT_CONTINUE;
|
||||
|
||||
size_t pos = nc->pass.find(':');
|
||||
if (pos == Anope::string::npos)
|
||||
return EVENT_CONTINUE;
|
||||
Anope::string hash_method(nc->pass.begin(), nc->pass.begin() + pos);
|
||||
if (!hash_method.equals_cs("md5"))
|
||||
return EVENT_CONTINUE;
|
||||
|
||||
Anope::string buf;
|
||||
this->OnEncrypt(password, buf);
|
||||
if (nc->pass.equals_cs(buf))
|
||||
{
|
||||
/* if we are NOT the first module in the list,
|
||||
* we want to re-encrypt the pass with the new encryption
|
||||
*/
|
||||
if (ModuleManager::FindFirstOf(ENCRYPTION) != this)
|
||||
enc_encrypt(password, nc->pass);
|
||||
return EVENT_ALLOW;
|
||||
}
|
||||
|
||||
return EVENT_CONTINUE;
|
||||
}
|
||||
};
|
||||
|
||||
MODULE_INIT(EMD5)
|
||||
@@ -0,0 +1,74 @@
|
||||
/* Module for plain text encryption.
|
||||
*
|
||||
* (C) 2003-2011 Anope Team
|
||||
* Contact us at team@anope.org
|
||||
*
|
||||
* This program is free but copyrighted software; see the file COPYING for
|
||||
* details.
|
||||
*/
|
||||
|
||||
#include "module.h"
|
||||
|
||||
class ENone : public Module
|
||||
{
|
||||
public:
|
||||
ENone(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, ENCRYPTION)
|
||||
{
|
||||
this->SetAuthor("Anope");
|
||||
|
||||
Implementation i[] = { I_OnEncrypt, I_OnDecrypt, I_OnCheckAuthentication };
|
||||
ModuleManager::Attach(i, this, sizeof(i) / sizeof(Implementation));
|
||||
}
|
||||
|
||||
EventReturn OnEncrypt(const Anope::string &src, Anope::string &dest)
|
||||
{
|
||||
Anope::string buf = "plain:";
|
||||
Anope::string cpass;
|
||||
Anope::B64Encode(src, cpass);
|
||||
buf += cpass;
|
||||
Log(LOG_DEBUG_2) << "(enc_none) hashed password from [" << src << "] to [" << buf << "]";
|
||||
dest = buf;
|
||||
return EVENT_ALLOW;
|
||||
}
|
||||
|
||||
EventReturn OnDecrypt(const Anope::string &hashm, const Anope::string &src, Anope::string &dest)
|
||||
{
|
||||
if (!hashm.equals_cs("plain"))
|
||||
return EVENT_CONTINUE;
|
||||
size_t pos = src.find(':');
|
||||
Anope::string buf = src.substr(pos + 1);
|
||||
Anope::B64Decode(buf, dest);
|
||||
return EVENT_ALLOW;
|
||||
}
|
||||
|
||||
EventReturn OnCheckAuthentication(Command *c, CommandSource *source, const std::vector<Anope::string> ¶ms, const Anope::string &account, const Anope::string &password)
|
||||
{
|
||||
NickAlias *na = findnick(account);
|
||||
NickCore *nc = na ? na->nc : NULL;
|
||||
if (na == NULL)
|
||||
return EVENT_CONTINUE;
|
||||
|
||||
size_t pos = nc->pass.find(':');
|
||||
if (pos == Anope::string::npos)
|
||||
return EVENT_CONTINUE;
|
||||
Anope::string hash_method(nc->pass.begin(), nc->pass.begin() + pos);
|
||||
if (!hash_method.equals_cs("plain"))
|
||||
return EVENT_CONTINUE;
|
||||
|
||||
Anope::string buf;
|
||||
this->OnEncrypt(password, buf);
|
||||
if (nc->pass.equals_cs(buf))
|
||||
{
|
||||
/* if we are NOT the first module in the list,
|
||||
* we want to re-encrypt the pass with the new encryption
|
||||
*/
|
||||
if (ModuleManager::FindFirstOf(ENCRYPTION) != this)
|
||||
enc_encrypt(password, nc->pass);
|
||||
return EVENT_ALLOW;
|
||||
}
|
||||
|
||||
return EVENT_CONTINUE;
|
||||
}
|
||||
};
|
||||
|
||||
MODULE_INIT(ENone)
|
||||
@@ -0,0 +1,382 @@
|
||||
/* Include file for high-level encryption routines.
|
||||
*
|
||||
* (C) 2003-2011 Anope Team
|
||||
* Contact us at team@anope.org
|
||||
*
|
||||
* Please read COPYING and README for further details.
|
||||
*
|
||||
* Based on the original code of Epona by Lara.
|
||||
* Based on the original code of Services by Andy Church.
|
||||
*/
|
||||
|
||||
#include "module.h"
|
||||
|
||||
/******** Code specific to the type of encryption. ********/
|
||||
|
||||
/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
|
||||
rights reserved.
|
||||
|
||||
License to copy and use this software is granted provided that it
|
||||
is identified as the "RSA Data Security, Inc. MD5 Message-Digest
|
||||
Algorithm" in all material mentioning or referencing this software
|
||||
or this function.
|
||||
|
||||
License is also granted to make and use derivative works provided
|
||||
that such works are identified as "derived from the RSA Data
|
||||
Security, Inc. MD5 Message-Digest Algorithm" in all material
|
||||
mentioning or referencing the derived work.
|
||||
|
||||
RSA Data Security, Inc. makes no representations concerning either
|
||||
the merchantability of this software or the suitability of this
|
||||
software for any particular purpose. It is provided "as is"
|
||||
without express or implied warranty of any kind.
|
||||
|
||||
These notices must be retained in any copies of any part of this
|
||||
documentation and/or software.
|
||||
*/
|
||||
|
||||
/* MD5 context. */
|
||||
struct MD5_CTX
|
||||
{
|
||||
unsigned state[4]; /* state (ABCD) */
|
||||
unsigned count[2]; /* number of bits, modulo 2^64 (lsb first) */
|
||||
unsigned char buffer[64]; /* input buffer */
|
||||
};
|
||||
|
||||
/* MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm
|
||||
*/
|
||||
|
||||
/* Constants for MD5Transform routine.
|
||||
*/
|
||||
enum
|
||||
{
|
||||
S11 = 7,
|
||||
S12 = 12,
|
||||
S13 = 17,
|
||||
S14 = 22,
|
||||
S21 = 5,
|
||||
S22 = 9,
|
||||
S23 = 14,
|
||||
S24 = 20,
|
||||
S31 = 4,
|
||||
S32 = 11,
|
||||
S33 = 16,
|
||||
S34 = 23,
|
||||
S41 = 6,
|
||||
S42 = 10,
|
||||
S43 = 15,
|
||||
S44 = 21
|
||||
};
|
||||
|
||||
static void MD5Transform(unsigned [4], const unsigned char[64]);
|
||||
static void Encode(unsigned char *, unsigned *, unsigned);
|
||||
static void Decode(unsigned *, const unsigned char *, unsigned);
|
||||
|
||||
static unsigned char PADDING[64] = {
|
||||
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
|
||||
};
|
||||
|
||||
/* F, G, H and I are basic MD5 functions.
|
||||
*/
|
||||
inline static unsigned F(unsigned x, unsigned y, unsigned z) { return (x & y) | (~x & z); }
|
||||
inline static unsigned G(unsigned x, unsigned y, unsigned z) { return (x & z) | (y & ~z); }
|
||||
inline static unsigned H(unsigned x, unsigned y, unsigned z) { return x ^ y ^ z; }
|
||||
inline static unsigned MD5_I(unsigned x, unsigned y, unsigned z) { return y ^ (x | ~z); }
|
||||
|
||||
/* ROTATE_LEFT rotates x left n bits.
|
||||
*/
|
||||
inline static unsigned ROTATE_LEFT(unsigned x, unsigned n) { return (x << n) | (x >> (32 - n)); }
|
||||
|
||||
/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
|
||||
* Rotation is separate from addition to prevent recomputation.
|
||||
*/
|
||||
inline static void FF(unsigned &a, unsigned b, unsigned c, unsigned d, unsigned x, unsigned s, unsigned ac)
|
||||
{
|
||||
a += F(b, c, d) + x + ac;
|
||||
a = ROTATE_LEFT(a, s);
|
||||
a += b;
|
||||
}
|
||||
inline static void GG(unsigned &a, unsigned b, unsigned c, unsigned d, unsigned x, unsigned s, unsigned ac)
|
||||
{
|
||||
a += G(b, c, d) + x + ac;
|
||||
a = ROTATE_LEFT(a, s);
|
||||
a += b;
|
||||
}
|
||||
inline static void HH(unsigned &a, unsigned b, unsigned c, unsigned d, unsigned x, unsigned s, unsigned ac)
|
||||
{
|
||||
a += H(b, c, d) + x + ac;
|
||||
a = ROTATE_LEFT(a, s);
|
||||
a += b;
|
||||
}
|
||||
inline static void II(unsigned &a, unsigned b, unsigned c, unsigned d, unsigned x, unsigned s, unsigned ac)
|
||||
{
|
||||
a += MD5_I(b, c, d) + x + ac;
|
||||
a = ROTATE_LEFT(a, s);
|
||||
a += b;
|
||||
}
|
||||
|
||||
/* MD5 initialization. Begins an MD5 operation, writing a new context.
|
||||
*/
|
||||
static void MD5Init(MD5_CTX *context)
|
||||
{
|
||||
context->count[0] = context->count[1] = 0;
|
||||
/* Load magic initialization constants.
|
||||
*/
|
||||
context->state[0] = 0x67452301;
|
||||
context->state[1] = 0xefcdab89;
|
||||
context->state[2] = 0x98badcfe;
|
||||
context->state[3] = 0x10325476;
|
||||
}
|
||||
|
||||
/* MD5 block update operation. Continues an MD5 message-digest
|
||||
* operation, processing another message block, and updating the
|
||||
* context.
|
||||
*/
|
||||
static void MD5Update(MD5_CTX *context, const unsigned char *input, unsigned inputLen)
|
||||
{
|
||||
unsigned i, index, partLen;
|
||||
|
||||
/* Compute number of bytes mod 64 */
|
||||
index = (context->count[0] >> 3) & 0x3F;
|
||||
|
||||
/* Update number of bits */
|
||||
if ((context->count[0] += inputLen << 3) < (inputLen << 3))
|
||||
++context->count[1];
|
||||
context->count[1] += inputLen >> 29;
|
||||
|
||||
partLen = 64 - index;
|
||||
|
||||
/* Transform as many times as possible.
|
||||
*/
|
||||
if (inputLen >= partLen)
|
||||
{
|
||||
memcpy(&context->buffer[index], input, partLen);
|
||||
MD5Transform(context->state, context->buffer);
|
||||
|
||||
for (i = partLen; i + 63 < inputLen; i += 64)
|
||||
MD5Transform(context->state, &input[i]);
|
||||
|
||||
index = 0;
|
||||
}
|
||||
else
|
||||
i = 0;
|
||||
|
||||
/* Buffer remaining input */
|
||||
memcpy(&context->buffer[index], &input[i], inputLen - i);
|
||||
}
|
||||
|
||||
/* MD5 finalization. Ends an MD5 message-digest operation, writing the
|
||||
* the message digest and zeroizing the context.
|
||||
*/
|
||||
static void MD5Final(unsigned char digest[17], MD5_CTX *context)
|
||||
{
|
||||
unsigned char bits[8];
|
||||
unsigned index, padLen;
|
||||
|
||||
/* Save number of bits */
|
||||
Encode(bits, context->count, 8);
|
||||
|
||||
/* Pad out to 56 mod 64.
|
||||
*/
|
||||
index = (context->count[0] >> 3) & 0x3f;
|
||||
padLen = index < 56 ? 56 - index : 120 - index;
|
||||
MD5Update(context, PADDING, padLen);
|
||||
|
||||
/* Append length (before padding) */
|
||||
MD5Update(context, bits, 8);
|
||||
/* Store state in digest */
|
||||
Encode(digest, context->state, 16);
|
||||
|
||||
/* Zeroize sensitive information.
|
||||
*/
|
||||
memset(context, 0, sizeof(*context));
|
||||
}
|
||||
|
||||
/* MD5 basic transformation. Transforms state based on block.
|
||||
*/
|
||||
static void MD5Transform(unsigned state[4], const unsigned char block[64])
|
||||
{
|
||||
unsigned a = state[0], b = state[1], c = state[2], d = state[3], x[16];
|
||||
|
||||
Decode(x, block, 64);
|
||||
|
||||
/* Round 1 */
|
||||
FF(a, b, c, d, x[0], S11, 0xd76aa478); /* 1 */
|
||||
FF(d, a, b, c, x[1], S12, 0xe8c7b756); /* 2 */
|
||||
FF(c, d, a, b, x[2], S13, 0x242070db); /* 3 */
|
||||
FF(b, c, d, a, x[3], S14, 0xc1bdceee); /* 4 */
|
||||
FF(a, b, c, d, x[4], S11, 0xf57c0faf); /* 5 */
|
||||
FF(d, a, b, c, x[5], S12, 0x4787c62a); /* 6 */
|
||||
FF(c, d, a, b, x[6], S13, 0xa8304613); /* 7 */
|
||||
FF(b, c, d, a, x[7], S14, 0xfd469501); /* 8 */
|
||||
FF(a, b, c, d, x[8], S11, 0x698098d8); /* 9 */
|
||||
FF(d, a, b, c, x[9], S12, 0x8b44f7af); /* 10 */
|
||||
FF(c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
|
||||
FF(b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
|
||||
FF(a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
|
||||
FF(d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
|
||||
FF(c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
|
||||
FF(b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
|
||||
|
||||
/* Round 2 */
|
||||
GG(a, b, c, d, x[1], S21, 0xf61e2562); /* 17 */
|
||||
GG(d, a, b, c, x[6], S22, 0xc040b340); /* 18 */
|
||||
GG(c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
|
||||
GG(b, c, d, a, x[0], S24, 0xe9b6c7aa); /* 20 */
|
||||
GG(a, b, c, d, x[5], S21, 0xd62f105d); /* 21 */
|
||||
GG(d, a, b, c, x[10], S22, 0x2441453); /* 22 */
|
||||
GG(c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
|
||||
GG(b, c, d, a, x[4], S24, 0xe7d3fbc8); /* 24 */
|
||||
GG(a, b, c, d, x[9], S21, 0x21e1cde6); /* 25 */
|
||||
GG(d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
|
||||
GG(c, d, a, b, x[3], S23, 0xf4d50d87); /* 27 */
|
||||
GG(b, c, d, a, x[8], S24, 0x455a14ed); /* 28 */
|
||||
GG(a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
|
||||
GG(d, a, b, c, x[2], S22, 0xfcefa3f8); /* 30 */
|
||||
GG(c, d, a, b, x[7], S23, 0x676f02d9); /* 31 */
|
||||
GG(b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
|
||||
|
||||
/* Round 3 */
|
||||
HH(a, b, c, d, x[5], S31, 0xfffa3942); /* 33 */
|
||||
HH(d, a, b, c, x[8], S32, 0x8771f681); /* 34 */
|
||||
HH(c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
|
||||
HH(b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
|
||||
HH(a, b, c, d, x[1], S31, 0xa4beea44); /* 37 */
|
||||
HH(d, a, b, c, x[4], S32, 0x4bdecfa9); /* 38 */
|
||||
HH(c, d, a, b, x[7], S33, 0xf6bb4b60); /* 39 */
|
||||
HH(b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
|
||||
HH(a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
|
||||
HH(d, a, b, c, x[0], S32, 0xeaa127fa); /* 42 */
|
||||
HH(c, d, a, b, x[3], S33, 0xd4ef3085); /* 43 */
|
||||
HH(b, c, d, a, x[6], S34, 0x4881d05); /* 44 */
|
||||
HH(a, b, c, d, x[9], S31, 0xd9d4d039); /* 45 */
|
||||
HH(d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
|
||||
HH(c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
|
||||
HH(b, c, d, a, x[2], S34, 0xc4ac5665); /* 48 */
|
||||
|
||||
/* Round 4 */
|
||||
II(a, b, c, d, x[0], S41, 0xf4292244); /* 49 */
|
||||
II(d, a, b, c, x[7], S42, 0x432aff97); /* 50 */
|
||||
II(c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
|
||||
II(b, c, d, a, x[5], S44, 0xfc93a039); /* 52 */
|
||||
II(a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
|
||||
II(d, a, b, c, x[3], S42, 0x8f0ccc92); /* 54 */
|
||||
II(c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
|
||||
II(b, c, d, a, x[1], S44, 0x85845dd1); /* 56 */
|
||||
II(a, b, c, d, x[8], S41, 0x6fa87e4f); /* 57 */
|
||||
II(d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
|
||||
II(c, d, a, b, x[6], S43, 0xa3014314); /* 59 */
|
||||
II(b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
|
||||
II(a, b, c, d, x[4], S41, 0xf7537e82); /* 61 */
|
||||
II(d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
|
||||
II(c, d, a, b, x[2], S43, 0x2ad7d2bb); /* 63 */
|
||||
II(b, c, d, a, x[9], S44, 0xeb86d391); /* 64 */
|
||||
|
||||
state[0] += a;
|
||||
state[1] += b;
|
||||
state[2] += c;
|
||||
state[3] += d;
|
||||
|
||||
/* Zeroize sensitive information.
|
||||
*/
|
||||
memset(x, 0, sizeof(x));
|
||||
}
|
||||
|
||||
/* Encodes input (unsigned) into output (unsigned char). Assumes len is
|
||||
* a multiple of 4.
|
||||
*/
|
||||
static void Encode(unsigned char *output, unsigned *input, unsigned len)
|
||||
{
|
||||
unsigned i, j;
|
||||
|
||||
for (i = 0, j = 0; j < len; ++i, j += 4)
|
||||
{
|
||||
output[j] = static_cast<unsigned char>(input[i] & 0xff);
|
||||
output[j + 1] = static_cast<unsigned char>((input[i] >> 8) & 0xff);
|
||||
output[j + 2] = static_cast<unsigned char>((input[i] >> 16) & 0xff);
|
||||
output[j + 3] = static_cast<unsigned char>((input[i] >> 24) & 0xff);
|
||||
}
|
||||
}
|
||||
|
||||
/* Decodes input (unsigned char) into output (unsigned). Assumes len is
|
||||
* a multiple of 4.
|
||||
*/
|
||||
static void Decode(unsigned *output, const unsigned char *input, unsigned len)
|
||||
{
|
||||
unsigned i, j;
|
||||
|
||||
for (i = 0, j = 0; j < len; ++i, j += 4)
|
||||
output[i] = static_cast<unsigned>(input[j]) | (static_cast<unsigned>(input[j + 1]) << 8) | (static_cast<unsigned>(input[j + 2]) << 16) | (static_cast<unsigned>(input[j + 3]) << 24);
|
||||
}
|
||||
|
||||
/*************************************************************************/
|
||||
|
||||
/******** Our own high-level routines. ********/
|
||||
|
||||
inline static char XTOI(char c) { return c > 9 ? c - 'A' + 10 : c - '0'; }
|
||||
|
||||
class EOld : public Module
|
||||
{
|
||||
public:
|
||||
EOld(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, ENCRYPTION)
|
||||
{
|
||||
this->SetAuthor("Anope");
|
||||
|
||||
Implementation i[] = { I_OnEncrypt, I_OnCheckAuthentication };
|
||||
ModuleManager::Attach(i, this, sizeof(i) / sizeof(Implementation));
|
||||
}
|
||||
|
||||
EventReturn OnEncrypt(const Anope::string &src, Anope::string &dest)
|
||||
{
|
||||
MD5_CTX context;
|
||||
char digest[33] = "", digest2[17] = "";
|
||||
int i;
|
||||
Anope::string buf = "oldmd5:";
|
||||
|
||||
memset(&context, 0, sizeof(context));
|
||||
|
||||
MD5Init(&context);
|
||||
MD5Update(&context, reinterpret_cast<const unsigned char *>(src.c_str()), src.length());
|
||||
MD5Final(reinterpret_cast<unsigned char *>(digest), &context);
|
||||
for (i = 0; i < 32; i += 2)
|
||||
digest2[i / 2] = XTOI(digest[i]) << 4 | XTOI(digest[i + 1]);
|
||||
|
||||
buf += Anope::Hex(digest2, 16);
|
||||
Log(LOG_DEBUG_2) << "(enc_old) hashed password from [" << src << "] to [" << buf << "]";
|
||||
dest = buf;
|
||||
return EVENT_ALLOW;
|
||||
}
|
||||
|
||||
EventReturn OnCheckAuthentication(Command *c, CommandSource *source, const std::vector<Anope::string> ¶ms, const Anope::string &account, const Anope::string &password)
|
||||
{
|
||||
NickAlias *na = findnick(account);
|
||||
NickCore *nc = na ? na->nc : NULL;
|
||||
if (na == NULL)
|
||||
return EVENT_CONTINUE;
|
||||
|
||||
size_t pos = nc->pass.find(':');
|
||||
if (pos == Anope::string::npos)
|
||||
return EVENT_CONTINUE;
|
||||
Anope::string hash_method(nc->pass.begin(), nc->pass.begin() + pos);
|
||||
if (!hash_method.equals_cs("oldmd5"))
|
||||
return EVENT_CONTINUE;
|
||||
|
||||
Anope::string buf;
|
||||
this->OnEncrypt(password, buf);
|
||||
if (nc->pass.equals_cs(buf))
|
||||
{
|
||||
/* if we are NOT the first module in the list,
|
||||
* we want to re-encrypt the pass with the new encryption
|
||||
*/
|
||||
if (ModuleManager::FindFirstOf(ENCRYPTION) != this)
|
||||
enc_encrypt(password, nc->pass);
|
||||
return EVENT_ALLOW;
|
||||
}
|
||||
|
||||
return EVENT_CONTINUE;
|
||||
}
|
||||
};
|
||||
|
||||
MODULE_INIT(EOld)
|
||||
@@ -0,0 +1,222 @@
|
||||
/*
|
||||
SHA-1 in C
|
||||
By Steve Reid <steve@edmweb.com>
|
||||
100% Public Domain
|
||||
|
||||
Test Vectors (from FIPS PUB 180-1)
|
||||
"abc"
|
||||
A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
|
||||
"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
|
||||
84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
|
||||
A million repetitions of "a"
|
||||
34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
|
||||
*/
|
||||
|
||||
/* #define LITTLE_ENDIAN * This should be #define'd if true. */
|
||||
|
||||
#include "module.h"
|
||||
|
||||
struct SHA1_CTX
|
||||
{
|
||||
uint32 state[5];
|
||||
uint32 count[2];
|
||||
unsigned char buffer[64];
|
||||
};
|
||||
|
||||
void SHA1Transform(uint32 state[5], const unsigned char buffer[64]);
|
||||
void SHA1Init(SHA1_CTX *context);
|
||||
void SHA1Update(SHA1_CTX *context, const unsigned char *data, uint32 len);
|
||||
void SHA1Final(unsigned char digest[20], SHA1_CTX *context);
|
||||
|
||||
inline static uint32 rol(uint32 value, uint32 bits) { return (value << bits) | (value >> (32 - bits)); }
|
||||
|
||||
union CHAR64LONG16
|
||||
{
|
||||
unsigned char c[64];
|
||||
uint32 l[16];
|
||||
};
|
||||
|
||||
/* blk0() and blk() perform the initial expand. */
|
||||
/* I got the idea of expanding during the round function from SSLeay */
|
||||
inline static uint32 blk0(CHAR64LONG16 *block, uint32 i)
|
||||
{
|
||||
#ifdef LITTLE_ENDIAN
|
||||
return block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | (rol(block->l[i], 8) & 0x00FF00FF);
|
||||
#else
|
||||
return block->l[i];
|
||||
#endif
|
||||
}
|
||||
inline static uint32 blk(CHAR64LONG16 *block, uint32 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); }
|
||||
|
||||
/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
|
||||
inline static void R0(CHAR64LONG16 *block, uint32 v, uint32 &w, uint32 x, uint32 y, uint32 &z, uint32 i) { z += ((w & (x ^ y)) ^ y) + blk0(block, i) + 0x5A827999 + rol(v, 5); w = rol(w, 30); }
|
||||
inline static void R1(CHAR64LONG16 *block, uint32 v, uint32 &w, uint32 x, uint32 y, uint32 &z, uint32 i) { z += ((w & (x ^ y)) ^ y) + blk(block, i) + 0x5A827999 + rol(v, 5); w = rol(w, 30); }
|
||||
inline static void R2(CHAR64LONG16 *block, uint32 v, uint32 &w, uint32 x, uint32 y, uint32 &z, uint32 i) { z += (w ^ x ^ y) + blk(block, i) + 0x6ED9EBA1 + rol(v, 5); w = rol(w, 30); }
|
||||
inline static void R3(CHAR64LONG16 *block, uint32 v, uint32 &w, uint32 x, uint32 y, uint32 &z, uint32 i) { z += (((w | x) & y) | (w & x)) + blk(block, i) + 0x8F1BBCDC + rol(v, 5); w = rol(w, 30); }
|
||||
inline static void R4(CHAR64LONG16 *block, uint32 v, uint32 &w, uint32 x, uint32 y, uint32 &z, uint32 i) { z += (w ^ x ^ y) + blk(block, i) + 0xCA62C1D6 + rol(v, 5); w = rol(w, 30); }
|
||||
|
||||
/* Hash a single 512-bit block. This is the core of the algorithm. */
|
||||
|
||||
void SHA1Transform(uint32 state[5], const unsigned char buffer[64])
|
||||
{
|
||||
uint32 a, b, c, d, e;
|
||||
static unsigned char workspace[64];
|
||||
CHAR64LONG16 *block = reinterpret_cast<CHAR64LONG16 *>(workspace);
|
||||
memcpy(block, buffer, 64);
|
||||
/* Copy context->state[] to working vars */
|
||||
a = state[0];
|
||||
b = state[1];
|
||||
c = state[2];
|
||||
d = state[3];
|
||||
e = state[4];
|
||||
/* 4 rounds of 20 operations each. Loop unrolled. */
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
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);
|
||||
/* Add the working vars back into context.state[] */
|
||||
state[0] += a;
|
||||
state[1] += b;
|
||||
state[2] += c;
|
||||
state[3] += d;
|
||||
state[4] += e;
|
||||
/* Wipe variables */
|
||||
a = b = c = d = e = 0;
|
||||
}
|
||||
|
||||
/* SHA1Init - Initialize new context */
|
||||
|
||||
void SHA1Init(SHA1_CTX *context)
|
||||
{
|
||||
/* SHA1 initialization constants */
|
||||
context->state[0] = 0x67452301;
|
||||
context->state[1] = 0xEFCDAB89;
|
||||
context->state[2] = 0x98BADCFE;
|
||||
context->state[3] = 0x10325476;
|
||||
context->state[4] = 0xC3D2E1F0;
|
||||
context->count[0] = context->count[1] = 0;
|
||||
}
|
||||
|
||||
/* Run your data through this. */
|
||||
|
||||
void SHA1Update(SHA1_CTX *context, const unsigned char *data, uint32 len)
|
||||
{
|
||||
uint32 i, j;
|
||||
|
||||
j = (context->count[0] >> 3) & 63;
|
||||
if ((context->count[0] += len << 3) < (len << 3))
|
||||
++context->count[1];
|
||||
context->count[1] += len >> 29;
|
||||
if (j + len > 63)
|
||||
{
|
||||
memcpy(&context->buffer[j], data, (i = 64 - j));
|
||||
SHA1Transform(context->state, context->buffer);
|
||||
for (; i + 63 < len; i += 64)
|
||||
SHA1Transform(context->state, &data[i]);
|
||||
j = 0;
|
||||
}
|
||||
else
|
||||
i = 0;
|
||||
memcpy(&context->buffer[j], &data[i], len - i);
|
||||
}
|
||||
|
||||
/* Add padding and return the message digest. */
|
||||
|
||||
void SHA1Final(unsigned char digest[21], SHA1_CTX *context)
|
||||
{
|
||||
uint32 i;
|
||||
unsigned char finalcount[8];
|
||||
|
||||
for (i = 0; i < 8; ++i)
|
||||
finalcount[i] = static_cast<unsigned char>((context->count[i >= 4 ? 0 : 1] >> ((3 - (i & 3)) * 8)) & 255); /* Endian independent */
|
||||
SHA1Update(context, reinterpret_cast<const unsigned char *>("\200"), 1);
|
||||
while ((context->count[0] & 504) != 448)
|
||||
SHA1Update(context, reinterpret_cast<const unsigned char *>("\0"), 1);
|
||||
SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */
|
||||
for (i = 0; i < 20; ++i)
|
||||
digest[i] = static_cast<unsigned char>((context->state[i>>2] >> ((3 - (i & 3)) * 8)) & 255);
|
||||
/* Wipe variables */
|
||||
i = 0;
|
||||
memset(context->buffer, 0, 64);
|
||||
memset(context->state, 0, 20);
|
||||
memset(context->count, 0, 8);
|
||||
memset(&finalcount, 0, 8);
|
||||
SHA1Transform(context->state, context->buffer);
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
/*****************************************************************************/
|
||||
|
||||
/* Module stuff. */
|
||||
|
||||
class ESHA1 : public Module
|
||||
{
|
||||
public:
|
||||
ESHA1(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, ENCRYPTION)
|
||||
{
|
||||
this->SetAuthor("Anope");
|
||||
|
||||
Implementation i[] = { I_OnEncrypt, I_OnCheckAuthentication };
|
||||
ModuleManager::Attach(i, this, sizeof(i) / sizeof(Implementation));
|
||||
}
|
||||
|
||||
EventReturn OnEncrypt(const Anope::string &src, Anope::string &dest)
|
||||
{
|
||||
SHA1_CTX context;
|
||||
char digest[21] = "";
|
||||
Anope::string buf = "sha1:";
|
||||
|
||||
SHA1Init(&context);
|
||||
SHA1Update(&context, reinterpret_cast<const unsigned char *>(src.c_str()), src.length());
|
||||
SHA1Final(reinterpret_cast<unsigned char *>(digest), &context);
|
||||
|
||||
buf += Anope::Hex(digest, 20);
|
||||
Log(LOG_DEBUG_2) << "(enc_sha1) hashed password from [" << src << "] to [" << buf << "]";
|
||||
dest = buf;
|
||||
return EVENT_ALLOW;
|
||||
}
|
||||
|
||||
EventReturn OnCheckAuthentication(Command *c, CommandSource *source, const std::vector<Anope::string> ¶ms, const Anope::string &account, const Anope::string &password)
|
||||
{
|
||||
NickAlias *na = findnick(account);
|
||||
NickCore *nc = na ? na->nc : NULL;
|
||||
if (na == NULL)
|
||||
return EVENT_CONTINUE;
|
||||
|
||||
size_t pos = nc->pass.find(':');
|
||||
if (pos == Anope::string::npos)
|
||||
return EVENT_CONTINUE;
|
||||
Anope::string hash_method(nc->pass.begin(), nc->pass.begin() + pos);
|
||||
if (!hash_method.equals_cs("sha1"))
|
||||
return EVENT_CONTINUE;
|
||||
|
||||
Anope::string buf;
|
||||
this->OnEncrypt(password, buf);
|
||||
if (nc->pass.equals_cs(buf))
|
||||
{
|
||||
if (ModuleManager::FindFirstOf(ENCRYPTION) != this)
|
||||
enc_encrypt(password, nc->pass);
|
||||
return EVENT_ALLOW;
|
||||
}
|
||||
|
||||
return EVENT_CONTINUE;
|
||||
}
|
||||
};
|
||||
|
||||
MODULE_INIT(ESHA1)
|
||||
@@ -0,0 +1,314 @@
|
||||
/* This module generates and compares password hashes using SHA256 algorithms.
|
||||
* To help reduce the risk of dictionary attacks, the code appends random bytes
|
||||
* (so-called "salt") to the original plain text before generating hashes and
|
||||
* stores this salt appended to the result. To verify another plain text value
|
||||
* against the given hash, this module will retrieve the salt value from the
|
||||
* password string and use it when computing a new hash of the plain text.
|
||||
*
|
||||
* If an intruder gets access to your system or uses a brute force attack,
|
||||
* salt will not provide much value.
|
||||
* IMPORTANT: DATA HASHES CANNOT BE "DECRYPTED" BACK TO PLAIN TEXT.
|
||||
*
|
||||
* Modified for Anope.
|
||||
* (C) 2003-2011 Anope Team
|
||||
* Contact us at team@anope.org
|
||||
*
|
||||
* Taken from InspIRCd ( www.inspircd.org )
|
||||
* see http://wiki.inspircd.org/Credits
|
||||
*
|
||||
* This program is free but copyrighted software; see
|
||||
* the file COPYING for details.
|
||||
*/
|
||||
|
||||
/* FIPS 180-2 SHA-224/256/384/512 implementation
|
||||
* Last update: 05/23/2005
|
||||
* Issue date: 04/30/2005
|
||||
*
|
||||
* Copyright (C) 2005 Olivier Gay <olivier.gay@a3.epfl.ch>
|
||||
* 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.
|
||||
*/
|
||||
|
||||
#include "module.h"
|
||||
|
||||
static const unsigned SHA256_DIGEST_SIZE = 256 / 8;
|
||||
static const unsigned SHA256_BLOCK_SIZE = 512 / 8;
|
||||
|
||||
/** An sha256 context
|
||||
*/
|
||||
class SHA256Context
|
||||
{
|
||||
public:
|
||||
unsigned tot_len;
|
||||
unsigned len;
|
||||
unsigned char block[2 * SHA256_BLOCK_SIZE];
|
||||
uint32 h[8];
|
||||
};
|
||||
|
||||
inline static uint32 SHFR(uint32 x, uint32 n) { return x >> n; }
|
||||
inline static uint32 ROTR(uint32 x, uint32 n) { return (x >> n) | (x << ((sizeof(x) << 3) - n)); }
|
||||
inline static uint32 ROTL(uint32 x, uint32 n) { return (x << n) | (x >> ((sizeof(x) << 3) - n)); }
|
||||
inline static uint32 CH(uint32 x, uint32 y, uint32 z) { return (x & y) ^ (~x & z); }
|
||||
inline static uint32 MAJ(uint32 x, uint32 y, uint32 z) { return (x & y) ^ (x & z) ^ (y & z); }
|
||||
|
||||
inline static uint32 SHA256_F1(uint32 x) { return ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22); }
|
||||
inline static uint32 SHA256_F2(uint32 x) { return ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25); }
|
||||
inline static uint32 SHA256_F3(uint32 x) { return ROTR(x, 7) ^ ROTR(x, 18) ^ SHFR(x, 3); }
|
||||
inline static uint32 SHA256_F4(uint32 x) { return ROTR(x, 17) ^ ROTR(x, 19) ^ SHFR(x, 10); }
|
||||
|
||||
inline static void UNPACK32(unsigned x, unsigned char *str)
|
||||
{
|
||||
str[3] = static_cast<uint8>(x);
|
||||
str[2] = static_cast<uint8>(x >> 8);
|
||||
str[1] = static_cast<uint8>(x >> 16);
|
||||
str[0] = static_cast<uint8>(x >> 24);
|
||||
}
|
||||
|
||||
inline static void PACK32(unsigned char *str, uint32 &x)
|
||||
{
|
||||
x = static_cast<uint32>(str[3]) | static_cast<uint32>(str[2]) << 8 | static_cast<uint32>(str[1]) << 16 | static_cast<uint32>(str[0]) << 24;
|
||||
}
|
||||
|
||||
/* Macros used for loops unrolling */
|
||||
|
||||
inline static void SHA256_SCR(uint32 w[64], int i)
|
||||
{
|
||||
w[i] = SHA256_F4(w[i - 2]) + w[i - 7] + SHA256_F3(w[i - 15]) + w[i - 16];
|
||||
}
|
||||
|
||||
uint32 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 ESHA256 : public Module
|
||||
{
|
||||
unsigned iv[8];
|
||||
bool use_iv;
|
||||
|
||||
/* initializes the IV with a new random value */
|
||||
void NewRandomIV()
|
||||
{
|
||||
for (int i = 0; i < 8; ++i)
|
||||
iv[i] = getrandom32();
|
||||
}
|
||||
|
||||
/* returns the IV as base64-encrypted string */
|
||||
Anope::string GetIVString()
|
||||
{
|
||||
char buf[33];
|
||||
for (int i = 0; i < 8; ++i)
|
||||
UNPACK32(iv[i], reinterpret_cast<unsigned char *>(&buf[i << 2]));
|
||||
buf[32] = '\0';
|
||||
return Anope::Hex(buf, 32);
|
||||
}
|
||||
|
||||
/* splits the appended IV from the password string so it can be used for the next encryption */
|
||||
/* password format: <hashmethod>:<password_b64>:<iv_b64> */
|
||||
void GetIVFromPass(const Anope::string &password)
|
||||
{
|
||||
size_t pos = password.find(':');
|
||||
Anope::string buf = password.substr(password.find(':', pos + 1) + 1, password.length());
|
||||
char buf2[33];
|
||||
Anope::Unhex(buf, buf2);
|
||||
for (int i = 0 ; i < 8; ++i)
|
||||
PACK32(reinterpret_cast<unsigned char *>(&buf2[i << 2]), iv[i]);
|
||||
}
|
||||
|
||||
void SHA256Init(SHA256Context *ctx)
|
||||
{
|
||||
for (int i = 0; i < 8; ++i)
|
||||
ctx->h[i] = iv[i];
|
||||
ctx->len = 0;
|
||||
ctx->tot_len = 0;
|
||||
}
|
||||
|
||||
void SHA256Transform(SHA256Context *ctx, unsigned char *message, unsigned block_nb)
|
||||
{
|
||||
uint32 w[64], wv[8];
|
||||
unsigned char *sub_block;
|
||||
for (unsigned 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(w, j);
|
||||
for (j = 0; j < 8; ++j)
|
||||
wv[j] = ctx->h[j];
|
||||
for (j = 0; j < 64; ++j)
|
||||
{
|
||||
uint32 t1 = wv[7] + SHA256_F2(wv[4]) + CH(wv[4], wv[5], wv[6]) + sha256_k[j] + w[j];
|
||||
uint32 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(SHA256Context *ctx, const unsigned char *message, unsigned len)
|
||||
{
|
||||
/*
|
||||
* XXX here be dragons!
|
||||
* After many hours of pouring over this, I think I've found the problem.
|
||||
* When Special created our module from the reference one, he used:
|
||||
*
|
||||
* unsigned rem_len = SHA256_BLOCK_SIZE - ctx->len;
|
||||
*
|
||||
* instead of the reference's version of:
|
||||
*
|
||||
* unsigned tmp_len = SHA256_BLOCK_SIZE - ctx->len;
|
||||
* unsigned rem_len = len < tmp_len ? len : tmp_len;
|
||||
*
|
||||
* I've changed back to the reference version of this code, and it seems to work with no errors.
|
||||
* So I'm inclined to believe this was the problem..
|
||||
* -- w00t (January 06, 2008)
|
||||
*/
|
||||
unsigned tmp_len = SHA256_BLOCK_SIZE - ctx->len, rem_len = len < tmp_len ? len : tmp_len;
|
||||
|
||||
memcpy(&ctx->block[ctx->len], message, rem_len);
|
||||
if (ctx->len + len < SHA256_BLOCK_SIZE)
|
||||
{
|
||||
ctx->len += len;
|
||||
return;
|
||||
}
|
||||
unsigned new_len = len - rem_len, block_nb = new_len / SHA256_BLOCK_SIZE;
|
||||
unsigned char *shifted_message = new unsigned char[len - rem_len];
|
||||
memcpy(shifted_message, message + rem_len, len - 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);
|
||||
delete [] shifted_message;
|
||||
ctx->len = rem_len;
|
||||
ctx->tot_len += (block_nb + 1) << 6;
|
||||
}
|
||||
|
||||
void SHA256Final(SHA256Context *ctx, unsigned char *digest)
|
||||
{
|
||||
unsigned block_nb = 1 + ((SHA256_BLOCK_SIZE - 9) < (ctx->len % SHA256_BLOCK_SIZE));
|
||||
unsigned len_b = (ctx->tot_len + ctx->len) << 3;
|
||||
unsigned 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]);
|
||||
}
|
||||
|
||||
/********** ANOPE ******/
|
||||
public:
|
||||
ESHA256(const Anope::string &modname, const Anope::string &creator) : Module(modname, creator, ENCRYPTION)
|
||||
{
|
||||
this->SetAuthor("Anope");
|
||||
|
||||
Implementation i[] = { I_OnEncrypt, I_OnCheckAuthentication };
|
||||
ModuleManager::Attach(i, this, sizeof(i) / sizeof(Implementation));
|
||||
|
||||
use_iv = false;
|
||||
}
|
||||
|
||||
EventReturn OnEncrypt(const Anope::string &src, Anope::string &dest)
|
||||
{
|
||||
char digest[SHA256_DIGEST_SIZE + 1];
|
||||
SHA256Context ctx;
|
||||
std::stringstream buf;
|
||||
|
||||
if (!use_iv)
|
||||
NewRandomIV();
|
||||
else
|
||||
use_iv = false;
|
||||
|
||||
SHA256Init(&ctx);
|
||||
SHA256Update(&ctx, reinterpret_cast<const unsigned char *>(src.c_str()), src.length());
|
||||
SHA256Final(&ctx, reinterpret_cast<unsigned char *>(digest));
|
||||
digest[SHA256_DIGEST_SIZE] = '\0';
|
||||
buf << "sha256:" << Anope::Hex(digest, SHA256_DIGEST_SIZE) << ":" << GetIVString();
|
||||
Log(LOG_DEBUG_2) << "(enc_sha256) hashed password from [" << src << "] to [" << buf.str() << " ]";
|
||||
dest = buf.str();
|
||||
return EVENT_ALLOW;
|
||||
}
|
||||
|
||||
EventReturn OnCheckAuthentication(Command *c, CommandSource *source, const std::vector<Anope::string> ¶ms, const Anope::string &account, const Anope::string &password)
|
||||
{
|
||||
NickAlias *na = findnick(account);
|
||||
NickCore *nc = na ? na->nc : NULL;
|
||||
if (na == NULL)
|
||||
return EVENT_CONTINUE;
|
||||
|
||||
size_t pos = nc->pass.find(':');
|
||||
if (pos == Anope::string::npos)
|
||||
return EVENT_CONTINUE;
|
||||
Anope::string hash_method(nc->pass.begin(), nc->pass.begin() + pos);
|
||||
if (!hash_method.equals_cs("sha256"))
|
||||
return EVENT_CONTINUE;
|
||||
|
||||
GetIVFromPass(nc->pass);
|
||||
use_iv = true;
|
||||
Anope::string buf;
|
||||
this->OnEncrypt(password, buf);
|
||||
|
||||
if (nc->pass.equals_cs(buf))
|
||||
{
|
||||
/* if we are NOT the first module in the list,
|
||||
* we want to re-encrypt the pass with the new encryption
|
||||
*/
|
||||
if (ModuleManager::FindFirstOf(ENCRYPTION) != this)
|
||||
enc_encrypt(password, nc->pass);
|
||||
return EVENT_ALLOW;
|
||||
}
|
||||
|
||||
return EVENT_CONTINUE;
|
||||
}
|
||||
};
|
||||
|
||||
MODULE_INIT(ESHA256)
|
||||
Reference in New Issue
Block a user