pearson & xxhash

5 files changed, 232 insertions, 0 deletions

diff --git a/src/crypto.h b/src/crypto.h
index eff9ffe..0bee9a3 100644
--- a/src/crypto.h
+++ b/src/crypto.h
@@ -3,6 +3,8 @@
 #include "hash/md5.h"
 #include "hash/sha01.h"
 #include "hash/sha2xx.h"
+#include "hash/pearson.h"
+#include "hash/xxh.h"
 
 #include "encode/uuencode.h"
 #include "encode/base64.h"
@@ -16,6 +18,10 @@ static const luaL_Reg crypto_function_list [] = {
       {"sha1",l_sha1},
       {"sha256",l_sha256},
       {"sha224",l_sha224},
+      {"setpearson",l_setpearson},
+      {"pearson",l_pearson},
+      {"xxh64",l_xxh64},
+      {"xxh32",l_xxh32},
 
       {"uuencode",l_uuencode},
       {"uudecode",l_uudecode},
diff --git a/src/hash/pearson.c b/src/hash/pearson.c
new file mode 100644
index 0000000..9372931
--- /dev/null
+++ b/src/hash/pearson.c
@@ -0,0 +1,64 @@
+#include "../i_util.h"
+#include "../crypto.h"
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+static uint8_t pearson_table[256] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,
+  15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,
+  39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,
+  63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,
+  87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,
+  108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,
+  126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,
+  144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,
+  162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,
+  180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,
+  198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,
+  216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,
+  234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,
+  252,253,254,255};
+
+uint8_t i_pearson(uint8_t *aa, size_t len){
+    uint8_t ret = 0;
+
+    for(int i = 0; i != len; i++) ret = pearson_table[(uint8_t)(ret^aa[i])];
+
+    return ret;
+}
+
+int l_setpearson(lua_State* L){
+  luaL_checktype(L, 1, LUA_TTABLE);
+  size_t len = lua_objlen(L,1);
+  
+  if(len != 256) {
+    p_error("new table must have a length of 256");
+    exit(0); 
+  }
+
+  double s = 0;
+  for(int i = 0; i <= len-1; i++){
+
+    lua_pushinteger(L,i+1);
+    lua_gettable(L,1);
+       
+    pearson_table[i] = luaL_checknumber(L, -1);
+    lua_pop(L,1);
+  }
+  return 0;
+}
+
+int l_pearson(lua_State* L){
+  
+  size_t len = 0;
+  uint8_t* a = (uint8_t*)luaL_checklstring(L, 1, &len);
+
+  char digest[3];
+  uint8_t u = i_pearson(a, len);
+  
+  sprintf(digest,"%x",u);
+
+  lua_pushstring(L, digest);
+
+  return 1;
+}
diff --git a/src/hash/pearson.h b/src/hash/pearson.h
new file mode 100644
index 0000000..aba89e4
--- /dev/null
+++ b/src/hash/pearson.h
@@ -0,0 +1,4 @@
+#include "../lua.h"
+
+int l_setpearson(lua_State* L);
+int l_pearson(lua_State* L);
diff --git a/src/hash/xxh.c b/src/hash/xxh.c
new file mode 100644
index 0000000..74cb202
--- /dev/null
+++ b/src/hash/xxh.c
@@ -0,0 +1,154 @@
+#include "../crypto.h"
+#include <stdio.h>
+#include <stdint.h>
+
+#define max_buffer_size32 16
+#define max_buffer_size64 32
+static inline uint32_t rol32(uint32_t x, unsigned char bits){
+    return (x << bits) | (x >> (32 - bits));
+}
+static inline uint64_t rol64(uint64_t x, unsigned char bits){
+    return (x << bits) | (x >> (64 - bits));
+}
+
+uint32_t i_xxhash32(uint8_t *data, uint32_t seed, size_t len){
+    const uint32_t prime1 = 2654435761U;
+    const uint32_t prime2 = 2246822519U;
+    const uint32_t prime3 = 3266489917U;
+    const uint32_t prime4 = 668265263U;
+    const uint32_t prime5 = 374761393U;
+
+    uint32_t state[4];
+    uint32_t result = len;
+
+    uint8_t* stop      = data + len;
+    uint8_t* stop_block = stop - max_buffer_size32;
+
+    state[0] = seed + prime1 + prime2;
+    state[1] = seed + prime2;
+    state[2] = seed;
+    state[3] = seed - prime1;
+
+    for(;data <= stop_block;){
+        state[0] = rol32(state[0] + data[0] * prime2, 13) * prime1;
+        state[1] = rol32(state[1] + data[1] * prime2, 13) * prime1;
+        state[2] = rol32(state[2] + data[2] * prime2, 13) * prime1;
+        state[3] = rol32(state[3] + data[3] * prime2, 13) * prime1;
+
+        data += 16;
+    }
+
+    if(len >= max_buffer_size32){
+        result += rol32(state[0],  1) + rol32(state[1],  7) +
+                rol32(state[2], 12) + rol32(state[3], 18);
+    } else result += state[2] + prime5;
+
+    for (; data + 4 <= stop; data += 4)
+      result = rol32(result + *(uint32_t*)data * prime3, 17) * prime4;
+
+    for(;data != stop;)
+      result = rol32(result + (*data++) * prime5, 11) * prime1;
+
+    result ^= result >> 15;
+    result *= prime2;
+    result ^= result >> 13;
+    result *= prime3;
+    result ^= result >> 16;
+
+    return result;
+}
+
+#define pr64(u1,u2) rol64((u1) + (u2) * prime2, 31) * prime1
+uint64_t i_xxhash64(uint8_t *data, uint64_t seed, uint64_t len){
+    const uint64_t prime1 = 11400714785074694791ULL;
+    const uint64_t prime2 = 14029467366897019727ULL;
+    const uint64_t prime3 = 1609587929392839161ULL;
+    const uint64_t prime4 = 9650029242287828579ULL;
+    const uint64_t prime5 = 2870177450012600261ULL;
+
+    uint64_t state[4];
+    uint64_t result;
+    
+    uint8_t* stop      = data + len;
+    uint8_t* stop_block = stop - max_buffer_size64;
+
+    state[0] = seed + prime1 + prime2;
+    state[1] = seed + prime2;
+    state[2] = seed;
+    state[3] = seed - prime1;
+
+    for(;data <= stop_block;){
+        state[0] = pr64(state[0], data[0]);
+        state[1] = pr64(state[1], data[1]);
+        state[2] = pr64(state[2], data[2]);
+        state[3] = pr64(state[3], data[3]);
+
+        data += 32;
+    }
+    
+    if(len >= max_buffer_size64){
+        result = rol64(state[0],  1) + rol64(state[1],  7) +
+                rol64(state[2], 12) + rol64(state[3], 18);
+        result = (result ^ pr64(0, state[0])) * prime1 + prime4;
+        result = (result ^ pr64(0, state[1])) * prime1 + prime4;
+        result = (result ^ pr64(0, state[2])) * prime1 + prime4;
+        result = (result ^ pr64(0, state[3])) * prime1 + prime4;
+    } else { 
+        result = state[2] + prime5;
+    }
+    result += len;
+
+    for (; data + 8 <= stop; data += 8)
+      result = rol64(result ^ pr64(0, *(uint64_t*)data), 27) * prime1 + prime4;
+
+    if (data + 4 <= stop){
+      result = rol64(result ^ (*(uint32_t*)data) * prime1,   23) * prime2 + prime3;
+      data  += 4;
+    }
+
+    for(;data != stop;)
+      result = rol64(result ^ (*data++) * prime5, 11) * prime1;
+
+    result ^= result >> 33;
+    result *= prime2;
+    result ^= result >> 29;
+    result *= prime3;
+    result ^= result >> 32;
+    return result;
+}
+
+int l_xxh64(lua_State* L){
+  
+  size_t len = 0;
+  uint8_t* a = (uint8_t*)luaL_checklstring(L, 1, &len);
+  int argv = lua_gettop(L);
+
+  uint64_t seed = 0;
+  if(argv>1) seed = luaL_checkinteger(L, 2);
+  
+  char digest[64];
+
+  uint64_t u = i_xxhash64(a, seed, len);
+  sprintf(digest,"%lx",u);
+  lua_pushstring(L, digest);
+
+  return 1;
+}
+
+int l_xxh32(lua_State* L){
+  
+  size_t len = 0;
+  uint8_t* a = (uint8_t*)luaL_checklstring(L, 1, &len);
+  int argv = lua_gettop(L);
+
+  uint32_t seed = 0;
+  if(argv>1) seed = luaL_checkinteger(L, 2);
+  
+  char digest[32];
+
+  uint32_t u = i_xxhash32(a, seed, len);
+  sprintf(digest,"%x",u);
+  lua_pushstring(L, digest);
+
+  return 1;
+}
diff --git a/src/hash/xxh.h b/src/hash/xxh.h
new file mode 100644
index 0000000..7dc3c8b
--- /dev/null
+++ b/src/hash/xxh.h
@@ -0,0 +1,4 @@
+#include "../lua.h"
+
+int l_xxh32(lua_State*);
+int l_xxh64(lua_State*);