rbnacl-libsodium 1.0.11 → 1.0.13

data/vendor/libsodium/src/libsodium/crypto_stream/aes128ctr/nacl/consts.h

@@ -0,0 +1,28 @@
+#ifndef aes128ctr_nacl_consts_H
+#define aes128ctr_nacl_consts_H
+
+#include "int128.h"
+
+#define ROTB crypto_stream_aes128ctr_nacl_ROTB
+#define M0 crypto_stream_aes128ctr_nacl_M0
+#define EXPB0 crypto_stream_aes128ctr_nacl_EXPB0
+#define SWAP32 crypto_stream_aes128ctr_nacl_SWAP32
+#define M0SWAP crypto_stream_aes128ctr_nacl_M0SWAP
+#define SR crypto_stream_aes128ctr_nacl_SR
+#define SRM0 crypto_stream_aes128ctr_nacl_SRM0
+#define BS0 crypto_stream_aes128ctr_nacl_BS0
+#define BS1 crypto_stream_aes128ctr_nacl_BS1
+#define BS2 crypto_stream_aes128ctr_nacl_BS2
+
+extern const unsigned char ROTB[16];
+extern const unsigned char M0[16];
+extern const unsigned char EXPB0[16];
+extern const unsigned char SWAP32[16];
+extern const unsigned char M0SWAP[16];
+extern const unsigned char SR[16];
+extern const unsigned char SRM0[16];
+extern const aes_uint128_t BS0;
+extern const aes_uint128_t BS1;
+extern const aes_uint128_t BS2;
+
+#endif

data/vendor/libsodium/src/libsodium/crypto_stream/aes128ctr/nacl/consts_aes128ctr.c

@@ -0,0 +1,28 @@
+#include "consts.h"
+
+const unsigned char ROTB[16] = {
+    0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x08
+};
+const unsigned char M0[16] = { 0x0f, 0x0b, 0x07, 0x03, 0x0e, 0x0a, 0x06, 0x02,
+                               0x0d, 0x09, 0x05, 0x01, 0x0c, 0x08, 0x04, 0x00 };
+const unsigned char EXPB0[16] = { 0x03, 0x03, 0x03, 0x03, 0x07, 0x07,
+                                  0x07, 0x07, 0x0b, 0x0b, 0x0b, 0x0b,
+                                  0x0f, 0x0f, 0x0f, 0x0f };
+
+const unsigned char SWAP32[16] = { 0x03, 0x02, 0x01, 0x00, 0x07, 0x06,
+                                   0x05, 0x04, 0x0b, 0x0a, 0x09, 0x08,
+                                   0x0f, 0x0e, 0x0d, 0x0c };
+const unsigned char M0SWAP[16] = { 0x0c, 0x08, 0x04, 0x00, 0x0d, 0x09,
+                                   0x05, 0x01, 0x0e, 0x0a, 0x06, 0x02,
+                                   0x0f, 0x0b, 0x07, 0x03 };
+const unsigned char SR[16] = { 0x01, 0x02, 0x03, 0x00, 0x06, 0x07, 0x04, 0x05,
+                               0x0b, 0x08, 0x09, 0x0a, 0x0c, 0x0d, 0x0e, 0x0f };
+const unsigned char SRM0[16] = {
+    0x0f, 0x0a, 0x05, 0x00, 0x0e, 0x09, 0x04, 0x03,
+    0x0d, 0x08, 0x07, 0x02, 0x0c, 0x0b, 0x06, 0x01
+};
+
+const aes_uint128_t BS0 = { { 0x5555555555555555ULL, 0x5555555555555555ULL } };
+const aes_uint128_t BS1 = { { 0x3333333333333333ULL, 0x3333333333333333ULL } };
+const aes_uint128_t BS2 = { { 0x0f0f0f0f0f0f0f0fULL, 0x0f0f0f0f0f0f0f0fULL } };

data/vendor/libsodium/src/libsodium/crypto_stream/aes128ctr/nacl/int128.h

