lib: Revise endian header and SHA3

This revises the endian header to let the build time checks of
endianness be performed by the standard libraries. We just check for
the OS that is being used and provide the endian functions from
OpenBSD to everyone. It also updates the SHA3 sources to use this new
header. The byte order header is removed.

4 files changed, 92 insertions, 253 deletions

diff --git a/include/ouroboros/endian.h b/include/ouroboros/endian.h
index a2745595..46f384ec 100644
--- a/include/ouroboros/endian.h
+++ b/include/ouroboros/endian.h
@@ -4,9 +4,7 @@
  * Endianness
  *
  *    Dimitri Staessens <[email protected]>
- *
- * This implementation is adapted and redistributed from the RHASH
- * project
+ *    Sander Vrijders   <[email protected]>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public License
@@ -23,126 +21,68 @@
  * 02110-1301 USA
  */
 
-/*
- * byte_order.h - byte order related platform dependent routines,
- *
- * Copyright: 2008-2012 Aleksey Kravchenko <[email protected]>
- *
- * Permission is hereby granted,  free of charge,  to any person  obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction,  including without limitation
- * the rights to  use, copy, modify,  merge, publish, distribute, sublicense,
- * and/or sell copies  of  the Software,  and to permit  persons  to whom the
- * Software is furnished to do so.
- *
- * This program  is  distributed  in  the  hope  that it will be useful,  but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE.  Use this program  at  your own risk!
- */
-
 #ifndef OUROBOROS_ENDIAN_H
 #define OUROBOROS_ENDIAN_H
 
-#include <stdint.h>
-#include <unistd.h>
-#include <stdlib.h>
+#if defined(__linux__) || defined(__CYGWIN__)
+
+#define _BSD_SOURCE
+#define __USE_BSD
+#define _DEFAULT_SOURCE
 
-#ifdef __GLIBC__
 #include <endian.h>
-#elif defined(__FreeBSD__)
+#include <features.h>
+
+#define betoh16(x) be16toh(x)
+#define letoh16(x) le16toh(x)
+#define betoh32(x) be32toh(x)
+#define letoh32(x) le32toh(x)
+#define betoh64(x) be64toh(x)
+#define letoh64(x) le64toh(x)
+
+#elif defined(__NetBSD__) || defined(__FreeBSD__)
+
 #include <sys/endian.h>
-#endif
 
-/* if x86 compatible cpu */
-#if defined(i386) || defined(__i386__) || defined(__i486__) || \
-        defined(__i586__) || defined(__i686__) || defined(__pentium__) || \
-        defined(__pentiumpro__) || defined(__pentium4__) ||             \
-        defined(__nocona__) || defined(prescott) || defined(__core2__) || \
-        defined(__k6__) || defined(__k8__) || defined(__athlon__) ||    \
-        defined(__amd64) || defined(__amd64__) ||                       \
-        defined(__x86_64) || defined(__x86_64__) || defined(_M_IX86) || \
-        defined(_M_AMD64) || defined(_M_IA64) || defined(_M_X64)
-/* detect if x86-64 instruction set is supported */
-# if defined(_LP64) || defined(__LP64__) || defined(__x86_64) || \
-        defined(__x86_64__) || defined(_M_AMD64) || defined(_M_X64)
-#  define CPU_X64
-# else
-#  define CPU_IA32
-# endif
-#endif
+#define betoh16(x) be16toh(x)
+#define letoh16(x) le16toh(x)
+#define betoh32(x) be32toh(x)
+#define letoh32(x) le32toh(x)
+#define betoh64(x) be64toh(x)
+#define letoh64(x) le64toh(x)
 
