changeset 31662:a1a0936d10c3

Fixed indentation, forgot to do so on my first commit. Added additional info from cipher.c to the file header
author Gary Kramlich <grim@reaperworld.com>
date Mon, 14 Feb 2011 05:55:02 +0000
parents 64587c6084e3
children 04ead332691f
files libpurple/ciphers/md4.c
diffstat 1 files changed, 158 insertions(+), 152 deletions(-) [+]
line wrap: on
line diff
--- a/libpurple/ciphers/md4.c	Mon Feb 14 05:48:59 2011 +0000
+++ b/libpurple/ciphers/md4.c	Mon Feb 14 05:55:02 2011 +0000
@@ -13,6 +13,12 @@
  * originally based on the public domain implementation written
  * by Colin Plumb in 1993.
  *
+ * Copyright (c) Andrew Tridgell 1997-1998.
+ * Modified by Steve French (sfrench@us.ibm.com) 2002
+ * Copyright (c) Cryptoapi developers.
+ * Copyright (c) 2002 David S. Miller (davem@redhat.com)
+ * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
@@ -36,30 +42,30 @@
 #define MD4_HASH_WORDS      4
 
 struct MD4_Context {
-    guint32 hash[MD4_HASH_WORDS];
-    guint32 block[MD4_BLOCK_WORDS];
-    guint64 byte_count;
+	guint32 hash[MD4_HASH_WORDS];
+	guint32 block[MD4_BLOCK_WORDS];
+	guint64 byte_count;
 };
 
 static inline guint32 lshift(guint32 x, unsigned int s)
 {
-    x &= 0xFFFFFFFF;
-    return ((x << s) & 0xFFFFFFFF) | (x >> (32 - s));
+	x &= 0xFFFFFFFF;
+	return ((x << s) & 0xFFFFFFFF) | (x >> (32 - s));
 }
 
 static inline guint32 F(guint32 x, guint32 y, guint32 z)
 {
-    return (x & y) | ((~x) & z);
+	return (x & y) | ((~x) & z);
 }
 
 static inline guint32 G(guint32 x, guint32 y, guint32 z)
 {
-    return (x & y) | (x & z) | (y & z);
+	return (x & y) | (x & z) | (y & z);
 }
 
 static inline guint32 H(guint32 x, guint32 y, guint32 z)
 {
-    return x ^ y ^ z;
+	return x ^ y ^ z;
 }
 
 #define ROUND1(a,b,c,d,k,s) (a = lshift(a + F(b,c,d) + k, s))
