Mercurial > pidgin.yaz

changeset 31662:a1a0936d10c3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
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 *