The next of a few "CBX OCDing over code style" commits, focusing on src/core/enc_*, plus fixing unintentional broken logic in said modules caused by my first OCD commit.

Also added a note to example.conf about enc_sha1 being potentially broken, and slight code style OCD in hashcomp.cpp found by Adam.

6 files changed, 553 insertions, 631 deletions

diff --git a/src/core/enc_md5.cpp b/src/core/enc_md5.cpp
index 5ec245a7b..87daea319 100644
--- a/src/core/enc_md5.cpp
+++ b/src/core/enc_md5.cpp
@@ -13,7 +13,6 @@
 
 #include "module.h"
 
-
 /*************************************************************************/
 
 /* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
@@ -38,292 +37,279 @@ These notices must be retained in any copies of any part of this
 documentation and/or software.
  */
 
-#include <string.h>
-
-typedef unsigned int UINT4;
-
 /* MD5 context. */
-typedef struct {
-  UINT4 state[4];								   /* state (ABCD) */
-  UINT4 count[2];		/* number of bits, modulo 2^64 (lsb first) */
-  unsigned char buffer[64];						 /* input buffer */
-} MD5_CTX;
+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
  */
 
-typedef void *POINTER;
-
 /* Constants for MD5Transform routine.
  */
-#define S11 7
-#define S12 12
-#define S13 17
-#define S14 22
-#define S21 5
-#define S22 9
-#define S23 14
-#define S24 20
-#define S31 4
-#define S32 11
-#define S33 16
-#define S34 23
-#define S41 6
-#define S42 10
-#define S43 15
-#define S44 21
-
-void MD5Transform (UINT4 [4], unsigned char [64]);
-void Encode (unsigned char *, UINT4 *, unsigned int);
-void Decode (UINT4 *, unsigned char *, unsigned int);
+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
+	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.
  */
-#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
-#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
-#define H(x, y, z) ((x) ^ (y) ^ (z))
-#define I(x, y, z) ((y) ^ ((x) | (~z)))
+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.
  */
-#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
+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.
+ * Rotation is separate from addition to prevent recomputation.
  */
-#define FF(a, b, c, d, x, s, ac) { \
- (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
- (a) = ROTATE_LEFT ((a), (s)); \
- (a) += (b); \
-  }
-#define GG(a, b, c, d, x, s, ac) { \
- (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
- (a) = ROTATE_LEFT ((a), (s)); \
- (a) += (b); \
-  }
-#define HH(a, b, c, d, x, s, ac) { \
- (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
- (a) = ROTATE_LEFT ((a), (s)); \
- (a) += (b); \
-  }
-#define II(a, b, c, d, x, s, ac) { \
- (a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
- (a) = ROTATE_LEFT ((a), (s)); \
- (a) += (b); \
-  }
+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;
+	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.
+ * operation, processing another message block, and updating the
+ * context.
  */
