rbnacl-libsodium 0.6.1 → 0.7.0

data/vendor/libsodium/src/libsodium/crypto_stream/aes256estream/hongjun/aes256.h

@@ -1,171 +0,0 @@
-/* aes256.h */
-/* Hongjun Wu, January 2007*/
-
-
-#include "ecrypt-sync.h"
-#include "aes-table.h"
-
-#include <stdio.h>
-
-#ifdef NATIVE_LITTLE_ENDIAN
-# define LEROT(X, S) ((uint8_t) ((uint32_t)(X) >> (S)))
-# define SWP32(X)    (X)
-#elif defined(NATIVE_BIG_ENDIAN)
-# define LEROT(X, S) ((uint8_t) ((uint32_t)(X) >> (24 - (S))))
-# define SWP32(X)    ((uint32_t)((((uint32_t)(X) & 0xff000000) >> 24) | \
-                                 (((uint32_t)(X) & 0x00ff0000) >>  8) | \
-                                 (((uint32_t)(X) & 0x0000ff00) <<  8) | \
-                                 (((uint32_t)(X) & 0x000000ff) << 24)))
-#else
-# error Unsupported byte ordering
-#endif
-
-#define first_round(ctx,x0,y0) { \
-        u32 z0,t0,tem0;              \
-        z0 = (x0) ^ ctx->round_key[0][0];        \
-        t0 = LEROT(z0, 0);                       \
-        tem0 = T0[t0];               \
-        (y0) = tem0 ^ ctx->first_round_output_x0;       \
-}
-
-#define second_round(ctx,x0,y0,y1,y2,y3) { \
-        u32 t0,t7,t10,t13; \
-        u32 tem0,tem7,tem10,tem13;    \
-        t0 = LEROT(x0, 0);            \
-        tem0 = T0[t0];      \
-        (y0) = tem0 ^ ctx->second_round_output[0];   \
-        t7 = LEROT(x0, 24);                          \
-        tem7 = T3[t7];    \
-        (y1) = tem7 ^ ctx->second_round_output[1];   \
-        t10 = LEROT(x0, 16);                 \
-        tem10 = T2[t10]; \
-        (y2) = tem10 ^ ctx->second_round_output[2];  \
-        t13 = LEROT(x0, 8);                  \
-        tem13 = T1[t13];\
-        (y3) = tem13 ^ ctx->second_round_output[3];  \
-}
-
-#define round(ctx,x0,x1,x2,x3,y0,y1,y2,y3,r) { \
-        u32 t0,t1,t2,t3;    \
-        u32 t4,t5,t6,t7;    \
-        u32 t8,t9,t10,t11;  \
-        u32 t12,t13,t14,t15;\
-        u32 tem0,tem1,tem2,tem3;    \
-        u32 tem4,tem5,tem6,tem7;    \
-        u32 tem8,tem9,tem10,tem11;  \
-        u32 tem12,tem13,tem14,tem15;\
-        \
-        t0 = LEROT(x0, 0);                      \
-        tem0 = T0[t0];      \
-        t1 = LEROT(x1, 8);       \
-        tem1 = tem0 ^ T1[t1];    \
-        t2 = LEROT(x2, 16);      \
-        tem2 = tem1 ^ T2[t2];    \
-        t3 = LEROT(x3, 24);      \
-        tem3 = tem2 ^ T3[t3];    \
-        (y0) = tem3 ^ ctx->round_key[r][0];   \
-        \
-        t4 = LEROT(x1, 0);                      \
-        tem4 = T0[t4];      \
-        t5 = LEROT(x2, 8);       \
-        tem5 = tem4 ^ T1[t5];    \
-        t6 = LEROT(x3, 16);      \
-        tem6 = tem5 ^ T2[t6];    \
-        t7 = LEROT(x0, 24);      \
-        tem7 = tem6 ^ T3[t7];    \
-        (y1) = tem7 ^ ctx->round_key[r][1];   \
-        \
-        t8 = LEROT(x2, 0);      \
-        tem8 = T0[t8];          \
-        t9 = LEROT(x3, 8);      \
-        tem9 = tem8 ^ T1[t9];   \
-        t10 = LEROT(x0, 16);            \
-        tem10 = tem9 ^ T2[t10]; \
-        t11 = LEROT(x1, 24);            \
-        tem11 = tem10 ^ T3[t11];\
-        (y2) = tem11 ^ ctx->round_key[r][2]; \
-        \
-        t12 = LEROT(x3, 0);     \
-        tem12 = T0[t12];        \
-        t13 = LEROT(x0, 8);                     \
-        tem13 = tem12 ^ T1[t13];\
-        t14 = LEROT(x1, 16);            \
-        tem14 = tem13 ^ T2[t14];\
-        t15 = LEROT(x2, 24);            \
-        tem15 = tem14 ^ T3[t15];\
-        (y3) = tem15 ^ ctx->round_key[r][3]; \
-}
-
-/* 22.14 cycles/byte*/
-#define last_round(ctx,x0,x1,x2,x3,output,r) { \
-        u32 t0,t1,t2,t3;    \
-        u32 t4,t5,t6,t7;    \
-        u32 t8,t9,t10,t11;  \
-        u32 t12,t13,t14,t15;\
-        \
-        t0 = LEROT(x0, 0); \
-        output[0] = Sbox[t0]; \
-        t7 = LEROT(x0, 24);                     \
-        output[7] = Sbox[t7]; \
-        t10 = LEROT(x0, 16);            \
-        output[10] = Sbox[t10]; \
-        t13 = LEROT(x0, 8);     \
-        output[13] = Sbox[t13]; \
-        \
-        t1 = LEROT(x1, 8);                      \
-        output[1] = Sbox[t1]; \
-        t4 = LEROT(x1, 0); \
-        output[4] = Sbox[t4]; \
-        t11 = LEROT(x1, 24);            \
-        output[11] = Sbox[t11]; \
-        t14 = LEROT(x1, 16);            \
-        output[14] = Sbox[t14]; \
-        \
-        t2 = LEROT(x2, 16);                     \
-        output[2] = Sbox[t2]; \
-        t5 = LEROT(x2, 8);                      \
-        output[5] = Sbox[t5]; \
-        t8 = LEROT(x2, 0);              \
-        output[8] = Sbox[t8]; \
-        t15 = LEROT(x2, 24);            \
-        output[15] = Sbox[t15]; \
-      \
-        t3 = LEROT(x3, 24);                     \
-        output[3] = Sbox[t3]; \
-        t6 = LEROT(x3, 16);                     \
-        output[6] = Sbox[t6]; \
-        t9 = LEROT(x3, 8);        \
-        output[9] = Sbox[t9];     \
-        t12 = LEROT(x3, 0);       \
-        output[12] = Sbox[t12];   \
-}
-
-#define aes256_enc_block(x,output,ctx) {\
-      u32 y0;\
-      u32 z0,z1,z2,z3;\
-      u32 a0,a1,a2,a3;\
-      u32 b0,b1,b2,b3;\
-      u32 c0,c1,c2,c3;\
-      u32 d0,d1,d2,d3;\
-      u32 e0,e1,e2,e3;\
-      u32 f0,f1,f2,f3;\
-      u32 g0,g1,g2,g3;\
-      u32 h0,h1,h2,h3;\
-      u32 i0,i1,i2,i3;\
-      u32 j0,j1,j2,j3;\
-      u32 k0,k1,k2,k3;\
-      first_round(ctx,x[0],y0);\
-      second_round(ctx,y0,z0,z1,z2,z3);\
-      round(ctx,z0,z1,z2,z3,a0,a1,a2,a3,3);\
-      round(ctx,a0,a1,a2,a3,b0,b1,b2,b3,4);\
-      round(ctx,b0,b1,b2,b3,c0,c1,c2,c3,5);\
-      round(ctx,c0,c1,c2,c3,d0,d1,d2,d3,6);\
-      round(ctx,d0,d1,d2,d3,e0,e1,e2,e3,7);\
-      round(ctx,e0,e1,e2,e3,f0,f1,f2,f3,8);\
-      round(ctx,f0,f1,f2,f3,g0,g1,g2,g3,9);\
-      round(ctx,g0,g1,g2,g3,h0,h1,h2,h3,10);\
-      round(ctx,h0,h1,h2,h3,i0,i1,i2,i3,11);\
-      round(ctx,i0,i1,i2,i3,j0,j1,j2,j3,12);\
-      round(ctx,j0,j1,j2,j3,k0,k1,k2,k3,13);\
-      last_round(ctx,k0,k1,k2,k3,(output),14);\
-}

