ruby_nacl 0.1.0

data/ext/ruby_nacl/NaCl/curvecp/safenonce.c

@@ -0,0 +1,74 @@
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include "crypto_uint64.h"
+#include "uint64_pack.h"
+#include "uint64_unpack.h"
+#include "savesync.h"
+#include "open.h"
+#include "load.h"
+#include "randombytes.h"
+#include "safenonce.h"
+
+#include "crypto_block.h"
+#if crypto_block_BYTES != 16
+error!
+#endif
+#if crypto_block_KEYBYTES != 32
+error!
+#endif
+
+/*
+Output: 128-bit nonce y[0],...,y[15].
+Reads and writes existing 8-byte file ".expertsonly/noncecounter",
+locked via existing 1-byte file ".expertsonly/lock".
+Also reads existing 32-byte file ".expertsonly/noncekey".
+Not thread-safe.
+
+Invariants:
+This process is free to use counters that are >=counterlow and <counterhigh.
+The 8-byte file contains a counter that is safe to use and >=counterhigh.
+
+XXX: should rewrite file in background, rather than briefly pausing
+*/
+
+static crypto_uint64 counterlow = 0;
+static crypto_uint64 counterhigh = 0;
+
+static unsigned char flagkeyloaded = 0;
+static unsigned char noncekey[32];
+static unsigned char data[16];
+
+int safenonce(unsigned char *y,int flaglongterm)
+{
+  if (!flagkeyloaded) {
+    int fdlock;
+    fdlock = open_lock(".expertsonly/lock");
+    if (fdlock == -1) return -1;
+    if (load(".expertsonly/noncekey",noncekey,sizeof noncekey) == -1) { close(fdlock); return -1; }
+    close(fdlock);
+    flagkeyloaded = 1;
+  }
+  
+  if (counterlow >= counterhigh) {
+    int fdlock;
+    fdlock = open_lock(".expertsonly/lock");
+    if (fdlock == -1) return -1;
+    if (load(".expertsonly/noncecounter",data,8) == -1) { close(fdlock); return -1; }
+    counterlow = uint64_unpack(data);
+    if (flaglongterm)
+      counterhigh = counterlow + 1048576;
+    else
+      counterhigh = counterlow + 1;
+    uint64_pack(data,counterhigh);
+    if (savesync(".expertsonly/noncecounter",data,8) == -1) { close(fdlock); return -1; }
+    close(fdlock);
+  }
+
+  randombytes(data + 8,8);
+  uint64_pack(data,counterlow++);
+  crypto_block(y,data,noncekey);
+  
+  return 0;
+}

data/ext/ruby_nacl/NaCl/curvecp/safenonce.h

@@ -0,0 +1,6 @@
+#ifndef SAFENONCE_H
+#define SAFENONCE_H
+
+extern int safenonce(unsigned char *,int);
+
+#endif

data/ext/ruby_nacl/NaCl/curvecp/savesync.c

@@ -0,0 +1,24 @@
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include "open.h"
+#include "savesync.h"
+#include "writeall.h"
+
+static int writesync(int fd,const void *x,long long xlen)
+{
+  if (writeall(fd,x,xlen) == -1) return -1;
+  return fsync(fd);
+}
+
+int savesync(const char *fn,const void *x,long long xlen)
+{
+  int fd;
+  int r;
+  fd = open_write(fn);
+  if (fd == -1) return -1;
+  r = writesync(fd,x,xlen);
+  close(fd);
+  return r;
+}

data/ext/ruby_nacl/NaCl/curvecp/savesync.h

@@ -0,0 +1,6 @@
+#ifndef SAVESYNC_H
+#define SAVESYNC_H
+
+extern int savesync(const char *,const void *,long long);
+
+#endif

data/ext/ruby_nacl/NaCl/curvecp/socket.h

@@ -0,0 +1,9 @@
+#ifndef SOCKET_H
+#define SOCKET_H
+
+extern int socket_udp(void);
+extern int socket_bind(int,const unsigned char *,const unsigned char *);
+extern int socket_send(int,const unsigned char *,long long,const unsigned char *,const unsigned char *);
+extern long long socket_recv(int,unsigned char *,long long,unsigned char *,unsigned char *);
+
+#endif

data/ext/ruby_nacl/NaCl/curvecp/socket_bind.c