-void MD5Update(MD5_CTX *context, unsigned char *input, unsigned int inputLen)
+void MD5Update(MD5_CTX *context, const unsigned char *input, unsigned inputLen)
 {
-  unsigned int i, index, partLen;
-
-  /* Compute number of bytes mod 64 */
-  index = (unsigned int)((context->count[0] >> 3) & 0x3F);
-
-  /* Update number of bits */
-  if ((context->count[0] += ((UINT4)inputLen << 3))
-   < ((UINT4)inputLen << 3))
- context->count[1]++;
-  context->count[1] += ((UINT4)inputLen >> 29);
-
-  partLen = 64 - index;
-
-  /* Transform as many times as possible.
-*/
-  if (inputLen >= partLen) {
- memcpy
-   ((POINTER)&context->buffer[index], (POINTER)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
- ((POINTER)&context->buffer[index], (POINTER)&input[i],
-  inputLen-i);
+	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.
+ * the message digest and zeroizing the context.
  */
-void MD5Final (unsigned char digest[16], MD5_CTX *context)
+void MD5Final(unsigned char digest[16], MD5_CTX *context)
 {
-  unsigned char bits[8];
-  unsigned int index, padLen;
-
-  /* Save number of bits */
-  Encode (bits, context->count, 8);
-
-  /* Pad out to 56 mod 64.
-*/
-  index = (unsigned int)((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 ((POINTER)context, 0, sizeof (*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 (UINT4 state[4], unsigned char block[64])
+void MD5Transform(unsigned state[4], const unsigned char block[64])
 {
-  UINT4 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 ((POINTER)x, 0, sizeof (x));
+	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 (UINT4) into output (unsigned char). Assumes len is
-  a multiple of 4.
+/* Encodes input (unsigned) into output (unsigned char). Assumes len is
+ * a multiple of 4.
  */
-void Encode (unsigned char *output, UINT4 *input, unsigned int len)
+void Encode(unsigned char *output, unsigned *input, unsigned len)
 {
-  unsigned int i, j;
-
-  for (i = 0, j = 0; j < len; i++, j += 4) {
- output[j] = (unsigned char)(input[i] & 0xff);
- output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
- output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
- output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
-  }
+	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 (UINT4). Assumes len is
-  a multiple of 4.
+/* Decodes input (unsigned char) into output (unsigned). Assumes len is
+ * a multiple of 4.
  */
-void Decode (UINT4 *output, unsigned char *input, unsigned int len)
+void Decode(unsigned *output, const unsigned char *input, unsigned len)
 {
-  unsigned int i, j;
+	unsigned i, j;
 
-  for (i = 0, j = 0; j < len; i++, j += 4)
- output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) |
-   (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
+	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. */
-
-#define XTOI(c) ((c)>9 ? (c)-'A'+10 : (c)-'0')
-
-
-/*************************************************************************/
-
 /* Module stuff. */
 
 class EMD5 : public Module
@@ -335,14 +321,12 @@ class EMD5 : public Module
 		this->SetVersion(VERSION_STRING);
 		this->SetType(ENCRYPTION);
 
-
 		ModuleManager::Attach(I_OnEncrypt, this);
 		ModuleManager::Attach(I_OnEncryptInPlace, this);
 		ModuleManager::Attach(I_OnDecrypt, this);
 		ModuleManager::Attach(I_OnCheckPassword, this);
 	}
 
-
 	EventReturn OnEncrypt(const std::string &src, std::string &dest)
 	{
 		MD5_CTX context;
@@ -351,13 +335,13 @@ class EMD5 : public Module
 		char cpass[1000];
 
 		MD5Init(&context);
-		MD5Update(&context, (unsigned char*)src.c_str(), src.size());
-		MD5Final((unsigned char*)digest, &context);
+		MD5Update(&context, reinterpret_cast<const unsigned char *>(src.c_str()), src.size());
+		MD5Final(reinterpret_cast<unsigned char *>(digest), &context);
 
 		b64_encode(digest, 16, cpass, 1000);
-		buf.append(cpass);
+		buf += cpass;
 		Alog(LOG_DEBUG_2) << "(enc_md5) hashed password from [" << src << "] to [" << buf << "]";
-		dest.assign(buf);
+		dest = buf;
 		delete [] digest;
 		return EVENT_ALLOW;
 	}
@@ -380,15 +364,13 @@ class EMD5 : public Module
 			return EVENT_CONTINUE;
 		std::string buf;
 		this->OnEncrypt(plaintext, buf);
-		if (!password.compare(buf))
+		if (password == buf)
 		{
 			/* if we are NOT the first module in the list,
 			 * we want to re-encrypt the pass with the new encryption
 			 */
-			if (Config.EncModuleList.front() == this->name)
-			{
+			if (Config.EncModuleList.front() != this->name)
 				enc_encrypt(plaintext, password);
-			}
 			return EVENT_ALLOW;
 		}
 		return EVENT_STOP;
diff --git a/src/core/enc_none.cpp b/src/core/enc_none.cpp
index c89db82ae..3cbd93060 100644
--- a/src/core/enc_none.cpp
+++ b/src/core/enc_none.cpp
@@ -29,9 +29,9 @@ class ENone : public Module
 		std::string buf = "plain:";
 		char cpass[1000];
 		b64_encode(src.c_str(), src.size(), cpass, 1000);
-		buf.append(cpass);
+		buf += cpass;
 		Alog(LOG_DEBUG_2) << "(enc_none) hashed password from [" << src << "] to [" << buf << "]";
-		dest.assign(buf);
+		dest = buf;
 		return EVENT_ALLOW;
 	}
 
@@ -44,12 +44,11 @@ class ENone : public Module
 	{
 		if (hashm != "plain")
 			return EVENT_CONTINUE;
-		char cpass[1000];
-		memset(&cpass, 0, sizeof(cpass));
+		char cpass[1000] = "";
 		size_t pos = src.find(":");
-		std::string buf(src.begin()+pos+1, src.end());
+		std::string buf(src.begin() + pos + 1, src.end());
 		b64_decode(buf.c_str(), cpass, 1000);
-		dest.assign(cpass);
+		dest = cpass;
 		return EVENT_ALLOW;
 	}
 
@@ -59,20 +58,17 @@ class ENone : public Module
 			return EVENT_CONTINUE;
 		std::string buf;
 		this->OnEncrypt(plaintext, buf);
-		if(!password.compare(buf))
+		if (password == buf)
 		{
 			/* if we are NOT the first module in the list,
 			 * we want to re-encrypt the pass with the new encryption
 			 */
-			if (Config.EncModuleList.front() == this->name)
-			{
+			if (Config.EncModuleList.front() != this->name)
 				enc_encrypt(plaintext, password);
-			}
 			return EVENT_ALLOW;
 		}
 		return EVENT_STOP;
 	}
-
 };
 
 MODULE_INIT(ENone)
diff --git a/src/core/enc_old.cpp b/src/core/enc_old.cpp
index 307e42316..2e1b57e10 100644
--- a/src/core/enc_old.cpp
+++ b/src/core/enc_old.cpp
@@ -7,15 +7,12 @@
  *
  * 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.
 
@@ -38,44 +35,42 @@ These notices must be retained in any copies of any part of this
 documentation and/or software.
  */
 
-#include <string.h>
-
-typedef unsigned int UINT4;
-
 /* MD5 context. */
-typedef struct {
-	UINT4 state[4];			 /* state (ABCD) */
-	UINT4 count[2];			 /* number of bits, modulo 2^64 (lsb first) */
-	unsigned char buffer[64];   /* input buffer */
-} MD5_CTX;
+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
  */
 
-typedef void *POINTER;
-
 /* Constants for MD5Transform routine.
  */
-#define S11 7
-#define S12 12
-#define S13 17
-#define S14 22
-#define S21 5
-#define S22 9
-#define S23 14
-#define S24 20
-#define S31 4
-#define S32 11
-#define S33 16
-#define S34 23
-#define S41 6
-#define S42 10
-#define S43 15
-#define S44 21
-
-static void MD5Transform(UINT4[4], unsigned char[64]);
-static void Encode(unsigned char *, UINT4 *, unsigned int);
-static void Decode(UINT4 *, unsigned char *, unsigned int);
+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,
@@ -85,38 +80,42 @@ static unsigned char PADDING[64] = {
 
 /* F, G, H and I are basic MD5 functions.
  */
-#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
-#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
-#define H(x, y, z) ((x) ^ (y) ^ (z))
-#define MD5_I(x, y, z) ((y) ^ ((x) | (~z)))
+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.
  */
-#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
+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.
+ * Rotation is separate from addition to prevent recomputation.
  */
-#define FF(a, b, c, d, x, s, ac) { \
- (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
- (a) = ROTATE_LEFT ((a), (s)); \
- (a) += (b); \
-  }
-#define GG(a, b, c, d, x, s, ac) { \
- (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
- (a) = ROTATE_LEFT ((a), (s)); \
- (a) += (b); \
-  }
-#define HH(a, b, c, d, x, s, ac) { \
- (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
- (a) = ROTATE_LEFT ((a), (s)); \
- (a) += (b); \
-  }
-#define II(a, b, c, d, x, s, ac) { \
- (a) += MD5_I ((b), (c), (d)) + (x) + (UINT4)(ac); \
- (a) = ROTATE_LEFT ((a), (s)); \
- (a) += (b); \
-  }
+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.
  */
@@ -132,59 +131,57 @@ static void MD5Init(MD5_CTX *context)
 }
 
 /* MD5 block update operation. Continues an MD5 message-digest
-  operation, processing another message block, and updating the
-  context.
+ * operation, processing another message block, and updating the
+ * context.
  */
-static void MD5Update(MD5_CTX *context, unsigned char *input, unsigned int inputLen)
+static void MD5Update(MD5_CTX *context, const unsigned char *input, unsigned inputLen)
 {
-	unsigned int i, index, partLen;
+	unsigned i, index, partLen;
 
 	/* Compute number of bytes mod 64 */
-	index = (unsigned int) ((context->count[0] >> 3) & 0x3F);
+	index = (context->count[0] >> 3) & 0x3F;
 
 	/* Update number of bits */
-	if ((context->count[0] += ((UINT4) inputLen << 3))
-		< ((UINT4) inputLen << 3))
-		context->count[1]++;
-	context->count[1] += ((UINT4) inputLen >> 29);
+	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
-			((POINTER) & context->buffer[index], (POINTER) input, partLen);
+	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
+	}
+	else
 		i = 0;
 
 	/* Buffer remaining input */
-	memcpy
-		((POINTER) & context->buffer[index], (POINTER) & input[i],
-		 inputLen - i);
+	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.
+ * the message digest and zeroizing the context.
  */
 static void MD5Final(unsigned char digest[16], MD5_CTX *context)
 {
 	unsigned char bits[8];
-	unsigned int index, padLen;
+	unsigned index, padLen;
 
 	/* Save number of bits */
 	Encode(bits, context->count, 8);
 
 	/* Pad out to 56 mod 64.
 	 */
-	index = (unsigned int) ((context->count[0] >> 3) & 0x3f);
-	padLen = (index < 56) ? (56 - index) : (120 - index);
+	index = (context->count[0] >> 3) & 0x3f;
+	padLen = index < 56 ? 56 - index : 120 - index;
 	MD5Update(context, PADDING, padLen);
 
 	/* Append length (before padding) */
@@ -194,88 +191,88 @@ static void MD5Final(unsigned char digest[16], MD5_CTX *context)
 
 	/* Zeroize sensitive information.
 	 */
-	memset((POINTER) context, 0, sizeof(*context));
+	memset(context, 0, sizeof(*context));
 }
 
 /* MD5 basic transformation. Transforms state based on block.
  */
-static void MD5Transform(UINT4 state[4], unsigned char block[64])
+static void MD5Transform(unsigned state[4], const unsigned char block[64])
 {
-	UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
+	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 */
+	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 */
+	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 */
+	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 */
+	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;
@@ -284,45 +281,41 @@ static void MD5Transform(UINT4 state[4], unsigned char block[64])
 
 	/* Zeroize sensitive information.
 	 */
-	memset((POINTER) x, 0, sizeof(x));
+	memset(x, 0, sizeof(x));
 }
 
-/* Encodes input (UINT4) into output (unsigned char). Assumes len is
-  a multiple of 4.
+/* Encodes input (unsigned) into output (unsigned char). Assumes len is
+ * a multiple of 4.
  */
-static void Encode(unsigned char *output, UINT4 *input, unsigned int len)
+static void Encode(unsigned char *output, unsigned *input, unsigned len)
 {
-	unsigned int i, j;
+	unsigned i, j;
 
-	for (i = 0, j = 0; j < len; i++, j += 4) {
-		output[j] = (unsigned char) (input[i] & 0xff);
-		output[j + 1] = (unsigned char) ((input[i] >> 8) & 0xff);
-		output[j + 2] = (unsigned char) ((input[i] >> 16) & 0xff);
-		output[j + 3] = (unsigned char) ((input[i] >> 24) & 0xff);
+	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 (UINT4). Assumes len is
-  a multiple of 4.
+/* Decodes input (unsigned char) into output (unsigned). Assumes len is
+ * a multiple of 4.
  */
-static void Decode(UINT4 *output, unsigned char *input, unsigned int len)
+static void Decode(unsigned *output, const unsigned char *input, unsigned len)
 {
-	unsigned int i, j;
+	unsigned i, j;
 
-	for (i = 0, j = 0; j < len; i++, j += 4)
-		output[i] = ((UINT4) input[j]) | (((UINT4) input[j + 1]) << 8) |
-			(((UINT4) input[j + 2]) << 16) | (((UINT4) input[j + 3]) <<
-											  24);
+	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. ********/
 
-
-#define XTOI(c) ((c)>9 ? (c)-'A'+10 : (c)-'0')
-
-
+inline static char XTOI(char c) { return c > 9 ? c - 'A' + 10 : c - '0'; }
 
 class EOld : public Module
 {
@@ -337,31 +330,27 @@ class EOld : public Module
 		ModuleManager::Attach(I_OnEncryptInPlace, this);
 		ModuleManager::Attach(I_OnDecrypt, this);
 		ModuleManager::Attach(I_OnCheckPassword, this);
-
 	}
 
 	EventReturn OnEncrypt(const std::string &src, std::string &dest)
 	{
-
 		MD5_CTX context;
-		char digest[33], digest2[33];
-		char cpass[1000];
+		char digest[33] = "", digest2[33], cpass[1000];
 		int i;
 		std::string buf = "oldmd5:";
 
 		memset(&context, 0, sizeof(context));
-		memset(&digest, 0, sizeof(digest));
 
 		MD5Init(&context);
-		MD5Update(&context, (unsigned char *)src.c_str(), src.size());
-		MD5Final((unsigned char *)digest, &context);
+		MD5Update(&context, reinterpret_cast<const unsigned char *>(src.c_str()), src.size());
+		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]);
 
 		b64_encode(digest2, 16, cpass, 1000);
-		buf.append(cpass);
+		buf += cpass;
 		Alog(LOG_DEBUG_2) << "(enc_old) hashed password from [" << src << "] to [" << buf << "]";
-		dest.assign(buf);
+		dest = buf;
 		return EVENT_ALLOW;
 	}
 
@@ -383,15 +372,13 @@ class EOld : public Module
 			return EVENT_CONTINUE;
 		std::string buf;
 		this->OnEncrypt(plaintext, buf);
-		if (!password.compare(buf))
+		if (password == buf)
 		{
 			/* if we are NOT the first module in the list,
 			 * we want to re-encrypt the pass with the new encryption
 			 */
-			if (Config.EncModuleList.front() == this->name)
-			{
+			if (Config.EncModuleList.front() != this->name)
 				enc_encrypt(plaintext, password);
-			}
 			return EVENT_ALLOW;
 		}
 		return EVENT_STOP;
diff --git a/src/core/enc_sha1.cpp b/src/core/enc_sha1.cpp
index 82c3f97a1..1668811d7 100644
--- a/src/core/enc_sha1.cpp
+++ b/src/core/enc_sha1.cpp
@@ -13,61 +13,56 @@ A million repetitions of "a"
 */
 
 /* #define LITTLE_ENDIAN * This should be #define'd if true. */
-/* #define SHA1HANDSOFF * Copies data before messing with it. */
 
 #include "module.h"
-#include <stdio.h>
-#include <string.h>
 
-typedef struct {
+struct SHA1_CTX
+{
 	uint32 state[5];
 	uint32 count[2];
 	unsigned char buffer[64];
-} SHA1_CTX;
+};
 
-void SHA1Transform(uint32 state[5], unsigned char const buffer[64]);
-void SHA1Init(SHA1_CTX* context);
-void SHA1Update(SHA1_CTX* context, unsigned char const * data, uint32 len);
-void SHA1Final(unsigned char digest[20], SHA1_CTX* context);
+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);
 
-#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
+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
-#define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
-	|(rol(block->l[i],8)&0x00FF00FF))
+	return block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | (rol(block->l[i], 8) & 0x00FF00FF);
 #else
-#define blk0(i) block->l[i]
+	return block->l[i];
 #endif
-#define blk(i) (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))
+}
+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 */
-#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
-#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
-#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
-#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
-#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
-
+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], unsigned char const buffer[64])
+void SHA1Transform(uint32 state[5], const unsigned char buffer[64])
 {
-uint32 a, b, c, d, e;
-typedef union {
-	unsigned char c[64];
-	uint32 l[16];
-} CHAR64LONG16;
-CHAR64LONG16* block;
-#ifdef SHA1HANDSOFF
-static unsigned char workspace[64];
-	block = (CHAR64LONG16*)workspace;
+	uint32 a, b, c, d, e;
+	static unsigned char workspace[64];
+	CHAR64LONG16 *block = reinterpret_cast<CHAR64LONG16 *>(workspace);
 	memcpy(block, buffer, 64);
-#else
-	block = (CHAR64LONG16*)buffer;
-#endif
 	/* Copy context->state[] to working vars */
 	a = state[0];
 	b = state[1];
@@ -75,26 +70,26 @@ static unsigned char workspace[64];
 	d = state[3];
 	e = state[4];
 	/* 4 rounds of 20 operations each. Loop unrolled. */
-	R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
-	R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
-	R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
-	R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
-	R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
-	R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
-	R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
-	R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
-	R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
-	R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
-	R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
-	R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
-	R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
-	R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
-	R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
-	R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
-	R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
-	R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
-	R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
-	R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
+	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;
@@ -105,10 +100,9 @@ static unsigned char workspace[64];
 	a = b = c = d = e = 0;
 }
 
-
 /* SHA1Init - Initialize new context */
 
-void SHA1Init(SHA1_CTX* context)
+void SHA1Init(SHA1_CTX *context)
 {
 	/* SHA1 initialization constants */
 	context->state[0] = 0x67452301;
@@ -119,58 +113,51 @@ void SHA1Init(SHA1_CTX* context)
 	context->count[0] = context->count[1] = 0;
 }
 
-
 /* Run your data through this. */
 
-void SHA1Update(SHA1_CTX* context, unsigned char const * data, uint32 len)
+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));
+	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) {
+		for (; i + 63 < len; i += 64)
 			SHA1Transform(context->state, &data[i]);
-		}
 		j = 0;
 	}
