iodine 0.1.21 → 0.2.0

data/ext/iodine/misc.c

@@ -0,0 +1,181 @@
+/*
+(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 "misc.h"
+/* ***************************************************************************
+Other helper functions
+*/
+
+#ifdef HAS_UNIX_FEATURES
+#include <fcntl.h>
+#include <limits.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+/**
+Allocates memory and dumps the whole file into the memory allocated.
+
+Remember to call `free` when done.
+
+Returns the number of bytes allocated. On error, returns 0 and sets the
+container pointer to NULL.
+
+This function has some Unix specific properties that resolve links and user
+folder referencing.
+*/
+fdump_s* bscrypt_fdump(const char* file_path, size_t size_limit) {
+  struct stat f_data;
+  int file = -1;
+  fdump_s* container = NULL;
+  size_t file_path_len;
+  if (file_path == NULL || (file_path_len = strlen(file_path)) == 0 ||
+      file_path_len > PATH_MAX)
+    return NULL;
+
+  char real_public_path[PATH_MAX + 1];
+  real_public_path[PATH_MAX] = 0;
+  if (file_path[0] == '~' && getenv("HOME") && file_path_len <= PATH_MAX) {
+    strcpy(real_public_path, getenv("HOME"));
+    memcpy(real_public_path + strlen(real_public_path), file_path + 1,
+           file_path_len);
+    file_path = real_public_path;
+  }
+
+  if (stat(file_path, &f_data))
+    goto error;
+  if (size_limit == 0 || f_data.st_size < size_limit)
+    size_limit = f_data.st_size;
+  container = malloc(size_limit + sizeof(fdump_s));
+  if (!container)
+    goto error;
+  container->length = size_limit;
+  file = open(file_path, O_RDONLY);
+  if (file < 0)
+    goto error;
+  if (read(file, container->data, size_limit) < size_limit)
+    goto error;
+  close(file);
+  return container;
+error:
+  if (container)
+    free(container), (container = NULL);
+  if (file >= 0)
+    close(file);
+  return 0;
+}
+
+#endif /* HAS_UNIX_FEATURES */
+
+/**
+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* bscrypt_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;
+}

data/ext/iodine/misc.h

@@ -0,0 +1,76 @@
+/*
+(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_MISC_H
+#define bscrypt_MISC_H
+#include "bscrypt-common.h"
+#include <time.h>
+/* *****************************************************************************
+C++ extern
+*/
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/* ***************************************************************************
+Miscellaneous helper functions
+
+i.e. file content dumping and GMT time alternative to `gmtime_r`.
+*/
+
+#ifdef HAS_UNIX_FEATURES
+
+/**
+File dump data.
+
+This struct (or, a pointer to this struct) is returned
+by the `bscrypt.fdump`
+function on success.
+
+To free the pointer returned, simply call `free`.
+*/
+typedef struct {
+  size_t length;
+  char data[];
+} fdump_s;
+
+/**
+Allocates memory and dumps the whole file into the
+memory allocated.
+Remember
+to call `free` when done.
+
+Returns the number of bytes allocated. On error,
+returns 0 and sets the
+container pointer to NULL.
+
+This function has some Unix specific properties that
+resolve links and user
+folder referencing.
+*/
+fdump_s *bscrypt_fdump(const char *file_path, size_t size_limit);
+
+#endif /* HAS_UNIX_FEATURES */
+
+/**
+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 *bscrypt_gmtime(const time_t *timer, struct tm *tmbuf);
+
+/* *****************************************************************************
+C++ extern finish
+*/
+#if defined(__cplusplus)
+}
+#endif
+
+#endif

data/ext/iodine/random.c

