cadcdev-svn-commits Mailing List for Cryptic Allusion DCDev (Page 49)

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Revision: 692
          http://cadcdev.svn.sourceforge.net/cadcdev/?rev=692&view=rev
Author:   ljsebald
Date:     2010-10-30 20:50:48 +0000 (Sat, 30 Oct 2010)

Log Message:
-----------
Adding in code to do MD5 checksums to libkosutils. A bit random, but I did originally write this for something that was for KOS...

Modified Paths:
--------------
    kos/addons/libkosutils/Makefile

Added Paths:
-----------
    kos/addons/include/kos/md5.h
    kos/addons/libkosutils/md5.c

Added: kos/addons/include/kos/md5.h
===================================================================

--- kos/addons/include/kos/md5.h	                        (rev 0)
+++ kos/addons/include/kos/md5.h	2010-10-30 20:50:48 UTC (rev 692)
@@ -0,0 +1,27 @@
+/* KallistiOS ##version##
+
+   kos/md5.h
+   Copyright (C) 2010 Lawrence Sebald
+*/
+
+#ifndef __KOS_MD5_H
+#define __KOS_MD5_H
+
+#include <sys/cdefs.h>
+__BEGIN_DECLS
+
+#include <arch/types.h>
+
+typedef struct kos_md5_cxt {
+    uint64 size;
+    uint32 hash[4];
+    uint8  buf[64];
+} kos_md5_cxt_t;
+
+void kos_md5_start(kos_md5_cxt_t *cxt);
+void kos_md5_hash_block(kos_md5_cxt_t *cxt, const uint8 *input, uint32 size);
+void kos_md5_finish(kos_md5_cxt_t *cxt, uint8 output[16]);
+
+__END_DECLS
+
+#endif /* !__KOS_MD5_H */

Modified: kos/addons/libkosutils/Makefile
===================================================================
--- kos/addons/libkosutils/Makefile	2010-10-25 17:55:48 UTC (rev 691)
+++ kos/addons/libkosutils/Makefile	2010-10-30 20:50:48 UTC (rev 692)
@@ -2,6 +2,6 @@
 #
 
 TARGET = libkosutils.a
-OBJS = bspline.o img.o pcx_small.o
+OBJS = bspline.o img.o pcx_small.o md5.o
 
 include $(KOS_BASE)/addons/Makefile.prefab

