iodine 0.1.21 → 0.2.0

data/ext/iodine/sha2.h

@@ -0,0 +1,138 @@
+/*
+(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_SHA2_H
+#define bscrypt_SHA2_H
+#include "bscrypt-common.h"
+/* *****************************************************************************
+C++ extern
+*/
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/* ***************************************************************************
+SHA-2 hashing
+*/
+
+/**
+SHA-2 function variants.
+
+This enum states the different SHA-2 function variants. placing SHA_512 at the
+beginning is meant to set this variant as the default (in case a 0 is passed).
+*/
+typedef enum {
+  SHA_512 = 1,
+  SHA_512_256 = 3,
+  SHA_512_224 = 5,
+  SHA_384 = 7,
+  SHA_256 = 2,
+  SHA_224 = 4,
+} sha2_variant;
+
+/**
+SHA-2 hashing container - you should ignore the contents of this struct.
+
+The `sha2_s` type will contain all the SHA-2 data required to perform the
+hashing, managing it's encoding. If it's stack allocated, no freeing will be
+required.
+
+Use, for example:
+
+    #include "mini-crypt.h"
+    sha2_s sha2;
+    bscrypt.sha2_init(&sha2, SHA_512);
+    bscrypt.sha2_write(&sha2,
+                  "The quick brown fox jumps over the lazy dog", 43);
+    char *hashed_result = bscrypt.sha2_result(&sha2);
+
+*/
+typedef struct {
+  /* notice: we're counting bits, not bytes. max length: 2^128 bits */
+  bits128_u length;
+  uint8_t buffer[128];
+  union {
+    uint32_t i32[16];
+    uint64_t i64[8];
+    uint8_t str[65]; /* added 64+1 for the NULL byte.*/
+  } digest;
+  sha2_variant type;
+} sha2_s;
+
+/**
+Initialize/reset the SHA-2 object.
+
+SHA-2 is actually a family of functions with different variants. When
+initializing the SHA-2 container, you must select the variant you intend to
+apply. The following are valid options (see the sha2_variant enum):
+
+- SHA_512 (== 0)
+- SHA_384
+- SHA_512_224
+- SHA_512_256
+- SHA_256
+- SHA_224
+
+*/
+sha2_s bscrypt_sha2_init(sha2_variant variant);
+/**
+Writes data to the SHA-2 buffer.
+*/
+void bscrypt_sha2_write(sha2_s *s, const void *data, size_t len);
+/**
+Finalizes the SHA-2 hash, returning the Hashed data.
+
+`sha2_result` can be called for the same object multiple times, but the
+finalization will only be performed the first time this function is called.
+*/
+char *bscrypt_sha2_result(sha2_s *s);
+
+/**
+An SHA2 helper function that performs initialiation, writing and finalizing.
+Uses the SHA2 512 variant.
+*/
+static inline __unused char *bscrypt_sha2_512(sha2_s *s, const void *data,
+                                              size_t len) {
+  *s = bscrypt_sha2_init(SHA_512);
+  bscrypt_sha2_write(s, data, len);
+  return bscrypt_sha2_result(s);
+}
+
+/**
+An SHA2 helper function that performs initialiation, writing and finalizing.
+Uses the SHA2 256 variant.
+*/
+static inline __unused char *bscrypt_sha2_256(sha2_s *s, const void *data,
+                                              size_t len) {
+  *s = bscrypt_sha2_init(SHA_256);
+  bscrypt_sha2_write(s, data, len);
+  return bscrypt_sha2_result(s);
+}
+
+/**
+An SHA2 helper function that performs initialiation, writing and finalizing.
+Uses the SHA2 384 variant.
+*/
+static inline __unused char *bscrypt_sha2_384(sha2_s *s, const void *data,
+                                              size_t len) {
+  *s = bscrypt_sha2_init(SHA_384);
+  bscrypt_sha2_write(s, data, len);
+  return bscrypt_sha2_result(s);
+}
+
+#if defined(DEBUG) && DEBUG == 1
+void bscrypt_test_sha2(void);
+#endif
+
+/* *****************************************************************************
+C++ extern finish
+*/
+#if defined(__cplusplus)
+}
+#endif
+
+#endif

data/ext/iodine/siphash.c

