Misc

Signed-off-by: Mattias Andrée <m@maandree.se>

4 files changed, 410 insertions, 19 deletions

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 */