data/vendor/libsodium/src/libsodium/crypto_stream/aes256estream/hongjun/api.h

@@ -1,13 +0,0 @@
-
-#include "crypto_stream_aes256estream.h"
-
-#define crypto_stream crypto_stream_aes256estream
-#define crypto_stream_xor crypto_stream_aes256estream_xor
-#define crypto_stream_beforenm crypto_stream_aes256estream_beforenm
-#define crypto_stream_afternm crypto_stream_aes256estream_afternm
-#define crypto_stream_xor_afternm crypto_stream_aes256estream_xor_afternm
-#define crypto_stream_KEYBYTES crypto_stream_aes256estream_KEYBYTES
-#define crypto_stream_NONCEBYTES crypto_stream_aes256estream_NONCEBYTES
-#define crypto_stream_BEFORENMBYTES crypto_stream_aes256estream_BEFORENMBYTES
-#define crypto_stream_IMPLEMENTATION crypto_stream_aes256estream_IMPLEMENTATION
-#define crypto_stream_VERSION crypto_stream_aes256estream_VERSION

data/vendor/libsodium/src/libsodium/crypto_stream/aes256estream/hongjun/ecrypt-sync.h

@@ -1,27 +0,0 @@
-
-#ifndef __ECRYPT_SYNC__
-#define __ECRYPT_SYNC__
-
-#include <stdint.h>
-
-typedef uint8_t  u8;
-typedef uint32_t u32;
-
-#define Nr 14
-#define Nk 8
-#define Nb 4
-
-#pragma pack(push, 1)
-typedef struct ECRYPT_ctx
-{
-  u32 round_key[Nr+1][4];
-  u32 counter[4];
-  u32 first_round_output_x0;
-  u32 second_round_output[4];
-} ECRYPT_ctx;
-#pragma pack(pop)
-
-#define ECRYPT_encrypt_bytes(ctx, plaintext, ciphertext, msglen)   \
-  ECRYPT_process_bytes(0, ctx, plaintext, ciphertext, msglen)
-
-#endif

