1
2#define TEST_NAME "pwhash_argon2id"
3#include "cmptest.h"
4
5#define OUT_LEN 128
6#define OPSLIMIT 3
7#define MEMLIMIT 5000000
8
9static void
10tv(void)
11{
12    static struct {
13        const char *       passwd_hex;
14        size_t             passwd_len;
15        const char *       salt_hex;
16        size_t             outlen;
17        unsigned long long opslimit;
18        size_t             memlimit;
19        unsigned int       lanes;
20    } tests[] = {
21        { "a347ae92bce9f80f6f595a4480fc9c2fe7e7d7148d371e9487d75f5c23008ffae0"
22          "65577a928febd9b1973a5a95073acdbeb6a030cfc0d79caa2dc5cd011cef02c08d"
23          "a232d76d52dfbca38ca8dcbd665b17d1665f7cf5fe59772ec909733b24de97d6f5"
24          "8d220b20c60d7c07ec1fd93c52c31020300c6c1facd77937a597c7a6",
25          127,
26          "5541fbc995d5c197ba290346d2c559dedf405cf97e5f95482143202f9e74f5c2",
27          155, 5, 7256678, 1 },
28        { "e125cee61c8cb7778d9e5ad0a6f5d978ce9f84de213a8556d9ffe202020ab4a6ed"
29          "9074a4eb3416f9b168f137510f3a30b70b96cbfa219ff99f6c6eaffb15c06b60e0"
30          "0cc2890277f0fd3c622115772f7048adaebed86e",
31          86,
32          "f1192dd5dc2368b9cd421338b22433455ee0a3699f9379a08b9650ea2c126f0d",
33          250, 4, 7849083, 1 },
34        { "92263cbf6ac376499f68a4289d3bb59e5a22335eba63a32e6410249155b956b6a3"
35          "b48d4a44906b18b897127300b375b8f834f1ceffc70880a885f47c33876717e392"
36          "be57f7da3ae58da4fd1f43daa7e44bb82d3717af4319349c24cd31e46d295856b0"
37          "441b6b289992a11ced1cc3bf3011604590244a3eb737ff221129215e4e4347f491"
38          "5d41292b5173d196eb9add693be5319fdadc242906178bb6c0286c9b6ca6012746"
39          "711f58c8c392016b2fdfc09c64f0f6b6ab7b",
40          183,
41          "3b840e20e9555e9fb031c4ba1f1747ce25cc1d0ff664be676b9b4a90641ff194",
42          249, 3, 7994791, 1 },
43        { "027b6d8e8c8c474e9b69c7d9ed4f9971e8e1ce2f6ba95048414c3970f0f09b70e3"
44          "b6c5ae05872b3d8678705b7d381829c351a5a9c88c233569b35d6b0b809df44b64"
45          "51a9c273f1150e2ef8a0b5437eb701e373474cd44b97ef0248ebce2ca0400e1b53"
46          "f3d86221eca3f18eb45b702b9172440f774a82cbf1f6f525df30a6e293c873cce6"
47          "9bb078ed1f0d31e7f9b8062409f37f19f8550aae",
48          152,
49          "eb2a3056a09ad2d7d7f975bcd707598f24cd32518cde3069f2e403b34bfee8a5", 5,
50          4, 1397645, 1 },
51        { "4a857e2ee8aa9b6056f2424e84d24a72473378906ee04a46cb05311502d5250b82"
52          "ad86b83c8f20a23dbb74f6da60b0b6ecffd67134d45946ac8ebfb3064294bc097d"
53          "43ced68642bfb8bbbdd0f50b30118f5e",
54          82,
55          "39d82eef32010b8b79cc5ba88ed539fbaba741100f2edbeca7cc171ffeabf258",
56          190, 3, 1432947, 1 },
57        { "c7b09aec680e7b42fedd7fc792e78b2f6c1bea8f4a884320b648f81e8cf515e8ba"
58          "9dcfb11d43c4aae114c1734aa69ca82d44998365db9c93744fa28b63fd16000e82"
59          "61cbbe083e7e2da1e5f696bde0834fe53146d7e0e35e7de9920d041f5a5621aabe"
60          "02da3e2b09b405b77937efef3197bd5772e41fdb73fb5294478e45208063b5f58e"
61          "089dbeb6d6342a909c1307b3fff5fe2cf4da56bdae50848f",
62          156,
63          "039c056d933b475032777edbaffac50f143f64c123329ed9cf59e3b65d3f43b6",
64          178, 3, 4886999, 1 },
65        { "b540beb016a5366524d4605156493f9874514a5aa58818cd0c6dfffaa9e90205f1"
66          "7b",
67          34,
68          "44071f6d181561670bda728d43fb79b443bb805afdebaf98622b5165e01b15fb",
69          231, 1, 1631659, 1 },
70        { "a14975c26c088755a8b715ff2528d647cd343987fcf4aa25e7194a8417fb2b4b3f"
71          "7268da9f3182b4cfb22d138b2749d673a47ecc7525dd15a0a3c66046971784bb63"
72          "d7eae24cc84f2631712075a10e10a96b0e0ee67c43e01c423cb9c44e5371017e9c"
73          "496956b632158da3fe12addecb88912e6759bc37f9af2f45af72c5cae3b179ffb6"
74          "76a697de6ebe45cd4c16d4a9d642d29ddc0186a0a48cb6cd62bfc3dd229d313b30"
75          "1560971e740e2cf1f99a9a090a5b283f35475057e96d7064e2e0fc81984591068d"
76          "55a3b4169f22cccb0745a2689407ea1901a0a766eb99",
77          220,
78          "3d968b2752b8838431165059319f3ff8910b7b8ecb54ea01d3f54769e9d98daf",
79          167, 3, 1784128, 1 },
80    };
81    char          passwd[256];
82    unsigned char salt[crypto_pwhash_SALTBYTES];
83    unsigned char out[256];
84    char          out_hex[256 * 2 + 1];
85    size_t        i = 0U;
86
87    do {
88        sodium_hex2bin((unsigned char *) passwd, sizeof passwd,
89                       tests[i].passwd_hex, strlen(tests[i].passwd_hex), NULL,
90                       NULL, NULL);
91        sodium_hex2bin(salt, sizeof salt, tests[i].salt_hex,
92                       strlen(tests[i].salt_hex), NULL, NULL, NULL);
93        if (crypto_pwhash(out, (unsigned long long) tests[i].outlen, passwd,
94                          tests[i].passwd_len, (const unsigned char *) salt,
95                          tests[i].opslimit, tests[i].memlimit,
96                          crypto_pwhash_alg_default()) != 0) {
97            printf("[tv] pwhash failure (maybe intentional): [%u]\n",
98                   (unsigned int) i);
99            continue;
100        }
101        sodium_bin2hex(out_hex, sizeof out_hex, out, tests[i].outlen);
102        printf("%s\n", out_hex);
103    } while (++i < (sizeof tests) / (sizeof tests[0]));
104}
105
106static void
107tv2(void)
108{
109    static struct {
110        const char *       passwd_hex;
111        size_t             passwd_len;
112        const char *       salt_hex;
113        size_t             outlen;
114        unsigned long long opslimit;
115        size_t             memlimit;
116        unsigned int       lanes;
117    } tests[] = {
118        { "a347ae92bce9f80f6f595a4480fc9c2fe7e7d7148d371e9487d75f5c23008ffae0"
119          "65577a928febd9b1973a5a95073acdbeb6a030cfc0d79caa2dc5cd011cef02c08d"
120          "a232d76d52dfbca38ca8dcbd665b17d1665f7cf5fe59772ec909733b24de97d6f5"
121          "8d220b20c60d7c07ec1fd93c52c31020300c6c1facd77937a597c7a6",
122          127,
123          "5541fbc995d5c197ba290346d2c559dedf405cf97e5f95482143202f9e74f5c2",
124          155, 4, 397645, 1 },
125        { "a347ae92bce9f80f6f595a4480fc9c2fe7e7d7148d371e9487d75f5c23008ffae0"
126          "65577a928febd9b1973a5a95073acdbeb6a030cfc0d79caa2dc5cd011cef02c08d"
127          "a232d76d52dfbca38ca8dcbd665b17d1665f7cf5fe59772ec909733b24de97d6f5"
128          "8d220b20c60d7c07ec1fd93c52c31020300c6c1facd77937a597c7a6",
129          127,
130          "5541fbc995d5c197ba290346d2c559dedf405cf97e5f95482143202f9e74f5c2",
131          155, 3, 397645, 1 },
132    };
133    char          passwd[256];
134    unsigned char salt[crypto_pwhash_SALTBYTES];
135    unsigned char out[256];
136    char          out_hex[256 * 2 + 1];
137    size_t        i = 0U;
138
139    do {
140        sodium_hex2bin((unsigned char *) passwd, sizeof passwd,
141                       tests[i].passwd_hex, strlen(tests[i].passwd_hex), NULL,
142                       NULL, NULL);
143        sodium_hex2bin(salt, sizeof salt, tests[i].salt_hex,
144                       strlen(tests[i].salt_hex), NULL, NULL, NULL);
145        if (crypto_pwhash(out, (unsigned long long) tests[i].outlen, passwd,
146                          tests[i].passwd_len, (const unsigned char *) salt,
147                          tests[i].opslimit, tests[i].memlimit,
148                          crypto_pwhash_alg_default()) != 0) {
149            printf("[tv2] pwhash failure: [%u]\n", (unsigned int) i);
150            continue;
151        }
152        sodium_bin2hex(out_hex, sizeof out_hex, out, tests[i].outlen);
153        printf("%s\n", out_hex);
154    } while (++i < (sizeof tests) / (sizeof tests[0]));
155
156    if (crypto_pwhash_argon2id(out, sizeof out, "password", strlen("password"), salt, 3,
157                               1ULL << 12, 0) != -1) {
158        printf("[tv2] pwhash should have failed (0)\n");
159    }
160    if (crypto_pwhash_argon2id(out, sizeof out, "password", strlen("password"), salt, 3,
161                               1, crypto_pwhash_argon2id_alg_argon2id13()) != -1) {
162        printf("[tv2] pwhash should have failed (1)\n");
163    }
164    if (crypto_pwhash_argon2id(out, sizeof out, "password", strlen("password"), salt, 3,
165                               1ULL << 12, crypto_pwhash_argon2id_alg_argon2id13()) != -1) {
166        printf("[tv2] pwhash should have failed (2)\n");
167    }
168    if (crypto_pwhash_argon2id(out, sizeof out, "password", strlen("password"), salt, 2,
169                               1ULL << 12, crypto_pwhash_argon2id_alg_argon2id13()) != -1) {
170        printf("[tv2] pwhash should have failed (3)\n");
171    }
172    if (crypto_pwhash_argon2id(out, 15, "password", strlen("password"), salt, 3,
173                               1ULL << 12, crypto_pwhash_argon2id_alg_argon2id13()) != -1) {
174        printf("[tv2] pwhash with a short output length should have failed\n");
175    }
176    if (crypto_pwhash_argon2id(out, sizeof out, "password", 0x100000000ULL, salt, 3,
177                               1ULL << 12, crypto_pwhash_argon2id_alg_argon2id13()) != -1) {
178        printf("[tv2] pwhash with a long password length should have failed\n");
179    }
180    assert(crypto_pwhash_argon2id(out, sizeof out, "password", strlen("password"), salt,
181                                  OPSLIMIT, MEMLIMIT, crypto_pwhash_alg_argon2i13()) == -1);
182}
183
184static void
185tv3(void)
186{
187    static struct {
188        const char *passwd;
189        const char *out;
190    } tests[] = {
191        { "",
192          "$argon2id$v=19$m=4096,t=0,p=1$X1NhbHQAAAAAAAAAAAAAAA$bWh++MKN1OiFHKgIWTLvIi1iHicmHH7+Fv3K88ifFfI" },
193        { "",
194          "$argon2id$v=19$m=2048,t=4,p=1$SWkxaUhpY21ISDcrRnYzSw$Mbg/Eck1kpZir5T9io7C64cpffdTBaORgyriLQFgQj8" },
195        { "",
196          "$argon2id$v=19$m=4882,t=2,p=1$bA81arsiXysd3WbTRzmEOw$Nm8QBM+7RH1DXo9rvp5cwKEOOOfD2g6JuxlXihoNcpE" },
197        { "^T5H$JYt39n%K*j:W]!1s?vg!:jGi]Ax?..l7[p0v:1jHTpla9;]bUN;?bWyCbtqg ",
198          "$argon2id$v=19$m=4096,t=0,p=1$PkEgMTYtYnl0ZXMgc2FsdA$ltB/ue1kPtBMBGfsysMpPigE6hiNEKZ9vs8vLNVDQGA" },
199        { "^T5H$JYt39n%K*j:W]!1s?vg!:jGi]Ax?..l7[p0v:1jHTpla9;]bUN;?bWyCbtqg ",
200          "$argon2id$v=19$m=4096,t=19,p=1$PkEgMTYtYnl0ZXMgc2FsdA$ltB/ue1kPtBMBGfsysMpPigE6hiNEKZ9vs8vLNVDQGA" },
201        { "K3S=KyH#)36_?]LxeR8QNKw6X=gFbxai$C%29V*",
202          "$argon2id$v=19$m=4096,t=1,p=3$PkEgcHJldHR5IGxvbmcgc2FsdA$HUqx5Z1b/ZypnUrvvJ5UC2Q+T6Q1WwASK/Kr9dRbGA0" }
203    };
204    char   *out;
205    char   *passwd;
206    size_t  i = 0U;
207    int     ret;
208
209    do {
210        out = (char *) sodium_malloc(strlen(tests[i].out) + 1U);
211        assert(out != NULL);
212        memcpy(out, tests[i].out, strlen(tests[i].out) + 1U);
213        passwd = (char *) sodium_malloc(strlen(tests[i].passwd) + 1U);
214        assert(passwd != NULL);
215        memcpy(passwd, tests[i].passwd, strlen(tests[i].passwd) + 1U);
216        ret = crypto_pwhash_str_verify(out, passwd, strlen(passwd));
217        sodium_free(out);
218        sodium_free(passwd);
219        if (ret != 0) {
220            printf("[tv3] pwhash_argon2id_str failure (maybe intentional): [%u]\n",
221                   (unsigned int) i);
222        }
223    } while (++i < (sizeof tests) / (sizeof tests[0]));
224}
225
226static void
227str_tests(void)
228{
229    char       *str_out;
230    char       *str_out2;
231    char       *salt;
232    const char *passwd = "Correct Horse Battery Staple";
233
234    salt     = (char *) sodium_malloc(crypto_pwhash_argon2id_SALTBYTES);
235    str_out  = (char *) sodium_malloc(crypto_pwhash_argon2id_STRBYTES);
236    str_out2 = (char *) sodium_malloc(crypto_pwhash_argon2id_STRBYTES);
237    memcpy(salt, ">A 16-bytes salt", crypto_pwhash_argon2id_SALTBYTES);
238    if (crypto_pwhash_str(str_out, passwd, strlen(passwd), OPSLIMIT,
239                          MEMLIMIT) != 0) {
240        printf("pwhash_str failure\n");
241    }
242    if (crypto_pwhash_str(str_out2, passwd, strlen(passwd), OPSLIMIT,
243                          MEMLIMIT) != 0) {
244        printf("pwhash_str(2) failure\n");
245    }
246    if (strcmp(str_out, str_out2) == 0) {
247        printf("pwhash_str() doesn't generate different salts\n");
248    }
249    if (crypto_pwhash_str_needs_rehash(str_out, OPSLIMIT, MEMLIMIT) != 0 ||
250        crypto_pwhash_str_needs_rehash(str_out, OPSLIMIT, MEMLIMIT) != 0) {
251        printf("needs_rehash() false positive\n");
252    }
253    if (crypto_pwhash_str_needs_rehash(str_out, OPSLIMIT, MEMLIMIT / 2) != 1 ||
254        crypto_pwhash_str_needs_rehash(str_out, OPSLIMIT - 1, MEMLIMIT) != 1 ||
255        crypto_pwhash_str_needs_rehash(str_out, OPSLIMIT, MEMLIMIT * 2) != 1 ||
256        crypto_pwhash_str_needs_rehash(str_out, OPSLIMIT + 1, MEMLIMIT) != 1) {
257        printf("needs_rehash() false negative (0)\n");
258    }
259    if (crypto_pwhash_argon2id_str_needs_rehash(str_out, OPSLIMIT, MEMLIMIT / 2) != 1 ||
260        crypto_pwhash_argon2id_str_needs_rehash(str_out, OPSLIMIT - 1, MEMLIMIT) != 1 ||
261        crypto_pwhash_argon2id_str_needs_rehash(str_out, OPSLIMIT, MEMLIMIT * 2) != 1 ||
262        crypto_pwhash_argon2id_str_needs_rehash(str_out, OPSLIMIT + 1, MEMLIMIT) != 1) {
263        printf("needs_rehash() false negative (1)\n");
264    }
265    if (crypto_pwhash_argon2i_str_needs_rehash(str_out, OPSLIMIT, MEMLIMIT / 2) != -1 ||
266        crypto_pwhash_argon2i_str_needs_rehash(str_out, OPSLIMIT - 1, MEMLIMIT) != -1 ||
267        crypto_pwhash_argon2i_str_needs_rehash(str_out, OPSLIMIT, MEMLIMIT * 2) != -1 ||
268        crypto_pwhash_argon2i_str_needs_rehash(str_out, OPSLIMIT + 1, MEMLIMIT) != -1) {
269        printf("needs_rehash() false negative (2)\n");
270    }
271    if (crypto_pwhash_str_needs_rehash(str_out, OPSLIMIT, MEMLIMIT / 2) != 1) {
272        printf("pwhash_str_needs_rehash() didn't handle argon2id\n");
273    }
274    if (crypto_pwhash_str_needs_rehash(str_out + 1, OPSLIMIT, MEMLIMIT) != -1 ||
275        crypto_pwhash_argon2id_str_needs_rehash(str_out + 1, OPSLIMIT, MEMLIMIT) != -1) {
276        printf("needs_rehash() didn't fail with an invalid hash string\n");
277    }
278    if (sodium_is_zero((const unsigned char *) str_out + strlen(str_out),
279                       crypto_pwhash_STRBYTES - strlen(str_out)) != 1 ||
280        sodium_is_zero((const unsigned char *) str_out2 + strlen(str_out2),
281                       crypto_pwhash_STRBYTES - strlen(str_out2)) != 1) {
282        printf("pwhash_argon2id_str() doesn't properly pad with zeros\n");
283    }
284    if (crypto_pwhash_argon2id_str_verify(str_out, passwd, strlen(passwd)) != 0) {
285        printf("pwhash_argon2id_str_verify(1) failure\n");
286    }
287    if (crypto_pwhash_str_verify(str_out, passwd, strlen(passwd)) != 0) {
288        printf("pwhash_str_verify(1') failure\n");
289    }
290    str_out[14]++;
291    if (crypto_pwhash_str_verify(str_out, passwd, strlen(passwd)) != -1) {
292        printf("pwhash_argon2id_str_verify(2) failure\n");
293    }
294    str_out[14]--;
295    assert(str_out[crypto_pwhash_argon2id_STRBYTES - 1U] == 0);
296
297    if (crypto_pwhash_str(str_out2, passwd, 0x100000000ULL, OPSLIMIT,
298                          MEMLIMIT) != -1) {
299        printf("pwhash_str() with a large password should have failed\n");
300    }
301    if (crypto_pwhash_str(str_out2, passwd, strlen(passwd), 1, MEMLIMIT) != 0) {
302        printf("pwhash_str() with a small opslimit should not have failed\n");
303    }
304    if (crypto_pwhash_str(str_out2, passwd, strlen(passwd), 0, MEMLIMIT) != -1) {
305        printf("pwhash_argon2id_str() with a null opslimit should have failed\n");
306    }
307    if (crypto_pwhash_str_verify("$argon2id$m=65536,t=2,p=1c29tZXNhbHQ"
308                                 "$9sTbSlTio3Biev89thdrlKKiCaYsjjYVJxGAL3swxpQ",
309                                 "password", 0x100000000ULL) != -1) {
310        printf("pwhash_str_verify(invalid(0)) failure\n");
311    }
312    if (crypto_pwhash_str_verify("$argon2id$m=65536,t=2,p=1c29tZXNhbHQ"
313                                 "$9sTbSlTio3Biev89thdrlKKiCaYsjjYVJxGAL3swxpQ",
314                                 "password", strlen("password")) != -1) {
315        printf("pwhash_str_verify(invalid(1)) failure %d\n", errno);
316    }
317    if (crypto_pwhash_str_verify("$argon2id$m=65536,t=2,p=1$c29tZXNhbHQ"
318                                 "9sTbSlTio3Biev89thdrlKKiCaYsjjYVJxGAL3swxpQ",
319                                 "password", strlen("password")) != -1) {
320        printf("pwhash_str_verify(invalid(2)) failure\n");
321    }
322    if (crypto_pwhash_str_verify("$argon2id$m=65536,t=2,p=1$c29tZXNhbHQ"
323                                 "$b2G3seW+uPzerwQQC+/E1K50CLLO7YXy0JRcaTuswRo",
324                                 "password", strlen("password")) != -1) {
325        printf("pwhash_str_verify(invalid(3)) failure\n");
326    }
327    if (crypto_pwhash_str_verify("$argon2id$v=19$m=65536,t=2,p=1c29tZXNhbHQ"
328                                 "$wWKIMhR9lyDFvRz9YTZweHKfbftvj+qf+YFY4NeBbtA",
329                                 "password", strlen("password")) != -1) {
330        printf("pwhash_str_verify(invalid(4)) failure\n");
331    }
332    if (crypto_pwhash_str_verify("$argon2id$v=19$m=65536,t=2,p=1$c29tZXNhbHQ"
333                                 "wWKIMhR9lyDFvRz9YTZweHKfbftvj+qf+YFY4NeBbtA",
334                                 "password", strlen("password")) != -1) {
335        printf("pwhash_str_verify(invalid(5)) failure\n");
336    }
337    if (crypto_pwhash_str_verify("$argon2id$v=19$m=65536,t=2,p=1$c29tZXNhbHQ"
338                                 "$8iIuixkI73Js3G1uMbezQXD0b8LG4SXGsOwoQkdAQIM",
339                                 "password", strlen("password")) != -1) {
340        printf("pwhash_str_verify(invalid(6)) failure\n");
341    }
342    if (crypto_pwhash_str_verify("$argon2id$v=19$m=256,t=3,p=1$MDEyMzQ1Njc"
343                                 "$G5ajKFCoUzaXRLdz7UJb5wGkb2Xt+X5/GQjUYtS2+TE",
344                                 "password", strlen("password")) != 0) {
345        printf("pwhash_str_verify(valid(7)) failure\n");
346    }
347    if (crypto_pwhash_str_verify("$argon2id$v=19$m=256,t=3,p=1$MDEyMzQ1Njc"
348                                 "$G5ajKFCoUzaXRLdz7UJb5wGkb2Xt+X5/GQjUYtS2+TE",
349                                 "passwore", strlen("passwore")) != -1 || errno != EINVAL) {
350        printf("pwhash_str_verify(invalid(7)) failure\n");
351    }
352    if (crypto_pwhash_str_verify("$Argon2id$v=19$m=256,t=3,p=1$MDEyMzQ1Njc"
353                                 "$G5ajKFCoUzaXRLdz7UJb5wGkb2Xt+X5/GQjUYtS2+TE",
354                                 "password", strlen("password")) != -1 || errno != EINVAL) {
355        printf("pwhash_str_verify(invalid(8)) failure\n");
356    }
357    if (crypto_pwhash_str_verify("$argon2id$v=19$m=256,t=3,p=2$MDEyMzQ1Njc"
358                                 "$G5ajKFCoUzaXRLdz7UJb5wGkb2Xt+X5/GQjUYtS2+TE",
359                                 "password", strlen("password")) != -1 || errno != EINVAL) {
360        printf("pwhash_str_verify(invalid(9)) failure\n");
361    }
362    assert(crypto_pwhash_str_alg(str_out, "test", 4, OPSLIMIT, MEMLIMIT,
363                                 crypto_pwhash_ALG_ARGON2ID13) == 0);
364    assert(crypto_pwhash_argon2id_str_verify(str_out, "test", 4) == 0);
365    assert(crypto_pwhash_argon2id_str_needs_rehash(str_out,
366                                                   OPSLIMIT, MEMLIMIT) == 0);
367    assert(crypto_pwhash_argon2id_str_needs_rehash(str_out,
368                                                   OPSLIMIT / 2, MEMLIMIT) == 1);
369    assert(crypto_pwhash_argon2id_str_needs_rehash(str_out,
370                                                   OPSLIMIT, MEMLIMIT / 2) == 1);
371    assert(crypto_pwhash_argon2id_str_needs_rehash(str_out, 0, 0) == 1);
372    assert(crypto_pwhash_argon2i_str_needs_rehash(str_out, 0, 0) == -1);
373    assert(crypto_pwhash_argon2id_str_needs_rehash(str_out + 1,
374                                                   OPSLIMIT, MEMLIMIT) == -1);
375    assert(crypto_pwhash_argon2i_str_needs_rehash(str_out, 0, 0) == -1);
376    assert(crypto_pwhash_argon2i_str_needs_rehash("", OPSLIMIT, MEMLIMIT) == -1);
377    assert(crypto_pwhash_str_alg(str_out, "test", 4, OPSLIMIT, MEMLIMIT,
378                                 crypto_pwhash_ALG_ARGON2I13) == 0);
379    assert(crypto_pwhash_argon2i_str_verify(str_out, "test", 4) == 0);
380    assert(crypto_pwhash_argon2i_str_needs_rehash(str_out,
381                                                  OPSLIMIT, MEMLIMIT) == 0);
382    assert(crypto_pwhash_argon2i_str_needs_rehash(str_out,
383                                                  OPSLIMIT / 2, MEMLIMIT) == 1);
384    assert(crypto_pwhash_argon2i_str_needs_rehash(str_out,
385                                                  OPSLIMIT, MEMLIMIT / 2) == 1);
386    assert(crypto_pwhash_argon2i_str_needs_rehash(str_out, 0, 0) == 1);
387    assert(crypto_pwhash_argon2id_str_needs_rehash(str_out, 0, 0) == -1);
388    assert(crypto_pwhash_argon2i_str_needs_rehash("", OPSLIMIT, MEMLIMIT) == -1);
389    assert(crypto_pwhash_argon2i_str_needs_rehash(str_out + 1,
390                                                  OPSLIMIT, MEMLIMIT) == -1);
391    sodium_free(salt);
392    sodium_free(str_out);
393    sodium_free(str_out2);
394}
395
396int
397main(void)
398{
399    tv();
400    tv2();
401    tv3();
402    str_tests();
403
404    assert(crypto_pwhash_bytes_min() > 0U);
405    assert(crypto_pwhash_bytes_max() > crypto_pwhash_bytes_min());
406    assert(crypto_pwhash_passwd_max() > crypto_pwhash_passwd_min());
407    assert(crypto_pwhash_saltbytes() > 0U);
408    assert(crypto_pwhash_strbytes() > 1U);
409    assert(crypto_pwhash_strbytes() > strlen(crypto_pwhash_strprefix()));
410
411    assert(crypto_pwhash_opslimit_min() > 0U);
412    assert(crypto_pwhash_opslimit_max() > 0U);
413    assert(crypto_pwhash_memlimit_min() > 0U);
414    assert(crypto_pwhash_memlimit_max() > 0U);
415    assert(crypto_pwhash_opslimit_interactive() > 0U);
416    assert(crypto_pwhash_memlimit_interactive() > 0U);
417    assert(crypto_pwhash_opslimit_moderate() > 0U);
418    assert(crypto_pwhash_memlimit_moderate() > 0U);
419    assert(crypto_pwhash_opslimit_sensitive() > 0U);
420    assert(crypto_pwhash_memlimit_sensitive() > 0U);
421    assert(strcmp(crypto_pwhash_primitive(), "argon2i") == 0);
422
423    assert(crypto_pwhash_bytes_min() == crypto_pwhash_BYTES_MIN);
424    assert(crypto_pwhash_bytes_max() == crypto_pwhash_BYTES_MAX);
425    assert(crypto_pwhash_passwd_min() == crypto_pwhash_PASSWD_MIN);
426    assert(crypto_pwhash_passwd_max() == crypto_pwhash_PASSWD_MAX);
427    assert(crypto_pwhash_saltbytes() == crypto_pwhash_SALTBYTES);
428    assert(crypto_pwhash_strbytes() == crypto_pwhash_STRBYTES);
429
430    assert(crypto_pwhash_opslimit_min() == crypto_pwhash_OPSLIMIT_MIN);
431    assert(crypto_pwhash_opslimit_max() == crypto_pwhash_OPSLIMIT_MAX);
432    assert(crypto_pwhash_memlimit_min() == crypto_pwhash_MEMLIMIT_MIN);
433    assert(crypto_pwhash_memlimit_max() == crypto_pwhash_MEMLIMIT_MAX);
434    assert(crypto_pwhash_opslimit_interactive() ==
435           crypto_pwhash_OPSLIMIT_INTERACTIVE);
436    assert(crypto_pwhash_memlimit_interactive() ==
437           crypto_pwhash_MEMLIMIT_INTERACTIVE);
438    assert(crypto_pwhash_opslimit_moderate() ==
439           crypto_pwhash_OPSLIMIT_MODERATE);
440    assert(crypto_pwhash_memlimit_moderate() ==
441           crypto_pwhash_MEMLIMIT_MODERATE);
442    assert(crypto_pwhash_opslimit_sensitive() ==
443           crypto_pwhash_OPSLIMIT_SENSITIVE);
444    assert(crypto_pwhash_memlimit_sensitive() ==
445           crypto_pwhash_MEMLIMIT_SENSITIVE);
446
447    assert(crypto_pwhash_argon2id_bytes_min() == crypto_pwhash_bytes_min());
448    assert(crypto_pwhash_argon2id_bytes_max() == crypto_pwhash_bytes_max());
449    assert(crypto_pwhash_argon2id_passwd_min() == crypto_pwhash_passwd_min());
450    assert(crypto_pwhash_argon2id_passwd_max() == crypto_pwhash_passwd_max());
451    assert(crypto_pwhash_argon2id_saltbytes() == crypto_pwhash_saltbytes());
452    assert(crypto_pwhash_argon2id_strbytes() == crypto_pwhash_strbytes());
453    assert(strcmp(crypto_pwhash_argon2id_strprefix(),
454                  crypto_pwhash_strprefix()) == 0);
455    assert(crypto_pwhash_argon2id_opslimit_min() ==
456           crypto_pwhash_opslimit_min());
457    assert(crypto_pwhash_argon2id_opslimit_max() ==
458           crypto_pwhash_opslimit_max());
459    assert(crypto_pwhash_argon2id_memlimit_min() ==
460           crypto_pwhash_memlimit_min());
461    assert(crypto_pwhash_argon2id_memlimit_max() ==
462           crypto_pwhash_memlimit_max());
463    assert(crypto_pwhash_argon2id_opslimit_interactive() ==
464           crypto_pwhash_opslimit_interactive());
465    assert(crypto_pwhash_argon2id_opslimit_moderate() ==
466           crypto_pwhash_opslimit_moderate());
467    assert(crypto_pwhash_argon2id_opslimit_sensitive() ==
468           crypto_pwhash_opslimit_sensitive());
469    assert(crypto_pwhash_argon2id_memlimit_interactive() ==
470           crypto_pwhash_memlimit_interactive());
471    assert(crypto_pwhash_argon2id_memlimit_moderate() ==
472           crypto_pwhash_memlimit_moderate());
473    assert(crypto_pwhash_argon2id_memlimit_sensitive() ==
474           crypto_pwhash_memlimit_sensitive());
475    assert(crypto_pwhash_alg_argon2id13() ==
476           crypto_pwhash_argon2id_alg_argon2id13());
477    assert(crypto_pwhash_alg_argon2i13() == crypto_pwhash_ALG_ARGON2I13);
478    assert(crypto_pwhash_alg_argon2i13() != crypto_pwhash_alg_default());
479    assert(crypto_pwhash_alg_argon2id13() == crypto_pwhash_ALG_ARGON2ID13);
480    assert(crypto_pwhash_alg_argon2id13() != crypto_pwhash_alg_argon2i13());
481    assert(crypto_pwhash_alg_argon2id13() == crypto_pwhash_alg_default());
482
483    assert(crypto_pwhash_argon2id(NULL, 0, NULL, 0, NULL,
484                                  crypto_pwhash_argon2id_OPSLIMIT_INTERACTIVE,
485                                  crypto_pwhash_argon2id_MEMLIMIT_INTERACTIVE,
486                                  0) == -1);
487    assert(crypto_pwhash_argon2id(NULL, 0, NULL, 0, NULL,
488                                 crypto_pwhash_argon2id_OPSLIMIT_INTERACTIVE,
489                                 crypto_pwhash_argon2id_MEMLIMIT_INTERACTIVE,
490                                 crypto_pwhash_ALG_ARGON2I13) == -1);
491    assert(crypto_pwhash_argon2i(NULL, 0, NULL, 0, NULL,
492                                 crypto_pwhash_argon2id_OPSLIMIT_INTERACTIVE,
493                                 crypto_pwhash_argon2id_MEMLIMIT_INTERACTIVE,
494                                 0) == -1);
495    assert(crypto_pwhash_argon2i(NULL, 0, NULL, 0, NULL,
496                                 crypto_pwhash_argon2id_OPSLIMIT_INTERACTIVE,
497                                 crypto_pwhash_argon2id_MEMLIMIT_INTERACTIVE,
498                                 crypto_pwhash_ALG_ARGON2ID13) == -1);
499
500    printf("OK\n");
501
502    return 0;
503}
504