@@ -0,0 +1,50 @@
+#ifndef aes128ctr_nacl_int128_H
+#define aes128ctr_nacl_int128_H
+
+#include <stdint.h>
+
+#include "common.h"
+
+typedef union {
+    uint64_t u64[2];
+    uint32_t u32[4];
+    uint8_t  u8[16];
+} aes_uint128_t;
+
+#define xor2 crypto_stream_aes128ctr_nacl_xor2
+void xor2(aes_uint128_t *r, const aes_uint128_t *x);
+
+#define and2 crypto_stream_aes128ctr_nacl_and2
+void and2(aes_uint128_t *r, const aes_uint128_t *x);
+
+#define or2 crypto_stream_aes128ctr_nacl_or2
+void or2(aes_uint128_t *r, const aes_uint128_t *x);
+
+#define copy2 crypto_stream_aes128ctr_nacl_copy2
+void copy2(aes_uint128_t *r, const aes_uint128_t *x);
+
+#define shufb crypto_stream_aes128ctr_nacl_shufb
+void shufb(aes_uint128_t *r, const unsigned char *l);
+
+#define shufd crypto_stream_aes128ctr_nacl_shufd
+void shufd(aes_uint128_t *r, const aes_uint128_t *x, const unsigned int c);
+
+#define rshift32_littleendian crypto_stream_aes128ctr_nacl_rshift32_littleendian
+void rshift32_littleendian(aes_uint128_t *r, const unsigned int n);
+
+#define rshift64_littleendian crypto_stream_aes128ctr_nacl_rshift64_littleendian
+void rshift64_littleendian(aes_uint128_t *r, const unsigned int n);
+
+#define lshift64_littleendian crypto_stream_aes128ctr_nacl_lshift64_littleendian
+void lshift64_littleendian(aes_uint128_t *r, const unsigned int n);
+
+#define toggle crypto_stream_aes128ctr_nacl_toggle
+void toggle(aes_uint128_t *r);
+
+#define xor_rcon crypto_stream_aes128ctr_nacl_xor_rcon
+void xor_rcon(aes_uint128_t *r);
+
+#define add_uint32_big crypto_stream_aes128ctr_nacl_add_uint32_big
+void add_uint32_big(aes_uint128_t *r, uint32_t x);
+
+#endif

data/vendor/libsodium/src/libsodium/crypto_stream/aes128ctr/nacl/int128_aes128ctr.c

