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

---
 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 ++++
 19 files changed, 142 insertions(+), 29 deletions(-)

(limited to 'src/hash')

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;
-- 
cgit v1.2.3