-/* detect CPU endianness */
-#if (defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && \
-     __BYTE_ORDER == __LITTLE_ENDIAN) ||                  \
-        defined(CPU_IA32) || defined(CPU_X64) ||                        \
-        defined(__ia64) || defined(__ia64__) || defined(__alpha__) ||   \
-        defined(_M_ALPHA) || defined(vax) || defined(MIPSEL) ||         \
-        defined(_ARM_) || defined(__arm__)
-#define CPU_LITTLE_ENDIAN
-#define IS_BIG_ENDIAN 0
-#define IS_LITTLE_ENDIAN 1
-#elif (defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) &&                \
-       __BYTE_ORDER == __BIG_ENDIAN) ||                                 \
-        defined(__sparc) || defined(__sparc__) || defined(sparc) ||     \
-        defined(_ARCH_PPC) || defined(_ARCH_PPC64) || defined(_POWER) || \
-        defined(__POWERPC__) || defined(POWERPC) || defined(__powerpc) || \
-        defined(__powerpc__) || defined(__powerpc64__) || defined(__ppc__) || \
-        defined(__hpux)  || defined(_MIPSEB) || defined(mc68000) ||     \
-        defined(__s390__) || defined(__s390x__) || defined(sel)
-#define CPU_BIG_ENDIAN
-#define IS_BIG_ENDIAN 1
-#define IS_LITTLE_ENDIAN 0
-#else
-# error "Can't detect CPU architecture."
-#endif
+#elif defined(__APPLE__)
+
+#include <libkern/OSByteOrder.h>
+
+#define htobe16(x) OSSwapHostToBigInt16(x)
+#define htole16(x) OSSwapHostToLittleInt16(x)
+#define betoh16(x) OSSwapBigToHostInt16(x)
+#define letoh16(x) OSSwapLittleToHostInt16(x)
+
+#define htobe32(x) OSSwapHostToBigInt32(x)
+#define htole32(x) OSSwapHostToLittleInt32(x)
+#define betoh32(x) OSSwapBigToHostInt32(x)
+#define letoh32(x) OSSwapLittleToHostInt32(x)
+
+#define htobe64(x) OSSwapHostToBigInt64(x)
+#define htole64(x) OSSwapHostToLittleInt64(x)
+#define betoh64(x) OSSwapBigToHostInt64(x)
+#define letoh64(x) OSSwapLittleToHostInt64(x)
+
+#elif defined(__OpenBSD__)
+
+#include <sys/endian.h>
 
-#if defined(__GNUC__)  && (__GNUC__ >= 4) &&  \
-        (__GNUC__ > 4 || __GNUC_MINOR__ >= 3)
-/* for GCC >= 4.3 */
-#define bswap_32(x) __builtin_bswap32(x)
-#elif !defined(__STRICT_ANSI__)
-/* general bswap_32 definition */
-static inline uint32_t bswap_32(uint32_t x) {
-        x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0x00FF00FF);
-        return (x >> 16) | (x << 16);
-}
-#else
-#define bswap_32(x) ((((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >>  8) | \
-                     (((x) & 0x0000ff00) <<  8) | (((x) & 0x000000ff) << 24))
-#endif /* bswap_32 */
-
-#if defined(__GNUC__) && (__GNUC__ >= 4) && \
-        (__GNUC__ > 4 || __GNUC_MINOR__ >= 3)
-#define bswap_64(x) __builtin_bswap64(x)
-#elif defined (bswap64)
-#define bswap_64 bswap64
-#else
-#if !defined(__STRICT_ANSI__)
-static inline uint64_t bswap_64(uint64_t x) {
-        union {
-                uint64_t ll;
-                uint32_t l[2];
-        } w, r;
-        w.ll = x;
-        r.l[0] = bswap_32(w.l[1]);
-        r.l[1] = bswap_32(w.l[0]);
-        return r.ll;
-}
 #else
-#error "bswap_64 unsupported"
-#endif
+
+#error OS currently not supported
+
 #endif
 
-#ifdef CPU_LITTLE_ENDIAN
-#define hton64(x) bswap_64(x)
-#define hton32(x) bswap_32(x)
-#define ntoh64(x) bswap_64(x)
-#define ntoh32(x) bswap_32(x)
-#else /* CPU_LITTLE_ENDIAN */
-#define hton64(x) (x)
-#define hton32(x) (x)
-#define ntoh64(x) (x)
-#define noth32(x) (x)
-#endif /* CPU_LITTLE_ENDIAN */
+#define hton64(x) htobe64(x)
+#define hton32(x) htobe32(x)
+#define ntoh64(x) betoh64(x)
+#define noth32(x) betoh32(x)
 
 #endif /* OUROBOROS_ENDIAN_H */
diff --git a/src/ipcpd/normal/enroll.c b/src/ipcpd/normal/enroll.c
index d09a62a9..a0d28598 100644
--- a/src/ipcpd/normal/enroll.c
+++ b/src/ipcpd/normal/enroll.c
@@ -21,12 +21,12 @@
 #define OUROBOROS_PREFIX "enrollment"
 
 #include <ouroboros/config.h>
+#include <ouroboros/endian.h>
 #include <ouroboros/time_utils.h>
 #include <ouroboros/cdap.h>
 #include <ouroboros/dev.h>
 #include <ouroboros/logs.h>
 #include <ouroboros/rib.h>
-#include <ouroboros/endian.h>
 
 #include "ae.h"
 