-	else i = 0;
-		memcpy(&context->buffer[j], &data[i], len - i);
+	else
+		i = 0;
+	memcpy(&context->buffer[j], &data[i], len - i);
 }
 
-
 /* Add padding and return the message digest. */
 
-void SHA1Final(unsigned char digest[20], SHA1_CTX* context)
+void SHA1Final(unsigned char digest[20], SHA1_CTX *context)
 {
 	uint32 i;
 	unsigned char finalcount[8];
 
-	for (i = 0; i < 8; i++) {
-		finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)]
-		 >> ((3-(i & 3)) * 8) ) & 255);  /* Endian independent */
-	}
-	SHA1Update(context, (unsigned char *)"\200", 1);
-	while ((context->count[0] & 504) != 448) {
-		SHA1Update(context, (unsigned char *)"\0", 1);
-	}
-	SHA1Update(context, finalcount, 8);  /* Should cause a SHA1Transform() */
-	for (i = 0; i < 20; i++) {
-		digest[i] = (unsigned char)
-		 ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
-	}
+	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);
-#ifdef SHA1HANDSOFF  /* make SHA1Transform overwrite it's own static vars */
 	SHA1Transform(context->state, context->buffer);
-#endif
 }
 
 /*****************************************************************************/
@@ -192,10 +179,8 @@ class ESHA1 : public Module
 		ModuleManager::Attach(I_OnEncryptCheckLen, this);
 		ModuleManager::Attach(I_OnDecrypt, this);
 		ModuleManager::Attach(I_OnCheckPassword, this);