@@ -0,0 +1,15 @@
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <errno.h>
+#include "socket.h"
+#include "byte.h"
+
+int socket_bind(int fd,const unsigned char *ip,const unsigned char *port)
+{
+  struct sockaddr_in sa;
+  byte_zero(&sa,sizeof sa);
+  byte_copy(&sa.sin_addr,4,ip);
+  byte_copy(&sa.sin_port,2,port);
+  return bind(fd,(struct sockaddr *) &sa,sizeof sa);
+}

data/ext/ruby_nacl/NaCl/curvecp/socket_recv.c

@@ -0,0 +1,23 @@
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <errno.h>
+#include "socket.h"
+#include "byte.h"
+
+long long socket_recv(int fd,unsigned char *x,long long xlen,unsigned char *ip,unsigned char *port)
+{
+  struct sockaddr_in sa;
+  socklen_t salen;
+  int r;
+
+  if (xlen < 0) { errno = EPROTO; return -1; }
+  if (xlen > 1048576) xlen = 1048576;
+
+  byte_zero(&sa,sizeof sa);
+  salen = sizeof sa;
+  r = recvfrom(fd,x,xlen,0,(struct sockaddr *) &sa,&salen);
+  byte_copy(ip,4,&sa.sin_addr);
+  byte_copy(port,2,&sa.sin_port);
+  return r;
+}

data/ext/ruby_nacl/NaCl/curvecp/socket_send.c

@@ -0,0 +1,19 @@
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <errno.h>
+#include "socket.h"
+#include "byte.h"
+
+int socket_send(int fd,const unsigned char *x,long long xlen,const unsigned char *ip,const unsigned char *port)
+{
+  struct sockaddr_in sa;
+
+  if (xlen < 0 || xlen > 1048576) { errno = EPROTO; return -1; }
+
+  byte_zero(&sa,sizeof sa);
+  sa.sin_family = AF_INET;
+  byte_copy(&sa.sin_addr,4,ip);
+  byte_copy(&sa.sin_port,2,port);
+  return sendto(fd,x,xlen,0,(struct sockaddr *) &sa,sizeof sa);
+}

data/ext/ruby_nacl/NaCl/curvecp/socket_udp.c

@@ -0,0 +1,36 @@
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include "socket.h"
+#include "blocking.h"
+
+static void enable_bsd_fragmentation(int fd)
+{
+#ifdef IP_DONTFRAG
+  const int x = 0;
+  setsockopt(fd,SOL_IP,IP_DONTFRAG,&x,sizeof x);
+#endif
+}
+
+static void enable_linux_fragmentation(int fd)
+{
+#ifdef IP_MTU_DISCOVER
+#ifdef IP_PMTUDISC_DONT
+  const int x = IP_PMTUDISC_DONT;
+  setsockopt(fd,SOL_IP,IP_MTU_DISCOVER,&x,sizeof x);
+#endif
+#endif
+}
+
+int socket_udp(void)
+{
+  int fd = socket(PF_INET,SOCK_DGRAM,0);
+  if (fd == -1) return -1;
+  fcntl(fd,F_SETFD,1);
+  blocking_disable(fd);
+  enable_bsd_fragmentation(fd);
+  enable_linux_fragmentation(fd);
+  return fd;
+}

data/ext/ruby_nacl/NaCl/curvecp/uint16_pack.c

@@ -0,0 +1,7 @@
+#include "uint16_pack.h"
+
+void uint16_pack(unsigned char *y,crypto_uint16 x)
+{
+  *y++ = x; x >>= 8;
+  *y++ = x; x >>= 8;
+}

data/ext/ruby_nacl/NaCl/curvecp/uint16_pack.h

@@ -0,0 +1,8 @@
+#ifndef UINT16_PACK_H
+#define UINT16_PACK_H
+
+#include "crypto_uint16.h"
+
+extern void uint16_pack(unsigned char *,crypto_uint16);
+
+#endif

data/ext/ruby_nacl/NaCl/curvecp/uint16_unpack.c

@@ -0,0 +1,9 @@
+#include "uint16_unpack.h"
+
+crypto_uint16 uint16_unpack(const unsigned char *x)
+{
+  crypto_uint16 result;
+  result = x[1];
+  result <<= 8; result |= x[0];
+  return result;
+}

data/ext/ruby_nacl/NaCl/curvecp/uint16_unpack.h

@@ -0,0 +1,8 @@
+#ifndef UINT16_UNPACK_H
+#define UINT16_UNPACK_H
+
+#include "crypto_uint16.h"
+
+extern crypto_uint16 uint16_unpack(const unsigned char *);
+
+#endif

