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"

5 files changed, 1364 insertions, 0 deletions

diff --git a/modules/encryption/enc_md5.cpp b/modules/encryption/enc_md5.cpp
new file mode 100644
index 000000000..109f31dfc
--- /dev/null
+++ b/modules/encryption/enc_md5.cpp
@@ -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> &params, 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)
diff --git a/modules/encryption/enc_none.cpp b/modules/encryption/enc_none.cpp
new file mode 100644
index 000000000..180b431c2
--- /dev/null
+++ b/modules/encryption/enc_none.cpp
@@ -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> &params, 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)
diff --git a/modules/encryption/enc_old.cpp b/modules/encryption/enc_old.cpp
new file mode 100644
index 000000000..e68887c49
--- /dev/null
+++ b/modules/encryption/enc_old.cpp
@@ -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> &params, 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)
diff --git a/modules/encryption/enc_sha1.cpp b/modules/encryption/enc_sha1.cpp
new file mode 100644
index 000000000..4fe321bdc
--- /dev/null
+++ b/modules/encryption/enc_sha1.cpp
@@ -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);