rbnacl-libsodium 1.0.11 → 1.0.13

data/vendor/libsodium/src/libsodium/crypto_pwhash/argon2/blamka-round-avx2.h

@@ -0,0 +1,150 @@
+#ifndef blamka_round_avx2_H
+#define blamka_round_avx2_H
+
+#include "private/common.h"
+#include "private/sse2_64_32.h"
+
+#define rotr32(x) _mm256_shuffle_epi32(x, _MM_SHUFFLE(2, 3, 0, 1))
+#define rotr24(x) _mm256_shuffle_epi8(x, _mm256_setr_epi8(3, 4, 5, 6, 7, 0, 1, 2, 11, 12, 13, 14, 15, 8, 9, 10, 3, 4, 5, 6, 7, 0, 1, 2, 11, 12, 13, 14, 15, 8, 9, 10))
+#define rotr16(x) _mm256_shuffle_epi8(x, _mm256_setr_epi8(2, 3, 4, 5, 6, 7, 0, 1, 10, 11, 12, 13, 14, 15, 8, 9, 2, 3, 4, 5, 6, 7, 0, 1, 10, 11, 12, 13, 14, 15, 8, 9))
+#define rotr63(x) _mm256_xor_si256(_mm256_srli_epi64((x), 63), _mm256_add_epi64((x), (x)))
+
+#define G1_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
+    do { \
+        __m256i ml = _mm256_mul_epu32(A0, B0); \
+        ml = _mm256_add_epi64(ml, ml); \
+        A0 = _mm256_add_epi64(A0, _mm256_add_epi64(B0, ml)); \
+        D0 = _mm256_xor_si256(D0, A0); \
+        D0 = rotr32(D0); \
+        \
+        ml = _mm256_mul_epu32(C0, D0); \
+        ml = _mm256_add_epi64(ml, ml); \
+        C0 = _mm256_add_epi64(C0, _mm256_add_epi64(D0, ml)); \
+        \
+        B0 = _mm256_xor_si256(B0, C0); \
+        B0 = rotr24(B0); \
+        \
+        ml = _mm256_mul_epu32(A1, B1); \
+        ml = _mm256_add_epi64(ml, ml); \
+        A1 = _mm256_add_epi64(A1, _mm256_add_epi64(B1, ml)); \
+        D1 = _mm256_xor_si256(D1, A1); \
+        D1 = rotr32(D1); \
+        \
+        ml = _mm256_mul_epu32(C1, D1); \
+        ml = _mm256_add_epi64(ml, ml); \
+        C1 = _mm256_add_epi64(C1, _mm256_add_epi64(D1, ml)); \
+        \
+        B1 = _mm256_xor_si256(B1, C1); \
+        B1 = rotr24(B1); \
+    } while((void)0, 0);
+
+#define G2_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
+    do { \
+        __m256i ml = _mm256_mul_epu32(A0, B0); \
+        ml = _mm256_add_epi64(ml, ml); \
+        A0 = _mm256_add_epi64(A0, _mm256_add_epi64(B0, ml)); \
+        D0 = _mm256_xor_si256(D0, A0); \
+        D0 = rotr16(D0); \
+        \
+        ml = _mm256_mul_epu32(C0, D0); \
+        ml = _mm256_add_epi64(ml, ml); \
+        C0 = _mm256_add_epi64(C0, _mm256_add_epi64(D0, ml)); \
+        B0 = _mm256_xor_si256(B0, C0); \
+        B0 = rotr63(B0); \
+        \
+        ml = _mm256_mul_epu32(A1, B1); \
+        ml = _mm256_add_epi64(ml, ml); \
+        A1 = _mm256_add_epi64(A1, _mm256_add_epi64(B1, ml)); \
+        D1 = _mm256_xor_si256(D1, A1); \
+        D1 = rotr16(D1); \
+        \
+        ml = _mm256_mul_epu32(C1, D1); \
+        ml = _mm256_add_epi64(ml, ml); \
+        C1 = _mm256_add_epi64(C1, _mm256_add_epi64(D1, ml)); \
+        B1 = _mm256_xor_si256(B1, C1); \
+        B1 = rotr63(B1); \
+    } while((void)0, 0);
+
+#define DIAGONALIZE_1(A0, B0, C0, D0, A1, B1, C1, D1) \
+    do { \
+        B0 = _mm256_permute4x64_epi64(B0, _MM_SHUFFLE(0, 3, 2, 1)); \
+        C0 = _mm256_permute4x64_epi64(C0, _MM_SHUFFLE(1, 0, 3, 2)); \
+        D0 = _mm256_permute4x64_epi64(D0, _MM_SHUFFLE(2, 1, 0, 3)); \
+        \
+        B1 = _mm256_permute4x64_epi64(B1, _MM_SHUFFLE(0, 3, 2, 1)); \
+        C1 = _mm256_permute4x64_epi64(C1, _MM_SHUFFLE(1, 0, 3, 2)); \
+        D1 = _mm256_permute4x64_epi64(D1, _MM_SHUFFLE(2, 1, 0, 3)); \
+    } while((void)0, 0);
+
+#define DIAGONALIZE_2(A0, A1, B0, B1, C0, C1, D0, D1) \
+    do { \
+        __m256i tmp1 = _mm256_blend_epi32(B0, B1, 0xCC); \
+        __m256i tmp2 = _mm256_blend_epi32(B0, B1, 0x33); \
+        B1 = _mm256_permute4x64_epi64(tmp1, _MM_SHUFFLE(2,3,0,1)); \
+        B0 = _mm256_permute4x64_epi64(tmp2, _MM_SHUFFLE(2,3,0,1)); \
+        \
+        tmp1 = C0; \
+        C0 = C1; \
+        C1 = tmp1; \
+        \
+        tmp1 = _mm256_blend_epi32(D0, D1, 0xCC); \
+        tmp2 = _mm256_blend_epi32(D0, D1, 0x33); \
+        D0 = _mm256_permute4x64_epi64(tmp1, _MM_SHUFFLE(2,3,0,1)); \
+        D1 = _mm256_permute4x64_epi64(tmp2, _MM_SHUFFLE(2,3,0,1)); \
+    } while(0);
+
+#define UNDIAGONALIZE_1(A0, B0, C0, D0, A1, B1, C1, D1) \
+    do { \
+        B0 = _mm256_permute4x64_epi64(B0, _MM_SHUFFLE(2, 1, 0, 3)); \
+        C0 = _mm256_permute4x64_epi64(C0, _MM_SHUFFLE(1, 0, 3, 2)); \
+        D0 = _mm256_permute4x64_epi64(D0, _MM_SHUFFLE(0, 3, 2, 1)); \
+        \
+        B1 = _mm256_permute4x64_epi64(B1, _MM_SHUFFLE(2, 1, 0, 3)); \
+        C1 = _mm256_permute4x64_epi64(C1, _MM_SHUFFLE(1, 0, 3, 2)); \
+        D1 = _mm256_permute4x64_epi64(D1, _MM_SHUFFLE(0, 3, 2, 1)); \
+    } while((void)0, 0);
+
+#define UNDIAGONALIZE_2(A0, A1, B0, B1, C0, C1, D0, D1) \
+    do { \
+        __m256i tmp1 = _mm256_blend_epi32(B0, B1, 0xCC); \
+        __m256i tmp2 = _mm256_blend_epi32(B0, B1, 0x33); \
+        B0 = _mm256_permute4x64_epi64(tmp1, _MM_SHUFFLE(2,3,0,1)); \
+        B1 = _mm256_permute4x64_epi64(tmp2, _MM_SHUFFLE(2,3,0,1)); \
+        \
+        tmp1 = C0; \
+        C0 = C1; \
+        C1 = tmp1; \
+        \
+        tmp1 = _mm256_blend_epi32(D0, D1, 0x33); \
+        tmp2 = _mm256_blend_epi32(D0, D1, 0xCC); \
+        D0 = _mm256_permute4x64_epi64(tmp1, _MM_SHUFFLE(2,3,0,1)); \
+        D1 = _mm256_permute4x64_epi64(tmp2, _MM_SHUFFLE(2,3,0,1)); \
+    } while((void)0, 0);
+
+#define BLAKE2_ROUND_1(A0, A1, B0, B1, C0, C1, D0, D1) \
+    do{ \
+        G1_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
+        G2_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
+        \
+        DIAGONALIZE_1(A0, B0, C0, D0, A1, B1, C1, D1) \
+        \
+        G1_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
+        G2_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
+        \
+        UNDIAGONALIZE_1(A0, B0, C0, D0, A1, B1, C1, D1) \
+    } while((void)0, 0);
+
+#define BLAKE2_ROUND_2(A0, A1, B0, B1, C0, C1, D0, D1) \
+    do{ \
+        G1_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
+        G2_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
+        \
+        DIAGONALIZE_2(A0, A1, B0, B1, C0, C1, D0, D1) \
+        \
+        G1_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
+        G2_AVX2(A0, A1, B0, B1, C0, C1, D0, D1) \
+        \
+        UNDIAGONALIZE_2(A0, A1, B0, B1, C0, C1, D0, D1) \
+    } while((void)0, 0);
+
+#endif

