rbnacl-libsodium 0.5.0.1 → 0.6.0

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

@@ -32,3 +32,28 @@ crypto_onetimeauth_verify(const unsigned char *h, const unsigned char *in,
 {
     return crypto_onetimeauth_poly1305_verify(h, in, inlen, k);
 }
+
+int
+crypto_onetimeauth_init(crypto_onetimeauth_state *state,
+                        const unsigned char *key)
+{
+    return crypto_onetimeauth_poly1305_init
+        ((crypto_onetimeauth_poly1305_state *) state, key);
+}
+
+int
+crypto_onetimeauth_update(crypto_onetimeauth_state *state,
+                          const unsigned char *in,
+                          unsigned long long inlen)
+{
+    return crypto_onetimeauth_poly1305_update
+        ((crypto_onetimeauth_poly1305_state *) state, in, inlen);
+}
+
+int
+crypto_onetimeauth_final(crypto_onetimeauth_state *state,
+                         unsigned char *out)
+{
+    return crypto_onetimeauth_poly1305_final
+        ((crypto_onetimeauth_poly1305_state *) state, out);
+}

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

@@ -1,10 +1,6 @@
 
-#include "api.h"
 #include "utils.h"
-
-#include "crypto_onetimeauth_poly1305_donna.h"
 #include "poly1305_donna.h"
-
 #ifdef HAVE_TI_MODE
 # include "poly1305_donna64.h"
 #else
@@ -14,62 +10,95 @@
 static void
 poly1305_update(poly1305_context *ctx, const unsigned char *m,
                 unsigned long long bytes) {
-        poly1305_state_internal_t *st = (poly1305_state_internal_t *)ctx;
-        unsigned long long i;
-
-        /* handle leftover */
-        if (st->leftover) {
-                unsigned long long want = (poly1305_block_size - st->leftover);
-                if (want > bytes)
-                        want = bytes;
-                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)
-                        return;
-                poly1305_blocks(st, st->buffer, poly1305_block_size);
-                st->leftover = 0;
-        }
-
-        /* process full blocks */
-        if (bytes >= poly1305_block_size) {
-                unsigned long long want = (bytes & ~(poly1305_block_size - 1));
-                poly1305_blocks(st, m, want);
-                m += want;
-                bytes -= want;
-        }
-
-        /* store leftover */
-        if (bytes) {
-                for (i = 0; i < bytes; i++)
-                        st->buffer[st->leftover + i] = m[i];
-                st->leftover += bytes;
-        }
+    poly1305_state_internal_t *st = (poly1305_state_internal_t *)(void *)ctx;
+    unsigned long long i;
+
+    /* handle leftover */
+    if (st->leftover) {
+        unsigned long long want = (poly1305_block_size - st->leftover);
+        if (want > bytes)
+            want = bytes;
+        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)
+            return;
+        poly1305_blocks(st, st->buffer, poly1305_block_size);
+        st->leftover = 0;
+    }
+
+    /* process full blocks */
+    if (bytes >= poly1305_block_size) {
+        unsigned long long want = (bytes & ~(poly1305_block_size - 1));
+        poly1305_blocks(st, m, want);
+        m += want;
+        bytes -= want;
+    }
+
+    /* store leftover */
+    if (bytes) {
+        for (i = 0; i < bytes; i++)
+            st->buffer[st->leftover + i] = m[i];
+        st->leftover += bytes;
+    }
+}
+
+int
+crypto_onetimeauth_poly1305_donna(unsigned char *out, const unsigned char *m,
+                                  unsigned long long inlen,
+                                  const unsigned char *key)
+{
+    poly1305_context ctx;
+    poly1305_init(&ctx, key);
+    poly1305_update(&ctx, m, inlen);
+    poly1305_finish(&ctx, out);
+
+    return 0;
+}
+
+int
+crypto_onetimeauth_poly1305_donna_init(crypto_onetimeauth_poly1305_state *state,
+                                       const unsigned char *key)
+{
+    poly1305_init((poly1305_context *) state, key);
+
+    return 0;
+}
+
+int
+crypto_onetimeauth_poly1305_donna_update(crypto_onetimeauth_poly1305_state *state,
+                                         const unsigned char *in,
+                                         unsigned long long inlen)
+{
+    poly1305_update((poly1305_context *) state, in, inlen);
+
+    return 0;
 }
 
 int
-crypto_onetimeauth(unsigned char *out, const unsigned char *m,
-                   unsigned long long inlen, const unsigned char *key)
+crypto_onetimeauth_poly1305_donna_final(crypto_onetimeauth_poly1305_state *state,
+                                        unsigned char *out)
 {
-        poly1305_context ctx;
-        poly1305_init(&ctx, key);
-        poly1305_update(&ctx, m, inlen);
-        poly1305_finish(&ctx, out);
+    poly1305_finish((poly1305_context *) state, out);
 
     return 0;
 }
 
