iodine 0.4.19 → 0.5.0

data/ext/iodine/{sha1.h → fio_sha1.h}

@@ -5,9 +5,32 @@ of), which might be subject to their own licenses.
 
 Feel free to copy, use and enjoy in accordance with to the license(s).
 */
-#ifndef bscrypt_SHA1_H
-#define bscrypt_SHA1_H
-#include "bscrypt-common.h"
+#ifndef H_FIO_SHA1_H
+#define H_FIO_SHA1_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
+
 /* *****************************************************************************
 C++ extern
 */
@@ -28,12 +51,11 @@ required.
 
 Use, for example:
 
-    #include "mini-crypt.h"
     sha1_s sha1;
-    bscrypt.sha1_init(&sha1);
-    bscrypt.sha1_write(&sha1,
+    fio_sha1_init(&sha1);
+    fio_sha1_write(&sha1,
                   "The quick brown fox jumps over the lazy dog", 43);
-    char *hashed_result = bscrypt.sha1_result(&sha1);
+    char *hashed_result = fio_sha1_result(&sha1);
 */
 typedef struct {
   uint64_t length;
@@ -48,31 +70,31 @@ typedef struct {
 Initialize or reset the `sha1` object. This must be performed before hashing
 data using sha1.
 */
-sha1_s bscrypt_sha1_init(void);
+sha1_s fio_sha1_init(void);
 /**
 Writes data to the sha1 buffer.
 */
-void bscrypt_sha1_write(sha1_s *s, const void *data, size_t len);
+void fio_sha1_write(sha1_s *s, const void *data, size_t len);
 /**
 Finalizes the SHA1 hash, returning the Hashed data.
 
 `sha1_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_sha1_result(sha1_s *s);
+char *fio_sha1_result(sha1_s *s);
 
 /**
 An SHA1 helper function that performs initialiation, writing and finalizing.
 */
-static inline UNUSED_FUNC char *bscrypt_sha1(sha1_s *s, const void *data,
-                                          size_t len) {
-  *s = bscrypt_sha1_init();
-  bscrypt_sha1_write(s, data, len);
-  return bscrypt_sha1_result(s);
+static inline UNUSED_FUNC char *fio_sha1(sha1_s *s, const void *data,
+                                         size_t len) {
+  *s = fio_sha1_init();
+  fio_sha1_write(s, data, len);
+  return fio_sha1_result(s);
 }
 
 #if defined(DEBUG) && DEBUG == 1
-void bscrypt_test_sha1(void);
+void fio_sha1_test(void);
 #endif
 
 /* *****************************************************************************

data/ext/iodine/{sha2.c → fio_sha2.c}

@@ -8,7 +8,21 @@ Feel free to copy, use and enjoy in accordance with to the license(s).
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE
 #endif
-#include "sha2.h"
+#include "fio_sha2.h"
+
+#include <stdio.h>
+#include <string.h>
+
+#ifndef __has_include
+#define __has_include(x) 0
+#endif
+
+/* include intrinsics if supported */
+#if __has_include(<x86intrin.h>)
+#include <x86intrin.h>
+#define HAVE_X86Intrin
+#endif
+
 /*****************************************************************************
 Useful Macros
 */
@@ -50,6 +64,7 @@ Useful Macros
           (((i)&0xFF000000000000ULL) >> 40) |                                  \
           (((i)&0xFF00000000000000ULL) >> 56);                                 \
   } while (0);
+#ifdef __SIZEOF_INT128__
 /** get the byte swap value of a 128 bit ...??? */
 #define gbswap128(c)                                                           \
   (((*((__uint128_t *)(c))) & 0xFFULL) << 120) |                               \
@@ -67,6 +82,7 @@ Useful Macros
       (((*((__uint128_t *)(c))) & 0xFF000000000000000000000000ULL) >> 72) |    \
       (((*((__uint128_t *)(c))) & 0xFF00000000000000000000000000ULL) >> 88) |  \
       (((*((__uint128_t *)(c))) & 0xFF0000000000000000000000000000ULL) >> 104)
+#endif
 
 #ifdef HAVE_X86Intrin
 #undef bswap64
@@ -373,7 +389,7 @@ apply. The following are valid options (see the sha2_variant enum):
 - SHA_224
 
 */
-sha2_s bscrypt_sha2_init(sha2_variant variant) {
+sha2_s fio_sha2_init(sha2_variant variant) {
   if (variant == SHA_256) {
     return (sha2_s){
         .type = SHA_256,
@@ -447,14 +463,14 @@ sha2_s bscrypt_sha2_init(sha2_variant variant) {
         .digest.i64[7] = 0x0eb72ddc81c52ca2,
     };
   }
-  fprintf(stderr, "bscrypt SHA2 ERROR - variant unknown\n");
+  fprintf(stderr, "SHA2 ERROR - variant unknown\n");
   exit(2);
 }
 
 /**
 Writes data to the SHA-2 buffer.
 */
-void bscrypt_sha2_write(sha2_s *s, const void *data, size_t len) {
+void fio_sha2_write(sha2_s *s, const void *data, size_t len) {
   size_t in_buffer;
   size_t partial;
   if (s->type & 1) { /* 512 type derived */
@@ -525,7 +541,7 @@ 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) {
+char *fio_sha2_result(sha2_s *s) {
   if (s->type & 1) {
 /* 512 bits derived hashing */
 
@@ -648,6 +664,7 @@ char *bscrypt_sha2_result(sha2_s *s) {
 SHA-2 testing
 */
 #if defined(DEBUG) && DEBUG == 1
+#include <time.h>
 
 // SHA_512 = 1, SHA_512_256 = 3, SHA_512_224 = 5, SHA_384 = 7, SHA_256 = 2,
 //              SHA_224 = 4,
@@ -663,96 +680,96 @@ static char *sha2_variant_names[] = {
 #endif
 // clang-format on
 
-void bscrypt_test_sha2(void) {
+void fio_sha2_test(void) {
   sha2_s s;
-  char *expect = NULL;
-  char *got = NULL;
+  char *expect;
+  char *got;
   char *str = "";
   fprintf(stderr, "===================================\n");
-  fprintf(stderr, "bscrypt SHA-2 struct size: %lu\n", sizeof(sha2_s));
-  fprintf(stderr, "+ bscrypt");
+  fprintf(stderr, "fio SHA-2 struct size: %zu\n", sizeof(sha2_s));
+  fprintf(stderr, "+ fio");
   // start tests
-  s = bscrypt_sha2_init(SHA_224);
-  bscrypt_sha2_write(&s, str, 0);
+  s = fio_sha2_init(SHA_224);
+  fio_sha2_write(&s, str, 0);
   expect = "\xd1\x4a\x02\x8c\x2a\x3a\x2b\xc9\x47\x61\x02\xbb\x28\x82\x34\xc4"
            "\x15\xa2\xb0\x1f\x82\x8e\xa6\x2a\xc5\xb3\xe4\x2f";
-  got = bscrypt_sha2_result(&s);
+  got = fio_sha2_result(&s);
   if (strcmp(expect, got))
     goto error;
 
-  s = bscrypt_sha2_init(SHA_256);
-  bscrypt_sha2_write(&s, str, 0);
+  s = fio_sha2_init(SHA_256);
+  fio_sha2_write(&s, str, 0);
   expect =
       "\xe3\xb0\xc4\x42\x98\xfc\x1c\x14\x9a\xfb\xf4\xc8\x99\x6f\xb9\x24\x27"
       "\xae\x41\xe4\x64\x9b\x93\x4c\xa4\x95\x99\x1b\x78\x52\xb8\x55";
-  got = bscrypt_sha2_result(&s);
+  got = fio_sha2_result(&s);
   if (strcmp(expect, got))
     goto error;
 
-  s = bscrypt_sha2_init(SHA_384);
-  bscrypt_sha2_write(&s, str, 0);
+  s = fio_sha2_init(SHA_384);
+  fio_sha2_write(&s, str, 0);
   expect = "\x38\xb0\x60\xa7\x51\xac\x96\x38\x4c\xd9\x32\x7e"
            "\xb1\xb1\xe3\x6a\x21\xfd\xb7\x11\x14\xbe\x07\x43\x4c\x0c"
            "\xc7\xbf\x63\xf6\xe1\xda\x27\x4e\xde\xbf\xe7\x6f\x65\xfb"
            "\xd5\x1a\xd2\xf1\x48\x98\xb9\x5b";
-  got = bscrypt_sha2_result(&s);
+  got = fio_sha2_result(&s);
   if (strcmp(expect, got))
     goto error;
 
-  s = bscrypt_sha2_init(SHA_512);
-  bscrypt_sha2_write(&s, str, 0);
+  s = fio_sha2_init(SHA_512);
+  fio_sha2_write(&s, str, 0);
   expect = "\xcf\x83\xe1\x35\x7e\xef\xb8\xbd\xf1\x54\x28\x50\xd6\x6d"
            "\x80\x07\xd6\x20\xe4\x05\x0b\x57\x15\xdc\x83\xf4\xa9\x21"
            "\xd3\x6c\xe9\xce\x47\xd0\xd1\x3c\x5d\x85\xf2\xb0\xff\x83"
            "\x18\xd2\x87\x7e\xec\x2f\x63\xb9\x31\xbd\x47\x41\x7a\x81"
            "\xa5\x38\x32\x7a\xf9\x27\xda\x3e";
-  got = bscrypt_sha2_result(&s);
+  got = fio_sha2_result(&s);
   if (strcmp(expect, got))
     goto error;
 
-  s = bscrypt_sha2_init(SHA_512_224);
-  bscrypt_sha2_write(&s, str, 0);
+  s = fio_sha2_init(SHA_512_224);
+  fio_sha2_write(&s, str, 0);
   expect = "\x6e\xd0\xdd\x02\x80\x6f\xa8\x9e\x25\xde\x06\x0c\x19\xd3"
            "\xac\x86\xca\xbb\x87\xd6\xa0\xdd\xd0\x5c\x33\x3b\x84\xf4";
-  got = bscrypt_sha2_result(&s);
+  got = fio_sha2_result(&s);
   if (strcmp(expect, got))
     goto error;
 
-  s = bscrypt_sha2_init(SHA_512_256);
-  bscrypt_sha2_write(&s, str, 0);
+  s = fio_sha2_init(SHA_512_256);
+  fio_sha2_write(&s, str, 0);
   expect = "\xc6\x72\xb8\xd1\xef\x56\xed\x28\xab\x87\xc3\x62\x2c\x51\x14\x06"
            "\x9b\xdd\x3a\xd7\xb8\xf9\x73\x74\x98\xd0\xc0\x1e\xce\xf0\x96\x7a";
-  got = bscrypt_sha2_result(&s);
+  got = fio_sha2_result(&s);
   if (strcmp(expect, got))
     goto error;
 
-  s = bscrypt_sha2_init(SHA_512);
+  s = fio_sha2_init(SHA_512);
   str = "god is a rotten tomato";
-  bscrypt_sha2_write(&s, str, strlen(str));
+  fio_sha2_write(&s, str, strlen(str));
   expect = "\x61\x97\x4d\x41\x9f\x77\x45\x21\x09\x4e\x95\xa3\xcb\x4d\xe4\x79"
            "\x26\x32\x2f\x2b\xe2\x62\x64\x5a\xb4\x5d\x3f\x73\x69\xef\x46\x20"
            "\xb2\xd3\xce\xda\xa9\xc2\x2c\xac\xe3\xf9\x02\xb2\x20\x5d\x2e\xfd"
            "\x40\xca\xa0\xc1\x67\xe0\xdc\xdf\x60\x04\x3e\x4e\x76\x87\x82\x74";
-  got = bscrypt_sha2_result(&s);
+  got = fio_sha2_result(&s);
   if (strcmp(expect, got))
     goto error;
 
-  // s = bscrypt_sha2_init(SHA_256);
+  // s = fio_sha2_init(SHA_256);
   // str = "The quick brown fox jumps over the lazy dog";
-  // bscrypt_sha2_write(&s, str, strlen(str));
+  // fio_sha2_write(&s, str, strlen(str));
   // expect =
   //     "\xd7\xa8\xfb\xb3\x07\xd7\x80\x94\x69\xca\x9a\xbc\xb0\x08\x2e\x4f"
   //     "\x8d\x56\x51\xe4\x6d\x3c\xdb\x76\x2d\x02\xd0\xbf\x37\xc9\xe5\x92";
-  // got = bscrypt_sha2_result(&s);
+  // got = fio_sha2_result(&s);
   // if (strcmp(expect, got))
   //   goto error;
 
-  s = bscrypt_sha2_init(SHA_224);
+  s = fio_sha2_init(SHA_224);
   str = "The quick brown fox jumps over the lazy dog";
-  bscrypt_sha2_write(&s, str, strlen(str));
+  fio_sha2_write(&s, str, strlen(str));
   expect = "\x73\x0e\x10\x9b\xd7\xa8\xa3\x2b\x1c\xb9\xd9\xa0\x9a\xa2"
            "\x32\x5d\x24\x30\x58\x7d\xdb\xc0\xc3\x8b\xad\x91\x15\x25";
-  got = bscrypt_sha2_result(&s);
+  got = fio_sha2_result(&s);
   if (strcmp(expect, got))
     goto error;
 
@@ -760,9 +777,9 @@ void bscrypt_test_sha2(void) {
 
 #ifdef HAVE_OPENSSL
   fprintf(stderr, "===================================\n");
-  fprintf(stderr, "bscrypt SHA-2 struct size: %lu\n", sizeof(sha2_s));
-  fprintf(stderr, "OpenSSL SHA-2/256 struct size: %lu\n", sizeof(SHA256_CTX));
-  fprintf(stderr, "OpenSSL SHA-2/512 struct size: %lu\n", sizeof(SHA512_CTX));
+  fprintf(stderr, "fio SHA-2 struct size: %zu\n", sizeof(sha2_s));
+  fprintf(stderr, "OpenSSL SHA-2/256 struct size: %zu\n", sizeof(SHA256_CTX));
+  fprintf(stderr, "OpenSSL SHA-2/512 struct size: %zu\n", sizeof(SHA512_CTX));
   fprintf(stderr, "===================================\n");
   SHA512_CTX s2;
   SHA256_CTX s3;
@@ -770,11 +787,11 @@ void bscrypt_test_sha2(void) {
   hash[SHA512_DIGEST_LENGTH] = 0;
   clock_t start = clock();
   for (size_t i = 0; i < 100000; i++) {
-    s = bscrypt_sha2_init(SHA_512);
-    bscrypt_sha2_write(&s, "The quick brown fox jumps over the lazy dog", 43);
-    bscrypt_sha2_result(&s);
+    s = fio_sha2_init(SHA_512);
+    fio_sha2_write(&s, "The quick brown fox jumps over the lazy dog", 43);
+    fio_sha2_result(&s);
   }
-  fprintf(stderr, "bscrypt 100K SHA-2/512: %lf\n",
+  fprintf(stderr, "fio 100K SHA-2/512: %lf\n",
           (double)(clock() - start) / CLOCKS_PER_SEC);
 
   start = clock();
@@ -788,11 +805,11 @@ void bscrypt_test_sha2(void) {
 
   start = clock();
   for (size_t i = 0; i < 100000; i++) {
-    s = bscrypt_sha2_init(SHA_256);
-    bscrypt_sha2_write(&s, "The quick brown fox jumps over the lazy dog", 43);
-    bscrypt_sha2_result(&s);
+    s = fio_sha2_init(SHA_256);
+    fio_sha2_write(&s, "The quick brown fox jumps over the lazy dog", 43);
+    fio_sha2_result(&s);
   }
-  fprintf(stderr, "bscrypt 100K SHA-2/256: %lf\n",
+  fprintf(stderr, "fio 100K SHA-2/256: %lf\n",
           (double)(clock() - start) / CLOCKS_PER_SEC);
 
   hash[SHA256_DIGEST_LENGTH] = 0;
@@ -812,7 +829,7 @@ void bscrypt_test_sha2(void) {
 
 error:
   fprintf(stderr,
-          ":\n--- bscrypt SHA-2 Test FAILED!\ntype: "
+          ":\n--- fio SHA-2 Test FAILED!\ntype: "
           "%s (%d)\nstring %s\nexpected:\n",
           sha2_variant_names[s.type], s.type, str);
   while (*expect)

data/ext/iodine/{sha2.h → fio_sha2.h}

@@ -5,9 +5,32 @@ of), which might be 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"
+#ifndef H_FIO_SHA2_H
+#define H_FIO_SHA2_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
+
+#include <stdlib.h>
+#include <stdint.h>
+
 /* *****************************************************************************
 C++ extern
 */
@@ -45,15 +68,23 @@ Use, for example:
 
     #include "mini-crypt.h"
     sha2_s sha2;
-    bscrypt.sha2_init(&sha2, SHA_512);
-    bscrypt.sha2_write(&sha2,
+    fio_sha2_init(&sha2, SHA_512);
+    fio_sha2_write(&sha2,
                   "The quick brown fox jumps over the lazy dog", 43);
-    char *hashed_result = bscrypt.sha2_result(&sha2);
+    char *hashed_result = fio_sha2_result(&sha2);
 
 */
 typedef struct {
   /* notice: we're counting bits, not bytes. max length: 2^128 bits */
-  bits128_u length;
+  union {
+    uint8_t bytes[16];
+    uint8_t matrix[4][4];
+    uint32_t words_small[4];
+    uint64_t words[2];
+#if defined(__SIZEOF_INT128__)
+    __uint128_t i;
+#endif
+  } length;
   uint8_t buffer[128];
   union {
     uint32_t i32[16];
@@ -78,54 +109,54 @@ apply. The following are valid options (see the sha2_variant enum):
 - SHA_224
 
 */
-sha2_s bscrypt_sha2_init(sha2_variant variant);
+sha2_s fio_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);
+void fio_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);
+char *fio_sha2_result(sha2_s *s);
 
 /**
 An SHA2 helper function that performs initialiation, writing and finalizing.
 Uses the SHA2 512 variant.
 */
-static inline UNUSED_FUNC 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);
+static inline UNUSED_FUNC char *fio_sha2_512(sha2_s *s, const void *data,
+                                             size_t len) {
+  *s = fio_sha2_init(SHA_512);
+  fio_sha2_write(s, data, len);
+  return fio_sha2_result(s);
 }
 
 /**
 An SHA2 helper function that performs initialiation, writing and finalizing.
 Uses the SHA2 256 variant.
 */
-static inline UNUSED_FUNC 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);
+static inline UNUSED_FUNC char *fio_sha2_256(sha2_s *s, const void *data,
+                                             size_t len) {
+  *s = fio_sha2_init(SHA_256);
+  fio_sha2_write(s, data, len);
+  return fio_sha2_result(s);
 }
 
 /**
 An SHA2 helper function that performs initialiation, writing and finalizing.
 Uses the SHA2 384 variant.
 */
-static inline UNUSED_FUNC 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);
+static inline UNUSED_FUNC char *fio_sha2_384(sha2_s *s, const void *data,
+                                             size_t len) {
+  *s = fio_sha2_init(SHA_384);
+  fio_sha2_write(s, data, len);
+  return fio_sha2_result(s);
 }
 
 #if defined(DEBUG) && DEBUG == 1
-void bscrypt_test_sha2(void);
+void fio_sha2_test(void);
 #endif
 
 /* *****************************************************************************