crypto: xxhash

nalgeon · nalgeon · commit e5d5e74b978f · 2025-08-31T22:59:17.000+05:00
diff --git a/Makefile b/Makefile
@@ -28,7 +28,8 @@ download-sqlite:
 	mv sqlite-amalgamation-$(SQLITE_VERSION)/* src
 
 download-external:
-	curl -L https://github.com/mackyle/sqlite/raw/branch-$(SQLITE_BRANCH)/src/test_windirent.h --output src/test_windirent.h
+	curl -L --silent https://github.com/mackyle/sqlite/raw/branch-$(SQLITE_BRANCH)/src/test_windirent.h --output src/test_windirent.h
+	curl -L --silent https://github.com/cyan4973/xxhash/raw/v0.8.3/xxhash.h --output src/crypto/xxhash.impl.h
 
 compile-linux:
 	$(CC) -O1 $(LINIX_FLAGS) src/sqlite3-crypto.c src/crypto/*.c -o dist/crypto.so
diff --git a/docs/crypto.md b/docs/crypto.md
@@ -15,7 +15,11 @@ Each hash function expects `data` to be TEXT or BLOB. Returns a BLOB hash. Use t
 [sha1](#crypto_sha1) •
 [sha256](#crypto_sha256) •
 [sha384](#crypto_sha384) •
-[sha512](#crypto_sha512)
+[sha512](#crypto_sha512) •
+[xxh32](#crypto_xxh32) •
+[xxh64](#crypto_xxh64) •
+[xxh3_64](#crypto_xxh3_64) •
+[xxh3_128](#crypto_xxh3_128)
 
 ### crypto_blake3
 
@@ -95,6 +99,58 @@ select hex(crypto_sha512('abc'));
 -- DDAF35A193617ABACC417349AE20413112E6FA4E89A97EA20A9EEEE64B55D39A2192992A274FC1A836BA3C23A3FEEBBD454D4423643CE80E2A9AC94FA54CA49F
 ```
 
+### crypto_xxh32
+
+```text
+crypto_xxh32(data)
+```
+
+Returns a XXH32 hash of the data as a blob.
+
+```sql
+select hex(crypto_xxh32('abc'));
+-- 32D153FF
+```
+
+### crypto_xx64
+
+```text
+crypto_xx64(data)
+```
+
+Returns a XXH64 hash of the data as a blob.
+
+```sql
+select hex(crypto_xx64('abc'));
+-- 44BC2CF5AD770999
+```
+
+### crypto_xxh3_64
+
+```text
+crypto_xxh3_64(data)
+```
+
+Returns a XXH3_64 hash of the data as a blob.
+
+```sql
+select hex(crypto_xxh3_64('abc'));
+-- 78AF5F94892F3950
+```
+
+### crypto_xxh3_128
+
+```text
+crypto_xxh3_128(data)
+```
+
+Returns a XXH3_128 hash of the data as a blob.
+
+```sql
+select hex(crypto_xxh3_128('abc'));
+-- 06B05AB6733A618578AF5F94892F3950
+```
+
 ## Encoding and decoding functions
 
 ```text
diff --git a/src/crypto/extension.c b/src/crypto/extension.c
@@ -20,6 +20,7 @@ SQLITE_EXTENSION_INIT3
 #include "crypto/sha1.h"
 #include "crypto/sha2.h"
 #include "crypto/url.h"
+#include "crypto/xxhash.h"
 
 // encoder/decoder function
 typedef uint8_t* (*encdec_fn)(const uint8_t* src, size_t len, size_t* out_len);
@@ -56,6 +57,30 @@ static void crypto_hash(sqlite3_context* context, int argc, sqlite3_value** argv
             final_func = (void*)md5_final;
             algo = 1;
             break;
+        case 1032: /* XXH32 */
+            init_func = (void*)xxh32_init;
+            update_func = (void*)xxh32_update;
+            final_func = (void*)xxh32_final;
+            algo = 1;
+            break;
+        case 1064: /* XXH64 */
+            init_func = (void*)xxh64_init;
+            update_func = (void*)xxh64_update;
+            final_func = (void*)xxh64_final;
+            algo = 1;
+            break;
+        case 3064: /* XXH3 64-bit */
+            init_func = (void*)xxh3_64_init;
+            update_func = (void*)xxh3_64_update;
+            final_func = (void*)xxh3_64_final;
+            algo = 1;
+            break;
+        case 3128: /* XXH3 128-bit */
+            init_func = (void*)xxh3_128_init;
+            update_func = (void*)xxh3_128_update;
+            final_func = (void*)xxh3_128_final;
+            algo = 1;
+            break;
         case 2256: /* SHA2-256 */
             init_func = (void*)sha256_init;
             update_func = (void*)sha256_update;
