ruby_olm 0.1.1

data/ext/ruby_olm/ext_lib_olm/olm/lib/curve25519-donna/python-src/curve25519/curve25519module.c

@@ -0,0 +1,105 @@
+/* tell python that PyArg_ParseTuple(t#) means Py_ssize_t, not int */
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#if (PY_VERSION_HEX < 0x02050000)
+	typedef int Py_ssize_t;
+#endif
+
+/* This is required for compatibility with Python 2. */
+#if PY_MAJOR_VERSION >= 3
+	#include <bytesobject.h> 
+	#define y "y"
+#else
+	#define PyBytes_FromStringAndSize PyString_FromStringAndSize
+	#define y "t"
+#endif
+
+int curve25519_donna(char *mypublic, 
+                     const char *secret, const char *basepoint);
+
+static PyObject *
+pycurve25519_makeprivate(PyObject *self, PyObject *args)
+{
+    char *in1;
+    Py_ssize_t in1len;
+    if (!PyArg_ParseTuple(args, y"#:clamp", &in1, &in1len))
+        return NULL;
+    if (in1len != 32) {
+        PyErr_SetString(PyExc_ValueError, "input must be 32-byte string");
+        return NULL;
+    }
+    in1[0] &= 248;
+    in1[31] &= 127;
+    in1[31] |= 64;
+    return PyBytes_FromStringAndSize((char *)in1, 32);
+}
+
+static PyObject *
+pycurve25519_makepublic(PyObject *self, PyObject *args)
+{
+    const char *private;
+    char mypublic[32];
+    char basepoint[32] = {9};
+    Py_ssize_t privatelen;
+    if (!PyArg_ParseTuple(args, y"#:makepublic", &private, &privatelen))
+        return NULL;
+    if (privatelen != 32) {
+        PyErr_SetString(PyExc_ValueError, "input must be 32-byte string");
+        return NULL;
+    }
+    curve25519_donna(mypublic, private, basepoint);
+    return PyBytes_FromStringAndSize((char *)mypublic, 32);
+}
+
+static PyObject *
+pycurve25519_makeshared(PyObject *self, PyObject *args)
+{
+    const char *myprivate, *theirpublic;
+    char shared_key[32];
+    Py_ssize_t myprivatelen, theirpubliclen;
+    if (!PyArg_ParseTuple(args, y"#"y"#:generate",
+                          &myprivate, &myprivatelen, &theirpublic, &theirpubliclen))
+        return NULL;
+    if (myprivatelen != 32) {
+        PyErr_SetString(PyExc_ValueError, "input must be 32-byte string");
+        return NULL;
+    }
+    if (theirpubliclen != 32) {
+        PyErr_SetString(PyExc_ValueError, "input must be 32-byte string");
+        return NULL;
+    }
+    curve25519_donna(shared_key, myprivate, theirpublic);
+    return PyBytes_FromStringAndSize((char *)shared_key, 32);
+}
+
+
+static PyMethodDef
+curve25519_functions[] = {
+    {"make_private", pycurve25519_makeprivate, METH_VARARGS, "data->private"},
+    {"make_public", pycurve25519_makepublic, METH_VARARGS, "private->public"},
+    {"make_shared", pycurve25519_makeshared, METH_VARARGS, "private+public->shared"},
+    {NULL, NULL, 0, NULL},
+};
+
+#if PY_MAJOR_VERSION >= 3
+    static struct PyModuleDef
+    curve25519_module = {
+        PyModuleDef_HEAD_INIT,
+        "_curve25519",
+        NULL,
+        NULL,
+        curve25519_functions,
+    };
+
+    PyObject *
+    PyInit__curve25519(void)
+    {
+        return PyModule_Create(&curve25519_module);
+    }
+#else
+    PyMODINIT_FUNC
+    init_curve25519(void)
+    {
+          (void)Py_InitModule("_curve25519", curve25519_functions);
+    }
+#endif

data/ext/ruby_olm/ext_lib_olm/olm/lib/curve25519-donna/speed-curve25519.c

@@ -0,0 +1,50 @@
+#include <stdio.h>
+#include <string.h>
+#include <sys/time.h>
+#include <time.h>
+#include <stdint.h>
+
+typedef uint8_t u8;
+
+extern void curve25519_donna(u8 *output, const u8 *secret, const u8 *bp);
+
+static uint64_t
+time_now() {
+  struct timeval tv;
+  uint64_t ret;
+
+  gettimeofday(&tv, NULL);
+  ret = tv.tv_sec;
+  ret *= 1000000;
+  ret += tv.tv_usec;
+
+  return ret;
+}
+
+int
+main() {
+  static const unsigned char basepoint[32] = {9};
+  unsigned char mysecret[32], mypublic[32];
+  unsigned i;
+  uint64_t start, end;
+
+  memset(mysecret, 42, 32);
+  mysecret[0] &= 248;
+  mysecret[31] &= 127;
+  mysecret[31] |= 64;
+
+  // Load the caches
+  for (i = 0; i < 1000; ++i) {
+    curve25519_donna(mypublic, mysecret, basepoint);
+  }
+
+  start = time_now();
+  for (i = 0; i < 30000; ++i) {
+    curve25519_donna(mypublic, mysecret, basepoint);
+  }
+  end = time_now();
+
+  printf("%luus\n", (unsigned long) ((end - start) / 30000));
+
+  return 0;
+}