@@ -68,209 +74,209 @@
 
 static inline void le32_to_cpu_array(guint32 *buf, unsigned int words)
 {
-    while (words--) {
-        *buf=GUINT_FROM_LE(*buf);
-        buf++;
-    }
+	while (words--) {
+		*buf=GUINT_FROM_LE(*buf);
+		buf++;
+	}
 }
 
 static inline void cpu_to_le32_array(guint32 *buf, unsigned int words)
 {
-    while (words--) {
-        *buf=GUINT_TO_LE(*buf);
-        buf++;
-    }
+	while (words--) {
+		*buf=GUINT_TO_LE(*buf);
+		buf++;
+	}
 }
 
 static void md4_transform(guint32 *hash, guint32 const *in)
 {
-    guint32 a, b, c, d;
+	guint32 a, b, c, d;
 
-    a = hash[0];
-    b = hash[1];
-    c = hash[2];
-    d = hash[3];
+	a = hash[0];
+	b = hash[1];
+	c = hash[2];
+	d = hash[3];
 
-    ROUND1(a, b, c, d, in[0], 3);
-    ROUND1(d, a, b, c, in[1], 7);
-    ROUND1(c, d, a, b, in[2], 11);
-    ROUND1(b, c, d, a, in[3], 19);
-    ROUND1(a, b, c, d, in[4], 3);
-    ROUND1(d, a, b, c, in[5], 7);
-    ROUND1(c, d, a, b, in[6], 11);
-    ROUND1(b, c, d, a, in[7], 19);
-    ROUND1(a, b, c, d, in[8], 3);
-    ROUND1(d, a, b, c, in[9], 7);
-    ROUND1(c, d, a, b, in[10], 11);
-    ROUND1(b, c, d, a, in[11], 19);
-    ROUND1(a, b, c, d, in[12], 3);
-    ROUND1(d, a, b, c, in[13], 7);
-    ROUND1(c, d, a, b, in[14], 11);
-    ROUND1(b, c, d, a, in[15], 19);
+	ROUND1(a, b, c, d, in[0], 3);
+	ROUND1(d, a, b, c, in[1], 7);
+	ROUND1(c, d, a, b, in[2], 11);
+	ROUND1(b, c, d, a, in[3], 19);
+	ROUND1(a, b, c, d, in[4], 3);
+	ROUND1(d, a, b, c, in[5], 7);
+	ROUND1(c, d, a, b, in[6], 11);
+	ROUND1(b, c, d, a, in[7], 19);
+	ROUND1(a, b, c, d, in[8], 3);
+	ROUND1(d, a, b, c, in[9], 7);
+	ROUND1(c, d, a, b, in[10], 11);
+	ROUND1(b, c, d, a, in[11], 19);
+	ROUND1(a, b, c, d, in[12], 3);
+	ROUND1(d, a, b, c, in[13], 7);
+	ROUND1(c, d, a, b, in[14], 11);
+	ROUND1(b, c, d, a, in[15], 19);
 
-    ROUND2(a, b, c, d,in[ 0], 3);
-    ROUND2(d, a, b, c, in[4], 5);
-    ROUND2(c, d, a, b, in[8], 9);
-    ROUND2(b, c, d, a, in[12], 13);
-    ROUND2(a, b, c, d, in[1], 3);
-    ROUND2(d, a, b, c, in[5], 5);
-    ROUND2(c, d, a, b, in[9], 9);
-    ROUND2(b, c, d, a, in[13], 13);
-    ROUND2(a, b, c, d, in[2], 3);
-    ROUND2(d, a, b, c, in[6], 5);
-    ROUND2(c, d, a, b, in[10], 9);
-    ROUND2(b, c, d, a, in[14], 13);
-    ROUND2(a, b, c, d, in[3], 3);
-    ROUND2(d, a, b, c, in[7], 5);
-    ROUND2(c, d, a, b, in[11], 9);
-    ROUND2(b, c, d, a, in[15], 13);
+	ROUND2(a, b, c, d,in[ 0], 3);
+	ROUND2(d, a, b, c, in[4], 5);
+	ROUND2(c, d, a, b, in[8], 9);
+	ROUND2(b, c, d, a, in[12], 13);
+	ROUND2(a, b, c, d, in[1], 3);
+	ROUND2(d, a, b, c, in[5], 5);
+	ROUND2(c, d, a, b, in[9], 9);
+	ROUND2(b, c, d, a, in[13], 13);
+	ROUND2(a, b, c, d, in[2], 3);
+	ROUND2(d, a, b, c, in[6], 5);
+	ROUND2(c, d, a, b, in[10], 9);
+	ROUND2(b, c, d, a, in[14], 13);
+	ROUND2(a, b, c, d, in[3], 3);
+	ROUND2(d, a, b, c, in[7], 5);
+	ROUND2(c, d, a, b, in[11], 9);
+	ROUND2(b, c, d, a, in[15], 13);
 
-    ROUND3(a, b, c, d,in[ 0], 3);
-    ROUND3(d, a, b, c, in[8], 9);
-    ROUND3(c, d, a, b, in[4], 11);
-    ROUND3(b, c, d, a, in[12], 15);
-    ROUND3(a, b, c, d, in[2], 3);
-    ROUND3(d, a, b, c, in[10], 9);
-    ROUND3(c, d, a, b, in[6], 11);
-    ROUND3(b, c, d, a, in[14], 15);
-    ROUND3(a, b, c, d, in[1], 3);
-    ROUND3(d, a, b, c, in[9], 9);
-    ROUND3(c, d, a, b, in[5], 11);
-    ROUND3(b, c, d, a, in[13], 15);
-    ROUND3(a, b, c, d, in[3], 3);
-    ROUND3(d, a, b, c, in[11], 9);
-    ROUND3(c, d, a, b, in[7], 11);
-    ROUND3(b, c, d, a, in[15], 15);
+	ROUND3(a, b, c, d,in[ 0], 3);
+	ROUND3(d, a, b, c, in[8], 9);
+	ROUND3(c, d, a, b, in[4], 11);
+	ROUND3(b, c, d, a, in[12], 15);
+	ROUND3(a, b, c, d, in[2], 3);
+	ROUND3(d, a, b, c, in[10], 9);
+	ROUND3(c, d, a, b, in[6], 11);
+	ROUND3(b, c, d, a, in[14], 15);
+	ROUND3(a, b, c, d, in[1], 3);
+	ROUND3(d, a, b, c, in[9], 9);
+	ROUND3(c, d, a, b, in[5], 11);
+	ROUND3(b, c, d, a, in[13], 15);
+	ROUND3(a, b, c, d, in[3], 3);
+	ROUND3(d, a, b, c, in[11], 9);
+	ROUND3(c, d, a, b, in[7], 11);
+	ROUND3(b, c, d, a, in[15], 15);
 
-    hash[0] += a;
-    hash[1] += b;
-    hash[2] += c;
-    hash[3] += d;
+	hash[0] += a;
+	hash[1] += b;
+	hash[2] += c;
+	hash[3] += d;
 }
 
 static inline void md4_transform_helper(struct MD4_Context *ctx)
 {
-    le32_to_cpu_array(ctx->block, sizeof(ctx->block) / sizeof(guint32));
-    md4_transform(ctx->hash, ctx->block);
+	le32_to_cpu_array(ctx->block, sizeof(ctx->block) / sizeof(guint32));
+	md4_transform(ctx->hash, ctx->block);
 }
 
 static void
 md4_init(PurpleCipherContext *context, gpointer extra) {
-    struct MD4_Context *mctx;
-    mctx = g_new0(struct MD4_Context, 1);
-    purple_cipher_context_set_data(context, mctx);
-    purple_cipher_context_reset(context, extra);
+	struct MD4_Context *mctx;
+	mctx = g_new0(struct MD4_Context, 1);
+	purple_cipher_context_set_data(context, mctx);
+	purple_cipher_context_reset(context, extra);
 
-    mctx->hash[0] = 0x67452301;
-    mctx->hash[1] = 0xefcdab89;
-    mctx->hash[2] = 0x98badcfe;
-    mctx->hash[3] = 0x10325476;
-    mctx->byte_count = 0;
+	mctx->hash[0] = 0x67452301;
+	mctx->hash[1] = 0xefcdab89;
+	mctx->hash[2] = 0x98badcfe;
+	mctx->hash[3] = 0x10325476;
+	mctx->byte_count = 0;
 }
 
 static void
 md4_reset(PurpleCipherContext *context, gpointer extra) {
-    struct MD4_Context *mctx;
+	struct MD4_Context *mctx;
 
-    mctx = purple_cipher_context_get_data(context);
+	mctx = purple_cipher_context_get_data(context);
 
-    mctx->hash[0] = 0x67452301;
-    mctx->hash[1] = 0xefcdab89;
-    mctx->hash[2] = 0x98badcfe;
-    mctx->hash[3] = 0x10325476;
-    mctx->byte_count = 0;
+	mctx->hash[0] = 0x67452301;
+	mctx->hash[1] = 0xefcdab89;
+	mctx->hash[2] = 0x98badcfe;
+	mctx->hash[3] = 0x10325476;
+	mctx->byte_count = 0;
 }
 