data/vendor/libsodium/src/libsodium/crypto_stream/aes256estream/stream_aes256estream_api.c

@@ -1,16 +0,0 @@
-#include "crypto_stream_aes256estream.h"
-
-size_t
-crypto_stream_aes256estream_keybytes(void) {
-    return crypto_stream_aes256estream_KEYBYTES;
-}
-
-size_t
-crypto_stream_aes256estream_noncebytes(void) {
-    return crypto_stream_aes256estream_NONCEBYTES;
-}
-
-size_t
-crypto_stream_aes256estream_beforenmbytes(void) {
-    return crypto_stream_aes256estream_BEFORENMBYTES;
-}

data/vendor/libsodium/src/libsodium/crypto_stream/try.c

@@ -1,122 +0,0 @@
-/*
- * crypto_stream/try.c version 20090118
- * D. J. Bernstein
- * Public domain.
- */
-
-#include <stdlib.h>
-#include "crypto_stream.h"
-#include "utils.h"
-#include "windows/windows-quirks.h"
-
-extern unsigned char *alignedcalloc(unsigned long long);
-
-const char *primitiveimplementation = crypto_stream_IMPLEMENTATION;
-
-#define MAXTEST_BYTES 10000
-#define CHECKSUM_BYTES 4096
-#define TUNE_BYTES 1536
-
-static unsigned char *k;
-static unsigned char *n;
-static unsigned char *m;
-static unsigned char *c;
-static unsigned char *s;
-static unsigned char *k2;
-static unsigned char *n2;
-static unsigned char *m2;
-static unsigned char *c2;
-static unsigned char *s2;
-
-void preallocate(void)
-{
-}
-
-void allocate(void)
-{
-  k = alignedcalloc(crypto_stream_KEYBYTES);
-  n = alignedcalloc(crypto_stream_NONCEBYTES);
-  m = alignedcalloc(MAXTEST_BYTES);
-  c = alignedcalloc(MAXTEST_BYTES);
-  s = alignedcalloc(MAXTEST_BYTES);
-  k2 = alignedcalloc(crypto_stream_KEYBYTES);
-  n2 = alignedcalloc(crypto_stream_NONCEBYTES);
-  m2 = alignedcalloc(MAXTEST_BYTES);
-  c2 = alignedcalloc(MAXTEST_BYTES);
-  s2 = alignedcalloc(MAXTEST_BYTES);
-}
-
-void predoit(void)
-{
-}
-
-void doit(void)
-{
-  crypto_stream_xor(c,m,TUNE_BYTES,n,k);
-}
-
-char checksum[crypto_stream_KEYBYTES * 2 + 1];
-
-const char *checksum_compute(void)
-{
-  long long i;
-  long long j;
-
-  for (i = 0;i < CHECKSUM_BYTES;++i) {
-    long long mlen = i;
-    long long clen = i;
-    long long slen = i;
-    long long klen = crypto_stream_KEYBYTES;
-    long long nlen = crypto_stream_NONCEBYTES;
-    for (j = -16;j < 0;++j) m[j] = rand();
-    for (j = -16;j < 0;++j) c[j] = rand();
-    for (j = -16;j < 0;++j) s[j] = rand();
-    for (j = -16;j < 0;++j) n[j] = rand();
-    for (j = -16;j < 0;++j) k[j] = rand();
-    for (j = mlen;j < mlen + 16;++j) m[j] = rand();
-    for (j = clen;j < clen + 16;++j) c[j] = rand();
-    for (j = slen;j < slen + 16;++j) s[j] = rand();
-    for (j = nlen;j < nlen + 16;++j) n[j] = rand();
-    for (j = klen;j < klen + 16;++j) k[j] = rand();
-    for (j = -16;j < mlen + 16;++j) m2[j] = m[j];
-    for (j = -16;j < clen + 16;++j) c2[j] = c[j];
-    for (j = -16;j < slen + 16;++j) s2[j] = s[j];
-    for (j = -16;j < nlen + 16;++j) n2[j] = n[j];
-    for (j = -16;j < klen + 16;++j) k2[j] = k[j];
-
-    crypto_stream_xor(c,m,mlen,n,k);
-
-    for (j = -16;j < mlen + 16;++j) if (m[j] != m2[j]) return "crypto_stream_xor overwrites m";
-    for (j = -16;j < slen + 16;++j) if (s[j] != s2[j]) return "crypto_stream_xor overwrites s";
-    for (j = -16;j < nlen + 16;++j) if (n[j] != n2[j]) return "crypto_stream_xor overwrites n";
-    for (j = -16;j < klen + 16;++j) if (k[j] != k2[j]) return "crypto_stream_xor overwrites k";
-    for (j = -16;j < 0;++j) if (c[j] != c2[j]) return "crypto_stream_xor writes before output";
-    for (j = clen;j < clen + 16;++j) if (c[j] != c2[j]) return "crypto_stream_xor writes after output";
-
-    for (j = -16;j < clen + 16;++j) c2[j] = c[j];
-
-    crypto_stream(s,slen,n,k);
-
-    for (j = -16;j < mlen + 16;++j) if (m[j] != m2[j]) return "crypto_stream overwrites m";
-    for (j = -16;j < clen + 16;++j) if (c[j] != c2[j]) return "crypto_stream overwrites c";
-    for (j = -16;j < nlen + 16;++j) if (n[j] != n2[j]) return "crypto_stream overwrites n";
-    for (j = -16;j < klen + 16;++j) if (k[j] != k2[j]) return "crypto_stream overwrites k";
-    for (j = -16;j < 0;++j) if (s[j] != s2[j]) return "crypto_stream writes before output";
-    for (j = slen;j < slen + 16;++j) if (s[j] != s2[j]) return "crypto_stream writes after output";
-
-    for (j = 0;j < mlen;++j)
-      if ((s[j] ^ m[j]) != c[j]) return "crypto_stream_xor does not match crypto_stream";
-
-    for (j = 0;j < clen;++j) k[j % klen] ^= c[j];
-    crypto_stream_xor(m,c,clen,n,k);
-    crypto_stream(s,slen,n,k);
-    for (j = 0;j < mlen;++j)
-      if ((s[j] ^ m[j]) != c[j]) return "crypto_stream_xor does not match crypto_stream";
-    for (j = 0;j < mlen;++j) n[j % nlen] ^= m[j];
-    m[mlen] = 0;
-  }
-
-  sodium_bin2hex(checksum, sizeof checksum, k, crypto_stream_KEYBYTES);
-
-  return 0;
-}

