libsodium: update to 1.0.19

4 files changed, 370 insertions, 370 deletions

diff --git a/libs/libsodium/src/crypto_auth/crypto_auth.c b/libs/libsodium/src/crypto_auth/crypto_auth.c
index d061c8c1c5..f5c3d4fe65 100644
--- a/libs/libsodium/src/crypto_auth/crypto_auth.c
+++ b/libs/libsodium/src/crypto_auth/crypto_auth.c
@@ -1,41 +1,41 @@
-
-#include "crypto_auth.h"
-#include "randombytes.h"
-
-size_t
-crypto_auth_bytes(void)
-{
-    return crypto_auth_BYTES;
-}
-
-size_t
-crypto_auth_keybytes(void)
-{
-    return crypto_auth_KEYBYTES;
-}
-
-const char *
-crypto_auth_primitive(void)
-{
-    return crypto_auth_PRIMITIVE;
-}
-
-int
-crypto_auth(unsigned char *out, const unsigned char *in,
-            unsigned long long inlen, const unsigned char *k)
-{
-    return crypto_auth_hmacsha512256(out, in, inlen, k);
-}
-
-int
-crypto_auth_verify(const unsigned char *h, const unsigned char *in,
-                   unsigned long long inlen,const unsigned char *k)
-{
-    return crypto_auth_hmacsha512256_verify(h, in, inlen, k);
-}
-
-void
-crypto_auth_keygen(unsigned char k[crypto_auth_KEYBYTES])
-{
-    randombytes_buf(k, crypto_auth_KEYBYTES);
-}
+

+#include "crypto_auth.h"

+#include "randombytes.h"

+

+size_t

+crypto_auth_bytes(void)

+{

+    return crypto_auth_BYTES;

+}

+

+size_t

+crypto_auth_keybytes(void)

+{

+    return crypto_auth_KEYBYTES;

+}

+

+const char *

+crypto_auth_primitive(void)

+{

+    return crypto_auth_PRIMITIVE;

+}

+

+int

+crypto_auth(unsigned char *out, const unsigned char *in,

+            unsigned long long inlen, const unsigned char *k)

+{

+    return crypto_auth_hmacsha512256(out, in, inlen, k);

+}

+

+int

+crypto_auth_verify(const unsigned char *h, const unsigned char *in,

+                   unsigned long long inlen,const unsigned char *k)

+{

+    return crypto_auth_hmacsha512256_verify(h, in, inlen, k);

+}

+

+void

+crypto_auth_keygen(unsigned char k[crypto_auth_KEYBYTES])

+{

+    randombytes_buf(k, crypto_auth_KEYBYTES);

+}

