iodine 0.1.21 → 0.2.0

data/ext/iodine/bscrypt.h

@@ -0,0 +1,49 @@
+/*
+(un)copyright: Boaz segev, 2016
+License: Public Domain except for any non-public-domain algorithms, which are
+subject to their own licenses.
+
+Feel free to copy, use and enjoy in accordance with to the license(s).
+*/
+#ifndef BSCRYPT
+/**
+The bscrypt library supplies some **basic** cryptographic functions.
+
+Read the README file for more details.
+
+All functions will be available using the prefix `bscrypt_`, i.e.:
+
+      char buffer[13] = {0};
+      bscrypt_base64_encode(buffer, "My String", 9);
+
+
+*/
+#define BSCRYPT "0.0.1"
+
+#include "bscrypt-common.h"
+#include "base64.h"
+#include "hex.h"
+#include "misc.h"
+#include "random.h"
+#include "sha1.h"
+#include "sha2.h"
+#include "siphash.h"
+#include "xor-crypt.h"
+
+#if defined(DEBUG) && DEBUG == 1
+#define bscrypt_test()                                                         \
+  {                                                                            \
+    bscrypt_test_sha1();                                                       \
+    bscrypt_test_sha2();                                                       \
+    bscrypt_test_base64();                                                     \
+    bscrypt_test_random();                                                     \
+    bscrypt_test_siphash();                                                    \
+  }
+#else
+#define bscrypt_test()                                                         \
+  fprintf(stderr,                                                              \
+          "Debug mode not enabled, define DEBUG as 1 in the compiler.\n");
+#endif
+
+/* end include gate */
+#endif

data/ext/iodine/extconf.rb

@@ -0,0 +1,41 @@
+require 'mkmf'
+
+def check_for_stdatomics
+  RbConfig::MAKEFILE_CONFIG['CC'] = $CC = ENV['CC'] if ENV['CC']
+  RbConfig::MAKEFILE_CONFIG['CPP'] = $CPP = ENV['CPP'] if ENV['CPP']
+  puts 'Missing support for atomic operations (support for C11) - is your compiler updated?' unless have_header('stdatomic.h')
+end
+
+abort 'Missing a Linux/Unix OS evented API (epoll/kqueue).' unless have_func('kevent') || have_func('epoll_ctl')
+
+if ENV['CC']
+  ENV['CPP'] ||= ENV['CC']
+  puts "detected user prefered compiler (#{ENV['CC']})."
+  check_for_stdatomics
+elsif find_executable('clang') && puts('testing clang for stdatomic support...').nil? && system("printf \"\#include <stdatomic.h>\nint main(void) {}\" | clang -include stdatomic.h -xc -o /dev/null -", out: '/dev/null')
+  $CC = ENV['CC'] = 'clang'
+  $CPP = ENV['CPP'] = 'clang'
+  puts "using clang compiler v. #{`clang -dumpversion`}."
+elsif find_executable('gcc-6')
+  $CC = ENV['CC'] = 'gcc-6'
+  $CPP = ENV['CPP'] = find_executable('g++-6') ? 'g++-6' : 'gcc-6'
+  puts 'using gcc-6 compiler.'
+elsif find_executable('gcc-5')
+  $CC = ENV['CC'] = 'gcc-5'
+  $CPP = ENV['CPP'] = find_executable('g++-5') ? 'g++-5' : 'gcc-5'
+  puts 'using gcc-5 compiler.'
+elsif find_executable('gcc-4.9')
+  $CC = ENV['CC'] = 'gcc-4.9'
+  $CPP = ENV['CPP'] = find_executable('g++-4.9') ? 'g++-4.9' : 'gcc-4.9'
+  puts 'using gcc-4.9 compiler.'
+else
+  check_for_stdatomics
+end
+
+$CFLAGS = '-std=c11 -O3 -Wall'
+RbConfig::MAKEFILE_CONFIG['CC'] = $CC = ENV['CC'] if ENV['CC']
+RbConfig::MAKEFILE_CONFIG['CPP'] = $CPP = ENV['CPP'] if ENV['CPP']
+
+# abort "Missing OpenSSL." unless have_library("ssl")
+
+create_makefile 'iodine/iodine'

data/ext/iodine/hex.c