@@ -216,6 +241,14 @@ int crypto_init(sqlite3* db) {
     sqlite3_create_function(db, "sha384", 1, flags, (void*)2384, crypto_hash, 0, 0);
     sqlite3_create_function(db, "crypto_sha512", 1, flags, (void*)2512, crypto_hash, 0, 0);
     sqlite3_create_function(db, "sha512", 1, flags, (void*)2512, crypto_hash, 0, 0);
+    sqlite3_create_function(db, "crypto_xxh32", 1, flags, (void*)1032, crypto_hash, 0, 0);
+    sqlite3_create_function(db, "xxh32", 1, flags, (void*)1032, crypto_hash, 0, 0);
+    sqlite3_create_function(db, "crypto_xxh64", 1, flags, (void*)1064, crypto_hash, 0, 0);
+    sqlite3_create_function(db, "xxh64", 1, flags, (void*)1064, crypto_hash, 0, 0);
+    sqlite3_create_function(db, "crypto_xxh3_64", 1, flags, (void*)3064, crypto_hash, 0, 0);
+    sqlite3_create_function(db, "xxh3_64", 1, flags, (void*)3064, crypto_hash, 0, 0);
+    sqlite3_create_function(db, "crypto_xxh3_128", 1, flags, (void*)3128, crypto_hash, 0, 0);
+    sqlite3_create_function(db, "xxh3_128", 1, flags, (void*)3128, crypto_hash, 0, 0);
 
     sqlite3_create_function(db, "crypto_encode", 2, flags, 0, crypto_encode, 0, 0);
     sqlite3_create_function(db, "encode", 2, flags, 0, crypto_encode, 0, 0);
diff --git a/src/crypto/xxhash.c b/src/crypto/xxhash.c
@@ -0,0 +1,111 @@
+// Copyright (c) 2025 Anton Zhiyanov, MIT License
+// https://github.com/nalgeon/sqlean
+
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#define XXH_STATIC_LINKING_ONLY
+#define XXH_IMPLEMENTATION
+#include "crypto/xxhash.h"
+#include "crypto/xxhash.impl.h"
+
+#define XXH32_DIGEST_LENGTH 4
+#define XXH64_DIGEST_LENGTH 8
+#define XXH128_DIGEST_LENGTH 16
+
+// XXH32.
+
+void* xxh32_init() {
+    XXH32_state_t* ctx = XXH32_createState();
+    if (!ctx) {
+        return NULL;
+    }
+    XXH32_reset(ctx, 0);
+    return ctx;
+}
+
+void xxh32_update(XXH32_state_t* ctx, const void* data, size_t len) {
+    XXH32_update(ctx, data, len);
+}
+
+int xxh32_final(XXH32_state_t* ctx, uint8_t* hash) {
+    XXH32_hash_t digest = XXH32_digest(ctx);
+    XXH32_canonical_t cano;
+    XXH32_canonicalFromHash(&cano, digest);
+    memcpy(hash, cano.digest, XXH32_DIGEST_LENGTH);
+    XXH32_freeState(ctx);
+    return XXH32_DIGEST_LENGTH;
+}
+
+// XXH64.
+
+void* xxh64_init() {
+    XXH64_state_t* ctx = XXH64_createState();
+    if (!ctx) {
+        return NULL;
+    }
+    XXH64_reset(ctx, 0);
+    return ctx;
+}
+
+void xxh64_update(XXH64_state_t* ctx, const void* data, size_t len) {
+    XXH64_update(ctx, data, len);
+}
+
+int xxh64_final(XXH64_state_t* ctx, uint8_t* hash) {
+    XXH64_hash_t digest = XXH64_digest(ctx);
+    XXH64_canonical_t cano;
+    XXH64_canonicalFromHash(&cano, digest);
+    memcpy(hash, cano.digest, XXH64_DIGEST_LENGTH);
+    XXH64_freeState(ctx);
+    return XXH64_DIGEST_LENGTH;
+}
+
+// XXH3 64-bit.
+
+void* xxh3_64_init() {
+    XXH3_state_t* ctx = XXH3_createState();
+    if (!ctx) {
+        return NULL;
+    }
+    XXH3_64bits_reset(ctx);
+    return ctx;
+}
+
+void xxh3_64_update(XXH3_state_t* ctx, const void* data, size_t len) {
+    XXH3_64bits_update(ctx, data, len);
+}
+
+int xxh3_64_final(XXH3_state_t* ctx, uint8_t* hash) {
+    uint64_t digest = XXH3_64bits_digest(ctx);
+    XXH64_canonical_t cano;
+    XXH64_canonicalFromHash(&cano, digest);
+    memcpy(hash, cano.digest, XXH64_DIGEST_LENGTH);
+    XXH3_freeState(ctx);
+    return XXH64_DIGEST_LENGTH;
+}
+
+// XXH3 128-bit.
+
+void* xxh3_128_init() {
+    XXH3_state_t* ctx = XXH3_createState();
+    if (!ctx) {
+        return NULL;
+    }
+    XXH3_128bits_reset(ctx);
+    return ctx;
+}
+
+void xxh3_128_update(XXH3_state_t* ctx, const void* data, size_t len) {
+    XXH3_128bits_update(ctx, data, len);
+}
+
+int xxh3_128_final(XXH3_state_t* ctx, uint8_t* hash) {
+    XXH128_hash_t digest = XXH3_128bits_digest(ctx);
+    XXH128_canonical_t cano;
+    XXH128_canonicalFromHash(&cano, digest);
+    memcpy(hash, cano.digest, XXH128_DIGEST_LENGTH);
+    XXH3_freeState(ctx);
+    return XXH128_DIGEST_LENGTH;
+}
diff --git a/src/crypto/xxhash.h b/src/crypto/xxhash.h
@@ -0,0 +1,28 @@
+// Copyright (c) 2025 Anton Zhiyanov, MIT License
+// https://github.com/nalgeon/sqlean
+
+#ifndef __XXHASH3_H__
+#define __XXHASH3_H__
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "crypto/xxhash.impl.h"
+
+void* xxh32_init();
+void xxh32_update(XXH32_state_t* ctx, const void* data, size_t len);
+int xxh32_final(XXH32_state_t* ctx, uint8_t* hash);
+
+void* xxh64_init();
+void xxh64_update(XXH64_state_t* ctx, const void* data, size_t len);
+int xxh64_final(XXH64_state_t* ctx, uint8_t* hash);
+
+void* xxh3_64_init();
+void xxh3_64_update(XXH3_state_t* ctx, const void* data, size_t len);
+int xxh3_64_final(XXH3_state_t* ctx, uint8_t* hash);
+
+void* xxh3_128_init();
+void xxh3_128_update(XXH3_state_t* ctx, const void* data, size_t len);
+int xxh3_128_final(XXH3_state_t* ctx, uint8_t* hash);
+
+#endif
diff --git a/test/crypto.sql b/test/crypto.sql
@@ -147,3 +147,23 @@ select '15_09', crypto_decode('<+ohcEHPu*CER),Dg-(An=QS8+DQ%9E-!.?G%G\:0f''qg@=!
 select '16_01', crypto_blake3(null) is NULL;
 select '16_02', hex(crypto_blake3('')) = upper('af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262');
 select '16_03', hex(crypto_blake3('abc')) = upper('6437b3ac38465133ffb63b75273a8db548c558465d79db03fd359c6cd5bd9d85');
+
+select '17_01', crypto_xxh32(null) is NULL;
+select '17_02', hex(crypto_xxh32('')) = '02CC5D05';
+select '17_03', hex(crypto_xxh32('abc')) = '32D153FF';
+select '17_04', hex(crypto_xxh32('The quick brown 🦊 jumps over 13 lazy 🐶.')) = '2C4A0402';
+
+select '18_01', crypto_xxh64(null) is NULL;
+select '18_02', hex(crypto_xxh64('')) = 'EF46DB3751D8E999';
+select '18_03', hex(crypto_xxh64('abc')) = '44BC2CF5AD770999';
+select '18_04', hex(crypto_xxh64('The quick brown 🦊 jumps over 13 lazy 🐶.')) = '1ED3E109F48F652C';
+
+select '19_01', crypto_xxh3_64(null) is NULL;
+select '19_02', hex(crypto_xxh3_64('')) = '2D06800538D394C2';
+select '19_03', hex(crypto_xxh3_64('abc')) = '78AF5F94892F3950';
+select '19_04', hex(crypto_xxh3_64('The quick brown 🦊 jumps over 13 lazy 🐶.')) = '09A3FF1CBDB28B84';
+
+select '20_01', crypto_xxh3_128(null) is NULL;
+select '20_02', hex(crypto_xxh3_128('')) = '99AA06D3014798D86001C324468D497F';
+select '20_03', hex(crypto_xxh3_128('abc')) = '06B05AB6733A618578AF5F94892F3950';
+select '20_04', hex(crypto_xxh3_128('The quick brown 🦊 jumps over 13 lazy 🐶.')) = 'E688EC7B9C40A08C87C989C0484E449E';