Added: kos/addons/libkosutils/md5.c
===================================================================
--- kos/addons/libkosutils/md5.c	                        (rev 0)
+++ kos/addons/libkosutils/md5.c	2010-10-30 20:50:48 UTC (rev 692)
@@ -0,0 +1,274 @@
+/* KallistiOS ##version##
+
+   md5.c
+   Copyright (C) 2010 Lawrence Sebald
+*/
+
+#include <string.h>
+#include <arch/types.h>
+
+#include <kos/md5.h>
+
+/* Initial values used in starting the MD5 checksum */
+static const uint32 md5initial[4] = {
+    0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476
+};
+
+/* We will append somewhere between 1 and 64 bytes of padding to every message,
+   depending on its length. This is the padding that is to be used. */
+static const uint8 md5padding[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
+};
+
+/* MD5 "magic" values */
+static const uint32 md5tab[64] = {
+    0xD76AA478, 0xE8C7B756, 0x242070DB, 0xC1BDCEEE,
+    0xF57C0FAF, 0x4787C62A, 0xA8304613, 0xFD469501,
+    0x698098D8, 0x8B44F7AF, 0xFFFF5BB1, 0x895CD7BE,
+    0x6B901122, 0xFD987193, 0xA679438E, 0x49B40821,
+    0xF61E2562, 0xC040B340, 0x265E5A51, 0xE9B6C7AA,
+    0xD62F105D, 0x02441453, 0xD8A1E681, 0xE7D3FBC8,
+    0x21E1CDE6, 0xC33707D6, 0xF4D50D87, 0x455A14ED,
+    0xA9E3E905, 0xFCEFA3F8, 0x676F02D9, 0x8D2A4C8A,
+    0xFFFA3942, 0x8771F681, 0x6D9D6122, 0xFDE5380C,
+    0xA4BEEA44, 0x4BDECFA9, 0xF6BB4B60, 0xBEBFBC70,
+    0x289B7EC6, 0xEAA127FA, 0xD4EF3085, 0x04881D05,
+    0xD9D4D039, 0xE6DB99E5, 0x1FA27CF8, 0xC4AC5665,
+    0xF4292244, 0x432AFF97, 0xAB9423A7, 0xFC93A039,
+    0x655B59C3, 0x8F0CCC92, 0xFFEFF47D, 0x85845DD1,
+    0x6FA87E4F, 0xFE2CE6E0, 0xA3014314, 0x4E0811A1,
+    0xF7537E82, 0xBD3AF235, 0x2AD7D2BB, 0xEB86D391
+};
+
+/* Code to generate the above table (in case anyone is interested):
+
+#include <stdio.h>
+#include <math.h>
+
+int main(int argc, char *argv[]) {
+    int i;
+    double tmp;
+
+    printf("static const uint32 md5tab[64] = {");
+
+    for(i = 0; i < 64; ++i) {        
+        if((i % 4) == 0)
+            printf("\n   ");
+
+        tmp = sin(i + 1) * 4294967296.0;
+        if(tmp < 0)
+            tmp = -tmp;
+
+        printf(" 0x%08X", (unsigned long) tmp);
+
+        if(i == 63)
+            break;
+
+        printf(",");
+    }
+
+    printf("\n};\n");
+    return 0;
+}
+*/
+
+#define MD5_PAD_LEN(mod) (((mod) < 56) ? 56 - (mod) : 120 - (mod))
+
+#define MD5_ROT(x, y)  ((x << y) | ((x & 0xFFFFFFFF) >> (32 - y)))
+
+/* Basic MD5 functions */
+#define MD5_F(x, y, z) (z ^ (x & (y ^ z)))
+#define MD5_G(x, y, z) (y ^ (z & (x ^ y)))
+#define MD5_H(x, y, z) (x ^ y ^ z)
+#define MD5_I(x, y, z) (y ^ (x | (~z)))
+
+/* Compound operations, consisting of a F, G, H, or I operation and a rotate */
+#define MD5_FH(a, b, c, d, w, s, t) { \
+    (a) += MD5_F((b), (c), (d)) + (w) + (t); \
+    (a) = MD5_ROT((a), (s)); \
+    (a) += (b); \
+}
+
+#define MD5_GH(a, b, c, d, w, s, t) { \
+    (a) += MD5_G((b), (c), (d)) + (w) + (t); \
+    (a) = MD5_ROT((a), (s)); \
+    (a) += (b); \
+}
+
+#define MD5_HH(a, b, c, d, w, s, t) { \
+    (a) += MD5_H((b), (c), (d)) + (w) + (t); \
+    (a) = MD5_ROT((a), (s)); \
+    (a) += (b); \
+}
+
+#define MD5_IH(a, b, c, d, w, s, t) { \
+    (a) += MD5_I((b), (c), (d)) + (w) + (t); \
+    (a) = MD5_ROT((a), (s)); \
+    (a) += (b); \
+}
+
+void kos_md5_start(kos_md5_cxt_t *cxt) {
+    cxt->size = 0;
+    cxt->hash[0] = md5initial[0];
+    cxt->hash[1] = md5initial[1];
+    cxt->hash[2] = md5initial[2];
+    cxt->hash[3] = md5initial[3];
+}
+
+/* input must be at least 64 bytes long */
+static void kos_md5_process(kos_md5_cxt_t *cxt, const uint8 *input) {
+    uint32 a, b, c, d, w[16];
+    int i;
+
+    /* Read in what we're starting with */
+    a = cxt->hash[0];
+    b = cxt->hash[1];
+    c = cxt->hash[2];
+    d = cxt->hash[3];
+
+    /* Read the input into our buffer */
+    for(i = 0; i < 16; ++i) {
+        w[i] = input[(i << 2)] | (input[(i << 2) + 1] << 8) |
+            (input[(i << 2) + 2] << 16) | (input[(i << 2) + 3] << 24);
+    }
+
+    /* First Round */
+    MD5_FH(a, b, c, d, w[ 0],  7, md5tab[ 0]);
+    MD5_FH(d, a, b, c, w[ 1], 12, md5tab[ 1]);
+    MD5_FH(c, d, a, b, w[ 2], 17, md5tab[ 2]);
+    MD5_FH(b, c, d, a, w[ 3], 22, md5tab[ 3]);
+    MD5_FH(a, b, c, d, w[ 4],  7, md5tab[ 4]);
+    MD5_FH(d, a, b, c, w[ 5], 12, md5tab[ 5]);
+    MD5_FH(c, d, a, b, w[ 6], 17, md5tab[ 6]);
+    MD5_FH(b, c, d, a, w[ 7], 22, md5tab[ 7]);
+    MD5_FH(a, b, c, d, w[ 8],  7, md5tab[ 8]);
+    MD5_FH(d, a, b, c, w[ 9], 12, md5tab[ 9]);
+    MD5_FH(c, d, a, b, w[10], 17, md5tab[10]);
+    MD5_FH(b, c, d, a, w[11], 22, md5tab[11]);
+    MD5_FH(a, b, c, d, w[12],  7, md5tab[12]);
+    MD5_FH(d, a, b, c, w[13], 12, md5tab[13]);
+    MD5_FH(c, d, a, b, w[14], 17, md5tab[14]);
+    MD5_FH(b, c, d, a, w[15], 22, md5tab[15]);
+
+    /* Second Round */
+    MD5_GH(a, b, c, d, w[ 1],  5, md5tab[16]);
+    MD5_GH(d, a, b, c, w[ 6],  9, md5tab[17]);
+    MD5_GH(c, d, a, b, w[11], 14, md5tab[18]);
+    MD5_GH(b, c, d, a, w[ 0], 20, md5tab[19]);
+    MD5_GH(a, b, c, d, w[ 5],  5, md5tab[20]);
+    MD5_GH(d, a, b, c, w[10],  9, md5tab[21]);
+    MD5_GH(c, d, a, b, w[15], 14, md5tab[22]);
+    MD5_GH(b, c, d, a, w[ 4], 20, md5tab[23]);
+    MD5_GH(a, b, c, d, w[ 9],  5, md5tab[24]);
+    MD5_GH(d, a, b, c, w[14],  9, md5tab[25]);
+    MD5_GH(c, d, a, b, w[ 3], 14, md5tab[26]);
+    MD5_GH(b, c, d, a, w[ 8], 20, md5tab[27]);
+    MD5_GH(a, b, c, d, w[13],  5, md5tab[28]);
+    MD5_GH(d, a, b, c, w[ 2],  9, md5tab[29]);
+    MD5_GH(c, d, a, b, w[ 7], 14, md5tab[30]);
+    MD5_GH(b, c, d, a, w[12], 20, md5tab[31]);
+
+    /* Third Round */
+    MD5_HH(a, b, c, d, w[ 5],  4, md5tab[32]);
+    MD5_HH(d, a, b, c, w[ 8], 11, md5tab[33]);
+    MD5_HH(c, d, a, b, w[11], 16, md5tab[34]);
+    MD5_HH(b, c, d, a, w[14], 23, md5tab[35]);
+    MD5_HH(a, b, c, d, w[ 1],  4, md5tab[36]);
+    MD5_HH(d, a, b, c, w[ 4], 11, md5tab[37]);
+    MD5_HH(c, d, a, b, w[ 7], 16, md5tab[38]);
+    MD5_HH(b, c, d, a, w[10], 23, md5tab[39]);
+    MD5_HH(a, b, c, d, w[13],  4, md5tab[40]);
+    MD5_HH(d, a, b, c, w[ 0], 11, md5tab[41]);
+    MD5_HH(c, d, a, b, w[ 3], 16, md5tab[42]);
+    MD5_HH(b, c, d, a, w[ 6], 23, md5tab[43]);
+    MD5_HH(a, b, c, d, w[ 9],  4, md5tab[44]);
+    MD5_HH(d, a, b, c, w[12], 11, md5tab[45]);
+    MD5_HH(c, d, a, b, w[15], 16, md5tab[46]);
+    MD5_HH(b, c, d, a, w[ 2], 23, md5tab[47]);
+
+    /* Last Round */
+    MD5_IH(a, b, c, d, w[ 0],  6, md5tab[48]);
+    MD5_IH(d, a, b, c, w[ 7], 10, md5tab[49]);
+    MD5_IH(c, d, a, b, w[14], 15, md5tab[50]);
+    MD5_IH(b, c, d, a, w[ 5], 21, md5tab[51]);
+    MD5_IH(a, b, c, d, w[12],  6, md5tab[52]);
+    MD5_IH(d, a, b, c, w[ 3], 10, md5tab[53]);
+    MD5_IH(c, d, a, b, w[10], 15, md5tab[54]);
+    MD5_IH(b, c, d, a, w[ 1], 21, md5tab[55]);
+    MD5_IH(a, b, c, d, w[ 8],  6, md5tab[56]);
+    MD5_IH(d, a, b, c, w[15], 10, md5tab[57]);
+    MD5_IH(c, d, a, b, w[ 6], 15, md5tab[58]);
+    MD5_IH(b, c, d, a, w[13], 21, md5tab[59]);
+    MD5_IH(a, b, c, d, w[ 4],  6, md5tab[60]);
+    MD5_IH(d, a, b, c, w[11], 10, md5tab[61]);
+    MD5_IH(c, d, a, b, w[ 2], 15, md5tab[62]);
+    MD5_IH(b, c, d, a, w[ 9], 21, md5tab[63]);
+
+    /* Save out what we have */
+    cxt->hash[0] += a;
+    cxt->hash[1] += b;
+    cxt->hash[2] += c;
+    cxt->hash[3] += d;
+}
+
+void kos_md5_hash_block(kos_md5_cxt_t *cxt, const uint8 *input, uint32 size) {
+    uint32 left, copy;
+
+    /* Figure out what we had left over from last time (if anything) */
+    left = (uint32)((cxt->size >> 3) & 0x3F);
+    copy = 64 - left;
+
+    /* Update the size */
+    cxt->size += (size << 3);
+
+    /* Deal with what was left over, if we have enough data to do so */
+    if(left && size >= copy) {
+        memcpy(&cxt->buf[left], input, copy);
+        kos_md5_process(cxt, cxt->buf);
+        left = 0;
+        size -= copy;
+        input += copy;
+    }
+
+    /* Hash each block of the data */
+    while(size >= 64) {
+        kos_md5_process(cxt, input);
+        input += 64;
+        size -= 64;
+    }
+
+    /* Buffer anything left over */
+    if(size) {
+        memcpy(&cxt->buf[left], input, size);
+    }
+}
+
+void kos_md5_finish(kos_md5_cxt_t *cxt, uint8 output[16]) {
+    uint64 len = cxt->size;
+    uint32 blen = (cxt->size >> 3) & 0x3F;
+    uint32 plen = MD5_PAD_LEN(blen);
+    int i;
+    uint8 len_bytes[8];
+
+    /* Add in the padding */
+    kos_md5_hash_block(cxt, md5padding, plen);
+
+    /* Hash in the length -- this will finish the last 64-byte block */
+    len_bytes[0] = (uint8)(len);
+    len_bytes[1] = (uint8)(len >> 8);
+    len_bytes[2] = (uint8)(len >> 16);
+    len_bytes[3] = (uint8)(len >> 24);
+    len_bytes[4] = (uint8)(len >> 32);
+    len_bytes[5] = (uint8)(len >> 40);
+    len_bytes[6] = (uint8)(len >> 48);
+    len_bytes[7] = (uint8)(len >> 56);
+    kos_md5_hash_block(cxt, len_bytes, 8);
+
+    /* Copy out the hash, since we're done */
+    for(i = 0; i < 16; ++i) {
+        output[i] = (uint8)(cxt->hash[i >> 2] >> ((i & 0x03) << 3));
+    }
+}


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.