data/vendor/libsodium/src/libsodium/crypto_verify/try.c

@@ -1,76 +0,0 @@
-/*
- * crypto_verify/try.c version 20090118
- * D. J. Bernstein
- * Public domain.
- */
-
-#include <stdlib.h>
-#include "crypto_verify.h"
-#include "windows/windows-quirks.h"
-
-extern unsigned char *alignedcalloc(unsigned long long);
-
-const char *primitiveimplementation = crypto_verify_IMPLEMENTATION;
-
-static unsigned char *x;
-static unsigned char *y;
-
-void preallocate(void)
-{
-}
-
-void allocate(void)
-{
-  x = alignedcalloc(crypto_verify_BYTES);
-  y = alignedcalloc(crypto_verify_BYTES);
-}
-
-void predoit(void)
-{
-}
-
-void doit(void)
-{
-  crypto_verify(x,y);
-}
-
-static const char *check(void)
-{
-  int r = crypto_verify(x,y);
-  if (r == 0) {
-    if (memcmp(x,y,crypto_verify_BYTES)) return "different strings pass verify";
-  } else if (r == -1) {
-    if (!memcmp(x,y,crypto_verify_BYTES)) return "equal strings fail verify";
-  } else {
-    return "weird return value from verify";
-  }
-  return 0;
-}
-
-char checksum[2];
-
-const char *checksum_compute(void)
-{
-  long long tests;
-  long long i;
-  long long j;
-  const char *c;
-
-  for (tests = 0;tests < 100000;++tests) {
-    for (i = 0;i < crypto_verify_BYTES;++i) x[i] = rand();
-    for (i = 0;i < crypto_verify_BYTES;++i) y[i] = rand();
-    c = check(); if (c) return c;
-    for (i = 0;i < crypto_verify_BYTES;++i) y[i] = x[i];
-    c = check(); if (c) return c;
-    y[rand() % crypto_verify_BYTES] = rand();
-    c = check(); if (c) return c;
-    y[rand() % crypto_verify_BYTES] = rand();
-    c = check(); if (c) return c;
-    y[rand() % crypto_verify_BYTES] = rand();
-    c = check(); if (c) return c;
-  }
-
-  checksum[0] = '0';
-  checksum[1] = 0;
-  return 0;
-}

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