+
 const char *
-crypto_onetimeauth_poly1305_implementation_name(void)
+crypto_onetimeauth_poly1305_donna_implementation_name(void)
 {
     return POLY1305_IMPLEMENTATION_NAME;
 }
 
 struct crypto_onetimeauth_poly1305_implementation
 crypto_onetimeauth_poly1305_donna_implementation = {
-    _SODIUM_C99(.implementation_name =) crypto_onetimeauth_poly1305_implementation_name,
-    _SODIUM_C99(.onetimeauth =) crypto_onetimeauth,
-    _SODIUM_C99(.onetimeauth_verify =) crypto_onetimeauth_verify
+    _SODIUM_C99(.implementation_name =) crypto_onetimeauth_poly1305_donna_implementation_name,
+    _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

@@ -1,12 +1,35 @@
-#ifndef POLY1305_DONNA_H
-#define POLY1305_DONNA_H
+#ifndef __POLY1305_DONNA_H__
+#define __POLY1305_DONNA_H__
 
 #include <stddef.h>
 
-typedef struct poly1305_context {
-        unsigned long long aligner;
-        unsigned char opaque[136];
-} poly1305_context;
+#include "crypto_onetimeauth_poly1305.h"
 
-#endif /* POLY1305_DONNA_H */
+typedef crypto_onetimeauth_poly1305_state poly1305_context;
 
+extern struct crypto_onetimeauth_poly1305_implementation
+    crypto_onetimeauth_poly1305_donna_implementation;
+
+const char *crypto_onetimeauth_poly1305_donna_implementation_name(void);
+
+int crypto_onetimeauth_poly1305_donna(unsigned char *out,
+                                      const unsigned char *in,
+                                      unsigned long long inlen,
+                                      const unsigned char *k);
+
+int crypto_onetimeauth_poly1305_donna_verify(const unsigned char *h,
+                                             const unsigned char *in,
+                                             unsigned long long inlen,
+                                             const unsigned char *k);
+
+int crypto_onetimeauth_poly1305_donna_init(crypto_onetimeauth_poly1305_state *state,
+                                           const unsigned char *key);
+
+int crypto_onetimeauth_poly1305_donna_update(crypto_onetimeauth_poly1305_state *state,
+                                             const unsigned char *in,
+                                             unsigned long long inlen);
+
+int crypto_onetimeauth_poly1305_donna_final(crypto_onetimeauth_poly1305_state *state,
+                                            unsigned char *out);
+
+#endif /* __POLY1305_DONNA_H__ */

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

@@ -45,7 +45,7 @@ U32TO8(unsigned char *p, unsigned long v) {
 
 static void
 poly1305_init(poly1305_context *ctx, const unsigned char key[32]) {
-        poly1305_state_internal_t *st = (poly1305_state_internal_t *)ctx;
+        poly1305_state_internal_t *st = (poly1305_state_internal_t *)(void *)ctx;
 
         /* r &= 0xffffffc0ffffffc0ffffffc0fffffff */
         st->r[0] = (U8TO32(&key[ 0])     ) & 0x3ffffff;
@@ -134,7 +134,7 @@ poly1305_blocks(poly1305_state_internal_t *st, const unsigned char *m, unsigned
 
 static POLY1305_NOINLINE void
 poly1305_finish(poly1305_context *ctx, unsigned char mac[16]) {
-        poly1305_state_internal_t *st = (poly1305_state_internal_t *)ctx;
+        poly1305_state_internal_t *st = (poly1305_state_internal_t *)(void *)ctx;
         unsigned long h0,h1,h2,h3,h4,c;
         unsigned long g0,g1,g2,g3,g4;
         unsigned long long f;
@@ -203,19 +203,6 @@ poly1305_finish(poly1305_context *ctx, unsigned char mac[16]) {
         U32TO8(mac + 12, h3);
 
         /* zero out the state */
-        st->h[0] = 0;
-        st->h[1] = 0;
-        st->h[2] = 0;
-        st->h[3] = 0;
-        st->h[4] = 0;
-        st->r[0] = 0;
-        st->r[1] = 0;
-        st->r[2] = 0;
-        st->r[3] = 0;
-        st->r[4] = 0;
-        st->pad[0] = 0;
-        st->pad[1] = 0;
-        st->pad[2] = 0;
-        st->pad[3] = 0;
+        sodium_memzero((void *)st, sizeof *st);
 }
 

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

@@ -59,7 +59,7 @@ U64TO8(unsigned char *p, unsigned long long v) {
 
 static void
 poly1305_init(poly1305_context *ctx, const unsigned char key[32]) {
-        poly1305_state_internal_t *st = (poly1305_state_internal_t *)ctx;
+        poly1305_state_internal_t *st = (poly1305_state_internal_t *)(void *)ctx;
         unsigned long long t0,t1;
 
         /* r &= 0xffffffc0ffffffc0ffffffc0fffffff */
@@ -138,7 +138,7 @@ poly1305_blocks(poly1305_state_internal_t *st, const unsigned char *m, unsigned
 
 static POLY1305_NOINLINE void
 poly1305_finish(poly1305_context *ctx, unsigned char mac[16]) {
-        poly1305_state_internal_t *st = (poly1305_state_internal_t *)ctx;
+        poly1305_state_internal_t *st = (poly1305_state_internal_t *)(void *)ctx;
         unsigned long long h0,h1,h2,c;
         unsigned long long g0,g1,g2;
         unsigned long long t0,t1;
@@ -197,13 +197,6 @@ poly1305_finish(poly1305_context *ctx, unsigned char mac[16]) {
         U64TO8(&mac[8], h1);
 
         /* zero out the state */
-        st->h[0] = 0;
-        st->h[1] = 0;
-        st->h[2] = 0;
-        st->r[0] = 0;
-        st->r[1] = 0;
-        st->r[2] = 0;
-        st->pad[0] = 0;
-        st->pad[1] = 0;
+        sodium_memzero((void *)st, sizeof *st);
 }
 

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

@@ -1,10 +1,15 @@
-#include "api.h"
-#include "crypto_onetimeauth_poly1305_donna.h"
+#include "crypto_onetimeauth_poly1305.h"
 #include "crypto_verify_16.h"
+#include "poly1305_donna.h"
 
-int crypto_onetimeauth_verify(const unsigned char *h,const unsigned char *in,unsigned long long inlen,const unsigned char *k)
+int
+crypto_onetimeauth_poly1305_donna_verify(const unsigned char *h,
+                                         const unsigned char *in,
+                                         unsigned long long inlen,
+                                         const unsigned char *k)
 {
-  unsigned char correct[16];
-  crypto_onetimeauth(correct,in,inlen,k);
-  return crypto_verify_16(h,correct);
+    unsigned char correct[16];
+
+    crypto_onetimeauth_poly1305_donna(correct,in,inlen,k);
+    return crypto_verify_16(h,correct);
 }

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

@@ -1,6 +1,6 @@
 
 #include "crypto_onetimeauth_poly1305.h"
-#include "crypto_onetimeauth_poly1305_donna.h"
+#include "donna/poly1305_donna.h"
 
 static const crypto_onetimeauth_poly1305_implementation *implementation =
     &crypto_onetimeauth_poly1305_donna_implementation;
@@ -34,3 +34,25 @@ crypto_onetimeauth_poly1305_verify(const unsigned char *h,
 {
     return implementation->onetimeauth_verify(h, in, inlen, k);
 }
+
+int
+crypto_onetimeauth_poly1305_init(crypto_onetimeauth_poly1305_state *state,
+                                 const unsigned char *key)
+{
+    return implementation->onetimeauth_init(state, key);
+}
+
+int
+crypto_onetimeauth_poly1305_update(crypto_onetimeauth_poly1305_state *state,
+                                   const unsigned char *in,
+                                   unsigned long long inlen)
+{
+    return implementation->onetimeauth_update(state, in, inlen);
+}
+
+int
+crypto_onetimeauth_poly1305_final(crypto_onetimeauth_poly1305_state *state,
+                                  unsigned char *out)
+{
+    return implementation->onetimeauth_final(state, out);
+}

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

@@ -3,8 +3,8 @@
 #include <string.h>
 #include "crypto_onetimeauth.h"
 #include "crypto_onetimeauth_poly1305.h"
-#include "crypto_onetimeauth_poly1305_donna.h"
 #include "utils.h"
+#include "donna/poly1305_donna.h"
 
 crypto_onetimeauth_poly1305_implementation *
 crypto_onetimeauth_pick_best_implementation(void)

data/vendor/libsodium/src/libsodium/crypto_pwhash/{scryptxsalsa208sha256 → scryptsalsa208sha256}/crypto_scrypt-common.c

@@ -21,7 +21,7 @@
 #include <stdint.h>
 #include <string.h>
 
-#include "crypto_pwhash_scryptxsalsa208sha256.h"
+#include "crypto_pwhash_scryptsalsa208sha256.h"
 #include "crypto_scrypt.h"
 #include "runtime.h"
 #include "utils.h"
@@ -107,7 +107,7 @@ uint8_t *
 escrypt_r(escrypt_local_t * local, const uint8_t * passwd, size_t passwdlen,
           const uint8_t * setting, uint8_t * buf, size_t buflen)
 {
-    uint8_t        hash[crypto_pwhash_scryptxsalsa208sha256_STRHASHBYTES];
+    uint8_t        hash[crypto_pwhash_scryptsalsa208sha256_STRHASHBYTES];
     escrypt_kdf_t  escrypt_kdf;
     const uint8_t *src;
     const uint8_t *salt;
@@ -149,7 +149,7 @@ escrypt_r(escrypt_local_t * local, const uint8_t * passwd, size_t passwdlen,
         saltlen = strlen((char *)salt);
     }
     need = prefixlen + saltlen + 1 +
-        crypto_pwhash_scryptxsalsa208sha256_STRHASHBYTES_ENCODED + 1;
+        crypto_pwhash_scryptsalsa208sha256_STRHASHBYTES_ENCODED + 1;
     if (need > buflen || need < saltlen) {
         return NULL;
     }
@@ -222,10 +222,10 @@ escrypt_gensalt_r(uint32_t N_log2, uint32_t r, uint32_t p,
 }
 
 int
-crypto_scrypt_compat(const uint8_t * passwd, size_t passwdlen,
-                     const uint8_t * salt, size_t saltlen,
-                     uint64_t N, uint32_t r, uint32_t p,
-                     uint8_t * buf, size_t buflen)
+crypto_pwhash_scryptsalsa208sha256_ll(const uint8_t * passwd, size_t passwdlen,
+                                      const uint8_t * salt, size_t saltlen,
+                                      uint64_t N, uint32_t r, uint32_t p,
+                                      uint8_t * buf, size_t buflen)
 {
     escrypt_kdf_t   escrypt_kdf;
     escrypt_local_t local;

data/vendor/libsodium/src/libsodium/crypto_pwhash/{scryptxsalsa208sha256 → scryptsalsa208sha256}/crypto_scrypt.h

@@ -32,29 +32,15 @@
 
 #include <stdint.h>
 
-#define crypto_pwhash_scryptxsalsa208sha256_STRPREFIXBYTES 14
-#define crypto_pwhash_scryptxsalsa208sha256_STRSETTINGBYTES 57
-#define crypto_pwhash_scryptxsalsa208sha256_STRSALTBYTES 32
-#define crypto_pwhash_scryptxsalsa208sha256_STRSALTBYTES_ENCODED 43
-#define crypto_pwhash_scryptxsalsa208sha256_STRHASHBYTES 32
-#define crypto_pwhash_scryptxsalsa208sha256_STRHASHBYTES_ENCODED 43
+#define crypto_pwhash_scryptsalsa208sha256_STRPREFIXBYTES 14
+#define crypto_pwhash_scryptsalsa208sha256_STRSETTINGBYTES 57
+#define crypto_pwhash_scryptsalsa208sha256_STRSALTBYTES 32
+#define crypto_pwhash_scryptsalsa208sha256_STRSALTBYTES_ENCODED 43
+#define crypto_pwhash_scryptsalsa208sha256_STRHASHBYTES 32
+#define crypto_pwhash_scryptsalsa208sha256_STRHASHBYTES_ENCODED 43
 
 #define BYTES2CHARS(bytes) ((((bytes) * 8) + 5) / 6)
 
-/**
- * crypto_scrypt_compat(passwd, passwdlen, salt, saltlen, N, r, p, buf, buflen):
- * Compute scrypt(passwd[0 .. passwdlen - 1], salt[0 .. saltlen - 1], N, r,
- * p, buflen) and write the result into buf.  The parameters r, p, and buflen
- * must satisfy r * p < 2^30 and buflen <= (2^32 - 1) * 32.  The parameter N
- * must be a power of 2 greater than 1.
- *
- * Return 0 on success; or -1 on error.
- */
-extern int crypto_scrypt_compat(const uint8_t * __passwd, size_t __passwdlen,
-    const uint8_t * __salt, size_t __saltlen,
-    uint64_t __N, uint32_t __r, uint32_t __p,
-    uint8_t * __buf, size_t __buflen);
-
 typedef struct {
 	void * base, * aligned;
 	size_t size;

data/vendor/libsodium/src/libsodium/crypto_pwhash/{scryptxsalsa208sha256 → scryptsalsa208sha256}/pbkdf2-sha256.c

@@ -32,19 +32,9 @@
 
 #include "crypto_auth_hmacsha256.h"
 #include "pbkdf2-sha256.h"
+#include "sysendian.h"
 #include "utils.h"
 
-static inline void
-be32enc(void *pp, uint32_t x)
-{
-    uint8_t * p = (uint8_t *)pp;
-
-    p[3] = x & 0xff;
-    p[2] = (x >> 8) & 0xff;
-    p[1] = (x >> 16) & 0xff;
-    p[0] = (x >> 24) & 0xff;
-}
-
 /**
  * PBKDF2_SHA256(passwd, passwdlen, salt, saltlen, c, buf, dkLen):
  * Compute PBKDF2(passwd, salt, c, dkLen) using HMAC-SHA256 as the PRF, and