aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--DEPENDENCIES5
-rw-r--r--Makefile15
-rw-r--r--argon2/hash.c120
-rw-r--r--argon2/make_settings.c230
-rw-r--r--argon2/suffix.mk11
-rw-r--r--argon2/test_supported.c68
-rw-r--r--common.h4
-rw-r--r--config-coverage-gcc.mk9
-rw-r--r--librecrypt_check_settings_.c519
-rw-r--r--librecrypt_find_first_algorithm_.c23
-rw-r--r--librecrypt_get_encoding.c91
-rw-r--r--librecrypt_make_settings.c127
-rw-r--r--librecrypt_test_supported.c26
-rw-r--r--libtest/Makefile4
-rw-r--r--libtest/alloc.c62
-rw-r--r--libtest/config_backtraces=false.mk2
-rw-r--r--libtest/config_backtraces=true.mk2
-rw-r--r--libtest/libtest_free.c1
-rw-r--r--libtest/mmap.c5
19 files changed, 1250 insertions, 74 deletions
diff --git a/DEPENDENCIES b/DEPENDENCIES
index 2501a5c..7915221 100644
--- a/DEPENDENCIES
+++ b/DEPENDENCIES
@@ -2,8 +2,9 @@ Unconditional runtime dependencies:
libc
For Argon2 support (runtime, build, and check dependencies):
- libar2simplified
- libar2
+ libar2simplified>=1.1
+ libar2simplified>=1.1.4 (check only)
+ libar2>=1.1
libblake (indirect)
pthread (indirect)
diff --git a/Makefile b/Makefile
index 9d12bea..46b6a83 100644
--- a/Makefile
+++ b/Makefile
@@ -70,10 +70,6 @@ all:
include argon2/suffix.mk
-SRC =\
- $(OBJ:.o=.c)\
- $(HDR)
-
ALL_CFLAGS = $(CFLAGS) $(CFLAGS_MODULES)
ALL_CPPFLAGS = $(CPPFLAGS) $(CPPFLAGS_MODULES)
ALL_LDFLAGS = $(LDFLAGS) $(LDFLAGS_MODULES)
@@ -89,19 +85,16 @@ $(TOBJ): $(HDR) libtest/libtest.h
$(TEST): $(HDR) librecrypt.a libtest/libtest.a libtest/libtest.h
.c.o:
- $(CC) -c -o $@ $< $(ALL_CFLAGS) $(ALL_CPPFLAGS)
+ $(CC) -c -o $@ $< $(ALL_CFLAGS) $(COV_CFLAGS) $(ALL_CPPFLAGS) $(COV_CPPFLAGS)
.c.lo:
- $(CC) -fPIC -c -o $@ $< $(ALL_CFLAGS) $(ALL_CPPFLAGS)
+ $(CC) -fPIC -c -o $@ $< $(ALL_CFLAGS) $(COV_CFLAGS) $(ALL_CPPFLAGS) $(COV_CPPFLAGS)
.c.to:
$(CC) -DTEST -c -o $@ $< $(ALL_CFLAGS) $(ALL_CPPFLAGS)
.to.t:
- $(CC) -o $@ $< librecrypt.a libtest/libtest.a $(G) $(ALL_LDFLAGS) $(TEST_LDFLAGS)
-
-.c.t:
- $(CC) -DTEST -o $@ $< librecrypt.a libtest/libtest.a $(G) $(ALL_CFLAGS) $(ALL_CPPFLAGS) $(ALL_LDFLAGS) $(TEST_LDFLAGS)
+ $(CC) -o $@ $< librecrypt.a libtest/libtest.a $(G) $(ALL_LDFLAGS) $(TEST_LDFLAGS) $(COV_LDFLAGS)
librecrypt.a: $(OBJ)
@rm -f -- $@
@@ -115,7 +108,7 @@ libtest/libtest.a:
+cd libtest && $(MAKE) libtest.a
check: $(TEST)
- +cd libtest && $(MAKE) check
+ +cd libtest && $(LIBTEST_CHECK_PREFIX) $(MAKE) check
@set -ex;\
for t in $(TEST); do\
$(CHECK_PREFIX) ./$$t;\
diff --git a/argon2/hash.c b/argon2/hash.c
index 5709df0..dbb7c53 100644
--- a/argon2/hash.c
+++ b/argon2/hash.c
@@ -42,7 +42,7 @@ librecrypt__argon2__hash(char *restrict out_buffer, size_t size, const char *phr
r = librecrypt_check_settings_(settings, prefix,
"$argon2%^s$%^sm=%^p,t=%^p,p=%^p$%&b$%^h",
&type, "id", "i", "ds", "d", NULL, /* order partially matters */
- &version, "v=19$", "v=16$", "", NULL,
+ &version, "v=19$", "v=16$", "", NULL, /* empty string last */
&mcost, RANGE(LIBAR2_MIN_M_COST, LIBAR2_MAX_M_COST),
&tcost, RANGE(LIBAR2_MIN_T_COST, LIBAR2_MAX_T_COST),
&lanes, RANGE(LIBAR2_MIN_LANES, LIBAR2_MAX_LANES),
@@ -55,13 +55,13 @@ librecrypt__argon2__hash(char *restrict out_buffer, size_t size, const char *phr
/* Decode salt */
if (!salt_encoded) /* this would be if asterisk-notation is used, but it is not */
- abort();
+ abort(); /* $covered$ */
r = librecrypt_decode(NULL, 0u, salt_encoded, saltlen, BASE64);
if (r < 0)
- return -1;
+ return -1; /* $covered$ (impossible) */
if (r > 0) {
/* We allow `r` to be 0, although that means saltlen is 0,
- * which it cannot actaully be since LIBAR2_MIN_SALTLEN is 8,
+ * which it cannot actually be since LIBAR2_MIN_SALTLEN is 8,
* but who knows the future. Of course, we cannot run this
* part if `r` is 0, because we don't want to run malloc(3)
* with 0 because our test's implementation of malloc(3)
@@ -73,7 +73,7 @@ librecrypt__argon2__hash(char *restrict out_buffer, size_t size, const char *phr
if (!salt)
return -1;
if (librecrypt_decode(salt, (size_t)r, salt_encoded, saltlen, BASE64) != r)
- abort();
+ abort(); /* $covered$ (impossible) */
saltlen = (uintmax_t)r;
}
@@ -81,7 +81,7 @@ librecrypt__argon2__hash(char *restrict out_buffer, size_t size, const char *phr
params.type = type[1u] == 'd' ? LIBAR2_ARGON2ID :
type[1u] == 's' ? LIBAR2_ARGON2DS :
type[0u] == 'i' ? LIBAR2_ARGON2I :
- LIBAR2_ARGON2ID;
+ LIBAR2_ARGON2D;
params.version = version[3u] == '9' ? LIBAR2_ARGON2_VERSION_13 : /* 19 = 0x13 = 1.3 */
LIBAR2_ARGON2_VERSION_10; /* 16 = 0x10 = 1.0 */
params.t_cost = (uint_least32_t)tcost;
@@ -106,6 +106,8 @@ librecrypt__argon2__hash(char *restrict out_buffer, size_t size, const char *phr
/* Calculate hash */
if (libar2_hash(scratch ? scratch : out_buffer, REMOVE_CONST(phrase), len, &params, &ctx))
goto fail;
+ if (scratch && out_buffer)
+ memcpy(out_buffer, scratch, params.hashlen < size ? params.hashlen : size);
/* same rationale as for `ctx.autoerase_salt = 1;` */
if (scratch) {
@@ -132,16 +134,118 @@ fail:
#else
-CONST int
+static int discarded_int;
+
+
+static void
+check(const char *phrase, const char *settings, const char *hash, size_t hashlen)
+{
+ size_t len = strlen(phrase);
+ size_t prefix = strlen(settings);
+ char buf[1024], expected[256];
+ ssize_t r;
+
+ assert(hashlen <= sizeof(buf));
+ assert(hashlen <= sizeof(expected));
+
+ r = librecrypt_decode(expected, sizeof(expected), hash, strlen(hash),
+ librecrypt_common_rfc4848s4_decoding_lut_,
+ argon2__PAD, argon2__STRICT_PAD);
+ assert(r > 0 && (size_t)r == hashlen);
+
+ memset(buf, 0, sizeof(buf));
+ EXPECT(librecrypt__argon2__hash(buf, sizeof(buf), phrase, len, settings, prefix, NULL) == 0);
+ EXPECT(!memcmp(expected, buf, hashlen));
+
+ memset(buf, 0, sizeof(buf));
+ EXPECT(librecrypt__argon2__hash(buf, hashlen, phrase, len, settings, prefix, NULL) == 0);
+ EXPECT(!memcmp(expected, buf, hashlen));
+
+ memset(buf, 0, sizeof(buf));
+ EXPECT(librecrypt__argon2__hash(buf, 1u, phrase, len, settings, prefix, NULL) == 0);
+ EXPECT(!memcmp(expected, buf, 1u));
+
+ EXPECT(librecrypt__argon2__hash(buf, 0u, phrase, len, settings, prefix, NULL) == 0);
+ EXPECT(librecrypt__argon2__hash(NULL, 0u, phrase, len, settings, prefix, NULL) == 0);
+}
+
+
+#define S(STR) (STR), (sizeof(STR) - 1u)
+
+
+#define CHECK(PHRASE, CONF, HASHLEN, HASH)\
+ do {\
+ check(PHRASE, CONF HASH, HASH, (size_t)HASHLEN);\
+ if ((size_t)HASHLEN == argon2__HASH_SIZE)\
+ check(PHRASE, CONF, HASH, (size_t)HASHLEN);\
+ check(PHRASE, CONF "*" #HASHLEN, HASH, (size_t)HASHLEN);\
+ } while (0)
+
+
+#define CHECK_BAD(ALGO)\
+ do {\
+ errno = 0;\
+ EXPECT(librecrypt__argon2__hash(NULL, 0u, NULL, 0u, S(ALGO"m=0,t=999999999999999999,p=0$AAAABBBB$*0"), NULL) == -1);\
+ EXPECT(errno == EINVAL);\
+ \
+ /* target `if (!salt_encoded)` */\
+ EXPECT_ABORT(discarded_int = librecrypt__argon2__hash(NULL, 0u, NULL, 0u, S(ALGO"m=1024,t=10,p=1$*10$"), NULL));\
+ \
+ if (!libtest_have_custom_malloc())\
+ break;\
+ \
+ /* target `salt = malloc((size_t)r);` */\
+ libtest_set_alloc_failure_in(1u);\
+ errno = 0;\
+ EXPECT(librecrypt__argon2__hash(NULL, 0u, NULL, 0u, S(ALGO"m=1024,t=10,p=1$AAAABBBBCCCCDDDD$"), NULL) == -1);\
+ EXPECT(errno == ENOMEM);\
+ \
+ /* target `scratch = malloc(scratch_size);` */\
+ libtest_set_alloc_failure_in(2u);\
+ errno = 0;\
+ EXPECT(librecrypt__argon2__hash(NULL, 0u, NULL, 0u, S(ALGO"m=1024,t=10,p=1$AAAABBBBCCCCDDDD$"), NULL) == -1);\
+ EXPECT(errno == ENOMEM);\
+ \
+ /* target `libar2_hash` */\
+ libtest_set_alloc_failure_in(3u);\
+ errno = 0;\
+ EXPECT(librecrypt__argon2__hash(NULL, 0u, NULL, 0u, S(ALGO"m=1024,t=10,p=1$AAAABBBBCCCCDDDD$"), NULL) == -1);\
+ EXPECT(errno == ENOMEM);\
+ \
+ assert(!libtest_get_alloc_failure_in());\
+ } while (0)
+
+
+int
main(void)
{
SET_UP_ALARM();
+ INIT_TEST_ABORT();
INIT_RESOURCE_TEST();
+#if defined(SUPPORT_ARGON2I)
+ CHECK("password", "$argon2i$" "m=256,t=2,p=1$c29tZXNhbHQ$", 32, "/U3YPXYsSb3q9XxHvc0MLxur+GP960kN9j7emXX8zwY");
+ CHECK("password", "$argon2i$v=19$m=256,t=2,p=1$c29tZXNhbHQ$", 32, "iekCn0Y3spW+sCcFanM2xBT63UP2sghkUoHLIUpWRS8");
+ CHECK_BAD("$argon2i$");
+#endif
+#if defined(SUPPORT_ARGON2ID)
+ CHECK("password", "$argon2id$v=19$m=256,t=2,p=1$c29tZXNhbHQ$", 32, "nf65EOgLrQMR/uIPnA4rEsF5h7TKyQwu9U1bMCHGi/4");
+ CHECK_BAD("$argon2id$");
+#endif
+#if defined(SUPPORT_ARGON2DS)
+ CHECK("", "$argon2ds$v=16$m=""8,t=1,p=1$ICAgICAgICA$", 32, "zgdykk9ZjN5VyrW0LxGw8LmrJ1Z6fqSC+3jPQtn4n0s");
+ CHECK_BAD("$argon2ds$");
+#endif
+#if defined(SUPPORT_ARGON2D)
+ CHECK("", "$argon2d$v=16$m=""8,t=1,p=1$ICAgICAgICA$", 100, "NjODMrWrS7zeivNNpHsuxD9c6uDmUQ6YqPRhb8H5DSNw9"
+ "n683FUCJZ3tyxgfJpYYANI+01WT/S5zp1UVs+qNRwnkdE"
+ "yLKZMg+DIOXVc9z1po9ZlZG8+Gp4g5brqfza3lvkR9vw");
+ CHECK_BAD("$argon2d$");
+#endif
+
STOP_RESOURCE_TEST();
return 0;
}
#endif
-/* TODO test */
diff --git a/argon2/make_settings.c b/argon2/make_settings.c
index 66ac3d6..396c48d 100644
--- a/argon2/make_settings.c
+++ b/argon2/make_settings.c
@@ -1,8 +1,7 @@
/* See LICENSE file for copyright and license details. */
#include "../common.h"
-#ifndef TEST
-
#include <libar2.h>
+#ifndef TEST
static ssize_t
@@ -43,11 +42,11 @@ make_settings(char *out_buffer, size_t size, const char *algorithm, size_t memco
/* Get version */
p = algorithm;
if (*p++ != '$')
- abort();
+ abort(); /* $covered$ */
p = strchr(p, '$');
algolen = p ? (size_t)(p - algorithm) : strlen(algorithm);
- if (algolen > 64) /* just some small value absolute will fit all variants */
- abort();
+ if (algolen > 32u) /* just some small value absolute will fit all variants */
+ abort(); /* $covered$ */
if (p++ && *p++ == 'v') {
if (!strncmp(p, "=16", 3u) && (!p[3u] || p[3u] == '$'))
version = "16";
@@ -62,7 +61,7 @@ make_settings(char *out_buffer, size_t size, const char *algorithm, size_t memco
(int)algolen, algorithm, version,
memcost, (unsigned long long int)timecost);
if (r < (int)sizeof("$argon2_$v=__$m=_,t=_,p=1$") - 1)
- abort();
+ abort(); /* $covered$ (impossible) */
ret = (size_t)r;
min = size ? ret < size - 1u ? ret : size - 1u : 0u;
out_buffer = &out_buffer[min];
@@ -129,16 +128,231 @@ IF__argon2ds__SUPPORTED(DECLARE_MAKE_SETTINGS(argon2ds))
#else
-CONST int
+static unsigned char saltbyte = 0u;
+static ssize_t discarded_ssize;
+
+
+static ssize_t
+saltgen(void *out, size_t n, void *user)
+{
+ if (!n)
+ return 0;
+ *(unsigned char *)out = *(unsigned char *)user;
+ return 1;
+}
+
+
+static ssize_t
+saltfail(void *out, size_t n, void *user)
+{
+ (void) out;
+ (void) n;
+ (void) user;
+ errno = EDOM;
+ return -1;
+}
+
+
+static void
+check(ssize_t (*gen)(char *, size_t, const char *, size_t, uintmax_t,
+ int , ssize_t (*)(void *, size_t, void *), void *),
+ const char *algo_out, const char *algo_in)
+{
+ uintmax_t v, d;
+ char buf[1024];
+ char buf2[sizeof(buf)];
+ size_t off, i;
+ ssize_t r;
+
+ if (!algo_out) {
+ errno = 0;
+ EXPECT((*gen)(buf, sizeof(buf), algo_in, 0u, 0u, 0, &saltgen, &saltbyte) == -1);
+ EXPECT(errno == ENOSYS);
+ return;
+ }
+
+ off = strlen(algo_out);
+
+ r = (*gen)(buf, sizeof(buf), algo_in, 0u, 0u, 0, &saltgen, &saltbyte);
+ EXPECT(r > 0 && (size_t)r < sizeof(buf));
+ EXPECT(!buf[r] && (size_t)r == strlen(buf));
+ EXPECT(!strncmp(buf, algo_out, off));
+ EXPECT(!strcmp(&buf[off], "m=4096,t=10,p=1$*16$*32"));
+ assert(LIBAR2_MIN_SALTLEN <= 16u && 16u <= LIBAR2_MAX_SALTLEN);
+ assert(LIBAR2_MIN_HASHLEN <= 32u && 32u <= LIBAR2_MAX_HASHLEN);
+
+ EXPECT((*gen)(NULL, 0u, algo_in, 0u, 0u, 0, &saltgen, &saltbyte) == r);
+ for (i = 1u; i <= (size_t)r; i++) {
+ EXPECT((*gen)(buf2, i, algo_in, 0u, 0u, 0, &saltgen, &saltbyte) == r);
+ EXPECT(!buf2[i - 1u]);
+ EXPECT(!memcmp(buf2, buf, i - 1u));
+ }
+
+ r = (*gen)(buf, sizeof(buf), algo_in, 8192u << 10, 0u, 0, &saltgen, &saltbyte);
+ EXPECT(r > 0 && (size_t)r < sizeof(buf));
+ EXPECT(!buf[r] && (size_t)r == strlen(buf));
+ EXPECT(!strncmp(buf, algo_out, off));
+ EXPECT(!strcmp(&buf[off], "m=8192,t=5,p=1$*16$*32"));
+
+ r = (*gen)(buf, sizeof(buf), algo_in, 8192u << 10, (uintmax_t)81920u, 0, &saltgen, &saltbyte);
+ EXPECT(r > 0 && (size_t)r < sizeof(buf));
+ EXPECT(!buf[r] && (size_t)r == strlen(buf));
+ EXPECT(!strncmp(buf, algo_out, off));
+ EXPECT(!strcmp(&buf[off], "m=8192,t=10,p=1$*16$*32"));
+
+ saltbyte = 0u;
+ r = (*gen)(buf, sizeof(buf), algo_in, 8192u << 10, (uintmax_t)81920u, 1, &saltgen, &saltbyte);
+ EXPECT(r > 0 && (size_t)r < sizeof(buf));
+ EXPECT(!buf[r] && (size_t)r == strlen(buf));
+ EXPECT(!strncmp(buf, algo_out, off));
+ EXPECT(!strcmp(&buf[off], "m=8192,t=10,p=1$AAAAAAAAAAAAAAAAAAAAAA$*32"));
+
+ EXPECT((*gen)(buf, sizeof(buf), algo_in, 8192u << 10, (uintmax_t)81920u, 1, &saltgen, &saltbyte) == r);
+ for (i = 1u; i <= (size_t)r; i++) {
+ EXPECT((*gen)(buf2, i, algo_in, 8192u << 10, (uintmax_t)81920u, 1, &saltgen, &saltbyte) == r);
+ EXPECT(!buf2[i - 1u]);
+ EXPECT(!memcmp(buf2, buf, i - 1u));
+ }
+
+ r = (*gen)(buf, sizeof(buf), algo_in, 8192u << 10, (uintmax_t)81920u, 1, NULL, &saltbyte);
+ EXPECT(r > 0 && (size_t)r < sizeof(buf));
+ EXPECT(!buf[r] && (size_t)r == strlen(buf));
+ EXPECT(!strncmp(buf, algo_out, off));
+ EXPECT(strcmp(&buf[off], "m=8192,t=10,p=1$AAAAAAAAAAAAAAAAAAAAAA$*32"));
+ memcpy(buf2, buf, (size_t)r);
+ memset(&buf[off + sizeof("m=8192,t=10,p=1$") - 1u], 'A', 22u);
+ EXPECT(!strcmp(&buf[off], "m=8192,t=10,p=1$AAAAAAAAAAAAAAAAAAAAAA$*32"));
+
+ EXPECT((*gen)(buf, sizeof(buf), algo_in, 8192u << 10, (uintmax_t)81920u, 1, NULL, &saltbyte) == r);
+ EXPECT(r > 0 && (size_t)r < sizeof(buf));
+ EXPECT(!buf[r] && (size_t)r == strlen(buf));
+ EXPECT(memcmp(buf, buf2, (size_t)r));
+ memset(&buf[off + sizeof("m=8192,t=10,p=1$") - 1u], 'A', 22u);
+ EXPECT(!strcmp(&buf[off], "m=8192,t=10,p=1$AAAAAAAAAAAAAAAAAAAAAA$*32"));
+
+ saltbyte = 255u;
+ r = (*gen)(buf, sizeof(buf), algo_in, 8192u << 10, (uintmax_t)81920u, 1, &saltgen, &saltbyte);
+ EXPECT(r > 0 && (size_t)r < sizeof(buf));
+ EXPECT(!buf[r] && (size_t)r == strlen(buf));
+ EXPECT(!strncmp(buf, algo_out, off));
+ EXPECT(!strcmp(&buf[off], "m=8192,t=10,p=1$/////////////////////w$*32"));
+
+ r = (*gen)(buf, sizeof(buf), algo_in, 0u, (uintmax_t)81920u, 0, &saltgen, &saltbyte);
+ EXPECT(r > 0 && (size_t)r < sizeof(buf));
+ EXPECT(!buf[r] && (size_t)r == strlen(buf));
+ EXPECT(!strncmp(buf, algo_out, off));
+ EXPECT(!strcmp(&buf[off], "m=4096,t=20,p=1$*16$*32"));
+
+ r = (*gen)(buf, sizeof(buf), algo_in, 1u, 1u, 0, &saltgen, &saltbyte);
+ EXPECT(r > 0 && (size_t)r < sizeof(buf));
+ EXPECT(!buf[r] && (size_t)r == strlen(buf));
+ EXPECT(!strncmp(buf, algo_out, off));
+ EXPECT(!strcmp(&buf[off], "m=8,t=1,p=1$*16$*32"));
+
+ r = (*gen)(buf, sizeof(buf), algo_in, 1u, 1u, 0, &saltgen, &saltbyte);
+ EXPECT(r > 0 && (size_t)r < sizeof(buf));
+ EXPECT(!buf[r] && (size_t)r == strlen(buf));
+ EXPECT(!strncmp(buf, algo_out, off));
+ EXPECT(!strcmp(&buf[off], "m=8,t=1,p=1$*16$*32"));
+
+ r = (*gen)(buf, sizeof(buf), algo_in, (10u << 10) + 512u, 1u, 0, &saltgen, &saltbyte);
+ EXPECT(r > 0 && (size_t)r < sizeof(buf));
+ EXPECT(!buf[r] && (size_t)r == strlen(buf));
+ EXPECT(!strncmp(buf, algo_out, off));
+ EXPECT(!strcmp(&buf[off], "m=11,t=1,p=1$*16$*32"));
+
+ r = (*gen)(buf, sizeof(buf), algo_in, (10u << 10) + 511u, 1u, 0, &saltgen, &saltbyte);
+ EXPECT(r > 0 && (size_t)r < sizeof(buf));
+ EXPECT(!buf[r] && (size_t)r == strlen(buf));
+ EXPECT(!strncmp(buf, algo_out, off));
+ EXPECT(!strcmp(&buf[off], "m=10,t=1,p=1$*16$*32"));
+
+ r = (*gen)(buf, sizeof(buf), algo_in, SIZE_MAX, 1u, 0, &saltgen, &saltbyte);
+ EXPECT(r > 0 && (size_t)r < sizeof(buf));
+ EXPECT(!buf[r] && (size_t)r == strlen(buf));
+ EXPECT(!strncmp(buf, algo_out, off));
+ EXPECT(!strncmp(&buf[off], "m=", sizeof("m=") - 1u));
+ i = off + sizeof("m=") - 1u;
+ EXPECT('0' <= buf[i] && buf[i] <= '9');
+ for (v = 0; buf[i] != ','; i++) {
+ EXPECT('0' <= buf[i] && buf[i] <= '9');
+ d = (uintmax_t)(buf[i] - '0');
+ EXPECT(v <= (UINTMAX_MAX - d) / 10u);
+ v = v * 10u + d;
+ }
+ EXPECT(v <= (uintmax_t)LIBAR2_MAX_M_COST);
+
+ r = (*gen)(buf, sizeof(buf), algo_in, 1u, UINTMAX_MAX, 0, &saltgen, &saltbyte);
+ EXPECT(r > 0 && (size_t)r < sizeof(buf));
+ EXPECT(!buf[r] && (size_t)r == strlen(buf));
+ EXPECT(!strncmp(buf, algo_out, off));
+ EXPECT(!strncmp(&buf[off], "m=8,t=", sizeof("m=8,t=") - 1u));
+ i = off + sizeof("m=8,t=") - 1u;
+ EXPECT('0' <= buf[i] && buf[i] <= '9');
+ for (v = 0; buf[i] != ','; i++) {
+ EXPECT('0' <= buf[i] && buf[i] <= '9');
+ d = (uintmax_t)(buf[i] - '0');
+ EXPECT(v <= (UINTMAX_MAX - d) / 10u);
+ v = v * 10u + d;
+ }
+ EXPECT(v <= (uintmax_t)LIBAR2_MAX_T_COST);
+
+ errno = 0;
+ EXPECT((*gen)(buf, sizeof(buf), algo_in, 0u, 0u, 1, &saltfail, NULL) == -1);
+ EXPECT(errno == EDOM);
+}
+
+
+static void
+check_aborts(ssize_t (*gen)(char *, size_t, const char *, size_t, uintmax_t,
+ int , ssize_t (*)(void *, size_t, void *), void *))
+{
+#define SHORTTEXT "------------------------------------------------------------------------"
+#define LONGTEXT SHORTTEXT SHORTTEXT SHORTTEXT SHORTTEXT SHORTTEXT SHORTTEXT SHORTTEXT
+ EXPECT_ABORT(discarded_ssize = (*gen)(NULL, 0, "argon2i$", 0u, 0u, 0, NULL, NULL));
+ EXPECT_ABORT(discarded_ssize = (*gen)(NULL, 0, "$argon2"LONGTEXT"$", 0u, 0u, 0, NULL, NULL));
+}
+
+
+#define CHECK(FUNC, ALGO)\
+ do {\
+ check(&(FUNC), "$"ALGO"$v=19$", NULL);\
+ check(&(FUNC), "$"ALGO"$v=19$", "$"ALGO"$");\
+ check(&(FUNC), "$"ALGO"$v=19$", "$"ALGO);\
+ check(&(FUNC), "$"ALGO"$v=19$", "$"ALGO"$m=100,t=10,p=2$xxxx$*32");\
+ check(&(FUNC), "$"ALGO"$v=19$", "$"ALGO"$m=100,t=10,p=2$*40$");\
+ check(&(FUNC), "$"ALGO"$v=16$", "$"ALGO"$v=16");\
+ check(&(FUNC), "$"ALGO"$v=16$", "$"ALGO"$v=16$");\
+ check(&(FUNC), "$"ALGO"$v=16$", "$"ALGO"$v=16$m=100,t=10,p=2$xxxx$*32");\
+ check(&(FUNC), "$"ALGO"$v=16$", "$"ALGO"$v=16$m=100,t=10,p=2$*40$");\
+ check(&(FUNC), "$"ALGO"$v=19$", "$"ALGO"$v=19");\
+ check(&(FUNC), "$"ALGO"$v=19$", "$"ALGO"$v=19$");\
+ check(&(FUNC), "$"ALGO"$v=19$", "$"ALGO"$v=19$m=100,t=10,p=2$xxxx$*32");\
+ check(&(FUNC), "$"ALGO"$v=19$", "$"ALGO"$v=19$m=100,t=10,p=2$*40$");\
+ check(&(FUNC), NULL, "$"ALGO"$v=1");\
+ check(&(FUNC), NULL, "$"ALGO"$v=");\
+ check(&(FUNC), NULL, "$"ALGO"$v=160");\
+ check(&(FUNC), NULL, "$"ALGO"$v=160$");\
+ check(&(FUNC), NULL, "$"ALGO"$v=10$");\
+ check_aborts(&(FUNC));\
+ } while (0)
+
+
+int
main(void)
{
SET_UP_ALARM();
+ INIT_TEST_ABORT();
INIT_RESOURCE_TEST();
+ IF__argon2i__SUPPORTED(CHECK(librecrypt__argon2i__make_settings, "argon2i");)
+ IF__argon2d__SUPPORTED(CHECK(librecrypt__argon2d__make_settings, "argon2d");)
+ IF__argon2id__SUPPORTED(CHECK(librecrypt__argon2id__make_settings, "argon2id");)
+ IF__argon2ds__SUPPORTED(CHECK(librecrypt__argon2ds__make_settings, "argon2ds");)
+
STOP_RESOURCE_TEST();
return 0;
}
#endif
-/* TODO test */
diff --git a/argon2/suffix.mk b/argon2/suffix.mk
index 01be2df..65617b1 100644
--- a/argon2/suffix.mk
+++ b/argon2/suffix.mk
@@ -12,7 +12,10 @@ OBJ_ARGON2 !=\
OBJ_PRIVATE += $(OBJ_ARGON2)
-OBJ_COMMON_RFC4848S4 = $(USE_OBJ_COMMON_RFC4848S4)
+OBJ_COMMON_RFC4848S4 !=\
+ if $(SUPPORT_ANY_ARGON2) || test -n "$(OBJ_COMMON_RFC4848S4)"; then\
+ echo $(USE_OBJ_COMMON_RFC4848S4);\
+ fi
CPPFLAGS_ARGON2 !=\
if $(SUPPORT_ARGON2I); then echo\
@@ -45,6 +48,12 @@ CPPFLAGS_MODULES += $(CPPFLAGS_ARGON2)
CFLAGS_MODULES += $(CFLAGS_ARGON2)
LDFLAGS_MODULES += $(LDFLAGS_ARGON2)
+MODULES_GCDA_ARGON !=\
+ if $(SUPPORT_ANY_ARGON2); then\
+ echo 'argon2/*.gcda';\
+ fi
+
+MODULES_GCDA += $(MODULES_GCDA_ARGON)
clean: clean-argon2
clean-argon2:
diff --git a/argon2/test_supported.c b/argon2/test_supported.c
index d2eba9a..7f47905 100644
--- a/argon2/test_supported.c
+++ b/argon2/test_supported.c
@@ -49,16 +49,80 @@ librecrypt__argon2__test_supported(const char *phrase, size_t len, int text, con
#else
-CONST int
+int
main(void)
{
+ size_t n = 99u;
+
SET_UP_ALARM();
INIT_RESOURCE_TEST();
+#define S(STR) (STR), (sizeof(STR) - 1u)
+
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=8,t=1,p=1$*16$"), &n) == 1);
+ EXPECT(n == 32u);
+
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=8,t=1,p=1$*16$*40"), &n) == 1);
+ EXPECT(n == 40u);
+
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=8,t=1,p=1$*16$////////////"), &n) == 1);
+ EXPECT(n == 9u);
+
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=8,t=1,p=1$*16$////////////AA"), &n) == 1);
+ EXPECT(n == 10u);
+
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=8,t=1,p=1$*16$////////////AAA"), &n) == 1);
+ EXPECT(n == 11u);
+
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=8,t=1,p=1$*16$////////////AA#"), &n) == 0);
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=8,t=1,p=1$*16$////"), &n) == 0);
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=8,t=1,p=1$*16$*40$"), &n) == 0);
+
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=8,t=1,p=1$CCCCBBBBAAA$*40"), &n) == 1);
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=8,t=1,p=1$CCCCBBBBAA#$*40"), &n) == 0);
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=8,t=1,p=1$CCCCBBBB$*40"), &n) == 0);
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=8,t=1,p=1$AAAABBBBCCCC$*40"), &n) == 1);
+
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$v=16$m=8,t=1,p=1$*16$*40"), &n) == 1);
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$v=19$m=8,t=1,p=1$*16$*40"), &n) == 1);
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$v=1$m=8,t=1,p=1$*16$*40"), &n) == 0);
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$v=10$m=8,t=1,p=1$*16$*40"), &n) == 0);
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$v=160$m=8,t=1,p=1$*16$*40"), &n) == 0);
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$v=190$m=8,t=1,p=1$*16$*40"), &n) == 0);
+
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=8,t=1,p=0$*16$"), &n) == 0);
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=8,t=0,p=1$*16$"), &n) == 0);
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=0,t=1,p=1$*16$"), &n) == 0);
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=7,t=1,p=1$*16$"), &n) == 0);
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=4294967296,t=1,p=1$*16$"), &n) == 0);
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=8,t=4294967296,p=1$*16$"), &n) == 0);
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=8,t=4294967295,p=1$*16$"), &n) == 1);
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=8,t=1,p=16777216$*16$"), &n) == 0);
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=8,t=1,p=16777215$*16$"), &n) == 1);
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=8,t=1,p=1$*4294967296$"), &n) == 0);
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=8,t=1,p=1$*4294967295$"), &n) == 1);
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=8,t=1,p=1$*8$"), &n) == 1);
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=8,t=1,p=1$*7$"), &n) == 0);
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=8,t=1,p=1$*0$"), &n) == 0);
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=8,t=1,p=1$*16$*4294967296"), &n) == 0);
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=8,t=1,p=1$*16$*4294967295"), &n) == 1);
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=8,t=1,p=1$*16$*4"), &n) == 1);
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=8,t=1,p=1$*16$*3"), &n) == 0);
+ EXPECT(librecrypt__argon2__test_supported(NULL, UINT32_MAX, 0, S("$...$m=8,t=1,p=1$*16$*0"), &n) == 0);
+
+ EXPECT(librecrypt__argon2__test_supported(NULL, 1u, 0, S("$...$m=8,t=1,p=1$*16$"), &n) == 1);
+ EXPECT(librecrypt__argon2__test_supported(NULL, 0u, 0, S("$...$m=8,t=1,p=1$*16$"), &n) == 1);
+
+ EXPECT(librecrypt__argon2__test_supported(NULL, 1u, 1, S("$...$m=8,t=1,p=1$*16$"), &n) == 1);
+ EXPECT(librecrypt__argon2__test_supported(NULL, 0u, 1, S("$...$m=8,t=1,p=1$*16$"), &n) == 1);
+
+#if SIZE_MAX > UINT32_MAX
+ EXPECT(librecrypt__argon2__test_supported(NULL, (size_t)UINT32_MAX + 1u, 0, S("$...$m=8,t=1,p=1$*16$"), &n) == 0);
+#endif
+
STOP_RESOURCE_TEST();
return 0;
}
#endif
-/* TODO test */
diff --git a/common.h b/common.h
index 5bdbf9c..fdbd25b 100644
--- a/common.h
+++ b/common.h
@@ -518,6 +518,8 @@ int librecrypt_check_settings_(const char *settings, size_t len, const char *fmt
# define EXPECT(EXPR)\
do {\
if (!(EXPR)) {\
+ libtest_expect_zeroed_on_free(0);\
+ libtest_stop_tracking();\
fprintf(stderr, "Failure at %s:%i: %s\n", __FILE__, __LINE__, #EXPR);\
libtest_dump_stack(NULL, "\t");\
exit(1);\
@@ -527,6 +529,8 @@ int librecrypt_check_settings_(const char *settings, size_t len, const char *fmt
# define assert(EXPR)\
do {\
if (!(EXPR)) {\
+ libtest_expect_zeroed_on_free(0);\
+ libtest_stop_tracking();\
fprintf(stderr, "Assertion failure at %s:%i: %s\n", __FILE__, __LINE__, #EXPR);\
libtest_dump_stack(NULL, "\t");\
exit(2);\
diff --git a/config-coverage-gcc.mk b/config-coverage-gcc.mk
index 4892752..c487b3a 100644
--- a/config-coverage-gcc.mk
+++ b/config-coverage-gcc.mk
@@ -4,10 +4,13 @@ include $(CONFIGFILE_PROPER)
CC = $(CC_PREFIX)gcc -std=c99
GCOV = gcov
-CFLAGS = -g -O0 -pedantic -fprofile-arcs -ftest-coverage
-LDFLAGS += -lgcov -fprofile-arcs
+CFLAGS = -g -O0
+COV_CFLAGS = --coverage
+COV_LDFLAGS = --coverage
G =
+LIBTEST_CHECK_PREFIX = :
+
coverage: check
- $(GCOV) -pr $(SRC) 2>&1
+ $(GCOV) -pr -- *.gcda $(MODULES_GCDA) 2>&1
diff --git a/librecrypt_check_settings_.c b/librecrypt_check_settings_.c
index 8462b73..16fbe7f 100644
--- a/librecrypt_check_settings_.c
+++ b/librecrypt_check_settings_.c
@@ -55,7 +55,7 @@ check_uint(const char *settings, size_t *off, size_t len, char min_first_digit,
*out = value;
/* Check that the integer is within the accepted range */
- return min <= value && value >= max;
+ return min <= value && value <= max;
}
@@ -120,7 +120,7 @@ check_data(const char *settings, size_t *off, size_t len, uintmax_t min, uintmax
q = i / 4u;
r = i % 4u;
n = q * 3u + r - (r ? 1u : 0u);
- if (!strout)
+ if (!strout && lenout)
*lenout = n;
/* 1 base-64 character in excees of a multiple of 4,
* this is illegal because 4 characters encode 3 bytes
@@ -204,6 +204,7 @@ librecrypt_check_settings_(const char *settings, size_t len, const char *fmt, ..
/* Like "%b"/"%h" except output pointer to base-64 text or decodes asterisk-notation */
strout = va_arg(args, const char **);
uout = va_arg(args, uintmax_t *);
+ fmt++;
goto plain_bh;
} else outable: if (fmt[1u] == 'p' || fmt[1u] == 'u') {
@@ -248,7 +249,7 @@ librecrypt_check_settings_(const char *settings, size_t len, const char *fmt, ..
goto outable_done;
} else {
- abort();
+ abort(); /* $covered$ */
outable_done:
output = 0;
@@ -266,16 +267,526 @@ librecrypt_check_settings_(const char *settings, size_t len, const char *fmt, ..
#else
+#define RANGE(A, B) (uintmax_t)(A), (uintmax_t)(B)
+#define BASE64(A, B) RANGE(A, B), lut, pad, strict_pad
+
+
+static unsigned char lut[256];
+
+
+static void
+check_asterisk(char pad, int strict_pad)
+{
+ uintmax_t u, u2;
+ const char *s, *s2;
+
+ EXPECT(librecrypt_check_settings_("*012", 4u, "%b", BASE64(0, 100)) == 1);
+ EXPECT(librecrypt_check_settings_("*200", 4u, "%b", BASE64(0, 100)) == 0);
+ EXPECT(librecrypt_check_settings_("*012", 4u, "%b", BASE64(100, 200)) == 0);
+ EXPECT(librecrypt_check_settings_("*0", 2u, "%b", BASE64(0, 100)) == 1);
+ EXPECT(librecrypt_check_settings_("*00", 3u, "%b", BASE64(0, 100)) == 1);
+ EXPECT(librecrypt_check_settings_("", 0u, "%b", BASE64(0, 100)) == 1);
+ EXPECT(librecrypt_check_settings_("", 0u, "%b", BASE64(5, 100)) == 0);
+
+ EXPECT(librecrypt_check_settings_("*012.", 5u, "%b.", BASE64(0, 100)) == 1);
+ EXPECT(librecrypt_check_settings_("*012-", 5u, "%b.", BASE64(0, 100)) == 0);
+ EXPECT(librecrypt_check_settings_("*012", 4u, "%b.", BASE64(0, 100)) == 0);
+
+ EXPECT(librecrypt_check_settings_("*2*5", 4u, "%b%b", BASE64(2, 2), BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("*2*4", 4u, "%b%b", BASE64(2, 2), BASE64(5, 5)) == 0);
+
+ EXPECT(librecrypt_check_settings_("*012", 4u, "%h", BASE64(0, 100)) == 1);
+ EXPECT(librecrypt_check_settings_("*200", 4u, "%h", BASE64(0, 100)) == 0);
+ EXPECT(librecrypt_check_settings_("*012", 4u, "%h", BASE64(100, 200)) == 0);
+ EXPECT(librecrypt_check_settings_("*0", 2u, "%h", BASE64(0, 100)) == 1);
+ EXPECT(librecrypt_check_settings_("*00", 3u, "%h", BASE64(0, 100)) == 1);
+ EXPECT(librecrypt_check_settings_("", 0u, "%h", BASE64(0, 100)) == 1);
+ EXPECT(librecrypt_check_settings_("", 0u, "%h", BASE64(5, 100)) == 1);
+
+ EXPECT(librecrypt_check_settings_("*012.", 5u, "%h.", BASE64(0, 100)) == 1);
+ EXPECT(librecrypt_check_settings_("*012-", 5u, "%h.", BASE64(0, 100)) == 0);
+ EXPECT(librecrypt_check_settings_("*012", 4u, "%h.", BASE64(0, 100)) == 0);
+
+ EXPECT(librecrypt_check_settings_("*2*5", 4u, "%h%h", BASE64(2, 2), BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("*2*4", 4u, "%h%h", BASE64(2, 2), BASE64(5, 5)) == 0);
+
+ u = 0u;
+ EXPECT(librecrypt_check_settings_("*012", 4u, "%^b", &u, BASE64(0, 100)) == 1);
+ EXPECT(u == 12u);
+ EXPECT(librecrypt_check_settings_("*200", 4u, "%^b", &u, BASE64(0, 100)) == 0);
+ EXPECT(librecrypt_check_settings_("*012", 4u, "%^b", &u, BASE64(100, 200)) == 0);
+ u = 99u;
+ EXPECT(librecrypt_check_settings_("*0", 2u, "%^b", &u, BASE64(0, 100)) == 1);
+ EXPECT(u == 0u);
+ u = 99u;
+ EXPECT(librecrypt_check_settings_("*00", 3u, "%^b", &u, BASE64(0, 100)) == 1);
+ EXPECT(u == 0u);
+ u = 99u;
+ EXPECT(librecrypt_check_settings_("", 0u, "%^b", &u, BASE64(0, 100)) == 1);
+ EXPECT(u == 0u);
+ EXPECT(librecrypt_check_settings_("", 0u, "%^b", &u, BASE64(5, 100)) == 0);
+
+ EXPECT(librecrypt_check_settings_("*012.", 5u, "%^b.", &u, BASE64(0, 100)) == 1);
+ EXPECT(librecrypt_check_settings_("*012-", 5u, "%^b.", &u, BASE64(0, 100)) == 0);
+ EXPECT(librecrypt_check_settings_("*012", 4u, "%^b.", &u, BASE64(0, 100)) == 0);
+
+ u = u2 = 99u;
+ EXPECT(librecrypt_check_settings_("*2*5", 4u, "%^b%^b", &u, BASE64(2, 2), &u2, BASE64(5, 5)) == 1);
+ EXPECT(u == 2u);
+ EXPECT(u2 == 5u);
+ EXPECT(librecrypt_check_settings_("*2*4", 4u, "%^b%^b", &u, BASE64(2, 2), &u2, BASE64(5, 5)) == 0);
+
+ u = 0u;
+ EXPECT(librecrypt_check_settings_("*012", 4u, "%^h", &u, BASE64(0, 100)) == 1);
+ EXPECT(u == 12u);
+ EXPECT(librecrypt_check_settings_("*200", 4u, "%^h", &u, BASE64(0, 100)) == 0);
+ EXPECT(librecrypt_check_settings_("*012", 4u, "%^h", &u, BASE64(100, 200)) == 0);
+ u = 99u;
+ EXPECT(librecrypt_check_settings_("*0", 2u, "%^h", &u, BASE64(0, 100)) == 1);
+ EXPECT(u == 0u);
+ u = 99u;
+ EXPECT(librecrypt_check_settings_("*00", 3u, "%^h", &u, BASE64(0, 100)) == 1);
+ EXPECT(u == 0u);
+ u = 99u;
+ EXPECT(librecrypt_check_settings_("", 0u, "%^h", &u, BASE64(0, 100)) == 1);
+ EXPECT(u == 0u);
+ u = 99u;
+ EXPECT(librecrypt_check_settings_("", 0u, "%^h", &u, BASE64(5, 100)) == 1);
+ EXPECT(u == 0u);
+
+ EXPECT(librecrypt_check_settings_("*012.", 5u, "%^h.", &u, BASE64(0, 100)) == 1);
+ EXPECT(librecrypt_check_settings_("*012-", 5u, "%^h.", &u, BASE64(0, 100)) == 0);
+ EXPECT(librecrypt_check_settings_("*012", 4u, "%^h.", &u, BASE64(0, 100)) == 0);
+
+ u = u2 = 99u;
+ EXPECT(librecrypt_check_settings_("*2*5", 4u, "%^h%^h", &u, BASE64(2, 2), &u2, BASE64(5, 5)) == 1);
+ EXPECT(u == 2u);
+ EXPECT(u2 == 5u);
+ EXPECT(librecrypt_check_settings_("*2*4", 4u, "%^h%^h", &u, BASE64(2, 2), &u2, BASE64(5, 5)) == 0);
+
+ s = "";
+ u = 99u;
+ EXPECT(librecrypt_check_settings_("*5.", 3, "%&b.", &s, &u, BASE64(2, 100)) == 1);
+ EXPECT(s == NULL);
+ EXPECT(u == 5u);
+
+ s = "";
+ u = 99u;
+ EXPECT(librecrypt_check_settings_("*5", 2, "%&b", &s, &u, BASE64(2, 100)) == 1);
+ EXPECT(s == NULL);
+ EXPECT(u == 5u);
+
+ EXPECT(librecrypt_check_settings_("*5", 2, "%&b", &s, &u, BASE64(1, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("*5", 2, "%&b", &s, &u, BASE64(6, 9)) == 0);
+
+ s = s2 = "";
+ u = u2 = 99u;
+ EXPECT(librecrypt_check_settings_("*5*10", 5, "%&b%&b", &s, &u, BASE64(2, 100), &s2, &u2, BASE64(2, 100)) == 1);
+ EXPECT(s == NULL);
+ EXPECT(u == 5u);
+ EXPECT(s2 == NULL);
+ EXPECT(u2 == 10u);
+
+ EXPECT(librecrypt_check_settings_("*", 1u, "%b", BASE64(0, 10)) == 0);
+ EXPECT(librecrypt_check_settings_("*", 1u, "%h", BASE64(0, 10)) == 0);
+ EXPECT(librecrypt_check_settings_("*", 1u, "%^b", &u, BASE64(0, 10)) == 0);
+ EXPECT(librecrypt_check_settings_("*", 1u, "%^h", &u, BASE64(0, 10)) == 0);
+ EXPECT(librecrypt_check_settings_("*", 1u, "%&b", &s, &u, BASE64(0, 10)) == 0);
+ EXPECT(librecrypt_check_settings_("*", 1u, "%&h", &s, &u, BASE64(0, 10)) == 0);
+ EXPECT(librecrypt_check_settings_("*x", 2u, "%b", BASE64(0, 10)) == 0);
+ EXPECT(librecrypt_check_settings_("*x", 2u, "%h", BASE64(0, 10)) == 0);
+ EXPECT(librecrypt_check_settings_("*x", 2u, "%^b", &u, BASE64(0, 10)) == 0);
+ EXPECT(librecrypt_check_settings_("*x", 2u, "%^h", &u, BASE64(0, 10)) == 0);
+ EXPECT(librecrypt_check_settings_("*x", 2u, "%&b", &s, &u, BASE64(0, 10)) == 0);
+ EXPECT(librecrypt_check_settings_("*x", 2u, "%&h", &s, &u, BASE64(0, 10)) == 0);
+}
+
+
+static void
+check_base64(char pad, int strict_pad)
+{
+ uintmax_t u;
+ const char *s;
+
+ EXPECT(librecrypt_check_settings_("", 0u, "%b", BASE64(0, 100)) == 1);
+ EXPECT(librecrypt_check_settings_("", 0u, "%b", BASE64(1, 100)) == 0);
+ EXPECT(librecrypt_check_settings_("abcd", 4u, "%b", BASE64(3, 3)) == 1);
+ EXPECT(librecrypt_check_settings_("abcd", 4u, "%b", BASE64(4, 4)) == 0);
+
+ EXPECT(librecrypt_check_settings_("", 0u, "%h", BASE64(0, 100)) == 1);
+ EXPECT(librecrypt_check_settings_("", 0u, "%h", BASE64(1, 100)) == 1);
+ EXPECT(librecrypt_check_settings_("abcd", 4u, "%h", BASE64(3, 3)) == 1);
+ EXPECT(librecrypt_check_settings_("abcd", 4u, "%h", BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("abcd", 4u, "%h", BASE64(2, 2)) == 0);
+
+ u = 99u;
+ EXPECT(librecrypt_check_settings_("", 0u, "%^b", &u, BASE64(0, 100)) == 1);
+ EXPECT(u == 0u);
+ EXPECT(librecrypt_check_settings_("", 0u, "%^b", &u, BASE64(1, 100)) == 0);
+ u = 99u;
+ EXPECT(librecrypt_check_settings_("abcd", 4u, "%^b", &u, BASE64(3, 3)) == 1);
+ EXPECT(u == 3u);
+ EXPECT(librecrypt_check_settings_("abcd", 4u, "%^b", &u, BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("abcd", 4u, "%^b", &u, BASE64(2, 2)) == 0);
+
+ u = 99u;
+ EXPECT(librecrypt_check_settings_("", 0u, "%^h", &u, BASE64(0, 100)) == 1);
+ EXPECT(u == 0u);
+ u = 99u;
+ EXPECT(librecrypt_check_settings_("", 0u, "%^h", &u, BASE64(1, 100)) == 1);
+ EXPECT(u == 0u);
+ u = 99u;
+ EXPECT(librecrypt_check_settings_("abcd", 4u, "%^h", &u, BASE64(3, 3)) == 1);
+ EXPECT(u == 3u);
+ EXPECT(librecrypt_check_settings_("abcd", 4u, "%^h", &u, BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("abcd", 4u, "%^h", &u, BASE64(2, 2)) == 0);
+
+ s = NULL;
+ u = 99u;
+ EXPECT(librecrypt_check_settings_("_", 1u, "_%&b", &s, &u, BASE64(0, 100)) == 1);
+ EXPECT(u == 0u);
+ EXPECT(s && !strcmp(s, ""));
+ EXPECT(librecrypt_check_settings_("_", 1u, "_%&b", &s, &u, BASE64(1, 100)) == 0);
+ s = NULL;
+ u = 99u;
+ EXPECT(librecrypt_check_settings_("_abcd", 5u, "_%&b", &s, &u, BASE64(3, 3)) == 1);
+ EXPECT(u == 4u);
+ EXPECT(s && !strcmp(s, "abcd"));
+ EXPECT(librecrypt_check_settings_("_abcd", 5u, "_%&b", &s, &u, BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("_abcd", 5u, "_%&b", &s, &u, BASE64(2, 2)) == 0);
+
+ s = NULL;
+ u = 99u;
+ EXPECT(librecrypt_check_settings_("_", 1u, "_%&h", &s, &u, BASE64(0, 100)) == 1);
+ EXPECT(u == 0u);
+ EXPECT(s && !strcmp(s, ""));
+ s = NULL;
+ u = 99u;
+ EXPECT(librecrypt_check_settings_("_", 1u, "_%&h", &s, &u, BASE64(1, 100)) == 1);
+ EXPECT(u == 0u);
+ EXPECT(s && !strcmp(s, ""));
+ s = NULL;
+ u = 99u;
+ EXPECT(librecrypt_check_settings_("_abcd", 5u, "_%&h", &s, &u, BASE64(3, 3)) == 1);
+ EXPECT(u == 4u);
+ EXPECT(s && !strcmp(s, "abcd"));
+ EXPECT(librecrypt_check_settings_("_abcd", 5u, "_%&h", &s, &u, BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("_abcd", 5u, "_%&h", &s, &u, BASE64(2, 2)) == 0);
+
+ u = 99u;
+ EXPECT(librecrypt_check_settings_("_abcd_", 6u, "_%&b_", &s, &u, BASE64(3, 3)) == 1);
+ EXPECT(u == 4u);
+ EXPECT(s && !strcmp(s, "abcd_"));
+ u = 99u;
+ EXPECT(librecrypt_check_settings_("_abcd_", 6u, "_%&h_", &s, &u, BASE64(3, 3)) == 1);
+ EXPECT(u == 4u);
+ EXPECT(s && !strcmp(s, "abcd_"));
+
+ u = 99u;
+ EXPECT(librecrypt_check_settings_("abcdabcd", 8u, "%&b", &s, &u, BASE64(6, 6)) == 1);
+ EXPECT(u == 8u);
+ EXPECT(s && strlen(s) == u);
+
+ u = 99u;
+ EXPECT(librecrypt_check_settings_("abcdabcd", 8u, "%&h", &s, &u, BASE64(6, 6)) == 1);
+ EXPECT(u == 8u);
+ EXPECT(s && strlen(s) == u);
+
+ EXPECT(librecrypt_check_settings_("abcda", 5u, "%&b", &s, &u, BASE64(1, 10)) == 0);
+ EXPECT(librecrypt_check_settings_("abcda---", 8u, "%&b", &s, &u, BASE64(1, 10)) == 0);
+ EXPECT(librecrypt_check_settings_("abcda---", 8u, "%&b---", &s, &u, BASE64(1, 10)) == 0);
+ EXPECT(librecrypt_check_settings_("abcda", 5u, "%&h", &s, &u, BASE64(1, 10)) == 0);
+ EXPECT(librecrypt_check_settings_("abcda---", 8u, "%&h", &s, &u, BASE64(1, 10)) == 0);
+ EXPECT(librecrypt_check_settings_("abcda---", 8u, "%&h---", &s, &u, BASE64(1, 10)) == 0);
+
+ if (pad && strict_pad) {
+ EXPECT(librecrypt_check_settings_("abcdab", 6u, "%&b", &s, &u, BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdab", 6u, "%&h", &s, &u, BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdabc", 7u, "%&b", &s, &u, BASE64(5, 5)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdabc", 7u, "%&h", &s, &u, BASE64(5, 5)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%&b", &s, &u, BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%&h", &s, &u, BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%&b", &s, &u, BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%&h", &s, &u, BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%&b--", &s, &u, BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%&h--", &s, &u, BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%&b-", &s, &u, BASE64(5, 5)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%&h-", &s, &u, BASE64(5, 5)) == 0);
+ } else if (pad) {
+ EXPECT(librecrypt_check_settings_("abcdab", 6u, "%&b", &s, &u, BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdab", 6u, "%&h", &s, &u, BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc", 7u, "%&b", &s, &u, BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc", 7u, "%&h", &s, &u, BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%&b", &s, &u, BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%&h", &s, &u, BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%&b", &s, &u, BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%&h", &s, &u, BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%&b--", &s, &u, BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%&h--", &s, &u, BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%&b-", &s, &u, BASE64(5, 5)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%&h-", &s, &u, BASE64(5, 5)) == 0);
+ } else {
+ EXPECT(librecrypt_check_settings_("abcdab", 6u, "%&b", &s, &u, BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdab", 6u, "%&h", &s, &u, BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc", 7u, "%&b", &s, &u, BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc", 7u, "%&h", &s, &u, BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%&b", &s, &u, BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%&h", &s, &u, BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%&b", &s, &u, BASE64(5, 5)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%&h", &s, &u, BASE64(5, 5)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%&b--", &s, &u, BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%&h--", &s, &u, BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%&b-", &s, &u, BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%&h-", &s, &u, BASE64(5, 5)) == 1);
+ }
+
+ if (pad && strict_pad) {
+ EXPECT(librecrypt_check_settings_("abcdab", 6u, "%^b", &u, BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdab", 6u, "%^h", &u, BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdabc", 7u, "%^b", &u, BASE64(5, 5)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdabc", 7u, "%^h", &u, BASE64(5, 5)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%^b", &u, BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%^h", &u, BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%^b", &u, BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%^h", &u, BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%^b--", &u, BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%^h--", &u, BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%^b-", &u, BASE64(5, 5)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%^h-", &u, BASE64(5, 5)) == 0);
+ } else if (pad) {
+ EXPECT(librecrypt_check_settings_("abcdab", 6u, "%^b", &u, BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdab", 6u, "%^h", &u, BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc", 7u, "%^b", &u, BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc", 7u, "%^h", &u, BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%^b", &u, BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%^h", &u, BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%^b", &u, BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%^h", &u, BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%^b--", &u, BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%^h--", &u, BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%^b-", &u, BASE64(5, 5)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%^h-", &u, BASE64(5, 5)) == 0);
+ } else {
+ EXPECT(librecrypt_check_settings_("abcdab", 6u, "%^b", &u, BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdab", 6u, "%^h", &u, BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc", 7u, "%^b", &u, BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc", 7u, "%^h", &u, BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%^b", &u, BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%^h", &u, BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%^b", &u, BASE64(5, 5)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%^h", &u, BASE64(5, 5)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%^b--", &u, BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%^h--", &u, BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%^b-", &u, BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%^h-", &u, BASE64(5, 5)) == 1);
+ }
+
+ if (pad && strict_pad) {
+ EXPECT(librecrypt_check_settings_("abcdab", 6u, "%b", BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdab", 6u, "%h", BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdabc", 7u, "%b", BASE64(5, 5)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdabc", 7u, "%h", BASE64(5, 5)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%b", BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%h", BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%b", BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%h", BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%b--", BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%h--", BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%b-", BASE64(5, 5)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%h-", BASE64(5, 5)) == 0);
+ } else if (pad) {
+ EXPECT(librecrypt_check_settings_("abcdab", 6u, "%b", BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdab", 6u, "%h", BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc", 7u, "%b", BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc", 7u, "%h", BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%b", BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%h", BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%b", BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%h", BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%b--", BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%h--", BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%b-", BASE64(5, 5)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%h-", BASE64(5, 5)) == 0);
+ } else {
+ EXPECT(librecrypt_check_settings_("abcdab", 6u, "%b", BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdab", 6u, "%h", BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc", 7u, "%b", BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc", 7u, "%h", BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%b", BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%h", BASE64(4, 4)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%b", BASE64(5, 5)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%h", BASE64(5, 5)) == 0);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%b--", BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdab--", 8u, "%h--", BASE64(4, 4)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%b-", BASE64(5, 5)) == 1);
+ EXPECT(librecrypt_check_settings_("abcdabc-", 8u, "%h-", BASE64(5, 5)) == 1);
+ }
+}
+
+
+static int discarded_int;
+
int
main(void)
{
+ const char *s, *s2;
+ uintmax_t u, u2;
+
SET_UP_ALARM();
+ INIT_TEST_ABORT();
INIT_RESOURCE_TEST();
+ memset(lut, 255, sizeof(lut));
+ lut['a'] = lut['b'] = lut['c'] = lut['d'] = 0;
+
+ EXPECT(librecrypt_check_settings_("", 0u, "") == 1);
+ EXPECT(librecrypt_check_settings_("hej", 3u, "hej") == 1);
+ EXPECT(librecrypt_check_settings_("hej", 2u, "hej") == 0);
+ EXPECT(librecrypt_check_settings_("hej", 4u, "hej") == 0);
+ EXPECT(librecrypt_check_settings_("tja", 3u, "hej") == 0);
+
+ EXPECT(librecrypt_check_settings_("%", 1u, "%%") == 1);
+ EXPECT(librecrypt_check_settings_("%", 0u, "%%") == 0);
+
+ EXPECT(librecrypt_check_settings_("hello", 5u, "%*") == 1);
+ EXPECT(librecrypt_check_settings_("hello$world", 11u, "%*$world") == 1);
+ EXPECT(librecrypt_check_settings_("hello$world", 11u, "%*$WORLD") == 0);
+
+ EXPECT(librecrypt_check_settings_("hej.", 4u, "%s.", "hej", "tja", NULL) == 1);
+ EXPECT(librecrypt_check_settings_("tja.", 4u, "%s.", "hej", "tja", NULL) == 1);
+ EXPECT(librecrypt_check_settings_("bye.", 4u, "%s.", "hej", "tja", NULL) == 0);
+ EXPECT(librecrypt_check_settings_("hej-", 4u, "%s.", "hej", "tja", NULL) == 0);
+ EXPECT(librecrypt_check_settings_("tja-", 4u, "%s.", "hej", "tja", NULL) == 0);
+ EXPECT(librecrypt_check_settings_("bye-", 4u, "%s.", "hej", "tja", NULL) == 0);
+ EXPECT(librecrypt_check_settings_("hej.", 3u, "%s.", "hej", "tja", NULL) == 0);
+ EXPECT(librecrypt_check_settings_("tja.", 3u, "%s.", "hej", "tja", NULL) == 0);
+ EXPECT(librecrypt_check_settings_("bye.", 3u, "%s.", "hej", "tja", NULL) == 0);
+ EXPECT(librecrypt_check_settings_("hej.", 3u, "%s", "hej", "tja", NULL) == 1);
+ EXPECT(librecrypt_check_settings_("tja.", 3u, "%s", "hej", "tja", NULL) == 1);
+ EXPECT(librecrypt_check_settings_("bye.", 3u, "%s", "hej", "tja", NULL) == 0);
+ EXPECT(librecrypt_check_settings_("hej.", 4u, "%s", "hej", "tja", NULL) == 0);
+ EXPECT(librecrypt_check_settings_("tja.", 4u, "%s", "hej", "tja", NULL) == 0);
+ EXPECT(librecrypt_check_settings_("bye.", 4u, "%s", "hej", "tja", NULL) == 0);
+ EXPECT(librecrypt_check_settings_(".", 1u, "%s.", "hej", "tja", "", NULL) == 1);
+ EXPECT(librecrypt_check_settings_("tja.", 4u, "%s.", "hej", "tja", "", NULL) == 1);
+ EXPECT(librecrypt_check_settings_("tja.", 4u, "%s.", "", "hej", "tja", NULL) == 0);
+ EXPECT(librecrypt_check_settings_("tja.", 4u, "%s.", NULL) == 0);
+
+ EXPECT(librecrypt_check_settings_("hejsan", 1u, "%s", "hej", NULL) == 0);
+ EXPECT(librecrypt_check_settings_("hejsan", 3u, "%s", "hej", NULL) == 1);
+ EXPECT(librecrypt_check_settings_("hejsan", 6u, "%s", "hej", NULL) == 0);
+
+ s = NULL;
+ EXPECT(librecrypt_check_settings_("hej.", 4u, "%^s.", &s, "hej", "tja", "", NULL) == 1);
+ EXPECT(s && !strcmp(s, "hej"));
+ s = NULL;
+ EXPECT(librecrypt_check_settings_("tja.", 4u, "%^s.", &s, "hej", "tja", "", NULL) == 1);
+ EXPECT(s && !strcmp(s, "tja"));
+ s = NULL;
+ EXPECT(librecrypt_check_settings_(".", 1u, "%^s.", &s, "hej", "tja", "", NULL) == 1);
+ EXPECT(s && !strcmp(s, ""));
+
+ EXPECT(librecrypt_check_settings_("10.", 3u, "%p.", RANGE(1, 10)) == 1);
+ EXPECT(librecrypt_check_settings_("10.", 3u, "%p.", RANGE(10, 20)) == 1);
+ EXPECT(librecrypt_check_settings_("10.", 3u, "%p.", RANGE(1, 20)) == 1);
+ EXPECT(librecrypt_check_settings_("10.", 3u, "%p.", RANGE(1, 9)) == 0);
+ EXPECT(librecrypt_check_settings_("10.", 3u, "%p.", RANGE(11, 20)) == 0);
+ EXPECT(librecrypt_check_settings_("0.", 2u, "%p.", RANGE(1, 10)) == 0);
+ EXPECT(librecrypt_check_settings_("0.", 2u, "%p.", RANGE(0, 10)) == 1);
+ EXPECT(librecrypt_check_settings_("00.", 3u, "%p.", RANGE(0, 10)) == 0);
+ EXPECT(librecrypt_check_settings_("010.", 4u, "%p.", RANGE(1, 10)) == 0);
+
+ EXPECT(librecrypt_check_settings_("10.", 3u, "%u.", RANGE(1, 10)) == 1);
+ EXPECT(librecrypt_check_settings_("10.", 3u, "%u.", RANGE(10, 20)) == 1);
+ EXPECT(librecrypt_check_settings_("10.", 3u, "%u.", RANGE(1, 20)) == 1);
+ EXPECT(librecrypt_check_settings_("10.", 3u, "%u.", RANGE(1, 9)) == 0);
+ EXPECT(librecrypt_check_settings_("10.", 3u, "%u.", RANGE(11, 20)) == 0);
+ EXPECT(librecrypt_check_settings_("0.", 2u, "%u.", RANGE(1, 10)) == 0);
+ EXPECT(librecrypt_check_settings_("0.", 2u, "%u.", RANGE(0, 10)) == 1);
+ EXPECT(librecrypt_check_settings_("00.", 3u, "%u.", RANGE(0, 10)) == 1);
+ EXPECT(librecrypt_check_settings_("010.", 4u, "%u.", RANGE(1, 10)) == 1);
+
+ u = 99u;
+ EXPECT(librecrypt_check_settings_("10.", 3u, "%^p.", &u, RANGE(0, 100)) == 1);
+ EXPECT(u == 10u);
+ EXPECT(librecrypt_check_settings_("15.", 3u, "%^p.", &u, RANGE(0, 100)) == 1);
+ EXPECT(u == 15u);
+ EXPECT(librecrypt_check_settings_("0.", 2u, "%^p.", &u, RANGE(0, 100)) == 1);
+ EXPECT(u == 0u);
+
+ u = 99u;
+ EXPECT(librecrypt_check_settings_("10.", 3u, "%^u.", &u, RANGE(0, 100)) == 1);
+ EXPECT(u == 10u);
+ EXPECT(librecrypt_check_settings_("15.", 3u, "%^u.", &u, RANGE(0, 100)) == 1);
+ EXPECT(u == 15u);
+ EXPECT(librecrypt_check_settings_("0.", 2u, "%^u.", &u, RANGE(0, 100)) == 1);
+ EXPECT(u == 0u);
+ EXPECT(librecrypt_check_settings_("010.", 4u, "%^u.", &u, RANGE(0, 100)) == 1);
+ EXPECT(u == 10u);
+ EXPECT(librecrypt_check_settings_("015.", 4u, "%^u.", &u, RANGE(0, 100)) == 1);
+ EXPECT(u == 15u);
+ EXPECT(librecrypt_check_settings_("00.", 3u, "%^u.", &u, RANGE(0, 100)) == 1);
+ EXPECT(u == 0u);
+
+ EXPECT(librecrypt_check_settings_("10.15.", 6u, "%u.%u.", RANGE(1, 10), RANGE(11, 20)) == 1);
+ EXPECT(librecrypt_check_settings_("10.10.", 6u, "%u.%u.", RANGE(1, 10), RANGE(11, 20)) == 0);
+ EXPECT(librecrypt_check_settings_("15.10.", 6u, "%u.%u.", RANGE(1, 10), RANGE(11, 20)) == 0);
+
+ u = 99u;
+ u2 = 99u;
+ EXPECT(librecrypt_check_settings_("10.15.", 6u, "%^u.%^u.", &u, RANGE(1, 10), &u2, RANGE(11, 20)) == 1);
+ EXPECT(u == 10u);
+ EXPECT(u2 == 15u);
+
+ EXPECT(librecrypt_check_settings_("", 0u, "%p", RANGE(0, 10)) == 0);
+ EXPECT(librecrypt_check_settings_("a", 1u, "%p", RANGE(0, 10)) == 0);
+ EXPECT(librecrypt_check_settings_("", 0u, "%u", RANGE(0, 10)) == 0);
+ EXPECT(librecrypt_check_settings_("a", 1u, "%u", RANGE(0, 10)) == 0);
+ EXPECT(librecrypt_check_settings_("", 0u, "%^p", &u, RANGE(0, 10)) == 0);
+ EXPECT(librecrypt_check_settings_("a", 1u, "%^p", &u, RANGE(0, 10)) == 0);
+ EXPECT(librecrypt_check_settings_("", 0u, "%^u", &u, RANGE(0, 10)) == 0);
+ EXPECT(librecrypt_check_settings_("a", 1u, "%^u", &u, RANGE(0, 10)) == 0);
+
+ EXPECT(librecrypt_check_settings_("hej.hello.", 10u, "%s.%s.", "hej", NULL, "hello", NULL) == 1);
+ EXPECT(librecrypt_check_settings_("hello.hej.", 10u, "%s.%s.", "hej", NULL, "hello", NULL) == 0);
+
+ EXPECT(librecrypt_check_settings_("hejsan", 1u, "%^s", &s, "hej", NULL) == 0);
+ s = NULL;
+ EXPECT(librecrypt_check_settings_("hejsan", 3u, "%^s", &s, "hej", NULL) == 1);
+ EXPECT(s && !strcmp(s, "hej"));
+ EXPECT(librecrypt_check_settings_("hejsan", 6u, "%^s", &s, "hej", NULL) == 0);
+
+ s = NULL;
+ s2 = NULL;
+ EXPECT(librecrypt_check_settings_("hej.hello.", 10u, "%^s.%^s.", &s, "x", "hej", NULL, &s2, "y", "hello", NULL) == 1);
+ EXPECT(s && !strcmp(s, "hej"));
+ EXPECT(s2 && !strcmp(s2, "hello"));
+
+ s = NULL;
+ s2 = NULL;
+ EXPECT(librecrypt_check_settings_("x.y.", 4u, "%^s.%^s.", &s, "x", "hej", NULL, &s2, "y", "hello", NULL) == 1);
+ EXPECT(s && !strcmp(s, "x"));
+ EXPECT(s2 && !strcmp(s2, "y"));
+
+ check_asterisk('-', 0);
+ check_asterisk('-', 1);
+ check_asterisk('\0', 0);
+ check_asterisk('\0', 1);
+
+ check_base64('-', 0);
+ check_base64('-', 1);
+ check_base64('\0', 0);
+ check_base64('\0', 1);
+
+#define S(STR) (STR), (sizeof(STR) - 1u)
+#define LARGE "999999999999999999999999999999999999999"
+ EXPECT(librecrypt_check_settings_(S(LARGE LARGE LARGE LARGE), "%p", RANGE(0, UINTMAX_MAX)) == 0);
+
+ EXPECT_ABORT(discarded_int = librecrypt_check_settings_("", 0u, "%\xFF", 0, 0, 0, 0, 0, 0, 0));
+
STOP_RESOURCE_TEST();
return 0;
}
#endif
-/* TODO test */
diff --git a/librecrypt_find_first_algorithm_.c b/librecrypt_find_first_algorithm_.c
index 34aa03e..6bbfe70 100644
--- a/librecrypt_find_first_algorithm_.c
+++ b/librecrypt_find_first_algorithm_.c
@@ -40,16 +40,37 @@ librecrypt_find_first_algorithm_(const char *settings, size_t len)
#else
+#define NSA "$~no~such~algorithm~$"
+
+
+#define CHECK(ALGO)\
+ do {\
+ algo = librecrypt_find_first_algorithm_(ALGO, sizeof(ALGO) - 1u);\
+ EXPECT(algo != NULL);\
+ EXPECT((*algo->is_algorithm)(ALGO, sizeof(ALGO) - 1u) > 0u);\
+ EXPECT(librecrypt_find_first_algorithm_(ALGO">"NSA, sizeof(ALGO">"NSA) - 1u) == algo);\
+ } while (0)
+
+
int
main(void)
{
+ const struct algorithm *algo;
+
SET_UP_ALARM();
INIT_RESOURCE_TEST();
+ EXPECT(librecrypt_find_first_algorithm_(NSA, sizeof(NSA) - 1u) == NULL);
+ EXPECT(librecrypt_find_first_algorithm_(NSA">", sizeof(NSA">") - 1u) == NULL);
+
+ IF__argon2i__SUPPORTED(CHECK("$argon2i$"));
+ IF__argon2d__SUPPORTED(CHECK("$argon2d$"));
+ IF__argon2id__SUPPORTED(CHECK("$argon2id$"));
+ IF__argon2ds__SUPPORTED(CHECK("$argon2ds$"));
+
STOP_RESOURCE_TEST();
return 0;
}
#endif
-/* TODO test */
diff --git a/librecrypt_get_encoding.c b/librecrypt_get_encoding.c
index 5867758..f253e70 100644
--- a/librecrypt_get_encoding.c
+++ b/librecrypt_get_encoding.c
@@ -36,16 +36,105 @@ librecrypt_get_encoding(const char *settings, size_t len, char *pad_out, int *st
#else
+#define NSA "$~no~such~algorithm~$"
+
+
+static int
+check_encoding_lut(const char *lut, const char *alpha)
+{
+ size_t i;
+ for (i = 0u; i < 256u; i++)
+ if (lut[i] != alpha[i % 64u])
+ return 0;
+ return 1;
+}
+
+
+static int
+check_decoding_lut(const unsigned char *lut, const char *alpha)
+{
+ size_t i, invalid_count = 0u;
+ for (i = 0u; i < 64u; i++)
+ if (lut[(unsigned char)alpha[i]] != (unsigned char)i)
+ return 0;
+ for (i = 0u; i < 256u; i++) {
+ if (lut[i] == 0xFFu)
+ invalid_count += 1u;
+ else
+ EXPECT(lut[i] < 64u);
+ }
+ return invalid_count == 256u - 64u;
+}
+
+
+#define CHECK(PREFIX, ALPHABET, PAD, STRICT_PAD) \
+ do {\
+ pad = (char)~(PAD);\
+ strict_pad = -1;\
+ elut = librecrypt_get_encoding(PREFIX, sizeof(PREFIX) - 1u, &pad, &strict_pad, 0);\
+ EXPECT(elut != NULL);\
+ EXPECT(pad == (PAD));\
+ EXPECT(strict_pad == (STRICT_PAD));\
+ EXPECT(check_encoding_lut(elut, ALPHABET));\
+ \
+ pad = (char)~(PAD);\
+ strict_pad = -1;\
+ dlut = librecrypt_get_encoding(PREFIX, sizeof(PREFIX) - 1u, &pad, &strict_pad, 1);\
+ EXPECT(dlut != NULL);\
+ EXPECT(pad == (PAD));\
+ EXPECT(strict_pad == (STRICT_PAD));\
+ EXPECT(check_decoding_lut(dlut, ALPHABET));\
+ \
+ pad = (char)~(PAD);\
+ strict_pad = -1;\
+ elut = librecrypt_get_encoding(NSA">"PREFIX, sizeof(NSA">"PREFIX) - 1u, &pad, &strict_pad, 0);\
+ EXPECT(elut != NULL);\
+ EXPECT(pad == (PAD));\
+ EXPECT(strict_pad == (STRICT_PAD));\
+ EXPECT(check_encoding_lut(elut, ALPHABET));\
+ } while (0)
+
+
+#define DIGIT "0123456789"
+#define LOWER "abcdefghijklmnopqrstuvwxyz"
+#define UPPER "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+
int
main(void)
{
+ const char *elut;
+ const unsigned char *dlut;
+ char pad;
+ int strict_pad;
+
SET_UP_ALARM();
INIT_RESOURCE_TEST();
+ errno = 0;
+ EXPECT(librecrypt_get_encoding(NSA, 1u, &pad, &strict_pad, 0) == NULL);
+ EXPECT(errno == ENOSYS);
+
+ errno = 0;
+ EXPECT(librecrypt_get_encoding(NSA, 1u, &pad, &strict_pad, 1) == NULL);
+ EXPECT(errno == ENOSYS);
+
+ errno = 0;
+ EXPECT(librecrypt_get_encoding(">"NSA, 1u, &pad, &strict_pad, 0) == NULL);
+ EXPECT(errno == ENOSYS);
+
+ errno = 0;
+ EXPECT(librecrypt_get_encoding(">"NSA, 1u, &pad, &strict_pad, 1) == NULL);
+ EXPECT(errno == ENOSYS);
+
+ IF__argon2i__SUPPORTED(CHECK("$argon2i$", UPPER LOWER DIGIT "+/", '=', 0);)
+ IF__argon2d__SUPPORTED(CHECK("$argon2d$", UPPER LOWER DIGIT "+/", '=', 0);)
+ IF__argon2id__SUPPORTED(CHECK("$argon2id$", UPPER LOWER DIGIT "+/", '=', 0);)
+ IF__argon2ds__SUPPORTED(CHECK("$argon2ds$", UPPER LOWER DIGIT "+/", '=', 0);)
+
STOP_RESOURCE_TEST();
return 0;
}
#endif
-/* TODO test */
diff --git a/librecrypt_make_settings.c b/librecrypt_make_settings.c
index 96ec24a..3efca4c 100644
--- a/librecrypt_make_settings.c
+++ b/librecrypt_make_settings.c
@@ -14,7 +14,7 @@ librecrypt_make_settings(char *out_buffer, size_t size, const char *algorithm, s
/* Select best algorithm if `NULL` is specified */
algo = &librecrypt_algorithms_[0];
if (IS_END_OF_ALGORITHMS(algo))
- goto enosys;
+ goto enosys; /* $covered$ (covered iff reachable: when algorithms are disabled) */
} else {
/* Verify single, unchained algorithm is specified if not `NULL`*/
if (strchr(algorithm, LIBRECRYPT_ALGORITHM_LINK_DELIMITER)) {
@@ -43,16 +43,139 @@ enosys:
#else
+static unsigned char saltbyte = 0u;
+
+
+static ssize_t
+saltgen(void *out, size_t n, void *user)
+{
+ if (!n)
+ return 0;
+ *(unsigned char *)out = *(unsigned char *)user;
+ return 1;
+}
+
+
+static ssize_t
+saltfail(void *out, size_t n, void *user)
+{
+ (void) out;
+ (void) n;
+ (void) user;
+ errno = EDOM;
+ return -1;
+}
+
+
int
main(void)
{
+ char buf[1024];
+ char buf2[sizeof(buf)];
+ int any_supported = 0;
+ int any_salted = 0;
+ ssize_t r;
+
SET_UP_ALARM();
INIT_RESOURCE_TEST();
+ errno = 0;
+ EXPECT(librecrypt_make_settings(NULL, 0, ">", 0u, 0u, 0, NULL, NULL) == -1);
+ EXPECT(errno == EINVAL);
+ errno = 0;
+ EXPECT(librecrypt_make_settings(NULL, 0, "$argon2id$>", 0u, 0u, 0, NULL, NULL) == -1);
+ EXPECT(errno == EINVAL);
+ errno = 0;
+ EXPECT(librecrypt_make_settings(NULL, 0, ">$argon2id$", 0u, 0u, 0, NULL, NULL) == -1);
+ EXPECT(errno == EINVAL);
+ errno = 0;
+ EXPECT(librecrypt_make_settings(NULL, 0, "$argon2id$>$argon2id$", 0u, 0u, 0, NULL, NULL) == -1);
+ EXPECT(errno == EINVAL);
+ errno = 0;
+ EXPECT(librecrypt_make_settings(NULL, 0, "$~no~such~algorithm~$", 0u, 0u, 0, NULL, NULL) == -1);
+ EXPECT(errno == ENOSYS);
+
+#if defined(SUPPORT_ARGON2I)
+ saltbyte = 0u;
+ r = librecrypt_make_settings(buf, sizeof(buf), "$argon2i$", 8192u << 10, (uintmax_t)81920u, 1, &saltgen, &saltbyte);
+ EXPECT(r > 0 && (size_t)r < sizeof(buf));
+ EXPECT(!buf[r] && (size_t)r == strlen(buf));
+ EXPECT(!strcmp(buf, "$argon2i$v=19$m=8192,t=10,p=1$AAAAAAAAAAAAAAAAAAAAAA$*32"));
+ any_supported = 1;
+ any_salted = 1;
+#endif
+
+#if defined(SUPPORT_ARGON2D)
+ saltbyte = 0u;
+ r = librecrypt_make_settings(buf, sizeof(buf), "$argon2d$", 8192u << 10, (uintmax_t)81920u, 1, &saltgen, &saltbyte);
+ EXPECT(r > 0 && (size_t)r < sizeof(buf));
+ EXPECT(!buf[r] && (size_t)r == strlen(buf));
+ EXPECT(!strcmp(buf, "$argon2d$v=19$m=8192,t=10,p=1$AAAAAAAAAAAAAAAAAAAAAA$*32"));
+ any_supported = 1;
+ any_salted = 1;
+#endif
+
+#if defined(SUPPORT_ARGON2ID)
+ saltbyte = 0u;
+ r = librecrypt_make_settings(buf, sizeof(buf), "$argon2id$", 8192u << 10, (uintmax_t)81920u, 1, &saltgen, &saltbyte);
+ EXPECT(r > 0 && (size_t)r < sizeof(buf));
+ EXPECT(!buf[r] && (size_t)r == strlen(buf));
+ EXPECT(!strcmp(buf, "$argon2id$v=19$m=8192,t=10,p=1$AAAAAAAAAAAAAAAAAAAAAA$*32"));
+ any_supported = 1;
+ any_salted = 1;
+#endif
+
+#if defined(SUPPORT_ARGON2DS)
+ saltbyte = 0u;
+ r = librecrypt_make_settings(buf, sizeof(buf), "$argon2ds$", 8192u << 10, (uintmax_t)81920u, 1, &saltgen, &saltbyte);
+ EXPECT(r > 0 && (size_t)r < sizeof(buf));
+ EXPECT(!buf[r] && (size_t)r == strlen(buf));
+ EXPECT(!strcmp(buf, "$argon2ds$v=19$m=8192,t=10,p=1$AAAAAAAAAAAAAAAAAAAAAA$*32"));
+ any_supported = 1;
+ any_salted = 1;
+#endif
+
+ if (any_supported) {
+ EXPECT(librecrypt_make_settings(NULL, 0, NULL, 0u, 0u, 0, NULL, NULL) > 0);
+ EXPECT(librecrypt_make_settings(buf, sizeof(buf), NULL, 0u, 0u, 0, NULL, NULL) > 0);
+
+ if (any_salted) {
+ errno = 0;
+ EXPECT(librecrypt_make_settings(buf, sizeof(buf), NULL, 0u, 0u, 1, &saltfail, NULL) == -1);
+ EXPECT(errno == EDOM);
+ } else {
+ EXPECT(librecrypt_make_settings(buf, sizeof(buf), NULL, 0u, 0u, 1, &saltfail, NULL) > 0);
+ }
+
+ r = librecrypt_make_settings(buf, sizeof(buf), NULL, 0u, 0u, 0, &saltfail, NULL);
+ EXPECT(r > 0 && (size_t)r < sizeof(buf));
+ EXPECT(!buf[r] && (size_t)r == strlen(buf));
+ EXPECT(librecrypt_make_settings(buf2, sizeof(buf2), NULL, 0u, 0u, 0, &saltfail, NULL) == r);
+ EXPECT(!buf2[r] && (size_t)r == strlen(buf2));
+ EXPECT(!strcmp(buf, buf2));
+
+ r = librecrypt_make_settings(buf, sizeof(buf), NULL, 0u, 0u, 0, NULL, NULL);
+ EXPECT(r > 0 && (size_t)r < sizeof(buf));
+ EXPECT(!buf[r] && (size_t)r == strlen(buf));
+ EXPECT(librecrypt_make_settings(buf2, sizeof(buf2), NULL, 0u, 0u, 0, NULL, NULL) == r);
+ EXPECT(!buf2[r] && (size_t)r == strlen(buf2));
+ EXPECT(!strcmp(buf, buf2));
+
+ r = librecrypt_make_settings(buf, sizeof(buf), NULL, 0u, 0u, 1, NULL, NULL);
+ EXPECT(r > 0 && (size_t)r < sizeof(buf));
+ EXPECT(!buf[r] && (size_t)r == strlen(buf));
+ EXPECT(librecrypt_make_settings(buf2, sizeof(buf2), NULL, 0u, 0u, 1, NULL, NULL) == r);
+ EXPECT(!buf2[r] && (size_t)r == strlen(buf2));
+ EXPECT(strcmp(buf, buf2));
+ } else {
+ errno = 0;
+ EXPECT(librecrypt_make_settings(NULL, 0, NULL, 0u, 0u, 0, NULL, NULL) == -1);
+ EXPECT(errno == ENOSYS);
+ }
+
STOP_RESOURCE_TEST();
return 0;
}
#endif
-/* TODO test */
diff --git a/librecrypt_test_supported.c b/librecrypt_test_supported.c
index a0f7d73..520ab68 100644
--- a/librecrypt_test_supported.c
+++ b/librecrypt_test_supported.c
@@ -33,7 +33,7 @@ librecrypt_test_supported(const char *phrase, size_t len, int text, const char *
phrase = NULL;
text = 0;
- /* Goto next algorithm */
+ /* Go to next algorithm */
settings = &settings[n]; /* conf */
settings++; /* '>' */
}
@@ -43,16 +43,38 @@ librecrypt_test_supported(const char *phrase, size_t len, int text, const char *
#else
+#define NSA "$~no~such~algorithm~$"
+
+
+#define CHECK(ALGO, VALID, INVALID)\
+ do {\
+ EXPECT(librecrypt_test_supported(NULL, 4096u, 0, ALGO VALID) == 1);\
+ EXPECT(librecrypt_test_supported(NULL, 4096u, 0, ALGO VALID">"NSA) == 0);\
+ EXPECT(librecrypt_test_supported(NULL, 4096u, 0, NSA">"ALGO VALID) == 0);\
+ EXPECT(librecrypt_test_supported(NULL, 4096u, 0, ALGO VALID">"ALGO VALID) == 1);\
+ EXPECT(librecrypt_test_supported(NULL, 4096u, 0, ALGO INVALID) == 0);\
+ } while (0)
+
+
int
main(void)
{
SET_UP_ALARM();
INIT_RESOURCE_TEST();
+ EXPECT(librecrypt_test_supported("abcdefgh", 8u, 1, NSA) == 0);
+ EXPECT(librecrypt_test_supported("abcdefgh", 8u, 1, NSA">") == 0);
+ EXPECT(librecrypt_test_supported("abcdefgh", 8u, 1, ">"NSA) == 0);
+ EXPECT(librecrypt_test_supported("abcdefgh", 8u, 1, NSA">"NSA) == 0);
+
+ IF__argon2i__SUPPORTED(CHECK("$argon2i$v=19$", "m=8,t=1,p=1$*16$*40", "m=0,t=0,p=0$*1$*1"));
+ IF__argon2d__SUPPORTED(CHECK("$argon2d$v=19$", "m=8,t=1,p=1$*16$*40", "m=0,t=0,p=0$*1$*1"));
+ IF__argon2id__SUPPORTED(CHECK("$argon2id$v=19$", "m=8,t=1,p=1$*16$*40", "m=0,t=0,p=0$*1$*1"));
+ IF__argon2ds__SUPPORTED(CHECK("$argon2ds$v=19$", "m=8,t=1,p=1$*16$*40", "m=0,t=0,p=0$*1$*1"));
+
STOP_RESOURCE_TEST();
return 0;
}
#endif
-/* TODO test */
diff --git a/libtest/Makefile b/libtest/Makefile
index 86b30ed..8eddb00 100644
--- a/libtest/Makefile
+++ b/libtest/Makefile
@@ -1,7 +1,7 @@
.POSIX:
-CONFIGFILE = config.mk
-include $(CONFIGFILE)
+TEST_CONFIGFILE = config.mk
+include $(TEST_CONFIGFILE)
OS = linux
# Linux: linux
diff --git a/libtest/alloc.c b/libtest/alloc.c
index 65eda04..7752091 100644
--- a/libtest/alloc.c
+++ b/libtest/alloc.c
@@ -252,22 +252,26 @@ PURE size_t
void
(free)(void *ptr)
{
- libtest_free_is_custom = 1;
+ if (libtest_free_is_custom < 0) {
+ libtest_free_is_custom = 1;
- assert(libtest_have_custom_malloc());
- assert(libtest_have_custom_calloc());
- assert(libtest_have_custom_realloc());
- assert(libtest_have_custom_reallocarray());
- assert(libtest_have_custom_valloc());
- assert(libtest_have_custom_pvalloc());
- assert(libtest_have_custom_memalign());
- assert(libtest_have_custom_aligned_alloc());
- assert(libtest_have_custom_posix_memalign());
- assert(libtest_have_custom_strdup());
- assert(libtest_have_custom_strndup());
- assert(libtest_have_custom_wcsdup());
- assert(libtest_have_custom_wcsdup());
- assert(libtest_have_custom_memdup());
+ assert(libtest_have_custom_malloc());
+ assert(libtest_have_custom_calloc());
+ assert(libtest_have_custom_realloc());
+ assert(libtest_have_custom_reallocarray());
+ assert(libtest_have_custom_valloc());
+ assert(libtest_have_custom_pvalloc());
+ assert(libtest_have_custom_memalign());
+ assert(libtest_have_custom_aligned_alloc());
+ assert(libtest_have_custom_posix_memalign());
+ assert(libtest_have_custom_strdup());
+ assert(libtest_have_custom_strndup());
+ assert(libtest_have_custom_wcsdup());
+ assert(libtest_have_custom_wcsndup());
+ assert(libtest_have_custom_memdup());
+ }
+
+ libtest_free_is_custom = 1;
if (ptr) {
struct meminfo *meminfo;
@@ -285,13 +289,17 @@ void
void
(free_sized)(void *ptr, size_t size)
{
- libtest_free_sized_is_custom = 1;
+ if (libtest_free_sized_is_custom < 0) {
+ libtest_free_sized_is_custom = 1;
- assert(libtest_have_custom_malloc());
- assert(libtest_have_custom_calloc());
- assert(libtest_have_custom_realloc());
- assert(libtest_have_custom_reallocarray());
- assert(libtest_have_custom_memdup());
+ assert(libtest_have_custom_malloc());
+ assert(libtest_have_custom_calloc());
+ assert(libtest_have_custom_realloc());
+ assert(libtest_have_custom_reallocarray());
+ assert(libtest_have_custom_memdup());
+ }
+
+ libtest_free_sized_is_custom = 1;
if (ptr) {
struct meminfo *meminfo;
@@ -307,11 +315,15 @@ void
void
(free_aligned_sized)(void *ptr, size_t alignment, size_t size)
{
- libtest_free_aligned_sized_is_custom = 1;
+ if (libtest_free_aligned_sized_is_custom < 0) {
+ libtest_free_aligned_sized_is_custom = 1;
- assert(libtest_have_custom_memalign());
- assert(libtest_have_custom_aligned_alloc());
- assert(libtest_have_custom_posix_memalign());
+ assert(libtest_have_custom_memalign());
+ assert(libtest_have_custom_aligned_alloc());
+ assert(libtest_have_custom_posix_memalign());
+ }
+
+ libtest_free_aligned_sized_is_custom = 1;
if (ptr) {
struct meminfo *meminfo;
diff --git a/libtest/config_backtraces=false.mk b/libtest/config_backtraces=false.mk
index 633d25a..ff6b659 100644
--- a/libtest/config_backtraces=false.mk
+++ b/libtest/config_backtraces=false.mk
@@ -1,4 +1,4 @@
-include common-config.mk
+include $(TEST_INCLUDE_PREFIX)common-config.mk
TEST_CPPFLAGS = -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_XOPEN_SOURCE=700 -D_GNU_SOURCE\
$(IMPLEMENT_MMAP_CPPFLAGS)
diff --git a/libtest/config_backtraces=true.mk b/libtest/config_backtraces=true.mk
index 4331d96..aac9cc3 100644
--- a/libtest/config_backtraces=true.mk
+++ b/libtest/config_backtraces=true.mk
@@ -1,4 +1,4 @@
-include common-config.mk
+include $(TEST_INCLUDE_PREFIX)common-config.mk
TEST_CPPFLAGS = -D_DEFAULT_SOURCE -D_BSD_SOURCE -D_XOPEN_SOURCE=700 -D_GNU_SOURCE\
$(IMPLEMENT_MMAP_CPPFLAGS) -DWITH_BACKTRACE
diff --git a/libtest/libtest_free.c b/libtest/libtest_free.c
index 3dcd41c..3e84ba6 100644
--- a/libtest/libtest_free.c
+++ b/libtest/libtest_free.c
@@ -53,6 +53,7 @@ libtest_free(void *ptr, enum libtest_zero_check zero_checking)
for (i = 0u; i < mem->usable_alloc_size; i++) {
if (usable_area[i]) {
memory_zeroed = 0;
+ libtest_expect_zeroed = 0;
break;
}
}
diff --git a/libtest/mmap.c b/libtest/mmap.c
index c12594f..d8a2a60 100644
--- a/libtest/mmap.c
+++ b/libtest/mmap.c
@@ -5,6 +5,11 @@
#include <sys/syscall.h>
+#if !defined(__linux__)
+# errno "Don't know how to implement mmap(3), mumap(3), and mremap(3)"
+#endif
+
+
void *
libtest_real_mmap(void *addr, size_t len, int prot, int flags, int fd, off_t off)
{
generated by cgit v1.2.3-70-g09d2 (git 2.51.0) at 2026-05-20 14:01:48 +0000