From af975d63f67e6cc2d17f1804acb66328905f8701 Mon Sep 17 00:00:00 2001
From: amelia squires <ameliasquires@disroot.org>
Date: Mon, 21 Apr 2025 20:43:51 -0500
Subject: better version support, fixes, and memory saftey

---
 .gitignore              |  2 ++
 makefile                |  4 +++-
 readme.md               |  4 ++++
 src/crypto.h            | 15 ++++++---------
 src/hash/adler.c        |  4 ++++
 src/hash/blake.c        | 34 ++++++++++++++++++++++++++--------
 src/hash/blake2.c       | 32 ++++++++++++++++++++++++--------
 src/hash/bsdchecksum.c  |  4 ++++
 src/hash/crc.c          |  4 ++++
 src/hash/djb2.c         |  4 ++++
 src/hash/fletcher.c     |  4 ++++
 src/hash/fnv.c          | 10 +++++++---
 src/hash/jenkins.c      |  4 ++++
 src/hash/loselose.c     |  4 ++++
 src/hash/md5.c          |  9 +++++++--
 src/hash/pearson.c      |  4 ++++
 src/hash/pjw.c          |  4 ++++
 src/hash/sdbm.c         |  4 ++++
 src/hash/sha01.c        | 12 +++++++++---
 src/hash/sha2-256.c     | 16 ++++++++++++----
 src/hash/sha2xx.c       | 10 +++++++++-
 src/hash/sysvchecksum.c |  4 ++++
 src/hash/xor.c          |  4 ++++
 src/lua.h               | 18 +++++++++++++-----
 src/thread.c            |  9 +++++++--
 tests/hash.lua          |  4 ++++
 26 files changed, 181 insertions(+), 46 deletions(-)

diff --git a/.gitignore b/.gitignore
index 3f302bc..ad431dc 100644
--- a/.gitignore
+++ b/.gitignore
@@ -19,4 +19,6 @@ CMakeCache.txt
 Makefile
 *.cmake
 
+.cache/
+
 !.luarc.json
diff --git a/makefile b/makefile
index 1c9bfae..30a261a 100644
--- a/makefile
+++ b/makefile
@@ -2,7 +2,9 @@ CC := clang
 
 GIT_COMMIT := "$(shell git describe --tags)-$(shell git describe --always --match 'NOT A TAG')"
 
-CFLAGS := -fPIC -DGIT_COMMIT='$(GIT_COMMIT)'
+version ?= lua5.4
+
+CFLAGS := -fPIC -DGIT_COMMIT='$(GIT_COMMIT)' `pkg-config --cflags $(version)`
 LFLAGS := -lm -shared -lcrypto -lssl
 LINKER := $(CC)
 
diff --git a/readme.md b/readme.md
index cf31461..4367b14 100644
--- a/readme.md
+++ b/readme.md
@@ -49,6 +49,10 @@ build with `make`, output is `./lullaby.so` or (win)`./lullaby.dll`
 
 windows works through msys2, install `mingw-w64-x86_64-lua` then run `make CC=gcc`
 
+lua version can be specified with `version=...`, similar to lua5.1, lua5.3, luajit, the default it lua5.4
+
+for working on the code base, i recommend using bear to generate compile_commands.json [(as outlined here)](https://clangd.llvm.org/installation#compile_commandsjson) which should probably let your ide find the headers
+
 ---
 
 [some docs](docs/)
diff --git a/src/crypto.h b/src/crypto.h
index b7f342e..2edabe0 100644
--- a/src/crypto.h
+++ b/src/crypto.h
@@ -45,8 +45,8 @@ int tp(lua_State*);
 
 #define common_hash_init_update(hashname) lua_common_hash_init_update(hashname, hashname)
 #define lua_common_hash_init_update(hashname, luaname) lua_common_hash_init(hashname, luaname) lua_common_hash_update(hashname, luaname)
-#define lua_common_hash_init(hashname, luaname) lua_common_hash_init_ni(hashname, luaname, hashname##_init())
-#define lua_common_hash_init_l(hashname, luaname) lua_common_hash_init_ni(hashname, luaname, hashname##_init_l(L))
+#define lua_common_hash_init(hashname, luaname) lua_common_hash_init_ni(hashname, luaname, hashname##_init(), hashname##_free_l)
+#define lua_common_hash_init_l(hashname, luaname) lua_common_hash_init_ni(hashname, luaname, hashname##_init_l(L), hashname##_free_l)
 
 #define common_hash_clone(hashname) lua_common_hash_clone(hashname, hashname)
 #define lua_common_hash_clone(hashname, luaname) lua_common_hash_clone_oargs(hashname, luaname, l_##luaname##_init(L), *b = *a)
@@ -78,15 +78,16 @@ int _##luaname##_common_hash(lua_State* L){\
     return 1;\
   }
 