-static void
+	static void
 md4_append(PurpleCipherContext *context, const guchar *data, size_t len)
 {
-    struct MD4_Context *mctx = purple_cipher_context_get_data(context);
-    const guint32 avail = sizeof(mctx->block) - (mctx->byte_count & 0x3f);
+	struct MD4_Context *mctx = purple_cipher_context_get_data(context);
+	const guint32 avail = sizeof(mctx->block) - (mctx->byte_count & 0x3f);
 
-    mctx->byte_count += len;
+	mctx->byte_count += len;
 
-    if (avail > len) {
-        memcpy((char *)mctx->block + (sizeof(mctx->block) - avail),
-                data, len);
-        return;
-    }
+	if (avail > len) {
+		memcpy((char *)mctx->block + (sizeof(mctx->block) - avail),
+				data, len);
+		return;
+	}
 
-    memcpy((char *)mctx->block + (sizeof(mctx->block) - avail),
-            data, avail);
+	memcpy((char *)mctx->block + (sizeof(mctx->block) - avail),
+			data, avail);
 
-    md4_transform_helper(mctx);
-    data += avail;
-    len -= avail;
+	md4_transform_helper(mctx);
+	data += avail;
+	len -= avail;
 
-    while (len >= sizeof(mctx->block)) {
-        memcpy(mctx->block, data, sizeof(mctx->block));
-        md4_transform_helper(mctx);
-        data += sizeof(mctx->block);
-        len -= sizeof(mctx->block);
-    }
+	while (len >= sizeof(mctx->block)) {
+		memcpy(mctx->block, data, sizeof(mctx->block));
+		md4_transform_helper(mctx);
+		data += sizeof(mctx->block);
+		len -= sizeof(mctx->block);
+	}
 
-    memcpy(mctx->block, data, len);
+	memcpy(mctx->block, data, len);
 }
 