data/vendor/libsodium/src/libsodium/crypto_pwhash/argon2/blamka-round-ref.h

@@ -1,38 +1,40 @@
 #ifndef blamka_round_ref_H
 #define blamka_round_ref_H
 
-#include "argon2-impl.h"
+#include "private/common.h"
 
 /*designed by the Lyra PHC team */
-static inline uint64_t fBlaMka(uint64_t x, uint64_t y) {
-    const uint64_t m = UINT64_C(0xFFFFFFFF);
+static inline uint64_t
+fBlaMka(uint64_t x, uint64_t y)
+{
+    const uint64_t m  = UINT64_C(0xFFFFFFFF);
     const uint64_t xy = (x & m) * (y & m);
     return x + y + 2 * xy;
 }
 
-#define G(a, b, c, d)                                                          \
-    do {                                                                       \
-        a = fBlaMka(a, b);                                                     \
-        d = rotr64(d ^ a, 32);                                                 \
-        c = fBlaMka(c, d);                                                     \
-        b = rotr64(b ^ c, 24);                                                 \
-        a = fBlaMka(a, b);                                                     \
-        d = rotr64(d ^ a, 16);                                                 \
-        c = fBlaMka(c, d);                                                     \
-        b = rotr64(b ^ c, 63);                                                 \
-    } while ((void)0, 0)
+#define G(a, b, c, d)          \
+    do {                       \
+        a = fBlaMka(a, b);     \
+        d = ROTR64(d ^ a, 32); \
+        c = fBlaMka(c, d);     \
+        b = ROTR64(b ^ c, 24); \
+        a = fBlaMka(a, b);     \
+        d = ROTR64(d ^ a, 16); \
+        c = fBlaMka(c, d);     \
+        b = ROTR64(b ^ c, 63); \
+    } while ((void) 0, 0)
 
-#define BLAKE2_ROUND_NOMSG(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,   \
-                           v12, v13, v14, v15)                                 \
-    do {                                                                       \
-        G(v0, v4, v8, v12);                                                    \
-        G(v1, v5, v9, v13);                                                    \
-        G(v2, v6, v10, v14);                                                   \
-        G(v3, v7, v11, v15);                                                   \
-        G(v0, v5, v10, v15);                                                   \
-        G(v1, v6, v11, v12);                                                   \
-        G(v2, v7, v8, v13);                                                    \
-        G(v3, v4, v9, v14);                                                    \
-    } while ((void)0, 0)
+#define BLAKE2_ROUND_NOMSG(v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, \
+                           v12, v13, v14, v15)                               \
+    do {                                                                     \
+        G(v0, v4, v8, v12);                                                  \
+        G(v1, v5, v9, v13);                                                  \
+        G(v2, v6, v10, v14);                                                 \
+        G(v3, v7, v11, v15);                                                 \
+        G(v0, v5, v10, v15);                                                 \
+        G(v1, v6, v11, v12);                                                 \
+        G(v2, v7, v8, v13);                                                  \
+        G(v3, v4, v9, v14);                                                  \
+    } while ((void) 0, 0)
 
 #endif