@@ -0,0 +1,149 @@
+#include <stdint.h>
+
+#include "common.h"
+#include "int128.h"
+
+void
+xor2(aes_uint128_t *r, const aes_uint128_t *x)
+{
+    r->u64[0] ^= x->u64[0];
+    r->u64[1] ^= x->u64[1];
+}
+
+void
+and2(aes_uint128_t *r, const aes_uint128_t *x)
+{
+    r->u64[0] &= x->u64[0];
+    r->u64[1] &= x->u64[1];
+}
+
+void
+or2(aes_uint128_t *r, const aes_uint128_t *x)
+{
+    r->u64[0] |= x->u64[0];
+    r->u64[1] |= x->u64[1];
+}
+
+void
+copy2(aes_uint128_t *r, const aes_uint128_t *x)
+{
+    r->u64[0] = x->u64[0];
+    r->u64[1] = x->u64[1];
+}
+
+void
+shufb(aes_uint128_t *r, const unsigned char *l)
+{
+    aes_uint128_t  t;
+    uint8_t       *ct;
+    uint8_t       *cr;
+
+    copy2(&t, r);
+    cr     = r->u8;
+    ct     = t.u8;
+    cr[0]  = ct[l[0]];
+    cr[1]  = ct[l[1]];
+    cr[2]  = ct[l[2]];
+    cr[3]  = ct[l[3]];
+    cr[4]  = ct[l[4]];
+    cr[5]  = ct[l[5]];
+    cr[6]  = ct[l[6]];
+    cr[7]  = ct[l[7]];
+    cr[8]  = ct[l[8]];
+    cr[9]  = ct[l[9]];
+    cr[10] = ct[l[10]];
+    cr[11] = ct[l[11]];
+    cr[12] = ct[l[12]];
+    cr[13] = ct[l[13]];
+    cr[14] = ct[l[14]];
+    cr[15] = ct[l[15]];
+}
+
+void
+shufd(aes_uint128_t *r, const aes_uint128_t *x, const unsigned int c)
+{
+    aes_uint128_t t;
+
+    t.u32[0] = x->u32[c >> 0 & 3];
+    t.u32[1] = x->u32[c >> 2 & 3];
+    t.u32[2] = x->u32[c >> 4 & 3];
+    t.u32[3] = x->u32[c >> 6 & 3];
+    copy2(r, &t);
+}
+
+void
+rshift32_littleendian(aes_uint128_t *r, const unsigned int n)
+{
+    unsigned char *rp = (unsigned char *) r;
+    uint32_t       t;
+
+    t = LOAD32_LE(rp);
+    t >>= n;
+    STORE32_LE(rp, t);
+    t = LOAD32_LE(rp + 4);
+    t >>= n;
+    STORE32_LE(rp + 4, t);
+    t = LOAD32_LE(rp + 8);
+    t >>= n;
+    STORE32_LE(rp + 8, t);
+    t = LOAD32_LE(rp + 12);
+    t >>= n;
+    STORE32_LE(rp + 12, t);
+}
+
+void
+rshift64_littleendian(aes_uint128_t *r, const unsigned int n)
+{
+    unsigned char *rp = (unsigned char *) r;
+    uint64_t       t;
+
+    t = LOAD64_LE(rp);
+    t >>= n;
+    STORE64_LE(rp, t);
+    t = LOAD64_LE(rp + 8);
+    t >>= n;
+    STORE64_LE(rp + 8, t);
+}
+
+void
+lshift64_littleendian(aes_uint128_t *r, const unsigned int n)
+{
+    unsigned char *rp = (unsigned char *) r;
+    uint64_t       t;
+
+    t = LOAD64_LE(rp);
+    t <<= n;
+    STORE64_LE(rp, t);
+    t = LOAD64_LE(rp + 8);
+    t <<= n;
+    STORE64_LE(rp + 8, t);
+}
+
+void
+toggle(aes_uint128_t *r)
+{
+    r->u64[0] ^= 0xffffffffffffffffULL;
+    r->u64[1] ^= 0xffffffffffffffffULL;
+}
+
+void
+xor_rcon(aes_uint128_t *r)
+{
+    unsigned char *rp = (unsigned char *) r;
+    uint32_t       t;
+
+    t = LOAD32_LE(rp + 12);
+    t ^= 0xffffffff;
+    STORE32_LE(rp + 12, t);
+}
+
+void
+add_uint32_big(aes_uint128_t *r, uint32_t x)
+{
+    unsigned char *rp = (unsigned char *) r;
+    uint32_t       t;
+
+    t = LOAD32_LE(rp + 12);
+    t += x;
+    STORE32_LE(rp + 12, t);
+}

data/vendor/libsodium/src/libsodium/crypto_stream/aes128ctr/nacl/stream_aes128ctr_nacl.c

@@ -0,0 +1,31 @@
+
+#include "crypto_stream_aes128ctr.h"
+
+#ifdef __GNUC__
+# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
+int
+crypto_stream_aes128ctr(unsigned char *out, unsigned long long outlen,
+                        const unsigned char *n, const unsigned char *k)
+{
+    unsigned char d[crypto_stream_aes128ctr_BEFORENMBYTES];
+
+    crypto_stream_aes128ctr_beforenm(d, k);
+    crypto_stream_aes128ctr_afternm(out, outlen, n, d);
+
+    return 0;
+}
+
+int
+crypto_stream_aes128ctr_xor(unsigned char *out, const unsigned char *in,
+                            unsigned long long inlen, const unsigned char *n,
+                            const unsigned char *k)
+{
+    unsigned char d[crypto_stream_aes128ctr_BEFORENMBYTES];
+
+    crypto_stream_aes128ctr_beforenm(d, k);
+    crypto_stream_aes128ctr_xor_afternm(out, in, inlen, n, d);
+
+    return 0;
+}