-static gboolean
+	static gboolean
 md4_digest(PurpleCipherContext *context, size_t in_len, guchar *out,
-                           size_t *out_len)
+		size_t *out_len)
 {
-    struct MD4_Context *mctx = purple_cipher_context_get_data(context);
-    const unsigned int offset = mctx->byte_count & 0x3f;
-    char *p = (char *)mctx->block + offset;
-    int padding = 56 - (offset + 1);
+	struct MD4_Context *mctx = purple_cipher_context_get_data(context);
+	const unsigned int offset = mctx->byte_count & 0x3f;
+	char *p = (char *)mctx->block + offset;
+	int padding = 56 - (offset + 1);
 
 
-    if(in_len<16) return FALSE;
-    if(out_len) *out_len = 16;
-    *p++ = 0x80;
-    if (padding < 0) {
-        memset(p, 0x00, padding + sizeof (guint64));
-        md4_transform_helper(mctx);
-        p = (char *)mctx->block;
-        padding = 56;
-    }
+	if(in_len<16) return FALSE;
+	if(out_len) *out_len = 16;
+	*p++ = 0x80;
+	if (padding < 0) {
+		memset(p, 0x00, padding + sizeof (guint64));
+		md4_transform_helper(mctx);
+		p = (char *)mctx->block;
+		padding = 56;
+	}
 
-    memset(p, 0, padding);
-    mctx->block[14] = mctx->byte_count << 3;
-    mctx->block[15] = mctx->byte_count >> 29;
-    le32_to_cpu_array(mctx->block, (sizeof(mctx->block) -
-                sizeof(guint64)) / sizeof(guint32));
-    md4_transform(mctx->hash, mctx->block);
-    cpu_to_le32_array(mctx->hash, sizeof(mctx->hash) / sizeof(guint32));
-    memcpy(out, mctx->hash, sizeof(mctx->hash));
-    memset(mctx, 0, sizeof(*mctx));
-    return TRUE;
+	memset(p, 0, padding);
+	mctx->block[14] = mctx->byte_count << 3;
+	mctx->block[15] = mctx->byte_count >> 29;
+	le32_to_cpu_array(mctx->block, (sizeof(mctx->block) -
+				sizeof(guint64)) / sizeof(guint32));
+	md4_transform(mctx->hash, mctx->block);
+	cpu_to_le32_array(mctx->hash, sizeof(mctx->hash) / sizeof(guint32));
+	memcpy(out, mctx->hash, sizeof(mctx->hash));
+	memset(mctx, 0, sizeof(*mctx));
+	return TRUE;
 }
 
 static void
 md4_uninit(PurpleCipherContext *context) {
-    struct MD4_Context *md4_context;
+	struct MD4_Context *md4_context;
 
-    purple_cipher_context_reset(context, NULL);
+	purple_cipher_context_reset(context, NULL);
 
-    md4_context = purple_cipher_context_get_data(context);
-    memset(md4_context, 0, sizeof(*md4_context));
+	md4_context = purple_cipher_context_get_data(context);
+	memset(md4_context, 0, sizeof(*md4_context));
 
-    g_free(md4_context);
-    md4_context = NULL;
+	g_free(md4_context);
+	md4_context = NULL;
 }
 
-static size_t
+	static size_t
 md4_get_block_size(PurpleCipherContext *context)
 {
-    /* This does not change (in this case) */
-    return MD4_HMAC_BLOCK_SIZE;
+	/* This does not change (in this case) */
+	return MD4_HMAC_BLOCK_SIZE;
 }
 
 static PurpleCipherOps MD4Ops = {
-    .init = md4_init,
-    .reset = md4_reset,
-    .uninit = md4_uninit,
-    .append = md4_append,
-    .digest = md4_digest,
-    .get_block_size = md4_get_block_size,
+	.init = md4_init,
+	.reset = md4_reset,
+	.uninit = md4_uninit,
+	.append = md4_append,
+	.digest = md4_digest,
+	.get_block_size = md4_get_block_size,
 };
 
 PurpleCipherOps *