data/vendor/libsodium/src/libsodium/crypto_pwhash/argon2/blamka-round-ssse3.h

@@ -1,117 +1,120 @@
 #ifndef blamka_round_ssse3_H
 #define blamka_round_ssse3_H
 
-#include "argon2-impl.h"
+#include "private/common.h"
+#include "private/sse2_64_32.h"
 
-#define r16                                                                    \
+#define r16 \
     (_mm_setr_epi8(2, 3, 4, 5, 6, 7, 0, 1, 10, 11, 12, 13, 14, 15, 8, 9))
-#define r24                                                                    \
+#define r24 \
     (_mm_setr_epi8(3, 4, 5, 6, 7, 0, 1, 2, 11, 12, 13, 14, 15, 8, 9, 10))
-#define _mm_roti_epi64(x, c)                                                   \
-    (-(c) == 32)                                                               \
-        ? _mm_shuffle_epi32((x), _MM_SHUFFLE(2, 3, 0, 1))                      \
-        : (-(c) == 24)                                                         \
-              ? _mm_shuffle_epi8((x), r24)                                     \
-              : (-(c) == 16)                                                   \
-                    ? _mm_shuffle_epi8((x), r16)                               \
-                    : (-(c) == 63)                                             \
-                          ? _mm_xor_si128(_mm_srli_epi64((x), -(c)),           \
-                                          _mm_add_epi64((x), (x)))             \
-                          : _mm_xor_si128(_mm_srli_epi64((x), -(c)),           \
+#define _mm_roti_epi64(x, c)                                         \
+    (-(c) == 32)                                                     \
+        ? _mm_shuffle_epi32((x), _MM_SHUFFLE(2, 3, 0, 1))            \
+        : (-(c) == 24)                                               \
+              ? _mm_shuffle_epi8((x), r24)                           \
+              : (-(c) == 16)                                         \
+                    ? _mm_shuffle_epi8((x), r16)                     \
+                    : (-(c) == 63)                                   \
+                          ? _mm_xor_si128(_mm_srli_epi64((x), -(c)), \
+                                          _mm_add_epi64((x), (x)))   \
+                          : _mm_xor_si128(_mm_srli_epi64((x), -(c)), \
                                           _mm_slli_epi64((x), 64 - (-(c))))
 
-static inline __m128i fBlaMka(__m128i x, __m128i y) {
+static inline __m128i
+fBlaMka(__m128i x, __m128i y)
+{
     const __m128i z = _mm_mul_epu32(x, y);
     return _mm_add_epi64(_mm_add_epi64(x, y), _mm_add_epi64(z, z));
 }
 
-#define G1(A0, B0, C0, D0, A1, B1, C1, D1)                                     \
-    do {                                                                       \
-        A0 = fBlaMka(A0, B0);                                                  \
-        A1 = fBlaMka(A1, B1);                                                  \
-                                                                               \
-        D0 = _mm_xor_si128(D0, A0);                                            \
-        D1 = _mm_xor_si128(D1, A1);                                            \
-                                                                               \
-        D0 = _mm_roti_epi64(D0, -32);                                          \
-        D1 = _mm_roti_epi64(D1, -32);                                          \
-                                                                               \
-        C0 = fBlaMka(C0, D0);                                                  \
-        C1 = fBlaMka(C1, D1);                                                  \
-                                                                               \
-        B0 = _mm_xor_si128(B0, C0);                                            \
-        B1 = _mm_xor_si128(B1, C1);                                            \
-                                                                               \
-        B0 = _mm_roti_epi64(B0, -24);                                          \
-        B1 = _mm_roti_epi64(B1, -24);                                          \
-    } while ((void)0, 0)
+#define G1(A0, B0, C0, D0, A1, B1, C1, D1) \
+    do {                                   \
+        A0 = fBlaMka(A0, B0);              \
+        A1 = fBlaMka(A1, B1);              \
+                                           \
+        D0 = _mm_xor_si128(D0, A0);        \
+        D1 = _mm_xor_si128(D1, A1);        \
+                                           \
+        D0 = _mm_roti_epi64(D0, -32);      \
+        D1 = _mm_roti_epi64(D1, -32);      \
+                                           \
+        C0 = fBlaMka(C0, D0);              \
+        C1 = fBlaMka(C1, D1);              \
+                                           \
+        B0 = _mm_xor_si128(B0, C0);        \
+        B1 = _mm_xor_si128(B1, C1);        \
+                                           \
+        B0 = _mm_roti_epi64(B0, -24);      \
+        B1 = _mm_roti_epi64(B1, -24);      \
+    } while ((void) 0, 0)
 
-#define G2(A0, B0, C0, D0, A1, B1, C1, D1)                                     \
-    do {                                                                       \
-        A0 = fBlaMka(A0, B0);                                                  \
-        A1 = fBlaMka(A1, B1);                                                  \
-                                                                               \
-        D0 = _mm_xor_si128(D0, A0);                                            \
-        D1 = _mm_xor_si128(D1, A1);                                            \
-                                                                               \
-        D0 = _mm_roti_epi64(D0, -16);                                          \
-        D1 = _mm_roti_epi64(D1, -16);                                          \
-                                                                               \
-        C0 = fBlaMka(C0, D0);                                                  \
-        C1 = fBlaMka(C1, D1);                                                  \
-                                                                               \
-        B0 = _mm_xor_si128(B0, C0);                                            \
-        B1 = _mm_xor_si128(B1, C1);                                            \
-                                                                               \
-        B0 = _mm_roti_epi64(B0, -63);                                          \
-        B1 = _mm_roti_epi64(B1, -63);                                          \
-    } while ((void)0, 0)
+#define G2(A0, B0, C0, D0, A1, B1, C1, D1) \
+    do {                                   \
+        A0 = fBlaMka(A0, B0);              \
+        A1 = fBlaMka(A1, B1);              \
+                                           \
+        D0 = _mm_xor_si128(D0, A0);        \
+        D1 = _mm_xor_si128(D1, A1);        \
+                                           \
+        D0 = _mm_roti_epi64(D0, -16);      \
+        D1 = _mm_roti_epi64(D1, -16);      \
+                                           \
+        C0 = fBlaMka(C0, D0);              \
+        C1 = fBlaMka(C1, D1);              \
+                                           \
+        B0 = _mm_xor_si128(B0, C0);        \
+        B1 = _mm_xor_si128(B1, C1);        \
+                                           \
+        B0 = _mm_roti_epi64(B0, -63);      \
+        B1 = _mm_roti_epi64(B1, -63);      \
+    } while ((void) 0, 0)
 
-#define DIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1)                            \
-    do {                                                                       \
-        __m128i t0 = _mm_alignr_epi8(B1, B0, 8);                               \
-        __m128i t1 = _mm_alignr_epi8(B0, B1, 8);                               \
-        B0 = t0;                                                               \
-        B1 = t1;                                                               \
-                                                                               \
-        t0 = C0;                                                               \
-        C0 = C1;                                                               \
-        C1 = t0;                                                               \
-                                                                               \
-        t0 = _mm_alignr_epi8(D1, D0, 8);                                       \
-        t1 = _mm_alignr_epi8(D0, D1, 8);                                       \
-        D0 = t1;                                                               \
-        D1 = t0;                                                               \
-    } while ((void)0, 0)
+#define DIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1) \
+    do {                                            \
+        __m128i t0 = _mm_alignr_epi8(B1, B0, 8);    \
+        __m128i t1 = _mm_alignr_epi8(B0, B1, 8);    \
+        B0         = t0;                            \
+        B1         = t1;                            \
+                                                    \
+        t0 = C0;                                    \
+        C0 = C1;                                    \
+        C1 = t0;                                    \
+                                                    \
+        t0 = _mm_alignr_epi8(D1, D0, 8);            \
+        t1 = _mm_alignr_epi8(D0, D1, 8);            \
+        D0 = t1;                                    \
+        D1 = t0;                                    \
+    } while ((void) 0, 0)
 
-#define UNDIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1)                          \
-    do {                                                                       \
-        __m128i t0 = _mm_alignr_epi8(B0, B1, 8);                               \
-        __m128i t1 = _mm_alignr_epi8(B1, B0, 8);                               \
-        B0 = t0;                                                               \
-        B1 = t1;                                                               \
-                                                                               \
-        t0 = C0;                                                               \
-        C0 = C1;                                                               \
-        C1 = t0;                                                               \
-                                                                               \
-        t0 = _mm_alignr_epi8(D0, D1, 8);                                       \
-        t1 = _mm_alignr_epi8(D1, D0, 8);                                       \
-        D0 = t1;                                                               \
-        D1 = t0;                                                               \
-    } while ((void)0, 0)
+#define UNDIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1) \
+    do {                                              \
+        __m128i t0 = _mm_alignr_epi8(B0, B1, 8);      \
+        __m128i t1 = _mm_alignr_epi8(B1, B0, 8);      \
+        B0         = t0;                              \
+        B1         = t1;                              \
+                                                      \
+        t0 = C0;                                      \
+        C0 = C1;                                      \
+        C1 = t0;                                      \
+                                                      \
+        t0 = _mm_alignr_epi8(D0, D1, 8);              \
+        t1 = _mm_alignr_epi8(D1, D0, 8);              \
+        D0 = t1;                                      \
+        D1 = t0;                                      \
+    } while ((void) 0, 0)
 
-#define BLAKE2_ROUND(A0, A1, B0, B1, C0, C1, D0, D1)                           \
-    do {                                                                       \
-        G1(A0, B0, C0, D0, A1, B1, C1, D1);                                    \
-        G2(A0, B0, C0, D0, A1, B1, C1, D1);                                    \
-                                                                               \
-        DIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1);                           \
-                                                                               \
-        G1(A0, B0, C0, D0, A1, B1, C1, D1);                                    \
-        G2(A0, B0, C0, D0, A1, B1, C1, D1);                                    \
-                                                                               \
-        UNDIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1);                         \
-    } while ((void)0, 0)
+#define BLAKE2_ROUND(A0, A1, B0, B1, C0, C1, D0, D1)   \
+    do {                                               \
+        G1(A0, B0, C0, D0, A1, B1, C1, D1);            \
+        G2(A0, B0, C0, D0, A1, B1, C1, D1);            \
+                                                       \
+        DIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1);   \
+                                                       \
+        G1(A0, B0, C0, D0, A1, B1, C1, D1);            \
+        G2(A0, B0, C0, D0, A1, B1, C1, D1);            \
+                                                       \
+        UNDIAGONALIZE(A0, B0, C0, D0, A1, B1, C1, D1); \
+    } while ((void) 0, 0)
 
 #endif