@@ -1,67 +0,0 @@
-#ifndef crypto_stream_aes256estream_H
-#define crypto_stream_aes256estream_H
-
-/*
- * WARNING: This is just a stream cipher. It is NOT authenticated encryption.
- * While it provides some protection against eavesdropping, it does NOT
- * provide any security against active attacks.
- * Furthermore, this implementation was not part of NaCl.
- * 
- * If you are looking for a stream cipher, you might consider
- * crypto_stream_aes128ctr, crypto_stream_chacha20 or crypto_stream_(x)salsa20
- * which are timing-attack resistant.
- * 
- * But unless you know what you're doing, what you are looking for is probably
- * the crypto_box or crypto_secretbox functions.
- */
-
-#include <stddef.h>
-#include "export.h"
-
-#ifdef __cplusplus
-# if __GNUC__
-#  pragma GCC diagnostic ignored "-Wlong-long"
-# endif
-extern "C" {
-#endif
-
-#define crypto_stream_aes256estream_KEYBYTES 32U
-SODIUM_EXPORT
-size_t crypto_stream_aes256estream_keybytes(void);
-
-#define crypto_stream_aes256estream_NONCEBYTES 16U
-SODIUM_EXPORT
-size_t crypto_stream_aes256estream_noncebytes(void);
-
-#define crypto_stream_aes256estream_BEFORENMBYTES 276U
-SODIUM_EXPORT
-size_t crypto_stream_aes256estream_beforenmbytes(void);
-
-SODIUM_EXPORT
-int crypto_stream_aes256estream(unsigned char *out, unsigned long long len,
-                                const unsigned char *nonce, const unsigned char *c);
-
-SODIUM_EXPORT
-int crypto_stream_aes256estream_xor(unsigned char *out, const unsigned char *in,
-                                    unsigned long long inlen, const unsigned char *n,
-                                    const unsigned char *k);
-
-SODIUM_EXPORT
-int crypto_stream_aes256estream_beforenm(unsigned char *c, const unsigned char *k);
-
-SODIUM_EXPORT
-int crypto_stream_aes256estream_afternm(unsigned char *out, unsigned long long len,
-                                        const unsigned char *nonce,
-                                        const unsigned char *c);
-
-SODIUM_EXPORT
-int crypto_stream_aes256estream_xor_afternm(unsigned char *out, const unsigned char *in,
-                                            unsigned long long len,
-                                            const unsigned char *nonce,
-                                            const unsigned char *c);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif