rbnacl-libsodium 1.0.11 → 1.0.13

data/vendor/libsodium/src/libsodium/crypto_hash/sha512/{hash_sha512_api.c → hash_sha512.c}

@@ -1,11 +1,13 @@
 #include "crypto_hash_sha512.h"
 
 size_t
-crypto_hash_sha512_bytes(void) {
+crypto_hash_sha512_bytes(void)
+{
     return crypto_hash_sha512_BYTES;
 }
 
 size_t
-crypto_hash_sha512_statebytes(void) {
+crypto_hash_sha512_statebytes(void)
+{
     return sizeof(crypto_hash_sha512_state);
 }

data/vendor/libsodium/src/libsodium/crypto_kdf/blake2b/kdf_blake2b.c

@@ -0,0 +1,52 @@
+#include <errno.h>
+
+#include "crypto_kdf_blake2b.h"
+#include "crypto_generichash_blake2b.h"
+#include "private/common.h"
+
+size_t
+crypto_kdf_blake2b_bytes_min(void)
+{
+    return crypto_kdf_blake2b_BYTES_MIN;
+}
+
+size_t
+crypto_kdf_blake2b_bytes_max(void)
+{
+    return crypto_kdf_blake2b_BYTES_MAX;
+}
+
+size_t
+crypto_kdf_blake2b_contextbytes(void)
+{
+    return crypto_kdf_blake2b_CONTEXTBYTES;
+}
+
+size_t
+crypto_kdf_blake2b_keybytes(void)
+{
+    return crypto_kdf_blake2b_KEYBYTES;
+}
+
+int crypto_kdf_blake2b_derive_from_key(unsigned char *subkey, size_t subkey_len,
+                                       uint64_t subkey_id,
+                                       const char ctx[crypto_kdf_blake2b_CONTEXTBYTES],
+                                       const unsigned char key[crypto_kdf_blake2b_KEYBYTES])
+{
+    unsigned char ctx_padded[crypto_generichash_blake2b_PERSONALBYTES];
+    unsigned char salt[crypto_generichash_blake2b_SALTBYTES];
+
+    memcpy(ctx_padded, ctx, crypto_kdf_blake2b_CONTEXTBYTES);
+    memset(ctx_padded + crypto_kdf_blake2b_CONTEXTBYTES, 0, sizeof ctx_padded - crypto_kdf_blake2b_CONTEXTBYTES);
+    STORE64_LE(salt, subkey_id);
+    memset(salt + 8, 0, (sizeof salt) - 8);
+    if (subkey_len < crypto_kdf_blake2b_BYTES_MIN ||
+        subkey_len > crypto_kdf_blake2b_BYTES_MAX) {
+        errno = EINVAL;
+        return -1;
+    }
+    return crypto_generichash_blake2b_salt_personal(subkey, subkey_len,
+                                                    NULL, 0,
+                                                    key, crypto_kdf_blake2b_KEYBYTES,
+                                                    salt, ctx_padded);
+}

data/vendor/libsodium/src/libsodium/crypto_kdf/crypto_kdf.c

@@ -0,0 +1,49 @@
+
+#include "crypto_kdf.h"
+#include "randombytes.h"
+
+const char *
+crypto_kdf_primitive(void)
+{
+    return crypto_kdf_PRIMITIVE;
+}
+
+size_t
+crypto_kdf_bytes_min(void)
+{
+    return crypto_kdf_BYTES_MIN;
+}
+
+size_t
+crypto_kdf_bytes_max(void)
+{
+    return crypto_kdf_BYTES_MAX;
+}
+
+size_t
+crypto_kdf_contextbytes(void)
+{
+    return crypto_kdf_CONTEXTBYTES;
+}
+
+size_t
+crypto_kdf_keybytes(void)
+{
+    return crypto_kdf_KEYBYTES;
+}
+
+int
+crypto_kdf_derive_from_key(unsigned char *subkey, size_t subkey_len,
+                           uint64_t subkey_id,
+                           const char ctx[crypto_kdf_CONTEXTBYTES],
+                           const unsigned char key[crypto_kdf_KEYBYTES])
+{
+    return crypto_kdf_blake2b_derive_from_key(subkey, subkey_len,
+                                              subkey_id, ctx, key);
+}
+
+void
+crypto_kdf_keygen(unsigned char k[crypto_kdf_KEYBYTES])
+{
+    randombytes_buf(k, crypto_kdf_KEYBYTES);
+}

data/vendor/libsodium/src/libsodium/crypto_kx/crypto_kx.c

@@ -0,0 +1,136 @@
+
+#include <stddef.h>
+
+#include "crypto_generichash.h"
+#include "crypto_kx.h"
+#include "crypto_scalarmult.h"
+#include "private/common.h"
+#include "randombytes.h"
+#include "utils.h"
+
+int
+crypto_kx_seed_keypair(unsigned char pk[crypto_kx_PUBLICKEYBYTES],
+                       unsigned char sk[crypto_kx_SECRETKEYBYTES],
+                       const unsigned char seed[crypto_kx_SEEDBYTES])
+{
+    crypto_generichash(sk, crypto_kx_SECRETKEYBYTES,
+                       seed, crypto_kx_SEEDBYTES, NULL, 0);
+    return crypto_scalarmult_base(pk, sk);
+}
+
+int
+crypto_kx_keypair(unsigned char pk[crypto_kx_PUBLICKEYBYTES],
+                  unsigned char sk[crypto_kx_SECRETKEYBYTES])
+{
+    COMPILER_ASSERT(crypto_kx_SECRETKEYBYTES == crypto_scalarmult_SCALARBYTES);
+    COMPILER_ASSERT(crypto_kx_PUBLICKEYBYTES == crypto_scalarmult_BYTES);
+
+    randombytes_buf(sk, crypto_kx_SECRETKEYBYTES);
+    return crypto_scalarmult_base(pk, sk);
+}
+
+int
+crypto_kx_client_session_keys(unsigned char rx[crypto_kx_SESSIONKEYBYTES],
+                              unsigned char tx[crypto_kx_SESSIONKEYBYTES],
+                              const unsigned char client_pk[crypto_kx_PUBLICKEYBYTES],
+                              const unsigned char client_sk[crypto_kx_SECRETKEYBYTES],
+                              const unsigned char server_pk[crypto_kx_PUBLICKEYBYTES])
+{
+    crypto_generichash_state h;
+    unsigned char            q[crypto_scalarmult_BYTES];
+    unsigned char            keys[2 * crypto_kx_SESSIONKEYBYTES];
+    int                      i;
+
+    if (rx == NULL) {
+        rx = tx;
+    }
+    if (tx == NULL) {
+        tx = rx;
+    }
+    if (crypto_scalarmult(q, client_sk, server_pk) != 0) {
+        return -1;
+    }
+    COMPILER_ASSERT(sizeof keys <= crypto_generichash_BYTES_MAX);
+    crypto_generichash_init(&h, NULL, 0U, sizeof keys);
+    crypto_generichash_update(&h, q, crypto_scalarmult_BYTES);
+    sodium_memzero(q, sizeof q);
+    crypto_generichash_update(&h, client_pk, crypto_kx_PUBLICKEYBYTES);
+    crypto_generichash_update(&h, server_pk, crypto_kx_PUBLICKEYBYTES);
+    crypto_generichash_final(&h, keys, sizeof keys);
+    sodium_memzero(&h, sizeof h);
+    for (i = 0; i < crypto_kx_SESSIONKEYBYTES; i++) {
+        rx[i] = keys[i];
+        tx[i] = keys[i + crypto_kx_SESSIONKEYBYTES];
+    }
+    sodium_memzero(keys, sizeof keys);
+
+    return 0;
+}
+
+int
+crypto_kx_server_session_keys(unsigned char rx[crypto_kx_SESSIONKEYBYTES],
+                              unsigned char tx[crypto_kx_SESSIONKEYBYTES],
+                              const unsigned char server_pk[crypto_kx_PUBLICKEYBYTES],
+                              const unsigned char server_sk[crypto_kx_SECRETKEYBYTES],
+                              const unsigned char client_pk[crypto_kx_PUBLICKEYBYTES])
+{
+    crypto_generichash_state h;
+    unsigned char            q[crypto_scalarmult_BYTES];
+    unsigned char            keys[2 * crypto_kx_SESSIONKEYBYTES];
+    int                      i;
+
+    if (rx == NULL) {
+        rx = tx;
+    }
+    if (tx == NULL) {
+        tx = rx;
+    }
+    if (crypto_scalarmult(q, server_sk, client_pk) != 0) {
+        return -1;
+    }
+    COMPILER_ASSERT(sizeof keys <= crypto_generichash_BYTES_MAX);
+    crypto_generichash_init(&h, NULL, 0U, sizeof keys);
+    crypto_generichash_update(&h, q, crypto_scalarmult_BYTES);
+    sodium_memzero(q, sizeof q);
+    crypto_generichash_update(&h, client_pk, crypto_kx_PUBLICKEYBYTES);
+    crypto_generichash_update(&h, server_pk, crypto_kx_PUBLICKEYBYTES);
+    crypto_generichash_final(&h, keys, sizeof keys);
+    sodium_memzero(&h, sizeof h);
+    for (i = 0; i < crypto_kx_SESSIONKEYBYTES; i++) {
+        tx[i] = keys[i];
+        rx[i] = keys[i + crypto_kx_SESSIONKEYBYTES];
+    }
+    sodium_memzero(keys, sizeof keys);
+
+    return 0;
+}
+
+size_t
+crypto_kx_publickeybytes(void)
+{
+    return crypto_kx_PUBLICKEYBYTES;
+}
+
+size_t
+crypto_kx_secretkeybytes(void)
+{
+    return crypto_kx_SECRETKEYBYTES;
+}
+
+size_t
+crypto_kx_seedbytes(void)
+{
+    return crypto_kx_SEEDBYTES;
+}
+
+size_t
+crypto_kx_sessionkeybytes(void)
+{
+    return crypto_kx_SESSIONKEYBYTES;
+}
+
+const char *
+crypto_kx_primitive(void)
+{
+    return crypto_kx_PRIMITIVE;
+}

data/vendor/libsodium/src/libsodium/crypto_onetimeauth/crypto_onetimeauth.c

@@ -1,5 +1,6 @@
 
 #include "crypto_onetimeauth.h"
+#include "randombytes.h"
 
 size_t
 crypto_onetimeauth_statebytes(void)
@@ -63,3 +64,8 @@ crypto_onetimeauth_primitive(void)
 {
     return crypto_onetimeauth_PRIMITIVE;
 }
+
+void crypto_onetimeauth_keygen(unsigned char k[crypto_onetimeauth_KEYBYTES])
+{
+    randombytes_buf(k, crypto_onetimeauth_KEYBYTES);
+}

data/vendor/libsodium/src/libsodium/crypto_onetimeauth/poly1305/donna/poly1305_donna.c

@@ -1,11 +1,13 @@
 
+#include "poly1305_donna.h"
 #include "crypto_verify_16.h"
+#include "private/common.h"
 #include "utils.h"
-#include "poly1305_donna.h"
+
 #ifdef HAVE_TI_MODE
-# include "poly1305_donna64.h"
+#include "poly1305_donna64.h"
 #else
-# include "poly1305_donna32.h"
+#include "poly1305_donna32.h"
 #endif
 #include "../onetimeauth_poly1305.h"
 
@@ -19,15 +21,18 @@ poly1305_update(poly1305_state_internal_t *st, const unsigned char *m,
     if (st->leftover) {
         unsigned long long want = (poly1305_block_size - st->leftover);
 
-        if (want > bytes)
+        if (want > bytes) {
             want = bytes;
-        for (i = 0; i < want; i++)
+        }
+        for (i = 0; i < want; i++) {
             st->buffer[st->leftover + i] = m[i];
+        }
         bytes -= want;
         m += want;
         st->leftover += want;
-        if (st->leftover < poly1305_block_size)
+        if (st->leftover < poly1305_block_size) {
             return;
+        }
         poly1305_blocks(st, st->buffer, poly1305_block_size);
         st->leftover = 0;
     }
@@ -52,7 +57,7 @@ poly1305_update(poly1305_state_internal_t *st, const unsigned char *m,
 
 static int
 crypto_onetimeauth_poly1305_donna(unsigned char *out, const unsigned char *m,
-                                  unsigned long long inlen,
+                                  unsigned long long   inlen,
                                   const unsigned char *key)
 {
     CRYPTO_ALIGN(64) poly1305_state_internal_t state;
@@ -68,28 +73,28 @@ static int
 crypto_onetimeauth_poly1305_donna_init(crypto_onetimeauth_poly1305_state *state,
                                        const unsigned char *key)
 {
-    (void) sizeof(int[sizeof (crypto_onetimeauth_poly1305_state) >=
-                      sizeof (poly1305_state_internal_t) ? 1 : -1]);
-    poly1305_init((poly1305_state_internal_t *)(void *) state, key);
+    COMPILER_ASSERT(sizeof(crypto_onetimeauth_poly1305_state) >=
+        sizeof(poly1305_state_internal_t));
+    poly1305_init((poly1305_state_internal_t *) (void *) state, key);
 
     return 0;
 }
 
 static int
-crypto_onetimeauth_poly1305_donna_update(crypto_onetimeauth_poly1305_state *state,
-                                         const unsigned char *in,
-                                         unsigned long long inlen)
+crypto_onetimeauth_poly1305_donna_update(
+    crypto_onetimeauth_poly1305_state *state, const unsigned char *in,
+    unsigned long long inlen)
 {
-    poly1305_update((poly1305_state_internal_t *)(void *) state, in, inlen);
+    poly1305_update((poly1305_state_internal_t *) (void *) state, in, inlen);
 
     return 0;
 }
 
 static int
-crypto_onetimeauth_poly1305_donna_final(crypto_onetimeauth_poly1305_state *state,
-                                        unsigned char *out)
+crypto_onetimeauth_poly1305_donna_final(
+    crypto_onetimeauth_poly1305_state *state, unsigned char *out)
 {
-    poly1305_finish((poly1305_state_internal_t *)(void *) state, out);
+    poly1305_finish((poly1305_state_internal_t *) (void *) state, out);
 
     return 0;
 }
@@ -97,21 +102,23 @@ crypto_onetimeauth_poly1305_donna_final(crypto_onetimeauth_poly1305_state *state
 static int
 crypto_onetimeauth_poly1305_donna_verify(const unsigned char *h,
                                          const unsigned char *in,
-                                         unsigned long long inlen,
+                                         unsigned long long   inlen,
                                          const unsigned char *k)
 {
     unsigned char correct[16];
 
-    crypto_onetimeauth_poly1305_donna(correct,in,inlen,k);
+    crypto_onetimeauth_poly1305_donna(correct, in, inlen, k);
 
-    return crypto_verify_16(h,correct);
+    return crypto_verify_16(h, correct);
 }
 
 struct crypto_onetimeauth_poly1305_implementation
-crypto_onetimeauth_poly1305_donna_implementation = {
-    SODIUM_C99(.onetimeauth =) crypto_onetimeauth_poly1305_donna,
-    SODIUM_C99(.onetimeauth_verify =) crypto_onetimeauth_poly1305_donna_verify,
-    SODIUM_C99(.onetimeauth_init =) crypto_onetimeauth_poly1305_donna_init,
-    SODIUM_C99(.onetimeauth_update =) crypto_onetimeauth_poly1305_donna_update,
-    SODIUM_C99(.onetimeauth_final =) crypto_onetimeauth_poly1305_donna_final
-};
+    crypto_onetimeauth_poly1305_donna_implementation = {
+        SODIUM_C99(.onetimeauth =) crypto_onetimeauth_poly1305_donna,
+        SODIUM_C99(.onetimeauth_verify =)
+            crypto_onetimeauth_poly1305_donna_verify,
+        SODIUM_C99(.onetimeauth_init =) crypto_onetimeauth_poly1305_donna_init,
+        SODIUM_C99(.onetimeauth_update =)
+            crypto_onetimeauth_poly1305_donna_update,
+        SODIUM_C99(.onetimeauth_final =) crypto_onetimeauth_poly1305_donna_final
+    };

data/vendor/libsodium/src/libsodium/crypto_onetimeauth/poly1305/donna/poly1305_donna.h

@@ -3,8 +3,8 @@
 
 #include <stddef.h>
 
-#include "crypto_onetimeauth_poly1305.h"
 #include "../onetimeauth_poly1305.h"
+#include "crypto_onetimeauth_poly1305.h"
 
 extern struct crypto_onetimeauth_poly1305_implementation
     crypto_onetimeauth_poly1305_donna_implementation;

data/vendor/libsodium/src/libsodium/crypto_onetimeauth/poly1305/donna/poly1305_donna32.h

@@ -1,11 +1,12 @@
 /*
-        poly1305 implementation using 32 bit * 32 bit = 64 bit multiplication and 64 bit addition
+   poly1305 implementation using 32 bit * 32 bit = 64 bit multiplication
+   and 64 bit addition
 */
 
 #if defined(_MSC_VER)
 # define POLY1305_NOINLINE __declspec(noinline)
 #elif defined(__GNUC__)
-# define POLY1305_NOINLINE __attribute__ ((noinline))
+# define POLY1305_NOINLINE __attribute__((noinline))
 #else
 # define POLY1305_NOINLINE
 #endif
@@ -16,173 +17,219 @@
 
 /* 17 + sizeof(unsigned long long) + 14*sizeof(unsigned long) */
 typedef struct poly1305_state_internal_t {
-        unsigned long r[5];
-        unsigned long h[5];
-        unsigned long pad[4];
-        unsigned long long leftover;
-        unsigned char buffer[poly1305_block_size];
-        unsigned char final;
+    unsigned long      r[5];
+    unsigned long      h[5];
+    unsigned long      pad[4];
+    unsigned long long leftover;
+    unsigned char      buffer[poly1305_block_size];
+    unsigned char      final;
 } poly1305_state_internal_t;
 
 static void
 poly1305_init(poly1305_state_internal_t *st, const unsigned char key[32])
 {
-        /* r &= 0xffffffc0ffffffc0ffffffc0fffffff */
-        st->r[0] = (LOAD32_LE(&key[ 0])     ) & 0x3ffffff;
-        st->r[1] = (LOAD32_LE(&key[ 3]) >> 2) & 0x3ffff03;
-        st->r[2] = (LOAD32_LE(&key[ 6]) >> 4) & 0x3ffc0ff;
-        st->r[3] = (LOAD32_LE(&key[ 9]) >> 6) & 0x3f03fff;
-        st->r[4] = (LOAD32_LE(&key[12]) >> 8) & 0x00fffff;
-
-        /* h = 0 */
-        st->h[0] = 0;
-        st->h[1] = 0;
-        st->h[2] = 0;
-        st->h[3] = 0;
-        st->h[4] = 0;
-
-        /* save pad for later */
-        st->pad[0] = LOAD32_LE(&key[16]);
-        st->pad[1] = LOAD32_LE(&key[20]);
-        st->pad[2] = LOAD32_LE(&key[24]);
-        st->pad[3] = LOAD32_LE(&key[28]);
-
-        st->leftover = 0;
-        st->final = 0;
+    /* r &= 0xffffffc0ffffffc0ffffffc0fffffff */
+    st->r[0] = (LOAD32_LE(&key[0])) & 0x3ffffff;
+    st->r[1] = (LOAD32_LE(&key[3]) >> 2) & 0x3ffff03;
+    st->r[2] = (LOAD32_LE(&key[6]) >> 4) & 0x3ffc0ff;
+    st->r[3] = (LOAD32_LE(&key[9]) >> 6) & 0x3f03fff;
+    st->r[4] = (LOAD32_LE(&key[12]) >> 8) & 0x00fffff;
+
+    /* h = 0 */
+    st->h[0] = 0;
+    st->h[1] = 0;
+    st->h[2] = 0;
+    st->h[3] = 0;
+    st->h[4] = 0;
+
+    /* save pad for later */
+    st->pad[0] = LOAD32_LE(&key[16]);
+    st->pad[1] = LOAD32_LE(&key[20]);
+    st->pad[2] = LOAD32_LE(&key[24]);
+    st->pad[3] = LOAD32_LE(&key[28]);
+
+    st->leftover = 0;
+    st->final    = 0;
 }
 
 static void
-poly1305_blocks(poly1305_state_internal_t *st, const unsigned char *m, unsigned long long bytes)
+poly1305_blocks(poly1305_state_internal_t *st, const unsigned char *m,
+                unsigned long long bytes)
 {
-        const unsigned long hibit = (st->final) ? 0UL : (1UL << 24); /* 1 << 128 */
-        unsigned long r0,r1,r2,r3,r4;
-        unsigned long s1,s2,s3,s4;
-        unsigned long h0,h1,h2,h3,h4;
-        unsigned long long d0,d1,d2,d3,d4;
-        unsigned long c;
-
-        r0 = st->r[0];
-        r1 = st->r[1];
-        r2 = st->r[2];
-        r3 = st->r[3];
-        r4 = st->r[4];
-
-        s1 = r1 * 5;
-        s2 = r2 * 5;
-        s3 = r3 * 5;
-        s4 = r4 * 5;
-
-        h0 = st->h[0];
-        h1 = st->h[1];
-        h2 = st->h[2];
-        h3 = st->h[3];
-        h4 = st->h[4];
-
-        while (bytes >= poly1305_block_size) {
-                /* h += m[i] */
-                h0 += (LOAD32_LE(m+ 0)     ) & 0x3ffffff;
-                h1 += (LOAD32_LE(m+ 3) >> 2) & 0x3ffffff;
-                h2 += (LOAD32_LE(m+ 6) >> 4) & 0x3ffffff;
-                h3 += (LOAD32_LE(m+ 9) >> 6) & 0x3ffffff;
-                h4 += (LOAD32_LE(m+12) >> 8) | hibit;
-
-                /* h *= r */
-                d0 = ((unsigned long long)h0 * r0) + ((unsigned long long)h1 * s4) + ((unsigned long long)h2 * s3) + ((unsigned long long)h3 * s2) + ((unsigned long long)h4 * s1);
-                d1 = ((unsigned long long)h0 * r1) + ((unsigned long long)h1 * r0) + ((unsigned long long)h2 * s4) + ((unsigned long long)h3 * s3) + ((unsigned long long)h4 * s2);
-                d2 = ((unsigned long long)h0 * r2) + ((unsigned long long)h1 * r1) + ((unsigned long long)h2 * r0) + ((unsigned long long)h3 * s4) + ((unsigned long long)h4 * s3);
-                d3 = ((unsigned long long)h0 * r3) + ((unsigned long long)h1 * r2) + ((unsigned long long)h2 * r1) + ((unsigned long long)h3 * r0) + ((unsigned long long)h4 * s4);
-                d4 = ((unsigned long long)h0 * r4) + ((unsigned long long)h1 * r3) + ((unsigned long long)h2 * r2) + ((unsigned long long)h3 * r1) + ((unsigned long long)h4 * r0);
-
-                /* (partial) h %= p */
-                              c = (unsigned long)(d0 >> 26); h0 = (unsigned long)d0 & 0x3ffffff;
-                d1 += c;      c = (unsigned long)(d1 >> 26); h1 = (unsigned long)d1 & 0x3ffffff;
-                d2 += c;      c = (unsigned long)(d2 >> 26); h2 = (unsigned long)d2 & 0x3ffffff;
-                d3 += c;      c = (unsigned long)(d3 >> 26); h3 = (unsigned long)d3 & 0x3ffffff;
-                d4 += c;      c = (unsigned long)(d4 >> 26); h4 = (unsigned long)d4 & 0x3ffffff;
-                h0 += c * 5;  c =                (h0 >> 26); h0 =                h0 & 0x3ffffff;
-                h1 += c;
-
-                m += poly1305_block_size;
-                bytes -= poly1305_block_size;
-        }
-
-        st->h[0] = h0;
-        st->h[1] = h1;
-        st->h[2] = h2;
-        st->h[3] = h3;
-        st->h[4] = h4;
+    const unsigned long hibit = (st->final) ? 0UL : (1UL << 24); /* 1 << 128 */
+    unsigned long       r0, r1, r2, r3, r4;
+    unsigned long       s1, s2, s3, s4;
+    unsigned long       h0, h1, h2, h3, h4;
+    unsigned long long  d0, d1, d2, d3, d4;
+    unsigned long       c;
+
+    r0 = st->r[0];
+    r1 = st->r[1];
+    r2 = st->r[2];
+    r3 = st->r[3];
+    r4 = st->r[4];
+
+    s1 = r1 * 5;
+    s2 = r2 * 5;
+    s3 = r3 * 5;
+    s4 = r4 * 5;
+
+    h0 = st->h[0];
+    h1 = st->h[1];
+    h2 = st->h[2];
+    h3 = st->h[3];
+    h4 = st->h[4];
+
+    while (bytes >= poly1305_block_size) {
+        /* h += m[i] */
+        h0 += (LOAD32_LE(m + 0)) & 0x3ffffff;
+        h1 += (LOAD32_LE(m + 3) >> 2) & 0x3ffffff;
+        h2 += (LOAD32_LE(m + 6) >> 4) & 0x3ffffff;
+        h3 += (LOAD32_LE(m + 9) >> 6) & 0x3ffffff;
+        h4 += (LOAD32_LE(m + 12) >> 8) | hibit;
+
+        /* h *= r */
+        d0 = ((unsigned long long) h0 * r0) + ((unsigned long long) h1 * s4) +
+             ((unsigned long long) h2 * s3) + ((unsigned long long) h3 * s2) +
+             ((unsigned long long) h4 * s1);
+        d1 = ((unsigned long long) h0 * r1) + ((unsigned long long) h1 * r0) +
+             ((unsigned long long) h2 * s4) + ((unsigned long long) h3 * s3) +
+             ((unsigned long long) h4 * s2);
+        d2 = ((unsigned long long) h0 * r2) + ((unsigned long long) h1 * r1) +
+             ((unsigned long long) h2 * r0) + ((unsigned long long) h3 * s4) +
+             ((unsigned long long) h4 * s3);
+        d3 = ((unsigned long long) h0 * r3) + ((unsigned long long) h1 * r2) +
+             ((unsigned long long) h2 * r1) + ((unsigned long long) h3 * r0) +
+             ((unsigned long long) h4 * s4);
+        d4 = ((unsigned long long) h0 * r4) + ((unsigned long long) h1 * r3) +
+             ((unsigned long long) h2 * r2) + ((unsigned long long) h3 * r1) +
+             ((unsigned long long) h4 * r0);
+
+        /* (partial) h %= p */
+        c  = (unsigned long) (d0 >> 26);
+        h0 = (unsigned long) d0 & 0x3ffffff;
+        d1 += c;
+        c  = (unsigned long) (d1 >> 26);
+        h1 = (unsigned long) d1 & 0x3ffffff;
+        d2 += c;
+        c  = (unsigned long) (d2 >> 26);
+        h2 = (unsigned long) d2 & 0x3ffffff;
+        d3 += c;
+        c  = (unsigned long) (d3 >> 26);
+        h3 = (unsigned long) d3 & 0x3ffffff;
+        d4 += c;
+        c  = (unsigned long) (d4 >> 26);
+        h4 = (unsigned long) d4 & 0x3ffffff;
+        h0 += c * 5;
+        c  = (h0 >> 26);
+        h0 = h0 & 0x3ffffff;
+        h1 += c;
+
+        m += poly1305_block_size;
+        bytes -= poly1305_block_size;
+    }
+
+    st->h[0] = h0;
+    st->h[1] = h1;
+    st->h[2] = h2;
+    st->h[3] = h3;
+    st->h[4] = h4;
 }
 
 static POLY1305_NOINLINE void
 poly1305_finish(poly1305_state_internal_t *st, unsigned char mac[16])
 {
-        unsigned long h0,h1,h2,h3,h4,c;
-        unsigned long g0,g1,g2,g3,g4;
-        unsigned long long f;
-        unsigned long mask;
-
-        /* process the remaining block */
-        if (st->leftover) {
-                unsigned long long i = st->leftover;
-                st->buffer[i++] = 1;
-                for (; i < poly1305_block_size; i++)
-                        st->buffer[i] = 0;
-                st->final = 1;
-                poly1305_blocks(st, st->buffer, poly1305_block_size);
+    unsigned long      h0, h1, h2, h3, h4, c;
+    unsigned long      g0, g1, g2, g3, g4;
+    unsigned long long f;
+    unsigned long      mask;
+
+    /* process the remaining block */
+    if (st->leftover) {
+        unsigned long long i = st->leftover;
+
+        st->buffer[i++] = 1;
+        for (; i < poly1305_block_size; i++) {
+            st->buffer[i] = 0;
         }
-
-        /* fully carry h */
-        h0 = st->h[0];
-        h1 = st->h[1];
-        h2 = st->h[2];
-        h3 = st->h[3];
-        h4 = st->h[4];
-
-                     c = h1 >> 26; h1 = h1 & 0x3ffffff;
-        h2 +=     c; c = h2 >> 26; h2 = h2 & 0x3ffffff;
-        h3 +=     c; c = h3 >> 26; h3 = h3 & 0x3ffffff;
-        h4 +=     c; c = h4 >> 26; h4 = h4 & 0x3ffffff;
-        h0 += c * 5; c = h0 >> 26; h0 = h0 & 0x3ffffff;
-        h1 +=     c;
-
-        /* compute h + -p */
-        g0 = h0 + 5; c = g0 >> 26; g0 &= 0x3ffffff;
-        g1 = h1 + c; c = g1 >> 26; g1 &= 0x3ffffff;
-        g2 = h2 + c; c = g2 >> 26; g2 &= 0x3ffffff;
-        g3 = h3 + c; c = g3 >> 26; g3 &= 0x3ffffff;
-        g4 = h4 + c - (1UL << 26);
-
-        /* select h if h < p, or h + -p if h >= p */
-        mask = (g4 >> ((sizeof(unsigned long) * 8) - 1)) - 1;
-        g0 &= mask;
-        g1 &= mask;
-        g2 &= mask;
-        g3 &= mask;
-        g4 &= mask;
-        mask = ~mask;
-        h0 = (h0 & mask) | g0;
-        h1 = (h1 & mask) | g1;
-        h2 = (h2 & mask) | g2;
-        h3 = (h3 & mask) | g3;
-        h4 = (h4 & mask) | g4;
-
-        /* h = h % (2^128) */
-        h0 = ((h0      ) | (h1 << 26)) & 0xffffffff;
-        h1 = ((h1 >>  6) | (h2 << 20)) & 0xffffffff;
-        h2 = ((h2 >> 12) | (h3 << 14)) & 0xffffffff;
-        h3 = ((h3 >> 18) | (h4 <<  8)) & 0xffffffff;
-
-        /* mac = (h + pad) % (2^128) */
-        f = (unsigned long long)h0 + st->pad[0]            ; h0 = (unsigned long)f;
-        f = (unsigned long long)h1 + st->pad[1] + (f >> 32); h1 = (unsigned long)f;
-        f = (unsigned long long)h2 + st->pad[2] + (f >> 32); h2 = (unsigned long)f;
-        f = (unsigned long long)h3 + st->pad[3] + (f >> 32); h3 = (unsigned long)f;
-
-        STORE32_LE(mac +  0, h0);
-        STORE32_LE(mac +  4, h1);
-        STORE32_LE(mac +  8, h2);
-        STORE32_LE(mac + 12, h3);
-
-        /* zero out the state */
-        sodium_memzero((void *)st, sizeof *st);
+        st->final = 1;
+        poly1305_blocks(st, st->buffer, poly1305_block_size);
+    }
+
+    /* fully carry h */
+    h0 = st->h[0];
+    h1 = st->h[1];
+    h2 = st->h[2];
+    h3 = st->h[3];
+    h4 = st->h[4];
+
+    c  = h1 >> 26;
+    h1 = h1 & 0x3ffffff;
+    h2 += c;
+    c  = h2 >> 26;
+    h2 = h2 & 0x3ffffff;
+    h3 += c;
+    c  = h3 >> 26;
+    h3 = h3 & 0x3ffffff;
+    h4 += c;
+    c  = h4 >> 26;
+    h4 = h4 & 0x3ffffff;
+    h0 += c * 5;
+    c  = h0 >> 26;
+    h0 = h0 & 0x3ffffff;
+    h1 += c;
+
+    /* compute h + -p */
+    g0 = h0 + 5;
+    c  = g0 >> 26;
+    g0 &= 0x3ffffff;
+    g1 = h1 + c;
+    c  = g1 >> 26;
+    g1 &= 0x3ffffff;
+    g2 = h2 + c;
+    c  = g2 >> 26;
+    g2 &= 0x3ffffff;
+    g3 = h3 + c;
+    c  = g3 >> 26;
+    g3 &= 0x3ffffff;
+    g4 = h4 + c - (1UL << 26);
+
+    /* select h if h < p, or h + -p if h >= p */
+    mask = (g4 >> ((sizeof(unsigned long) * 8) - 1)) - 1;
+    g0 &= mask;
+    g1 &= mask;
+    g2 &= mask;
+    g3 &= mask;
+    g4 &= mask;
+    mask = ~mask;
+
+    h0 = (h0 & mask) | g0;
+    h1 = (h1 & mask) | g1;
+    h2 = (h2 & mask) | g2;
+    h3 = (h3 & mask) | g3;
+    h4 = (h4 & mask) | g4;
+
+    /* h = h % (2^128) */
+    h0 = ((h0) | (h1 << 26)) & 0xffffffff;
+    h1 = ((h1 >> 6) | (h2 << 20)) & 0xffffffff;
+    h2 = ((h2 >> 12) | (h3 << 14)) & 0xffffffff;
+    h3 = ((h3 >> 18) | (h4 << 8)) & 0xffffffff;
+
+    /* mac = (h + pad) % (2^128) */
+    f  = (unsigned long long) h0 + st->pad[0];
+    h0 = (unsigned long) f;
+    f  = (unsigned long long) h1 + st->pad[1] + (f >> 32);
+    h1 = (unsigned long) f;
+    f  = (unsigned long long) h2 + st->pad[2] + (f >> 32);
+    h2 = (unsigned long) f;
+    f  = (unsigned long long) h3 + st->pad[3] + (f >> 32);
+    h3 = (unsigned long) f;
+
+    STORE32_LE(mac + 0, (uint32_t) h0);
+    STORE32_LE(mac + 4, (uint32_t) h1);
+    STORE32_LE(mac + 8, (uint32_t) h2);
+    STORE32_LE(mac + 12, (uint32_t) h3);
+
+    /* zero out the state */
+    sodium_memzero((void *) st, sizeof *st);
 }