rbnacl-libsodium 1.0.11 → 1.0.13

data/vendor/libsodium/src/libsodium/crypto_pwhash/scryptsalsa208sha256/pbkdf2-sha256.c

@@ -24,16 +24,17 @@
  * SUCH DAMAGE.
  */
 
-#include <stdlib.h>
-#include <sys/types.h>
-
+#include <limits.h>
 #include <stdint.h>
+#include <stdlib.h>
 #include <string.h>
 
+#include <sys/types.h>
+
 #include "crypto_auth_hmacsha256.h"
 #include "pbkdf2-sha256.h"
-#include "utils.h"
 #include "private/common.h"
+#include "utils.h"
 
 /**
  * PBKDF2_SHA256(passwd, passwdlen, salt, saltlen, c, buf, dkLen):
@@ -41,21 +42,23 @@
  * write the output to buf.  The value dkLen must be at most 32 * (2^32 - 1).
  */
 void
-PBKDF2_SHA256(const uint8_t * passwd, size_t passwdlen, const uint8_t * salt,
-              size_t saltlen, uint64_t c, uint8_t * buf, size_t dkLen)
+PBKDF2_SHA256(const uint8_t *passwd, size_t passwdlen, const uint8_t *salt,
+              size_t saltlen, uint64_t c, uint8_t *buf, size_t dkLen)
 {
     crypto_auth_hmacsha256_state PShctx, hctx;
-    size_t          i;
-    uint8_t         ivec[4];
-    uint8_t         U[32];
-    uint8_t         T[32];
-    uint64_t        j;
-    int             k;
-    size_t          clen;
+    size_t                       i;
+    uint8_t                      ivec[4];
+    uint8_t                      U[32];
+    uint8_t                      T[32];
+    uint64_t                     j;
+    int                          k;
+    size_t                       clen;
 
+#if SIZE_MAX > 0x1fffffffe0ULL
     if (dkLen > 0x1fffffffe0ULL) {
         abort();
     }
+#endif
     crypto_auth_hmacsha256_init(&PShctx, passwd, passwdlen);
     crypto_auth_hmacsha256_update(&PShctx, salt, saltlen);
 

data/vendor/libsodium/src/libsodium/crypto_pwhash/scryptsalsa208sha256/pbkdf2-sha256.h

@@ -28,10 +28,10 @@
 #ifndef pbkdf2_sha256_H
 #define pbkdf2_sha256_H
 
-#include <sys/types.h>
-
 #include <stdint.h>
 
+#include <sys/types.h>
+
 #include "crypto_auth_hmacsha256.h"
 
 /**
@@ -39,7 +39,7 @@
  * Compute PBKDF2(passwd, salt, c, dkLen) using HMAC-SHA256 as the PRF, and
  * write the output to buf.  The value dkLen must be at most 32 * (2^32 - 1).
  */
-void PBKDF2_SHA256(const uint8_t *, size_t, const uint8_t *, size_t,
-                   uint64_t, uint8_t *, size_t);
+void PBKDF2_SHA256(const uint8_t *, size_t, const uint8_t *, size_t, uint64_t,
+                   uint8_t *, size_t);
 
 #endif /* !_SHA256_H_ */

data/vendor/libsodium/src/libsodium/crypto_pwhash/scryptsalsa208sha256/pwhash_scryptsalsa208sha256.c

@@ -7,16 +7,17 @@
 
 #include "crypto_pwhash_scryptsalsa208sha256.h"
 #include "crypto_scrypt.h"
+#include "private/common.h"
 #include "randombytes.h"
 #include "utils.h"
 
-#define SETTING_SIZE(saltbytes) \
-    ((sizeof "$7$" - 1U) + \
-     (1U /* N_log2 */) + (5U /* r */) + (5U /* p */) + BYTES2CHARS(saltbytes))
+#define SETTING_SIZE(saltbytes)                                              \
+    ((sizeof "$7$" - 1U) + (1U /* N_log2 */) + (5U /* r */) + (5U /* p */) + \
+     BYTES2CHARS(saltbytes))
 
 static int
 pickparams(unsigned long long opslimit, const size_t memlimit,
-           uint32_t * const N_log2, uint32_t * const p, uint32_t * const r)
+           uint32_t *const N_log2, uint32_t *const p, uint32_t *const r)
 {
     unsigned long long maxN;
     unsigned long long maxrp;
@@ -26,7 +27,7 @@ pickparams(unsigned long long opslimit, const size_t memlimit,
     }
     *r = 8;
     if (opslimit < memlimit / 32) {
-        *p = 1;
+        *p   = 1;
         maxN = opslimit / (*r * 4);
         for (*N_log2 = 1; *N_log2 < 63; *N_log2 += 1) {
             if ((uint64_t)(1) << *N_log2 > maxN / 2) {
@@ -36,21 +37,45 @@ pickparams(unsigned long long opslimit, const size_t memlimit,
     } else {
         maxN = memlimit / ((size_t) *r * 128);
         for (*N_log2 = 1; *N_log2 < 63; *N_log2 += 1) {
-            if ((uint64_t) (1) << *N_log2 > maxN / 2) {
+            if ((uint64_t)(1) << *N_log2 > maxN / 2) {
                 break;
             }
         }
-        maxrp = (opslimit / 4) / ((uint64_t) (1) << *N_log2);
+        maxrp = (opslimit / 4) / ((uint64_t)(1) << *N_log2);
         /* LCOV_EXCL_START */
         if (maxrp > 0x3fffffff) {
             maxrp = 0x3fffffff;
         }
         /* LCOV_EXCL_STOP */
-        *p = (uint32_t) (maxrp) / *r;
+        *p = (uint32_t)(maxrp) / *r;
     }
     return 0;
 }
 
+size_t
+crypto_pwhash_scryptsalsa208sha256_bytes_min(void)
+{
+    return crypto_pwhash_scryptsalsa208sha256_BYTES_MIN;
+}
+
+size_t
+crypto_pwhash_scryptsalsa208sha256_bytes_max(void)
+{
+    return crypto_pwhash_scryptsalsa208sha256_BYTES_MAX;
+}
+
+size_t
+crypto_pwhash_scryptsalsa208sha256_passwd_min(void)
+{
+    return crypto_pwhash_scryptsalsa208sha256_PASSWD_MIN;
+}
+
+size_t
+crypto_pwhash_scryptsalsa208sha256_passwd_max(void)
+{
+    return crypto_pwhash_scryptsalsa208sha256_PASSWD_MAX;
+}
+
 size_t
 crypto_pwhash_scryptsalsa208sha256_saltbytes(void)
 {
@@ -69,6 +94,30 @@ crypto_pwhash_scryptsalsa208sha256_strprefix(void)
     return crypto_pwhash_scryptsalsa208sha256_STRPREFIX;
 }
 
+size_t
+crypto_pwhash_scryptsalsa208sha256_opslimit_min(void)
+{
+    return crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MIN;
+}
+
+size_t
+crypto_pwhash_scryptsalsa208sha256_opslimit_max(void)
+{
+    return crypto_pwhash_scryptsalsa208sha256_OPSLIMIT_MAX;
+}
+
+size_t
+crypto_pwhash_scryptsalsa208sha256_memlimit_min(void)
+{
+    return crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN;
+}
+
+size_t
+crypto_pwhash_scryptsalsa208sha256_memlimit_max(void)
+{
+    return crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MAX;
+}
+
 size_t
 crypto_pwhash_scryptsalsa208sha256_opslimit_interactive(void)
 {
@@ -94,63 +143,62 @@ crypto_pwhash_scryptsalsa208sha256_memlimit_sensitive(void)
 }
 
 int
-crypto_pwhash_scryptsalsa208sha256(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)
+crypto_pwhash_scryptsalsa208sha256(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)
 {
     uint32_t N_log2;
     uint32_t p;
     uint32_t r;
 
     memset(out, 0, outlen);
-    if (passwdlen > SIZE_MAX || outlen > SIZE_MAX) {
+    if (passwdlen > crypto_pwhash_scryptsalsa208sha256_PASSWD_MAX ||
+        outlen > crypto_pwhash_scryptsalsa208sha256_BYTES_MAX) {
         errno = EFBIG; /* LCOV_EXCL_LINE */
-        return -1; /* LCOV_EXCL_LINE */
+        return -1;     /* LCOV_EXCL_LINE */
     }
-    if (pickparams(opslimit, memlimit, &N_log2, &p, &r) != 0) {
+    if (outlen < crypto_pwhash_scryptsalsa208sha256_BYTES_MIN ||
+        pickparams(opslimit, memlimit, &N_log2, &p, &r) != 0) {
         errno = EINVAL; /* LCOV_EXCL_LINE */
-        return -1; /* LCOV_EXCL_LINE */
+        return -1;      /* LCOV_EXCL_LINE */
     }
-    return crypto_pwhash_scryptsalsa208sha256_ll((const uint8_t *) passwd,
-                                                 (size_t) passwdlen,
-                                                 (const uint8_t *) salt,
-                                                 crypto_pwhash_scryptsalsa208sha256_SALTBYTES,
-                                                 (uint64_t) (1) << N_log2, r, p,
-                                                 out, (size_t) outlen);
+    return crypto_pwhash_scryptsalsa208sha256_ll(
+        (const uint8_t *) passwd, (size_t) passwdlen, (const uint8_t *) salt,
+        crypto_pwhash_scryptsalsa208sha256_SALTBYTES, (uint64_t)(1) << N_log2,
+        r, p, out, (size_t) outlen);
 }
 
 int
-crypto_pwhash_scryptsalsa208sha256_str(char out[crypto_pwhash_scryptsalsa208sha256_STRBYTES],
-                                       const char * const passwd,
-                                       unsigned long long passwdlen,
-                                       unsigned long long opslimit,
-                                       size_t memlimit)
-{
-    uint8_t         salt[crypto_pwhash_scryptsalsa208sha256_STRSALTBYTES];
-    char            setting[crypto_pwhash_scryptsalsa208sha256_STRSETTINGBYTES + 1U];
+crypto_pwhash_scryptsalsa208sha256_str(
+    char              out[crypto_pwhash_scryptsalsa208sha256_STRBYTES],
+    const char *const passwd, unsigned long long passwdlen,
+    unsigned long long opslimit, size_t memlimit)
+{
+    uint8_t salt[crypto_pwhash_scryptsalsa208sha256_STRSALTBYTES];
+    char    setting[crypto_pwhash_scryptsalsa208sha256_STRSETTINGBYTES + 1U];
     escrypt_local_t escrypt_local;
     uint32_t        N_log2;
     uint32_t        p;
     uint32_t        r;
 
     memset(out, 0, crypto_pwhash_scryptsalsa208sha256_STRBYTES);
-    if (passwdlen > SIZE_MAX) {
+    if (passwdlen > crypto_pwhash_scryptsalsa208sha256_PASSWD_MAX) {
         errno = EFBIG; /* LCOV_EXCL_LINE */
-        return -1; /* LCOV_EXCL_LINE */
+        return -1;     /* LCOV_EXCL_LINE */
     }
-    if (pickparams(opslimit, memlimit, &N_log2, &p, &r) != 0) {
+    if (passwdlen < crypto_pwhash_scryptsalsa208sha256_PASSWD_MIN ||
+        pickparams(opslimit, memlimit, &N_log2, &p, &r) != 0) {
         errno = EINVAL; /* LCOV_EXCL_LINE */
-        return -1; /* LCOV_EXCL_LINE */
+        return -1;      /* LCOV_EXCL_LINE */
     }
     randombytes_buf(salt, sizeof salt);
-    if (escrypt_gensalt_r(N_log2, r, p, salt, sizeof salt,
-                          (uint8_t *) setting, sizeof setting) == NULL) {
+    if (escrypt_gensalt_r(N_log2, r, p, salt, sizeof salt, (uint8_t *) setting,
+                          sizeof setting) == NULL) {
         errno = EINVAL; /* LCOV_EXCL_LINE */
-        return -1; /* LCOV_EXCL_LINE */
+        return -1;      /* LCOV_EXCL_LINE */
     }
     if (escrypt_init_local(&escrypt_local) != 0) {
         return -1; /* LCOV_EXCL_LINE */
@@ -166,21 +214,21 @@ crypto_pwhash_scryptsalsa208sha256_str(char out[crypto_pwhash_scryptsalsa208sha2
     }
     escrypt_free_local(&escrypt_local);
 
-    (void) sizeof
-        (int[SETTING_SIZE(crypto_pwhash_scryptsalsa208sha256_STRSALTBYTES)
-            == crypto_pwhash_scryptsalsa208sha256_STRSETTINGBYTES ? 1 : -1]);
-    (void) sizeof
-        (int[crypto_pwhash_scryptsalsa208sha256_STRSETTINGBYTES + 1U +
-             crypto_pwhash_scryptsalsa208sha256_STRHASHBYTES_ENCODED + 1U
-             == crypto_pwhash_scryptsalsa208sha256_STRBYTES ? 1 : -1]);
+    COMPILER_ASSERT(
+        SETTING_SIZE(crypto_pwhash_scryptsalsa208sha256_STRSALTBYTES) ==
+        crypto_pwhash_scryptsalsa208sha256_STRSETTINGBYTES);
+    COMPILER_ASSERT(
+        crypto_pwhash_scryptsalsa208sha256_STRSETTINGBYTES + 1U +
+            crypto_pwhash_scryptsalsa208sha256_STRHASHBYTES_ENCODED + 1U ==
+        crypto_pwhash_scryptsalsa208sha256_STRBYTES);
 
     return 0;
 }
 
 int
-crypto_pwhash_scryptsalsa208sha256_str_verify(const char str[crypto_pwhash_scryptsalsa208sha256_STRBYTES],
-                                              const char * const passwd,
-                                              unsigned long long passwdlen)
+crypto_pwhash_scryptsalsa208sha256_str_verify(
+    const char        str[crypto_pwhash_scryptsalsa208sha256_STRBYTES],
+    const char *const passwd, unsigned long long passwdlen)
 {
     char            wanted[crypto_pwhash_scryptsalsa208sha256_STRBYTES];
     escrypt_local_t escrypt_local;

data/vendor/libsodium/src/libsodium/crypto_pwhash/scryptsalsa208sha256/scrypt_platform.c

@@ -19,7 +19,7 @@
  */
 
 #ifdef HAVE_SYS_MMAN_H
-# include <sys/mman.h>
+#include <sys/mman.h>
 #endif
 #include <errno.h>
 #include <stdlib.h>
@@ -28,26 +28,27 @@
 #include "runtime.h"
 
 #if !defined(MAP_ANON) && defined(MAP_ANONYMOUS)
-# define MAP_ANON MAP_ANONYMOUS
+#define MAP_ANON MAP_ANONYMOUS
 #endif
 
 void *
-alloc_region(escrypt_region_t * region, size_t size)
+alloc_region(escrypt_region_t *region, size_t size)
 {
-    uint8_t * base, * aligned;
+    uint8_t *base, *aligned;
 #if defined(MAP_ANON) && defined(HAVE_MMAP)
     if ((base = (uint8_t *) mmap(NULL, size, PROT_READ | PROT_WRITE,
 #ifdef MAP_NOCORE
-        MAP_ANON | MAP_PRIVATE | MAP_NOCORE,
+                                 MAP_ANON | MAP_PRIVATE | MAP_NOCORE,
 #else
-        MAP_ANON | MAP_PRIVATE,
+                                 MAP_ANON | MAP_PRIVATE,
 #endif
-        -1, 0)) == MAP_FAILED)
+                                 -1, 0)) == MAP_FAILED)
         base = NULL; /* LCOV_EXCL_LINE */
-    aligned = base;
+    aligned  = base;
 #elif defined(HAVE_POSIX_MEMALIGN)
-    if ((errno = posix_memalign((void **) &base, 64, size)) != 0)
+    if ((errno = posix_memalign((void **) &base, 64, size)) != 0) {
         base = NULL;
+    }
     aligned = base;
 #else
     base = aligned = NULL;
@@ -55,46 +56,50 @@ alloc_region(escrypt_region_t * region, size_t size)
         errno = ENOMEM;
     else if ((base = (uint8_t *) malloc(size + 63)) != NULL) {
         aligned = base + 63;
-        aligned -= (uintptr_t)aligned & 63;
+        aligned -= (uintptr_t) aligned & 63;
     }
 #endif
-    region->base = base;
+    region->base    = base;
     region->aligned = aligned;
-    region->size = base ? size : 0;
+    region->size    = base ? size : 0;
+
     return aligned;
 }
 
 static inline void
-init_region(escrypt_region_t * region)
+init_region(escrypt_region_t *region)
 {
     region->base = region->aligned = NULL;
-    region->size = 0;
+    region->size                   = 0;
 }
 
 int
-free_region(escrypt_region_t * region)
+free_region(escrypt_region_t *region)
 {
     if (region->base) {
 #if defined(MAP_ANON) && defined(HAVE_MMAP)
-        if (munmap(region->base, region->size))
+        if (munmap(region->base, region->size)) {
             return -1; /* LCOV_EXCL_LINE */
+        }
 #else
         free(region->base);
 #endif
     }
     init_region(region);
+
     return 0;
 }
 
 int
-escrypt_init_local(escrypt_local_t * local)
+escrypt_init_local(escrypt_local_t *local)
 {
     init_region(local);
+
     return 0;
 }
 
 int
-escrypt_free_local(escrypt_local_t * local)
+escrypt_free_local(escrypt_local_t *local)
 {
     return free_region(local);
 }

data/vendor/libsodium/src/libsodium/crypto_pwhash/scryptsalsa208sha256/sse/pwhash_scryptsalsa208sha256_sse.c

@@ -28,57 +28,59 @@
  * online backup system.
  */
 
-#if defined(HAVE_EMMINTRIN_H) || \
-    (defined(_MSC_VER) && (defined(_M_X64) || defined(_M_AMD64) || defined(_M_IX86)))
-#ifdef __GNUC__
-# pragma GCC target("sse2")
-#endif
-#include <emmintrin.h>
-#if defined(__XOP__) && defined(DISABLED)
-# include <x86intrin.h>
-#endif
-
 #include <errno.h>
 #include <limits.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
-#include "../pbkdf2-sha256.h"
-#include "../crypto_scrypt.h"
 #include "private/common.h"
+#include "private/sse2_64_32.h"
+
+#ifdef HAVE_EMMINTRIN_H
+
+# ifdef __GNUC__
+#  pragma GCC target("sse2")
+# endif
+# include <emmintrin.h>
+# if defined(__XOP__) && defined(DISABLED)
+#  include <x86intrin.h>
+# endif
+
+# include "../crypto_scrypt.h"
+# include "../pbkdf2-sha256.h"
 
-#if defined(__XOP__) && defined(DISABLED)
-#define ARX(out, in1, in2, s) \
+# if defined(__XOP__) && defined(DISABLED)
+#  define ARX(out, in1, in2, s) \
     out = _mm_xor_si128(out, _mm_roti_epi32(_mm_add_epi32(in1, in2), s));
-#else
-#define ARX(out, in1, in2, s) \
-    { \
-        __m128i T = _mm_add_epi32(in1, in2); \
-        out = _mm_xor_si128(out, _mm_slli_epi32(T, s)); \
-        out = _mm_xor_si128(out, _mm_srli_epi32(T, 32-s)); \
+# else
+#  define ARX(out, in1, in2, s)                                    \
+    {                                                              \
+        __m128i T = _mm_add_epi32(in1, in2);                       \
+        out       = _mm_xor_si128(out, _mm_slli_epi32(T, s));      \
+        out       = _mm_xor_si128(out, _mm_srli_epi32(T, 32 - s)); \
     }
-#endif
-
-#define SALSA20_2ROUNDS \
-    /* Operate on "columns". */ \
-    ARX(X1, X0, X3, 7) \
-    ARX(X2, X1, X0, 9) \
-    ARX(X3, X2, X1, 13) \
-    ARX(X0, X3, X2, 18) \
-\
-    /* Rearrange data. */ \
+# endif
+
+# define SALSA20_2ROUNDS              \
+    /* Operate on "columns". */       \
+    ARX(X1, X0, X3, 7)                \
+    ARX(X2, X1, X0, 9)                \
+    ARX(X3, X2, X1, 13)               \
+    ARX(X0, X3, X2, 18)               \
+                                      \
+    /* Rearrange data. */             \
     X1 = _mm_shuffle_epi32(X1, 0x93); \
     X2 = _mm_shuffle_epi32(X2, 0x4E); \
     X3 = _mm_shuffle_epi32(X3, 0x39); \
-\
-    /* Operate on "rows". */ \
-    ARX(X3, X0, X1, 7) \
-    ARX(X2, X3, X0, 9) \
-    ARX(X1, X2, X3, 13) \
-    ARX(X0, X1, X2, 18) \
-\
-    /* Rearrange data. */ \
+                                      \
+    /* Operate on "rows". */          \
+    ARX(X3, X0, X1, 7)                \
+    ARX(X2, X3, X0, 9)                \
+    ARX(X1, X2, X3, 13)               \
+    ARX(X0, X1, X2, 18)               \
+                                      \
+    /* Rearrange data. */             \
     X1 = _mm_shuffle_epi32(X1, 0x39); \
     X2 = _mm_shuffle_epi32(X2, 0x4E); \
     X3 = _mm_shuffle_epi32(X3, 0x93);
@@ -86,20 +88,19 @@
 /**
  * Apply the salsa20/8 core to the block provided in (X0 ... X3) ^ (Z0 ... Z3).
  */
-#define SALSA20_8_XOR(in, out) \
-    { \
-        __m128i Y0 = X0 = _mm_xor_si128(X0, (in)[0]); \
-        __m128i Y1 = X1 = _mm_xor_si128(X1, (in)[1]); \
-        __m128i Y2 = X2 = _mm_xor_si128(X2, (in)[2]); \
-        __m128i Y3 = X3 = _mm_xor_si128(X3, (in)[3]); \
-        SALSA20_2ROUNDS \
-        SALSA20_2ROUNDS \
-        SALSA20_2ROUNDS \
-        SALSA20_2ROUNDS \
-        (out)[0] = X0 = _mm_add_epi32(X0, Y0); \
-        (out)[1] = X1 = _mm_add_epi32(X1, Y1); \
-        (out)[2] = X2 = _mm_add_epi32(X2, Y2); \
-        (out)[3] = X3 = _mm_add_epi32(X3, Y3); \
+# define SALSA20_8_XOR(in, out)                               \
+    {                                                         \
+        __m128i Y0 = X0 = _mm_xor_si128(X0, (in)[0]);         \
+        __m128i Y1 = X1 = _mm_xor_si128(X1, (in)[1]);         \
+        __m128i Y2 = X2 = _mm_xor_si128(X2, (in)[2]);         \
+        __m128i Y3 = X3 = _mm_xor_si128(X3, (in)[3]);         \
+        SALSA20_2ROUNDS                                       \
+        SALSA20_2ROUNDS                                       \
+        SALSA20_2ROUNDS                                       \
+        SALSA20_2ROUNDS(out)[0] = X0 = _mm_add_epi32(X0, Y0); \
+        (out)[1] = X1 = _mm_add_epi32(X1, Y1);                \
+        (out)[2] = X2 = _mm_add_epi32(X2, Y2);                \
+        (out)[3] = X3 = _mm_add_epi32(X3, Y3);                \
     }
 
 /**
@@ -108,10 +109,10 @@
  * bytes in length; the output Bout must also be the same size.
  */
 static inline void
-blockmix_salsa8(const __m128i * Bin, __m128i * Bout, size_t r)
+blockmix_salsa8(const __m128i *Bin, __m128i *Bout, size_t r)
 {
     __m128i X0, X1, X2, X3;
-    size_t i;
+    size_t  i;
 
     /* 1: X <-- B_{2r - 1} */
     X0 = Bin[8 * r - 4];
@@ -146,24 +147,24 @@ blockmix_salsa8(const __m128i * Bin, __m128i * Bout, size_t r)
     SALSA20_8_XOR(&Bin[i * 8 + 4], &Bout[(r + i) * 4 + 4])
 }
 
-#define XOR4(in) \
+# define XOR4(in)                    \
     X0 = _mm_xor_si128(X0, (in)[0]); \
     X1 = _mm_xor_si128(X1, (in)[1]); \
     X2 = _mm_xor_si128(X2, (in)[2]); \
     X3 = _mm_xor_si128(X3, (in)[3]);
 
-#define XOR4_2(in1, in2) \
+# define XOR4_2(in1, in2)                   \
     X0 = _mm_xor_si128((in1)[0], (in2)[0]); \
     X1 = _mm_xor_si128((in1)[1], (in2)[1]); \
     X2 = _mm_xor_si128((in1)[2], (in2)[2]); \
     X3 = _mm_xor_si128((in1)[3], (in2)[3]);
 
 static inline uint32_t
-blockmix_salsa8_xor(const __m128i * Bin1, const __m128i * Bin2, __m128i * Bout,
-    size_t r)
+blockmix_salsa8_xor(const __m128i *Bin1, const __m128i *Bin2, __m128i *Bout,
+                    size_t r)
 {
     __m128i X0, X1, X2, X3;
-    size_t i;
+    size_t  i;
 
     /* 1: X <-- B_{2r - 1} */
     XOR4_2(&Bin1[8 * r - 4], &Bin2[8 * r - 4])
@@ -201,11 +202,11 @@ blockmix_salsa8_xor(const __m128i * Bin1, const __m128i * Bin2, __m128i * Bout,
     return _mm_cvtsi128_si32(X0);
 }
 
-#undef ARX
-#undef SALSA20_2ROUNDS
-#undef SALSA20_8_XOR
-#undef XOR4
-#undef XOR4_2
+# undef ARX
+# undef SALSA20_2ROUNDS
+# undef SALSA20_8_XOR
+# undef XOR4
+# undef XOR4_2
 
 /**
  * integerify(B, r):
@@ -213,9 +214,9 @@ blockmix_salsa8_xor(const __m128i * Bin1, const __m128i * Bin2, __m128i * Bout,
  * Note that B's layout is permuted compared to the generic implementation.
  */
 static inline uint32_t
-integerify(const void * B, size_t r)
+integerify(const void *B, size_t r)
 {
-    return *(const uint32_t *)((uintptr_t)(B) + (2 * r - 1) * 64);
+    return *(const uint32_t *) ((uintptr_t)(B) + (2 * r - 1) * 64);
 }
 
 /**
@@ -227,20 +228,19 @@ integerify(const void * B, size_t r)
  * multiple of 64 bytes.
  */
 static void
-smix(uint8_t * B, size_t r, uint32_t N, void * V, void * XY)
+smix(uint8_t *B, size_t r, uint32_t N, void *V, void *XY)
 {
-    size_t s = 128 * r;
-    __m128i * X = (__m128i *) V, * Y;
-    uint32_t * X32 = (uint32_t *) V;
-    uint32_t i, j;
-    size_t k;
+    size_t    s   = 128 * r;
+    __m128i * X   = (__m128i *) V, *Y;
+    uint32_t *X32 = (uint32_t *) V;
+    uint32_t  i, j;
+    size_t    k;
 
     /* 1: X <-- B */
     /* 3: V_i <-- X */
     for (k = 0; k < 2 * r; k++) {
         for (i = 0; i < 16; i++) {
-            X32[k * 16 + i] =
-                LOAD32_LE(&B[(k * 16 + (i * 5 % 16)) * 4]);
+            X32[k * 16 + i] = LOAD32_LE(&B[(k * 16 + (i * 5 % 16)) * 4]);
         }
     }
 
@@ -248,18 +248,18 @@ smix(uint8_t * B, size_t r, uint32_t N, void * V, void * XY)
     for (i = 1; i < N - 1; i += 2) {
         /* 4: X <-- H(X) */
         /* 3: V_i <-- X */
-        Y = (__m128i *)((uintptr_t)(V) + i * s);
+        Y = (__m128i *) ((uintptr_t)(V) + i * s);
         blockmix_salsa8(X, Y, r);
 
         /* 4: X <-- H(X) */
         /* 3: V_i <-- X */
-        X = (__m128i *)((uintptr_t)(V) + (i + 1) * s);
+        X = (__m128i *) ((uintptr_t)(V) + (i + 1) * s);
         blockmix_salsa8(Y, X, r);
     }
 
     /* 4: X <-- H(X) */
     /* 3: V_i <-- X */
-    Y = (__m128i *)((uintptr_t)(V) + i * s);
+    Y = (__m128i *) ((uintptr_t)(V) + i * s);
     blockmix_salsa8(X, Y, r);
 
     /* 4: X <-- H(X) */
@@ -268,19 +268,19 @@ smix(uint8_t * B, size_t r, uint32_t N, void * V, void * XY)
     blockmix_salsa8(Y, X, r);
 
     X32 = (uint32_t *) XY;
-    Y = (__m128i *)((uintptr_t)(XY) + s);
+    Y   = (__m128i *) ((uintptr_t)(XY) + s);
 
     /* 7: j <-- Integerify(X) mod N */
     j = integerify(X, r) & (N - 1);
 
     /* 6: for i = 0 to N - 1 do */
     for (i = 0; i < N; i += 2) {
-        __m128i * V_j = (__m128i *)((uintptr_t)(V) + j * s);
+        __m128i *V_j = (__m128i *) ((uintptr_t)(V) + j * s);
 
         /* 8: X <-- H(X \xor V_j) */
         /* 7: j <-- Integerify(X) mod N */
-        j = blockmix_salsa8_xor(X, V_j, Y, r) & (N - 1);
-        V_j = (__m128i *)((uintptr_t)(V) + j * s);
+        j   = blockmix_salsa8_xor(X, V_j, Y, r) & (N - 1);
+        V_j = (__m128i *) ((uintptr_t)(V) + j * s);
 
         /* 8: X <-- H(X \xor V_j) */
         /* 7: j <-- Integerify(X) mod N */
@@ -306,25 +306,23 @@ smix(uint8_t * B, size_t r, uint32_t N, void * V, void * XY)
  * Return 0 on success; or -1 on error.
  */
 int
-escrypt_kdf_sse(escrypt_local_t * local,
-    const uint8_t * passwd, size_t passwdlen,
-    const uint8_t * salt, size_t saltlen,
-    uint64_t N, uint32_t _r, uint32_t _p,
-    uint8_t * buf, size_t buflen)
+escrypt_kdf_sse(escrypt_local_t *local, const uint8_t *passwd, size_t passwdlen,
+                const uint8_t *salt, size_t saltlen, uint64_t N, uint32_t _r,
+                uint32_t _p, uint8_t *buf, size_t buflen)
 {
-    size_t B_size, V_size, XY_size, need;
+    size_t    B_size, V_size, XY_size, need;
     uint8_t * B;
-    uint32_t * V, * XY;
-    size_t r = _r, p = _p;
-    uint32_t i;
+    uint32_t *V, *XY;
+    size_t    r = _r, p = _p;
+    uint32_t  i;
 
-    /* Sanity-check parameters. */
-#if SIZE_MAX > UINT32_MAX
+/* Sanity-check parameters. */
+# if SIZE_MAX > UINT32_MAX
     if (buflen > (((uint64_t)(1) << 32) - 1) * 32) {
         errno = EFBIG;
         return -1;
     }
-#endif
+# endif
     if ((uint64_t)(r) * (uint64_t)(p) >= ((uint64_t) 1 << 30)) {
         errno = EFBIG;
         return -1;
@@ -342,37 +340,39 @@ escrypt_kdf_sse(escrypt_local_t * local,
         return -1;
     }
     if ((r > SIZE_MAX / 128 / p) ||
-#if SIZE_MAX / 256 <= UINT32_MAX
+# if SIZE_MAX / 256 <= UINT32_MAX
         (r > SIZE_MAX / 256) ||
-#endif
+# endif
         (N > SIZE_MAX / 128 / r)) {
         errno = ENOMEM;
         return -1;
     }
 
     /* Allocate memory. */
-    B_size = (size_t)128 * r * p;
-    V_size = (size_t)128 * r * N;
-    need = B_size + V_size;
+    B_size = (size_t) 128 * r * p;
+    V_size = (size_t) 128 * r * N;
+    need   = B_size + V_size;
     if (need < V_size) {
         errno = ENOMEM;
         return -1;
     }
-    XY_size = (size_t)256 * r + 64;
+    XY_size = (size_t) 256 * r + 64;
     need += XY_size;
     if (need < XY_size) {
         errno = ENOMEM;
         return -1;
     }
     if (local->size < need) {
-        if (free_region(local))
+        if (free_region(local)) {
             return -1; /* LCOV_EXCL_LINE */
-        if (!alloc_region(local, need))
+        }
+        if (!alloc_region(local, need)) {
             return -1; /* LCOV_EXCL_LINE */
+        }
     }
-    B = (uint8_t *)local->aligned;
-    V = (uint32_t *)((uint8_t *)B + B_size);
-    XY = (uint32_t *)((uint8_t *)V + V_size);
+    B  = (uint8_t *) local->aligned;
+    V  = (uint32_t *) ((uint8_t *) B + B_size);
+    XY = (uint32_t *) ((uint8_t *) V + V_size);
 
     /* 1: (B_0 ... B_{p-1}) <-- PBKDF2(P, S, 1, p * MFLen) */
     PBKDF2_SHA256(passwd, passwdlen, salt, saltlen, 1, B, B_size);
@@ -380,7 +380,7 @@ escrypt_kdf_sse(escrypt_local_t * local,
     /* 2: for i = 0 to p - 1 do */
     for (i = 0; i < p; i++) {
         /* 3: B_i <-- MF(B_i, N) */
-        smix(&B[(size_t)128 * i * r], r, (uint32_t) N, V, XY);
+        smix(&B[(size_t) 128 * i * r], r, (uint32_t) N, V, XY);
     }
 
     /* 5: DK <-- PBKDF2(P, B, 1, dkLen) */