-
 	}
 
-
 	EventReturn OnEncrypt(const std::string &src, std::string &dest)
 	{
 		SHA1_CTX context;
@@ -203,21 +188,20 @@ class ESHA1 : public Module
 		std::string buf = "sha1:";
 		char cpass[1000];
 
-		memset(digest,0,32);
+		memset(digest, 0, 32);
 
 		SHA1Init(&context);
-		SHA1Update(&context, (unsigned char *)src.c_str(), src.size());
-		SHA1Final((unsigned char *)digest, &context);
+		SHA1Update(&context, reinterpret_cast<const unsigned char *>(src.c_str()), src.size());
+		SHA1Final(reinterpret_cast<unsigned char *>(digest), &context);
 
 		b64_encode(digest, 20, cpass, 1000);
-		buf.append(cpass);
+		buf += cpass;
 		Alog(LOG_DEBUG_2) << "(enc_sha1) hashed password from [" << src << "] to [" << buf << "]";
-		dest.assign(buf);
+		dest = buf;
 		delete [] digest;
 		return EVENT_ALLOW;
 	}
 
-
 	EventReturn OnEncryptInPlace(std::string &buf)
 	{
 		return this->OnEncrypt(buf, buf);
@@ -230,28 +214,23 @@ class ESHA1 : public Module
 		return EVENT_STOP;
 	}
 