diff --git a/src/lib/byte_order.h b/src/lib/byte_order.h
deleted file mode 100644
index a0c72cf5..00000000
--- a/src/lib/byte_order.h
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
- * Ouroboros - Copyright (C) 2016 - 2017
- *
- * Byte order routines for SHA3 function
- *
- *    Dimitri Staessens <[email protected]>
- *
- * This implementation is adapted and redistributed from the RHASH
- * project
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public License
- * version 2.1 as published by the Free Software Foundation.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301 USA
- */
-
-/*
- * byte_order.h - byte order related platform dependent routines,
- *
- * Copyright: 2008-2012 Aleksey Kravchenko <[email protected]>
- *
- * Permission is hereby granted,  free of charge,  to any person  obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction,  including without limitation
- * the rights to  use, copy, modify,  merge, publish, distribute, sublicense,
- * and/or sell copies  of  the Software,  and to permit  persons  to whom the
- * Software is furnished to do so.
- *
- * This program  is  distributed  in  the  hope  that it will be useful,  but
- * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
- * or FITNESS FOR A PARTICULAR PURPOSE.  Use this program  at  your own risk!
- */
-
-#ifndef OUROBOROS_BYTE_ORDER_H
-#define OUROBOROS_BYTE_ORDER_H
-
-#include <ouroboros/endian.h>
-
-#define IS_ALIGNED_32(p) (0 == (3 & ((const char*)(p) - (const char*)0)))
-#define IS_ALIGNED_64(p) (0 == (7 & ((const char*)(p) - (const char*)0)))
-
-#if defined(__GNUC__)
-#define ALIGN_ATTR(n) __attribute__((aligned (n)))
-#else
-#define ALIGN_ATTR(n) /* nothing */
-#endif
-
-#define I64(x) x##LL
-
-/* convert a hash flag to index */
-#if __GNUC__ >= 4 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) /* GCC < 3.4 */
-#define rhash_ctz(x) __builtin_ctz(x)
-#else
-unsigned rhash_ctz(unsigned); /* define as function */
-#endif
-
-#ifdef CPU_BIG_ENDIAN
-#define be2me_32(x) (x)
-#define be2me_64(x) (x)
-#define le2me_32(x) bswap_32(x)
-#define le2me_64(x) bswap_64(x)
-
-#define be32_copy(to, index, from, length) \
-        memcpy((to) + (index), (from), (length))
-#define le32_copy(to, index, from, length) \
-        rhash_swap_copy_str_to_u32((to), (index), (from), (length))
-#define be64_copy(to, index, from, length) \
-        memcpy((to) + (index), (from), (length))
-#define le64_copy(to, index, from, length) \
-        rhash_swap_copy_str_to_u64((to), (index), (from), (length))
-#define me64_to_be_str(to, from, length) \
-        memcpy((to), (from), (length))
-#define me64_to_le_str(to, from, length) \
-        rhash_swap_copy_u64_to_str((to), (from), (length))
-
-#else /* CPU_BIG_ENDIAN */
-#define be2me_32(x) bswap_32(x)
-#define be2me_64(x) bswap_64(x)
-#define le2me_32(x) (x)
-#define le2me_64(x) (x)
-
-#define be32_copy(to, index, from, length) \
-        rhash_swap_copy_str_to_u32((to), (index), (from), (length))
-#define le32_copy(to, index, from, length) \
-        memcpy((to) + (index), (from), (length))
-#define be64_copy(to, index, from, length) \
-        rhash_swap_copy_str_to_u64((to), (index), (from), (length))
-#define le64_copy(to, index, from, length) \
-        memcpy((to) + (index), (from), (length))
-#define me64_to_be_str(to, from, length) \
-        rhash_swap_copy_u64_to_str((to), (from), (length))
-#define me64_to_le_str(to, from, length) \
-        memcpy((to), (from), (length))
-#endif /* CPU_BIG_ENDIAN */
-
-/* ROTL/ROTR macros rotate a 32/64-bit word left/right by n bits */
-#define ROTL32(dword, n) ((dword) << (n) ^ ((dword) >> (32 - (n))))
-#define ROTR32(dword, n) ((dword) >> (n) ^ ((dword) << (32 - (n))))
-#define ROTL64(qword, n) ((qword) << (n) ^ ((qword) >> (64 - (n))))
-#define ROTR64(qword, n) ((qword) >> (n) ^ ((qword) << (64 - (n))))
-
-#endif /* OUROBOROS_BYTE_ORDER_H */
diff --git a/src/lib/sha3.c b/src/lib/sha3.c
index 4d9b9b8c..b2f9de57 100644
--- a/src/lib/sha3.c
+++ b/src/lib/sha3.c
@@ -40,11 +40,16 @@
  * or FITNESS FOR A PARTICULAR PURPOSE.  Use this program  at  your own risk!
  */
 
+#include <ouroboros/endian.h>
+
 #include <assert.h>
 #include <string.h>
 
 #include "sha3.h"