data/ext/ruby_olm/ext_lib_olm/olm/lib/curve25519-donna/test-curve25519.c

@@ -0,0 +1,54 @@
+/*
+test-curve25519 version 20050915
+D. J. Bernstein
+Public domain.
+
+Tiny modifications by agl
+*/
+
+#include <stdio.h>
+
+extern void curve25519_donna(unsigned char *output, const unsigned char *a,
+                             const unsigned char *b);
+void doit(unsigned char *ek,unsigned char *e,unsigned char *k);
+
+void doit(unsigned char *ek,unsigned char *e,unsigned char *k)
+{
+  int i;
+
+  for (i = 0;i < 32;++i) printf("%02x",(unsigned int) e[i]); printf(" ");
+  for (i = 0;i < 32;++i) printf("%02x",(unsigned int) k[i]); printf(" ");
+  curve25519_donna(ek,e,k);
+  for (i = 0;i < 32;++i) printf("%02x",(unsigned int) ek[i]); printf("\n");
+}
+
+unsigned char e1k[32];
+unsigned char e2k[32];
+unsigned char e1e2k[32];
+unsigned char e2e1k[32];
+unsigned char e1[32] = {3};
+unsigned char e2[32] = {5};
+unsigned char k[32] = {9};
+
+int
+main()
+{
+  int loop;
+  int i;
+
+  for (loop = 0;loop < 10000;++loop) {
+    doit(e1k,e1,k);
+    doit(e2e1k,e2,e1k);
+    doit(e2k,e2,k);
+    doit(e1e2k,e1,e2k);
+    for (i = 0;i < 32;++i) if (e1e2k[i] != e2e1k[i]) {
+      printf("fail\n");
+      return 1;
+    }
+    for (i = 0;i < 32;++i) e1[i] ^= e2k[i];
+    for (i = 0;i < 32;++i) e2[i] ^= e1k[i];
+    for (i = 0;i < 32;++i) k[i] ^= e1e2k[i];
+  }
+
+  return 0;
+}

data/ext/ruby_olm/ext_lib_olm/olm/lib/curve25519-donna/test-noncanon.c

@@ -0,0 +1,39 @@
+/* This file can be used to test whether the code handles non-canonical curve
+ * points (i.e. points with the 256th bit set) in the same way as the reference
+ * implementation. */
+
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+extern void curve25519_donna(unsigned char *output, const unsigned char *a,
+                             const unsigned char *b);
+int
+main()
+{
+  static const uint8_t point1[32] = {
+    0x25,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+  };
+  static const uint8_t point2[32] = {
+    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+    0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
+  };
+  static const uint8_t scalar[32] = { 1 };
+  uint8_t out1[32], out2[32];
+
+  curve25519_donna(out1, scalar, point1);
+  curve25519_donna(out2, scalar, point2);
+
+  if (0 == memcmp(out1, out2, sizeof(out1))) {
+    fprintf(stderr, "Top bit not ignored.\n");
+    return 1;
+  }
+
+  fprintf(stderr, "Top bit correctly ignored.\n");
+  return 0;
+}

data/ext/ruby_olm/ext_lib_olm/olm/lib/curve25519-donna/test-sc-curve25519.c

@@ -0,0 +1,72 @@
+#define _GNU_SOURCE
+
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#include <math.h>
+
+extern void curve25519_donna(uint8_t *, const uint8_t *, const uint8_t *);
+extern uint64_t tsc_read();
+
+int
+main(int argc, char **argv) {
+  uint8_t private_key[32], public[32], peer1[32], peer2[32], output[32];
+  static const uint8_t basepoint[32] = {9};
+  unsigned i;
+  uint64_t sum = 0, sum_squares = 0, skipped = 0, mean;
+  static const unsigned count = 200000;
+
+  memset(private_key, 42, sizeof(private_key));
+
+  private_key[0] &= 248;
+  private_key[31] &= 127;
+  private_key[31] |= 64;
+
+  curve25519_donna(public, private_key, basepoint);
+  memset(peer1, 0, sizeof(peer1));
+  memset(peer2, 255, sizeof(peer2));
+
+  for (i = 0; i < count; ++i) {
+    const uint64_t start = tsc_read();
+    curve25519_donna(output, peer1, public);
+    const uint64_t end = tsc_read();
+    const uint64_t delta = end - start;
+    if (delta > 650000) {
+      // something terrible happened (task switch etc)
+      skipped++;
+      continue;
+    }
+    sum += delta;
+    sum_squares += (delta * delta);
+  }
+
+  mean = sum / ((uint64_t) count);
+  printf("all 0: mean:%lu sd:%f skipped:%lu\n",
+         mean,
+         sqrt((double)(sum_squares/((uint64_t) count) - mean*mean)),
+         skipped);
+
+  sum = sum_squares = skipped = 0;
+
+  for (i = 0; i < count; ++i) {
+    const uint64_t start = tsc_read();
+    curve25519_donna(output, peer2, public);
+    const uint64_t end = tsc_read();
+    const uint64_t delta = end - start;
+    if (delta > 650000) {
+      // something terrible happened (task switch etc)
+      skipped++;
+      continue;
+    }
+    sum += delta;
+    sum_squares += (delta * delta);
+  }
+
+  mean = sum / ((uint64_t) count);
+  printf("all 1: mean:%lu sd:%f skipped:%lu\n",
+         mean,
+         sqrt((double)(sum_squares/((uint64_t) count) - mean*mean)),
+         skipped);
+
+  return 0;
+}