-
 	EventReturn OnCheckPassword(const std::string &hashm, std::string &plaintext, std::string &password)
 	{
 		if (hashm != "sha1")
 			return EVENT_CONTINUE;
 		std::string buf;
 		this->OnEncrypt(plaintext, buf);
-		if (!password.compare(buf))
+		if (password == buf)
 		{
 			/* when we are NOT the first module in the list,
 			 * we want to re-encrypt the pass with the new encryption
 			 */
-			if (Config.EncModuleList.front() == this->name)
-			{
+			if (Config.EncModuleList.front() != this->name)
 				enc_encrypt(plaintext, password);
-			}
 			return EVENT_ALLOW;
 		}
 		return EVENT_STOP;
 	}
-
 };
 
-
 MODULE_INIT(ESHA1)
diff --git a/src/core/enc_sha256.cpp b/src/core/enc_sha256.cpp
index 7d29b43d2..f47aa6a4d 100644
--- a/src/core/enc_sha256.cpp
+++ b/src/core/enc_sha256.cpp
@@ -52,63 +52,54 @@
  * SUCH DAMAGE.
  */
 
-
 #include "module.h"
 
-#define SHA256_DIGEST_SIZE (256 / 8)
-#define SHA256_BLOCK_SIZE  (512 / 8)
-
-#ifndef HAS_STDINT
-typedef unsigned int uint32_t;
-#endif
+static const unsigned SHA256_DIGEST_SIZE = 256 / 8;
+static const unsigned SHA256_BLOCK_SIZE = 512 / 8;
 
 /** An sha256 context
  */
 class SHA256Context
 {
  public:
-	unsigned int tot_len;
-	unsigned int len;
+	unsigned tot_len;
+	unsigned len;
 	unsigned char block[2 * SHA256_BLOCK_SIZE];
-	uint32_t h[8];
+	uint32 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) ((x)      );      \
-	*((str) + 2) = (uint8) ((x) >>  8);      \
-	*((str) + 1) = (uint8) ((x) >> 16);      \
-	*((str) + 0) = (uint8) ((x) >> 24);      \
+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);
 }
 
