rbnacl-libsodium 0.4.5 → 0.5.0

data/vendor/libsodium/src/libsodium/crypto_auth/hmacsha512/cp/verify_hmacsha512.c

@@ -0,0 +1,10 @@
+#include "api.h"
+#include "crypto_verify_64.h"
+
+int crypto_auth_verify(const unsigned char *h, const unsigned char *in,
+                       unsigned long long inlen, const unsigned char *k)
+{
+  unsigned char correct[64];
+  crypto_auth(correct,in,inlen,k);
+  return crypto_verify_64(h,correct);
+}

data/vendor/libsodium/src/libsodium/crypto_auth/hmacsha512256/auth_hmacsha512256_api.c

@@ -9,8 +9,3 @@ size_t
 crypto_auth_hmacsha512256_keybytes(void) {
     return crypto_auth_hmacsha512256_KEYBYTES;
 }
-
-const char *
-crypto_auth_hmacsha512256_primitive(void) {
-    return "hmacsha512256";
-}

data/vendor/libsodium/src/libsodium/crypto_auth/hmacsha512256/{ref → cp}/api.h

@@ -5,6 +5,5 @@
 #define crypto_auth_verify crypto_auth_hmacsha512256_verify
 #define crypto_auth_BYTES crypto_auth_hmacsha512256_BYTES
 #define crypto_auth_KEYBYTES crypto_auth_hmacsha512256_KEYBYTES
-#define crypto_auth_PRIMITIVE "hmacsha512256"
 #define crypto_auth_IMPLEMENTATION crypto_auth_hmacsha512256_IMPLEMENTATION
 #define crypto_auth_VERSION crypto_auth_hmacsha512256_VERSION

data/vendor/libsodium/src/libsodium/crypto_auth/hmacsha512256/cp/hmac_hmacsha512256.c

@@ -0,0 +1,54 @@
+
+#include "api.h"
+#include "crypto_auth_hmacsha512256.h"
+#include "crypto_auth_hmacsha512.h"
+#include "crypto_hash_sha512.h"
+#include "utils.h"
+
+#include <sys/types.h>
+
+#include <stdint.h>
+#include <string.h>
+
+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(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_KEYBYTES);
+    crypto_auth_hmacsha512256_update(&state, in, inlen);
+    crypto_auth_hmacsha512256_final(&state, out);
+
+    return 0;
+}

data/vendor/libsodium/src/libsodium/crypto_auth/hmacsha512256/{ref → cp}/verify_hmacsha512256.c

@@ -1,7 +1,8 @@
 #include "api.h"
 #include "crypto_verify_32.h"
 
