REM Simple MD5 implementation.
REM Taken from http://en.wikipedia.org/wiki/MD5#Simple_implementation
REM
REM PvE, September 2014 - GPL.
REM
REM Add the necessary include files and libraries as command line option to the compiler:
REM
REM gcc -include stdint.h -g -o md5sum md5sum.c -lm -lgc
REM

REM Constants are the integer part of the sines of integers (in radians) * 2^32.
DECLARE k[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} TYPE uint32_t

REM r specifies the per-round shift amounts
DECLARE r[] = {7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22,
            5,  9, 14, 20, 5,  9, 14, 20, 5,  9, 14, 20, 5,  9, 14, 20,
            4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23,
            6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21} TYPE uint32_t

REM leftrotate function definition
DEFFN LEFTROTATE(x, c) = (((x) << (c)) | ((x) >> (32 - (c))))

REM ------------------------------------------------------------------------------------------------------------------

SUB to_bytes(uint32_t val, uint8_t *bytes)

    LET bytes[0] = (uint8_t) val
    LET bytes[1] = (uint8_t) (val >> 8)
    LET bytes[2] = (uint8_t) (val >> 16)
    LET bytes[3] = (uint8_t) (val >> 24)

ENDSUB

REM ------------------------------------------------------------------------------------------------------------------

FUNC to_int32(uint8_t *bytes)

    RETURN (uint32_t) bytes[0] | ((uint32_t) bytes[1] << 8) | ((uint32_t) bytes[2] << 16) | ((uint32_t) bytes[3] << 24)

ENDFUNC

REM ------------------------------------------------------------------------------------------------------------------

SUB md5(uint8_t *initial_msg, size_t initial_len, uint8_t *digest)

    REM These vars will contain the hash
    DECLARE h0, h1, h2, h3 TYPE uint32_t

    REM Message (to prepare)
    DECLARE *msg TYPE uint8_t

    DECLARE new_len, offset TYPE size_t
    DECLARE w[16] TYPE uint32_t
    DECLARE a, b, c, d, i, f, g, temp TYPE uint32_t

    REM Initialize variables - simple count in nibbles:
    LET h0 = 0x67452301
    LET h1 = 0xefcdab89
    LET h2 = 0x98badcfe
    LET h3 = 0x10325476

    REM Pre-processing:
    REM append "1" bit to message    
    REM append "0" bits until message length in bits â<89>¡ 448 (mod 512)
    REM append length mod (2^64) to message

    LET new_len = initial_len + 1
    WHILE new_len % (512/8) != 448/8
        INCR new_len
    WEND

    LET msg = (uint8_t*)MEMORY(new_len + 8)

    FOR i = 0 TO initial_len-1
        POKE msg+i, PEEK(initial_msg+i)
    NEXT

    REM append the "1" bit; most significant bit is "first"
    LET msg[initial_len] = 0x80

    REM append "0" bits
    FOR offset = initial_len + 1 TO new_len - 1
        LET msg[offset] = 0
    NEXT

    REM append the len in bits at the end of the buffer.
    LET to_bytes(initial_len*8, msg + new_len)

    REM initial_len>>29 == initial_len*8>>32, but avoids overflow.
    LET to_bytes(initial_len>>29, msg + new_len + 4)

    REM Process the message in successive 512-bit chunks:
    REM for each 512-bit chunk of message:
    FOR offset = 0 TO new_len - 1 STEP (512/8)

        REM break chunk into sixteen 32-bit words w[j], 0 â<89>¤ j â<89>¤ 15
        FOR i = 0 TO 15
            LET w[i] = to_int32(msg + offset + i*4)
        NEXT

        REM Initialize hash value for this chunk:
        LET a = h0
        LET b = h1
        LET c = h2
        LET d = h3

        REM Main loop:
        FOR i = 0 TO 63
            IF i < 16 THEN
                LET f = (b & c) | ((~b) & d)
                LET g = i
            ELIF i < 32 THEN
                LET f = (d & b) | ((~d) & c)
                LET g = (5*i + 1) % 16
            ELIF i < 48 THEN
                LET f = b ^ c ^ d
                LET g = (3*i + 5) % 16
            ELSE
                LET f = c ^ (b | (~d))
                LET g = (7*i) % 16
            ENDIF
            LET temp = d
            LET d = c
            LET c = b
            LET b = b + LEFTROTATE((a + f + k[i] + w[g]), r[i])
            LET a = temp
        NEXT
        REM Add this chunk's hash to result so far:
        INCR h0, a
        INCR h1, b
        INCR h2, c
        INCR h3, d
    NEXT

    REM cleanup
    FREE msg

    REM var char digest[16] := h0 append h1 append h2 append h3 (Output is in little-endian)
    LET to_bytes(h0, digest)
    LET to_bytes(h1, digest + 4)
    LET to_bytes(h2, digest + 8)
    LET to_bytes(h3, digest + 12)

ENDSUB

REM ------------------------------------------------------------------------------------------------------------------

DECLARE result[16] TYPE uint8_t
INTEGER len, i

IF argc != 2 THEN
    PRINT "Usage: md5sum <string>" NL
    END 1
ENDIF

LET len = LEN(argv[1])
CALL md5((uint8_t*)argv[1], len, result)

REM Display result
FOR i = 0 TO 15
    PRINT result[i] FORMAT "%2.2x"
NEXT
NL

Return to M4BASIC