diff --git a/libs/libsodium/src/crypto_auth/hmacsha256/auth_hmacsha256.c b/libs/libsodium/src/crypto_auth/hmacsha256/auth_hmacsha256.c
index a951e932b8..63ca1cfb64 100644
--- a/libs/libsodium/src/crypto_auth/hmacsha256/auth_hmacsha256.c
+++ b/libs/libsodium/src/crypto_auth/hmacsha256/auth_hmacsha256.c
@@ -1,118 +1,118 @@
-
-#include <stddef.h>
-#include <stdint.h>
-#include <string.h>
-
-#include "crypto_auth_hmacsha256.h"
-#include "crypto_hash_sha256.h"
-#include "crypto_verify_32.h"
-#include "randombytes.h"
-#include "utils.h"
-
-size_t
-crypto_auth_hmacsha256_bytes(void)
-{
-    return crypto_auth_hmacsha256_BYTES;
-}
-
-size_t
-crypto_auth_hmacsha256_keybytes(void)
-{
-    return crypto_auth_hmacsha256_KEYBYTES;
-}
-
-size_t
-crypto_auth_hmacsha256_statebytes(void)
-{
-    return sizeof(crypto_auth_hmacsha256_state);
-}
-
-void
-crypto_auth_hmacsha256_keygen(unsigned char k[crypto_auth_hmacsha256_KEYBYTES])
-{
-    randombytes_buf(k, crypto_auth_hmacsha256_KEYBYTES);
-}
-
-int
-crypto_auth_hmacsha256_init(crypto_auth_hmacsha256_state *state,
-                            const unsigned char *key, size_t keylen)
-{
-    unsigned char pad[64];
-    unsigned char khash[32];
-    size_t        i;
-
-    if (keylen > 64) {
-        crypto_hash_sha256_init(&state->ictx);
-        crypto_hash_sha256_update(&state->ictx, key, keylen);
-        crypto_hash_sha256_final(&state->ictx, khash);
-        key    = khash;
-        keylen = 32;
-    }
-    crypto_hash_sha256_init(&state->ictx);
-    memset(pad, 0x36, 64);
-    for (i = 0; i < keylen; i++) {
-        pad[i] ^= key[i];
-    }
-    crypto_hash_sha256_update(&state->ictx, pad, 64);
-
-    crypto_hash_sha256_init(&state->octx);
-    memset(pad, 0x5c, 64);
-    for (i = 0; i < keylen; i++) {
-        pad[i] ^= key[i];
-    }
-    crypto_hash_sha256_update(&state->octx, pad, 64);
-
-    sodium_memzero((void *) pad, sizeof pad);
-    sodium_memzero((void *) khash, sizeof khash);
-
-    return 0;
-}
-
-int
-crypto_auth_hmacsha256_update(crypto_auth_hmacsha256_state *state,
-                              const unsigned char *in, unsigned long long inlen)
-{
-    crypto_hash_sha256_update(&state->ictx, in, inlen);
-
-    return 0;
-}
-
-int
-crypto_auth_hmacsha256_final(crypto_auth_hmacsha256_state *state,
-                             unsigned char                *out)
-{
-    unsigned char ihash[32];
-
-    crypto_hash_sha256_final(&state->ictx, ihash);
-    crypto_hash_sha256_update(&state->octx, ihash, 32);
-    crypto_hash_sha256_final(&state->octx, out);
-
-    sodium_memzero((void *) ihash, sizeof ihash);
-
-    return 0;
-}
-
-int
-crypto_auth_hmacsha256(unsigned char *out, const unsigned char *in,
-                       unsigned long long inlen, const unsigned char *k)
-{
-    crypto_auth_hmacsha256_state state;
-
-    crypto_auth_hmacsha256_init(&state, k, crypto_auth_hmacsha256_KEYBYTES);
-    crypto_auth_hmacsha256_update(&state, in, inlen);
-    crypto_auth_hmacsha256_final(&state, out);
-
-    return 0;
-}
-
-int
-crypto_auth_hmacsha256_verify(const unsigned char *h, const unsigned char *in,
-                              unsigned long long inlen, const unsigned char *k)
-{
-    unsigned char correct[32];
-
-    crypto_auth_hmacsha256(correct, in, inlen, k);
-
-    return crypto_verify_32(h, correct) | (-(h == correct)) |
-           sodium_memcmp(correct, h, 32);
-}
+

+#include <stddef.h>

+#include <stdint.h>

+#include <string.h>

+

+#include "crypto_auth_hmacsha256.h"

+#include "crypto_hash_sha256.h"

+#include "crypto_verify_32.h"

+#include "randombytes.h"

+#include "utils.h"

+

+size_t

+crypto_auth_hmacsha256_bytes(void)

+{

+    return crypto_auth_hmacsha256_BYTES;

+}

+

+size_t

+crypto_auth_hmacsha256_keybytes(void)

+{

+    return crypto_auth_hmacsha256_KEYBYTES;

+}

+

+size_t

+crypto_auth_hmacsha256_statebytes(void)

+{

+    return sizeof(crypto_auth_hmacsha256_state);

+}

+

+void

+crypto_auth_hmacsha256_keygen(unsigned char k[crypto_auth_hmacsha256_KEYBYTES])

+{

+    randombytes_buf(k, crypto_auth_hmacsha256_KEYBYTES);

+}

+

+int

+crypto_auth_hmacsha256_init(crypto_auth_hmacsha256_state *state,

+                            const unsigned char *key, size_t keylen)