-int crypto_auth_verify(const unsigned char *h,const unsigned char *in,unsigned long long inlen,const unsigned char *k)
+int crypto_auth_verify(const unsigned char *h, const unsigned char *in,
+                       unsigned long long inlen, const unsigned char *k)
 {
   unsigned char correct[32];
   crypto_auth(correct,in,inlen,k);

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

@@ -0,0 +1,94 @@
+
+#include <assert.h>
+#include <limits.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "crypto_box.h"
+#include "utils.h"
+
+int
+crypto_box_easy(unsigned char *c, const unsigned char *m,
+                unsigned long long mlen, const unsigned char *n,
+                const unsigned char *pk, const unsigned char *sk)
+{
+    unsigned char *c_boxed;
+    unsigned char *m_boxed;
+    size_t         c_boxed_len;
+    size_t         m_boxed_len;
+    int            rc;
+
+    if (mlen > SIZE_MAX - crypto_box_ZEROBYTES) {
+        return -1;
+    }
+    (void) sizeof(char[crypto_box_ZEROBYTES >=
+                       crypto_box_BOXZEROBYTES ? 1 : -1]);
+    m_boxed_len = (size_t) mlen + crypto_box_ZEROBYTES;
+    if ((m_boxed = (unsigned char *) malloc((size_t) m_boxed_len)) == NULL) {
+        return -1;
+    }
+    c_boxed_len = (size_t) mlen + crypto_box_ZEROBYTES;
+    if ((c_boxed = (unsigned char *) malloc(c_boxed_len)) == NULL) {
+        free(m_boxed);
+        return -1;
+    }
+    memset(m_boxed, 0, crypto_box_ZEROBYTES);
+    sodium_mlock(m_boxed, m_boxed_len);
+    memcpy(m_boxed + crypto_box_ZEROBYTES, m, mlen);
+    rc = crypto_box(c_boxed, m_boxed, m_boxed_len, n, pk, sk);
+    sodium_munlock(m_boxed, m_boxed_len);
+    free(m_boxed);
+    if (rc != 0) {
+        free(c_boxed);
+        return -1;
+    }
+    assert(m_boxed_len - crypto_box_BOXZEROBYTES ==
+           mlen + crypto_box_MACBYTES);
+    memcpy(c, c_boxed + crypto_box_BOXZEROBYTES, mlen + crypto_box_MACBYTES);
+    free(c_boxed);
+
+    return 0;
+}
+
+int
+crypto_box_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)
+{
+    unsigned char *c_boxed;
+    unsigned char *m_boxed;
+    size_t         c_boxed_len;
+    size_t         m_boxed_len;
+    int            rc;
+
+    if (clen < crypto_box_MACBYTES ||
+        clen > SIZE_MAX - crypto_box_BOXZEROBYTES) {
+        return -1;
+    }
+    c_boxed_len = clen + crypto_box_BOXZEROBYTES;
+    if ((c_boxed = (unsigned char *) malloc(c_boxed_len)) == NULL) {
+        return -1;
+    }
+    memset(c_boxed, 0, crypto_box_BOXZEROBYTES);
+    memcpy(c_boxed + crypto_box_BOXZEROBYTES, c, clen);
+    m_boxed_len = c_boxed_len + crypto_box_MACBYTES;
+    if ((m_boxed = (unsigned char *) malloc(m_boxed_len)) == NULL) {
+        free(c_boxed);
+        return -1;
+    }
+    sodium_mlock(m_boxed, m_boxed_len);
+    rc = crypto_box_open(m_boxed, c_boxed,
+                         (unsigned long long) c_boxed_len, n, pk, sk);
+    free(c_boxed);
+    if (rc != 0) {
+        sodium_munlock(m_boxed, m_boxed_len);
+        free(m_boxed);
+        return -1;
+    }
+    memcpy(m, m_boxed + crypto_box_ZEROBYTES, clen - crypto_box_MACBYTES);
+    sodium_munlock(m_boxed, m_boxed_len);
+    free(m_boxed);
+
+    return 0;
+}

data/vendor/libsodium/src/libsodium/crypto_box/curve25519xsalsa20poly1305/box_curve25519xsalsa20poly1305_api.c

@@ -34,8 +34,3 @@ size_t
 crypto_box_curve25519xsalsa20poly1305_macbytes(void) {
     return crypto_box_curve25519xsalsa20poly1305_MACBYTES;
 }
-
-const char *
-crypto_box_curve25519xsalsa20poly1305_primitive(void) {
-    return "curve25519xsalsa20poly1305";
-}

data/vendor/libsodium/src/libsodium/crypto_box/curve25519xsalsa20poly1305/ref/api.h

@@ -14,6 +14,5 @@
 #define crypto_box_ZEROBYTES crypto_box_curve25519xsalsa20poly1305_ZEROBYTES
 #define crypto_box_BOXZEROBYTES crypto_box_curve25519xsalsa20poly1305_BOXZEROBYTES
 #define crypto_box_MACBYTES (crypto_box_ZEROBYTES - crypto_box_BOXZEROBYTES)
-#define crypto_box_PRIMITIVE "curve25519xsalsa20poly1305"
 #define crypto_box_IMPLEMENTATION crypto_box_curve25519xsalsa20poly1305_IMPLEMENTATION
 #define crypto_box_VERSION crypto_box_curve25519xsalsa20poly1305_VERSION

data/vendor/libsodium/src/libsodium/crypto_core/hsalsa20/core_hsalsa20_api.c

@@ -19,8 +19,3 @@ size_t
 crypto_core_hsalsa20_constbytes(void) {
     return crypto_core_hsalsa20_CONSTBYTES;
 }
-
-const char *
-crypto_core_hsalsa20_primitive(void) {
-    return "hsalsa20";
-}

