iodine 0.4.19 → 0.5.0

data/ext/iodine/resp.h

@@ -1,261 +0,0 @@
-/*
-Copyright: Boaz segev, 2017
-License: MIT except for any non-public-domain algorithms (none that I'm aware
-of), which might be subject to their own licenses.
-
-Feel free to copy, use and enjoy in accordance with to the license(s).
-*/
-#ifndef H_RESP_PARSER_H
-/**
-This is a neive implementation of the RESP protocol for Redis.
-*/
-#define H_RESP_PARSER_H
-
-#include <stdint.h>
-#include <stdlib.h>
-
-/* support C++ */
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/** The RESP Parser Type */
-typedef struct resp_parser_s *resp_parser_pt;
-
-/* *****************************************************************************
-RESP types and objects (Arrays, Strings & Integers)
-***************************************************************************** */
-
-enum resp_type_enum {
-  /** A simple flag object object (`resp_object_s`) for NULL. */
-  RESP_NULL = 0,
-  /** A simple flag object object (`resp_object_s`) for OK. */
-  RESP_OK = 1,
-  /** A String object (`resp_string_s`) that indicates an error. */
-  RESP_ERR = (2 + 8),
-  /** A Number object object (`resp_number_s`). */
-  RESP_NUMBER = 4,
-  /** A String object (`resp_string_s`). */
-  RESP_STRING = 8,
-  /** An Array object object (`resp_array_s`). */
-  RESP_ARRAY = 16,
-  /**
-   * A specific Array object object (`resp_array_s`) for Pub/Sub semantics.
-   *
-   * This is more of a hint than a decree, sometimes pubsub semantics are
-   * misleading.
-   */
-  RESP_PUBSUB = (32 + 16),
-};
-
-/** a simple emtpy object type, used for RESP_NULL and RESP_OK */
-typedef struct { enum resp_type_enum type; } resp_object_s;
-
-/** The RESP_ARRAY and RESP_PUBSUB types */
-typedef struct {
-  enum resp_type_enum type;
-  size_t len;
-  size_t pos; /** allows simple iteration. */
-  resp_object_s *array[];
-} resp_array_s;
-
-/** The RESP_STRING and RESP_ERR types */
-typedef struct {
-  enum resp_type_enum type;
-  size_t len;
-  uint8_t string[];
-} resp_string_s;
-
-/** The RESP_NUMBER type */
-typedef struct {
-  enum resp_type_enum type;
-  int64_t number;
-} resp_number_s;
-
-#define resp_obj2arr(obj)                                                      \
-  ((resp_array_s *)((obj)->type == RESP_ARRAY || (obj)->type == RESP_PUBSUB    \
-                        ? (obj)                                                \
-                        : NULL))
-#define resp_obj2str(obj)                                                      \
-  ((resp_string_s *)((obj)->type == RESP_STRING || (obj)->type == RESP_ERR     \
-                         ? (obj)                                               \
-                         : NULL))
-#define resp_obj2num(obj)                                                      \
-  ((resp_number_s *)((obj)->type == RESP_NUMBER ? (obj) : NULL))
-
-/** Allocates an RESP NULL objcet. Remeber to free when done. */
-resp_object_s *resp_nil2obj(void);
-
-/** Allocates an RESP OK objcet. Remeber to free when done. */
-resp_object_s *resp_OK2obj(void);
-
-/** Allocates an RESP Error objcet. Remeber to free when done. */
-resp_object_s *resp_err2obj(const void *msg, size_t len);
-
-/** Allocates an RESP Number objcet. Remeber to free when done. */
-resp_object_s *resp_num2obj(uint64_t num);
-
-/** Allocates an RESP String objcet. Remeber to free when done. */
-resp_object_s *resp_str2obj(const void *str, size_t len);
-
-/**
- *Allocates an RESP Array objcet. Remeber to free when done (freeing an array
- *frees it's children automatically).
- *
- * It's possible to pass NULL as the `argv`, in which case the array created
- * will have the capacity `argc` and could me manually populated.
- *
- * The objects are MOVED into the array's possesion. If you wish to retain a
- * copy of the objects, use the `resp_dup_object` to increase their reference
- * count.
- */
-resp_object_s *resp_arr2obj(int argc, resp_object_s *argv[]);
-
-/** Duplicates an object by increasing it's reference count. */
-resp_object_s *resp_dup_object(resp_object_s *obj);
-
-/** frees an object by decreasing it's reference count and testing. */
-void resp_free_object(resp_object_s *obj);
-
-/**
- * Formats a RESP object back into a string.
- *
- * Returns 0 on success and -1 on failur.
- *
- * Accepts a memory buffer `dest` to which the data will be written and a poiner
- * to the size of the buffer.
- *
- * Once the function returns, `size` will be updated to include the number of
- * bytes required for the string. If the function returned a failure, this value
- * can be used to allocate enough memory to contain the string.
- *
- * The string is Binary safe and it ISN'T always NUL terminated.
- *
- * The optional `parser` argument allows experimental extensions to be used when
- * formatting the object. It can be ignored when formatting without extensions.
- *
- * **If implementing a server**:
- *
- * When implementing a server, Pub/Sub should avoid multiple copies by using a
- * dedicated buffer with a reference count. By decreasing the reference count
- * every time the message was sent (see the `sock_write2` support for the
- * dealloc callback), it's possible to avoid multiple copies of the message.
- */
-int resp_format(resp_parser_pt p, uint8_t *dest, size_t *size,
-                resp_object_s *obj);
-
-/**
- * Performs a task on each object. Protects from loop-backs.
- *
- * To break loop in the middle, `task` can return -1.
- *
- * Returns count.
- */
-size_t resp_obj_each(resp_parser_pt p, resp_object_s *obj,
-                     int (*task)(resp_parser_pt p, resp_object_s *obj,
-                                 void *arg),
-                     void *arg);
-
-/* *****************************************************************************
-The RESP Parser
-***************************************************************************** */
-
-/** create the parser */
-resp_parser_pt resp_parser_new(void);
-
-/** free the parser and it's resources. */
-void resp_parser_destroy(resp_parser_pt);
-
-/** Clears the parser state, as if starting a new session / connection. */
-void resp_parser_clear(resp_parser_pt);
-
-/**
- * Feed the parser with data.
- *
- * Returns any fully parsed object / reply (often an array, but not always) or
- * NULL (needs more data / error).
- *
- * If a RESP object was parsed, it is returned and `len` is updated to reflect
- * the number of bytes actually read.
- *
- * If more data is needed, NULL is returned and `len` is left unchanged.
- *
- * An error is reported by by returning NULL and setting `len` to 0 at the same
- * time.
- *
- * Partial consumption is possible when multiple replys were available in the
- * buffer. Otherwise the parser will consume the whole of the buffer.
- *
- */
-resp_object_s *resp_parser_feed(resp_parser_pt, uint8_t *buffer, size_t *len);
-
-/* *****************************************************************************
-State - The Pub / Sub Multiplexer (Experimental)
-***************************************************************************** */
-
-/**
-It seems to me that the main reason that pub/sub messages and normal RESP
-connetcions cannot share the same socket is the risk of identity collisions.
-
-For example, the command LRANGE might return the following array response
-`["message", "users", "hello"]`... this looks exactly like a Pub/Sub
-notification.
-
-However, this situation is very uncomfortable. For example:
-
-* The sender already knows the content of the message. There is no reason to
-  waste bandwidth to send the same message back to the sender using a different
-  socket.
-
-* The cost isn't just Bandwidth, but also memory, since the sender will have two
-  copies of the same message (if not more), the one being sent and the other
-  being received (sometimes more then once, for different channel patterns).
-
-
-* Instead of handling the message localy, the sender is forced to wait until the
-  message is received by the pub/sub Redis conection - otherwise tere will be
-  duplicate messages being published.
-
-* This design doubles the client load (number of connections) for each Redis
-  server (and client).
-
-But we can solve this.
-
-For example, what if we use a "magic byte" to distinguish between the array
-`["message", "users", "hello"]` and the pub/sub notification `["message",
-"users", "hello"]`?
-
-What if every time the first word in an array response satrts with an `"m"` or a
-`"+"`, we will add the `"+"` byte infront of it?
-
-Now the notification will look like this: `["message", "users", "hello"]`, and
-the array response (i.e. to `LRANGE`) will be: `["+message", "users", "hello"]`
-- a distinct difference allowing for pub/sub and regular conections to use the
-same pipelining socket.
-
-The big issue (and I may be wrong), is backwards compatibility - we can't change
-the semantics of the protocol without breaking existing clients... or can we?
-
-I believe this hurdle can be easily circumvented by adding a single command to
-the existing pallet. Somthing along the lines of: `ENABLE <feature>`.
-
-Such a flexible command allows clients to negotiate changes to the semantics
-for the connection. It's meant to be a single non-reversible change for the
-specific connection (similar to the `Upgrade` HTTP/Websocket concept).
-
-Now, the little `"+"` "magic byte" can be easily handled.
-
-The following function activates the "magic byte" assuming the `ENABLE` command
-was negotiated for the connection.
-*/
-void resp_enable_duplex_pubsub(resp_parser_pt parser);
-
-#ifdef DEBUG
-void resp_test(void);
-#endif
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif

data/ext/iodine/siphash.c

@@ -1,154 +0,0 @@
-/*
-Copyright: Boaz segev, 2016-2017
-License: MIT except for any non-public-domain algorithms (none that I'm aware
-of), which might be subject to their own licenses.
-
-Feel free to copy, use and enjoy in accordance with to the license(s).
-*/
-#include "siphash.h"
-#include <stdint.h>
-#include <stdlib.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_FUNC
-#   define UNUSED_FUNC __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) { // fallthrough is intentional
-  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>
-#include <time.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");
-  clock_t start;
-  start = clock();
-  for (size_t i = 0; i < 100000; i++) {
-    __asm__ volatile("" ::: "memory");
-    result = siphash24("The quick brown fox jumps over the lazy dog ", 43,
-                       SIPHASH_DEFAULT_KEY);
-  }
-  fprintf(stderr, "bscrypt 100K SipHash: %lf\n",
-          (double)(clock() - start) / CLOCKS_PER_SEC);
-  fprintf(stderr, "===================================\n");
-}
-
-#endif

data/ext/iodine/siphash.h

@@ -1,22 +0,0 @@
-/*
-Copyright: Boaz segev, 2016-2017
-License: MIT except for any non-public-domain algorithms (none that I'm aware
-of), which might be subject to their own licenses.
-
-Feel free to copy, use and enjoy in accordance with to the license(s).
-*/
-#ifndef BS_SIPHASH_H
-#define BS_SIPHASH_H
-#include <stdint.h>
-#include <stdlib.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/xor-crypt.c