+{

+    unsigned char pad[64];

+    unsigned char khash[32];

+    size_t        i;

+

+    if (keylen > 64) {

+        crypto_hash_sha256_init(&state->ictx);

+        crypto_hash_sha256_update(&state->ictx, key, keylen);

+        crypto_hash_sha256_final(&state->ictx, khash);

+        key    = khash;

+        keylen = 32;

+    }

+    crypto_hash_sha256_init(&state->ictx);

+    memset(pad, 0x36, 64);

+    for (i = 0; i < keylen; i++) {

+        pad[i] ^= key[i];

+    }

+    crypto_hash_sha256_update(&state->ictx, pad, 64);

+

+    crypto_hash_sha256_init(&state->octx);

+    memset(pad, 0x5c, 64);

+    for (i = 0; i < keylen; i++) {

+        pad[i] ^= key[i];

+    }

+    crypto_hash_sha256_update(&state->octx, pad, 64);

+

+    sodium_memzero((void *) pad, sizeof pad);

+    sodium_memzero((void *) khash, sizeof khash);

+

+    return 0;

+}

+

+int

+crypto_auth_hmacsha256_update(crypto_auth_hmacsha256_state *state,

+                              const unsigned char *in, unsigned long long inlen)

+{

+    crypto_hash_sha256_update(&state->ictx, in, inlen);

+

+    return 0;

+}

+

+int

+crypto_auth_hmacsha256_final(crypto_auth_hmacsha256_state *state,

+                             unsigned char                *out)

+{

+    unsigned char ihash[32];

+

+    crypto_hash_sha256_final(&state->ictx, ihash);

+    crypto_hash_sha256_update(&state->octx, ihash, 32);

+    crypto_hash_sha256_final(&state->octx, out);

+

+    sodium_memzero((void *) ihash, sizeof ihash);

+

+    return 0;

+}

+

+int

+crypto_auth_hmacsha256(unsigned char *out, const unsigned char *in,

+                       unsigned long long inlen, const unsigned char *k)

+{

+    crypto_auth_hmacsha256_state state;

+

+    crypto_auth_hmacsha256_init(&state, k, crypto_auth_hmacsha256_KEYBYTES);

+    crypto_auth_hmacsha256_update(&state, in, inlen);

+    crypto_auth_hmacsha256_final(&state, out);

+

+    return 0;

+}

+

+int

+crypto_auth_hmacsha256_verify(const unsigned char *h, const unsigned char *in,

+                              unsigned long long inlen, const unsigned char *k)

+{

+    unsigned char correct[32];

+

+    crypto_auth_hmacsha256(correct, in, inlen, k);

+

+    return crypto_verify_32(h, correct) | (-(h == correct)) |

+           sodium_memcmp(correct, h, 32);

+}