-#include "byte_order.h"
+
+#define IS_ALIGNED_64(p) (0 == (7 & ((const char*) (p) - (const char*) 0)))
+#define I64(x) x##LL
+#define ROTL64(qword, n) ((qword) << (n) ^ ((qword) >> (64 - (n))))
 
 #define NumberOfRounds 24
 
@@ -207,40 +212,40 @@ static void rhash_sha3_process_block(uint64_t         hash[25],
                                      size_t           block_size)
 {
         /* expanded loop */
-        hash[ 0] ^= le2me_64(block[ 0]);
-        hash[ 1] ^= le2me_64(block[ 1]);
-        hash[ 2] ^= le2me_64(block[ 2]);
-        hash[ 3] ^= le2me_64(block[ 3]);
-        hash[ 4] ^= le2me_64(block[ 4]);
-        hash[ 5] ^= le2me_64(block[ 5]);
-        hash[ 6] ^= le2me_64(block[ 6]);
-        hash[ 7] ^= le2me_64(block[ 7]);
-        hash[ 8] ^= le2me_64(block[ 8]);
+        hash[ 0] ^= htole64(block[ 0]);
+        hash[ 1] ^= htole64(block[ 1]);
+        hash[ 2] ^= htole64(block[ 2]);
+        hash[ 3] ^= htole64(block[ 3]);
+        hash[ 4] ^= htole64(block[ 4]);
+        hash[ 5] ^= htole64(block[ 5]);
+        hash[ 6] ^= htole64(block[ 6]);
+        hash[ 7] ^= htole64(block[ 7]);
+        hash[ 8] ^= htole64(block[ 8]);
         /* if not sha3-512 */
         if (block_size > 72) {
-                hash[ 9] ^= le2me_64(block[ 9]);
-                hash[10] ^= le2me_64(block[10]);
-                hash[11] ^= le2me_64(block[11]);
-                hash[12] ^= le2me_64(block[12]);
+                hash[ 9] ^= htole64(block[ 9]);
+                hash[10] ^= htole64(block[10]);
+                hash[11] ^= htole64(block[11]);
+                hash[12] ^= htole64(block[12]);
                 /* if not sha3-384 */
                 if (block_size > 104) {
-                        hash[13] ^= le2me_64(block[13]);
-                        hash[14] ^= le2me_64(block[14]);
-                        hash[15] ^= le2me_64(block[15]);
-                        hash[16] ^= le2me_64(block[16]);
+                        hash[13] ^= htole64(block[13]);
+                        hash[14] ^= htole64(block[14]);
+                        hash[15] ^= htole64(block[15]);
+                        hash[16] ^= htole64(block[16]);
                         /* if not sha3-256 */
                         if (block_size > 136) {
-                                hash[17] ^= le2me_64(block[17]);
+                                hash[17] ^= htole64(block[17]);
 #ifdef FULL_SHA3_FAMILY_SUPPORT
                                 /* if not sha3-224 */
                                 if (block_size > 144) {
-                                        hash[18] ^= le2me_64(block[18]);
-                                        hash[19] ^= le2me_64(block[19]);
-                                        hash[20] ^= le2me_64(block[20]);
-                                        hash[21] ^= le2me_64(block[21]);
-                                        hash[22] ^= le2me_64(block[22]);
-                                        hash[23] ^= le2me_64(block[23]);
-                                        hash[24] ^= le2me_64(block[24]);
+                                        hash[18] ^= htole64(block[18]);
+                                        hash[19] ^= htole64(block[19]);
+                                        hash[20] ^= htole64(block[20]);
+                                        hash[21] ^= htole64(block[21]);
+                                        hash[22] ^= htole64(block[22]);
+                                        hash[23] ^= htole64(block[23]);
+                                        hash[24] ^= htole64(block[24]);
                                 }
 #endif
                         }
@@ -301,8 +306,9 @@ void rhash_sha3_update(struct sha3_ctx * ctx,
 void rhash_sha3_final(struct sha3_ctx * ctx,
                       uint8_t *         res)
 {
-        size_t digest_length    = 100 - ctx->block_size / 2;
+        size_t       digest_length = 100 - ctx->block_size / 2;
         const size_t block_size = ctx->block_size;
+        unsigned int i = 0;
 
         if (!(ctx->rest & SHA3_FINALIZED)) {
                 /* clear the rest of the data queue */
@@ -318,6 +324,10 @@ void rhash_sha3_final(struct sha3_ctx * ctx,
 
         assert(block_size > digest_length);
 
-        if (res != NULL)
-                me64_to_le_str(res, ctx->hash, digest_length);
+        if (res != NULL) {
+                for (i = 0; i < digest_length; i++)
+                        ctx->hash[i] = htole64(ctx->hash[i]);
+
+                memcpy(res, ctx->hash, digest_length);
+        }
 }