更改为lib

.gitignore

@@ -0,0 +1,2 @@
+build
+.DS_Store

CMakeLists.txt

@@ -0,0 +1,19 @@
+cmake_minimum_required(VERSION 2.6)
+project(simple-md5-lib C)
+SET(CMAKE_BUILD_TYPE "Release")
+
+include(TestBigEndian)
+test_big_endian(isBigEndian)
+if (${isBigEndian})
+    add_definitions(-DWORDS_BIGENDIAN)
+endif()
+
+set(TEST 0)
+if(TEST)
+    add_definitions(-DTEST_SIMPLE_MD5_LIB)
+    add_executable(smd5 simplemd5.c)
+else()
+    add_library(smd5 SHARED simplemd5.c)
+    INSTALL(TARGETS smd5 LIBRARY DESTINATION lib)
+    INSTALL(FILES simplemd5.h DESTINATION include)
+endif()

README.md

@@ -1,4 +1,26 @@
-MD5
+# simple-md5-lib
-===
-implementation of the MD5 algorithm written in C
 
+Simple C lib of the MD5 algorithm
+
+# Install
+
+```bash
+git clone https://github.com/fumiama/simple-md5-lib.git
+cd simple-md5-lib
+mkdir build
+cd build
+cmake ..
+make
+make install
+```
+
+# Usage
+
+1. Include `simplemd5.h` in your c program.
+```c
+#include <simplemd5.h>
+```
+2. Call `md5` function. Don't forget to `free` the returned digest.
+```c
+uint8_t* md5(const uint8_t *data, size_t data_len);
+```

simplemd5.c

@@ -1,58 +1,65 @@
-/*
- * Simple MD5 implementation
- *
- * Compile with: gcc -o md5 md5.c
- */
-#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <stdint.h>
+#if !__APPLE__
- 
+    #include <endian.h>
+#else
+    #include <machine/endian.h>
+#endif
+#include "simplemd5.h"
+
 // Constants are the integer part of the sines of integers (in radians) * 2^32.
-const uint32_t k[64] = {
+const static uint32_t k[64] = {
-0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee ,
+    0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee ,
-0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501 ,
+    0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501 ,
-0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be ,
+    0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be ,
-0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821 ,
+    0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821 ,
-0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa ,
+    0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa ,
-0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8 ,
+    0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8 ,
-0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed ,
+    0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed ,
-0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a ,
+    0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a ,
-0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c ,
+    0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c ,
-0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70 ,
+    0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70 ,
-0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05 ,
+    0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05 ,
-0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665 ,
+    0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665 ,
-0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039 ,
+    0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039 ,
-0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1 ,
+    0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1 ,
-0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1 ,
+    0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1 ,
-0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391 };
+    0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391 };
- 
+
 // r specifies the per-round shift amounts
-const uint32_t r[] = {7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22,
+const static uint32_t 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};
  
 // leftrotate function definition
 #define LEFTROTATE(x, c) (((x) << (c)) | ((x) >> (32 - (c))))