diff --git a/libs/libsodium/src/crypto_auth/hmacsha512/auth_hmacsha512.c b/libs/libsodium/src/crypto_auth/hmacsha512/auth_hmacsha512.c
index 018d7a4e87..abb9e79277 100644
--- a/libs/libsodium/src/crypto_auth/hmacsha512/auth_hmacsha512.c
+++ b/libs/libsodium/src/crypto_auth/hmacsha512/auth_hmacsha512.c
@@ -1,118 +1,118 @@
-
-#include <stddef.h>
-#include <stdint.h>
-#include <string.h>
-
-#include "crypto_auth_hmacsha512.h"
-#include "crypto_hash_sha512.h"
-#include "crypto_verify_64.h"
-#include "randombytes.h"
-#include "utils.h"
-
-size_t
-crypto_auth_hmacsha512_bytes(void)
-{
-    return crypto_auth_hmacsha512_BYTES;
-}
-
-size_t
-crypto_auth_hmacsha512_keybytes(void)
-{
-    return crypto_auth_hmacsha512_KEYBYTES;
-}
-
-size_t
-crypto_auth_hmacsha512_statebytes(void)
-{
-    return sizeof(crypto_auth_hmacsha512_state);
-}
-
-void
-crypto_auth_hmacsha512_keygen(unsigned char k[crypto_auth_hmacsha512_KEYBYTES])
-{
-    randombytes_buf(k, crypto_auth_hmacsha512_KEYBYTES);
-}
-
-int
-crypto_auth_hmacsha512_init(crypto_auth_hmacsha512_state *state,
-                            const unsigned char *key, size_t keylen)
-{
-    unsigned char pad[128];
-    unsigned char khash[64];
-    size_t        i;
-
-    if (keylen > 128) {
-        crypto_hash_sha512_init(&state->ictx);
-        crypto_hash_sha512_update(&state->ictx, key, keylen);
-        crypto_hash_sha512_final(&state->ictx, khash);
-        key    = khash;
-        keylen = 64;
-    }
-    crypto_hash_sha512_init(&state->ictx);
-    memset(pad, 0x36, 128);
-    for (i = 0; i < keylen; i++) {
-        pad[i] ^= key[i];
-    }
-    crypto_hash_sha512_update(&state->ictx, pad, 128);
-
-    crypto_hash_sha512_init(&state->octx);
-    memset(pad, 0x5c, 128);
-    for (i = 0; i < keylen; i++) {
-        pad[i] ^= key[i];
-    }
-    crypto_hash_sha512_update(&state->octx, pad, 128);
-
-    sodium_memzero((void *) pad, sizeof pad);
-    sodium_memzero((void *) khash, sizeof khash);
-
-    return 0;
-}
-
-int
-crypto_auth_hmacsha512_update(crypto_auth_hmacsha512_state *state,
-                              const unsigned char *in, unsigned long long inlen)
-{
-    crypto_hash_sha512_update(&state->ictx, in, inlen);
-
-    return 0;
-}
-
-int
-crypto_auth_hmacsha512_final(crypto_auth_hmacsha512_state *state,
-                             unsigned char                *out)
-{
-    unsigned char ihash[64];
-
-    crypto_hash_sha512_final(&state->ictx, ihash);
-    crypto_hash_sha512_update(&state->octx, ihash, 64);
-    crypto_hash_sha512_final(&state->octx, out);
-
-    sodium_memzero((void *) ihash, sizeof ihash);
-
-    return 0;
-}
-
-int
-crypto_auth_hmacsha512(unsigned char *out, const unsigned char *in,
-                       unsigned long long inlen, const unsigned char *k)
-{
-    crypto_auth_hmacsha512_state state;
-
-    crypto_auth_hmacsha512_init(&state, k, crypto_auth_hmacsha512_KEYBYTES);
-    crypto_auth_hmacsha512_update(&state, in, inlen);
-    crypto_auth_hmacsha512_final(&state, out);
-
-    return 0;
-}
-
-int
-crypto_auth_hmacsha512_verify(const unsigned char *h, const unsigned char *in,
-                              unsigned long long inlen, const unsigned char *k)
-{
-    unsigned char correct[64];
-
-    crypto_auth_hmacsha512(correct, in, inlen, k);
-
-    return crypto_verify_64(h, correct) | (-(h == correct)) |
-           sodium_memcmp(correct, h, 64);
-}
+

+#include <stddef.h>

+#include <stdint.h>

+#include <string.h>

+

+#include "crypto_auth_hmacsha512.h"

+#include "crypto_hash_sha512.h"

+#include "crypto_verify_64.h"

+#include "randombytes.h"

+#include "utils.h"

+

+size_t

+crypto_auth_hmacsha512_bytes(void)

+{

+    return crypto_auth_hmacsha512_BYTES;

+}

+

+size_t

+crypto_auth_hmacsha512_keybytes(void)

+{

+    return crypto_auth_hmacsha512_KEYBYTES;

+}

+

+size_t

+crypto_auth_hmacsha512_statebytes(void)

+{

+    return sizeof(crypto_auth_hmacsha512_state);

+}

+

+void

+crypto_auth_hmacsha512_keygen(unsigned char k[crypto_auth_hmacsha512_KEYBYTES])

+{

+    randombytes_buf(k, crypto_auth_hmacsha512_KEYBYTES);

+}

+

+int

+crypto_auth_hmacsha512_init(crypto_auth_hmacsha512_state *state,

+                            const unsigned char *key, size_t keylen)

+{

+    unsigned char pad[128];

+    unsigned char khash[64];

+    size_t        i;

+

+    if (keylen > 128) {

+        crypto_hash_sha512_init(&state->ictx);

+        crypto_hash_sha512_update(&state->ictx, key, keylen);

+        crypto_hash_sha512_final(&state->ictx, khash);

+        key    = khash;

+        keylen = 64;

+    }

+    crypto_hash_sha512_init(&state->ictx);

+    memset(pad, 0x36, 128);

+    for (i = 0; i < keylen; i++) {

+        pad[i] ^= key[i];

+    }

+    crypto_hash_sha512_update(&state->ictx, pad, 128);

+

+    crypto_hash_sha512_init(&state->octx);

+    memset(pad, 0x5c, 128);

+    for (i = 0; i < keylen; i++) {

+        pad[i] ^= key[i];

+    }

+    crypto_hash_sha512_update(&state->octx, pad, 128);

+

+    sodium_memzero((void *) pad, sizeof pad);

+    sodium_memzero((void *) khash, sizeof khash);

+

+    return 0;

+}