@@ -0,0 +1,136 @@
+#include "siphash.h"
+#include <stdlib.h>
+#include <stdint.h>
+
+// clang-format off
+#if !defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)
+#   if defined(__has_include)
+#     if __has_include(<endian.h>)
+#      include <endian.h>
+#     elif __has_include(<sys/endian.h>)
+#      include <sys/endian.h>
+#     endif
+#   endif
+#   if !defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__) && \
+                __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#      define __BIG_ENDIAN__
+#   endif
+#endif
+
+#ifndef __unused
+#   define __unused __attribute__((unused))
+#endif
+// clang-format on
+
+/** 64Bit left rotation, inlined. */
+#define _lrot64(i, bits)                                                       \
+  (((uint64_t)(i) << (bits)) | ((uint64_t)(i) >> (64 - (bits))))
+
+#ifdef __BIG_ENDIAN__
+/* the algorithm was designed as little endian */
+/** inplace byte swap 64 bit integer */
+#define sip_local64(i)                                                         \
+  (((i)&0xFFULL) << 56) | (((i)&0xFF00ULL) << 40) |                            \
+      (((i)&0xFF0000ULL) << 24) | (((i)&0xFF000000ULL) << 8) |                 \
+      (((i)&0xFF00000000ULL) >> 8) | (((i)&0xFF0000000000ULL) >> 24) |         \
+      (((i)&0xFF000000000000ULL) >> 40) | (((i)&0xFF00000000000000ULL) >> 56)
+
+#else
+/** no need */
+#define sip_local64(i) (i)
+#endif
+
+uint64_t siphash24(const void *data, size_t len, uint64_t iv_key[2]) {
+  /* initialize the 4 words */
+  uint64_t v0 = iv_key[0] ^ 0x736f6d6570736575ULL;
+  uint64_t v1 = iv_key[1] ^ 0x646f72616e646f6dULL;
+  uint64_t v2 = iv_key[0] ^ 0x6c7967656e657261ULL;
+  uint64_t v3 = iv_key[1] ^ 0x7465646279746573ULL;
+  const uint64_t *w64 = data;
+  uint8_t len_mod = len & 255;
+  union {
+    uint64_t i;
+    uint8_t str[8];
+  } word;
+
+#define _bs_map_SipRound                                                       \
+  do {                                                                         \
+    v2 += v3;                                                                  \
+    v3 = _lrot64(v3, 16) ^ v2;                                                 \
+    v0 += v1;                                                                  \
+    v1 = _lrot64(v1, 13) ^ v0;                                                 \
+    v0 = _lrot64(v0, 32);                                                      \
+    v2 += v1;                                                                  \
+    v0 += v3;                                                                  \
+    v1 = _lrot64(v1, 17) ^ v2;                                                 \
+    v3 = _lrot64(v3, 21) ^ v0;                                                 \
+    v2 = _lrot64(v2, 32);                                                      \
+  } while (0);
+
+  while (len >= 8) {
+    word.i = sip_local64(*w64);
+    v3 ^= word.i;
+    /* Sip Rounds */
+    _bs_map_SipRound;
+    _bs_map_SipRound;
+    v0 ^= word.i;
+    w64 += 1;
+    len -= 8;
+  }
+  word.i = 0;
+  uint8_t *pos = word.str;
+  uint8_t *w8 = (void *)w64;
+  switch (len) {
+  case 7:
+    pos[6] = w8[6];
+  case 6:
+    pos[5] = w8[5];
+  case 5:
+    pos[4] = w8[4];
+  case 4:
+    pos[3] = w8[3];
+  case 3:
+    pos[2] = w8[2];
+  case 2:
+    pos[1] = w8[1];
+  case 1:
+    pos[0] = w8[0];
+  }
+  word.str[7] = len_mod;
+  // word.i = sip_local64(word.i);
+
+  /* last round */
+  v3 ^= word.i;
+  _bs_map_SipRound;
+  _bs_map_SipRound;
+  v0 ^= word.i;
+  /* Finalization */
+  v2 ^= 0xff;
+  /* d iterations of SipRound */
+  _bs_map_SipRound;
+  _bs_map_SipRound;
+  _bs_map_SipRound;
+  _bs_map_SipRound;
+  /* XOR it all together */
+  v0 ^= v1 ^ v2 ^ v3;
+#undef _bs_map_SipRound
+  return v0;
+}
+
+#undef sip_local64
+#undef _lrot64
+
+#if defined(DEBUG) && DEBUG == 1
+
+#include <stdio.h>
+void bscrypt_test_siphash(void) {
+  uint64_t result =
+      siphash24("\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e",
+                15, SIPHASH_DEFAULT_KEY);
+  fprintf(stderr, "===================================\n");
+  fprintf(stderr, "SipHash simple test %s\n",
+          (result == 0xa129ca6149be45e5ULL) ? "passed" : "FAILED");
+  fprintf(stderr, "===================================\n");
+}
+
+#endif

data/ext/iodine/siphash.h

@@ -0,0 +1,15 @@
+#ifndef BS_SIPHASH_H
+#define BS_SIPHASH_H
+#include <stdlib.h>
+#include <stdint.h>
+
+#define SIPHASH_DEFAULT_KEY                                                    \
+  (uint64_t[]) { 0x0706050403020100, 0x0f0e0d0c0b0a0908 }
+uint64_t siphash24(const void *data, size_t len, uint64_t iv_key[2]);
+
+#if defined(DEBUG) && DEBUG == 1
+void bscrypt_test_siphash(void);
+
+#endif
+
+#endif