-#define PACK32(str, x)			 \
-{					      \
-	*(x) = ((uint32_t) *((str) + 3)      )     \
-	| ((uint32_t) *((str) + 2) <<  8)     \
-	| ((uint32_t) *((str) + 1) << 16)     \
-	| ((uint32_t) *((str) + 0) << 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 */
 
-#define SHA256_SCR(i)			  \
-{					      \
-	w[i] =  SHA256_F4(w[i - 2]) + w[i - 7]     \
-	+ SHA256_F3(w[i - 15]) + w[i - 16];  \
+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_t sha256_k[64] =
+uint32 sha256_k[64] =
 {
 	0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
 	0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
@@ -130,17 +121,14 @@ uint32_t sha256_k[64] =
 
 class ESHA256 : public Module
 {
-	unsigned int iv[8];
+	unsigned iv[8];
 	bool use_iv;
 
 	/* initializes the IV with a new random value */
 	void NewRandomIV()
 	{
-		srand(time(NULL));
-		for (int i = 0; i < 8; i++)
-		{
+		for (int i = 0; i < 8; ++i)
 			iv[i] = getrandom32();
-		}
 	}
 
 	/* returns the IV as base64-encrypted string */
@@ -148,11 +136,9 @@ class ESHA256 : public Module
 	{
 		unsigned char buf[33];
 		char buf2[512];
-		for (int i = 0; i < 8; i++)
-		{
+		for (int i = 0; i < 8; ++i)
 			UNPACK32(iv[i], &buf[i << 2]);
-		}
-		b64_encode(reinterpret_cast<char*>(buf), 32, buf2, 512);
+		b64_encode(reinterpret_cast<char *>(buf), 32, buf2, 512);
 		return buf2;
 	}
 
@@ -160,45 +146,41 @@ class ESHA256 : public Module
 	/* password format:  <hashmethod>:<password_b64>:<iv_b64> */
 	void GetIVFromPass(std::string &password)
 	{
-		size_t pos;
-		pos = password.find(":");
-		std::string buf(password, password.find(":", pos+1)+1, password.size());
+		size_t pos = password.find(":");
+		std::string buf(password, password.find(":", pos + 1) + 1, password.size());
 		unsigned char buf2[33];
-		b64_decode(buf.c_str(), reinterpret_cast<char*>(buf2), 33);
-		for (int i = 0 ; i < 8; i++)
-		{
-			PACK32(&buf2[i<<2], &iv[i]);
-		}
+		b64_decode(buf.c_str(), reinterpret_cast<char *>(buf2), 33);
+		for (int i = 0 ; i < 8; ++i)
+			PACK32(&buf2[i<<2], iv[i]);
 	}
 
 	void SHA256Init(SHA256Context *ctx)
 	{
-		for (int i = 0; i < 8; i++)
+		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 int block_nb)
+	void SHA256Transform(SHA256Context *ctx, unsigned char *message, unsigned block_nb)
 	{
-		uint32_t w[64];
-		uint32_t wv[8];
+		uint32 w[64], wv[8];
 		unsigned char *sub_block;
-		for (unsigned int i = 1; i <= block_nb; i++)
+		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(j);
-			for (j = 0; j < 8; j++)
+			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++)
+			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]);
+				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];
@@ -208,32 +190,30 @@ class ESHA256 : public Module
 				wv[1] = wv[0];
 				wv[0] = t1 + t2;
 			}
-			for (j = 0; j < 8; j++)
+			for (j = 0; j < 8; ++j)
 				ctx->h[j] += wv[j];
 		}
 	}
 