+

+int

+crypto_auth_hmacsha512_update(crypto_auth_hmacsha512_state *state,

+                              const unsigned char *in, unsigned long long inlen)

+{

+    crypto_hash_sha512_update(&state->ictx, in, inlen);

+

+    return 0;

+}

+

+int

+crypto_auth_hmacsha512_final(crypto_auth_hmacsha512_state *state,

+                             unsigned char                *out)

+{

+    unsigned char ihash[64];

+

+    crypto_hash_sha512_final(&state->ictx, ihash);

+    crypto_hash_sha512_update(&state->octx, ihash, 64);

+    crypto_hash_sha512_final(&state->octx, out);

+

+    sodium_memzero((void *) ihash, sizeof ihash);

+

+    return 0;

+}

+

+int

+crypto_auth_hmacsha512(unsigned char *out, const unsigned char *in,

+                       unsigned long long inlen, const unsigned char *k)

+{

+    crypto_auth_hmacsha512_state state;

+

+    crypto_auth_hmacsha512_init(&state, k, crypto_auth_hmacsha512_KEYBYTES);

+    crypto_auth_hmacsha512_update(&state, in, inlen);

+    crypto_auth_hmacsha512_final(&state, out);

+

+    return 0;

+}

+

+int

+crypto_auth_hmacsha512_verify(const unsigned char *h, const unsigned char *in,

+                              unsigned long long inlen, const unsigned char *k)

+{

+    unsigned char correct[64];

+

+    crypto_auth_hmacsha512(correct, in, inlen, k);

+

+    return crypto_verify_64(h, correct) | (-(h == correct)) |

+           sodium_memcmp(correct, h, 64);

+}

diff --git a/libs/libsodium/src/crypto_auth/hmacsha512256/auth_hmacsha512256.c b/libs/libsodium/src/crypto_auth/hmacsha512256/auth_hmacsha512256.c
index 432d6dbee5..63ed270268 100644
--- a/libs/libsodium/src/crypto_auth/hmacsha512256/auth_hmacsha512256.c
+++ b/libs/libsodium/src/crypto_auth/hmacsha512256/auth_hmacsha512256.c
@@ -1,93 +1,93 @@
-
-#include <stddef.h>
-#include <stdint.h>
-#include <string.h>
-
-#include "crypto_auth_hmacsha512.h"
-#include "crypto_auth_hmacsha512256.h"
-#include "crypto_hash_sha512.h"
-#include "crypto_verify_32.h"
-#include "randombytes.h"
-#include "utils.h"
-
-size_t
-crypto_auth_hmacsha512256_bytes(void)
-{
-    return crypto_auth_hmacsha512256_BYTES;
-}
-
-size_t
-crypto_auth_hmacsha512256_keybytes(void)
-{
-    return crypto_auth_hmacsha512256_KEYBYTES;
-}
-
-size_t
-crypto_auth_hmacsha512256_statebytes(void)
-{
-    return sizeof(crypto_auth_hmacsha512256_state);
-}
-
-void
-crypto_auth_hmacsha512256_keygen(
-    unsigned char k[crypto_auth_hmacsha512256_KEYBYTES])
-{
-    randombytes_buf(k, crypto_auth_hmacsha512256_KEYBYTES);
-}
-
-int
-crypto_auth_hmacsha512256_init(crypto_auth_hmacsha512256_state *state,
-                               const unsigned char *key, size_t keylen)
-{
-    return crypto_auth_hmacsha512_init((crypto_auth_hmacsha512_state *) state,
-                                       key, keylen);
-}
-
-int
-crypto_auth_hmacsha512256_update(crypto_auth_hmacsha512256_state *state,
-                                 const unsigned char             *in,
-                                 unsigned long long               inlen)
-{
-    return crypto_auth_hmacsha512_update((crypto_auth_hmacsha512_state *) state,
-                                         in, inlen);
-}
-
-int
-crypto_auth_hmacsha512256_final(crypto_auth_hmacsha512256_state *state,
-                                unsigned char                   *out)
-{
-    unsigned char out0[64];
-
-    crypto_auth_hmacsha512_final((crypto_auth_hmacsha512_state *) state, out0);
-    memcpy(out, out0, 32);
-
-    return 0;
-}
-
-int
-crypto_auth_hmacsha512256(unsigned char *out, const unsigned char *in,
-                          unsigned long long inlen, const unsigned char *k)
-{
-    crypto_auth_hmacsha512256_state state;
-
-    crypto_auth_hmacsha512256_init(&state, k,
-                                   crypto_auth_hmacsha512256_KEYBYTES);
-    crypto_auth_hmacsha512256_update(&state, in, inlen);
-    crypto_auth_hmacsha512256_final(&state, out);
-
-    return 0;
-}
-
-int
-crypto_auth_hmacsha512256_verify(const unsigned char *h,
-                                 const unsigned char *in,
-                                 unsigned long long   inlen,
-                                 const unsigned char *k)
-{
-    unsigned char correct[32];
-
-    crypto_auth_hmacsha512256(correct, in, inlen, k);
-
-    return crypto_verify_32(h, correct) | (-(h == correct)) |
-           sodium_memcmp(correct, h, 32);
-}
+