data/vendor/libsodium/src/libsodium/crypto_pwhash/argon2/pwhash_argon2i.c

@@ -5,8 +5,8 @@
 #include <stdint.h>
 #include <string.h>
 
-#include "argon2.h"
 #include "argon2-core.h"
+#include "argon2.h"
 #include "crypto_pwhash_argon2i.h"
 #include "randombytes.h"
 #include "utils.h"
@@ -19,6 +19,30 @@ crypto_pwhash_argon2i_alg_argon2i13(void)
     return crypto_pwhash_argon2i_ALG_ARGON2I13;
 }
 
+size_t
+crypto_pwhash_argon2i_bytes_min(void)
+{
+    return crypto_pwhash_argon2i_BYTES_MIN;
+}
+
+size_t
+crypto_pwhash_argon2i_bytes_max(void)
+{
+    return crypto_pwhash_argon2i_BYTES_MAX;
+}
+
+size_t
+crypto_pwhash_argon2i_passwd_min(void)
+{
+    return crypto_pwhash_argon2i_PASSWD_MIN;
+}
+
+size_t
+crypto_pwhash_argon2i_passwd_max(void)
+{
+    return crypto_pwhash_argon2i_PASSWD_MAX;
+}
+
 size_t
 crypto_pwhash_argon2i_saltbytes(void)
 {
@@ -31,12 +55,36 @@ crypto_pwhash_argon2i_strbytes(void)
     return crypto_pwhash_argon2i_STRBYTES;
 }
 