-	void SHA256Update(SHA256Context *ctx, unsigned char *message, unsigned int len)
+	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 int rem_len = SHA256_BLOCK_SIZE - ctx->len;
+		 *     unsigned rem_len = SHA256_BLOCK_SIZE - ctx->len;
 		 *
 		 * instead of the reference's version of:
 		 *
-		 *     unsigned int tmp_len = SHA256_BLOCK_SIZE - ctx->len;
-		 *     unsigned int rem_len = len < tmp_len ? len : tmp_len;
+		 *     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 int tmp_len = SHA256_BLOCK_SIZE - ctx->len;
-		unsigned int rem_len = len < tmp_len ? len : tmp_len;
-
+		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)
@@ -241,27 +221,28 @@ class ESHA256 : public Module
 			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;
+		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);
+		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 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;
+		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++)
+		for (int i = 0 ; i < 8; ++i)
 			UNPACK32(ctx->h[i], &digest[i << 2]);
 	}
 
@@ -294,15 +275,14 @@ class ESHA256 : public Module
 			use_iv = false;
 
 		SHA256Init(&ctx);
-		SHA256Update(&ctx, (unsigned char *)src.c_str(), src.size());
-		SHA256Final(&ctx, (unsigned char*)digest);
+		SHA256Update(&ctx, reinterpret_cast<const unsigned char *>(src.c_str()), src.size());
+		SHA256Final(&ctx, reinterpret_cast<unsigned char *>(digest));
 
 		b64_encode(digest, SHA256_DIGEST_SIZE, cpass, 1000);
 		buf << "sha256:" << cpass << ":" << GetIVString();
 		Alog(LOG_DEBUG_2) << "(enc_sha256) hashed password from [" << src << "] to [" << buf.str() << " ]";