-#define lua_common_hash_meta_def(luaname)\
+#define lua_common_hash_meta_def(luaname, exitf)\
   lua_newtable(L);\
   int mt = lua_gettop(L);\
   luaI_tsetcf(L, mt, "__index", _##luaname##_common_hash);\
   luaI_tsetcf(L, mt, "__add", _##luaname##_hash_add);\
+  luaI_tsetcf(L, mt, "__gc", exitf);\
   lua_pushvalue(L, mt);\
   lua_setmetatable(L, ud);\
 
-#define lua_common_hash_init_ni(hashname, luaname, initf)\
+#define lua_common_hash_init_ni(hashname, luaname, initf, exitf)\
  lua_common_hash_meta(luaname);\
  int l_##luaname##_init(lua_State* L){\
   \
@@ -94,11 +95,7 @@ int _##luaname##_common_hash(lua_State* L){\
   int ud = lua_gettop(L);\
   *a = initf;\
   int ini = lua_gettop(L);\
-  lua_newtable(L);\
-  luaI_tsetlud(L, LUA_REGISTRYINDEX, "__", (void*)lua_topointer(L, ud));\
-  int i;\
-  for(i = ud; i != ini; i++) luaI_tsetv(L, ini + 1, lua_topointer(L, i), i);\
-  lua_common_hash_meta_def(luaname);\
+  lua_common_hash_meta_def(luaname, exitf);\
   lua_pushvalue(L, ud);\
   return 1;\
 }
diff --git a/src/hash/adler.c b/src/hash/adler.c
index 7ee9197..b4a1135 100644
--- a/src/hash/adler.c
+++ b/src/hash/adler.c
@@ -6,6 +6,10 @@ struct adler32_hash adler32_init(){
   return (struct adler32_hash){.a = 1, .b = 0};
 }
 
+int adler32_free_l(lua_State* L){
+  return 0;
+}
+
 void adler32_update(uint8_t* aa, size_t len, struct adler32_hash* hash){
   for(int i = 0; i != len; i++){
     hash->a += aa[i];
diff --git a/src/hash/blake.c b/src/hash/blake.c
index cf948f1..e5e9b16 100644
--- a/src/hash/blake.c
+++ b/src/hash/blake.c
@@ -104,8 +104,8 @@ struct blake256_hash blake256_init(){
 
 struct blake256_hash blake256_init_l(lua_State* L){
     struct blake256_hash a = {.bufflen = 0, .total = 0, .compressed = 0};
-    a.buffer = lua_newuserdata(L, sizeof * a.buffer * bs);
-    a.hash = lua_newuserdata(L, sizeof * a.hash * 8);
+    a.buffer = calloc(sizeof * a.buffer, bs);
+    a.hash = calloc(sizeof * a.hash, 8);
     memset(a.buffer, 0, bs);
     a.hash[0] = 0x6a09e667;
     a.hash[1] = 0xbb67ae85;
@@ -135,8 +135,8 @@ struct blake256_hash blake224_init(){
 
 struct blake256_hash blake224_init_l(lua_State* L){
     struct blake256_hash a = {.bufflen = 0, .total = 0, .compressed = 0};
-    a.buffer = lua_newuserdata(L, sizeof * a.buffer * bs);
-    a.hash = lua_newuserdata(L, sizeof * a.hash * 8);
+    a.buffer = calloc(sizeof * a.buffer, bs);
+    a.hash = calloc(sizeof * a.hash, 8);
     memset(a.buffer, 0, bs);
     a.hash[0] = 0xc1059ed8;
     a.hash[1] = 0x367cd507;
@@ -149,6 +149,15 @@ struct blake256_hash blake224_init_l(lua_State* L){
     return a;
 }
 
+int blake256_free_l(lua_State* L){
+  struct blake256_hash* h = lua_touserdata(L, -1);
+  free(h->buffer);
+  free(h->hash);
+  return 0;
+}
+
+#define blake224_free_l blake256_free_l
+
 void blake256_round(struct blake256_hash* hash){
   compress256(hash->hash, (char*)hash->buffer, hash->compressed * 8);
 } 
@@ -326,8 +335,8 @@ struct blake512_hash blake512_init(){
 
 struct blake512_hash blake512_init_l(lua_State* L){
     struct blake512_hash a = {.bufflen = 0, .total = 0, .compressed = 0};
-    a.buffer = lua_newuserdata(L, sizeof * a.buffer * bs_2);
-    a.hash = lua_newuserdata(L, sizeof * a.hash * 8);
+    a.buffer = calloc(sizeof * a.buffer, bs_2);
+    a.hash = calloc(sizeof * a.hash, 8);
     memset(a.buffer, 0, bs_2);
     a.hash[0] = 0x6a09e667f3bcc908ULL;
     a.hash[1] = 0xbb67ae8584caa73bULL;
@@ -357,8 +366,8 @@ struct blake384_hash blake384_init(){
 
 struct blake384_hash blake384_init_l(lua_State* L){
     struct blake384_hash a = {.bufflen = 0, .total = 0, .compressed = 0};
-    a.buffer = lua_newuserdata(L, sizeof * a.buffer * bs_2);
-    a.hash = lua_newuserdata(L, sizeof * a.hash * 8);
+    a.buffer = calloc(sizeof * a.buffer, bs_2);
+    a.hash = calloc(sizeof * a.hash, 8);
     memset(a.buffer, 0, bs_2);
     a.hash[0] = 0xcbbb9d5dc1059ed8ULL;
     a.hash[1] = 0x629a292a367cd507ULL;
@@ -371,6 +380,15 @@ struct blake384_hash blake384_init_l(lua_State* L){
     return a;
 }
 
+int blake512_free_l(lua_State* L){
+  struct blake512_hash* h = lua_touserdata(L, -1);
+  free(h->buffer);
+  free(h->hash);
+  return 0;
+}
+
+#define blake384_free_l blake512_free_l
+
 void blake512_round(struct blake512_hash* hash){
   compress512(hash->hash, hash->buffer, hash->compressed * 8);
 } 
diff --git a/src/hash/blake2.c b/src/hash/blake2.c
index adb1419..42dc0ab 100644
--- a/src/hash/blake2.c
+++ b/src/hash/blake2.c
@@ -161,9 +161,9 @@ struct blake2b_hash blake2b_init(char* key, int key_len, int digest_len){
 
 struct blake2b_hash blake2b_init_l(lua_State* L, char* key, int key_len, int digest_len){
     struct blake2b_hash a = {.bufflen = key_len, .total = 0, .compressed = 0, .keylen = key_len, .digest_len = digest_len};
-    a.buffer = lua_newuserdata(L, sizeof * a.buffer * bs_2);
-    a.hash = lua_newuserdata(L, sizeof * a.hash * 8);
-    a.key = lua_newuserdata(L, sizeof* a.key * key_len);
+    a.buffer = calloc(sizeof * a.buffer, bs_2);
+    a.hash = calloc(sizeof * a.hash, 8);
+    a.key = calloc(sizeof* a.key, key_len);
     memset(a.buffer, 0, bs_2);
     memcpy(a.key, key, key_len);
     memcpy(a.buffer, key, key_len);
@@ -188,6 +188,22 @@ struct blake2b_hash blake2b_init_l(lua_State* L, char* key, int key_len, int dig
     return a;
 }
 
+int blake2b_free_l(lua_State* L){
+  struct blake2b_hash* h = lua_touserdata(L, -1);
+  free(h->buffer);
+  free(h->hash);
+  free(h->key);
+  return 0;
+}
+
+int blake2s_free_l(lua_State* L){
+  struct blake2b_hash* h = lua_touserdata(L, -1);
+  free(h->buffer);
+  free(h->hash);
+  free(h->key);
+  return 0;
+}
+
 void blake2b_update(uint8_t* input, size_t len, struct blake2b_hash* hash){
     hash->total += len;
     size_t total_add = len + hash->bufflen;
@@ -286,9 +302,9 @@ struct blake2s_hash blake2s_init(char* key, int key_len, int digest_len){
 
 struct blake2s_hash blake2s_init_l(lua_State* L, char* key, int key_len, int digest_len){
     struct blake2s_hash a = {.bufflen = key_len, .total = 0, .compressed = 0, .keylen = key_len, .digest_len = digest_len};
-    a.buffer = lua_newuserdata(L, sizeof * a.buffer * bs);
-    a.hash = lua_newuserdata(L, sizeof * a.hash * 8);
-    a.key = lua_newuserdata(L, sizeof* a.key * key_len);
+    a.buffer = calloc(sizeof * a.buffer, bs);
+    a.hash = calloc(sizeof * a.hash, 8);
+    a.key = calloc(sizeof* a.key, key_len);
     memcpy(a.key, key, key_len);
     memset(a.buffer, 0, bs);
     memcpy(a.buffer, key, key_len);
@@ -413,7 +429,7 @@ int l_blake2b_init(lua_State* L){
   struct blake2b_hash* a = (struct blake2b_hash*)lua_newuserdata(L, sizeof * a);
   int ud = lua_gettop(L);
   *a = blake2b_init_l(L, key, keylen, outlen);
-  lua_common_hash_meta_def(blake2b);
+  lua_common_hash_meta_def(blake2b, blake2b_free_l);
   lua_pushvalue(L, ud);
   return 1;
 }
@@ -490,7 +506,7 @@ int l_blake2s_init(lua_State* L){
   struct blake2s_hash* a = (struct blake2s_hash*)lua_newuserdata(L, sizeof * a);
   int ud = lua_gettop(L);
   *a = blake2s_init_l(L, key, keylen, outlen);
-  lua_common_hash_meta_def(blake2s);
+  lua_common_hash_meta_def(blake2s, blake2s_free_l);
   lua_pushvalue(L, ud);
   return 1;
 }
diff --git a/src/hash/bsdchecksum.c b/src/hash/bsdchecksum.c
index ccb1e65..18bae0c 100644
--- a/src/hash/bsdchecksum.c
+++ b/src/hash/bsdchecksum.c
@@ -6,6 +6,10 @@ struct bsdchecksum_hash bsdchecksum_init(){
   return (struct bsdchecksum_hash){.check = 0x0};
 }
 
+int bsdchecksum_free_l(lua_State* L){
+  return 0;
+}
+
 void bsdchecksum_update(uint8_t* aa, size_t len, struct bsdchecksum_hash* hash){
   for(int i = 0; i != len; i++){
       uint8_t a = aa[i];
diff --git a/src/hash/crc.c b/src/hash/crc.c
index 650b315..e1433bd 100644
--- a/src/hash/crc.c
+++ b/src/hash/crc.c
@@ -4,6 +4,10 @@
 #include <stdio.h>
 #include <stdint.h>
 
+int crc32_free_l(lua_State* L){return 0;}
+int crc16_free_l(lua_State* L){return 0;}
+int crc8_free_l(lua_State* L){return 0;}
+
 struct crc32_hash crc32_init(){
     return (struct crc32_hash){.crc = 0xFFFFFFFF};
 }
diff --git a/src/hash/djb2.c b/src/hash/djb2.c
index d17c163..e75a0ed 100644
--- a/src/hash/djb2.c
+++ b/src/hash/djb2.c
@@ -3,6 +3,10 @@
 #include <stdint.h>
 #include <inttypes.h>
 
+int djb2_free_l(lua_State* L){
+  return 0;
+}
+
 struct djb2_hash djb2_init(){
   return (struct djb2_hash){.hash = 5381};
 }
diff --git a/src/hash/fletcher.c b/src/hash/fletcher.c
index 52008d8..bfd3e7c 100644
--- a/src/hash/fletcher.c
+++ b/src/hash/fletcher.c
@@ -2,6 +2,10 @@
 #include <stdio.h>
 #include <stdint.h>
 
+int fletcher8_free_l(lua_State* L){return 0;}
+int fletcher16_free_l(lua_State* L){return 0;}
+int fletcher32_free_l(lua_State* L){return 0;}
+
 struct fletcher8_hash fletcher8_init(){
   return (struct fletcher8_hash){.s1 = 0, .s2 = 0};
 }
diff --git a/src/hash/fnv.c b/src/hash/fnv.c
index 48b351e..34623b7 100644
--- a/src/hash/fnv.c
+++ b/src/hash/fnv.c
@@ -6,6 +6,10 @@ struct fnv_1_hash fnv_1_init(enum fnv_version A){
   return (struct fnv_1_hash){.A = A, .hash = (A != v_0) * 0xcbf29ce484222325};
 }
 
+int fnv_1_free_l(lua_State* L){
+  return 0;
+}
+
 void fnv_1_update(uint8_t* in, size_t len, struct fnv_1_hash* hash){
   uint64_t prime = 0x100000001b3;
 
@@ -42,9 +46,9 @@ lua_common_hash_update(fnv_1, fnv_1);
 lua_common_hash_update(fnv_1, fnv_0);
 lua_common_hash_update(fnv_1, fnv_a);
 
-lua_common_hash_init_ni(fnv_1, fnv_1, fnv_1_init(v_1));
-lua_common_hash_init_ni(fnv_1, fnv_0, fnv_1_init(v_0));
-lua_common_hash_init_ni(fnv_1, fnv_a, fnv_1_init(v_a));
+lua_common_hash_init_ni(fnv_1, fnv_1, fnv_1_init(v_1), fnv_1_free_l);
+lua_common_hash_init_ni(fnv_1, fnv_0, fnv_1_init(v_0), fnv_1_free_l);
+lua_common_hash_init_ni(fnv_1, fnv_a, fnv_1_init(v_a), fnv_1_free_l);
 
 #define aaa(v)\
 int l_fnv_##v##_final(lua_State* L){\
diff --git a/src/hash/jenkins.c b/src/hash/jenkins.c
index 8a417c6..ede202f 100644
--- a/src/hash/jenkins.c
+++ b/src/hash/jenkins.c
@@ -6,6 +6,10 @@ struct jenkins_oaat_hash jenkins_oaat_init(){
   return (struct jenkins_oaat_hash){.hash = 0};
 }
 
+int jenkins_oaat_free_l(lua_State* L){
+  return 0;
+}
+
 void jenkins_oaat_update(uint8_t* in, size_t len, struct jenkins_oaat_hash* hash){
   for(int i = 0; i != len;){
     hash->hash += in[i++];
diff --git a/src/hash/loselose.c b/src/hash/loselose.c
index e99987c..4d6d3fe 100644
--- a/src/hash/loselose.c
+++ b/src/hash/loselose.c
@@ -6,6 +6,10 @@ struct loselose_hash loselose_init(){
   return (struct loselose_hash){.hash = 0};
 }
 
+int loselose_free_l(lua_State* L){
+  return 0;
+}
+
 void loselose_update(uint8_t* in, size_t len, struct loselose_hash* hash){
   for(int i = 0; i != len; i++){
     hash->hash += (uint64_t)*in;
diff --git a/src/hash/md5.c b/src/hash/md5.c
index 45844f2..f98e590 100644
--- a/src/hash/md5.c
+++ b/src/hash/md5.c
@@ -27,10 +27,15 @@ struct md5_hash md5_init(){
   return a;
 }
 
+int l_md5_free(lua_State* L){
+  struct md5_hash* h = lua_touserdata(L, -1);
+  free(h->buffer);
+  return 0;
+}
 
 struct md5_hash md5_init_l(lua_State* L){
   struct md5_hash a = {.a0 = 0x67452301, .b0 = 0xefcdab89, .c0 = 0x98badcfe, .d0 = 0x10325476, .total = 0, .bufflen = 0};
-  a.buffer = lua_newuserdata(L, sizeof * a.buffer * bs);
+  a.buffer = calloc(sizeof * a.buffer, bs);
   memset(a.buffer, 0, bs);
   return a;
 }
@@ -142,7 +147,7 @@ lua_common_hash_clone_oargs(md5, md5, l_md5_init(L), {
     memcpy(b->buffer, a->buffer, bs * sizeof * b->buffer);
 });
 
-lua_common_hash_init_ni(md5, md5, md5_init_l(L));
+lua_common_hash_init_ni(md5, md5, md5_init_l(L), l_md5_free);
 lua_common_hash_update(md5, md5);
 //common_hash_init_update(md5);
 
diff --git a/src/hash/pearson.c b/src/hash/pearson.c
index 21c0c96..a544515 100644
--- a/src/hash/pearson.c
+++ b/src/hash/pearson.c
@@ -23,6 +23,10 @@ struct pearson_hash pearson_init(){
   return (struct pearson_hash){.ret = 0};
 }
 
+int pearson_free_l(lua_State* L){
+  return 0;
+}
+
 void pearson_update(uint8_t* aa, size_t len, struct pearson_hash* hash){
   for(int i = 0; i != len; i++)
     hash->ret = pearson_table[(uint8_t)(hash->ret^aa[i])];
diff --git a/src/hash/pjw.c b/src/hash/pjw.c
index 7d37275..188030f 100644
--- a/src/hash/pjw.c
+++ b/src/hash/pjw.c
@@ -7,6 +7,10 @@ struct pjw_hash pjw_init(){
     return (struct pjw_hash){.hash = 0, .high = 0};
 }
 
+int pjw_free_l(lua_State* L){
+  return 0;
+}
+
 void pjw_update(uint8_t* in, size_t len, struct pjw_hash* hash){
     for(int i = 0; i != len; i++){
         hash->hash = (hash->hash << 4) + *in++;
diff --git a/src/hash/sdbm.c b/src/hash/sdbm.c
index 2387301..279130c 100644
--- a/src/hash/sdbm.c
+++ b/src/hash/sdbm.c
@@ -7,6 +7,10 @@ struct sdbm_hash sdbm_init(){
   return (struct sdbm_hash){.hash = 0};
 }
 
+int sdbm_free_l(lua_State* L){
+  return 0;
+}
+
 void sdbm_update(uint8_t* in, size_t len, struct sdbm_hash* hash){
   for(int i = 0; i != len; i++){
     hash->hash = (uint64_t)*in + (hash->hash << 6) + (hash->hash << 16) - hash->hash;
diff --git a/src/hash/sha01.c b/src/hash/sha01.c
index 1711faa..f5478dd 100644
--- a/src/hash/sha01.c
+++ b/src/hash/sha01.c
@@ -23,10 +23,16 @@ struct sha01_hash sha01_init(uint8_t ver){
     return a;
 }
 
+int sha01_free_l(lua_State* L){
+  struct sha01_hash* h = lua_touserdata(L, -1);
+  free(h->buffer);
+  return 0;
+}
+
 struct sha01_hash sha01_init_l(uint8_t ver, lua_State* L){
     struct sha01_hash a = {.h0 = 0x67452301, .h1 = 0xEFCDAB89, .h2 = 0x98BADCFE, .h3 = 0x10325476, .h4 = 0xC3D2E1F0,
         .total = 0, .bufflen = 0, .version = ver};
-    a.buffer = lua_newuserdata(L, sizeof * a.buffer * bs);
+    a.buffer = calloc(sizeof * a.buffer, bs);
     memset(a.buffer, 0, bs);
     return a;
 }
@@ -182,7 +188,7 @@ lua_common_hash_clone_oargs(sha1, sha1, l_sha1_init(L), {
     memcpy(b->buffer, a->buffer, bs * sizeof * b->buffer);
 });
 
-lua_common_hash_init_ni(sha1, sha1, sha01_init_l(1, L));
+lua_common_hash_init_ni(sha1, sha1, sha01_init_l(1, L), sha01_free_l);
 lua_common_hash_update(sha1, sha1);
 
 //common_hash_clone(sha0);
@@ -192,7 +198,7 @@ lua_common_hash_clone_oargs(sha0, sha0, l_sha0_init(L), {
     b->buffer = old;
     memcpy(b->buffer, a->buffer, bs * sizeof * b->buffer);
 });
-lua_common_hash_init_ni(sha0, sha0, sha01_init_l(0, L));
+lua_common_hash_init_ni(sha0, sha0, sha01_init_l(0, L), sha01_free_l);
 lua_common_hash_update(sha0, sha0);
 
 int l_sha1_final(lua_State* L){
diff --git a/src/hash/sha2-256.c b/src/hash/sha2-256.c
index 42f6a81..de79d3f 100644
--- a/src/hash/sha2-256.c
+++ b/src/hash/sha2-256.c
@@ -108,10 +108,16 @@ struct sha512_hash sha512_t_init(struct iv sha_iv){
     return a;
 }
 
+int sha512_t_free_l(lua_State* L){
+  struct sha512_hash* h = lua_touserdata(L, -1);
+  free(h->buffer);
+  return 0;
+}
+
 struct sha512_hash sha512_t_init_l(struct iv sha_iv, lua_State* L){
     struct sha512_hash a = {.h0 = sha_iv.h0, .h1 = sha_iv.h1, .h2 = sha_iv.h2, .h3 = sha_iv.h3, .h4 = sha_iv.h4, .h5 = sha_iv.h5, .h6 = sha_iv.h6, .h7 = sha_iv.h7,
         .total = 0, .bufflen = 0};
-    a.buffer = lua_newuserdata(L, sizeof * a.buffer * bs);
+    a.buffer = calloc((sizeof * a.buffer), bs);
     memset(a.buffer, 0, bs);
     return a;
 }
@@ -124,6 +130,7 @@ struct sha512_hash sha384_init(){
     return sha512_t_init(sha384_iv);
 }
 
+char old[512];
 void sha512_update(uint8_t* input, size_t len, struct sha512_hash* hash){
   hash->total += len;
   size_t total_add = len + hash->bufflen;
@@ -131,6 +138,7 @@ void sha512_update(uint8_t* input, size_t len, struct sha512_hash* hash){
   if(total_add < bs){
     memcpy(hash->buffer + hash->bufflen, input, len);
     hash->bufflen += len;
+    memcpy(old, hash->buffer, hash->bufflen);
     return;
   }
 
@@ -252,7 +260,7 @@ lua_common_hash_clone_oargs(sha512, sha512, l_sha512_init(L), {
     b->buffer = old;
     memcpy(b->buffer, a->buffer, bs * sizeof * b->buffer);
 });
-lua_common_hash_init_ni(sha512, sha512, sha512_t_init_l(sha512_iv, L));
+lua_common_hash_init_ni(sha512, sha512, sha512_t_init_l(sha512_iv, L), sha512_t_free_l);
 lua_common_hash_update(sha512, sha512);
 
 int l_sha512_final(lua_State* L){
@@ -272,7 +280,7 @@ lua_common_hash_clone_oargs(sha384, sha384, l_sha384_init(L), {
     b->buffer = old;
     memcpy(b->buffer, a->buffer, bs * sizeof * b->buffer);
 });
-lua_common_hash_init_ni(sha384, sha384, sha512_t_init_l(sha384_iv, L));
+lua_common_hash_init_ni(sha384, sha384, sha512_t_init_l(sha384_iv, L), sha512_t_free_l);
 lua_common_hash_update(sha384, sha384);
 
 int l_sha384_final(lua_State* L){
@@ -309,7 +317,7 @@ int l_sha512_t_init(lua_State* L){
   *a = sha512_t_init_l(sha_iv_gen(tt), L);
   a->t = tt;
   
-  lua_common_hash_meta_def(sha512_t);
+  lua_common_hash_meta_def(sha512_t, sha512_t_free_l);
 
   lua_pushvalue(L, ud);
   return 1;
diff --git a/src/hash/sha2xx.c b/src/hash/sha2xx.c
index 1ef3f6f..c67e40d 100644
--- a/src/hash/sha2xx.c
+++ b/src/hash/sha2xx.c
@@ -12,10 +12,18 @@ struct sha256_hash sha256_init(){
     return a;
 }
 
+int sha256_free_l(lua_State* L){
+  struct sha256_hash* h = lua_touserdata(L, -1);
+  free(h->buffer);
+  return 0;
+}
+
+#define sha224_free_l sha256_free_l
+
 struct sha256_hash sha256_init_l(lua_State* L){
     struct sha256_hash a = {.h0 = 0x6a09e667, .h1 = 0xbb67ae85, .h2 = 0x3c6ef372, .h3 = 0xa54ff53a, .h4 = 0x510e527f, .h5 = 0x9b05688c, .h6 = 0x1f83d9ab, .h7 = 0x5be0cd19,
         .total = 0, .bufflen = 0};
-    a.buffer = lua_newuserdata(L, sizeof * a.buffer * bs);
+    a.buffer = calloc(sizeof * a.buffer, bs);
     memset(a.buffer, 0, bs);
     return a;
 }
diff --git a/src/hash/sysvchecksum.c b/src/hash/sysvchecksum.c
index 107a998..527bcc7 100644
--- a/src/hash/sysvchecksum.c
+++ b/src/hash/sysvchecksum.c
@@ -7,6 +7,10 @@ struct sysvchecksum_hash sysvchecksum_init(){
   return (struct sysvchecksum_hash){.check = 0};
 }
 
+int sysvchecksum_free_l(lua_State* L){
+  return 0;
+}
+
 void sysvchecksum_update(uint8_t* aa, size_t len, struct sysvchecksum_hash* hash){
   for(int i = 0; i != len; i++)
     hash->check += aa[i];
diff --git a/src/hash/xor.c b/src/hash/xor.c
index fab17d7..bca4d5b 100644
--- a/src/hash/xor.c
+++ b/src/hash/xor.c
@@ -6,6 +6,10 @@ struct xor8_hash xor8_init(){
   return (struct xor8_hash){.a = 0};
 }
 
+int xor8_free_l(lua_State* L){
+  return 0;
+}
+
 void xor8_update(uint8_t* aa, size_t len, struct xor8_hash* hash){
   for(int i = 0; i != len; i++)
     hash->a += aa[i] & 0xff;
diff --git a/src/lua.h b/src/lua.h
index 47d6757..9f28c06 100644
--- a/src/lua.h
+++ b/src/lua.h
@@ -1,6 +1,6 @@
-#include <lua5.4/lua.h>
-#include <lua5.4/lualib.h>
-#include <lua5.4/lauxlib.h>
+#include <lua.h>
+#include <lualib.h>
+#include <lauxlib.h>
 #include <stdlib.h>
 
 #ifndef __lua_h
@@ -76,9 +76,17 @@ int lua_assign_upvalues(lua_State* L, int fidx);
 int writer(lua_State*, const void*, size_t, void*);
 
 #if LUA_VERSION_NUM == 504
-    #define lua_objlen(L,i) lua_rawlen(L,(i))
+    #define lua_objlen lua_rawlen
 
     #define luaL_register(L, M, F) luaL_newlib(L, F);
+
+#elif LUA_VERSION_NUM == 503
+  #define lua_objlen lua_rawlen
+
+  #define luaL_register(L, M, F) luaL_newlib(L, F);
+
+  #define lua_gc(A, B) lua_gc(A, B, 0)
+
 #elif LUA_VERSION_NUM == 501
     #define luaL_tolstring lua_tolstring
     
@@ -88,7 +96,7 @@ int writer(lua_State*, const void*, size_t, void*);
 
     #define lua_gc(A, B) lua_gc(A, B, 0)
 
-    #define lua_pushglobaltable(L) {lua_getglobal(L, "_G");}
+    #define lua_pushglobaltable(L) {lua_getglobal(L, "_G");if(lua_isnil(L, -1)){lua_newtable(L);lua_setglobal(L, "_G");lua_getglobal(L, "_G");}}
 #endif
 
 
diff --git a/src/thread.c b/src/thread.c
index f205165..a5eb892 100644
--- a/src/thread.c
+++ b/src/thread.c
@@ -327,6 +327,11 @@ int meta_proxy(lua_State* L){
   //printf("%i\n",count);
   lua_call(buffer->L, count + 1, 1);
   luaI_deepcopy(buffer->L, L, 0);
+
+  lua_pushnil(buffer->L);
+  lua_setmetatable(buffer->L, -2);
+
+  lua_settop(buffer->L, 1);
   //printf("%p\n", lua_topointer(buffer->L, -1));
   return 1;
 }
@@ -349,8 +354,8 @@ void meta_proxy_gen(lua_State* L, struct thread_buffer *buffer, int meta_idx, in
 
     char* fn = calloc(128, sizeof * fn); 
     const char* key = lua_tostring(L, k);
-    sprintf(fn, "return function(_a,_b,_c)\
-return __proxy_call(__this_obj,'%s',__unpack({_a,_b,_c}));end", key);
+    sprintf(fn, "return function(...)\
+return __proxy_call(__this_obj,'%s',...);end", key);
     luaL_dostring(L, fn);
 
     free(fn);
diff --git a/tests/hash.lua b/tests/hash.lua
index d314167..898b0e6 100644
--- a/tests/hash.lua
+++ b/tests/hash.lua
@@ -2,6 +2,10 @@ llib = require "lullaby"
 
 --llib.io.log = function() end
 
+if table.unpack == nil then
+  table.unpack = llib.array.unpack
+end
+
 local hashes_working = 0
 local hashes_failed = 0
 local functions_working = 0
-- 
cgit v1.2.3