rbnacl-libsodium 1.0.11 → 1.0.13

data/vendor/libsodium/src/libsodium/crypto_auth/hmacsha512/{cp/hmac_hmacsha512.c → auth_hmacsha512.c}

@@ -1,44 +1,41 @@
 
-/*-
- * Copyright 2005,2007,2009 Colin Percival
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- */
+#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"
 
-#include <sys/types.h>
+size_t
+crypto_auth_hmacsha512_bytes(void)
+{
+    return crypto_auth_hmacsha512_BYTES;
+}
 
-#include <stdint.h>
-#include <string.h>
+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)
+                            const unsigned char *key, size_t keylen)
 {
     unsigned char pad[128];
     unsigned char khash[64];
@@ -48,7 +45,7 @@ crypto_auth_hmacsha512_init(crypto_auth_hmacsha512_state *state,
         crypto_hash_sha512_init(&state->ictx);
         crypto_hash_sha512_update(&state->ictx, key, keylen);
         crypto_hash_sha512_final(&state->ictx, khash);
-        key = khash;
+        key    = khash;
         keylen = 64;
     }
     crypto_hash_sha512_init(&state->ictx);
@@ -73,8 +70,7 @@ crypto_auth_hmacsha512_init(crypto_auth_hmacsha512_state *state,
 
 int
 crypto_auth_hmacsha512_update(crypto_auth_hmacsha512_state *state,
-                              const unsigned char *in,
-                              unsigned long long inlen)
+                              const unsigned char *in, unsigned long long inlen)
 {
     crypto_hash_sha512_update(&state->ictx, in, inlen);
 
@@ -83,7 +79,7 @@ crypto_auth_hmacsha512_update(crypto_auth_hmacsha512_state *state,
 
 int
 crypto_auth_hmacsha512_final(crypto_auth_hmacsha512_state *state,
-                             unsigned char *out)
+                             unsigned char                *out)
 {
     unsigned char ihash[64];
 
@@ -108,3 +104,15 @@ crypto_auth_hmacsha512(unsigned char *out, const unsigned char *in,
 
     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);
+}

data/vendor/libsodium/src/libsodium/crypto_auth/hmacsha512256/{cp/hmac_hmacsha512256.c → auth_hmacsha512256.c}

@@ -1,18 +1,43 @@
 
-#include "crypto_auth_hmacsha512256.h"
+#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"
 
-#include <sys/types.h>
+size_t
+crypto_auth_hmacsha512256_bytes(void)
+{
+    return crypto_auth_hmacsha512256_BYTES;
+}
 
-#include <stdint.h>
-#include <string.h>
+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)
+                               const unsigned char *key, size_t keylen)
 {
     return crypto_auth_hmacsha512_init((crypto_auth_hmacsha512_state *) state,
                                        key, keylen);
@@ -20,8 +45,8 @@ crypto_auth_hmacsha512256_init(crypto_auth_hmacsha512256_state *state,
 
 int
 crypto_auth_hmacsha512256_update(crypto_auth_hmacsha512256_state *state,
-                                 const unsigned char *in,
-                                 unsigned long long inlen)
+                                 const unsigned char             *in,
+                                 unsigned long long               inlen)
 {
     return crypto_auth_hmacsha512_update((crypto_auth_hmacsha512_state *) state,
                                          in, inlen);
@@ -29,7 +54,7 @@ crypto_auth_hmacsha512256_update(crypto_auth_hmacsha512256_state *state,
 
 int
 crypto_auth_hmacsha512256_final(crypto_auth_hmacsha512256_state *state,
-                                unsigned char *out)
+                                unsigned char                   *out)
 {
     unsigned char out0[64];
 
@@ -52,3 +77,17 @@ crypto_auth_hmacsha512256(unsigned char *out, const unsigned char *in,
 
     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);
+}

data/vendor/libsodium/src/libsodium/crypto_box/crypto_box_easy.c

@@ -5,6 +5,7 @@
 
 #include "crypto_box.h"
 #include "crypto_secretbox.h"
+#include "private/common.h"
 #include "utils.h"
 
 int
@@ -24,8 +25,7 @@ crypto_box_detached(unsigned char *c, unsigned char *mac,
     unsigned char k[crypto_box_BEFORENMBYTES];
     int           ret;
 
-    (void) sizeof(int[crypto_box_BEFORENMBYTES >=
-                      crypto_secretbox_KEYBYTES ? 1 : -1]);
+    COMPILER_ASSERT(crypto_box_BEFORENMBYTES >= crypto_secretbox_KEYBYTES);
     if (crypto_box_beforenm(k, pk, sk) != 0) {
         return -1;
     }
@@ -62,7 +62,8 @@ crypto_box_easy(unsigned char *c, const unsigned char *m,
 int
 crypto_box_open_detached_afternm(unsigned char *m, const unsigned char *c,
                                  const unsigned char *mac,
-                                 unsigned long long clen, const unsigned char *n,
+                                 unsigned long long clen,
+                                 const unsigned char *n,
                                  const unsigned char *k)
 {
     return crypto_secretbox_open_detached(m, c, mac, clen, n, k);

data/vendor/libsodium/src/libsodium/crypto_box/crypto_box_seal.c

@@ -3,6 +3,7 @@
 
 #include "crypto_box.h"
 #include "crypto_generichash.h"
+#include "private/common.h"
 #include "utils.h"
 
 static int
@@ -54,7 +55,7 @@ crypto_box_seal_open(unsigned char *m, const unsigned char *c,
     }
     _crypto_box_seal_nonce(nonce, c, pk);
 
-    (void) sizeof(int[crypto_box_PUBLICKEYBYTES < crypto_box_SEALBYTES ? 1 : -1]);
+    COMPILER_ASSERT(crypto_box_PUBLICKEYBYTES < crypto_box_SEALBYTES);
     return crypto_box_open_easy(m, c + crypto_box_PUBLICKEYBYTES,
                                 clen - crypto_box_PUBLICKEYBYTES,
                                 nonce, c, sk);

data/vendor/libsodium/src/libsodium/crypto_box/curve25519xchacha20poly1305/box_curve25519xchacha20poly1305.c

@@ -0,0 +1,197 @@
+
+#include <limits.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "crypto_box_curve25519xchacha20poly1305.h"
+#include "crypto_core_hchacha20.h"
+#include "crypto_hash_sha512.h"
+#include "crypto_scalarmult_curve25519.h"
+#include "crypto_secretbox_xchacha20poly1305.h"
+#include "private/common.h"
+#include "randombytes.h"
+#include "utils.h"
+
+int
+crypto_box_curve25519xchacha20poly1305_seed_keypair(unsigned char *pk,
+                                                    unsigned char *sk,
+                                                    const unsigned char *seed)
+{
+    unsigned char hash[64];
+
+    crypto_hash_sha512(hash, seed, 32);
+    memcpy(sk, hash, 32);
+    sodium_memzero(hash, sizeof hash);
+
+    return crypto_scalarmult_curve25519_base(pk, sk);
+}
+
+int
+crypto_box_curve25519xchacha20poly1305_keypair(unsigned char *pk,
+                                               unsigned char *sk)
+{
+    randombytes_buf(sk, 32);
+
+    return crypto_scalarmult_curve25519_base(pk, sk);
+}
+
+int
+crypto_box_curve25519xchacha20poly1305_beforenm(unsigned char *k,
+                                                const unsigned char *pk,
+                                                const unsigned char *sk)
+{
+    static const unsigned char zero[16] = { 0 };
+    unsigned char s[32];
+
+    if (crypto_scalarmult_curve25519(s, sk, pk) != 0) {
+        return -1;
+    }
+    return crypto_core_hchacha20(k, zero, s, NULL);
+}
+
+int
+crypto_box_curve25519xchacha20poly1305_detached_afternm(
+    unsigned char *c, unsigned char *mac, const unsigned char *m,
+    unsigned long long mlen, const unsigned char *n, const unsigned char *k)
+{
+    return crypto_secretbox_xchacha20poly1305_detached(c, mac, m, mlen, n, k);
+}
+
+int
+crypto_box_curve25519xchacha20poly1305_detached(
+    unsigned char *c, unsigned char *mac, const unsigned char *m,
+    unsigned long long mlen, const unsigned char *n, const unsigned char *pk,
+    const unsigned char *sk)
+{
+    unsigned char k[crypto_box_curve25519xchacha20poly1305_BEFORENMBYTES];
+    int           ret;
+
+    COMPILER_ASSERT(crypto_box_curve25519xchacha20poly1305_BEFORENMBYTES >=
+                    crypto_secretbox_xchacha20poly1305_KEYBYTES);
+    if (crypto_box_curve25519xchacha20poly1305_beforenm(k, pk, sk) != 0) {
+        return -1;
+    }
+    ret = crypto_box_curve25519xchacha20poly1305_detached_afternm(c, mac, m,
+                                                                  mlen, n, k);
+    sodium_memzero(k, sizeof k);
+
+    return ret;
+}
+
+int
+crypto_box_curve25519xchacha20poly1305_easy_afternm(unsigned char *c,
+                                                    const unsigned char *m,
+                                                    unsigned long long mlen,
+                                                    const unsigned char *n,
+                                                    const unsigned char *k)
+{
+    if (mlen > SIZE_MAX - crypto_box_curve25519xchacha20poly1305_MACBYTES) {
+        return -1;
+    }
+    return crypto_box_curve25519xchacha20poly1305_detached_afternm(
+        c + crypto_box_curve25519xchacha20poly1305_MACBYTES, c, m, mlen, n, k);
+}
+
+int
+crypto_box_curve25519xchacha20poly1305_easy(
+    unsigned char *c, const unsigned char *m, unsigned long long mlen,
+    const unsigned char *n, const unsigned char *pk, const unsigned char *sk)
+{
+    if (mlen > SIZE_MAX - crypto_box_curve25519xchacha20poly1305_MACBYTES) {
+        return -1;
+    }
+    return crypto_box_curve25519xchacha20poly1305_detached(
+        c + crypto_box_curve25519xchacha20poly1305_MACBYTES, c, m, mlen, n, pk,
+        sk);
+}
+
+int
+crypto_box_curve25519xchacha20poly1305_open_detached_afternm(
+    unsigned char *m, const unsigned char *c, const unsigned char *mac,
+    unsigned long long clen, const unsigned char *n, const unsigned char *k)
+{
+    return crypto_secretbox_xchacha20poly1305_open_detached(m, c, mac, clen, n,
+                                                            k);
+}
+
+int
+crypto_box_curve25519xchacha20poly1305_open_detached(
+    unsigned char *m, const unsigned char *c, const unsigned char *mac,
+    unsigned long long clen, const unsigned char *n, const unsigned char *pk,
+    const unsigned char *sk)
+{
+    unsigned char k[crypto_box_curve25519xchacha20poly1305_BEFORENMBYTES];
+    int           ret;
+
+    if (crypto_box_curve25519xchacha20poly1305_beforenm(k, pk, sk) != 0) {
+        return -1;
+    }
+    ret = crypto_box_curve25519xchacha20poly1305_open_detached_afternm(
+        m, c, mac, clen, n, k);
+    sodium_memzero(k, sizeof k);
+
+    return ret;
+}
+
+int
+crypto_box_curve25519xchacha20poly1305_open_easy_afternm(
+    unsigned char *m, const unsigned char *c, unsigned long long clen,
+    const unsigned char *n, const unsigned char *k)
+{
+    if (clen < crypto_box_curve25519xchacha20poly1305_MACBYTES) {
+        return -1;
+    }
+    return crypto_box_curve25519xchacha20poly1305_open_detached_afternm(
+        m, c + crypto_box_curve25519xchacha20poly1305_MACBYTES, c,
+        clen - crypto_box_curve25519xchacha20poly1305_MACBYTES, n, k);
+}
+
+int
+crypto_box_curve25519xchacha20poly1305_open_easy(
+    unsigned char *m, const unsigned char *c, unsigned long long clen,
+    const unsigned char *n, const unsigned char *pk, const unsigned char *sk)
+{
+    if (clen < crypto_box_curve25519xchacha20poly1305_MACBYTES) {
+        return -1;
+    }
+    return crypto_box_curve25519xchacha20poly1305_open_detached(
+        m, c + crypto_box_curve25519xchacha20poly1305_MACBYTES, c,
+        clen - crypto_box_curve25519xchacha20poly1305_MACBYTES, n, pk, sk);
+}
+
+size_t
+crypto_box_curve25519xchacha20poly1305_seedbytes(void)
+{
+    return crypto_box_curve25519xchacha20poly1305_SEEDBYTES;
+}
+
+size_t
+crypto_box_curve25519xchacha20poly1305_publickeybytes(void)
+{
+    return crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES;
+}
+
+size_t
+crypto_box_curve25519xchacha20poly1305_secretkeybytes(void)
+{
+    return crypto_box_curve25519xchacha20poly1305_SECRETKEYBYTES;
+}
+
+size_t
+crypto_box_curve25519xchacha20poly1305_beforenmbytes(void)
+{
+    return crypto_box_curve25519xchacha20poly1305_BEFORENMBYTES;
+}
+
+size_t
+crypto_box_curve25519xchacha20poly1305_noncebytes(void)
+{
+    return crypto_box_curve25519xchacha20poly1305_NONCEBYTES;
+}
+
+size_t
+crypto_box_curve25519xchacha20poly1305_macbytes(void)
+{
+    return crypto_box_curve25519xchacha20poly1305_MACBYTES;
+}

data/vendor/libsodium/src/libsodium/crypto_box/curve25519xchacha20poly1305/box_seal_curve25519xchacha20poly1305.c

@@ -0,0 +1,79 @@
+
+#include <string.h>
+
+#include "crypto_box_curve25519xchacha20poly1305.h"
+#include "crypto_generichash.h"
+#include "private/common.h"
+#include "utils.h"
+
+static int
+_crypto_box_curve25519xchacha20poly1305_seal_nonce(unsigned char *nonce,
+                                                   const unsigned char *pk1,
+                                                   const unsigned char *pk2)
+{
+    crypto_generichash_state st;
+
+    crypto_generichash_init(&st, NULL, 0U,
+                            crypto_box_curve25519xchacha20poly1305_NONCEBYTES);
+    crypto_generichash_update(&st, pk1,
+                              crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES);
+    crypto_generichash_update(&st, pk2,
+                              crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES);
+    crypto_generichash_final(&st, nonce,
+                             crypto_box_curve25519xchacha20poly1305_NONCEBYTES);
+
+    return 0;
+}
+
+int
+crypto_box_curve25519xchacha20poly1305_seal(unsigned char *c, const unsigned char *m,
+                                            unsigned long long mlen,
+                                            const unsigned char *pk)
+{
+    unsigned char nonce[crypto_box_curve25519xchacha20poly1305_NONCEBYTES];
+    unsigned char epk[crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES];
+    unsigned char esk[crypto_box_curve25519xchacha20poly1305_SECRETKEYBYTES];
+    int           ret;
+
+    if (crypto_box_curve25519xchacha20poly1305_keypair(epk, esk) != 0) {
+        return -1; /* LCOV_EXCL_LINE */
+    }
+    memcpy(c, epk, crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES);
+    _crypto_box_curve25519xchacha20poly1305_seal_nonce(nonce, epk, pk);
+    ret = crypto_box_curve25519xchacha20poly1305_easy(
+         c + crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES, m, mlen,
+         nonce, pk, esk);
+    sodium_memzero(esk, sizeof esk);
+    sodium_memzero(epk, sizeof epk);
+    sodium_memzero(nonce, sizeof nonce);
+
+    return ret;
+}
+
+int
+crypto_box_curve25519xchacha20poly1305_seal_open(unsigned char *m, const unsigned char *c,
+                                                 unsigned long long clen,
+                                                 const unsigned char *pk,
+                                                 const unsigned char *sk)
+{
+    unsigned char nonce[crypto_box_curve25519xchacha20poly1305_NONCEBYTES];
+
+    if (clen < crypto_box_curve25519xchacha20poly1305_SEALBYTES) {
+        return -1;
+    }
+    _crypto_box_curve25519xchacha20poly1305_seal_nonce(nonce, c, pk);
+
+    COMPILER_ASSERT(crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES <
+                    crypto_box_curve25519xchacha20poly1305_SEALBYTES);
+
+    return crypto_box_curve25519xchacha20poly1305_open_easy(
+         m, c + crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES,
+         clen - crypto_box_curve25519xchacha20poly1305_PUBLICKEYBYTES,
+         nonce, c, sk);
+}
+
+size_t
+crypto_box_curve25519xchacha20poly1305_sealbytes(void)
+{
+    return crypto_box_curve25519xchacha20poly1305_SEALBYTES;
+}