@@ -0,0 +1,193 @@
+/*
+(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 "random.h"
+
+#if defined(USE_ALT_RANDOM) || !defined(HAS_UNIX_FEATURES)
+#include <time.h>
+#include "sha2.h"
+uint32_t bscrypt_rand32(void) {
+  bits256_u pseudo = bscrypt_rand256();
+  return pseudo.ints[3];
+}
+
+uint64_t bscrypt_rand64(void) {
+  bits256_u pseudo = bscrypt_rand256();
+  return pseudo.words[3];
+}
+
+bits128_u bscrypt_rand128(void) {
+  bits256_u pseudo = bscrypt_rand256();
+  bits128_u ret;
+  ret.words[0] = pseudo.words[0];
+  ret.words[1] = pseudo.words[1];
+  return ret;
+}
+
+bits256_u bscrypt_rand256(void) {
+  clock_t cpu_state = clock();
+  time_t the_time;
+  time(&the_time);
+  bits256_u pseudo;
+  sha2_s sha2 = bscrypt_sha2_init(SHA_256);
+  bscrypt_sha2_write(&sha2, &cpu_state, sizeof(cpu_state));
+  bscrypt_sha2_write(&sha2, &the_time, sizeof(the_time));
+  bscrypt_sha2_write(&sha2, &cpu_state - 2, 64); /* whatever's on the stack */
+  bscrypt_sha2_result(&sha2);
+  pseudo.words[0] = sha2.digest.i64[0];
+  pseudo.words[1] = sha2.digest.i64[1];
+  pseudo.words[2] = sha2.digest.i64[2];
+  pseudo.words[3] = sha2.digest.i64[3];
+  return pseudo;
+}
+
+void bscrypt_rand_bytes(void *target, size_t length) {
+  clock_t cpu_state = clock();
+  time_t the_time;
+  time(&the_time);
+  sha2_s sha2 = bscrypt_sha2_init(SHA_512);
+  bscrypt_sha2_write(&sha2, &cpu_state, sizeof(cpu_state));
+  bscrypt_sha2_write(&sha2, &the_time, sizeof(the_time));
+  bscrypt_sha2_write(&sha2, &cpu_state - 2, 64); /* whatever's on the stack */
+  bscrypt_sha2_result(&sha2);
+  while (length > 64) {
+    memcpy(target, sha2.digest.str, 64);
+    length -= 64;
+    target += 64;
+    bscrypt_sha2_write(&sha2, &cpu_state, sizeof(cpu_state));
+    bscrypt_sha2_result(&sha2);
+  }
+  if (length > 32) {
+    memcpy(target, sha2.digest.str, 32);
+    length -= 32;
+    target += 32;
+    bscrypt_sha2_write(&sha2, &cpu_state, sizeof(cpu_state));
+    bscrypt_sha2_result(&sha2);
+  }
+  if (length > 16) {
+    memcpy(target, sha2.digest.str, 16);
+    length -= 16;
+    target += 16;
+    bscrypt_sha2_write(&sha2, &cpu_state, sizeof(cpu_state));
+    bscrypt_sha2_result(&sha2);
+  }
+  if (length > 8) {
+    memcpy(target, sha2.digest.str, 8);
+    length -= 8;
+    target += 8;
+    bscrypt_sha2_write(&sha2, &cpu_state, sizeof(cpu_state));
+    bscrypt_sha2_result(&sha2);
+  }
+  while (length) {
+    *((uint8_t *)target) = sha2.digest.str[length];
+    ++target;
+    --length;
+  }
+}
+
+#else
+/* ***************************************************************************
+Unix Random Engine (use built in machine)
+*/
+#include <fcntl.h>
+#include <errno.h>
+#include <unistd.h>
+#include <pthread.h>
+
+/* ***************************************************************************
+Machine specific changes
+*/
+// #ifdef __linux__
+// #undef bswap16
+// #undef bswap32
+// #undef bswap64
+// #include <machine/bswap.h>
+// #endif
+#ifdef HAVE_X86Intrin
+// #undef bswap16
+/*
+#undef bswap32
+#define bswap32(i) \
+  { __asm__("bswap %k0" : "+r"(i) :); }
+*/
+#undef bswap64
+#define bswap64(i)                                                             \
+  { __asm__("bswapq %0" : "+r"(i) :); }
+
+// shadow sched_yield as _mm_pause for spinwait
+#define sched_yield() _mm_pause()
+#endif
+
+/* ***************************************************************************
+Random ... (why is this not a system call?)
+*/
+
+/* rand generator management */
+static int _rand_fd_ = -1;
+static void close_rand_fd(void) {
+  if (_rand_fd_ >= 0)
+    close(_rand_fd_);
+  _rand_fd_ = -1;
+}
+static void init_rand_fd(void) {
+  if (_rand_fd_ < 0) {
+    while ((_rand_fd_ = open("/dev/urandom", O_RDONLY)) == -1) {
+      if (errno == ENXIO)
+        perror("bscrypt fatal error, caanot initiate random generator"),
+            exit(-1);
+      sched_yield();
+    }
+  }
+  atexit(close_rand_fd);
+}
+/* rand function template */
+#define MAKE_RAND_FUNC(type, func_name)                                        \
+  type func_name(void) {                                                       \
+    if (_rand_fd_ < 0)                                                         \
+      init_rand_fd();                                                          \
+    type ret;                                                                  \
+    while (read(_rand_fd_, &ret, sizeof(type)) < 0)                            \
+      sched_yield();                                                           \
+    return ret;                                                                \
+  }
+/* rand functions */
+MAKE_RAND_FUNC(uint32_t, bscrypt_rand32);
+MAKE_RAND_FUNC(uint64_t, bscrypt_rand64);
+MAKE_RAND_FUNC(bits128_u, bscrypt_rand128);
+MAKE_RAND_FUNC(bits256_u, bscrypt_rand256);
+/* clear template */
+#undef MAKE_RAND_FUNC
+
+void bscrypt_rand_bytes(void *target, size_t length) {
+  if (_rand_fd_ < 0)
+    init_rand_fd();
+  while (read(_rand_fd_, target, length) < 0)
+    sched_yield();
+}
+#endif /* Unix Random */
+
+/*******************************************************************************
+Random
+*/
+#if defined(DEBUG) && DEBUG == 1
+void bscrypt_test_random(void) {
+  clock_t start, end;
+  bscrypt_rand256();
+  start = clock();
+  for (size_t i = 0; i < 100000; i++) {
+    bscrypt_rand256();
+  }
+  end = clock();
+  fprintf(stderr,
+          "+ bscrypt Random generator available\n+ bscrypt 100K X 256bit "
+          "Random %lu CPU clock count\n",
+          end - start);
+}
+#endif