- 
+
-void to_bytes(uint32_t val, uint8_t *bytes)
+static void to_bytes(uint32_t val, uint8_t *bytes) {
-{
+    #ifdef WORDS_BIGENDIAN
-    bytes[0] = (uint8_t) val;
+        #if __APPLE__
-    bytes[1] = (uint8_t) (val >> 8);
+            val = __DARWIN_OSSwapInt32(val);
-    bytes[2] = (uint8_t) (val >> 16);
+        #else
-    bytes[3] = (uint8_t) (val >> 24);
+            val = __builtin_bswap32(val);
+        #endif
+    #endif
+    *(uint32_t*)bytes = val;
 }
- 
+
-uint32_t to_int32(const uint8_t *bytes)
+static uint32_t to_int32(const uint8_t *bytes) {
-{
+    #ifdef WORDS_BIGENDIAN
-    return (uint32_t) bytes[0]
+        #if __APPLE__
-        | ((uint32_t) bytes[1] << 8)
+            uint32_t val = __DARWIN_OSSwapInt32(*(uint32_t*)bytes);
-        | ((uint32_t) bytes[2] << 16)
+        #else
-        | ((uint32_t) bytes[3] << 24);
+            uint32_t val = __builtin_bswap32(*(uint32_t*)bytes);
+        #endif
+    #else
+        uint32_t val = *(uint32_t*)bytes;
+    #endif
+    return val;
 }
- 
+
-void md5(const uint8_t *initial_msg, size_t initial_len, uint8_t *digest) {
+uint8_t* md5(const uint8_t *data, size_t data_len) {
  
     // These vars will contain the hash
     uint32_t h0, h1, h2, h3;
@@ -75,19 +82,19 @@ void md5(const uint8_t *initial_msg, size_t initial_len, uint8_t *digest) {
     //append "0" bits until message length in bits ≡ 448 (mod 512)
     //append length mod (2^64) to message
  
-    for (new_len = initial_len + 1; new_len % (512/8) != 448/8; new_len++)
+    for (new_len = data_len + 1; new_len % (512/8) != 448/8; new_len++)
         ;
  
     msg = (uint8_t*)malloc(new_len + 8);
-    memcpy(msg, initial_msg, initial_len);
+    memcpy(msg, data, data_len);
-    msg[initial_len] = 0x80; // append the "1" bit; most significant bit is "first"
+    msg[data_len] = 0x80; // append the "1" bit; most significant bit is "first"
-    for (offset = initial_len + 1; offset < new_len; offset++)
+    for (offset = data_len + 1; offset < new_len; offset++)
         msg[offset] = 0; // append "0" bits
  
     // append the len in bits at the end of the buffer.
-    to_bytes(initial_len*8, msg + new_len);
+    to_bytes(data_len*8, msg + new_len);
     // initial_len>>29 == initial_len*8>>32, but avoids overflow.
-    to_bytes(initial_len>>29, msg + new_len + 4);
+    to_bytes(data_len>>29, msg + new_len + 4);
  
     // Process the message in successive 512-bit chunks:
     //for each 512-bit chunk of message:
@@ -119,7 +126,7 @@ void md5(const uint8_t *initial_msg, size_t initial_len, uint8_t *digest) {
                 f = c ^ (b | (~d));
                 g = (7*i) % 16;
             }
- 
+
             temp = d;
             d = c;
             c = b;
@@ -140,17 +147,20 @@ void md5(const uint8_t *initial_msg, size_t initial_len, uint8_t *digest) {
     free(msg);
  
     //var char digest[16] := h0 append h1 append h2 append h3 //(Output is in little-endian)
+    uint8_t *digest = (uint8_t*)malloc(16*sizeof(char));
     to_bytes(h0, digest);
     to_bytes(h1, digest + 4);
     to_bytes(h2, digest + 8);
     to_bytes(h3, digest + 12);
+    return digest;
 }
- 
+
+#ifdef TEST_SIMPLE_MD5_LIB
 int main(int argc, char **argv) {
     char *msg;
     size_t len;
     int i;
-    uint8_t result[16];
+    uint8_t* result;
  
     if (argc < 2) {
         printf("usage: %s 'string'\n", argv[0]);
@@ -159,16 +169,13 @@ int main(int argc, char **argv) {
     msg = argv[1];
  
     len = strlen(msg);
- 
+    result = md5((uint8_t*)msg, len);
-    // benchmark
-    for (i = 0; i < 1000000; i++) {
-        md5((uint8_t*)msg, len, result);
-    }
- 
     // display result
     for (i = 0; i < 16; i++)
         printf("%2.2x", result[i]);
     puts("");
- 
+    free(result);
+
     return 0;
-}
+}
+#endif

simplemd5.h

@@ -0,0 +1,7 @@
+#ifndef _SIMPLE_MD5_H_
+#define _SIMPLE_MD5_H_
+#include <stdio.h>
+#include <stdint.h>
+//return 128bit(16bytes) digest
+uint8_t* md5(const uint8_t *data, size_t data_len);
+#endif