data/vendor/libsodium/src/libsodium/crypto_stream/aes128ctr/nacl/xor_afternm_aes128ctr.c

@@ -0,0 +1,195 @@
+/* Author: Peter Schwabe, ported from an assembly implementation by Emilia
+ * Käsper
+ * Date: 2009-03-19
+ * Public domain */
+
+#include "common.h"
+#include "consts.h"
+#include "crypto_stream_aes128ctr.h"
+#include "int128.h"
+
+int
+crypto_stream_aes128ctr_xor_afternm(unsigned char *out, const unsigned char *in,
+                                    unsigned long long   len,
+                                    const unsigned char *nonce,
+                                    const unsigned char *c)
+{
+    aes_uint128_t      xmm0;
+    aes_uint128_t      xmm1;
+    aes_uint128_t      xmm2;
+    aes_uint128_t      xmm3;
+    aes_uint128_t      xmm4;
+    aes_uint128_t      xmm5;
+    aes_uint128_t      xmm6;
+    aes_uint128_t      xmm7;
+    aes_uint128_t      xmm8;
+    aes_uint128_t      xmm9;
+    aes_uint128_t      xmm10;
+    aes_uint128_t      xmm11;
+    aes_uint128_t      xmm12;
+    aes_uint128_t      xmm13;
+    aes_uint128_t      xmm14;
+    aes_uint128_t      xmm15;
+    aes_uint128_t      nonce_stack;
+    unsigned long long lensav;
+    unsigned char      bl[128];
+    unsigned char     *blp;
+    unsigned char     *np;
+    unsigned char      b;
+    uint32_t           tmp;
+
+    /* Copy nonce on the stack */
+    copy2(&nonce_stack, (const aes_uint128_t *) (nonce + 0));
+    np = (unsigned char *) &nonce_stack;
+
+enc_block:
+
+    xmm0 = *(aes_uint128_t *) (np + 0);
+    copy2(&xmm1, &xmm0);
+    shufb(&xmm1, SWAP32);
+    copy2(&xmm2, &xmm1);
+    copy2(&xmm3, &xmm1);
+    copy2(&xmm4, &xmm1);
+    copy2(&xmm5, &xmm1);
+    copy2(&xmm6, &xmm1);
+    copy2(&xmm7, &xmm1);
+
+    add_uint32_big(&xmm1, 1);
+    add_uint32_big(&xmm2, 2);
+    add_uint32_big(&xmm3, 3);
+    add_uint32_big(&xmm4, 4);
+    add_uint32_big(&xmm5, 5);
+    add_uint32_big(&xmm6, 6);
+    add_uint32_big(&xmm7, 7);
+
+    shufb(&xmm0, M0);
+    shufb(&xmm1, M0SWAP);
+    shufb(&xmm2, M0SWAP);
+    shufb(&xmm3, M0SWAP);
+    shufb(&xmm4, M0SWAP);
+    shufb(&xmm5, M0SWAP);
+    shufb(&xmm6, M0SWAP);
+    shufb(&xmm7, M0SWAP);
+
+    bitslice(xmm7, xmm6, xmm5, xmm4, xmm3, xmm2, xmm1, xmm0, xmm8);
+
+    aesround(1, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9,
+             xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, c);
+    aesround(2, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0,
+             xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, c);
+    aesround(3, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9,
+             xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, c);
+    aesround(4, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0,
+             xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, c);
+    aesround(5, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9,
+             xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, c);
+    aesround(6, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0,
+             xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, c);
+    aesround(7, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9,
+             xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, c);
+    aesround(8, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0,
+             xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, c);
+    aesround(9, xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9,
+             xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, c);
+    lastround(xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15, xmm0, xmm1,
+              xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, c);
+
+    bitslice(xmm13, xmm10, xmm15, xmm11, xmm14, xmm12, xmm9, xmm8, xmm0);
+
+    if (len < 128) {
+        goto partial;
+    }
+    if (len == 128) {
+        goto full;
+    }
+    tmp = LOAD32_BE(np + 12);
+    tmp += 8;
+    STORE32_BE(np + 12, tmp);
+
+    xor2(&xmm8, (const aes_uint128_t *) (in + 0));
+    xor2(&xmm9, (const aes_uint128_t *) (in + 16));
+    xor2(&xmm12, (const aes_uint128_t *) (in + 32));
+    xor2(&xmm14, (const aes_uint128_t *) (in + 48));
+    xor2(&xmm11, (const aes_uint128_t *) (in + 64));
+    xor2(&xmm15, (const aes_uint128_t *) (in + 80));
+    xor2(&xmm10, (const aes_uint128_t *) (in + 96));
+    xor2(&xmm13, (const aes_uint128_t *) (in + 112));
+
+    *(aes_uint128_t *) (out + 0)   = xmm8;
+    *(aes_uint128_t *) (out + 16)  = xmm9;
+    *(aes_uint128_t *) (out + 32)  = xmm12;
+    *(aes_uint128_t *) (out + 48)  = xmm14;
+    *(aes_uint128_t *) (out + 64)  = xmm11;
+    *(aes_uint128_t *) (out + 80)  = xmm15;
+    *(aes_uint128_t *) (out + 96)  = xmm10;
+    *(aes_uint128_t *) (out + 112) = xmm13;
+
+    len -= 128;
+    in += 128;
+    out += 128;
+
+    goto enc_block;
+
+partial:
+
+    lensav = len;
+    len >>= 4;
+
+    tmp = LOAD32_BE(np + 12);
+    tmp += len;
+    STORE32_BE(np + 12, tmp);
+
+    blp = bl;
+
+    *(aes_uint128_t *) (blp + 0)   = xmm8;
+    *(aes_uint128_t *) (blp + 16)  = xmm9;
+    *(aes_uint128_t *) (blp + 32)  = xmm12;
+    *(aes_uint128_t *) (blp + 48)  = xmm14;
+    *(aes_uint128_t *) (blp + 64)  = xmm11;
+    *(aes_uint128_t *) (blp + 80)  = xmm15;
+    *(aes_uint128_t *) (blp + 96)  = xmm10;
+    *(aes_uint128_t *) (blp + 112) = xmm13;
+
+bytes:
+
+    if (lensav == 0) {
+        goto end;
+    }
+    b = blp[0]; /* clang false positive */
+    b ^= *(const unsigned char *) (in + 0);
+    *(unsigned char *) (out + 0) = b;
+
+    blp += 1;
+    in += 1;
+    out += 1;
+    lensav -= 1;
+
+    goto bytes;
+
+full:
+
+    tmp = LOAD32_BE(np + 12);
+    tmp += 8;
+    STORE32_BE(np + 12, tmp);
+
+    xor2(&xmm8, (const aes_uint128_t *) (in + 0));
+    xor2(&xmm9, (const aes_uint128_t *) (in + 16));
+    xor2(&xmm12, (const aes_uint128_t *) (in + 32));
+    xor2(&xmm14, (const aes_uint128_t *) (in + 48));
+    xor2(&xmm11, (const aes_uint128_t *) (in + 64));
+    xor2(&xmm15, (const aes_uint128_t *) (in + 80));
+    xor2(&xmm10, (const aes_uint128_t *) (in + 96));
+    xor2(&xmm13, (const aes_uint128_t *) (in + 112));
+
+    *(aes_uint128_t *) (out + 0)   = xmm8;
+    *(aes_uint128_t *) (out + 16)  = xmm9;
+    *(aes_uint128_t *) (out + 32)  = xmm12;
+    *(aes_uint128_t *) (out + 48)  = xmm14;
+    *(aes_uint128_t *) (out + 64)  = xmm11;
+    *(aes_uint128_t *) (out + 80)  = xmm15;
+    *(aes_uint128_t *) (out + 96)  = xmm10;
+    *(aes_uint128_t *) (out + 112) = xmm13;
+
+end:
+    return 0;
+}