rbnacl-libsodium 0.7.0 → 1.0.0

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

@@ -2,6 +2,7 @@
 #include "crypto_onetimeauth_poly1305.h"
 #include "donna/poly1305_donna.h"
 
+/* LCOV_EXCL_START */
 static const crypto_onetimeauth_poly1305_implementation *implementation =
     &crypto_onetimeauth_poly1305_donna_implementation;
 
@@ -18,6 +19,7 @@ crypto_onetimeauth_poly1305_implementation_name(void)
 {
     return implementation->implementation_name();
 }
+/* LCOV_EXCL_STOP */
 
 int
 crypto_onetimeauth_poly1305(unsigned char *out, const unsigned char *in,

data/vendor/libsodium/src/libsodium/crypto_pwhash/scryptsalsa208sha256/crypto_scrypt-common.c

@@ -36,7 +36,7 @@ encode64_uint32(uint8_t * dst, size_t dstlen, uint32_t src, uint32_t srcbits)
 
     for (bit = 0; bit < srcbits; bit += 6) {
         if (dstlen < 1) {
-            return NULL;
+            return NULL; /* LCOV_EXCL_LINE */
         }
         *dst++ = itoa64[src & 0x3f];
         dstlen--;
@@ -60,7 +60,7 @@ encode64(uint8_t * dst, size_t dstlen, const uint8_t * src, size_t srclen)
         } while (bits < 24 && i < srclen);
         dnext = encode64_uint32(dst, dstlen, value, bits);
         if (!dnext) {
-            return NULL;
+            return NULL; /* LCOV_EXCL_LINE */
         }
         dstlen -= dnext - dst;
         dst = dnext;
@@ -171,8 +171,8 @@ escrypt_r(escrypt_local_t * local, const uint8_t * passwd, size_t passwdlen,
 
     dst = encode64(dst, buflen - (dst - buf), hash, sizeof(hash));
     sodium_memzero(hash, sizeof hash);
-    if (!dst || dst >= buf + buflen) { /* Can't happen */
-        return NULL;
+    if (!dst || dst >= buf + buflen) {
+        return NULL; /* Can't happen LCOV_EXCL_LINE */
     }
     *dst = 0; /* NUL termination */
 
@@ -192,7 +192,7 @@ escrypt_gensalt_r(uint32_t N_log2, uint32_t r, uint32_t p,
 
     need = prefixlen + saltlen + 1;
     if (need > buflen || need < saltlen || saltlen < srclen) {
-        return NULL;
+        return NULL; /* LCOV_EXCL_LINE */
     }
     if (N_log2 > 63 || ((uint64_t)r * (uint64_t)p >= (1U << 30))) {
         return NULL;
@@ -205,16 +205,16 @@ escrypt_gensalt_r(uint32_t N_log2, uint32_t r, uint32_t p,
     *dst++ = itoa64[N_log2];
 
     dst = encode64_uint32(dst, buflen - (dst - buf), r, 30);
-    if (!dst) { /* Can't happen */
-        return NULL;
+    if (!dst) {
+        return NULL; /* Can't happen LCOV_EXCL_LINE */
     }
     dst = encode64_uint32(dst, buflen - (dst - buf), p, 30);
-    if (!dst) { /* Can't happen */
-        return NULL;
+    if (!dst) {
+        return NULL; /* Can't happen LCOV_EXCL_LINE */
     }
     dst = encode64(dst, buflen - (dst - buf), src, srclen);
-    if (!dst || dst >= buf + buflen) { /* Can't happen */
-        return NULL;
+    if (!dst || dst >= buf + buflen) {
+        return NULL; /* Can't happen LCOV_EXCL_LINE */
     }
     *dst = 0; /* NUL termination */
 
@@ -232,7 +232,7 @@ crypto_pwhash_scryptsalsa208sha256_ll(const uint8_t * passwd, size_t passwdlen,
     int             retval;
 
     if (escrypt_init_local(&local)) {
-        return -1;
+        return -1; /* LCOV_EXCL_LINE */
     }
 #if defined(HAVE_EMMINTRIN_H) || defined(_MSC_VER)
     escrypt_kdf =
@@ -244,7 +244,7 @@ crypto_pwhash_scryptsalsa208sha256_ll(const uint8_t * passwd, size_t passwdlen,
                          passwd, passwdlen, salt, saltlen,
                          N, r, p, buf, buflen);
     if (escrypt_free_local(&local)) {
-        return -1;
+        return -1; /* LCOV_EXCL_LINE */
     }
     return retval;
 }

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

@@ -44,41 +44,42 @@ 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)
 {
-        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;
+    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;
 
     crypto_auth_hmacsha256_init(&PShctx, passwd, passwdlen);
     crypto_auth_hmacsha256_update(&PShctx, salt, saltlen);
 
-        for (i = 0; i * 32 < dkLen; i++) {
-                be32enc(ivec, (uint32_t)(i + 1));
-                memcpy(&hctx, &PShctx, sizeof(crypto_auth_hmacsha256_state));
-                crypto_auth_hmacsha256_update(&hctx, ivec, 4);
-                crypto_auth_hmacsha256_final(&hctx, U);
+    for (i = 0; i * 32 < dkLen; i++) {
+        be32enc(ivec, (uint32_t)(i + 1));
+        memcpy(&hctx, &PShctx, sizeof(crypto_auth_hmacsha256_state));
+        crypto_auth_hmacsha256_update(&hctx, ivec, 4);
+        crypto_auth_hmacsha256_final(&hctx, U);
 
-                memcpy(T, U, 32);
+        memcpy(T, U, 32);
+        /* LCOV_EXCL_START */
+        for (j = 2; j <= c; j++) {
+            crypto_auth_hmacsha256_init(&hctx, passwd, passwdlen);
+            crypto_auth_hmacsha256_update(&hctx, U, 32);
+            crypto_auth_hmacsha256_final(&hctx, U);
 
-                for (j = 2; j <= c; j++) {
-                        crypto_auth_hmacsha256_init(&hctx, passwd, passwdlen);
-                        crypto_auth_hmacsha256_update(&hctx, U, 32);
-                        crypto_auth_hmacsha256_final(&hctx, U);
-
-                        for (k = 0; k < 32; k++) {
-                                T[k] ^= U[k];
+            for (k = 0; k < 32; k++) {
+                T[k] ^= U[k];
             }
-                }
-
-                clen = dkLen - i * 32;
-                if (clen > 32) {
-                        clen = 32;
         }
-                memcpy(&buf[i * 32], T, clen);
+        /* LCOV_EXCL_STOP */
+
+        clen = dkLen - i * 32;
+        if (clen > 32) {
+            clen = 32;
         }
+        memcpy(&buf[i * 32], T, clen);
+    }
     sodium_memzero((void *) &PShctx, sizeof PShctx);
 }

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

@@ -41,9 +41,11 @@ pickparams(unsigned long long opslimit, const size_t memlimit,
             }
         }
         maxrp = (opslimit / 4) / ((uint64_t) (1) << *N_log2);
+        /* LCOV_EXCL_START */
         if (maxrp > 0x3fffffff) {
             maxrp = 0x3fffffff;
         }
+        /* LCOV_EXCL_STOP */
         *p = (uint32_t) (maxrp) / *r;
     }
     return 0;
@@ -106,12 +108,12 @@ crypto_pwhash_scryptsalsa208sha256(unsigned char * const out,
 
     memset(out, 0, outlen);
     if (passwdlen > SIZE_MAX || outlen > SIZE_MAX) {
-        errno = EFBIG;
-        return -1;
+        errno = EFBIG; /* LCOV_EXCL_LINE */
+        return -1; /* LCOV_EXCL_LINE */
     }
     if (pickparams(opslimit, memlimit, &N_log2, &p, &r) != 0) {
-        errno = EINVAL;
-        return -1;
+        errno = EINVAL; /* LCOV_EXCL_LINE */
+        return -1; /* LCOV_EXCL_LINE */
     }
     return crypto_pwhash_scryptsalsa208sha256_ll((const uint8_t *) passwd,
                                                  (size_t) passwdlen,
@@ -137,28 +139,30 @@ crypto_pwhash_scryptsalsa208sha256_str(char out[crypto_pwhash_scryptsalsa208sha2
 
     memset(out, 0, crypto_pwhash_scryptsalsa208sha256_STRBYTES);
     if (passwdlen > SIZE_MAX) {
-        errno = EFBIG;
-        return -1;
+        errno = EFBIG; /* LCOV_EXCL_LINE */
+        return -1; /* LCOV_EXCL_LINE */
     }
     if (pickparams(opslimit, memlimit, &N_log2, &p, &r) != 0) {
-        errno = EINVAL;
-        return -1;
+        errno = EINVAL; /* 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) {
-        errno = EINVAL;
-        return -1;
+        errno = EINVAL; /* LCOV_EXCL_LINE */
+        return -1; /* LCOV_EXCL_LINE */
     }
     if (escrypt_init_local(&escrypt_local) != 0) {
-        return -1;
+        return -1; /* LCOV_EXCL_LINE */
     }
     if (escrypt_r(&escrypt_local, (const uint8_t *) passwd, (size_t) passwdlen,
                   (const uint8_t *) setting, (uint8_t *) out,
                   crypto_pwhash_scryptsalsa208sha256_STRBYTES) == NULL) {
+        /* LCOV_EXCL_START */
         escrypt_free_local(&escrypt_local);
         errno = EINVAL;
         return -1;
+        /* LCOV_EXCL_STOP */
     }
     escrypt_free_local(&escrypt_local);
 
@@ -187,7 +191,7 @@ crypto_pwhash_scryptsalsa208sha256_str_verify(const char str[crypto_pwhash_scryp
         return -1;
     }
     if (escrypt_init_local(&escrypt_local) != 0) {
-        return -1;
+        return -1; /* LCOV_EXCL_LINE */
     }
     if (escrypt_r(&escrypt_local, (const uint8_t *) passwd, (size_t) passwdlen,
                   (const uint8_t *) str, (uint8_t *) wanted,

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

@@ -43,7 +43,7 @@ alloc_region(escrypt_region_t * region, size_t size)
 	    MAP_ANON | MAP_PRIVATE,
 #endif
 	    -1, 0)) == MAP_FAILED)
-		base = NULL;
+		base = NULL; /* LCOV_EXCL_LINE */
 	aligned = base;
 #elif defined(HAVE_POSIX_MEMALIGN)
 	if ((errno = posix_memalign((void **) &base, 64, size)) != 0)
@@ -77,7 +77,7 @@ free_region(escrypt_region_t * region)
 	if (region->base) {
 #ifdef MAP_ANON
 		if (munmap(region->base, region->size))
-			return -1;
+			return -1; /* LCOV_EXCL_LINE */
 #else
 		free(region->base);
 #endif

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

@@ -365,9 +365,9 @@ escrypt_kdf_sse(escrypt_local_t * local,
 	}
 	if (local->size < need) {
 		if (free_region(local))
-			return -1;
+			return -1; /* LCOV_EXCL_LINE */
 		if (!alloc_region(local, need))
-			return -1;
+			return -1; /* LCOV_EXCL_LINE */
 	}
 	B = (uint8_t *)local->aligned;
 	V = (uint32_t *)((uint8_t *)B + B_size);

data/vendor/libsodium/src/libsodium/crypto_secretbox/crypto_secretbox_easy.c

@@ -27,9 +27,6 @@ crypto_secretbox_detached(unsigned char *c, unsigned char *mac,
     unsigned long long                i;
     unsigned long long                mlen0;
 
-    if (mlen > SIZE_MAX - crypto_secretbox_MACBYTES) {
-        return -1;
-    }
     crypto_core_hsalsa20(subkey, n, k, sigma);
 
     memset(block0, 0U, crypto_secretbox_ZEROBYTES);
@@ -68,6 +65,9 @@ crypto_secretbox_easy(unsigned char *c, const unsigned char *m,
                       unsigned long long mlen, const unsigned char *n,
                       const unsigned char *k)
 {
+    if (mlen > SIZE_MAX - crypto_secretbox_MACBYTES) {
+        return -1;
+    }
     return crypto_secretbox_detached(c + crypto_secretbox_MACBYTES,
                                      c, m, mlen, n, k);
 }

data/vendor/libsodium/src/libsodium/crypto_sign/ed25519/ref10/keypair.c

@@ -32,7 +32,7 @@ int crypto_sign_keypair(unsigned char *pk, unsigned char *sk)
     unsigned char seed[32];
     int           ret;
 
-    randombytes(seed, sizeof seed);
+    randombytes_buf(seed, sizeof seed);
     ret = crypto_sign_seed_keypair(pk, sk, seed);
     sodium_memzero(seed, sizeof seed);
 

data/vendor/libsodium/src/libsodium/crypto_sign/ed25519/ref10/sign.c

@@ -61,15 +61,19 @@ crypto_sign(unsigned char *sm, unsigned long long *smlen,
 {
     unsigned long long siglen;
 
-    if (crypto_sign_detached(sm, &siglen, m, mlen, sk) != 0 ||
-        siglen > crypto_sign_ed25519_BYTES) {
+    memmove(sm + crypto_sign_ed25519_BYTES, m, mlen);
+/* LCOV_EXCL_START */
+    if (crypto_sign_detached(sm, &siglen, sm + crypto_sign_ed25519_BYTES,
+                             mlen, sk) != 0 ||
+        siglen != crypto_sign_ed25519_BYTES) {
         if (smlen != NULL) {
             *smlen = 0;
         }
         memset(sm, 0, mlen + crypto_sign_ed25519_BYTES);
         return -1;
     }
-    memmove(sm + siglen, m, mlen);
+/* LCOV_EXCL_STOP */
+
     if (smlen != NULL) {
         *smlen = mlen + siglen;
     }

data/vendor/libsodium/src/libsodium/crypto_sign/edwards25519sha512batch/ref/sign_edwards25519sha512batch.c

@@ -13,7 +13,7 @@ int crypto_sign_keypair(
   sc25519 scsk;
   ge25519 gepk;
 
-  randombytes(sk, 32);
+  randombytes_buf(sk, 32);
   crypto_hash_sha512(sk, sk, 32);
   sk[0] &= 248;
   sk[31] &= 127;

data/vendor/libsodium/src/libsodium/crypto_stream/chacha20/ref/stream_chacha20_ref.c

@@ -101,7 +101,7 @@ chacha_encrypt_bytes(chacha_ctx *x, const u8 *m, u8 *c, unsigned long long bytes
     unsigned long long i;
 
     if (!bytes) {
-        return;
+        return; /* LCOV_EXCL_LINE */
     }
     j0 = x->input[0];
     j1 = x->input[1];
@@ -190,10 +190,11 @@ chacha_encrypt_bytes(chacha_ctx *x, const u8 *m, u8 *c, unsigned long long bytes
         x15 = XOR(x15, U8TO32_LITTLE(m + 60));
 
         j12 = PLUSONE(j12);
+        /* LCOV_EXCL_START */
         if (!j12) {
             j13 = PLUSONE(j13);
-            /* stopping at 2^70 bytes per nonce is user's responsibility */
         }
+        /* LCOV_EXCL_STOP */
 
         U32TO8_LITTLE(c + 0, x0);
         U32TO8_LITTLE(c + 4, x1);

data/vendor/libsodium/src/libsodium/include/sodium/randombytes.h

@@ -26,28 +26,30 @@ typedef struct randombytes_implementation {
 } randombytes_implementation;
 
 SODIUM_EXPORT
-int randombytes_set_implementation(randombytes_implementation *impl);
+void randombytes_buf(void * const buf, const size_t size);
 
 SODIUM_EXPORT
-void randombytes(unsigned char * const buf, const unsigned long long buf_len);
+uint32_t randombytes_random(void);
 
 SODIUM_EXPORT
-const char *randombytes_implementation_name(void);
+uint32_t randombytes_uniform(const uint32_t upper_bound);
 
 SODIUM_EXPORT
-uint32_t randombytes_random(void);
+void randombytes_stir(void);
 
 SODIUM_EXPORT
-void randombytes_stir(void);
+int randombytes_close(void);
 
 SODIUM_EXPORT
-uint32_t randombytes_uniform(const uint32_t upper_bound);
+int randombytes_set_implementation(randombytes_implementation *impl);
 
 SODIUM_EXPORT
-void randombytes_buf(void * const buf, const size_t size);
+const char *randombytes_implementation_name(void);
+
+/* -- Compatibility layer with NaCl -- */
 
 SODIUM_EXPORT
-int randombytes_close(void);
+void randombytes(unsigned char * const buf, const unsigned long long buf_len);
 
 #ifdef __cplusplus
 }

data/vendor/libsodium/src/libsodium/randombytes/salsa20/randombytes_salsa20_random.c

@@ -67,7 +67,10 @@ sodium_hrtime(void)
 #ifdef _WIN32
     struct _timeb tb;
 
-    _ftime_s(&tb);
+# pragma warning(push)
+# pragma warning(disable: 4996)
+    _ftime(&tb);
+# pragma warning(pop)
     tv.tv_sec = (long) tb.time;
     tv.tv_usec = ((int) tb.millitm) * 1000;
     ret = 0;
@@ -91,12 +94,12 @@ safe_read(const int fd, void * const buf_, size_t count)
     assert(count > (size_t) 0U);
     do {
         while ((readnb = read(fd, buf, count)) < (ssize_t) 0 &&
-               errno == EINTR);
+               errno == EINTR);  /* LCOV_EXCL_LINE */
         if (readnb < (ssize_t) 0) {
-            return readnb;
+            return readnb; /* LCOV_EXCL_LINE */
         }
         if (readnb == (ssize_t) 0) {
-            break;
+            break; /* LCOV_EXCL_LINE */
         }
         count -= (size_t) readnb;
         buf += readnb;
@@ -110,6 +113,7 @@ safe_read(const int fd, void * const buf_, size_t count)
 static int
 randombytes_salsa20_random_random_dev_open(void)
 {
+/* LCOV_EXCL_START */
     struct stat       st;
     static const char *devices[] = {
 # ifndef USE_BLOCKING_RANDOM
@@ -131,6 +135,7 @@ randombytes_salsa20_random_random_dev_open(void)
     } while (*device != NULL);
 
     return -1;
+/* LCOV_EXCL_STOP */
 }
 
 static void
@@ -143,7 +148,7 @@ randombytes_salsa20_random_init(void)
 
     if ((stream.random_data_source_fd =
          randombytes_salsa20_random_random_dev_open()) == -1) {
-        abort();
+        abort(); /* LCOV_EXCL_LINE */
     }
     errno = errno_save;
 }
@@ -181,11 +186,11 @@ randombytes_salsa20_random_stir(void)
 #ifndef _WIN32
     if (safe_read(stream.random_data_source_fd, m0,
                   sizeof m0) != (ssize_t) sizeof m0) {
-        abort();
+        abort(); /* LCOV_EXCL_LINE */
     }
 #else /* _WIN32 */
     if (! RtlGenRandom((PVOID) m0, (ULONG) sizeof m0)) {
-        abort();
+        abort(); /* LCOV_EXCL_LINE */
     }
 #endif
     COMPILER_ASSERT(sizeof stream.key == crypto_auth_hmacsha512256_BYTES);
@@ -319,7 +324,7 @@ randombytes_salsa20_random_uniform(const uint32_t upper_bound)
         if (r >= min) {
             break;
         }
-    }
+    } /* LCOV_EXCL_LINE */
     return r % upper_bound;
 }