-const char *
+const char*
 crypto_pwhash_argon2i_strprefix(void)
 {
     return crypto_pwhash_argon2i_STRPREFIX;
 }
 
+size_t
+crypto_pwhash_argon2i_opslimit_min(void)
+{
+    return crypto_pwhash_argon2i_OPSLIMIT_MIN;
+}
+
+size_t
+crypto_pwhash_argon2i_opslimit_max(void)
+{
+    return crypto_pwhash_argon2i_OPSLIMIT_MAX;
+}
+
+size_t
+crypto_pwhash_argon2i_memlimit_min(void)
+{
+    return crypto_pwhash_argon2i_MEMLIMIT_MIN;
+}
+
+size_t
+crypto_pwhash_argon2i_memlimit_max(void)
+{
+    return crypto_pwhash_argon2i_MEMLIMIT_MAX;
+}
+
 size_t
 crypto_pwhash_argon2i_opslimit_interactive(void)
 {
@@ -74,17 +122,12 @@ crypto_pwhash_argon2i_memlimit_sensitive(void)
 }
 
 int
-crypto_pwhash_argon2i(unsigned char * const out,
-                      unsigned long long outlen,
-                      const char * const passwd,
-                      unsigned long long passwdlen,
-                      const unsigned char * const salt,
-                      unsigned long long opslimit,
-                      size_t memlimit, int alg)
-{
-    if (alg != crypto_pwhash_argon2i_ALG_ARGON2I13) {
-        return -1;
-    }
+crypto_pwhash_argon2i(unsigned char *const out, unsigned long long outlen,
+                      const char *const passwd, unsigned long long passwdlen,
+                      const unsigned char *const salt,
+                      unsigned long long opslimit, size_t memlimit, int alg)
+{
+    memset(out, 0, outlen);
     memlimit /= 1024U;
     if (outlen > ARGON2_MAX_OUTLEN || passwdlen > ARGON2_MAX_PWD_LENGTH ||
         opslimit > ARGON2_MAX_TIME || memlimit > ARGON2_MAX_MEMORY) {
@@ -96,41 +139,46 @@ crypto_pwhash_argon2i(unsigned char * const out,
         errno = EINVAL;
         return -1;
     }
-    if (argon2i_hash_raw((uint32_t) opslimit, (uint32_t) memlimit,
-                         (uint32_t) 1U, passwd, (size_t) passwdlen,
-                         salt, (size_t) crypto_pwhash_argon2i_SALTBYTES,
-                         out, (size_t) outlen) != ARGON2_OK) {
-        return -1; /* LCOV_EXCL_LINE */
+    switch (alg) {
+    case crypto_pwhash_argon2i_ALG_ARGON2I13:
+        if (argon2i_hash_raw((uint32_t) opslimit, (uint32_t) memlimit,
+                             (uint32_t) 1U, passwd, (size_t) passwdlen, salt,
+                             (size_t) crypto_pwhash_argon2i_SALTBYTES, out,
+                             (size_t) outlen) != ARGON2_OK) {
+            return -1; /* LCOV_EXCL_LINE */
+        }
+        return 0;
+    default:
+        errno = EINVAL;
+        return -1;
     }
-    return 0;
 }
 
 int
 crypto_pwhash_argon2i_str(char out[crypto_pwhash_argon2i_STRBYTES],
-                          const char * const passwd,
+                          const char *const passwd,
                           unsigned long long passwdlen,
-                          unsigned long long opslimit,
-                          size_t memlimit)
+                          unsigned long long opslimit, size_t memlimit)
 {
     unsigned char salt[crypto_pwhash_argon2i_SALTBYTES];
 
     memset(out, 0, crypto_pwhash_argon2i_STRBYTES);
     memlimit /= 1024U;
-    if (passwdlen > ARGON2_MAX_PWD_LENGTH ||
-        opslimit > ARGON2_MAX_TIME || memlimit > ARGON2_MAX_MEMORY) {
+    if (passwdlen > ARGON2_MAX_PWD_LENGTH || opslimit > ARGON2_MAX_TIME ||
+        memlimit > ARGON2_MAX_MEMORY) {
         errno = EFBIG;
         return -1;
     }
-    if (passwdlen < ARGON2_MIN_PWD_LENGTH ||
-        opslimit < ARGON2_MIN_TIME || memlimit < ARGON2_MIN_MEMORY) {
+    if (passwdlen < ARGON2_MIN_PWD_LENGTH || opslimit < ARGON2_MIN_TIME ||
+        memlimit < ARGON2_MIN_MEMORY) {
         errno = EINVAL;
         return -1;
     }
     randombytes_buf(salt, sizeof salt);
     if (argon2i_hash_encoded((uint32_t) opslimit, (uint32_t) memlimit,
-                             (uint32_t) 1U, passwd, (size_t) passwdlen,
-                             salt, sizeof salt, STR_HASHBYTES,
-                             out, crypto_pwhash_argon2i_STRBYTES) != ARGON2_OK) {
+                             (uint32_t) 1U, passwd, (size_t) passwdlen, salt,
+                             sizeof salt, STR_HASHBYTES, out,
+                             crypto_pwhash_argon2i_STRBYTES) != ARGON2_OK) {
         return -1; /* LCOV_EXCL_LINE */
     }
     return 0;
@@ -138,27 +186,28 @@ crypto_pwhash_argon2i_str(char out[crypto_pwhash_argon2i_STRBYTES],
 
 int
 crypto_pwhash_argon2i_str_verify(const char str[crypto_pwhash_argon2i_STRBYTES],
-                                 const char * const passwd,
+                                 const char *const  passwd,
                                  unsigned long long passwdlen)
 {
+    int verify_ret;
+
     if (passwdlen > ARGON2_MAX_PWD_LENGTH) {
         errno = EFBIG;
         return -1;
     }
-/* LCOV_EXCL_START */
+    /* LCOV_EXCL_START */
     if (passwdlen < ARGON2_MIN_PWD_LENGTH) {
         errno = EINVAL;
         return -1;
     }
-/* LCOV_EXCL_STOP */
-    if (argon2i_verify(str, passwd, (size_t) passwdlen) != ARGON2_OK) {
-        return -1;
-    }
-    return 0;
-}
+    /* LCOV_EXCL_STOP */
 
-int
-_crypto_pwhash_argon2i_pick_best_implementation(void)
-{
-    return argon2_pick_best_implementation();
+    verify_ret = argon2i_verify(str, passwd, (size_t) passwdlen);
+    if (verify_ret == ARGON2_OK) {
+        return 0;
+    }
+    if (verify_ret == ARGON2_VERIFY_MISMATCH) {
+        errno = EINVAL;
+    }
+    return -1;
 }