2003	Jan	Feb	Mar	Apr	May	Jun	Jul	Aug	Sep	Oct	Nov (35)	Dec (2)
2004	Jan (37)	Feb (10)	Mar	Apr (2)	May (17)	Jun (1)	Jul (14)	Aug (14)	Sep (4)	Oct	Nov (14)	Dec (4)
2005	Jan (6)	Feb	Mar	Apr (6)	May	Jun	Jul	Aug	Sep (1)	Oct	Nov (92)	Dec (12)
2006	Jan (3)	Feb (4)	Mar	Apr (5)	May (3)	Jun (15)	Jul (3)	Aug (1)	Sep (29)	Oct (1)	Nov (6)	Dec (5)
2007	Jan (2)	Feb (2)	Mar	Apr (3)	May (14)	Jun (2)	Jul (16)	Aug (73)	Sep (12)	Oct (9)	Nov (27)	Dec (3)
2008	Jan (4)	Feb (4)	Mar (3)	Apr (8)	May (23)	Jun (4)	Jul (1)	Aug (3)	Sep (7)	Oct (5)	Nov (1)	Dec (1)
2009	Jan	Feb (10)	Mar	Apr (4)	May (4)	Jun (10)	Jul	Aug (1)	Sep	Oct (7)	Nov	Dec (1)
2010	Jan	Feb (1)	Mar	Apr (6)	May	Jun (3)	Jul (11)	Aug (1)	Sep	Oct (15)	Nov (1)	Dec (5)
2011	Jan (4)	Feb (1)	Mar (6)	Apr	May (22)	Jun	Jul (8)	Aug (2)	Sep	Oct	Nov	Dec (2)
2012	Jan	Feb (10)	Mar (1)	Apr (6)	May (27)	Jun (48)	Jul (30)	Aug (4)	Sep	Oct (3)	Nov (1)	Dec (11)
2013	Jan (4)	Feb (7)	Mar (6)	Apr (18)	May (28)	Jun (20)	Jul	Aug (4)	Sep (1)	Oct (1)	Nov (2)	Dec (7)
2014	Jan (3)	Feb (2)	Mar (4)	Apr (9)	May (11)	Jun (10)	Jul	Aug (18)	Sep (12)	Oct (17)	Nov (10)	Dec (16)
2015	Jan (5)	Feb (1)	Mar (5)	Apr (4)	May (28)	Jun (2)	Jul	Aug	Sep (6)	Oct	Nov (2)	Dec (1)
2016	Jan (14)	Feb	Mar (3)	Apr	May	Jun (3)	Jul (4)	Aug (4)	Sep (1)	Oct (1)	Nov	Dec (1)
2017	Jan (11)	Feb	Mar (21)	Apr	May (1)	Jun	Jul	Aug	Sep	Oct	Nov	Dec (1)
2018	Jan	Feb	Mar (1)	Apr	May (1)	Jun	Jul	Aug (2)	Sep (4)	Oct (4)	Nov	Dec (1)
2019	Jan (1)	Feb	Mar	Apr (1)	May	Jun	Jul	Aug (13)	Sep (4)	Oct	Nov	Dec
2020	Jan (10)	Feb (9)	Mar (5)	Apr (4)	May (3)	Jun (18)	Jul (4)	Aug (2)	Sep (20)	Oct (2)	Nov	Dec
2021	Jan	Feb	Mar	Apr (2)	May (1)	Jun (2)	Jul (1)	Aug (2)	Sep	Oct	Nov	Dec (2)
2022	Jan (1)	Feb (2)	Mar (2)	Apr (1)	May	Jun	Jul	Aug (5)	Sep	Oct (1)	Nov	Dec (1)
2023	Jan (10)	Feb (7)	Mar (29)	Apr (31)	May (29)	Jun (34)	Jul (3)	Aug (24)	Sep (22)	Oct (10)	Nov (38)	Dec (27)
2024	Jan (15)	Feb (8)	Mar (4)	Apr (20)	May (33)	Jun (18)	Jul (15)	Aug (23)	Sep (26)	Oct (32)	Nov (6)	Dec (4)
2025	Jan (7)	Feb (1)	Mar (1)	Apr (4)	May (46)	Jun (19)	Jul (1)	Aug	Sep	Oct	Nov	Dec

cadcdev-svn-commits Mailing List for Cryptic Allusion DCDev (Page 49)

cadcdev-svn-commits — Source Code Repository Updates