@@ -1,193 +0,0 @@
-/*
-Copyright: Boaz segev, 2016-2017
-License: MIT except for any non-public-domain algorithms (none that I'm aware
-of), which might be 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 "xor-crypt.h"
-/*****************************************************************************
-Useful Macros
-*/
-
-/** 32Bit left rotation, inlined. */
-#define left_rotate32(i, bits)                                                 \
-  (((uint32_t)(i) << (bits)) | ((uint32_t)(i) >> (32 - (bits))))
-/** 32Bit right rotation, inlined. */
-#define right_rotate32(i, bits)                                                \
-  (((uint32_t)(i) >> (bits)) | ((uint32_t)(i) << (32 - (bits))))
-/** 64Bit left rotation, inlined. */
-#define left_rotate64(i, bits)                                                 \
-  (((uint64_t)(i) << (bits)) | ((uint64_t)(i) >> (64 - (bits))))
-/** 64Bit right rotation, inlined. */
-#define right_rotate64(i, bits)                                                \
-  (((uint64_t)(i) >> (bits)) | ((uint64_t)(i) << (64 - (bits))))
-/** unknown size element - left rotation, inlined. */
-#define left_rotate(i, bits) (((i) << (bits)) | ((i) >> (sizeof((i)) - (bits))))
-/** unknown size element - right rotation, inlined. */
-#define right_rotate(i, bits)                                                  \
-  (((i) >> (bits)) | ((i) << (sizeof((i)) - (bits))))
-/** inplace byte swap 16 bit integer */
-#define bswap16(i)                                                             \
-  do {                                                                         \
-    (i) = (((i)&0xFFU) << 8) | (((i)&0xFF00U) >> 8);                           \
-  } while (0);
-/** inplace byte swap 32 bit integer */
-#define bswap32(i)                                                             \
-  do {                                                                         \
-    (i) = (((i)&0xFFUL) << 24) | (((i)&0xFF00UL) << 8) |                       \
-          (((i)&0xFF0000UL) >> 8) | (((i)&0xFF000000UL) >> 24);                \
-  } while (0);
-/** inplace byte swap 64 bit integer */
-#define bswap64(i)                                                             \
-  do {                                                                         \
-    (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);                                 \
-  } while (0);
-
-#ifdef HAVE_X86Intrin
-#undef bswap64
-#define bswap64(i)                                                             \
-  { __asm__("bswapq %0" : "+r"(i) :); }
-
-// shadow sched_yield as _mm_pause for spinwait
-#define sched_yield() _mm_pause()
-#endif
-
-/* ***************************************************************************
-XOR encryption
-*/
-
-/**
-Uses an XOR key `xor_key_s` to encrypt / decrypt the data provided.
-
-Encryption/decryption can be destructive (the target and the source can point
-to the same object).
-
-The key's `on_cycle` callback option should be utilized to er-calculate the
-key every cycle. Otherwise, XOR encryption should be avoided.
-
-A more secure encryption would be easier to implement using seperate
-`xor_key_s` objects for encryption and decription.
-
-If `target` is NULL, the source will be used as the target (destructive mode).
-
-Returns -1 on error and 0 on success.
-*/
-int bscrypt_xor_crypt(xor_key_s *key, void *target, const void *source,
-                      size_t length) {
-  if (!source || !key)
-    return -1;
-  if (!length)
-    return 0;
-  if (!target)
-    target = (void *)source;
-  if (key->on_cycle) {
-    /* loop to provide vector initialization when needed. */
-    while (key->position >= key->length) {
-      if (key->on_cycle(key))
-        return -1;
-      key->position -= key->length;
-    }
-  } else if (key->position >= key->length)
-    key->position = 0; /* no callback? no need for vector alterations. */
-  size_t i = 0;
-
-  /* start decryption */
-  while (length > i) {
-    while ((key->length - key->position >= 8) // we have 8 bytes for key.
-           && ((i + 8) <= length)             // we have 8 bytes for stream.
-           && (((uintptr_t)((uintptr_t)target + i)) & 7) ==
-                  0 // target memory is aligned.
-           && (((uintptr_t)((uintptr_t)source + i)) & 7) ==
-                  0 // source memory is aligned.
-           && ((uintptr_t)(key->key + key->position) & 7) == 0 // key aligned.
-           ) {
-      // fprintf(stderr, "XOR optimization used i= %lu, key pos = %lu.\n", i,
-      //         key->position);
-      *((uint64_t *)((uintptr_t)target + i)) =
-          *((uint64_t *)((uintptr_t)source + i)) ^
-          *((uint64_t *)(key->key + key->position));
-      key->position += 8;
-      i += 8;
-      if (key->position < key->length)
-        continue;
-      if (key->on_cycle && key->on_cycle(key))
-        return -1;
-      key->position = 0;
-    }
-
-    if (i < length) {
-      // fprintf(stderr, "XOR single byte.\n");
-      *((uint8_t *)((uintptr_t)target + i)) =
-          *((uint8_t *)((uintptr_t)source + i)) ^
-          *((uint8_t *)(key->key + key->position));
-      ++i;
-      ++key->position;
-      if (key->position == key->length) {
-        if (key->on_cycle && key->on_cycle(key))
-          return -1;
-        key->position = 0;
-      }
-    }
-  }
-  return 0;
-}
-
-/**
-Similar to the bscrypt_xor_crypt except with a fixed key size of 128bits.
-*/
-int bscrypt_xor128_crypt(uint64_t *key, void *target, const void *source,
-                         size_t length, int (*on_cycle)(uint64_t *key)) {
-  length = length & 31;
-  uint8_t pos = 0;
-  for (size_t i = 0; i < (length >> 3); i++) {
-    ((uint64_t *)target)[0] = ((uint64_t *)source)[0] ^ key[pos++];
-    target = (void *)((uintptr_t)target + 8);
-    source = (void *)((uintptr_t)source + 8);
-    if (pos < 2)
-      continue;
-    if (on_cycle && on_cycle(key))
-      return -1;
-    pos = 0;
-  }
-  length = length & 7;
-  for (size_t i = 0; i < length; i++) {
-    ((uint64_t *)target)[i] = ((uint64_t *)source)[i] ^ key[pos];
-  }
-  return 0;
-}
-/**
-Similar to the bscrypt_xor_crypt except with a fixed key size of 256bits.
-*/
-int bscrypt_xor256_crypt(uint64_t *key, void *target, const void *source,
-                         size_t length, int (*on_cycle)(uint64_t *key)) {
-  for (size_t i = 0; i < (length >> 5); i++) {
-    ((uint64_t *)target)[0] = ((uint64_t *)source)[0] ^ key[0];
-    ((uint64_t *)target)[1] = ((uint64_t *)source)[1] ^ key[1];
-    ((uint64_t *)target)[2] = ((uint64_t *)source)[2] ^ key[2];
-    ((uint64_t *)target)[3] = ((uint64_t *)source)[3] ^ key[3];
-    target = (void *)((uintptr_t)target + 32);
-    source = (void *)((uintptr_t)source + 32);
-    if (on_cycle && on_cycle(key))
-      return -1;
-  }
-  length = length & 31;
-  uint8_t pos = 0;
-  for (size_t i = 0; i < (length >> 3); i++) {
-    ((uint64_t *)target)[0] = ((uint64_t *)source)[0] ^ key[pos++];
-    target = (void *)((uintptr_t)target + 8);
-    source = (void *)((uintptr_t)source + 8);
-  }
-  length = length & 7;
-  for (size_t i = 0; i < length; i++) {
-    ((uint64_t *)target)[i] = ((uint64_t *)source)[i] ^ key[pos];
-  }
-  return 0;
-}