@@ -0,0 +1,123 @@
+/*
+(un)copyright: Boaz segev, 2016
+License: Public Domain except for any non-public-domain algorithms, which are
+subject to their own licenses.
+
+Feel free to copy, use and enjoy in accordance with to the license(s).
+*/
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+#include "hex.h"
+#include <ctype.h>
+
+/* ***************************************************************************
+Hex Conversion
+*/
+
+/*
+#define hex2i(h) \
+  (((h) >= '0' && (h) <= '9') ? ((h) - '0') : (((h) | 32) - 'a' + 10))
+*/
+
+#define i2hex(hi) (((hi) < 10) ? ('0' + (hi)) : ('A' + ((hi)-10)))
+
+/* Credit to Jonathan Leffler for the idea */
+#define hex2i(c)                                                               \
+  (((c) >= '0' && (c) <= '9') ? ((c)-48) : (((c) >= 'a' && (c) <= 'f') ||      \
+                                            ((c) >= 'A' && (c) <= 'F'))        \
+                                               ? (((c) | 32) - 87)             \
+                                               : ({                            \
+                                                   return -1;                  \
+                                                   0;                          \
+                                                 }))
+
+/**
+Returns 1 if the string is HEX encoded (no non-valid hex values). Returns 0 if
+it isn't.
+*/
+int bscrypt_is_hex(const char *string, size_t length) {
+  // for (size_t i = 0; i < length; i++) {
+  //   if (isxdigit(string[i]) == 0)
+  //     return 0;
+  char c;
+  for (size_t i = 0; i < length; i++) {
+    c = string[i];
+    if ((!isspace(c)) &&
+        (c < '0' || c > 'z' ||
+         !((c >= 'a') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9'))))
+      return 0;
+  }
+  return 1;
+}
+/**
+This will convert the string (byte stream) to a Hex string. This is not
+cryptography, just conversion for pretty print.
+
+The target buffer MUST have enough room for the expected data. The expected
+data is double the length of the string + 1 byte for the NULL terminator
+byte.
+
+A NULL byte will be appended to the target buffer. The function will return
+the number of bytes written to the target buffer.
+
+Returns the number of bytes actually written to the target buffer (excluding
+the NULL terminator byte).
+*/
+int bscrypt_str2hex(char *target, const char *string, size_t length) {
+  if (!target)
+    return -1;
+  size_t i = length;
+  target[(length << 1) + 1] = 0;
+  // go in reverse, so that target could be same as string.
+  while (i) {
+    --i;
+    target[(i << 1) + 1] = i2hex(string[i] & 0x0F);
+    target[(i << 1)] = i2hex(((uint8_t *)string)[i] >> 4);
+  }
+  return (length << 1);
+}
+
+/**
+This will convert a Hex string to a byte string. This is not cryptography,
+just conversion for pretty print.
+
+The target buffer MUST have enough room for the expected data. The expected
+data is half the length of the Hex string + 1 byte for the NULL terminator
+byte.
+
+A NULL byte will be appended to the target buffer. The function will return
+the number of bytes written to the target buffer.
+
+If the target buffer is NULL, the encoded string will be destructively
+edited
+and the decoded data will be placed in the original string's buffer.
+
+Returns the number of bytes actually written to the target buffer (excluding
+the NULL terminator byte).
+*/
+int bscrypt_hex2str(char *target, char *hex, size_t length) {
+  if (!target)
+    target = hex;
+  size_t i = 0;
+  size_t written = 0;
+  while (i + 1 < length) {
+    if (isspace(hex[i])) {
+      ++i;
+      continue;
+    }
+    target[written] = (hex2i(hex[i]) << 4) | hex2i(hex[i + 1]);
+    ++written;
+    i += 2;
+  }
+  if (i < length && !isspace(hex[i])) {
+    target[written] = hex2i(hex[i + 1]);
+    ++written;
+  }
+
+  target[written] = 0;
+  return written;
+}
+
+#undef hex2i
+#undef i2hex

data/ext/iodine/hex.h

@@ -0,0 +1,70 @@
+/*
+(un)copyright: Boaz segev, 2016
+License: Public Domain except for any non-public-domain algorithms, which are
+subject to their own licenses.
+
+Feel free to copy, use and enjoy in accordance with to the license(s).
+*/
+#ifndef bscrypt_HEX_H
+#define bscrypt_HEX_H
+#include "bscrypt-common.h"
+/* *****************************************************************************
+C++ extern
+*/
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/* ***************************************************************************
+Hex Conversion
+*/
+
+/**
+Returns 1 if the string is HEX encoded (no non-valid hex values). Returns 0 if
+it isn't.
+*/
+int bscrypt_is_hex(const char *string, size_t length);
+/**
+This will convert the string (byte stream) to a Hex string. This is not
+cryptography, just conversion for pretty print.
+
+The target buffer MUST have enough room for the expected data. The expected
+data is double the length of the string + 1 byte for the NULL terminator
+byte.
+
+A NULL byte will be appended to the target buffer. The function will return
+the number of bytes written to the target buffer.
+
+Returns the number of bytes actually written to the target buffer (excluding
+the NULL terminator byte).
+*/
+int bscrypt_str2hex(char *target, const char *string, size_t length);
+
+/**
+This will convert a Hex string to a byte string. This is not cryptography,
+just conversion for pretty print.
+
+The target buffer MUST have enough room for the expected data. The expected
+data is half the length of the Hex string + 1 byte for the NULL terminator
+byte.
+
+A NULL byte will be appended to the target buffer. The function will return
+the number of bytes written to the target buffer.
+
+If the target buffer is NULL, the encoded string will be destructively
+edited
+and the decoded data will be placed in the original string's buffer.
+
+Returns the number of bytes actually written to the target buffer (excluding
+the NULL terminator byte).
+*/
+int bscrypt_hex2str(char *target, char *hex, size_t length);
+
+/* *****************************************************************************
+C++ extern finish
+*/
+#if defined(__cplusplus)
+}
+#endif
+
+#endif

data/ext/iodine/http.c

@@ -0,0 +1,200 @@
+#include "http.h"
+
+/**
+A faster (yet less localized) alternative to `gmtime_r`.
+
+See the libc `gmtime_r` documentation for details.
+
+Falls back to `gmtime_r` for dates before epoch.
+*/
+struct tm* http_gmtime(const time_t* timer, struct tm* tmbuf) {
+  // static char* DAYS[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
+  // static char * Months = {  "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+  // "Jul",
+  // "Aug", "Sep", "Oct", "Nov", "Dec"};
+  static uint8_t month_len[] = {
+      31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,  // nonleap year
+      31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31   // leap year
+  };
+  if (*timer < 0)
+    return gmtime_r(timer, tmbuf);
+  ssize_t tmp;
+  tmbuf->tm_gmtoff = 0;
+  tmbuf->tm_zone = "UTC";
+  tmbuf->tm_isdst = 0;
+  tmbuf->tm_year = 70;  // tm_year == The number of years since 1900
+  tmbuf->tm_mon = 0;
+  // for seconds up to weekdays, we build up, as small values clean up larger
+  // values.
+  tmp = ((ssize_t)*timer);
+  tmbuf->tm_sec = tmp % 60;
+  tmp = tmp / 60;
+  tmbuf->tm_min = tmp % 60;
+  tmp = tmp / 60;
+  tmbuf->tm_hour = tmp % 24;
+  tmp = tmp / 24;
+  // day of epoch was a thursday. Add + 3 so sunday == 0...
+  tmbuf->tm_wday = (tmp + 3) % 7;
+// tmp == number of days since epoch
+#define DAYS_PER_400_YEARS ((400 * 365) + 97)
+  while (tmp >= DAYS_PER_400_YEARS) {
+    tmbuf->tm_year += 400;
+    tmp -= DAYS_PER_400_YEARS;
+  }
+#undef DAYS_PER_400_YEARS
+#define DAYS_PER_100_YEARS ((100 * 365) + 24)
+  while (tmp >= DAYS_PER_100_YEARS) {
+    tmbuf->tm_year += 100;
+    tmp -= DAYS_PER_100_YEARS;
+    if (((tmbuf->tm_year / 100) & 3) ==
+        0)  // leap century divisable by 400 => add leap
+      --tmp;
+  }
+#undef DAYS_PER_100_YEARS
+#define DAYS_PER_32_YEARS ((32 * 365) + 8)
+  while (tmp >= DAYS_PER_32_YEARS) {
+    tmbuf->tm_year += 32;
+    tmp -= DAYS_PER_32_YEARS;
+  }
+#undef DAYS_PER_32_YEARS
+#define DAYS_PER_8_YEARS ((8 * 365) + 2)
+  while (tmp >= DAYS_PER_8_YEARS) {
+    tmbuf->tm_year += 8;
+    tmp -= DAYS_PER_8_YEARS;
+  }
+#undef DAYS_PER_8_YEARS
+#define DAYS_PER_4_YEARS ((4 * 365) + 1)
+  while (tmp >= DAYS_PER_4_YEARS) {
+    tmbuf->tm_year += 4;
+    tmp -= DAYS_PER_4_YEARS;
+  }
+#undef DAYS_PER_4_YEARS
+  while (tmp >= 365) {
+    tmbuf->tm_year += 1;
+    tmp -= 365;
+    if ((tmbuf->tm_year & 3) == 0) {  // leap year
+      if (tmp > 0) {
+        --tmp;
+        continue;
+      } else {
+        tmp += 365;
+        --tmbuf->tm_year;
+        break;
+      }
+    }
+  }
+  tmbuf->tm_yday = tmp;
+  if ((tmbuf->tm_year & 3) == 1) {
+    // regular year
+    for (size_t i = 0; i < 12; i++) {
+      if (tmp < month_len[i])
+        break;
+      tmp -= month_len[i];
+      ++tmbuf->tm_mon;
+    }
+  } else {
+    // leap year
+    for (size_t i = 12; i < 24; i++) {
+      if (tmp < month_len[i])
+        break;
+      tmp -= month_len[i];
+      ++tmbuf->tm_mon;
+    }
+  }
+  tmbuf->tm_mday = tmp;
+  return tmbuf;
+}
+
+static char* DAY_NAMES[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
+static char* MONTH_NAMES[] = {"Jan ", "Feb ", "Mar ", "Apr ", "May ", "Jun ",
+                              "Jul ", "Aug ", "Sep ", "Oct ", "Nov ", "Dec "};
+static const char* GMT_STR = "GMT";
+
+size_t http_date2str(char* target, struct tm* tmbuf) {
+  char* pos = target;
+  uint16_t tmp;
+  *(uint32_t*)pos = *((uint32_t*)DAY_NAMES[tmbuf->tm_wday]);
+  pos[3] = ',';
+  pos[4] = ' ';
+  pos += 5;
+  if (tmbuf->tm_mday < 10) {
+    *pos = '0' + tmbuf->tm_mday;
+    ++pos;
+  } else {
+    tmp = tmbuf->tm_mday / 10;
+    pos[0] = '0' + tmp;
+    pos[1] = '0' + (tmbuf->tm_mday - (tmp * 10));
+    pos += 2;
+  }
+  *(pos++) = ' ';
+  *(uint32_t*)pos = *((uint32_t*)MONTH_NAMES[tmbuf->tm_mon]);
+  pos += 4;
+  // write year.
+  pos += http_ul2a(pos, tmbuf->tm_year + 1900);
+  *(pos++) = ' ';
+  tmp = tmbuf->tm_hour / 10;
+  pos[0] = '0' + tmp;
+  pos[1] = '0' + (tmbuf->tm_hour - (tmp * 10));
+  pos[2] = ':';
+  tmp = tmbuf->tm_min / 10;
+  pos[3] = '0' + tmp;
+  pos[4] = '0' + (tmbuf->tm_min - (tmp * 10));
+  pos[5] = ':';
+  tmp = tmbuf->tm_sec / 10;
+  pos[6] = '0' + tmp;
+  pos[7] = '0' + (tmbuf->tm_sec - (tmp * 10));
+  pos += 8;
+  pos[0] = ' ';
+  *((uint32_t*)(pos + 1)) = *((uint32_t*)GMT_STR);
+  pos += 4;
+  return pos - target;
+}
+
+/* Credit to Jonathan Leffler for the idea of a unified conditional */
+#define hex_val(c)                                                        \
+  (((c) >= '0' && (c) <= '9') ? ((c)-48) : (((c) >= 'a' && (c) <= 'f') || \
+                                            ((c) >= 'A' && (c) <= 'F'))   \
+                                               ? (((c) | 32) - 87)        \
+                                               : ({                       \
+                                                   return -1;             \
+                                                   0;                     \
+                                                 }))
+ssize_t http_decode_url(char* dest, const char* url_data, size_t length) {
+  char* pos = dest;
+  const char* end = url_data + length;
+  while (url_data < end) {
+    if (*url_data == '+') {
+      // decode space
+      *(pos++) = ' ';
+      ++url_data;
+    } else if (*url_data == '%') {
+      // decode hex value
+      // this is a percent encoded value.
+      *(pos++) = (hex_val(url_data[1]) << 4) | hex_val(url_data[2]);
+      url_data += 3;
+    } else
+      *(pos++) = *(url_data++);
+  }
+  *pos = 0;
+  return pos - dest;
+}
+
+ssize_t http_decode_url_unsafe(char* dest, const char* url_data) {
+  char* pos = dest;
+  while (*url_data) {
+    if (*url_data == '+') {
+      // decode space
+      *(pos++) = ' ';
+      ++url_data;
+    } else if (*url_data == '%') {
+      // decode hex value
+      // this is a percent encoded value.
+      *(pos++) = (hex_val(url_data[1]) << 4) | hex_val(url_data[2]);
+      url_data += 3;
+    } else
+      *(pos++) = *(url_data++);
+  }
+  *pos = 0;
+  return pos - dest;
+}
+#undef hex_val