+#include <stddef.h>

+#include <stdint.h>

+#include <string.h>

+

+#include "crypto_auth_hmacsha512.h"

+#include "crypto_auth_hmacsha512256.h"

+#include "crypto_hash_sha512.h"

+#include "crypto_verify_32.h"

+#include "randombytes.h"

+#include "utils.h"

+

+size_t

+crypto_auth_hmacsha512256_bytes(void)

+{

+    return crypto_auth_hmacsha512256_BYTES;

+}

+

+size_t

+crypto_auth_hmacsha512256_keybytes(void)

+{

+    return crypto_auth_hmacsha512256_KEYBYTES;

+}

+

+size_t

+crypto_auth_hmacsha512256_statebytes(void)

+{

+    return sizeof(crypto_auth_hmacsha512256_state);

+}

+

+void

+crypto_auth_hmacsha512256_keygen(

+    unsigned char k[crypto_auth_hmacsha512256_KEYBYTES])

+{

+    randombytes_buf(k, crypto_auth_hmacsha512256_KEYBYTES);

+}

+

+int

+crypto_auth_hmacsha512256_init(crypto_auth_hmacsha512256_state *state,

+                               const unsigned char *key, size_t keylen)

+{

+    return crypto_auth_hmacsha512_init((crypto_auth_hmacsha512_state *) state,

+                                       key, keylen);

+}

+

+int

+crypto_auth_hmacsha512256_update(crypto_auth_hmacsha512256_state *state,

+                                 const unsigned char             *in,

+                                 unsigned long long               inlen)

+{

+    return crypto_auth_hmacsha512_update((crypto_auth_hmacsha512_state *) state,

+                                         in, inlen);

+}

+

+int

+crypto_auth_hmacsha512256_final(crypto_auth_hmacsha512256_state *state,

+                                unsigned char                   *out)

+{

+    unsigned char out0[64];

+

+    crypto_auth_hmacsha512_final((crypto_auth_hmacsha512_state *) state, out0);

+    memcpy(out, out0, 32);

+

+    return 0;

+}

+

+int

+crypto_auth_hmacsha512256(unsigned char *out, const unsigned char *in,

+                          unsigned long long inlen, const unsigned char *k)

+{

+    crypto_auth_hmacsha512256_state state;

+

+    crypto_auth_hmacsha512256_init(&state, k,

+                                   crypto_auth_hmacsha512256_KEYBYTES);

+    crypto_auth_hmacsha512256_update(&state, in, inlen);

+    crypto_auth_hmacsha512256_final(&state, out);

+

+    return 0;

+}

+

+int

+crypto_auth_hmacsha512256_verify(const unsigned char *h,

+                                 const unsigned char *in,

+                                 unsigned long long   inlen,

+                                 const unsigned char *k)

+{

+    unsigned char correct[32];

+

+    crypto_auth_hmacsha512256(correct, in, inlen, k);

+

+    return crypto_verify_32(h, correct) | (-(h == correct)) |

+           sodium_memcmp(correct, h, 32);

+}