data/ext/ruby_nacl/NaCl/curvecp/uint32_pack.c

@@ -0,0 +1,9 @@
+#include "uint32_pack.h"
+
+void uint32_pack(unsigned char *y,crypto_uint32 x)
+{
+  *y++ = x; x >>= 8;
+  *y++ = x; x >>= 8;
+  *y++ = x; x >>= 8;
+  *y++ = x; x >>= 8;
+}

data/ext/ruby_nacl/NaCl/curvecp/uint32_pack.h

@@ -0,0 +1,8 @@
+#ifndef UINT32_PACK_H
+#define UINT32_PACK_H
+
+#include "crypto_uint32.h"
+
+extern void uint32_pack(unsigned char *,crypto_uint32);
+
+#endif

data/ext/ruby_nacl/NaCl/curvecp/uint32_unpack.c

@@ -0,0 +1,11 @@
+#include "uint32_unpack.h"
+
+crypto_uint32 uint32_unpack(const unsigned char *x)
+{
+  crypto_uint32 result;
+  result = x[3];
+  result <<= 8; result |= x[2];
+  result <<= 8; result |= x[1];
+  result <<= 8; result |= x[0];
+  return result;
+}

data/ext/ruby_nacl/NaCl/curvecp/uint32_unpack.h

@@ -0,0 +1,8 @@
+#ifndef UINT32_UNPACK_H
+#define UINT32_UNPACK_H
+
+#include "crypto_uint32.h"
+
+extern crypto_uint32 uint32_unpack(const unsigned char *);
+
+#endif

data/ext/ruby_nacl/NaCl/curvecp/uint64_pack.c

@@ -0,0 +1,13 @@
+#include "uint64_pack.h"
+
+void uint64_pack(unsigned char *y,crypto_uint64 x)
+{
+  *y++ = x; x >>= 8;
+  *y++ = x; x >>= 8;
+  *y++ = x; x >>= 8;
+  *y++ = x; x >>= 8;
+  *y++ = x; x >>= 8;
+  *y++ = x; x >>= 8;
+  *y++ = x; x >>= 8;
+  *y++ = x; x >>= 8;
+}

data/ext/ruby_nacl/NaCl/curvecp/uint64_pack.h

@@ -0,0 +1,8 @@
+#ifndef UINT64_PACK_H
+#define UINT64_PACK_H
+
+#include "crypto_uint64.h"
+
+extern void uint64_pack(unsigned char *,crypto_uint64);
+
+#endif

data/ext/ruby_nacl/NaCl/curvecp/uint64_unpack.c

@@ -0,0 +1,15 @@
+#include "uint64_unpack.h"
+
+crypto_uint64 uint64_unpack(const unsigned char *x)
+{
+  crypto_uint64 result;
+  result = x[7];
+  result <<= 8; result |= x[6];
+  result <<= 8; result |= x[5];
+  result <<= 8; result |= x[4];
+  result <<= 8; result |= x[3];
+  result <<= 8; result |= x[2];
+  result <<= 8; result |= x[1];
+  result <<= 8; result |= x[0];
+  return result;
+}

data/ext/ruby_nacl/NaCl/curvecp/uint64_unpack.h

@@ -0,0 +1,8 @@
+#ifndef UINT64_UNPACK_H
+#define UINT64_UNPACK_H
+
+#include "crypto_uint64.h"
+
+extern crypto_uint64 uint64_unpack(const unsigned char *);
+
+#endif

data/ext/ruby_nacl/NaCl/curvecp/writeall.c

@@ -0,0 +1,27 @@
+#include <poll.h>
+#include <unistd.h>
+#include "e.h"
+#include "writeall.h"
+
+int writeall(int fd,const void *x,long long xlen)
+{
+  long long w;
+  while (xlen > 0) {
+    w = xlen;
+    if (w > 1048576) w = 1048576;
+    w = write(fd,x,w);
+    if (w < 0) {
+      if (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK) {
+        struct pollfd p;
+	p.fd = fd;
+	p.events = POLLOUT | POLLERR;
+	poll(&p,1,-1);
+        continue;
+      }
+      return -1;
+    }
+    x += w;
+    xlen -= w;
+  }
+  return 0;
+}

data/ext/ruby_nacl/NaCl/curvecp/writeall.h

@@ -0,0 +1,6 @@
+#ifndef WRITEALL_H
+#define WRITEALL_H
+
+extern int writeall(int,const void *,long long);
+
+#endif