data/vendor/libsodium/src/libsodium/crypto_core/hsalsa20/ref2/api.h

@@ -6,6 +6,5 @@
 #define crypto_core_INPUTBYTES crypto_core_hsalsa20_INPUTBYTES
 #define crypto_core_KEYBYTES crypto_core_hsalsa20_KEYBYTES
 #define crypto_core_CONSTBYTES crypto_core_hsalsa20_CONSTBYTES
-#define crypto_core_PRIMITIVE "hsalsa20"
 #define crypto_core_IMPLEMENTATION crypto_core_hsalsa20_IMPLEMENTATION
 #define crypto_core_VERSION crypto_core_hsalsa20_VERSION

data/vendor/libsodium/src/libsodium/crypto_core/salsa20/core_salsa20_api.c

@@ -19,8 +19,3 @@ size_t
 crypto_core_salsa20_constbytes(void) {
     return crypto_core_salsa20_CONSTBYTES;
 }
-
-const char *
-crypto_core_salsa20_primitive(void) {
-    return "salsa20";
-}

data/vendor/libsodium/src/libsodium/crypto_core/salsa20/ref/api.h

@@ -6,6 +6,5 @@
 #define crypto_core_INPUTBYTES crypto_core_salsa20_INPUTBYTES
 #define crypto_core_KEYBYTES crypto_core_salsa20_KEYBYTES
 #define crypto_core_CONSTBYTES crypto_core_salsa20_CONSTBYTES
-#define crypto_core_PRIMITIVE "salsa20"
 #define crypto_core_IMPLEMENTATION crypto_core_salsa20_IMPLEMENTATION
 #define crypto_core_VERSION crypto_core_salsa20_VERSION

data/vendor/libsodium/src/libsodium/crypto_core/salsa2012/core_salsa2012_api.c

@@ -19,8 +19,3 @@ size_t
 crypto_core_salsa2012_constbytes(void) {
     return crypto_core_salsa2012_CONSTBYTES;
 }
-
-const char *
-crypto_core_salsa2012_primitive(void) {
-    return "salsa2012";
-}

data/vendor/libsodium/src/libsodium/crypto_core/salsa2012/ref/api.h

@@ -6,6 +6,5 @@
 #define crypto_core_INPUTBYTES crypto_core_salsa2012_INPUTBYTES
 #define crypto_core_KEYBYTES crypto_core_salsa2012_KEYBYTES
 #define crypto_core_CONSTBYTES crypto_core_salsa2012_CONSTBYTES
-#define crypto_core_PRIMITIVE "salsa2012"
 #define crypto_core_IMPLEMENTATION crypto_core_salsa2012_IMPLEMENTATION
 #define crypto_core_VERSION crypto_core_salsa2012_VERSION

data/vendor/libsodium/src/libsodium/crypto_core/salsa208/core_salsa208_api.c

@@ -19,8 +19,3 @@ size_t
 crypto_core_salsa208_constbytes(void) {
     return crypto_core_salsa208_CONSTBYTES;
 }
-
-const char *
-crypto_core_salsa208_primitive(void) {
-    return "salsa208";
-}

data/vendor/libsodium/src/libsodium/crypto_core/salsa208/ref/api.h

@@ -6,6 +6,5 @@
 #define crypto_core_INPUTBYTES crypto_core_salsa208_INPUTBYTES
 #define crypto_core_KEYBYTES crypto_core_salsa208_KEYBYTES
 #define crypto_core_CONSTBYTES crypto_core_salsa208_CONSTBYTES
-#define crypto_core_PRIMITIVE "salsa208"
 #define crypto_core_IMPLEMENTATION crypto_core_salsa208_IMPLEMENTATION
 #define crypto_core_VERSION crypto_core_salsa208_VERSION

data/vendor/libsodium/src/libsodium/crypto_generichash/blake2/generichash_blake2_api.c

@@ -10,6 +10,11 @@ crypto_generichash_blake2b_bytes_max(void) {
     return crypto_generichash_blake2b_BYTES_MAX;
 }
 