data/ext/iodine/spnlock.h

@@ -0,0 +1,235 @@
+/* *****************************************************************************
+A Simple busy lock implementation ... (spnlock.h)
+
+Based on a lot of internet reading as well as comperative work (i.e the Linux
+karnel's code and the more readable Apple's kernel code)
+
+Written by Boaz Segev at 2016. Donated to the public domain for all to enjoy.
+*/
+#ifndef _SPN_LOCK_H
+#define _SPN_LOCK_H
+
+/* allow of the unused flag */
+#ifndef __unused
+#define __unused __attribute__((unused))
+#endif
+
+#include <stdlib.h>
+#include <stdint.h>
+
+/*********
+ * manage the way threads "wait" for the lock to release
+ */
+#if defined(__unix__) || defined(__APPLE__) || defined(__linux__)
+/* nanosleep seems to be the most effective and efficient reschedule */
+#include <time.h>
+#define reschedule_thread()                                                    \
+  {                                                                            \
+    static const struct timespec tm = {.tv_nsec = 1};                          \
+    nanosleep(&tm, NULL);                                                      \
+  }
+
+#else /* no effective rescheduling, just spin... */
+#define reschedule_thread()
+
+/* these are SUPER slow when comapred with nanosleep or CPU cycling */
+// #if defined(__SSE2__) || defined(__SSE2)
+// #define reschedule_thread() __asm__("pause" :::)
+//
+// #elif defined(__has_include) && __has_include(<pthread.h>)
+// #include "pthread.h"
+// #define reschedule_thread() sched_yield()
+// #endif
+
+#endif
+/* end `reschedule_thread` block*/
+
+/*********
+ * The spin lock core functions (spn_trylock, spn_unlock, is_spn_locked)
+ */
+
+/* prefer C11 standard implementation where available (trust the system) */
+#if defined(__has_include)
+#if __has_include(<stdatomic.h>)
+#define SPN_TMP_HAS_ATOMICS 1
+#include <stdatomic.h>
+typedef atomic_bool spn_lock_i;
+#define SPN_LOCK_INIT ATOMIC_VAR_INIT(0)
+/** returns 1 if the lock was busy (TRUE == FAIL). */
+__unused static inline int spn_trylock(spn_lock_i *lock) {
+  __asm__ volatile("" ::: "memory");
+  return atomic_exchange(lock, 1);
+}
+/** Releases a lock. */
+__unused static inline void spn_unlock(spn_lock_i *lock) {
+  atomic_store(lock, 0);
+  __asm__ volatile("" ::: "memory");
+}
+/** returns a lock's state (non 0 == Busy). */
+__unused static inline int spn_is_locked(spn_lock_i *lock) {
+  return atomic_load(lock);
+}
+#endif
+#endif
+
+/* Chack if stdatomic was available */
+#ifdef SPN_TMP_HAS_ATOMICS
+#undef SPN_TMP_HAS_ATOMICS
+
+#else
+/* Test for compiler builtins */
+
+/* use clang builtins if available - trust the compiler */
+#if defined(__clang__)
+#if defined(__has_builtin) && __has_builtin(__sync_swap)
+/* define the type */
+typedef volatile uint8_t spn_lock_i;
+/** returns 1 if the lock was busy (TRUE == FAIL). */
+__unused static inline int spn_trylock(spn_lock_i *lock) {
+  return __sync_swap(lock, 1);
+}
+#define SPN_TMP_HAS_BUILTIN 1
+#endif
+/* use gcc builtins if available - trust the compiler */
+#elif defined(__GNUC__) &&                                                     \
+    (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4))
+/* define the type */
+typedef volatile uint8_t spn_lock_i;
+/** returns 1 if the lock was busy (TRUE == FAIL). */
+__unused static inline int spn_trylock(spn_lock_i *lock) {
+  return __sync_fetch_and_or(lock, 1);
+}
+#define SPN_TMP_HAS_BUILTIN 1
+#endif
+
+/* Check if compiler builtins were available, if not, try assembly*/
+#if SPN_TMP_HAS_BUILTIN
+#undef SPN_TMP_HAS_BUILTIN
+
+/* use Intel's asm if on Intel - trust Intel's documentation */
+#elif defined(__amd64__) || defined(__x86_64__) || defined(__x86__) ||         \
+    defined(__i386__) || defined(__ia64__) || defined(_M_IA64) ||              \
+    defined(__itanium__) || defined(__i386__)
+/* define the type */
+typedef volatile uint8_t spn_lock_i;
+/** returns 1 if the lock was busy (TRUE == FAIL). */
+__unused static inline int spn_trylock(spn_lock_i *lock) {
+  spn_lock_i tmp;
+  __asm__ volatile("xchgb %0,%1" : "=r"(tmp), "=m"(*lock) : "0"(1) : "memory");
+  return tmp;
+}
+
+/* use SPARC's asm if on SPARC - trust the design */
+#elif defined(__sparc__) || defined(__sparc)
+/* define the type */
+typedef volatile uint8_t spn_lock_i;
+/** returns TRUE (non-zero) if the lock was busy (TRUE == FAIL). */
+__unused static inline int spn_trylock(spn_lock_i *lock) {
+  spn_lock_i tmp;
+  __asm__ volatile("ldstub    [%1], %0" : "=r"(tmp) : "r"(lock) : "memory");
+  return tmp; /* return 0xFF if the lock was busy, 0 if free */
+}
+
+#else
+/* I don't know how to provide green thread safety on PowerPC or ARM */
+#error "Couldn't implement a spinlock for this system / compiler"
+#endif /* types and atomic exchange */
+/** Initialization value in `free` state. */
+#define SPN_LOCK_INIT 0
+
+/** Releases a lock. */
+__unused static inline void spn_unlock(spn_lock_i *lock) {
+  __asm__ volatile("" ::: "memory");
+  *lock = 0;
+}
+/** returns a lock's state (non 0 == Busy). */
+__unused static inline int spn_is_locked(spn_lock_i *lock) {
+  __asm__ volatile("" ::: "memory");
+  return *lock;
+}
+
+#endif /* has atomics */
+#include <stdio.h>
+/** Busy waits for the lock. */
+__unused static inline void spn_lock(spn_lock_i *lock) {
+  while (spn_trylock(lock)) {
+    reschedule_thread();
+  }
+}
+
+/* *****************************************************************************
+spnlock.h finished
+*/
+#endif
+
+#if DEBUG == 1 && !defined(_SPN_LOCK_TEST_REPEAT_COUNT)
+
+#define _SPN_LOCK_TEST_REPEAT_COUNT 10000UL
+#define _SPN_LOCK_TEST_THREAD_COUNT 10000UL
+#include <pthread.h>
+#include <stdio.h>
+
+__unused static void *test_spn_lock_work(void *arg) {
+  static spn_lock_i lck = SPN_LOCK_INIT;
+  uint64_t *ip = arg;
+  for (size_t i = 0; i < _SPN_LOCK_TEST_REPEAT_COUNT; i++) {
+    spn_lock(&lck);
+    uint64_t j = *ip;
+    j++;
+    __asm__ volatile("" ::: "memory", "cc");
+    *ip = j;
+    spn_unlock(&lck);
+  }
+  return NULL;
+}
+
+__unused static void *test_spn_lock_lockless_work(void *arg) {
+  uint64_t *ip = arg;
+  for (size_t i = 0; i < _SPN_LOCK_TEST_REPEAT_COUNT; i++) {
+    uint64_t j = *ip;
+    j++;
+    __asm__ volatile("" ::: "memory", "cc");
+    *ip = j;
+  }
+  return NULL;
+}
+
+__unused static void spn_lock_test(void) {
+  time_t start, end;
+  unsigned long num = 0;
+  pthread_t *threads = malloc(_SPN_LOCK_TEST_THREAD_COUNT * sizeof(*threads));
+  void *tmp;
+  start = clock();
+  for (size_t i = 0; i < _SPN_LOCK_TEST_THREAD_COUNT; i++) {
+    pthread_create(threads + i, NULL, test_spn_lock_lockless_work, &num);
+  }
+  for (size_t i = 0; i < _SPN_LOCK_TEST_THREAD_COUNT; i++) {
+    pthread_join(threads[i], &tmp);
+  }
+  end = clock();
+  fprintf(stderr, "Lockless Num = %lu with %lu CPU cycles.\n", num,
+          end - start);
+
+  num = 0;
+
+  start = clock();
+  for (size_t i = 0; i < _SPN_LOCK_TEST_THREAD_COUNT; i++) {
+    if (pthread_create(threads + i, NULL, test_spn_lock_work, &num))
+      fprintf(stderr,
+              "Failed to create thread number %lu... test will fail to run as "
+              "expected.\n",
+              i);
+    ;
+  }
+  for (size_t i = 0; i < _SPN_LOCK_TEST_THREAD_COUNT; i++) {
+    pthread_join(threads[i], &tmp);
+  }
+  end = clock();
+  free(threads);
+  fprintf(stderr, "Locked Num = %lu with %lu CPU cycles.\n", num, end - start);
+  fprintf(stderr, "spn_lock test %s\n",
+          num == _SPN_LOCK_TEST_THREAD_COUNT * _SPN_LOCK_TEST_REPEAT_COUNT
+              ? "passed."
+              : "FAILED!");
+}
+#endif /* Test */