From e4464a1c559ce52b18dae923c543954ca27deb95 Mon Sep 17 00:00:00 2001 From: Farhan Saiyed Date: Fri, 6 Mar 2026 19:47:59 +0530 Subject: [PATCH] blake2 hash support (#5995) --- doc/PACKAGERS.md | 1 + librz/hash/meson.build | 14 +++- librz/hash/p/algo_blake2b.c | 83 +++++++++++++++++++++ librz/hash/p/algo_blake2bp.c | 83 +++++++++++++++++++++ librz/hash/p/algo_blake2s.c | 83 +++++++++++++++++++++ librz/hash/p/algo_blake2sp.c | 83 +++++++++++++++++++++ librz/hash/p/algo_blake2xb.c | 83 +++++++++++++++++++++ librz/hash/p/algo_blake2xs.c | 83 +++++++++++++++++++++ meson.build | 3 + meson_options.txt | 1 + subprojects/blake2.wrap | 5 ++ subprojects/packagefiles/blake2/meson.build | 29 +++++++ test/db/cmd/cmd_list | 20 ++++- test/db/tools/rz_hash | 60 +++++++++++++++ test/unit/test_hash.c | 6 ++ 15 files changed, 635 insertions(+), 2 deletions(-) create mode 100644 librz/hash/p/algo_blake2b.c create mode 100644 librz/hash/p/algo_blake2bp.c create mode 100644 librz/hash/p/algo_blake2s.c create mode 100644 librz/hash/p/algo_blake2sp.c create mode 100644 librz/hash/p/algo_blake2xb.c create mode 100644 librz/hash/p/algo_blake2xs.c create mode 100644 subprojects/blake2.wrap create mode 100644 subprojects/packagefiles/blake2/meson.build diff --git a/doc/PACKAGERS.md b/doc/PACKAGERS.md index 8341f9f860..93c248bc0b 100644 --- a/doc/PACKAGERS.md +++ b/doc/PACKAGERS.md @@ -87,6 +87,7 @@ At the time of writing, these are: * `use_sys_tree_sitter` * `use_sys_softfloat` * `use_sys_zydis` +* `use_sys_blake2` * `use_sys_blake3` See [meson_options.txt][] for a complete list of compile-time options. diff --git a/librz/hash/meson.build b/librz/hash/meson.build index 860e388a90..7dbb976364 100644 --- a/librz/hash/meson.build +++ b/librz/hash/meson.build @@ -14,6 +14,12 @@ hash_plugins_list = [ 'keccak_384', 'keccak_512', 'sm3', + 'blake2b', + 'blake2bp', + 'blake2xb', + 'blake2s', + 'blake2sp', + 'blake2xs', 'blake3', 'fletcher8', 'fletcher16', @@ -94,6 +100,12 @@ rz_hash_sources = [ 'p/algo_crca.c', 'p/algo_adler32.c', 'p/algo_fletcher.c', + 'p/algo_blake2b.c', + 'p/algo_blake2bp.c', + 'p/algo_blake2xb.c', + 'p/algo_blake2s.c', + 'p/algo_blake2sp.c', + 'p/algo_blake2xs.c', 'p/algo_blake3.c', 'p/algo_sm3.c', 'p/algo_md2.c', @@ -132,7 +144,7 @@ rz_hash_sources = [ 'algorithms/sha3/sha3.c' ] -dependencies = [mth, rz_util_dep, xxhash_dep, blake3_dep] +dependencies = [mth, rz_util_dep, xxhash_dep, blake3_dep, blake2_dep] if sys_openssl.found() dependencies += [sys_openssl] diff --git a/librz/hash/p/algo_blake2b.c b/librz/hash/p/algo_blake2b.c new file mode 100644 index 0000000000..fc3c242b16 --- /dev/null +++ b/librz/hash/p/algo_blake2b.c @@ -0,0 +1,83 @@ +// SPDX-FileCopyrightText: 2026 Farhan-25 +// SPDX-License-Identifier: LGPL-3.0-only + +#include +#include +#include + +/** + * This file implements RzHashPlugin for BLAKE2b: + * - blake2b : sequential, 64-bit optimised, up to 512-bit digest + */ + +static void *plugin_blake2b_context_new(void) { + return RZ_NEW0(blake2b_state); +} + +static void plugin_blake2b_context_free(void *context) { + free(context); +} + +static RzHashSize plugin_blake2b_digest_size(void *context) { + return BLAKE2B_OUTBYTES; +} + +static RzHashSize plugin_blake2b_block_size(void *context) { + return BLAKE2B_BLOCKBYTES; +} + +static bool plugin_blake2b_init(void *context) { + rz_return_val_if_fail(context, false); + return blake2b_init((blake2b_state *)context, BLAKE2B_OUTBYTES) == 0; +} + +static bool plugin_blake2b_update(void *context, const ut8 *data, ut64 size) { + rz_return_val_if_fail(context && data, false); + return blake2b_update((blake2b_state *)context, data, size) == 0; +} + +static bool plugin_blake2b_final(void *context, ut8 *digest) { + rz_return_val_if_fail(context && digest, false); + return blake2b_final((blake2b_state *)context, digest, BLAKE2B_OUTBYTES) == 0; +} + +static bool plugin_blake2b_small_block(const ut8 *data, ut64 size, ut8 **digest, RzHashSize *digest_size) { + rz_return_val_if_fail(data && digest, false); + ut8 *dgst = malloc(BLAKE2B_OUTBYTES); + if (!dgst) { + return false; + } + if (blake2b(dgst, BLAKE2B_OUTBYTES, data, size, NULL, 0) < 0) { + free(dgst); + return false; + } + *digest = dgst; + if (digest_size) { + *digest_size = BLAKE2B_OUTBYTES; + } + return true; +} + +RzHashPlugin rz_hash_plugin_blake2b = { + .name = "blake2b", + .license = "LGPL3", + .author = "Farhan-25", + .description = "BLAKE2b cryptographic hash", + .support_hmac = false, + .context_new = plugin_blake2b_context_new, + .context_free = plugin_blake2b_context_free, + .digest_size = plugin_blake2b_digest_size, + .block_size = plugin_blake2b_block_size, + .init = plugin_blake2b_init, + .update = plugin_blake2b_update, + .final = plugin_blake2b_final, + .small_block = plugin_blake2b_small_block, +}; + +#ifndef RZ_PLUGIN_INCORE +RZ_API RzLibStruct rizin_plugin_blake2b = { + .type = RZ_LIB_TYPE_HASH, + .data = &rz_hash_plugin_blake2b, + .version = RZ_VERSION +}; +#endif \ No newline at end of file diff --git a/librz/hash/p/algo_blake2bp.c b/librz/hash/p/algo_blake2bp.c new file mode 100644 index 0000000000..10e26ba45e --- /dev/null +++ b/librz/hash/p/algo_blake2bp.c @@ -0,0 +1,83 @@ +// SPDX-FileCopyrightText: 2026 Farhan-25 +// SPDX-License-Identifier: LGPL-3.0-only + +#include +#include +#include + +/** + * This file implements RzHashPlugin for BLAKE2bp: + * - blake2bp : parallel (4-lane) blake2b, up to 512-bit digest + */ + +static void *plugin_blake2bp_context_new(void) { + return RZ_NEW0(blake2bp_state); +} + +static void plugin_blake2bp_context_free(void *context) { + free(context); +} + +static RzHashSize plugin_blake2bp_digest_size(void *context) { + return BLAKE2B_OUTBYTES; +} + +static RzHashSize plugin_blake2bp_block_size(void *context) { + return BLAKE2B_BLOCKBYTES; +} + +static bool plugin_blake2bp_init(void *context) { + rz_return_val_if_fail(context, false); + return blake2bp_init((blake2bp_state *)context, BLAKE2B_OUTBYTES) == 0; +} + +static bool plugin_blake2bp_update(void *context, const ut8 *data, ut64 size) { + rz_return_val_if_fail(context && data, false); + return blake2bp_update((blake2bp_state *)context, data, size) == 0; +} + +static bool plugin_blake2bp_final(void *context, ut8 *digest) { + rz_return_val_if_fail(context && digest, false); + return blake2bp_final((blake2bp_state *)context, digest, BLAKE2B_OUTBYTES) == 0; +} + +static bool plugin_blake2bp_small_block(const ut8 *data, ut64 size, ut8 **digest, RzHashSize *digest_size) { + rz_return_val_if_fail(data && digest, false); + ut8 *dgst = malloc(BLAKE2B_OUTBYTES); + if (!dgst) { + return false; + } + if (blake2bp(dgst, BLAKE2B_OUTBYTES, data, size, NULL, 0) < 0) { + free(dgst); + return false; + } + *digest = dgst; + if (digest_size) { + *digest_size = BLAKE2B_OUTBYTES; + } + return true; +} + +RzHashPlugin rz_hash_plugin_blake2bp = { + .name = "blake2bp", + .license = "LGPL3", + .author = "Farhan-25", + .description = "BLAKE2bp cryptographic hash", + .support_hmac = false, + .context_new = plugin_blake2bp_context_new, + .context_free = plugin_blake2bp_context_free, + .digest_size = plugin_blake2bp_digest_size, + .block_size = plugin_blake2bp_block_size, + .init = plugin_blake2bp_init, + .update = plugin_blake2bp_update, + .final = plugin_blake2bp_final, + .small_block = plugin_blake2bp_small_block, +}; + +#ifndef RZ_PLUGIN_INCORE +RZ_API RzLibStruct rizin_plugin_blake2bp = { + .type = RZ_LIB_TYPE_HASH, + .data = &rz_hash_plugin_blake2bp, + .version = RZ_VERSION +}; +#endif \ No newline at end of file diff --git a/librz/hash/p/algo_blake2s.c b/librz/hash/p/algo_blake2s.c new file mode 100644 index 0000000000..f166ac9558 --- /dev/null +++ b/librz/hash/p/algo_blake2s.c @@ -0,0 +1,83 @@ +// SPDX-FileCopyrightText: 2026 Farhan-25 +// SPDX-License-Identifier: LGPL-3.0-only + +#include +#include +#include + +/** + * This file implements RzHashPlugin for BLAKE2s: + * - blake2s : sequential, 32-bit optimised, up to 256-bit digest + */ + +static void *plugin_blake2s_context_new(void) { + return RZ_NEW0(blake2s_state); +} + +static void plugin_blake2s_context_free(void *context) { + free(context); +} + +static RzHashSize plugin_blake2s_digest_size(void *context) { + return BLAKE2S_OUTBYTES; +} + +static RzHashSize plugin_blake2s_block_size(void *context) { + return BLAKE2S_BLOCKBYTES; +} + +static bool plugin_blake2s_init(void *context) { + rz_return_val_if_fail(context, false); + return blake2s_init((blake2s_state *)context, BLAKE2S_OUTBYTES) == 0; +} + +static bool plugin_blake2s_update(void *context, const ut8 *data, ut64 size) { + rz_return_val_if_fail(context && data, false); + return blake2s_update((blake2s_state *)context, data, size) == 0; +} + +static bool plugin_blake2s_final(void *context, ut8 *digest) { + rz_return_val_if_fail(context && digest, false); + return blake2s_final((blake2s_state *)context, digest, BLAKE2S_OUTBYTES) == 0; +} + +static bool plugin_blake2s_small_block(const ut8 *data, ut64 size, ut8 **digest, RzHashSize *digest_size) { + rz_return_val_if_fail(data && digest, false); + ut8 *dgst = malloc(BLAKE2S_OUTBYTES); + if (!dgst) { + return false; + } + if (blake2s(dgst, BLAKE2S_OUTBYTES, data, size, NULL, 0) < 0) { + free(dgst); + return false; + } + *digest = dgst; + if (digest_size) { + *digest_size = BLAKE2S_OUTBYTES; + } + return true; +} + +RzHashPlugin rz_hash_plugin_blake2s = { + .name = "blake2s", + .license = "LGPL3", + .author = "Farhan-25", + .description = "BLAKE2s cryptographic hash", + .support_hmac = false, + .context_new = plugin_blake2s_context_new, + .context_free = plugin_blake2s_context_free, + .digest_size = plugin_blake2s_digest_size, + .block_size = plugin_blake2s_block_size, + .init = plugin_blake2s_init, + .update = plugin_blake2s_update, + .final = plugin_blake2s_final, + .small_block = plugin_blake2s_small_block, +}; + +#ifndef RZ_PLUGIN_INCORE +RZ_API RzLibStruct rizin_plugin_blake2s = { + .type = RZ_LIB_TYPE_HASH, + .data = &rz_hash_plugin_blake2s, + .version = RZ_VERSION +}; +#endif \ No newline at end of file diff --git a/librz/hash/p/algo_blake2sp.c b/librz/hash/p/algo_blake2sp.c new file mode 100644 index 0000000000..b9ad863e93 --- /dev/null +++ b/librz/hash/p/algo_blake2sp.c @@ -0,0 +1,83 @@ +// SPDX-FileCopyrightText: 2026 Farhan-25 +// SPDX-License-Identifier: LGPL-3.0-only + +#include +#include +#include + +/** + * This file implements RzHashPlugin for BLAKE2sp: + * - blake2sp : parallel (8-lane) blake2s, up to 256-bit digest + */ + +static void *plugin_blake2sp_context_new(void) { + return RZ_NEW0(blake2sp_state); +} + +static void plugin_blake2sp_context_free(void *context) { + free(context); +} + +static RzHashSize plugin_blake2sp_digest_size(void *context) { + return BLAKE2S_OUTBYTES; +} + +static RzHashSize plugin_blake2sp_block_size(void *context) { + return BLAKE2S_BLOCKBYTES; +} + +static bool plugin_blake2sp_init(void *context) { + rz_return_val_if_fail(context, false); + return blake2sp_init((blake2sp_state *)context, BLAKE2S_OUTBYTES) == 0; +} + +static bool plugin_blake2sp_update(void *context, const ut8 *data, ut64 size) { + rz_return_val_if_fail(context && data, false); + return blake2sp_update((blake2sp_state *)context, data, size) == 0; +} + +static bool plugin_blake2sp_final(void *context, ut8 *digest) { + rz_return_val_if_fail(context && digest, false); + return blake2sp_final((blake2sp_state *)context, digest, BLAKE2S_OUTBYTES) == 0; +} + +static bool plugin_blake2sp_small_block(const ut8 *data, ut64 size, ut8 **digest, RzHashSize *digest_size) { + rz_return_val_if_fail(data && digest, false); + ut8 *dgst = malloc(BLAKE2S_OUTBYTES); + if (!dgst) { + return false; + } + if (blake2sp(dgst, BLAKE2S_OUTBYTES, data, size, NULL, 0) < 0) { + free(dgst); + return false; + } + *digest = dgst; + if (digest_size) { + *digest_size = BLAKE2S_OUTBYTES; + } + return true; +} + +RzHashPlugin rz_hash_plugin_blake2sp = { + .name = "blake2sp", + .license = "LGPL3", + .author = "Farhan-25", + .description = "BLAKE2sp cryptographic hash", + .support_hmac = false, + .context_new = plugin_blake2sp_context_new, + .context_free = plugin_blake2sp_context_free, + .digest_size = plugin_blake2sp_digest_size, + .block_size = plugin_blake2sp_block_size, + .init = plugin_blake2sp_init, + .update = plugin_blake2sp_update, + .final = plugin_blake2sp_final, + .small_block = plugin_blake2sp_small_block, +}; + +#ifndef RZ_PLUGIN_INCORE +RZ_API RzLibStruct rizin_plugin_blake2sp = { + .type = RZ_LIB_TYPE_HASH, + .data = &rz_hash_plugin_blake2sp, + .version = RZ_VERSION +}; +#endif \ No newline at end of file diff --git a/librz/hash/p/algo_blake2xb.c b/librz/hash/p/algo_blake2xb.c new file mode 100644 index 0000000000..e5f0bf8dbd --- /dev/null +++ b/librz/hash/p/algo_blake2xb.c @@ -0,0 +1,83 @@ +// SPDX-FileCopyrightText: 2026 Farhan-25 +// SPDX-License-Identifier: LGPL-3.0-only + +#include +#include +#include + +/** + * This file implements RzHashPlugin for BLAKE2xb: + * - blake2xb : extendable-output (XOF) built on blake2b, arbitrary digest length + */ + +static void *plugin_blake2xb_context_new(void) { + return RZ_NEW0(blake2xb_state); +} + +static void plugin_blake2xb_context_free(void *context) { + free(context); +} + +static RzHashSize plugin_blake2xb_digest_size(void *context) { + return BLAKE2B_OUTBYTES; +} + +static RzHashSize plugin_blake2xb_block_size(void *context) { + return BLAKE2B_BLOCKBYTES; +} + +static bool plugin_blake2xb_init(void *context) { + rz_return_val_if_fail(context, false); + return blake2xb_init((blake2xb_state *)context, BLAKE2B_OUTBYTES) == 0; +} + +static bool plugin_blake2xb_update(void *context, const ut8 *data, ut64 size) { + rz_return_val_if_fail(context && data, false); + return blake2xb_update((blake2xb_state *)context, data, size) == 0; +} + +static bool plugin_blake2xb_final(void *context, ut8 *digest) { + rz_return_val_if_fail(context && digest, false); + return blake2xb_final((blake2xb_state *)context, digest, BLAKE2B_OUTBYTES) == 0; +} + +static bool plugin_blake2xb_small_block(const ut8 *data, ut64 size, ut8 **digest, RzHashSize *digest_size) { + rz_return_val_if_fail(data && digest, false); + ut8 *dgst = malloc(BLAKE2B_OUTBYTES); + if (!dgst) { + return false; + } + if (blake2xb(dgst, BLAKE2B_OUTBYTES, data, size, NULL, 0) < 0) { + free(dgst); + return false; + } + *digest = dgst; + if (digest_size) { + *digest_size = BLAKE2B_OUTBYTES; + } + return true; +} + +RzHashPlugin rz_hash_plugin_blake2xb = { + .name = "blake2xb", + .license = "LGPL3", + .author = "Farhan-25", + .description = "BLAKE2xb cryptographic hash", + .support_hmac = false, + .context_new = plugin_blake2xb_context_new, + .context_free = plugin_blake2xb_context_free, + .digest_size = plugin_blake2xb_digest_size, + .block_size = plugin_blake2xb_block_size, + .init = plugin_blake2xb_init, + .update = plugin_blake2xb_update, + .final = plugin_blake2xb_final, + .small_block = plugin_blake2xb_small_block, +}; + +#ifndef RZ_PLUGIN_INCORE +RZ_API RzLibStruct rizin_plugin_blake2xb = { + .type = RZ_LIB_TYPE_HASH, + .data = &rz_hash_plugin_blake2xb, + .version = RZ_VERSION +}; +#endif \ No newline at end of file diff --git a/librz/hash/p/algo_blake2xs.c b/librz/hash/p/algo_blake2xs.c new file mode 100644 index 0000000000..edede78cde --- /dev/null +++ b/librz/hash/p/algo_blake2xs.c @@ -0,0 +1,83 @@ +// SPDX-FileCopyrightText: 2026 Farhan-25 +// SPDX-License-Identifier: LGPL-3.0-only + +#include +#include +#include + +/** + * This file implements RzHashPlugin for BLAKE2xs: + * - blake2xs : extendable-output (XOF) built on blake2s, arbitrary digest length + */ + +static void *plugin_blake2xs_context_new(void) { + return RZ_NEW0(blake2xs_state); +} + +static void plugin_blake2xs_context_free(void *context) { + free(context); +} + +static RzHashSize plugin_blake2xs_digest_size(void *context) { + return BLAKE2S_OUTBYTES; +} + +static RzHashSize plugin_blake2xs_block_size(void *context) { + return BLAKE2S_BLOCKBYTES; +} + +static bool plugin_blake2xs_init(void *context) { + rz_return_val_if_fail(context, false); + return blake2xs_init((blake2xs_state *)context, BLAKE2S_OUTBYTES) == 0; +} + +static bool plugin_blake2xs_update(void *context, const ut8 *data, ut64 size) { + rz_return_val_if_fail(context && data, false); + return blake2xs_update((blake2xs_state *)context, data, size) == 0; +} + +static bool plugin_blake2xs_final(void *context, ut8 *digest) { + rz_return_val_if_fail(context && digest, false); + return blake2xs_final((blake2xs_state *)context, digest, BLAKE2S_OUTBYTES) == 0; +} + +static bool plugin_blake2xs_small_block(const ut8 *data, ut64 size, ut8 **digest, RzHashSize *digest_size) { + rz_return_val_if_fail(data && digest, false); + ut8 *dgst = malloc(BLAKE2S_OUTBYTES); + if (!dgst) { + return false; + } + if (blake2xs(dgst, BLAKE2S_OUTBYTES, data, size, NULL, 0) < 0) { + free(dgst); + return false; + } + *digest = dgst; + if (digest_size) { + *digest_size = BLAKE2S_OUTBYTES; + } + return true; +} + +RzHashPlugin rz_hash_plugin_blake2xs = { + .name = "blake2xs", + .license = "LGPL3", + .author = "Farhan-25", + .description = "BLAKE2xs cryptographic hash", + .support_hmac = false, + .context_new = plugin_blake2xs_context_new, + .context_free = plugin_blake2xs_context_free, + .digest_size = plugin_blake2xs_digest_size, + .block_size = plugin_blake2xs_block_size, + .init = plugin_blake2xs_init, + .update = plugin_blake2xs_update, + .final = plugin_blake2xs_final, + .small_block = plugin_blake2xs_small_block, +}; + +#ifndef RZ_PLUGIN_INCORE +RZ_API RzLibStruct rizin_plugin_blake2xs = { + .type = RZ_LIB_TYPE_HASH, + .data = &rz_hash_plugin_blake2xs, + .version = RZ_VERSION +}; +#endif \ No newline at end of file diff --git a/meson.build b/meson.build index e8125c4f86..496d7f5ac4 100644 --- a/meson.build +++ b/meson.build @@ -316,6 +316,8 @@ libdemangle_options = [ libdemangle_proj = subproject('libdemangle', default_options: libdemangle_options) libdemangle_dep = libdemangle_proj.get_variable('libdemangle_dep') +blake2_dep = dependency('libblake2', fallback: ['blake2', 'libblake2_dep']) + # handle blake3 algo blake3_dep = dependency('libblake3', required: get_option('use_sys_blake3'), static: is_static_build) if not blake3_dep.found() @@ -879,6 +881,7 @@ summary({ 'System zstd library': libzstd_dep.found() and libzstd_dep.type_name() != 'internal', 'System zip library': libzip_dep.found() and libzip_dep.type_name() != 'internal', 'System blake3 library': blake3_dep.found() and blake3_dep.type_name() != 'internal', + 'System blake2 library': blake2_dep.found() and blake2_dep.type_name() != 'internal', 'Use ptrace-wrap': use_ptrace_wrap, 'Use RPATH': rpath_summary, }, section: 'Configuration', bool_yn: true) diff --git a/meson_options.txt b/meson_options.txt index a3969fd67b..508740d0f4 100644 --- a/meson_options.txt +++ b/meson_options.txt @@ -38,6 +38,7 @@ option('use_sys_libmspack', type: 'feature', value: 'disabled') option('use_sys_tree_sitter', type: 'feature', value: 'disabled') option('use_sys_pcre2', type: 'feature', value: 'disabled') option('use_sys_softfloat', type: 'feature', value: 'disabled') +option('use_sys_blake2', type: 'feature', value: 'disabled') option('use_sys_blake3', type: 'feature', value: 'disabled') option('use_gpl', type: 'boolean', value: true, description: 'Set to false when you want to disable gpl code') option('install_sigdb', type: 'boolean', value: false, description: 'Downloads and installs rizin sigdb') diff --git a/subprojects/blake2.wrap b/subprojects/blake2.wrap new file mode 100644 index 0000000000..cfafb5d7da --- /dev/null +++ b/subprojects/blake2.wrap @@ -0,0 +1,5 @@ +[wrap-git] +url = https://github.com/BLAKE2/BLAKE2.git +revision = ed1974ea83433eba7b2d95c5dcd9ac33cb847913 +patch_directory = blake2 +depth = 1 diff --git a/subprojects/packagefiles/blake2/meson.build b/subprojects/packagefiles/blake2/meson.build new file mode 100644 index 0000000000..b4cd482c2b --- /dev/null +++ b/subprojects/packagefiles/blake2/meson.build @@ -0,0 +1,29 @@ +project('blake2', 'c', + version : '0.0.1', + license : 'CC0', + meson_version : '>=0.57.0', +) + +blake2_inc = include_directories('ref') + +blake2_sources = files( + 'ref/blake2b-ref.c', + 'ref/blake2s-ref.c', + 'ref/blake2bp-ref.c', + 'ref/blake2sp-ref.c', + 'ref/blake2xb-ref.c', + 'ref/blake2xs-ref.c', +) + +blake2_lib = static_library('blake2', + blake2_sources, + include_directories : blake2_inc, + install : false, +) + +libblake2_dep = declare_dependency( + link_with : blake2_lib, + include_directories : blake2_inc, +) + +meson.override_dependency('libblake2', libblake2_dep) \ No newline at end of file diff --git a/test/db/cmd/cmd_list b/test/db/cmd/cmd_list index fe332256e5..dd0f79b4a2 100644 --- a/test/db/cmd/cmd_list +++ b/test/db/cmd/cmd_list @@ -373,6 +373,12 @@ Lhq EOF EXPECT=<