-		dest.assign(buf.str());
+		dest = buf.str();
 		return EVENT_ALLOW;
-
 	}
 
 	EventReturn OnEncryptInPlace(std::string &buf)
@@ -327,15 +307,13 @@ class ESHA256 : public Module
 		use_iv = true;
 		this->OnEncrypt(plaintext, buf);
 
-		if(!password.compare(buf))
+		if (password == buf)
 		{
 			/* if we are NOT the first module in the list,
 			 * we want to re-encrypt the pass with the new encryption
 			 */
-			if (Config.EncModuleList.front() == this->name)
-			{
+			if (Config.EncModuleList.front() != this->name)
 				enc_encrypt(plaintext, password );
-			}
 			return EVENT_ALLOW;
 		}
 		return EVENT_STOP;
diff --git a/src/hashcomp.cpp b/src/hashcomp.cpp
index 3afef7b46..f8a03c5f8 100644
--- a/src/hashcomp.cpp
+++ b/src/hashcomp.cpp
@@ -171,7 +171,7 @@ size_t hash_compare_std_string::operator()(const std::string &s) const
 {
 	register size_t t = 0;
 
-	for (std::string::const_iterator it = s.begin(); it != s.end(); ++it)
+	for (std::string::const_iterator it = s.begin(), it_end = s.end(); it != it_end; ++it)
 		t = 5 * t + static_cast<const unsigned char>(*it);
 
 	return t;
@@ -185,7 +185,7 @@ size_t hash_compare_ci_string::operator()(const ci::string &s) const
 {
 	register size_t t = 0;
 
-	for (ci::string::const_iterator it = s.begin(); it != s.end(); ++it)
+	for (ci::string::const_iterator it = s.begin(), it_end = s.end(); it != it_end; ++it)
 		t = 5 * t + ascii_case_insensitive_map[static_cast<const unsigned char>(*it)];
 
 	return t;
@@ -199,7 +199,7 @@ size_t hash_compare_irc_string::operator()(const irc::string &s) const
 {
 	register size_t t = 0;
 
-	for (irc::string::const_iterator it = s.begin(); it != s.end(); ++it)
+	for (irc::string::const_iterator it = s.begin(), it_end = s.end(); it != it_end; ++it)
 		t = 5 * t + rfc_case_insensitive_map[static_cast<const unsigned char>(*it)];
 
 	return t;