data/ext/ruby_olm/ext_lib_olm/olm/lib/curve25519-donna.h

@@ -0,0 +1,18 @@
+/* header file for the curve25519-donna implementation, because the
+ * authors of that project don't supply one.
+ */
+#ifndef CURVE25519_DONNA_H
+#define CURVE25519_DONNA_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int curve25519_donna(unsigned char *output, const unsigned char *a,
+                            const unsigned char *b);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/ruby_olm/ext_lib_olm/olm/lib/ed25519/src/add_scalar.c

@@ -0,0 +1,56 @@
+#include "ed25519.h"
+#include "ge.h"
+#include "sc.h"
+
+
+/* see http://crypto.stackexchange.com/a/6215/4697 */
+void ed25519_add_scalar(unsigned char *public_key, unsigned char *private_key, const unsigned char *scalar) {
+    const unsigned char SC_1[32] = {1}; /* scalar with value 1 */
+    
+    unsigned char n[32]; 
+    ge_p3 nB;
+    ge_p1p1 A_p1p1;
+    ge_p3 A;
+    ge_p3 public_key_unpacked;
+    ge_cached T;
+
+    int i;
+
+    /* copy the scalar and clear highest bit */
+    for (i = 0; i < 31; ++i) {
+        n[i] = scalar[i];
+    }
+    n[31] = scalar[31] & 127;
+
+    /* private key: a = n + t */
+    if (private_key) {
+        sc_muladd(private_key, SC_1, n, private_key);
+    }
+
+    /* public key: A = nB + T */
+    if (public_key) {
+        /* if we know the private key we don't need a point addition, which is faster */
+        /* using a "timing attack" you could find out wether or not we know the private
+           key, but this information seems rather useless - if this is important pass
+           public_key and private_key seperately in 2 function calls */
+        if (private_key) {
+            ge_scalarmult_base(&A, private_key);
+        } else {
+            /* unpack public key into T */
+            ge_frombytes_negate_vartime(&public_key_unpacked, public_key);
+            fe_neg(public_key_unpacked.X, public_key_unpacked.X); /* undo negate */
+            fe_neg(public_key_unpacked.T, public_key_unpacked.T); /* undo negate */
+            ge_p3_to_cached(&T, &public_key_unpacked);
+
+            /* calculate n*B */
+            ge_scalarmult_base(&nB, n);
+
+            /* A = n*B + T */
+            ge_add(&A_p1p1, &nB, &T);
+            ge_p1p1_to_p3(&A, &A_p1p1);
+        }
+            
+        /* pack public key */
+        ge_p3_tobytes(public_key, &A);
+    }
+}

data/ext/ruby_olm/ext_lib_olm/olm/lib/ed25519/src/ed25519.h

@@ -0,0 +1,38 @@
+#ifndef ED25519_H
+#define ED25519_H
+
+#include <stddef.h>
+
+#if defined(_WIN32)
+    #if defined(ED25519_BUILD_DLL)
+        #define ED25519_DECLSPEC __declspec(dllexport)
+    #elif defined(ED25519_DLL)
+        #define ED25519_DECLSPEC __declspec(dllimport)
+    #else
+        #define ED25519_DECLSPEC
+    #endif
+#else
+    #define ED25519_DECLSPEC
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef ED25519_NO_SEED
+int ED25519_DECLSPEC ed25519_create_seed(unsigned char *seed);
+#endif
+
+void ED25519_DECLSPEC ed25519_create_keypair(unsigned char *public_key, unsigned char *private_key, const unsigned char *seed);
+void ED25519_DECLSPEC ed25519_sign(unsigned char *signature, const unsigned char *message, size_t message_len, const unsigned char *public_key, const unsigned char *private_key);
+int ED25519_DECLSPEC ed25519_verify(const unsigned char *signature, const unsigned char *message, size_t message_len, const unsigned char *public_key);
+void ED25519_DECLSPEC ed25519_add_scalar(unsigned char *public_key, unsigned char *private_key, const unsigned char *scalar);
+void ED25519_DECLSPEC ed25519_key_exchange(unsigned char *shared_secret, const unsigned char *public_key, const unsigned char *private_key);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif