diff -r 0f1349ffa719 -r 03982275f29b libidav/crypto.c
--- a/libidav/crypto.c	Tue Apr 01 20:30:02 2025 +0200
+++ b/libidav/crypto.c	Tue Apr 01 21:48:14 2025 +0200
@@ -66,7 +66,7 @@
 
 AESDecrypter* aes_decrypter_new(DavKey *key, void *stream, dav_write_func write_func) {
     AESDecrypter *dec = calloc(1, sizeof(AESDecrypter));
-    SHA256_Init(&dec->sha256);
+    dav_sha256_init(&dec->sha256);
     dec->stream = stream;
     dec->write = write_func;
     dec->key = key;
@@ -122,7 +122,7 @@
     unsigned char *out = malloc(outlen);
     EVP_DecryptUpdate(dec->ctx, out, &outlen, buf, len);
     ssize_t wlen = dec->write(out, 1, outlen, dec->stream);
-    SHA256_Update(&dec->sha256, out, wlen);
+    dav_sha256_update(&dec->sha256, out, wlen);
     free(out);
     return (s*n) / s;
 }
@@ -133,7 +133,7 @@
         int len = 0;
         EVP_DecryptFinal_ex(dec->ctx, out, &len);
         dec->write(out, 1, len, dec->stream);
-        SHA256_Update(&dec->sha256, out, len);
+        dav_sha256_update(&dec->sha256, out, len);
         free(out);
         //EVP_CIPHER_CTX_cleanup(&dec->ctx);
         EVP_CIPHER_CTX_free(dec->ctx);
@@ -153,7 +153,7 @@
     }
     
     AESEncrypter *enc = malloc(sizeof(AESEncrypter));
-    SHA256_Init(&enc->sha256);
+    dav_sha256_init(&enc->sha256);
     enc->stream = stream;
     enc->read = read_func;
     enc->seek = seek_func;
@@ -200,7 +200,7 @@
     void *in = malloc(len);
     size_t in_len = enc->read(in, 1, len, enc->stream);
     
-    SHA256_Update(&enc->sha256, in, in_len);
+    dav_sha256_update(&enc->sha256, in, in_len);
     
     unsigned char *out = NULL;
     int outlen = 0;
@@ -357,33 +357,56 @@
 
 
 void dav_get_hash(DAV_SHA_CTX *sha256, unsigned char *buf){
-    SHA256_Final((unsigned char*)buf, sha256);
+    dav_sha256_final(sha256, (unsigned char*)buf);
 }
 
 char* dav_create_hash(const char *data, size_t len) {
     unsigned char hash[DAV_SHA256_DIGEST_LENGTH];
     DAV_SHA_CTX ctx;
-    SHA256_Init(&ctx);
-    SHA256_Update(&ctx, data, len);
-    SHA256_Final(hash, &ctx);
+    dav_sha256_init(&ctx);
+    dav_sha256_update(&ctx, data, len);
+    dav_sha256_final(&ctx, hash);
     return util_hexstr(hash, DAV_SHA256_DIGEST_LENGTH);
 }
 
-DAV_SHA_CTX* dav_hash_init(void) {
+DAV_SHA_CTX* dav_sha256_create(void) {
     DAV_SHA_CTX *ctx = malloc(sizeof(DAV_SHA_CTX));
-    SHA256_Init(ctx);
+    dav_sha256_init(ctx);
     return ctx;
 }
 
-void dav_hash_update(DAV_SHA_CTX *ctx, const char *data, size_t len) {
-    SHA256_Update(ctx, data, len);
+#if OPENSSL_VERSION_NUMBER < 0x30000000L
+
+void dav_sha256_init(DAV_SHA_CTX *ctx) {
+    SHA256_Init(ctx);
+}
+
+void dav_sha256_update(DAV_SHA_CTX *ctx, const void *data, size_t length) {
+    SHA256_Update(ctx, data, length);
+}
+
+void dav_sha256_final(char *md, DAV_SHA_CTX *ctx) {
+    SHA256_Final(md, ctx);
 }
 
-void dav_hash_final(DAV_SHA_CTX *ctx, unsigned char *buf) {
-    SHA256_Final(buf, ctx);
-    free(ctx);
+#else
+
+void dav_sha256_init(DAV_SHA_CTX *ctx) {
+    EVP_MD_CTX *mdctx = EVP_MD_CTX_new();
+    EVP_DigestInit_ex(mdctx, EVP_sha256(), NULL);
+    *ctx = mdctx;
 }
 
+void dav_sha256_update(DAV_SHA_CTX *ctx, const char *data, size_t length) {
+    EVP_DigestUpdate(*ctx, data, length);
+}
+
+void dav_sha256_final(DAV_SHA_CTX *ctx, unsigned char *md) {
+    EVP_DigestFinal(*ctx, md, NULL);
+}
+
+#endif
+
 #if OPENSSL_VERSION_NUMBER < 0x10100000L
 static int crypto_pw2key_error = 0;
 DavKey* dav_pw2key(const char *password, const unsigned char *salt, int saltlen, int pwfunc, int enc) {
@@ -819,17 +842,17 @@
     return util_hexstr(hash, DAV_SHA256_DIGEST_LENGTH);
 }
 
-DAV_SHA_CTX* dav_hash_init(void) {
+DAV_SHA_CTX* dav_sha256_create(void) {
     DAV_SHA_CTX *ctx = malloc(sizeof(DAV_SHA_CTX));
     CC_SHA256_Init(ctx);
     return ctx;
 }
 
-void dav_hash_update(DAV_SHA_CTX *ctx, const char *data, size_t len) {
+void dav_sha256_update(DAV_SHA_CTX *ctx, const char *data, size_t len) {
     CC_SHA256_Update(ctx, data, len);
 }
 
-void dav_hash_final(DAV_SHA_CTX *ctx, unsigned char *buf) {
+void dav_sha256_final(DAV_SHA_CTX *ctx, unsigned char *buf) {
     CC_SHA256_Final(buf, ctx);
     free(ctx);
 }
@@ -1396,15 +1419,15 @@
 
 char* dav_create_hash(const char *data, size_t len) {
     unsigned char hash[DAV_SHA256_DIGEST_LENGTH];
-    DAV_SHA_CTX *ctx = dav_hash_init();
+    DAV_SHA_CTX *ctx = dav_sha256_create();
     if(ctx) {
-        dav_hash_update(ctx, data, len);
-        dav_hash_final(ctx, hash);
+        dav_sha256_update(ctx, data, len);
+        dav_sha256_final(ctx, hash);
     }
     return util_hexstr(hash, DAV_SHA256_DIGEST_LENGTH);
 }
 
-DAV_SHA_CTX* dav_hash_init(void) {
+DAV_SHA_CTX* dav_sha256_create(void) {
     DAV_SHA_CTX *ctx = malloc(sizeof(DAV_SHA_CTX));
     if(!ctx) {
         return NULL;
@@ -1416,11 +1439,11 @@
     return ctx;
 }
 
-void dav_hash_update(DAV_SHA_CTX *ctx, const char *data, size_t len) {
+void dav_sha256_update(DAV_SHA_CTX *ctx, const char *data, size_t len) {
     BCryptHashData(ctx->hHash, (PUCHAR)data, len, 0);
 }
 
-void dav_hash_final(DAV_SHA_CTX *ctx, unsigned char *buf) {
+void dav_sha256_final(DAV_SHA_CTX *ctx, unsigned char *buf) {
     BCryptFinishHash(ctx->hHash, (PUCHAR)buf, DAV_SHA256_DIGEST_LENGTH, 0);
     
     // cleanup