+size_t
+crypto_generichash_blake2b_bytes(void) {
+    return crypto_generichash_blake2b_BYTES;
+}
+
 size_t
 crypto_generichash_blake2b_keybytes_min(void) {
     return crypto_generichash_blake2b_KEYBYTES_MIN;
@@ -21,11 +26,16 @@ crypto_generichash_blake2b_keybytes_max(void) {
 }
 
 size_t
-crypto_generichash_blake2b_blockbytes(void) {
-    return crypto_generichash_blake2b_BLOCKBYTES;
+crypto_generichash_blake2b_keybytes(void) {
+    return crypto_generichash_blake2b_KEYBYTES;
 }
 
-const char *
-crypto_generichash_blake2b_blockbytes_primitive(void) {
-    return "blake2b";
+size_t
+crypto_generichash_blake2b_saltbytes(void) {
+    return crypto_generichash_blake2b_SALTBYTES;
+}
+
+size_t
+crypto_generichash_blake2b_personalbytes(void) {
+    return crypto_generichash_blake2b_PERSONALBYTES;
 }

data/vendor/libsodium/src/libsodium/crypto_generichash/blake2/ref/api.h

@@ -1,4 +1,2 @@
 
 #include "crypto_generichash_blake2b.h"
-
-#define crypto_generichash_blake2b crypto_generichash_blake2b_ref

data/vendor/libsodium/src/libsodium/crypto_generichash/blake2/ref/blake2.h

@@ -19,12 +19,15 @@
 
 #include "crypto_generichash_blake2b.h"
 
-#define blake2b_init_param crypto_generichash_blake2b__init_param
-#define blake2b_init       crypto_generichash_blake2b__init
-#define blake2b_init_key   crypto_generichash_blake2b__init_key
-#define blake2b_update     crypto_generichash_blake2b__update
-#define blake2b_final      crypto_generichash_blake2b__final
-#define blake2b            crypto_generichash_blake2b__blake2b
+#define blake2b_init_param             crypto_generichash_blake2b__init_param
+#define blake2b_init                   crypto_generichash_blake2b__init
+#define blake2b_init_salt_personal     crypto_generichash_blake2b__init_salt_personal
+#define blake2b_init_key               crypto_generichash_blake2b__init_key
+#define blake2b_init_key_salt_personal crypto_generichash_blake2b__init_key_salt_personal
+#define blake2b_update                 crypto_generichash_blake2b__update
+#define blake2b_final                  crypto_generichash_blake2b__final
+#define blake2b                        crypto_generichash_blake2b__blake2b
+#define blake2b_salt_personal          crypto_generichash_blake2b__blake2b_salt_personal
 
 #if defined(_MSC_VER)
 #define ALIGN(x) __declspec(align(x))
@@ -134,7 +137,11 @@ typedef crypto_generichash_blake2b_state blake2b_state;
   int blake2s_final( blake2s_state *S, uint8_t *out, uint8_t outlen );
 
   int blake2b_init( blake2b_state *S, const uint8_t outlen );
+  int blake2b_init_salt_personal( blake2b_state *S, const uint8_t outlen,
+                                  const void *personal, const void *salt );
   int blake2b_init_key( blake2b_state *S, const uint8_t outlen, const void *key, const uint8_t keylen );
+  int blake2b_init_key_salt_personal( blake2b_state *S, const uint8_t outlen, const void *key, const uint8_t keylen,
+                                      const void *salt, const void *personal );
   int blake2b_init_param( blake2b_state *S, const blake2b_param *P );
   int blake2b_update( blake2b_state *S, const uint8_t *in, uint64_t inlen );
   int blake2b_final( blake2b_state *S, uint8_t *out, uint8_t outlen );
@@ -152,6 +159,7 @@ typedef crypto_generichash_blake2b_state blake2b_state;
   // Simple API
   int blake2s( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen );
   int blake2b( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen );
+  int blake2b_salt_personal( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen, const void *salt, const void *personal );
 
   int blake2sp( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen );
   int blake2bp( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen );

data/vendor/libsodium/src/libsodium/crypto_generichash/blake2/ref/blake2b-ref.c

@@ -184,6 +184,34 @@ int blake2b_init( blake2b_state *S, const uint8_t outlen )
   return blake2b_init_param( S, P );
 }
 
+int blake2b_init_salt_personal( blake2b_state *S, const uint8_t outlen,
+                                const void *salt, const void *personal )
+{
+  blake2b_param P[1];
+
+  if ( ( !outlen ) || ( outlen > BLAKE2B_OUTBYTES ) ) return -1;
+
+  P->digest_length = outlen;
+  P->key_length    = 0;
+  P->fanout        = 1;
+  P->depth         = 1;
+  store32( &P->leaf_length, 0 );
+  store64( &P->node_offset, 0 );
+  P->node_depth    = 0;
+  P->inner_length  = 0;
+  memset( P->reserved, 0, sizeof( P->reserved ) );
+  if (salt != NULL) {
+    blake2b_param_set_salt( P, (const uint8_t *) salt );
+  } else {
+    memset( P->salt, 0, sizeof( P->salt ) );
+  }
+  if (personal != NULL) {
+    blake2b_param_set_personal( P, (const uint8_t *) personal );
+  } else {
+    memset( P->personal, 0, sizeof( P->personal ) );
+  }
+  return blake2b_init_param( S, P );
+}
 
 int blake2b_init_key( blake2b_state *S, const uint8_t outlen, const void *key, const uint8_t keylen )
 {
@@ -217,6 +245,47 @@ int blake2b_init_key( blake2b_state *S, const uint8_t outlen, const void *key, c
   return 0;
 }
 
+int blake2b_init_key_salt_personal( blake2b_state *S, const uint8_t outlen, const void *key, const uint8_t keylen,
+                                    const void *salt, const void *personal )
+{
+  blake2b_param P[1];
+
+  if ( ( !outlen ) || ( outlen > BLAKE2B_OUTBYTES ) ) return -1;
+
+  if ( !key || !keylen || keylen > BLAKE2B_KEYBYTES ) return -1;
+
+  P->digest_length = outlen;
+  P->key_length    = keylen;
+  P->fanout        = 1;
+  P->depth         = 1;
+  store32( &P->leaf_length, 0 );
+  store64( &P->node_offset, 0 );
+  P->node_depth    = 0;
+  P->inner_length  = 0;
+  memset( P->reserved, 0, sizeof( P->reserved ) );
+  if (salt != NULL) {
+    blake2b_param_set_salt( P, (const uint8_t *) salt );
+  } else {
+    memset( P->salt, 0, sizeof( P->salt ) );
+  }
+  if (personal != NULL) {
+    blake2b_param_set_personal( P, (const uint8_t *) personal );
+  } else {
+    memset( P->personal, 0, sizeof( P->personal ) );
+  }
+
+  if( blake2b_init_param( S, P ) < 0 ) return -1;
+
+  {
+    uint8_t block[BLAKE2B_BLOCKBYTES];
+    memset( block, 0, BLAKE2B_BLOCKBYTES );
+    memcpy( block, key, keylen );
+    blake2b_update( S, block, BLAKE2B_BLOCKBYTES );
+    secure_zero_memory( block, BLAKE2B_BLOCKBYTES ); /* Burn the key from stack */
+  }
+  return 0;
+}
+
 static int blake2b_compress( blake2b_state *S, const uint8_t block[BLAKE2B_BLOCKBYTES] )
 {
   uint64_t m[16];
@@ -362,3 +431,29 @@ int blake2b( uint8_t *out, const void *in, const void *key, const uint8_t outlen
   blake2b_final( S, out, outlen );
   return 0;
 }
+
+int blake2b_salt_personal( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen,
+                           const void *salt, const void *personal )
+{
+  blake2b_state S[1];
+
+  /* Verify parameters */
+  if ( NULL == in ) return -1;
+
+  if ( NULL == out ) return -1;
+
+  if( NULL == key ) keylen = 0;
+
+  if( keylen > 0 )
+  {
+    if( blake2b_init_key_salt_personal( S, outlen, key, keylen, salt, personal ) < 0 ) return -1;
+  }
+  else
+  {
+    if( blake2b_init_salt_personal( S, outlen, salt, personal ) < 0 ) return -1;
+  }
+
+  blake2b_update( S, ( const uint8_t * )in, inlen );
+  blake2b_final( S, out, outlen );
+  return 0;
+}