From d43e7b7de84cc3c2f7fc71d553f727194b653d0b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matjaz=CC=8C?= Date: Sun, 26 Apr 2020 19:36:44 +0200 Subject: [PATCH 01/27] Add initial version with reimplemented init(), next() is broken --- CMakeLists.txt | 74 ++++++++ LICENSE.md | 28 +++ inc/isaac.h | 68 +++++++ src/isaac.c | 205 ++++++++++++++++++++ tst/atto/atto.c | 33 ++++ tst/atto/atto.h | 483 ++++++++++++++++++++++++++++++++++++++++++++++++ tst/test.c | 18 ++ tst/test.h | 31 ++++ tst/test_init.c | 202 ++++++++++++++++++++ tst/test_next.c | 142 ++++++++++++++ 10 files changed, 1284 insertions(+) create mode 100644 CMakeLists.txt create mode 100644 LICENSE.md create mode 100644 inc/isaac.h create mode 100644 src/isaac.c create mode 100644 tst/atto/atto.c create mode 100644 tst/atto/atto.h create mode 100644 tst/test.c create mode 100644 tst/test.h create mode 100644 tst/test_init.c create mode 100644 tst/test_next.c diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..ccf61d1 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,74 @@ +cmake_minimum_required(VERSION 3.5) +project(LibISAAC + VERSION 0.1.0 + LANGUAGES C + DESCRIPTION + "A modern wrapping of the ISAAC CPRNG.") + +# Unless specified, by default create Release builds +if (NOT CMAKE_BUILD_TYPE) + set(CMAKE_BUILD_TYPE Release) +endif () + +set(CMAKE_EXPORT_COMPILE_COMMANDS ON) + +set(CMAKE_C_STANDARD 11) +# Activate a million warnings to have the cleanest possible code +set(FLAGS_WARNINGS -Wall -Wextra -pedantic -Wconversion -Wdouble-promotion + -Wswitch-default -Wswitch-enum -Wuninitialized -Wno-unused-variable + -Wpacked -Wpadded -Wshadow -Wformat-security -Wlogical-not-parentheses + -Waggregate-return -Wmissing-declarations -Wmissing-declarations) +# Debug build: compile with no optimisation, debug info and printing +set(CMAKE_C_FLAGS_DEBUG "${WARNING_FLAGS} -g -O0 -DDEBUG") +# Append sanitiser flags on non-Windows systems +if (NOT WIN32 AND NOT CYGWIN AND NOT MSYS) + set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} \ + -fsanitize=address,undefined -static-libsan") +endif () + +# Mini-sized release build: compile with optimisation for size +# convert warnings into errors and some other optimisations +set(CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_MINSIZEREL} \ + ${WARNING_FLAGS} \ + -Os -Werror -fomit-frame-pointer -march=native -mtune=native") + +# Performance-oriented release build: compile with optimisation for speed +# convert warnings into errors and some other optimisations +set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} \ + ${WARNING_FLAGS} \ + -O3 -Werror -fomit-frame-pointer -march=native -mtune=native \ + -funroll-loops") + +include_directories(inc/) +set(LIB_FILES src/isaac.c) +include_directories(tst/ tst/atto/) +set(TEST_FILES tst/test.c tst/test_init.c tst/test_next.c tst/atto/atto.c) + +add_library("isaac" STATIC ${LIB_FILES}) +add_executable("testisaac" ${LIB_FILES} ${TEST_FILES}) + +include_directories(tst/original/) +add_executable("orig" tst/original/randport.c) + +# Doxygen documentation builder +find_package(Doxygen) +if (DOXYGEN_FOUND) + # Cmake's wrapper of Doxygen, constructing a doxyfile from the + # DOXYGEN_* variables, which are mapped to the Doxygen variables. + set(DOXYGEN_GENERATE_HTML YES) + set(DOXYGEN_GENERATE_MAN YES) + set(DOXYGEN_JAVADOC_AUTOBRIEF YES) + set(DOXYGEN_OPTIMIZE_OUTPUT_FOR_C YES) + set(DOXYGEN_SORT_MEMBER_DOCS NO) + set(DOXYGEN_ALIASES license="**License:**") + set(DOXYGEN_USE_MDFILE_AS_MAINPAGE README.md) + doxygen_add_docs(doxygen + ALL # Build doxygen on make-all + # List of input files for Doxygen + ${PROJECT_SOURCE_DIR}/inc/isaac.h + ${PROJECT_SOURCE_DIR}/LICENSE.md + ${PROJECT_SOURCE_DIR}/README.md + ${PROJECT_SOURCE_DIR}/CHANGELOG.md) +else (DOXYGEN_FOUND) + message(WARNING "Doxygen not found. Cannot generate documentation.") +endif (DOXYGEN_FOUND) diff --git a/LICENSE.md b/LICENSE.md new file mode 100644 index 0000000..0373019 --- /dev/null +++ b/LICENSE.md @@ -0,0 +1,28 @@ +BSD 3-Clause License +============================================================================== + +Copyright © 2020, Matjaž Guštin . +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. +3. Neither the name of the copyright holder nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS “AS IS” AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY DIRECT, +INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE +OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/inc/isaac.h b/inc/isaac.h new file mode 100644 index 0000000..7eee872 --- /dev/null +++ b/inc/isaac.h @@ -0,0 +1,68 @@ +/** + * @file + * + * ISAAC, the fast cryptographic pseudo random number generator (CPRNG) wrapped + * into a C11, modern, documented API and package. Quoting from its + * [web page](https://www.burtleburtle.net/bob/rand/isaacafa.html): + * + * > ISAAC (Indirection, Shift, Accumulate, Add, and Count) generates 32-bit + * > random numbers. Averaged out, it requires 18.75 machine cycles to + * > generate each 32-bit value. Cycles are guaranteed to be at least 240 + * > values long, and they are 28295 values long on average. The results are + * > uniformly distributed, unbiased, and unpredictable unless you know the + * > seed. + * + * ISAAC and its original source code is created by Bob Jenkins and + * released into the public domain. + * + * @copyright Copyright © 2020, Matjaž Guštin + * . All rights reserved. + * @license BSD 3-clause license. + */ + +#ifndef ISAAC_H +#define ISAAC_H + +#ifdef __cplusplus +extern "C" +{ +#endif + +/** + * Version of the isaac.h API using semantic versioning. + */ +#define LIBISAAC_VERSION "1.0.0" + +#include +#include + +#define ISAAC_SIZE 256U + +/* Context of random number generator */ +typedef struct { + uint32_t cnt; + uint32_t rsl[ISAAC_SIZE]; + uint32_t mem[ISAAC_SIZE]; + uint32_t a; + uint32_t b; + uint32_t c; +} isaac_ctx_t; + +// If (flag==TRUE), then use the contents of randrsl[0..RANDSIZ-1] as the seed. +/** + * Initialises the ISAAC CPRNG. + * + * Uses the `rsl` field as initial seed + * + * @param ctx + * @param flag + */ +void isaac_init(isaac_ctx_t* ctx, bool flag); +uint32_t isaac_next(isaac_ctx_t* ctx); + + +#ifdef __cplusplus +} +#endif + +#endif /* ISAAC_H */ diff --git a/src/isaac.c b/src/isaac.c new file mode 100644 index 0000000..b57e063 --- /dev/null +++ b/src/isaac.c @@ -0,0 +1,205 @@ +/** + * @file + * + * LibISAAC implementation. + * + * Basic on the 32-bit portable implementation by Bob Jenkins, originally + * public domain: + * https://www.burtleburtle.net/bob/c/randport.c + * + * @copyright Copyright © 2020, Matjaž Guštin + * . All rights reserved. + * @license BSD 3-clause license. + */ + +#include "isaac.h" + + +#ifndef min +# define min(a, b) (((a)<(b)) ? (a) : (b)) +#endif /* min */ +#ifndef max +# define max(a, b) (((a)<(b)) ? (b) : (a)) +#endif /* max */ +#ifndef align +# define align(a) (((uint32_t)a+(sizeof(void *)-1))&(~(sizeof(void *)-1))) +#endif /* align */ +#ifndef abs +# define abs(a) (((a)>0) ? (a) : -(a)) +#endif + +#define ISAAC_LEFTSHIFT 8U + +#define ISAAC_IND(mm, x) ((mm)[(x >> 2U) & (ISAAC_SIZE - 1)]) + +#define ISAAC_STEP(mix, a, b, mm, m, m2, r, x) \ +{ \ + x = *m; \ + a = ((a^(mix)) + *(m2++)); \ + *(m++) = y = (ISAAC_IND(mm, x) + a + b); \ + *(r++) = b = (ISAAC_IND(mm, y >> ISAAC_LEFTSHIFT) + x) & UINT32_MAX; \ +} + +#define ISAAC_MIX(a, b, c, d, e, f, g, h) \ +{ \ + a ^= b << 11U; d += a; b += c; \ + b ^= (c & UINT32_MAX) >> 2U; e += b; c += d; \ + c ^= d << 8U; f += c; d += e; \ + d ^= (e & UINT32_MAX) >> 16U; g += d; e += f; \ + e ^= f << 10U; h += e; f += g; \ + f ^= (g & UINT32_MAX) >> 4U; a += f; g += h; \ + g ^= h << 8U; b += g; h += a; \ + h ^= (a & UINT32_MAX) >> 9U; c += h; a += b; \ +} + +/* Explanations why it does not look like 1.618033988749894848...: + * https://stackoverflow.com/a/4948967 + * https://softwareengineering.stackexchange.com/a/63605 + */ +#define GOLDEN_RATIO 0x9e3779b9 + +static void isaac_round(isaac_ctx_t* ctx); + +void isaac_init(isaac_ctx_t* const ctx, const bool flag) +{ + uint32_t* m; + uint32_t* r; + uint32_t a; + uint32_t b; + uint32_t c; + uint32_t d; + uint32_t e; + uint32_t f; + uint32_t g; + uint32_t h; + unsigned int i; /* Fastest integer type */ + + ctx->a = ctx->b = ctx->c = 0; + m = ctx->mem; + r = ctx->rsl; + a = b = c = d = e = f = g = h = GOLDEN_RATIO; + + /* scramble it */ + for (i = 0; i < 4; i++) + { + ISAAC_MIX(a, b, c, d, e, f, g, h); + } + /* if (flag==TRUE), then use the contents of rsl[] to initialize mm[]. */ + if (flag) + { + /* initialize using the contents of r[] as the seed */ + for (i = 0; i < ISAAC_SIZE; i += 8) + { + a += r[i]; + b += r[i + 1]; + c += r[i + 2]; + d += r[i + 3]; + e += r[i + 4]; + f += r[i + 5]; + g += r[i + 6]; + h += r[i + 7]; + ISAAC_MIX(a, b, c, d, e, f, g, h); + m[i] = a; + m[i + 1] = b; + m[i + 2] = c; + m[i + 3] = d; + m[i + 4] = e; + m[i + 5] = f; + m[i + 6] = g; + m[i + 7] = h; + } + /* do a second pass to make all of the seed affect all of m */ + for (i = 0; i < ISAAC_SIZE; i += 8) + { + a += m[i]; + b += m[i + 1]; + c += m[i + 2]; + d += m[i + 3]; + e += m[i + 4]; + f += m[i + 5]; + g += m[i + 6]; + h += m[i + 7]; + ISAAC_MIX(a, b, c, d, e, f, g, h); + m[i] = a; + m[i + 1] = b; + m[i + 2] = c; + m[i + 3] = d; + m[i + 4] = e; + m[i + 5] = f; + m[i + 6] = g; + m[i + 7] = h; + } + } + else + { + for (i = 0; i < ISAAC_SIZE; i += 8) + { + /* fill in mm[] with messy stuff */ + ISAAC_MIX(a, b, c, d, e, f, g, h); + m[i] = a; + m[i + 1] = b; + m[i + 2] = c; + m[i + 3] = d; + m[i + 4] = e; + m[i + 5] = f; + m[i + 6] = g; + m[i + 7] = h; + } + } + /* fill in the first set of results */ + isaac_round(ctx); + /* prepare to use the first set of results */ + ctx->cnt = ISAAC_SIZE; +} + +static void isaac_round(isaac_ctx_t* const ctx) +{ + uint32_t* m; + uint32_t* mm; + uint32_t* m2; + uint32_t* r; + uint32_t* mend; + uint32_t a; + uint32_t b; + uint32_t x; + uint32_t y; + + mm = ctx->mem; + r = ctx->rsl; + a = ctx->a; + b = ctx->b + (++ctx->c); + for (m = mm, mend = m2 = m + (ISAAC_SIZE / 2U); m < mend;) + { + ISAAC_STEP(a << 13U, a, b, mm, m, m2, r, x); + ISAAC_STEP((a & UINT32_MAX) >> 6U, a, b, mm, m, m2, r, x); + ISAAC_STEP(a << 2U, a, b, mm, m, m2, r, x); + ISAAC_STEP((a & UINT32_MAX) >> 16U, a, b, mm, m, m2, r, x); + } + for (m2 = mm; m2 < mend;) + { + ISAAC_STEP(a << 13U, a, b, mm, m, m2, r, x); + ISAAC_STEP((a & UINT32_MAX) >> 6U, a, b, mm, m, m2, r, x); + ISAAC_STEP(a << 2U, a, b, mm, m, m2, r, x); + ISAAC_STEP((a & UINT32_MAX) >> 16U, a, b, mm, m, m2, r, x); + } + ctx->b = b; + ctx->a = a; +} + +uint32_t isaac_next(isaac_ctx_t* const ctx) +{ + if (!ctx->cnt--) + { + isaac_round(ctx); + ctx->cnt = ISAAC_SIZE - 1; + } + return ctx->rsl[ctx->cnt]; +} + + +#ifdef NEVER +int main() +{ + +} +#endif diff --git a/tst/atto/atto.c b/tst/atto/atto.c new file mode 100644 index 0000000..3f24995 --- /dev/null +++ b/tst/atto/atto.c @@ -0,0 +1,33 @@ +/** + * @file + * Atto - the microscopic C unit test framework + * + * @copyright Copyright © 2019-2020, Matjaž Guštin + * . All rights reserved. + * @license BSD 3-Clause License + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * 3. Neither the name of nor the names of its contributors may be used to + * endorse or promote products derived from this software without specific + * prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS “AS IS” + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +char atto_at_least_one_fail = 0; diff --git a/tst/atto/atto.h b/tst/atto/atto.h new file mode 100644 index 0000000..bd19668 --- /dev/null +++ b/tst/atto/atto.h @@ -0,0 +1,483 @@ +/** + * @file + * Atto - the microscopic C unit test framework + * + * @copyright Copyright © 2019-2020, Matjaž Guštin + * . All rights reserved. + * @license BSD 3-Clause License + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * 3. Neither the name of nor the names of its contributors may be used to + * endorse or promote products derived from this software without specific + * prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS “AS IS” + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ATTO_H +#define ATTO_H + +#ifdef __cplusplus +extern "C" +{ +#endif + +/** + * Semantic version of this file and framework. + */ +#define ATTO_VERSION "1.2.0" + +#include /* For printf() */ +#include /* For fabs(), fabsf(), isnan(), isinf(), isfinite() */ +#include /* For strncmp(), memcmp() */ + +/** + * Boolean indicating if all tests passed successfully (when 0) or not. + * + * Useful as a value to return from the main function of the test executable, + * so that the test executable returns non-zero in case at least one test + * failed. + */ +extern char atto_at_least_one_fail; + +/** + * Absolute tolerance when comparing two single-precision floating point + * value for approximate-equality using atto_fapprox(). + * + * If the difference between the two float values is bigger than this + * tolerance, the assertion fails. + */ +#define ATTO_FLOAT_EQ_ABSTOL (1e-5f) + +/** + * Absolute tolerance when comparing two double-precision floating point + * value for approximate-equality using atto_dapprox(). + * + * If the difference between the two double values is bigger than this + * tolerance, the assertion fails. + */ +#define ATTO_DOUBLE_EQ_ABSTOL (1e-8) + +/** + * Verifies if the given boolean expression is true. + * + * Otherwise stops the test case immediately and reports the failing file, + * function and line number on standard output. + * + * It's the most generic macro offered by Atto. If you need something more + * specific, try using the other macros instead. + * + * The `do-while(0)` construct allows to write multi-line macros. + * + * If your system does not support `printf()`, replace it with something + * else in this file! For example a `transmit()` function to communicate + * the result to other devices. + * + * Example: + * ``` + * atto_assert(1); // Passes + * atto_assert(0); // Fails + * atto_assert(3 < 1); // Fails + * ``` + */ +#define atto_assert(expression) do { \ + if (!(expression)) { \ + printf("FAIL | File: %s | Line: %4d | Test case: %s\n", \ + __FILE__, __LINE__, __func__); \ + atto_at_least_one_fail = 1U; \ + return; \ + } \ +} while (0) + +/** + * Verifies if the given boolean expression is false. + * + * Otherwise stops the test case immediately and reports the failing file, + * function and line number on standard output. + * + * Example: + * ``` + * atto_false(1); // Fails + * atto_false(0); // Passes + * ``` + */ +#define atto_false(x) atto_assert(!(x)) + +/** + * Verifies if the two arguments are exactly equal. + * + * Otherwise stops the test case immediately and reports the failing file, + * function and line number on standard output. + * + * It is recommended to use this macro instead of calling `atto_assert(a == b)` + * to avoid mistyping the equality comparison operator `==` into the assignment + * operator `=`. + * + * Example: + * ``` + * atto_eq(12, 12); // Passes + * atto_eq(12.0f, 12U); // Passes due to implicit conversion of 12U to 12.0f + * atto_eq(100, 1); // Fails + * ``` + */ +#define atto_eq(a, b) atto_assert((a) == (b)) + +/** + * Verifies if the two arguments are not equal. + * + * Otherwise stops the test case immediately and reports the failing file, + * function and line number on standard output. + * + * Example: + * ``` + * atto_neq(12, 12); // Fails + * atto_neq(12.0f, 12U); // Fails + * atto_neq(100, 1); // Passes + * ``` + */ +#define atto_neq(a, b) atto_assert((a) != (b)) + +/** + * Verifies if the first argument is strictly Greater Than the second. + * + * Otherwise stops the test case immediately and reports the failing file, + * function and line number on standard output. + * + * Example: + * ``` + * atto_gt(1, 10); // Fails + * atto_gt(10, 10); // Fails + * atto_gt(100, 10); // Passes + * ``` + */ +#define atto_gt(a, b) atto_assert((a) > (b)) + +/** + * Verifies if the first argument is Greater or Equal to the second. + * + * Otherwise stops the test case immediately and reports the failing file, + * function and line number on standard output. + * + * Example: + * ``` + * atto_ge(1, 10); // Fails + * atto_ge(10, 10); // Passes + * atto_ge(100, 10); // Passes + * ``` + */ +#define atto_ge(a, b) atto_assert((a) >= (b)) + +/** + * Verifies if the first argument is strictly Less Than the second. + * + * Otherwise stops the test case immediately and reports the failing file, + * function and line number on standard output. + * + * Example: + * ``` + * atto_lt(1, 10); // Passes + * atto_lt(10, 10); // Fails + * atto_lt(100, 10); // Fails + * ``` + */ +#define atto_lt(a, b) atto_assert((a) < (b)) + +/** + * Verifies if the first argument is Less or Equal to the second. + * + * Otherwise stops the test case immediately and reports the failing file, + * function and line number on standard output. + * + * Example: + * ``` + * atto_le(1, 10); // Passes + * atto_le(10, 10); // Fails + * atto_le(100, 10); // Fails + * ``` + */ +#define atto_le(a, b) atto_assert((a) <= (b)) + +/** + * Verifies if two single-precision floating point values are within a given + * absolute tolerance from each other. + * + * Otherwise stops the test case and reports on standard output. + * + * Example: + * ``` + * atto_fdelta(1.0f, 1.00000001f, 0.1f); // Passes + * atto_fdelta(1.0f, 1.1f, 0.15f); // Passes + * atto_fdelta(1.0f, 2.0f, 0.1f); // Fails + * ``` + */ +#define atto_fdelta(a, b, delta) atto_assert(fabsf((a) - (b)) <= fabsf(delta)) + +/** + * Verifies if two single-precision floating point values are within a fixed + * absolute tolerance #ATTO_FLOAT_EQ_ABSTOL from each other. + * + * Useful to check for almost-equality but ignoring minor rounding errors. + * + * Otherwise stops the test case and reports on standard output. + * + * Example: + * ``` + * atto_fapprox(1.0f, 1.000001f); // Passes + * atto_fapprox(1.0f, 1.1); // Fails + * ``` + */ +#define atto_fapprox(a, b) atto_fdelta((a), (b), ATTO_FLOAT_EQ_ABSTOL) + +/** + * Verifies if two double-precision floating point values are within a given + * absolute tolerance from each other. + * + * Otherwise stops the test case and reports on standard output. + * + * Example: + * ``` + * atto_ddelta(1.0, 1.00000001, 0.1); // Passes + * atto_ddelta(1.0, 1.1, 0.15); // Passes + * atto_ddelta(1.0, 2.0, 0.1); // Fails + * ``` + */ +#define atto_ddelta(a, b, delta) \ + atto_assert(fabs((a) - (b)) <= fabs(delta)) + +/** + * Verifies if two double-precision floating point values are within a fixed + * absolute tolerance #ATTO_DOUBLE_EQ_ABSTOL from each other. + * + * Useful to check for almost-equality but ignoring minor rounding errors. + * + * Otherwise stops the test case and reports on standard output. + * + * Example: + * ``` + * atto_dapprox(1.0, 1.00000001); // Passes + * atto_dapprox(1.0, 1.1); // Fails + * ``` + */ +#define atto_dapprox(a, b) atto_ddelta((a), (b), ATTO_DOUBLE_EQ_ABSTOL) + +/** + * Verifies that the floating point value is Not a Number (NaN). + * + * Otherwise stops the test case and reports on standard output. + * + * Example: + * ``` + * atto_nan(NAN); // Passes + * atto_nan(INFINITY); // Fails + * atto_nan(-INFINITY); // Fails + * atto_nan(1.0); // Fails + * atto_nan(1); // Fails + * ``` + */ +#define atto_nan(value) atto_assert(isnan(value)) + +/** + * Verifies that the floating point value is infinity, either positive or + * negative. + * + * Otherwise stops the test case and reports on standard output. + * + * Example: + * ``` + * atto_inf(NAN); // Fails + * atto_inf(INFINITY); // Passes + * atto_inf(-INFINITY); // Passes + * atto_inf(1.0); // Fails + * atto_inf(1); // Fails + * ``` + */ +#define atto_inf(value) atto_assert(isinf(value)) + +/** + * Verifies that the floating point value is positive infinity. + * + * Otherwise stops the test case and reports on standard output. + * + * Example: + * ``` + * atto_plusinf(NAN); // Fails + * atto_plusinf(INFINITY); // Passes + * atto_plusinf(-INFINITY); // Fails + * atto_plusinf(1.0); // Fails + * atto_plusinf(1); // Fails + * ``` + */ +#define atto_plusinf(value) atto_assert((isinf(value)) && (value > 0)) + +/** + * Verifies that the floating point value is negative infinity. + * + * Otherwise stops the test case and reports on standard output. + * + * Example: + * ``` + * atto_minusinf(NAN); // Fails + * atto_minusinf(INFINITY); // Fails + * atto_minusinf(-INFINITY); // Passes + * atto_minusinf(1.0); // Fails + * atto_minusinf(1); // Fails + * ``` + */ +#define atto_minusinf(value) atto_assert((isinf(value)) && (value < 0)) + +/** + * Verifies that the floating point value is finite, thus not NaN or + * +/- infinity. + * + * Otherwise stops the test case and reports on standard output. + * + * Example: + * ``` + * atto_finite(NAN); // Fails + * atto_finite(INFINITY); // Fails + * atto_finite(-INFINITY); // Fails + * atto_finite(1.0); // Passes + * atto_finite(1); // Passes + * ``` + */ +#define atto_finite(value) atto_assert(isfinite(value)) + +/** + * Verifies that the floating point value is not finite, thus either NaN or + * +/- infinity. + * + * Otherwise stops the test case and reports on standard output. + * + * Example: + * ``` + * atto_notfinite(NAN); // Passes + * atto_notfinite(INFINITY); // Passes + * atto_notfinite(-INFINITY); // Passes + * atto_notfinite(1.0); // Fails + * atto_notfinite(1); // Fails + * ``` + */ +#define atto_notfinite(value) atto_assert(!isfinite(value)) + +/** + * Verifies if the bits of the value specified by a bit mask are set to 1. + * + * Otherwise stops the test case and reports on standard output. + * + * Example: + * ``` + * atto_flag(0x07, 1 << 1); // Passes + * atto_flag(0x07, 0x04); // Passes + * atto_flag(0x07, 0x06); // Passes + * atto_flag(0x07, 0xF0); // Fails + * ``` + */ +#define atto_flag(value, mask) atto_assert(((value) & (mask))) + +/** + * Verifies if the bits of the value specified by a bit mask are set to 0. + * + * Otherwise stops the test case and reports on standard output. + * + * Example: + * ``` + * atto_noflag(0x07, 1 << 5); // Passes + * atto_noflag(0x07, 0xF8); // Passes + * atto_noflag(0x07, 0x04); // Fails + * ``` +*/ +#define atto_noflag(value, mask) atto_assert(((value) & (mask)) == 0) + +/** + * Verifies if two strings are equal up to a given length or until the shortest + * string terminates. + * + * Otherwise stops the test case and reports on standard output. + * + * Example: + * ``` + * atto_streq("abcd", "abcd", 2); // Passes + * atto_streq("abcd", "abcd", 4); // Passes + * atto_streq("abcd", "abcd", 100); // Passes, reached null terminator + * atto_streq("abcd", "ABCD", 4); // Fails, different casing + * ``` + */ +#define atto_streq(a, b, maxlen) \ + atto_assert(strncmp((a), (b), (maxlen)) == 0) + +/** + * Verifies if two memory sections are equal up to a given length. + * + * Otherwise stops the test case and reports on standard output. + * + * Example: + * ``` + * atto_memeq("abcd", "abcd", 2); // Passes + * atto_memeq("abcd", "abcd", 4); // Passes + * atto_memeq("abcd", "abcd", 100); // UNDEFINED as exceeding known memory + * atto_memeq("abcd", "ABCD", 4); // Fails + * ``` + */ +#define atto_memeq(a, b, len) atto_assert(memcmp((a), (b), len) == 0) + +/** +* Verifies if two memory sections are different within the given length. +* +* Otherwise stops the test case and reports on standard output. +* +* Example: +* ``` +* atto_memneq("abcd", "abcd", 2); // Fails +* atto_memneq("abcd", "abcd", 4); // Fails +* atto_memneq("abcd", "abcd", 100); // UNDEFINED as exceeding known memory +* atto_memneq("abcd", "abCD", 4); // Passes +* ``` +*/ +#define atto_memneq(a, b, len) atto_assert(memcmp((a), (b), len) != 0) + +/** +* Verifies if a memory section is filled with just zeros. +* +* Otherwise stops the test case and reports on standard output. +* +* Example: +* ``` +* atto_zeros("abcd", 2); // Fails +* atto_zeros("\0\0cd", 2); // Passes +* atto_zeros("\0\0cd", 4); // Fails +* atto_zeros("\0\0\0\0", 4); // Passes +* atto_zeros("\0\0\0\0", 100); // UNDEFINED as exceeding known memory +* ``` +*/ +#define atto_zeros(x, len) \ + for (unsigned long long atto_idx = 0; atto_idx < (len); atto_idx ++) { \ + atto_eq((x)[atto_idx], 0); \ + } + +/** + * Forces a failure of the test case, stopping it and reporting on standard + * output. + */ +#define atto_fail() atto_assert(0) + +#ifdef __cplusplus +} +#endif + +#endif /* ATTO_H */ diff --git a/tst/test.c b/tst/test.c new file mode 100644 index 0000000..49e3226 --- /dev/null +++ b/tst/test.c @@ -0,0 +1,18 @@ +/** + * @file + * + * Test suite runner of LibISAAC. + * + * @copyright Copyright © 2020, Matjaž Guštin + * . All rights reserved. + * @license BSD 3-clause license. + */ + +#include "test.h" + +int main(void) +{ + test_isaac_init(); + test_isaac_next(); + return atto_at_least_one_fail; +} diff --git a/tst/test.h b/tst/test.h new file mode 100644 index 0000000..dcf44fb --- /dev/null +++ b/tst/test.h @@ -0,0 +1,31 @@ +/** + * @file + * + * @copyright Copyright © 2020, Matjaž Guštin + * . All rights reserved. + * @license BSD 3-clause license. + */ + +#ifndef TEST_H +#define TEST_H + +#ifdef __cplusplus +extern "C" +{ +#endif + +#include +#include +#include "isaac.h" +#include "atto.h" +#include +#include + +void test_isaac_init(void); +void test_isaac_next(void); + +#ifdef __cplusplus +} +#endif + +#endif /* TEST_H */ diff --git a/tst/test_init.c b/tst/test_init.c new file mode 100644 index 0000000..5a53897 --- /dev/null +++ b/tst/test_init.c @@ -0,0 +1,202 @@ +/** + * @file + * + * Test suite of LibISAAC + * + * @copyright Copyright © 2020, Matjaž Guštin + * . All rights reserved. + * @license BSD 3-clause license. + */ + +#include "test.h" + +const static uint8_t expected_initialised_ctx[] = { + 0x00, 0x01, 0x00, 0x00, 0x39, 0xD3, 0x6D, 0xE7, 0x38, 0xA7, 0x1A, 0xD9, + 0xE5, 0x56, 0x29, 0xD3, 0x33, 0xE9, 0x64, 0xA2, 0x23, 0x00, 0xD2, 0x3D, + 0xDD, 0x1E, 0x6F, 0x45, 0xF4, 0x9C, 0xC5, 0x96, 0xFC, 0x88, 0xA3, 0xD3, + 0xC1, 0xA1, 0x89, 0x5D, 0xFC, 0x13, 0xF4, 0x49, 0x1E, 0xD9, 0x73, 0x48, + 0x43, 0x0E, 0x84, 0x2F, 0x62, 0xBD, 0x6A, 0xED, 0xAB, 0xA5, 0xC8, 0x10, + 0x7B, 0xA5, 0xC1, 0x43, 0x10, 0x1E, 0x0B, 0xD7, 0x04, 0xDC, 0x73, 0x81, + 0xAA, 0x8E, 0xF7, 0x53, 0x84, 0x1D, 0x65, 0x89, 0xFA, 0x7F, 0xBE, 0xD5, + 0xCE, 0xE7, 0x57, 0x6F, 0x47, 0xC4, 0x8A, 0x9C, 0x42, 0xE3, 0x73, 0x00, + 0x6C, 0xA6, 0x5A, 0x36, 0x5E, 0x1C, 0x66, 0x97, 0x9E, 0xE4, 0x90, 0xAF, + 0x23, 0x0A, 0x09, 0x8C, 0x42, 0x45, 0x86, 0x0E, 0x39, 0xDF, 0xE0, 0x3D, + 0x8E, 0xF4, 0x7A, 0xBF, 0xE7, 0x1B, 0x87, 0x13, 0x49, 0x8B, 0x7A, 0x3E, + 0x6F, 0xD3, 0x07, 0x42, 0x30, 0xC6, 0x8E, 0x4A, 0x72, 0xB2, 0x06, 0x0A, + 0x54, 0x76, 0x90, 0x66, 0x44, 0x82, 0xED, 0x9D, 0xB8, 0x8B, 0x02, 0x32, + 0xC6, 0x01, 0x39, 0x4C, 0x34, 0x08, 0x47, 0xB6, 0xCA, 0xD7, 0x1B, 0x62, + 0xEC, 0xAD, 0x13, 0xF3, 0x83, 0x98, 0x65, 0x2F, 0x02, 0x97, 0x97, 0x9E, + 0x84, 0xD1, 0xAD, 0xBB, 0xA5, 0x14, 0xDD, 0x03, 0x1C, 0xC2, 0xAB, 0x43, + 0x29, 0x22, 0x5E, 0x56, 0x27, 0xE9, 0xDA, 0x89, 0xFB, 0x0A, 0x06, 0x60, + 0x31, 0x0B, 0x89, 0xCA, 0x52, 0x35, 0x25, 0xD5, 0x80, 0xA4, 0x2B, 0xAD, + 0x0E, 0x4B, 0x19, 0xE1, 0x0D, 0x5C, 0x84, 0x2D, 0x53, 0x8E, 0xA4, 0x97, + 0x2F, 0xBC, 0xEF, 0xC7, 0x96, 0xE4, 0x71, 0x99, 0xDE, 0xC2, 0xD8, 0x80, + 0x0B, 0x71, 0xE5, 0xA0, 0x69, 0x59, 0x95, 0x0F, 0x4C, 0xE1, 0x66, 0xB5, + 0xDA, 0xD6, 0x0C, 0x0B, 0xF6, 0x89, 0xF4, 0xE5, 0xDE, 0x7A, 0x90, 0x2C, + 0x2E, 0xF0, 0xE3, 0x7B, 0x07, 0x3B, 0xF6, 0x71, 0x7F, 0xE5, 0xE6, 0x09, + 0x7A, 0x3E, 0x37, 0x4C, 0x39, 0x26, 0x9A, 0xC9, 0x17, 0x3D, 0x71, 0x54, + 0x1A, 0x83, 0xF0, 0x11, 0x4E, 0x1C, 0xAA, 0x76, 0x01, 0x7F, 0xF5, 0xDB, + 0xA8, 0x60, 0x21, 0x8B, 0x09, 0x4C, 0x2F, 0x2B, 0x74, 0x69, 0x5E, 0xCC, + 0xC4, 0x83, 0xE2, 0xFD, 0x94, 0x6B, 0x9E, 0x8B, 0xCA, 0x89, 0x1A, 0x80, + 0xC0, 0x11, 0x1B, 0x65, 0xCD, 0x41, 0x0D, 0x36, 0xD6, 0x43, 0x24, 0xBF, + 0xD5, 0x1F, 0x80, 0x79, 0xB3, 0x25, 0x5F, 0xD9, 0x85, 0xD7, 0x49, 0xB8, + 0xF3, 0xC5, 0xC7, 0x5F, 0x00, 0x3D, 0x8D, 0x36, 0xC2, 0xEE, 0xC5, 0x85, + 0x20, 0x55, 0x2F, 0x7E, 0xDC, 0x2A, 0xBA, 0x41, 0x48, 0x98, 0x50, 0x5C, + 0x80, 0xDC, 0x61, 0x07, 0xA4, 0x83, 0x27, 0x87, 0x7C, 0x90, 0xCE, 0x71, + 0xA8, 0x1F, 0x80, 0x52, 0xF4, 0xE3, 0xE8, 0x64, 0x1E, 0xD5, 0x21, 0x5D, + 0xBA, 0x0D, 0x93, 0xF4, 0x02, 0x70, 0x34, 0x3B, 0x32, 0xBD, 0xB6, 0x4E, + 0x3A, 0x5A, 0x58, 0xF9, 0xBD, 0xFA, 0x60, 0x7A, 0x7A, 0xF9, 0xEC, 0x49, + 0xEB, 0xCA, 0xFC, 0x82, 0x5C, 0xAB, 0xB8, 0xFF, 0xE2, 0xCE, 0x44, 0x18, + 0xA6, 0x5C, 0x1F, 0x16, 0xAB, 0xFC, 0x5C, 0xAF, 0xD6, 0x95, 0x2C, 0x33, + 0x1D, 0x98, 0xB5, 0xA5, 0xE6, 0xD9, 0xD8, 0x99, 0xCB, 0xEF, 0x95, 0x60, + 0x28, 0xE4, 0xE6, 0xAD, 0x40, 0x11, 0x0A, 0x29, 0x45, 0x2B, 0x82, 0x67, + 0x66, 0xC3, 0x9A, 0x35, 0x54, 0x34, 0x25, 0xFB, 0x3C, 0x75, 0x8E, 0x8B, + 0xF6, 0x12, 0xAB, 0x7C, 0xA6, 0x00, 0x50, 0xE1, 0x96, 0x08, 0xF4, 0x4A, + 0x32, 0xB1, 0x6F, 0x5B, 0x9B, 0xB1, 0x84, 0xFD, 0x02, 0x1D, 0x3A, 0xA4, + 0x25, 0x37, 0x2C, 0x67, 0x42, 0xAC, 0x21, 0x9D, 0x70, 0xCC, 0xF4, 0x3F, + 0x65, 0xA4, 0x1E, 0xE4, 0x64, 0x20, 0xBB, 0xE3, 0x9D, 0xD7, 0xC4, 0x44, + 0x93, 0xE8, 0xD6, 0x44, 0xC6, 0x85, 0x63, 0x43, 0x6E, 0xD0, 0x10, 0xB3, + 0x48, 0xE5, 0x8B, 0xDF, 0xC6, 0xDF, 0x92, 0x29, 0xE4, 0xD9, 0xCB, 0xB2, + 0x15, 0xB9, 0xB4, 0x80, 0x66, 0x5C, 0xFC, 0xB3, 0xB2, 0x5B, 0x72, 0x7A, + 0x84, 0x5B, 0x65, 0x4C, 0x64, 0xD7, 0xD1, 0x1A, 0xEB, 0x43, 0x30, 0x1D, + 0x6B, 0x33, 0xCC, 0xB0, 0x38, 0x45, 0x2F, 0x6B, 0x9B, 0x66, 0x29, 0x3D, + 0xF3, 0xAC, 0x75, 0x62, 0x4F, 0xD6, 0xDF, 0x08, 0x01, 0x82, 0x65, 0x36, + 0xA3, 0x96, 0x7E, 0x00, 0xF5, 0x02, 0x3A, 0x00, 0x8F, 0x8A, 0xF3, 0xDB, + 0xEE, 0x30, 0x55, 0x20, 0x33, 0x03, 0x31, 0xB3, 0x7F, 0x8C, 0xFC, 0x7D, + 0x22, 0x2A, 0xB2, 0x10, 0xCC, 0x7B, 0xC1, 0x9C, 0x71, 0x19, 0xBA, 0xC6, + 0xAC, 0xE2, 0x30, 0xC2, 0xC6, 0x06, 0x5E, 0xDD, 0x49, 0xEC, 0x07, 0x3F, + 0xD5, 0xD9, 0xD3, 0x1A, 0xBA, 0x0D, 0x5F, 0x76, 0x24, 0x81, 0x41, 0xC5, + 0x54, 0xED, 0x0D, 0x06, 0x9B, 0x31, 0x55, 0xFA, 0x01, 0x31, 0x56, 0x5B, + 0x14, 0xAD, 0x31, 0xB8, 0x23, 0xC3, 0x7D, 0x9C, 0xF1, 0xBA, 0x99, 0xE0, + 0x9A, 0x1C, 0x08, 0x7F, 0x3C, 0xA2, 0xCF, 0xB7, 0x46, 0x85, 0xE4, 0xD7, + 0xBE, 0x94, 0xBB, 0x4F, 0x29, 0x5D, 0x0B, 0xB1, 0xB2, 0xC9, 0x53, 0x7C, + 0x6E, 0xAD, 0x35, 0x09, 0x02, 0xFF, 0x5F, 0xCC, 0xD5, 0x02, 0x48, 0xE3, + 0x32, 0x98, 0x35, 0x03, 0xDB, 0x20, 0xAC, 0x4D, 0x6D, 0x40, 0xF0, 0xBA, + 0xB4, 0x65, 0xD5, 0x15, 0xD0, 0x1F, 0xDF, 0x1B, 0x4F, 0x8A, 0x4B, 0x39, + 0xED, 0xA9, 0x7E, 0x2E, 0xE4, 0x69, 0x29, 0x0F, 0x0C, 0x74, 0x0A, 0x89, + 0x16, 0x25, 0x34, 0xDE, 0x7E, 0xD9, 0x26, 0x90, 0x5F, 0x82, 0x21, 0x95, + 0x39, 0x9A, 0x35, 0x6F, 0x8B, 0x3F, 0xCB, 0x98, 0xAB, 0xD8, 0xC0, 0x02, + 0x7D, 0x34, 0x2B, 0x90, 0x04, 0x0E, 0xFE, 0x1F, 0xF1, 0xBD, 0x60, 0xF4, + 0x56, 0x6E, 0xDC, 0xA7, 0xBF, 0x7E, 0xCB, 0x17, 0x6D, 0x01, 0x26, 0xB0, + 0x3B, 0x96, 0x6E, 0xED, 0x7B, 0x76, 0xEB, 0x72, 0xEA, 0x3E, 0xF6, 0xBE, + 0x10, 0x18, 0x46, 0x6F, 0xAD, 0x5E, 0xBA, 0x7B, 0xEA, 0x00, 0x3C, 0x5D, + 0x54, 0xD2, 0xFD, 0x4C, 0xAE, 0xC8, 0x5C, 0x67, 0xBE, 0xFA, 0x7F, 0xB9, + 0x76, 0xD4, 0x92, 0x24, 0x0A, 0x93, 0x83, 0x4E, 0x4D, 0x77, 0xF0, 0x26, + 0xDE, 0xA4, 0x90, 0x4B, 0x81, 0xCE, 0xE6, 0x6B, 0x58, 0x21, 0xCA, 0x19, + 0x94, 0xEB, 0x58, 0xA3, 0xD7, 0x9C, 0xD1, 0x42, 0xAE, 0x1E, 0x04, 0xC7, + 0x27, 0xF6, 0xB4, 0xE8, 0x6F, 0x7B, 0xE1, 0x02, 0x99, 0x0E, 0x8A, 0xFB, + 0x7B, 0x4C, 0x60, 0x9E, 0x0D, 0xDA, 0x1E, 0xC0, 0x00, 0xA9, 0xD4, 0xEA, + 0xC4, 0x31, 0x21, 0x84, 0x94, 0xD9, 0x2F, 0x47, 0x0F, 0xD2, 0xAC, 0xC6, + 0x79, 0xFF, 0xD3, 0x44, 0xCE, 0x4F, 0xC0, 0x05, 0x17, 0x8B, 0x64, 0x67, + 0x0D, 0x4D, 0x7C, 0xF2, 0x6F, 0xE8, 0x16, 0x00, 0xA4, 0xCF, 0x29, 0x16, + 0x8F, 0x0B, 0x45, 0xAC, 0xB9, 0xEA, 0xB3, 0x5A, 0x24, 0x5E, 0xC7, 0xF4, + 0xBD, 0x71, 0xC8, 0x25, 0xFA, 0x6F, 0xE1, 0xBA, 0x29, 0xFA, 0x49, 0x62, + 0x18, 0x9E, 0xC2, 0xC5, 0x7A, 0xF5, 0x58, 0xA6, 0xBD, 0x8F, 0x0F, 0xC9, + 0x1D, 0xB7, 0x7C, 0x34, 0x74, 0x3F, 0xC3, 0x96, 0xFB, 0x9A, 0x4C, 0xCC, + 0xC2, 0x41, 0x4F, 0x89, 0xEF, 0x1D, 0x25, 0x52, 0xAF, 0x1F, 0x07, 0x5F, + 0x24, 0x9C, 0xC9, 0x0F, 0xB5, 0xA8, 0xFF, 0xB3, 0xE9, 0x06, 0x52, 0x99, + 0x79, 0xD6, 0x6F, 0x29, 0x21, 0xCD, 0x8A, 0xB0, 0x22, 0x66, 0x1B, 0x30, + 0x8D, 0x4A, 0x0B, 0x30, 0xF3, 0x00, 0x26, 0x18, 0x81, 0x7A, 0x04, 0x56, + 0x99, 0x05, 0x66, 0xD6, 0x4B, 0x9A, 0x15, 0xB0, 0x2A, 0xDC, 0x64, 0x19, + 0x6C, 0x42, 0x02, 0x4D, 0x95, 0x61, 0x0F, 0x68, 0x69, 0xD7, 0x4C, 0xB0, + 0xBD, 0x84, 0x17, 0x11, 0xAE, 0x04, 0x73, 0x26, 0x48, 0x2F, 0x45, 0x7E, + 0xED, 0xF7, 0xCF, 0x02, 0x89, 0x78, 0x6E, 0xCC, 0x5A, 0x53, 0x3A, 0x7D, + 0xC0, 0xE3, 0x8E, 0x36, 0x2C, 0x80, 0x4D, 0x3F, 0x9E, 0x9E, 0x18, 0xEE, + 0x0E, 0x35, 0x6D, 0x63, 0xBF, 0x99, 0xFD, 0x59, 0x83, 0x29, 0xA2, 0xC5, + 0x5B, 0x5D, 0x9A, 0x4B, 0xDB, 0x09, 0x47, 0xC4, 0xFD, 0xFF, 0x63, 0x89, + 0x4A, 0xDF, 0x4C, 0xE5, 0xA6, 0x9D, 0xFC, 0x6E, 0xD5, 0x47, 0x27, 0x34, + 0xC1, 0xE6, 0x59, 0x60, 0x56, 0x06, 0xF4, 0x90, 0x3A, 0x6B, 0x85, 0x4B, + 0x10, 0x80, 0x93, 0xD4, 0x58, 0x5D, 0xFD, 0xA4, 0x85, 0xB8, 0xB0, 0xA4, + 0x23, 0x11, 0xA9, 0xD9, 0x6E, 0x4B, 0xE0, 0x1E, 0xCA, 0x79, 0x11, 0x43, + 0x52, 0xC0, 0x6C, 0x5D, 0xA5, 0x54, 0x91, 0xFA, 0x2E, 0x17, 0xD4, 0x8C, + 0xC5, 0x70, 0x73, 0xD4, 0x76, 0x76, 0xD1, 0xAC, 0x6C, 0x34, 0xFD, 0xAA, + 0x2E, 0x71, 0x30, 0x07, 0x8F, 0xAE, 0x93, 0x47, 0x02, 0xE5, 0x8D, 0x1C, + 0x2A, 0xFC, 0x9C, 0x0B, 0x3C, 0x9D, 0xDD, 0x64, 0xB9, 0x2E, 0x66, 0x51, + 0x40, 0xBC, 0xAF, 0xC9, 0xED, 0xE1, 0x75, 0x1E, 0x58, 0xB0, 0xD4, 0x4F, + 0x97, 0xC1, 0x70, 0xB3, 0xC3, 0x7B, 0x5A, 0xE1, 0xDD, 0x20, 0x2E, 0x38, + 0x83, 0x33, 0x03, 0x0F, 0x0E, 0xDC, 0x00, 0xCB, 0xFE, 0x4C, 0x04, 0xEF, + 0x3A, 0xBE, 0xF5, 0xAA, 0x5C, 0x17, 0x25, 0xF2, 0x88, 0x31, 0x76, 0x8A, + 0x14, 0x69, 0x6A, 0x4B, 0xAF, 0xC1, 0x8B, 0x7A, 0x5B, 0x7C, 0x5C, 0x05, + 0x25, 0x64, 0x80, 0xFE, 0x94, 0xA4, 0xF9, 0x4B, 0xDF, 0x37, 0x62, 0x01, + 0xED, 0xC2, 0xB7, 0xE2, 0x50, 0x88, 0x1E, 0x6F, 0x0B, 0xEA, 0x5B, 0x7B, + 0x13, 0x06, 0x35, 0x1D, 0xD7, 0x29, 0x4E, 0xF9, 0xC1, 0x2F, 0xE9, 0x55, + 0xEA, 0x5D, 0x91, 0xD2, 0x6A, 0x05, 0xF3, 0xF9, 0x69, 0x3F, 0x1B, 0x12, + 0x8D, 0xFD, 0x72, 0xC3, 0x64, 0x1E, 0x35, 0xD0, 0x16, 0x39, 0x04, 0xCA, + 0x2E, 0xD6, 0x3F, 0x33, 0x5C, 0x67, 0xC4, 0x17, 0xA2, 0x8E, 0x30, 0xA3, + 0x95, 0x7F, 0xD0, 0x13, 0x4F, 0xE1, 0xF2, 0x09, 0x0F, 0xC8, 0x8A, 0x46, + 0xAA, 0x50, 0x13, 0xE5, 0xB5, 0xB3, 0xDC, 0x85, 0xDE, 0xA9, 0xEF, 0xC1, + 0x5E, 0x5C, 0xB4, 0xFA, 0xEA, 0x75, 0x07, 0xAA, 0xE2, 0xA4, 0xB6, 0x70, + 0x84, 0xCE, 0x3D, 0x5B, 0x69, 0x95, 0xC5, 0xE8, 0xE9, 0xCC, 0x6D, 0xE1, + 0x03, 0xC9, 0xC9, 0xEA, 0xE9, 0xD5, 0x99, 0x16, 0x2D, 0x75, 0xCE, 0xB5, + 0xF0, 0x48, 0x8A, 0x30, 0xC1, 0xC1, 0xD5, 0xBC, 0xD1, 0xE2, 0xC4, 0x3C, + 0x10, 0xA8, 0x52, 0xE3, 0x88, 0xC6, 0xB0, 0xD6, 0x45, 0x1F, 0x5E, 0x63, + 0x56, 0x38, 0xFF, 0x16, 0x89, 0x19, 0x53, 0x26, 0xD0, 0x5D, 0xCE, 0x71, + 0x13, 0x16, 0x03, 0x65, 0x4A, 0xC8, 0x5C, 0x42, 0xFA, 0xF9, 0xB8, 0xFD, + 0x99, 0x87, 0x64, 0x6B, 0x39, 0xA6, 0xE1, 0x4E, 0xD8, 0x08, 0x6E, 0xEB, + 0x58, 0xA2, 0x88, 0x6A, 0x21, 0x2D, 0x05, 0xA6, 0x29, 0x30, 0xFF, 0x1D, + 0x72, 0x39, 0x41, 0x05, 0x17, 0x89, 0xB8, 0xDE, 0xB6, 0xFA, 0x4E, 0x17, + 0x47, 0x6A, 0x4C, 0xA0, 0x81, 0x3F, 0xE6, 0x63, 0x6C, 0x16, 0x89, 0x70, + 0xAD, 0x28, 0x32, 0x89, 0xB0, 0xEA, 0x4A, 0xEB, 0xCE, 0x9B, 0xA0, 0x10, + 0x63, 0x6D, 0xB4, 0x79, 0x9D, 0x91, 0xCC, 0x69, 0x2E, 0x30, 0x7E, 0xC1, + 0x6E, 0xE5, 0x7E, 0x50, 0x35, 0x57, 0xCE, 0x07, 0x8F, 0xD8, 0x3C, 0xF6, + 0x5A, 0x82, 0xA8, 0xFE, 0xE0, 0x12, 0xD2, 0xEB, 0x9B, 0xDD, 0xFF, 0x75, + 0x67, 0xC9, 0x9E, 0xBD, 0x23, 0xF7, 0xBE, 0xF2, 0xB3, 0x70, 0x98, 0x02, + 0x8B, 0xD0, 0xAB, 0x3A, 0x64, 0x77, 0x39, 0x64, 0x11, 0x34, 0xCE, 0x08, + 0xCF, 0x47, 0xBC, 0x49, 0x04, 0xAC, 0xC3, 0xEB, 0xD4, 0xE3, 0xE2, 0x0D, + 0x37, 0xE4, 0x28, 0x38, 0x53, 0x92, 0x2F, 0x1F, 0xA8, 0x57, 0x2A, 0x3F, + 0x32, 0xDA, 0x1B, 0xB5, 0x86, 0x8E, 0x49, 0xED, 0xAC, 0xF6, 0xC9, 0xD2, + 0x81, 0x73, 0x27, 0xA6, 0xD7, 0x6A, 0xA4, 0x15, 0x57, 0xE6, 0x54, 0xFA, + 0xB8, 0x79, 0x94, 0xB4, 0x95, 0xB1, 0xF4, 0x95, 0x03, 0x17, 0x4F, 0xDB, + 0x14, 0x5A, 0x74, 0x54, 0xBC, 0xC3, 0xB8, 0x02, 0x78, 0x49, 0xA1, 0xFE, + 0xAE, 0x80, 0xAA, 0xAD, 0xED, 0xFC, 0x32, 0x24, 0xC2, 0x0F, 0xBB, 0xF4, + 0x07, 0xA4, 0xF6, 0x87, 0x4C, 0xF2, 0x15, 0x0C, 0xF4, 0xAD, 0x0F, 0x79, + 0x28, 0x8D, 0x76, 0x50, 0xC7, 0x13, 0x96, 0x34, 0x90, 0x6F, 0x70, 0x37, + 0xB6, 0xB5, 0x47, 0xE0, 0xD1, 0x55, 0x29, 0x16, 0x62, 0xE5, 0xC6, 0x46, + 0x94, 0x56, 0x70, 0xCF, 0x4B, 0x78, 0xA3, 0x92, 0xE0, 0x4C, 0xD2, 0x4C, + 0x9D, 0x52, 0x63, 0x3A, 0x39, 0xD9, 0x80, 0xC9, 0xC4, 0x65, 0x6E, 0x91, + 0x1E, 0x2D, 0xEA, 0x27, 0x39, 0x23, 0xAD, 0x77, 0xC2, 0x61, 0x7A, 0x35, + 0x91, 0x3C, 0x6A, 0x13, 0x25, 0xF9, 0x95, 0xDC, 0xB8, 0xAA, 0x8E, 0x8B, + 0x60, 0xAD, 0x2A, 0x6E, 0xD6, 0xCB, 0xEA, 0xC3, 0xDA, 0xC6, 0x73, 0x10, + 0xAA, 0x3D, 0x56, 0x4D, 0x5E, 0x29, 0xD0, 0x1A, 0x54, 0xDA, 0x3F, 0xF2, + 0x44, 0xD7, 0xFB, 0x4F, 0x8C, 0x80, 0x78, 0xD0, 0x7E, 0x9D, 0xDF, 0xA6, + 0x0B, 0xF3, 0x07, 0x3A, 0xBB, 0x15, 0xD2, 0xD4, 0x12, 0x07, 0x50, 0x9E, + 0x87, 0x15, 0x0F, 0x87, 0xB3, 0x99, 0xDF, 0x03, 0x93, 0xA8, 0x69, 0xE1, + 0x7A, 0x02, 0x2A, 0x5D, 0xC3, 0x4E, 0xB4, 0x4A, 0x7C, 0xB2, 0x62, 0xCC, + 0xA2, 0x6C, 0xBA, 0x20, 0x20, 0x75, 0x7A, 0xD8, 0xA6, 0xE0, 0xEF, 0x76, + 0x4D, 0xD7, 0xCF, 0x31, 0xFB, 0xEC, 0x4A, 0xB6, 0x75, 0xB0, 0x0E, 0x94, + 0xCC, 0xE8, 0x49, 0xAB, 0xE4, 0x97, 0x11, 0x70, 0xDF, 0xF8, 0x27, 0xC7, + 0xD1, 0x41, 0xBD, 0x46, 0x57, 0x4B, 0xBC, 0x71, 0x7E, 0xB2, 0x4F, 0x55, + 0xB8, 0x95, 0xB4, 0x12, 0x2D, 0x18, 0x21, 0x98, 0x4E, 0x60, 0xA0, 0x57, + 0x6E, 0x4A, 0xAE, 0x65, 0xE7, 0xE5, 0x97, 0xAD, 0xB1, 0x62, 0xE7, 0x16, + 0x34, 0x8F, 0xFA, 0xFC, 0x54, 0x8F, 0xA1, 0x5C, 0x83, 0xA0, 0x06, 0x34, + 0xA6, 0x94, 0xB1, 0xA1, 0x96, 0xB2, 0x2D, 0x25, 0xD6, 0x0F, 0xEC, 0x43, + 0x29, 0x74, 0x94, 0x26, 0xA2, 0x2F, 0xB1, 0x6C, 0xB2, 0xA4, 0x38, 0x6D, + 0xA9, 0x37, 0x2A, 0x4A, 0x01, 0xD1, 0x6E, 0x6B, 0x37, 0x84, 0x18, 0xFD, + 0x76, 0xCA, 0xD7, 0xED, 0x33, 0x85, 0x30, 0x96, 0x86, 0x8D, 0x5C, 0xC8, + 0x36, 0xBC, 0x79, 0x41, 0x8E, 0x37, 0xF7, 0x35, 0x66, 0xB4, 0x6D, 0x0B, + 0x39, 0xAC, 0x48, 0x1C, 0x96, 0x69, 0x1F, 0x0C, 0xA9, 0x10, 0x58, 0x71, + 0x07, 0xD0, 0xAE, 0x7A, 0x6A, 0x53, 0x3F, 0x10, 0x3F, 0x46, 0xA9, 0x89, + 0x28, 0xDD, 0x25, 0x03, 0x7F, 0xB5, 0x97, 0x5E, 0xB6, 0x9B, 0xFA, 0x4C, + 0x4F, 0x08, 0xE5, 0x24, 0x9D, 0xE5, 0xC9, 0x65, 0x45, 0x29, 0xCD, 0xC4, + 0xC4, 0x84, 0x91, 0x7F, 0x8A, 0xDE, 0xAA, 0xC1, 0x0B, 0xAE, 0xE5, 0x10, + 0xDD, 0xCA, 0xB2, 0x35, 0x11, 0xE2, 0xF5, 0xEA, 0xA6, 0x8C, 0xDE, 0x8F, + 0x77, 0x22, 0xC8, 0x5F, 0x81, 0x11, 0xAD, 0x58, 0x71, 0x0A, 0x71, 0x3D, + 0x2F, 0xC3, 0x10, 0x0B, 0xD6, 0x36, 0xBB, 0x94, 0x09, 0x05, 0xD8, 0x71, + 0x48, 0x2B, 0xD2, 0x44, 0xF3, 0x00, 0x26, 0x18, 0x01, 0x00, 0x00, 0x00, +}; + +static void test_init_against_reference(void) +{ + isaac_ctx_t ctx; + memset(&ctx, 0, sizeof(ctx)); + + isaac_init(&ctx, true); + + atto_eq(sizeof(ctx), sizeof(expected_initialised_ctx)); + atto_memeq(&ctx, expected_initialised_ctx, sizeof(ctx)); +} + +void test_isaac_init(void) +{ + test_init_against_reference(); +} diff --git a/tst/test_next.c b/tst/test_next.c new file mode 100644 index 0000000..fc2ee3b --- /dev/null +++ b/tst/test_next.c @@ -0,0 +1,142 @@ +/** + * @file + * + * Test suite of LibISAAC + * + * @copyright Copyright © 2020, Matjaž Guštin + * . All rights reserved. + * @license BSD 3-clause license. + */ + +#include "test.h" + +#define EXPECTED_UINT32_ENTRIES 512 + +const static uint32_t expected_random_stream[EXPECTED_UINT32_ENTRIES] = { + 0xF650E4C8UL, 0xE448E96DUL, 0x98DB2FB4UL, 0xF5FAD54FUL, 0x433F1AFBUL, + 0xEDEC154AUL, 0xD8370487UL, 0x46CA4F9AUL, 0x5DE3743EUL, 0x88381097UL, + 0xF1D444EBUL, 0x823CEDB6UL, 0x6A83E1E0UL, 0x4A5F6355UL, 0xC7442433UL, + 0x25890E2EUL, 0x7452E319UL, 0x57161DF6UL, 0x38A824F3UL, 0x002ED713UL, + 0x29F55449UL, 0x51C08D83UL, 0xD78CB99EUL, 0xA0CC74F3UL, 0x8F651659UL, + 0xCBC8B7C2UL, 0xF5F71C69UL, 0x12AD6419UL, 0xE5792E1BUL, 0x860536B8UL, + 0x09B3CE98UL, 0xD45D6D81UL, 0xF3B26129UL, 0x17E38F85UL, 0x29CF72CEUL, + 0x349947B0UL, 0xC998F9FFUL, 0xB5E13DAEUL, 0x32AE2A2BUL, 0xF7CF814CUL, + 0x8EBFA303UL, 0xCF22E064UL, 0x0B923200UL, 0xECA4D58AUL, 0xEF53CEC4UL, + 0xD0F7B37DUL, 0x9C411A2AUL, 0xFFDF8A80UL, 0xB40E27BCUL, 0xB4D2F976UL, + 0x44B89B08UL, 0xF37C71D5UL, 0x1A70E7E9UL, 0x0BDB9C30UL, 0x60DC5207UL, + 0xB3C3F24BUL, 0xD7386806UL, 0x229749B5UL, 0x4E232CD0UL, 0x91DABC65UL, + 0xA70E1101UL, 0x8B87437EUL, 0x5781414FUL, 0xCDBC62E2UL, 0x8107C9FFUL, + 0x69D2E4AEUL, 0x3B18E752UL, 0xB143B688UL, 0x6F4E0772UL, 0x95138769UL, + 0x943C3C74UL, 0xAFC17A97UL, 0x0FD43963UL, 0x6A529B0BUL, 0xD8C58A6AUL, + 0xA8BCC22DUL, 0x2DB35DFEUL, 0xA7A2F402UL, 0x6CB167DBUL, 0x538E1F4EUL, + 0x7275E277UL, 0x1D3B8E97UL, 0xECC5DC91UL, 0x15E3A5B9UL, 0x03696614UL, + 0x30AB93ECUL, 0xAC9FE69DUL, 0x7BC76811UL, 0x60EDA8DAUL, 0x28833522UL, + 0xD5295EBCUL, 0x5ADB60E7UL, 0xF7E1CDD0UL, 0x97166D14UL, 0xB67EC13AUL, + 0x210F3925UL, 0x64AF0FEFUL, 0x0D028684UL, 0x3AEA3DECUL, 0xB058BAFBUL, + 0xB8B0CCFCUL, 0xF2B5CC05UL, 0xE3A662D9UL, 0x814BC24CUL, 0x2364A1AAUL, + 0x37C0ED05UL, 0x2B36505CUL, 0x451E7EC8UL, 0x5D2A542FUL, 0xE43D0FBBUL, + 0x91C8D925UL, 0x60D4D5F8UL, 0x12A0594BUL, 0x9E8A51DAUL, 0xCD49EBDBUL, + 0x1B0DCDC1UL, 0xCD57C7F7UL, 0xE6344451UL, 0x7DED386FUL, 0x2F36FA86UL, + 0xA6D12101UL, 0x33BC405DUL, 0xB388D96CUL, 0xDB6DBE96UL, 0xFE29661CUL, + 0x13EDC0CBUL, 0xCB0EEE4AUL, 0x70CC94AEUL, 0xDE11ED34UL, 0x0606CF9FUL, + 0x3A6CE389UL, 0x23D74F4EUL, 0xA37F63FFUL, 0x917BDEC2UL, 0xD73F72D4UL, + 0x0E7E0E67UL, 0x3D77D9A2UL, 0x13ADD922UL, 0x8891B3DBUL, 0x01A9BD70UL, + 0x56A001E3UL, 0xD51F093DUL, 0xCC033CE3UL, 0x5AD0D3B0UL, 0x34105A8CUL, + 0x6A123F57UL, 0xBD2E5024UL, 0x7364944BUL, 0xE89B1A3BUL, 0x21835C4DUL, + 0x9F39E2D9UL, 0xD405DED8UL, 0x294D37E5UL, 0xBCCAAEEDUL, 0x35A124B5UL, + 0x6708A2BCUL, 0xB00960BAUL, 0x2A98121AUL, 0x4D8FAE82UL, 0x0BB3263FUL, + 0x12595A19UL, 0x6A107589UL, 0x0809E494UL, 0x21C171ECUL, 0x884D6825UL, + 0x14C8009BUL, 0xB0B84E7BUL, 0x03FB88F4UL, 0x28E7CB78UL, 0x9388B13BUL, + 0xDD2DC1D5UL, 0x848F520AUL, 0x07C28CD1UL, 0x68A39358UL, 0x72C9137DUL, + 0x127DD430UL, 0xC613F157UL, 0x8C2F0D55UL, 0xF7D3F39FUL, 0x309BFB78UL, + 0x8406B137UL, 0x46C0A6F5UL, 0x3718D597UL, 0x08607F04UL, 0x76904B6DUL, + 0x04DB4E13UL, 0xCD7411A7UL, 0xB510CE0EUL, 0xBFC7F7CCUL, 0xB83F957AUL, + 0xFDFEF62DUL, 0xC35E4580UL, 0x3FF1E524UL, 0x4112D96CUL, 0x02C9B944UL, + 0xD5990DFBUL, 0xE7E26581UL, 0x0D9C7E7EUL, 0x826DFA89UL, 0x66F1E0ABUL, + 0x30BCC764UL, 0xEADEBEACUL, 0xED35E5EEUL, 0x0C571A7DUL, 0xE4F3A26AUL, + 0xF7F58F7BUL, 0xADF6BC23UL, 0x5D023E65UL, 0x1ED3FF4EUL, 0xEC46B0B6UL, + 0xD2A93B51UL, 0xE75B41C9UL, 0x7E315AEBUL, 0x61119A5AUL, 0x53245B79UL, + 0x33F6D7B1UL, 0xCAE8DEBAUL, 0x50FC8194UL, 0xAFA92A6DUL, 0xC87C8006UL, + 0x4188BFCDUL, 0x8BACE62EUL, 0x78FFA568UL, 0x5597EC0FUL, 0xB4415F7DUL, + 0x08294766UL, 0xAD567643UL, 0x09C36F90UL, 0x3DDE9F39UL, 0x4A0A283CUL, + 0x18080C8EUL, 0x080C79ECUL, 0x79AE4C10UL, 0xCB9E1563UL, 0x7CDD662FUL, + 0x62D31911UL, 0xA4CA0CF1UL, 0x5CF824CDUL, 0x3B708F99UL, 0x1E16614CUL, + 0xB6B9D766UL, 0x5DE87ABBUL, 0x7229EA81UL, 0xD5B2D750UL, 0x56E6CD21UL, + 0xFE1E42D5UL, 0x96DA2655UL, 0xC2B9AA36UL, 0xB8F6FD4AUL, 0x6A158D10UL, + 0x01913FD3UL, 0xAF7D1FB8UL, 0x0B5E435FUL, 0x90C10757UL, 0x6554ABDAUL, + 0x7A68710FUL, 0x82AC484FUL, 0xD7E1C7BEUL, 0x95C85EAAUL, 0x94A302F4UL, + 0x4D3CFBDAUL, 0x786B2908UL, 0x1010B275UL, 0x82D53D12UL, 0x21E2A51CUL, + 0x3D1E9150UL, 0xB059261DUL, 0xD0638E1AUL, 0x31860F05UL, 0x81F2864DUL, + 0xFF4CFC35UL, 0x0451516DUL, 0xBD086F26UL, 0xBC5654C1UL, 0x65DFA427UL, + 0xA82427F5UL, 0x582E3014UL, 0xB8D2486DUL, 0xC79A1749UL, 0x9A1D7745UL, + 0x8766BB54UL, 0x1E04A7F7UL, 0x3D3DFF8AUL, 0xD5EC6BF4UL, 0xDBEF7D9FUL, + 0x36EC0EA3UL, 0x1FEB2E4FUL, 0x15CFCC5CUL, 0xD8C423FBUL, 0xD0EF3CC9UL, + 0xEB244925UL, 0xBA5590C8UL, 0xA5F48AC4UL, 0x33C5321CUL, 0x613B67B2UL, + 0x479C3A22UL, 0xE21339CCUL, 0x10D210AAUL, 0x931DD7E2UL, 0xEF05EE06UL, + 0xB82F2703UL, 0xA385CB2CUL, 0x5D67133CUL, 0x877EB7B4UL, 0x1E3437F7UL, + 0x5AFB43AEUL, 0x53C078F3UL, 0x94D90481UL, 0x1D964589UL, 0x08063A85UL, + 0xE1322228UL, 0x1956B1E5UL, 0x31860F13UL, 0x2E7B022FUL, 0x21182CA3UL, + 0x96F703ACUL, 0x46819E2EUL, 0x0D28FE52UL, 0x3724D4DCUL, 0xA0EABE6BUL, + 0xC66699FDUL, 0xC6112FDDUL, 0x19C1E69CUL, 0x04D3658AUL, 0x4B55DD99UL, + 0x31907D62UL, 0xF854B522UL, 0x4D678F26UL, 0x22AE0582UL, 0xEAFED133UL, + 0xE4A51D21UL, 0x84BD6DD6UL, 0xC1A51375UL, 0x3F28EE63UL, 0xFB737B1AUL, + 0x70A1660EUL, 0x8A8DFAA3UL, 0x1BE79937UL, 0xF7476978UL, 0x513C1764UL, + 0x531AC6BFUL, 0x12C06908UL, 0x001CDB95UL, 0x1A4B6A53UL, 0xD067FCE5UL, + 0x12B2CFB6UL, 0x9DDB477FUL, 0x740E0066UL, 0x39DDF25AUL, 0xCC8BFA2DUL, + 0xF1B20EAFUL, 0x64F2632CUL, 0x9783CDEEUL, 0x63BFD4D8UL, 0x0084CFE5UL, + 0x75F4E9E2UL, 0x19B48FD0UL, 0x6C48DDD8UL, 0x7A36AF93UL, 0x71865C4CUL, + 0x9CE0199DUL, 0x867027D7UL, 0x2CB7B77FUL, 0x84EF01DAUL, 0x72F5972FUL, + 0x040F7074UL, 0xDF9AFA29UL, 0xC921F94EUL, 0x75C08A36UL, 0x18C1EF9AUL, + 0xD649A428UL, 0xC5B71937UL, 0x8A30738AUL, 0xD97CD348UL, 0x858129A6UL, + 0x239E3B0AUL, 0xBBB8ABC4UL, 0x80FAC4C2UL, 0xECFCF20BUL, 0xD9D711F9UL, + 0xE2A4EF71UL, 0xB5FE87C0UL, 0xBE8B06B2UL, 0xAAFEF5A7UL, 0x9C15DB3BUL, + 0x0AEB8165UL, 0x4389A84AUL, 0x253B1D7AUL, 0x19047C79UL, 0x7CDC78A2UL, + 0xD20ADF03UL, 0x56F55A71UL, 0x3E730FA8UL, 0xFD8650D8UL, 0x959E234EUL, + 0xB7546681UL, 0xDAD1B22AUL, 0x142A6E85UL, 0x8EF4BCE6UL, 0x68235B9DUL, + 0x85A13F85UL, 0x74096AE7UL, 0xA949BEA2UL, 0x29322D0DUL, 0xD5683858UL, + 0x82846526UL, 0x403DAE08UL, 0x6DD1943AUL, 0xE1279BFFUL, 0x9E7E4F04UL, + 0x1C3A4524UL, 0x484525E4UL, 0x81D4CC5FUL, 0xE24124C0UL, 0x037464C0UL, + 0xBF1BD691UL, 0x26CEB003UL, 0x275EAD3AUL, 0xC5BDE908UL, 0x26414FF3UL, + 0xA30519ADUL, 0xD7B43ABEUL, 0x2CE5D3D5UL, 0x88412761UL, 0x97CA2070UL, + 0xE5FBB9C7UL, 0x276DF0B4UL, 0x308F751FUL, 0x37A97DF6UL, 0xC9CD808CUL, + 0xFE4CB380UL, 0x3D469303UL, 0xAEE19096UL, 0xC0D5D42AUL, 0x4E823AD3UL, + 0xF5F9CC3BUL, 0x4286619CUL, 0x9CA45E1CUL, 0x66C97340UL, 0x891AEC49UL, + 0x45BAE606UL, 0xC798F047UL, 0x52649D6CUL, 0xCE86FDFCUL, 0x80C6E402UL, + 0xD6EC2F2BUL, 0x27C82282UL, 0x1FE26CE0UL, 0x92F57EA7UL, 0xDE462F4DUL, + 0x07497CAEUL, 0x5A48755CUL, 0x721502DDUL, 0x6CBE7935UL, 0x836D8003UL, + 0x9EAD7F70UL, 0x9AB3A42FUL, 0x4C8652D6UL, 0x32E39273UL, 0xE8FA3860UL, + 0x1DA4F25AUL, 0x0CD6EF81UL, 0x02503F7DUL, 0x8854A0A1UL, 0x9A30C4E8UL, + 0x88157153UL, 0x05EFE294UL, 0x57C4C925UL, 0x2887D96FUL, 0xC1A71E3CUL, + 0xE9F84163UL, 0x2D0985DEUL, 0xD21E796CUL, 0x6FB5CE56UL, 0x02614ABFUL, + 0xC3C7BE2CUL, 0xB54FED6FUL, 0xA617A083UL, 0xC3142D8FUL, 0x6079E4CEUL, + 0xCEFFC147UL, 0x1D0CB81BUL, 0xDC153E5FUL, 0xE36EF5BBUL, 0xD531161AUL, + 0x165B1015UL, 0x7AA114EDUL, 0x3F7579B3UL, 0xF7F395F1UL, 0xBC6172C7UL, + 0xA86F875EUL, 0x0E6C51B3UL, 0xCDFEC2AFUL, 0x73C0E762UL, 0x824C2009UL, + 0xC5A87748UL, 0x94D40125UL, 0x8ABA3FFBUL, 0xD32BE060UL, 0x8C17EFF0UL, + 0x21E2547EUL, 0x07CFFAD9UL, 0x05340E15UL, 0xF3310C92UL, 0x9D8D1908UL, + 0x86BA527FUL, 0xF943F672UL, 0xEF73FBF0UL, 0x46D95CA5UL, 0xC54CD95BUL, + 0x9D855E89UL, 0x4BB5AF29UL, +}; + +static uint32_t result[EXPECTED_UINT32_ENTRIES]; + +static void test_next_against_reference_vector(void) +{ + isaac_ctx_t ctx; + memset(result, 0, EXPECTED_UINT32_ENTRIES); + memset(&ctx, 0, sizeof(ctx)); + isaac_init(&ctx, true); + printf("i = "); + for (uint_fast32_t i = 0; i < EXPECTED_UINT32_ENTRIES; i++) + { + result[i] = isaac_next(&ctx); + printf("\r%3"PRIu32" | ", i); + atto_eq(result[i], expected_random_stream[i]); + } + puts(""); +} + +void test_isaac_next(void) +{ + test_next_against_reference_vector(); +} From f54ab407542037920a3502f65151d3ed21438a58 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matjaz=CC=8C?= Date: Sun, 26 Apr 2020 19:47:59 +0200 Subject: [PATCH 02/27] Document init test, add single-value next test --- inc/isaac.h | 3 +-- tst/test_init.c | 2 +- tst/test_next.c | 36 ++++++++++++++++++++++++++++-------- 3 files changed, 30 insertions(+), 11 deletions(-) diff --git a/inc/isaac.h b/inc/isaac.h index 7eee872..9cde5d2 100644 --- a/inc/isaac.h +++ b/inc/isaac.h @@ -48,11 +48,10 @@ typedef struct { uint32_t c; } isaac_ctx_t; -// If (flag==TRUE), then use the contents of randrsl[0..RANDSIZ-1] as the seed. /** * Initialises the ISAAC CPRNG. * - * Uses the `rsl` field as initial seed + * Uses the `rsl` field as initial seed if the flag is TRUE. Otherwise ??? * * @param ctx * @param flag diff --git a/tst/test_init.c b/tst/test_init.c index 5a53897..e46a637 100644 --- a/tst/test_init.c +++ b/tst/test_init.c @@ -188,7 +188,7 @@ const static uint8_t expected_initialised_ctx[] = { static void test_init_against_reference(void) { isaac_ctx_t ctx; - memset(&ctx, 0, sizeof(ctx)); + memset(ctx.rsl, 0, ISAAC_SIZE); // Zero seed isaac_init(&ctx, true); diff --git a/tst/test_next.c b/tst/test_next.c index fc2ee3b..4e9157b 100644 --- a/tst/test_next.c +++ b/tst/test_next.c @@ -10,9 +10,19 @@ #include "test.h" -#define EXPECTED_UINT32_ENTRIES 512 +#define EXPECTED_STREAM_ELEMENTS 512 -const static uint32_t expected_random_stream[EXPECTED_UINT32_ENTRIES] = { +/* + * This is the stream of uint32 values obtained by calling isaac_next() + * repeatedly after the isaac_ctx_t has been initialised with a zero seed. + * + * The value is obtained from the ISAAC's author website + * https://www.burtleburtle.net/bob/rand/randvect.txt + * and could be obtained from the reference implementation by + * compiling any version (e.g. rand.c or randport.c) with the -DNEVER flag + * and running it, as it sets a zero seed. + */ +const static uint32_t expected_zero_seed_stream[EXPECTED_STREAM_ELEMENTS] = { 0xF650E4C8UL, 0xE448E96DUL, 0x98DB2FB4UL, 0xF5FAD54FUL, 0x433F1AFBUL, 0xEDEC154AUL, 0xD8370487UL, 0x46CA4F9AUL, 0x5DE3743EUL, 0x88381097UL, 0xF1D444EBUL, 0x823CEDB6UL, 0x6A83E1E0UL, 0x4A5F6355UL, 0xC7442433UL, @@ -118,25 +128,35 @@ const static uint32_t expected_random_stream[EXPECTED_UINT32_ENTRIES] = { 0x9D855E89UL, 0x4BB5AF29UL, }; -static uint32_t result[EXPECTED_UINT32_ENTRIES]; +static void test_next_once(void) +{ + isaac_ctx_t ctx; + memset(&ctx, 0, sizeof(ctx)); // Zero seed + isaac_init(&ctx, true); + + const uint32_t next = isaac_next(&ctx); + + atto_eq(next, expected_zero_seed_stream[0]); +} -static void test_next_against_reference_vector(void) +static void test_next_all(void) { + uint32_t result; isaac_ctx_t ctx; - memset(result, 0, EXPECTED_UINT32_ENTRIES); memset(&ctx, 0, sizeof(ctx)); isaac_init(&ctx, true); printf("i = "); - for (uint_fast32_t i = 0; i < EXPECTED_UINT32_ENTRIES; i++) + for (uint_fast32_t i = 0; i < EXPECTED_STREAM_ELEMENTS; i++) { - result[i] = isaac_next(&ctx); + result = isaac_next(&ctx); printf("\r%3"PRIu32" | ", i); - atto_eq(result[i], expected_random_stream[i]); + atto_eq(result, expected_zero_seed_stream[i]); } puts(""); } void test_isaac_next(void) { + test_next_once(); test_next_against_reference_vector(); } From 9fa97c367837a870fedd875f7523f9c8c41dbe3c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matjaz=CC=8C?= Date: Sun, 26 Apr 2020 20:18:46 +0200 Subject: [PATCH 03/27] Fix isaac_next() tests (they had the wrong vectors) --- inc/isaac.h | 12 ++- src/isaac.c | 6 +- tst/test_next.c | 240 +++++++++++++++++++++++++----------------------- 3 files changed, 139 insertions(+), 119 deletions(-) diff --git a/inc/isaac.h b/inc/isaac.h index 9cde5d2..1591b6d 100644 --- a/inc/isaac.h +++ b/inc/isaac.h @@ -15,6 +15,9 @@ * ISAAC and its original source code is created by Bob Jenkins and * released into the public domain. * + * This implementation is based on the `randport.c` implementation, which uses + * 32-bit words while being portable onto 64 bit machines. + * * @copyright Copyright © 2020, Matjaž Guštin * . All rights reserved. * @license BSD 3-clause license. @@ -38,7 +41,11 @@ extern "C" #define ISAAC_SIZE 256U -/* Context of random number generator */ +/** + * Context of the ISAAC CPRNG. + * + * Maps to `randctx` from the original implementation. + */ typedef struct { uint32_t cnt; uint32_t rsl[ISAAC_SIZE]; @@ -53,6 +60,9 @@ typedef struct { * * Uses the `rsl` field as initial seed if the flag is TRUE. Otherwise ??? * + * Maps to `void randinit(randctx *r, word flag)` from the original + * implementation. + * * @param ctx * @param flag */ diff --git a/src/isaac.c b/src/isaac.c index b57e063..fafcd42 100644 --- a/src/isaac.c +++ b/src/isaac.c @@ -152,6 +152,9 @@ void isaac_init(isaac_ctx_t* const ctx, const bool flag) ctx->cnt = ISAAC_SIZE; } +/* + * Maps to `void isaac(randctx*)` from the original implementation. + */ static void isaac_round(isaac_ctx_t* const ctx) { uint32_t* m; @@ -188,7 +191,7 @@ static void isaac_round(isaac_ctx_t* const ctx) uint32_t isaac_next(isaac_ctx_t* const ctx) { - if (!ctx->cnt--) + if (!(ctx->cnt--)) { isaac_round(ctx); ctx->cnt = ISAAC_SIZE - 1; @@ -196,7 +199,6 @@ uint32_t isaac_next(isaac_ctx_t* const ctx) return ctx->rsl[ctx->cnt]; } - #ifdef NEVER int main() { diff --git a/tst/test_next.c b/tst/test_next.c index 4e9157b..e805a51 100644 --- a/tst/test_next.c +++ b/tst/test_next.c @@ -10,122 +10,132 @@ #include "test.h" -#define EXPECTED_STREAM_ELEMENTS 512 +#define EXPECTED_NEXT_ELEMENTS 512 /* * This is the stream of uint32 values obtained by calling isaac_next() * repeatedly after the isaac_ctx_t has been initialised with a zero seed. * - * The value is obtained from the ISAAC's author website - * https://www.burtleburtle.net/bob/rand/randvect.txt - * and could be obtained from the reference implementation by - * compiling any version (e.g. rand.c or randport.c) with the -DNEVER flag - * and running it, as it sets a zero seed. + * The value is obtained by taking the original ISAAC implementation + * (in particular `randport.c`), zero-initialising the seed + * and calling `rand(&ctx)` repeatedly. + * + * randctx ctx; + * unsigned long int i; + * unsigned long int next; + * for (i = 0; i < 256; i++) { + * ctx.randrsl[i] = 0; // Zero seed + * } + * randinit(&ctx, TRUE); // Init ISAAC with zero seed + * for (i = 0; i < 512; i++) { + * next = rand(&ctx); + * printf("0x%08lXUL, ", next); + * } */ -const static uint32_t expected_zero_seed_stream[EXPECTED_STREAM_ELEMENTS] = { - 0xF650E4C8UL, 0xE448E96DUL, 0x98DB2FB4UL, 0xF5FAD54FUL, 0x433F1AFBUL, - 0xEDEC154AUL, 0xD8370487UL, 0x46CA4F9AUL, 0x5DE3743EUL, 0x88381097UL, - 0xF1D444EBUL, 0x823CEDB6UL, 0x6A83E1E0UL, 0x4A5F6355UL, 0xC7442433UL, - 0x25890E2EUL, 0x7452E319UL, 0x57161DF6UL, 0x38A824F3UL, 0x002ED713UL, - 0x29F55449UL, 0x51C08D83UL, 0xD78CB99EUL, 0xA0CC74F3UL, 0x8F651659UL, - 0xCBC8B7C2UL, 0xF5F71C69UL, 0x12AD6419UL, 0xE5792E1BUL, 0x860536B8UL, - 0x09B3CE98UL, 0xD45D6D81UL, 0xF3B26129UL, 0x17E38F85UL, 0x29CF72CEUL, - 0x349947B0UL, 0xC998F9FFUL, 0xB5E13DAEUL, 0x32AE2A2BUL, 0xF7CF814CUL, - 0x8EBFA303UL, 0xCF22E064UL, 0x0B923200UL, 0xECA4D58AUL, 0xEF53CEC4UL, - 0xD0F7B37DUL, 0x9C411A2AUL, 0xFFDF8A80UL, 0xB40E27BCUL, 0xB4D2F976UL, - 0x44B89B08UL, 0xF37C71D5UL, 0x1A70E7E9UL, 0x0BDB9C30UL, 0x60DC5207UL, - 0xB3C3F24BUL, 0xD7386806UL, 0x229749B5UL, 0x4E232CD0UL, 0x91DABC65UL, - 0xA70E1101UL, 0x8B87437EUL, 0x5781414FUL, 0xCDBC62E2UL, 0x8107C9FFUL, - 0x69D2E4AEUL, 0x3B18E752UL, 0xB143B688UL, 0x6F4E0772UL, 0x95138769UL, - 0x943C3C74UL, 0xAFC17A97UL, 0x0FD43963UL, 0x6A529B0BUL, 0xD8C58A6AUL, - 0xA8BCC22DUL, 0x2DB35DFEUL, 0xA7A2F402UL, 0x6CB167DBUL, 0x538E1F4EUL, - 0x7275E277UL, 0x1D3B8E97UL, 0xECC5DC91UL, 0x15E3A5B9UL, 0x03696614UL, - 0x30AB93ECUL, 0xAC9FE69DUL, 0x7BC76811UL, 0x60EDA8DAUL, 0x28833522UL, - 0xD5295EBCUL, 0x5ADB60E7UL, 0xF7E1CDD0UL, 0x97166D14UL, 0xB67EC13AUL, - 0x210F3925UL, 0x64AF0FEFUL, 0x0D028684UL, 0x3AEA3DECUL, 0xB058BAFBUL, - 0xB8B0CCFCUL, 0xF2B5CC05UL, 0xE3A662D9UL, 0x814BC24CUL, 0x2364A1AAUL, - 0x37C0ED05UL, 0x2B36505CUL, 0x451E7EC8UL, 0x5D2A542FUL, 0xE43D0FBBUL, - 0x91C8D925UL, 0x60D4D5F8UL, 0x12A0594BUL, 0x9E8A51DAUL, 0xCD49EBDBUL, - 0x1B0DCDC1UL, 0xCD57C7F7UL, 0xE6344451UL, 0x7DED386FUL, 0x2F36FA86UL, - 0xA6D12101UL, 0x33BC405DUL, 0xB388D96CUL, 0xDB6DBE96UL, 0xFE29661CUL, - 0x13EDC0CBUL, 0xCB0EEE4AUL, 0x70CC94AEUL, 0xDE11ED34UL, 0x0606CF9FUL, - 0x3A6CE389UL, 0x23D74F4EUL, 0xA37F63FFUL, 0x917BDEC2UL, 0xD73F72D4UL, - 0x0E7E0E67UL, 0x3D77D9A2UL, 0x13ADD922UL, 0x8891B3DBUL, 0x01A9BD70UL, - 0x56A001E3UL, 0xD51F093DUL, 0xCC033CE3UL, 0x5AD0D3B0UL, 0x34105A8CUL, - 0x6A123F57UL, 0xBD2E5024UL, 0x7364944BUL, 0xE89B1A3BUL, 0x21835C4DUL, - 0x9F39E2D9UL, 0xD405DED8UL, 0x294D37E5UL, 0xBCCAAEEDUL, 0x35A124B5UL, - 0x6708A2BCUL, 0xB00960BAUL, 0x2A98121AUL, 0x4D8FAE82UL, 0x0BB3263FUL, - 0x12595A19UL, 0x6A107589UL, 0x0809E494UL, 0x21C171ECUL, 0x884D6825UL, - 0x14C8009BUL, 0xB0B84E7BUL, 0x03FB88F4UL, 0x28E7CB78UL, 0x9388B13BUL, - 0xDD2DC1D5UL, 0x848F520AUL, 0x07C28CD1UL, 0x68A39358UL, 0x72C9137DUL, - 0x127DD430UL, 0xC613F157UL, 0x8C2F0D55UL, 0xF7D3F39FUL, 0x309BFB78UL, - 0x8406B137UL, 0x46C0A6F5UL, 0x3718D597UL, 0x08607F04UL, 0x76904B6DUL, - 0x04DB4E13UL, 0xCD7411A7UL, 0xB510CE0EUL, 0xBFC7F7CCUL, 0xB83F957AUL, - 0xFDFEF62DUL, 0xC35E4580UL, 0x3FF1E524UL, 0x4112D96CUL, 0x02C9B944UL, - 0xD5990DFBUL, 0xE7E26581UL, 0x0D9C7E7EUL, 0x826DFA89UL, 0x66F1E0ABUL, - 0x30BCC764UL, 0xEADEBEACUL, 0xED35E5EEUL, 0x0C571A7DUL, 0xE4F3A26AUL, - 0xF7F58F7BUL, 0xADF6BC23UL, 0x5D023E65UL, 0x1ED3FF4EUL, 0xEC46B0B6UL, - 0xD2A93B51UL, 0xE75B41C9UL, 0x7E315AEBUL, 0x61119A5AUL, 0x53245B79UL, - 0x33F6D7B1UL, 0xCAE8DEBAUL, 0x50FC8194UL, 0xAFA92A6DUL, 0xC87C8006UL, - 0x4188BFCDUL, 0x8BACE62EUL, 0x78FFA568UL, 0x5597EC0FUL, 0xB4415F7DUL, - 0x08294766UL, 0xAD567643UL, 0x09C36F90UL, 0x3DDE9F39UL, 0x4A0A283CUL, - 0x18080C8EUL, 0x080C79ECUL, 0x79AE4C10UL, 0xCB9E1563UL, 0x7CDD662FUL, - 0x62D31911UL, 0xA4CA0CF1UL, 0x5CF824CDUL, 0x3B708F99UL, 0x1E16614CUL, - 0xB6B9D766UL, 0x5DE87ABBUL, 0x7229EA81UL, 0xD5B2D750UL, 0x56E6CD21UL, - 0xFE1E42D5UL, 0x96DA2655UL, 0xC2B9AA36UL, 0xB8F6FD4AUL, 0x6A158D10UL, - 0x01913FD3UL, 0xAF7D1FB8UL, 0x0B5E435FUL, 0x90C10757UL, 0x6554ABDAUL, - 0x7A68710FUL, 0x82AC484FUL, 0xD7E1C7BEUL, 0x95C85EAAUL, 0x94A302F4UL, - 0x4D3CFBDAUL, 0x786B2908UL, 0x1010B275UL, 0x82D53D12UL, 0x21E2A51CUL, - 0x3D1E9150UL, 0xB059261DUL, 0xD0638E1AUL, 0x31860F05UL, 0x81F2864DUL, - 0xFF4CFC35UL, 0x0451516DUL, 0xBD086F26UL, 0xBC5654C1UL, 0x65DFA427UL, - 0xA82427F5UL, 0x582E3014UL, 0xB8D2486DUL, 0xC79A1749UL, 0x9A1D7745UL, - 0x8766BB54UL, 0x1E04A7F7UL, 0x3D3DFF8AUL, 0xD5EC6BF4UL, 0xDBEF7D9FUL, - 0x36EC0EA3UL, 0x1FEB2E4FUL, 0x15CFCC5CUL, 0xD8C423FBUL, 0xD0EF3CC9UL, - 0xEB244925UL, 0xBA5590C8UL, 0xA5F48AC4UL, 0x33C5321CUL, 0x613B67B2UL, - 0x479C3A22UL, 0xE21339CCUL, 0x10D210AAUL, 0x931DD7E2UL, 0xEF05EE06UL, - 0xB82F2703UL, 0xA385CB2CUL, 0x5D67133CUL, 0x877EB7B4UL, 0x1E3437F7UL, - 0x5AFB43AEUL, 0x53C078F3UL, 0x94D90481UL, 0x1D964589UL, 0x08063A85UL, - 0xE1322228UL, 0x1956B1E5UL, 0x31860F13UL, 0x2E7B022FUL, 0x21182CA3UL, - 0x96F703ACUL, 0x46819E2EUL, 0x0D28FE52UL, 0x3724D4DCUL, 0xA0EABE6BUL, - 0xC66699FDUL, 0xC6112FDDUL, 0x19C1E69CUL, 0x04D3658AUL, 0x4B55DD99UL, - 0x31907D62UL, 0xF854B522UL, 0x4D678F26UL, 0x22AE0582UL, 0xEAFED133UL, - 0xE4A51D21UL, 0x84BD6DD6UL, 0xC1A51375UL, 0x3F28EE63UL, 0xFB737B1AUL, - 0x70A1660EUL, 0x8A8DFAA3UL, 0x1BE79937UL, 0xF7476978UL, 0x513C1764UL, - 0x531AC6BFUL, 0x12C06908UL, 0x001CDB95UL, 0x1A4B6A53UL, 0xD067FCE5UL, - 0x12B2CFB6UL, 0x9DDB477FUL, 0x740E0066UL, 0x39DDF25AUL, 0xCC8BFA2DUL, - 0xF1B20EAFUL, 0x64F2632CUL, 0x9783CDEEUL, 0x63BFD4D8UL, 0x0084CFE5UL, - 0x75F4E9E2UL, 0x19B48FD0UL, 0x6C48DDD8UL, 0x7A36AF93UL, 0x71865C4CUL, - 0x9CE0199DUL, 0x867027D7UL, 0x2CB7B77FUL, 0x84EF01DAUL, 0x72F5972FUL, - 0x040F7074UL, 0xDF9AFA29UL, 0xC921F94EUL, 0x75C08A36UL, 0x18C1EF9AUL, - 0xD649A428UL, 0xC5B71937UL, 0x8A30738AUL, 0xD97CD348UL, 0x858129A6UL, - 0x239E3B0AUL, 0xBBB8ABC4UL, 0x80FAC4C2UL, 0xECFCF20BUL, 0xD9D711F9UL, - 0xE2A4EF71UL, 0xB5FE87C0UL, 0xBE8B06B2UL, 0xAAFEF5A7UL, 0x9C15DB3BUL, - 0x0AEB8165UL, 0x4389A84AUL, 0x253B1D7AUL, 0x19047C79UL, 0x7CDC78A2UL, - 0xD20ADF03UL, 0x56F55A71UL, 0x3E730FA8UL, 0xFD8650D8UL, 0x959E234EUL, - 0xB7546681UL, 0xDAD1B22AUL, 0x142A6E85UL, 0x8EF4BCE6UL, 0x68235B9DUL, - 0x85A13F85UL, 0x74096AE7UL, 0xA949BEA2UL, 0x29322D0DUL, 0xD5683858UL, - 0x82846526UL, 0x403DAE08UL, 0x6DD1943AUL, 0xE1279BFFUL, 0x9E7E4F04UL, - 0x1C3A4524UL, 0x484525E4UL, 0x81D4CC5FUL, 0xE24124C0UL, 0x037464C0UL, - 0xBF1BD691UL, 0x26CEB003UL, 0x275EAD3AUL, 0xC5BDE908UL, 0x26414FF3UL, - 0xA30519ADUL, 0xD7B43ABEUL, 0x2CE5D3D5UL, 0x88412761UL, 0x97CA2070UL, - 0xE5FBB9C7UL, 0x276DF0B4UL, 0x308F751FUL, 0x37A97DF6UL, 0xC9CD808CUL, - 0xFE4CB380UL, 0x3D469303UL, 0xAEE19096UL, 0xC0D5D42AUL, 0x4E823AD3UL, - 0xF5F9CC3BUL, 0x4286619CUL, 0x9CA45E1CUL, 0x66C97340UL, 0x891AEC49UL, - 0x45BAE606UL, 0xC798F047UL, 0x52649D6CUL, 0xCE86FDFCUL, 0x80C6E402UL, - 0xD6EC2F2BUL, 0x27C82282UL, 0x1FE26CE0UL, 0x92F57EA7UL, 0xDE462F4DUL, - 0x07497CAEUL, 0x5A48755CUL, 0x721502DDUL, 0x6CBE7935UL, 0x836D8003UL, - 0x9EAD7F70UL, 0x9AB3A42FUL, 0x4C8652D6UL, 0x32E39273UL, 0xE8FA3860UL, - 0x1DA4F25AUL, 0x0CD6EF81UL, 0x02503F7DUL, 0x8854A0A1UL, 0x9A30C4E8UL, - 0x88157153UL, 0x05EFE294UL, 0x57C4C925UL, 0x2887D96FUL, 0xC1A71E3CUL, - 0xE9F84163UL, 0x2D0985DEUL, 0xD21E796CUL, 0x6FB5CE56UL, 0x02614ABFUL, - 0xC3C7BE2CUL, 0xB54FED6FUL, 0xA617A083UL, 0xC3142D8FUL, 0x6079E4CEUL, - 0xCEFFC147UL, 0x1D0CB81BUL, 0xDC153E5FUL, 0xE36EF5BBUL, 0xD531161AUL, - 0x165B1015UL, 0x7AA114EDUL, 0x3F7579B3UL, 0xF7F395F1UL, 0xBC6172C7UL, - 0xA86F875EUL, 0x0E6C51B3UL, 0xCDFEC2AFUL, 0x73C0E762UL, 0x824C2009UL, - 0xC5A87748UL, 0x94D40125UL, 0x8ABA3FFBUL, 0xD32BE060UL, 0x8C17EFF0UL, - 0x21E2547EUL, 0x07CFFAD9UL, 0x05340E15UL, 0xF3310C92UL, 0x9D8D1908UL, - 0x86BA527FUL, 0xF943F672UL, 0xEF73FBF0UL, 0x46D95CA5UL, 0xC54CD95BUL, - 0x9D855E89UL, 0x4BB5AF29UL, +const static uint32_t expected_next_results[EXPECTED_NEXT_ELEMENTS] = { + 0x182600F3UL, 0x300B4A8DUL, 0x301B6622UL, 0xB08ACD21UL, 0x296FD679UL, + 0x995206E9UL, 0xB3FFA8B5UL, 0x0FC99C24UL, 0x5F071FAFUL, 0x52251DEFUL, + 0x894F41C2UL, 0xCC4C9AFBUL, 0x96C33F74UL, 0x347CB71DUL, 0xC90F8FBDUL, + 0xA658F57AUL, 0xC5C29E18UL, 0x6249FA29UL, 0xBAE16FFAUL, 0x25C871BDUL, + 0xF4C75E24UL, 0x5AB3EAB9UL, 0xAC450B8FUL, 0x1629CFA4UL, 0x0016E86FUL, + 0xF27C4D0DUL, 0x67648B17UL, 0x05C04FCEUL, 0x44D3FF79UL, 0xC6ACD20FUL, + 0x472FD994UL, 0x842131C4UL, 0xEAD4A900UL, 0xC01EDA0DUL, 0x9E604C7BUL, + 0xFB8A0E99UL, 0x02E17B6FUL, 0xE8B4F627UL, 0xC7041EAEUL, 0x42D19CD7UL, + 0xA358EB94UL, 0x19CA2158UL, 0x6BE6CE81UL, 0x4B90A4DEUL, 0x26F0774DUL, + 0x4E83930AUL, 0x2492D476UL, 0xB97FFABEUL, 0x675CC8AEUL, 0x4CFDD254UL, + 0x5D3C00EAUL, 0x7BBA5EADUL, 0x6F461810UL, 0xBEF63EEAUL, 0x72EB767BUL, + 0xED6E963BUL, 0xB026016DUL, 0x17CB7EBFUL, 0xA7DC6E56UL, 0xF460BDF1UL, + 0x1FFE0E04UL, 0x902B347DUL, 0x02C0D8ABUL, 0x98CB3F8BUL, 0x6F359A39UL, + 0x9521825FUL, 0x9026D97EUL, 0xDE342516UL, 0x890A740CUL, 0x0F2969E4UL, + 0x2E7EA9EDUL, 0x394B8A4FUL, 0x1BDF1FD0UL, 0x15D565B4UL, 0xBAF0406DUL, + 0x4DAC20DBUL, 0x03359832UL, 0xE34802D5UL, 0xCC5FFF02UL, 0x0935AD6EUL, + 0x7C53C9B2UL, 0xB10B5D29UL, 0x4FBB94BEUL, 0xD7E48546UL, 0xB7CFA23CUL, + 0x7F081C9AUL, 0xE099BAF1UL, 0x9C7DC323UL, 0xB831AD14UL, 0x5B563101UL, + 0xFA55319BUL, 0x060DED54UL, 0xC5418124UL, 0x765F0DBAUL, 0x1AD3D9D5UL, + 0x3F07EC49UL, 0xDD5E06C6UL, 0xC230E2ACUL, 0xC6BA1971UL, 0x9CC17BCCUL, + 0x10B22A22UL, 0x7DFC8C7FUL, 0xB3310333UL, 0x205530EEUL, 0xDBF38A8FUL, + 0x003A02F5UL, 0x007E96A3UL, 0x36658201UL, 0x08DFD64FUL, 0x6275ACF3UL, + 0x3D29669BUL, 0x6B2F4538UL, 0xB0CC336BUL, 0x1D3043EBUL, 0x1AD1D764UL, + 0x4C655B84UL, 0x7A725BB2UL, 0xB3FC5C66UL, 0x80B4B915UL, 0xB2CBD9E4UL, + 0x2992DFC6UL, 0xDF8BE548UL, 0xB310D06EUL, 0x436385C6UL, 0x44D6E893UL, + 0x44C4D79DUL, 0xE3BB2064UL, 0xE41EA465UL, 0x3FF4CC70UL, 0x9D21AC42UL, + 0x672C3725UL, 0xA43A1D02UL, 0xFD84B19BUL, 0x5B6FB132UL, 0x4AF40896UL, + 0xE15000A6UL, 0x7CAB12F6UL, 0x8B8E753CUL, 0xFB253454UL, 0x359AC366UL, + 0x67822B45UL, 0x290A1140UL, 0xADE6E428UL, 0x6095EFCBUL, 0x99D8D9E6UL, + 0xA5B5981DUL, 0x332C95D6UL, 0xAF5CFCABUL, 0x161F5CA6UL, 0x1844CEE2UL, + 0xFFB8AB5CUL, 0x82FCCAEBUL, 0x49ECF97AUL, 0x7A60FABDUL, 0xF9585A3AUL, + 0x4EB6BD32UL, 0x3B347002UL, 0xF4930DBAUL, 0x5D21D51EUL, 0x64E8E3F4UL, + 0x52801FA8UL, 0x71CE907CUL, 0x872783A4UL, 0x0761DC80UL, 0x5C509848UL, + 0x41BA2ADCUL, 0x7E2F5520UL, 0x85C5EEC2UL, 0x368D3D00UL, 0x5FC7C5F3UL, + 0xB849D785UL, 0xD95F25B3UL, 0x79801FD5UL, 0xBF2443D6UL, 0x360D41CDUL, + 0x651B11C0UL, 0x801A89CAUL, 0x8B9E6B94UL, 0xFDE283C4UL, 0xCC5E6974UL, + 0x2B2F4C09UL, 0x8B2160A8UL, 0xDBF57F01UL, 0x76AA1C4EUL, 0x11F0831AUL, + 0x54713D17UL, 0xC99A2639UL, 0x4C373E7AUL, 0x09E6E57FUL, 0x71F63B07UL, + 0x7BE3F02EUL, 0x2C907ADEUL, 0xE5F489F6UL, 0x0B0CD6DAUL, 0xB566E14CUL, + 0x0F955969UL, 0xA0E5710BUL, 0x80D8C2DEUL, 0x9971E496UL, 0xC7EFBC2FUL, + 0x97A48E53UL, 0x2D845C0DUL, 0xE1194B0EUL, 0xAD2BA480UL, 0xD5253552UL, + 0xCA890B31UL, 0x60060AFBUL, 0x89DAE927UL, 0x565E2229UL, 0x43ABC21CUL, + 0x03DD14A5UL, 0xBBADD184UL, 0x9E979702UL, 0x2F659883UL, 0xF313ADECUL, + 0x621BD7CAUL, 0xB6470834UL, 0x4C3901C6UL, 0x32028BB8UL, 0x9DED8244UL, + 0x66907654UL, 0x0A06B272UL, 0x4A8EC630UL, 0x4207D36FUL, 0x3E7A8B49UL, + 0x13871BE7UL, 0xBF7AF48EUL, 0x3DE0DF39UL, 0x0E864542UL, 0x8C090A23UL, + 0xAF90E49EUL, 0x97661C5EUL, 0x365AA66CUL, 0x0073E342UL, 0x9C8AC447UL, + 0x6F57E7CEUL, 0xD5BE7FFAUL, 0x89651D84UL, 0x53F78EAAUL, 0x8173DC04UL, + 0xD70B1E10UL, 0x43C1A57BUL, 0x10C8A5ABUL, 0xED6ABD62UL, 0x2F840E43UL, + 0x4873D91EUL, 0x49F413FCUL, 0x5D89A1C1UL, 0xD3A388FCUL, 0x96C59CF4UL, + 0x456F1EDDUL, 0x3DD20023UL, 0xA264E933UL, 0xD32956E5UL, 0xD91AA738UL, + 0xE76DD339UL, 0x7A68710FUL, 0x6554ABDAUL, 0x90C10757UL, 0x0B5E435FUL, + 0xAF7D1FB8UL, 0x01913FD3UL, 0x6A158D10UL, 0xB8F6FD4AUL, 0xC2B9AA36UL, + 0x96DA2655UL, 0xFE1E42D5UL, 0x56E6CD21UL, 0xD5B2D750UL, 0x7229EA81UL, + 0x5DE87ABBUL, 0xB6B9D766UL, 0x1E16614CUL, 0x3B708F99UL, 0x5CF824CDUL, + 0xA4CA0CF1UL, 0x62D31911UL, 0x7CDD662FUL, 0xCB9E1563UL, 0x79AE4C10UL, + 0x080C79ECUL, 0x18080C8EUL, 0x4A0A283CUL, 0x3DDE9F39UL, 0x09C36F90UL, + 0xAD567643UL, 0x08294766UL, 0xB4415F7DUL, 0x5597EC0FUL, 0x78FFA568UL, + 0x8BACE62EUL, 0x4188BFCDUL, 0xC87C8006UL, 0xAFA92A6DUL, 0x50FC8194UL, + 0xCAE8DEBAUL, 0x33F6D7B1UL, 0x53245B79UL, 0x61119A5AUL, 0x7E315AEBUL, + 0xE75B41C9UL, 0xD2A93B51UL, 0xEC46B0B6UL, 0x1ED3FF4EUL, 0x5D023E65UL, + 0xADF6BC23UL, 0xF7F58F7BUL, 0xE4F3A26AUL, 0x0C571A7DUL, 0xED35E5EEUL, + 0xEADEBEACUL, 0x30BCC764UL, 0x66F1E0ABUL, 0x826DFA89UL, 0x0D9C7E7EUL, + 0xE7E26581UL, 0xD5990DFBUL, 0x02C9B944UL, 0x4112D96CUL, 0x3FF1E524UL, + 0xC35E4580UL, 0xFDFEF62DUL, 0xB83F957AUL, 0xBFC7F7CCUL, 0xB510CE0EUL, + 0xCD7411A7UL, 0x04DB4E13UL, 0x76904B6DUL, 0x08607F04UL, 0x3718D597UL, + 0x46C0A6F5UL, 0x8406B137UL, 0x309BFB78UL, 0xF7D3F39FUL, 0x8C2F0D55UL, + 0xC613F157UL, 0x127DD430UL, 0x72C9137DUL, 0x68A39358UL, 0x07C28CD1UL, + 0x848F520AUL, 0xDD2DC1D5UL, 0x9388B13BUL, 0x28E7CB78UL, 0x03FB88F4UL, + 0xB0B84E7BUL, 0x14C8009BUL, 0x884D6825UL, 0x21C171ECUL, 0x0809E494UL, + 0x6A107589UL, 0x12595A19UL, 0x0BB3263FUL, 0x4D8FAE82UL, 0x2A98121AUL, + 0xB00960BAUL, 0x6708A2BCUL, 0x35A124B5UL, 0xBCCAAEEDUL, 0x294D37E5UL, + 0xD405DED8UL, 0x9F39E2D9UL, 0x21835C4DUL, 0xE89B1A3BUL, 0x7364944BUL, + 0xBD2E5024UL, 0x6A123F57UL, 0x34105A8CUL, 0x5AD0D3B0UL, 0xCC033CE3UL, + 0xD51F093DUL, 0x56A001E3UL, 0x01A9BD70UL, 0x8891B3DBUL, 0x13ADD922UL, + 0x3D77D9A2UL, 0x0E7E0E67UL, 0xD73F72D4UL, 0x917BDEC2UL, 0xA37F63FFUL, + 0x23D74F4EUL, 0x3A6CE389UL, 0x0606CF9FUL, 0xDE11ED34UL, 0x70CC94AEUL, + 0xCB0EEE4AUL, 0x13EDC0CBUL, 0xFE29661CUL, 0xDB6DBE96UL, 0xB388D96CUL, + 0x33BC405DUL, 0xA6D12101UL, 0x2F36FA86UL, 0x7DED386FUL, 0xE6344451UL, + 0xCD57C7F7UL, 0x1B0DCDC1UL, 0xCD49EBDBUL, 0x9E8A51DAUL, 0x12A0594BUL, + 0x60D4D5F8UL, 0x91C8D925UL, 0xE43D0FBBUL, 0x5D2A542FUL, 0x451E7EC8UL, + 0x2B36505CUL, 0x37C0ED05UL, 0x2364A1AAUL, 0x814BC24CUL, 0xE3A662D9UL, + 0xF2B5CC05UL, 0xB8B0CCFCUL, 0xB058BAFBUL, 0x3AEA3DECUL, 0x0D028684UL, + 0x64AF0FEFUL, 0x210F3925UL, 0xB67EC13AUL, 0x97166D14UL, 0xF7E1CDD0UL, + 0x5ADB60E7UL, 0xD5295EBCUL, 0x28833522UL, 0x60EDA8DAUL, 0x7BC76811UL, + 0xAC9FE69DUL, 0x30AB93ECUL, 0x03696614UL, 0x15E3A5B9UL, 0xECC5DC91UL, + 0x1D3B8E97UL, 0x7275E277UL, 0x538E1F4EUL, 0x6CB167DBUL, 0xA7A2F402UL, + 0x2DB35DFEUL, 0xA8BCC22DUL, 0xD8C58A6AUL, 0x6A529B0BUL, 0x0FD43963UL, + 0xAFC17A97UL, 0x943C3C74UL, 0x95138769UL, 0x6F4E0772UL, 0xB143B688UL, + 0x3B18E752UL, 0x69D2E4AEUL, 0x8107C9FFUL, 0xCDBC62E2UL, 0x5781414FUL, + 0x8B87437EUL, 0xA70E1101UL, 0x91DABC65UL, 0x4E232CD0UL, 0x229749B5UL, + 0xD7386806UL, 0xB3C3F24BUL, 0x60DC5207UL, 0x0BDB9C30UL, 0x1A70E7E9UL, + 0xF37C71D5UL, 0x44B89B08UL, 0xB4D2F976UL, 0xB40E27BCUL, 0xFFDF8A80UL, + 0x9C411A2AUL, 0xD0F7B37DUL, 0xEF53CEC4UL, 0xECA4D58AUL, 0x0B923200UL, + 0xCF22E064UL, 0x8EBFA303UL, 0xF7CF814CUL, 0x32AE2A2BUL, 0xB5E13DAEUL, + 0xC998F9FFUL, 0x349947B0UL, 0x29CF72CEUL, 0x17E38F85UL, 0xF3B26129UL, + 0xD45D6D81UL, 0x09B3CE98UL, 0x860536B8UL, 0xE5792E1BUL, 0x12AD6419UL, + 0xF5F71C69UL, 0xCBC8B7C2UL, 0x8F651659UL, 0xA0CC74F3UL, 0xD78CB99EUL, + 0x51C08D83UL, 0x29F55449UL, 0x002ED713UL, 0x38A824F3UL, 0x57161DF6UL, + 0x7452E319UL, 0x25890E2EUL, 0xC7442433UL, 0x4A5F6355UL, 0x6A83E1E0UL, + 0x823CEDB6UL, 0xF1D444EBUL, 0x88381097UL, 0x5DE3743EUL, 0x46CA4F9AUL, + 0xD8370487UL, 0xEDEC154AUL, 0x433F1AFBUL, 0xF5FAD54FUL, 0x98DB2FB4UL, + 0xE448E96DUL, 0xF650E4C8UL, }; static void test_next_once(void) @@ -136,7 +146,7 @@ static void test_next_once(void) const uint32_t next = isaac_next(&ctx); - atto_eq(next, expected_zero_seed_stream[0]); + atto_eq(next, expected_next_results[0]); } static void test_next_all(void) @@ -145,12 +155,10 @@ static void test_next_all(void) isaac_ctx_t ctx; memset(&ctx, 0, sizeof(ctx)); isaac_init(&ctx, true); - printf("i = "); - for (uint_fast32_t i = 0; i < EXPECTED_STREAM_ELEMENTS; i++) + for (uint_fast32_t i = 0; i < EXPECTED_NEXT_ELEMENTS; i++) { result = isaac_next(&ctx); - printf("\r%3"PRIu32" | ", i); - atto_eq(result, expected_zero_seed_stream[i]); + atto_eq(result, expected_next_results[i]); } puts(""); } @@ -158,5 +166,5 @@ static void test_next_all(void) void test_isaac_next(void) { test_next_once(); - test_next_against_reference_vector(); + test_next_all(); } From f55adaed356f59bd8e04d8c8fa394464f97b137c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matjaz=CC=8C?= Date: Sun, 26 Apr 2020 20:28:38 +0200 Subject: [PATCH 04/27] Remove some unused pointers on stack in init - rename round to shuffle - rename rsl to result - rename cnt to available_next_values --- inc/isaac.h | 4 +- src/isaac.c | 146 ++++++++++++++++++++---------------------------- tst/test_init.c | 2 +- 3 files changed, 64 insertions(+), 88 deletions(-) diff --git a/inc/isaac.h b/inc/isaac.h index 1591b6d..b8e8ba3 100644 --- a/inc/isaac.h +++ b/inc/isaac.h @@ -47,8 +47,8 @@ extern "C" * Maps to `randctx` from the original implementation. */ typedef struct { - uint32_t cnt; - uint32_t rsl[ISAAC_SIZE]; + uint32_t available_next_values; + uint32_t result[ISAAC_SIZE]; uint32_t mem[ISAAC_SIZE]; uint32_t a; uint32_t b; diff --git a/src/isaac.c b/src/isaac.c index fafcd42..8f0f012 100644 --- a/src/isaac.c +++ b/src/isaac.c @@ -28,8 +28,6 @@ # define abs(a) (((a)>0) ? (a) : -(a)) #endif -#define ISAAC_LEFTSHIFT 8U - #define ISAAC_IND(mm, x) ((mm)[(x >> 2U) & (ISAAC_SIZE - 1)]) #define ISAAC_STEP(mix, a, b, mm, m, m2, r, x) \ @@ -37,7 +35,7 @@ x = *m; \ a = ((a^(mix)) + *(m2++)); \ *(m++) = y = (ISAAC_IND(mm, x) + a + b); \ - *(r++) = b = (ISAAC_IND(mm, y >> ISAAC_LEFTSHIFT) + x) & UINT32_MAX; \ + *(r++) = b = (ISAAC_IND(mm, y >> 8U) + x) & UINT32_MAX; \ } #define ISAAC_MIX(a, b, c, d, e, f, g, h) \ @@ -58,119 +56,104 @@ */ #define GOLDEN_RATIO 0x9e3779b9 -static void isaac_round(isaac_ctx_t* ctx); +static void isaac_shuffle(isaac_ctx_t* const ctx); void isaac_init(isaac_ctx_t* const ctx, const bool flag) { - uint32_t* m; - uint32_t* r; - uint32_t a; - uint32_t b; - uint32_t c; - uint32_t d; - uint32_t e; - uint32_t f; - uint32_t g; - uint32_t h; + uint32_t a, b, c, d, e, f, g, h; unsigned int i; /* Fastest integer type */ ctx->a = ctx->b = ctx->c = 0; - m = ctx->mem; - r = ctx->rsl; a = b = c = d = e = f = g = h = GOLDEN_RATIO; - /* scramble it */ + /* Scramble it */ for (i = 0; i < 4; i++) { ISAAC_MIX(a, b, c, d, e, f, g, h); } - /* if (flag==TRUE), then use the contents of rsl[] to initialize mm[]. */ + /* If (flag==TRUE), then use the contents of result[] to initialize mm[]. */ if (flag) { - /* initialize using the contents of r[] as the seed */ + /* Initialise using the contents of result[] as the seed. */ for (i = 0; i < ISAAC_SIZE; i += 8) { - a += r[i]; - b += r[i + 1]; - c += r[i + 2]; - d += r[i + 3]; - e += r[i + 4]; - f += r[i + 5]; - g += r[i + 6]; - h += r[i + 7]; + a += ctx->result[i]; + b += ctx->result[i + 1]; + c += ctx->result[i + 2]; + d += ctx->result[i + 3]; + e += ctx->result[i + 4]; + f += ctx->result[i + 5]; + g += ctx->result[i + 6]; + h += ctx->result[i + 7]; ISAAC_MIX(a, b, c, d, e, f, g, h); - m[i] = a; - m[i + 1] = b; - m[i + 2] = c; - m[i + 3] = d; - m[i + 4] = e; - m[i + 5] = f; - m[i + 6] = g; - m[i + 7] = h; + ctx->mem[i] = a; + ctx->mem[i + 1] = b; + ctx->mem[i + 2] = c; + ctx->mem[i + 3] = d; + ctx->mem[i + 4] = e; + ctx->mem[i + 5] = f; + ctx->mem[i + 6] = g; + ctx->mem[i + 7] = h; } - /* do a second pass to make all of the seed affect all of m */ + /* Do a second pass to make all of the seed affect all of ctx->mem. */ for (i = 0; i < ISAAC_SIZE; i += 8) { - a += m[i]; - b += m[i + 1]; - c += m[i + 2]; - d += m[i + 3]; - e += m[i + 4]; - f += m[i + 5]; - g += m[i + 6]; - h += m[i + 7]; + a += ctx->mem[i]; + b += ctx->mem[i + 1]; + c += ctx->mem[i + 2]; + d += ctx->mem[i + 3]; + e += ctx->mem[i + 4]; + f += ctx->mem[i + 5]; + g += ctx->mem[i + 6]; + h += ctx->mem[i + 7]; ISAAC_MIX(a, b, c, d, e, f, g, h); - m[i] = a; - m[i + 1] = b; - m[i + 2] = c; - m[i + 3] = d; - m[i + 4] = e; - m[i + 5] = f; - m[i + 6] = g; - m[i + 7] = h; + ctx->mem[i] = a; + ctx->mem[i + 1] = b; + ctx->mem[i + 2] = c; + ctx->mem[i + 3] = d; + ctx->mem[i + 4] = e; + ctx->mem[i + 5] = f; + ctx->mem[i + 6] = g; + ctx->mem[i + 7] = h; } } else { for (i = 0; i < ISAAC_SIZE; i += 8) { - /* fill in mm[] with messy stuff */ + /* Fill in ctx->mem[] with messy stuff. */ ISAAC_MIX(a, b, c, d, e, f, g, h); - m[i] = a; - m[i + 1] = b; - m[i + 2] = c; - m[i + 3] = d; - m[i + 4] = e; - m[i + 5] = f; - m[i + 6] = g; - m[i + 7] = h; + ctx->mem[i] = a; + ctx->mem[i + 1] = b; + ctx->mem[i + 2] = c; + ctx->mem[i + 3] = d; + ctx->mem[i + 4] = e; + ctx->mem[i + 5] = f; + ctx->mem[i + 6] = g; + ctx->mem[i + 7] = h; } } - /* fill in the first set of results */ - isaac_round(ctx); - /* prepare to use the first set of results */ - ctx->cnt = ISAAC_SIZE; + /* Fill in the first set of results. */ + isaac_shuffle(ctx); + /* Prepare to use the first set of results. */ + ctx->available_next_values = ISAAC_SIZE; } /* * Maps to `void isaac(randctx*)` from the original implementation. */ -static void isaac_round(isaac_ctx_t* const ctx) +static void isaac_shuffle(isaac_ctx_t* const ctx) { uint32_t* m; - uint32_t* mm; + uint32_t* mm = ctx->mem; uint32_t* m2; - uint32_t* r; + uint32_t* r = ctx->result; uint32_t* mend; - uint32_t a; - uint32_t b; + uint32_t a = ctx->a; + uint32_t b = ctx->b + (++ctx->c); uint32_t x; uint32_t y; - mm = ctx->mem; - r = ctx->rsl; - a = ctx->a; - b = ctx->b + (++ctx->c); for (m = mm, mend = m2 = m + (ISAAC_SIZE / 2U); m < mend;) { ISAAC_STEP(a << 13U, a, b, mm, m, m2, r, x); @@ -191,17 +174,10 @@ static void isaac_round(isaac_ctx_t* const ctx) uint32_t isaac_next(isaac_ctx_t* const ctx) { - if (!(ctx->cnt--)) + if (!(ctx->available_next_values--)) { - isaac_round(ctx); - ctx->cnt = ISAAC_SIZE - 1; + isaac_shuffle(ctx); + ctx->available_next_values = ISAAC_SIZE - 1; } - return ctx->rsl[ctx->cnt]; + return ctx->result[ctx->available_next_values]; } - -#ifdef NEVER -int main() -{ - -} -#endif diff --git a/tst/test_init.c b/tst/test_init.c index e46a637..d4943fb 100644 --- a/tst/test_init.c +++ b/tst/test_init.c @@ -188,7 +188,7 @@ const static uint8_t expected_initialised_ctx[] = { static void test_init_against_reference(void) { isaac_ctx_t ctx; - memset(ctx.rsl, 0, ISAAC_SIZE); // Zero seed + memset(ctx.result, 0, ISAAC_SIZE); // Zero seed isaac_init(&ctx, true); From 8c365107762bc18969c4ea94d2bd8150af656aa5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matjaz=CC=8C?= Date: Sun, 26 Apr 2020 21:34:09 +0200 Subject: [PATCH 05/27] Add next8, remove unused macros --- inc/isaac.h | 37 +++++- src/isaac.c | 60 +++++---- tst/test_init.c | 315 +++++++++++++++++++++--------------------------- tst/test_next.c | 74 ++++++++++-- 4 files changed, 273 insertions(+), 213 deletions(-) diff --git a/inc/isaac.h b/inc/isaac.h index b8e8ba3..3b1ace3 100644 --- a/inc/isaac.h +++ b/inc/isaac.h @@ -39,20 +39,22 @@ extern "C" #include #include -#define ISAAC_SIZE 256U +#define ISAAC_U32_ELEMENTS 256U /** * Context of the ISAAC CPRNG. * * Maps to `randctx` from the original implementation. */ -typedef struct { - uint32_t available_next_values; - uint32_t result[ISAAC_SIZE]; - uint32_t mem[ISAAC_SIZE]; +typedef struct +{ + uint32_t result[ISAAC_U32_ELEMENTS]; + uint32_t mem[ISAAC_U32_ELEMENTS]; uint32_t a; uint32_t b; uint32_t c; + uint16_t next32_index; // cound be uint8 + uint16_t next8_index; // cound be uint8 } isaac_ctx_t; /** @@ -67,7 +69,30 @@ typedef struct { * @param flag */ void isaac_init(isaac_ctx_t* ctx, bool flag); -uint32_t isaac_next(isaac_ctx_t* ctx); + +/** + * Provides the next pseudo-random 32-bit integer. + * + * After #ISAAC_ELEMENTS calls it will automatically reshuffle the ISAAC state + * to provide #ISAAC_ELEMENTS new elements. This means that #ISAAC_ELEMENTS + * calls are very cheap (just reading the uint32_t value from the state), + * and the #ISAAC_ELEMENTS+1 call is expensive. + * + * @warning + * **Use either isaac_next32() or isaac_next8(), never both**, especially not + * in an interleaved manner. The issue is that isaac_next8() reads bytes + * from the isaac_next32() output; this means that calling isaac_next8() and + * then isaac_next32() will produce the same byte twice, which is **unsecure** + * and predictable. + * + * @param ctx + * @return a pseudo-random 32-bit integer. + */ +uint32_t isaac_next32(isaac_ctx_t* ctx); + +// Compared to the next32, this provides the bytes in little endian order +// DO NOT MIX USAGE OF NEXT8 and NEXT32 +uint8_t isaac_next8(isaac_ctx_t* ctx); #ifdef __cplusplus diff --git a/src/isaac.c b/src/isaac.c index 8f0f012..52ebd0c 100644 --- a/src/isaac.c +++ b/src/isaac.c @@ -14,21 +14,7 @@ #include "isaac.h" - -#ifndef min -# define min(a, b) (((a)<(b)) ? (a) : (b)) -#endif /* min */ -#ifndef max -# define max(a, b) (((a)<(b)) ? (b) : (a)) -#endif /* max */ -#ifndef align -# define align(a) (((uint32_t)a+(sizeof(void *)-1))&(~(sizeof(void *)-1))) -#endif /* align */ -#ifndef abs -# define abs(a) (((a)>0) ? (a) : -(a)) -#endif - -#define ISAAC_IND(mm, x) ((mm)[(x >> 2U) & (ISAAC_SIZE - 1)]) +#define ISAAC_IND(mm, x) ((mm)[(x >> 2U) & (ISAAC_U32_ELEMENTS - 1)]) #define ISAAC_STEP(mix, a, b, mm, m, m2, r, x) \ { \ @@ -75,7 +61,7 @@ void isaac_init(isaac_ctx_t* const ctx, const bool flag) if (flag) { /* Initialise using the contents of result[] as the seed. */ - for (i = 0; i < ISAAC_SIZE; i += 8) + for (i = 0; i < ISAAC_U32_ELEMENTS; i += 8) { a += ctx->result[i]; b += ctx->result[i + 1]; @@ -96,7 +82,7 @@ void isaac_init(isaac_ctx_t* const ctx, const bool flag) ctx->mem[i + 7] = h; } /* Do a second pass to make all of the seed affect all of ctx->mem. */ - for (i = 0; i < ISAAC_SIZE; i += 8) + for (i = 0; i < ISAAC_U32_ELEMENTS; i += 8) { a += ctx->mem[i]; b += ctx->mem[i + 1]; @@ -119,7 +105,7 @@ void isaac_init(isaac_ctx_t* const ctx, const bool flag) } else { - for (i = 0; i < ISAAC_SIZE; i += 8) + for (i = 0; i < ISAAC_U32_ELEMENTS; i += 8) { /* Fill in ctx->mem[] with messy stuff. */ ISAAC_MIX(a, b, c, d, e, f, g, h); @@ -136,7 +122,8 @@ void isaac_init(isaac_ctx_t* const ctx, const bool flag) /* Fill in the first set of results. */ isaac_shuffle(ctx); /* Prepare to use the first set of results. */ - ctx->available_next_values = ISAAC_SIZE; + ctx->next32_index = ISAAC_U32_ELEMENTS - 1; + ctx->next8_index = 0; } /* @@ -154,7 +141,7 @@ static void isaac_shuffle(isaac_ctx_t* const ctx) uint32_t x; uint32_t y; - for (m = mm, mend = m2 = m + (ISAAC_SIZE / 2U); m < mend;) + for (m = mm, mend = m2 = m + (ISAAC_U32_ELEMENTS / 2U); m < mend;) { ISAAC_STEP(a << 13U, a, b, mm, m, m2, r, x); ISAAC_STEP((a & UINT32_MAX) >> 6U, a, b, mm, m, m2, r, x); @@ -172,12 +159,37 @@ static void isaac_shuffle(isaac_ctx_t* const ctx) ctx->a = a; } -uint32_t isaac_next(isaac_ctx_t* const ctx) +uint32_t isaac_next32(isaac_ctx_t* const ctx) { - if (!(ctx->available_next_values--)) + const uint32_t next32 = ctx->result[ctx->next32_index]; + if (ctx->next32_index == 0) { + /* This is the last value we could extract before the reshuffle. */ isaac_shuffle(ctx); - ctx->available_next_values = ISAAC_SIZE - 1; + ctx->next32_index = ISAAC_U32_ELEMENTS - 1; + } + else + { + ctx->next32_index--; + } + return next32; +} + +/* We read the same next32 value 4 times and extract 4 different bytes from + * it, one per next8 call. */ +uint8_t isaac_next8(isaac_ctx_t* const ctx) +{ + const uint8_t next8 = (uint8_t) ( + ctx->result[ctx->next32_index] >> ctx->next8_index * 8U + ); + if (ctx->next8_index >= 3) + { + ctx->next8_index = 0; + isaac_next32(ctx); + } + else + { + ctx->next8_index++; } - return ctx->result[ctx->available_next_values]; + return next8; } diff --git a/tst/test_init.c b/tst/test_init.c index d4943fb..1279142 100644 --- a/tst/test_init.c +++ b/tst/test_init.c @@ -10,190 +10,155 @@ #include "test.h" -const static uint8_t expected_initialised_ctx[] = { - 0x00, 0x01, 0x00, 0x00, 0x39, 0xD3, 0x6D, 0xE7, 0x38, 0xA7, 0x1A, 0xD9, - 0xE5, 0x56, 0x29, 0xD3, 0x33, 0xE9, 0x64, 0xA2, 0x23, 0x00, 0xD2, 0x3D, - 0xDD, 0x1E, 0x6F, 0x45, 0xF4, 0x9C, 0xC5, 0x96, 0xFC, 0x88, 0xA3, 0xD3, - 0xC1, 0xA1, 0x89, 0x5D, 0xFC, 0x13, 0xF4, 0x49, 0x1E, 0xD9, 0x73, 0x48, - 0x43, 0x0E, 0x84, 0x2F, 0x62, 0xBD, 0x6A, 0xED, 0xAB, 0xA5, 0xC8, 0x10, - 0x7B, 0xA5, 0xC1, 0x43, 0x10, 0x1E, 0x0B, 0xD7, 0x04, 0xDC, 0x73, 0x81, - 0xAA, 0x8E, 0xF7, 0x53, 0x84, 0x1D, 0x65, 0x89, 0xFA, 0x7F, 0xBE, 0xD5, - 0xCE, 0xE7, 0x57, 0x6F, 0x47, 0xC4, 0x8A, 0x9C, 0x42, 0xE3, 0x73, 0x00, - 0x6C, 0xA6, 0x5A, 0x36, 0x5E, 0x1C, 0x66, 0x97, 0x9E, 0xE4, 0x90, 0xAF, - 0x23, 0x0A, 0x09, 0x8C, 0x42, 0x45, 0x86, 0x0E, 0x39, 0xDF, 0xE0, 0x3D, - 0x8E, 0xF4, 0x7A, 0xBF, 0xE7, 0x1B, 0x87, 0x13, 0x49, 0x8B, 0x7A, 0x3E, - 0x6F, 0xD3, 0x07, 0x42, 0x30, 0xC6, 0x8E, 0x4A, 0x72, 0xB2, 0x06, 0x0A, - 0x54, 0x76, 0x90, 0x66, 0x44, 0x82, 0xED, 0x9D, 0xB8, 0x8B, 0x02, 0x32, - 0xC6, 0x01, 0x39, 0x4C, 0x34, 0x08, 0x47, 0xB6, 0xCA, 0xD7, 0x1B, 0x62, - 0xEC, 0xAD, 0x13, 0xF3, 0x83, 0x98, 0x65, 0x2F, 0x02, 0x97, 0x97, 0x9E, - 0x84, 0xD1, 0xAD, 0xBB, 0xA5, 0x14, 0xDD, 0x03, 0x1C, 0xC2, 0xAB, 0x43, - 0x29, 0x22, 0x5E, 0x56, 0x27, 0xE9, 0xDA, 0x89, 0xFB, 0x0A, 0x06, 0x60, - 0x31, 0x0B, 0x89, 0xCA, 0x52, 0x35, 0x25, 0xD5, 0x80, 0xA4, 0x2B, 0xAD, - 0x0E, 0x4B, 0x19, 0xE1, 0x0D, 0x5C, 0x84, 0x2D, 0x53, 0x8E, 0xA4, 0x97, - 0x2F, 0xBC, 0xEF, 0xC7, 0x96, 0xE4, 0x71, 0x99, 0xDE, 0xC2, 0xD8, 0x80, - 0x0B, 0x71, 0xE5, 0xA0, 0x69, 0x59, 0x95, 0x0F, 0x4C, 0xE1, 0x66, 0xB5, - 0xDA, 0xD6, 0x0C, 0x0B, 0xF6, 0x89, 0xF4, 0xE5, 0xDE, 0x7A, 0x90, 0x2C, - 0x2E, 0xF0, 0xE3, 0x7B, 0x07, 0x3B, 0xF6, 0x71, 0x7F, 0xE5, 0xE6, 0x09, - 0x7A, 0x3E, 0x37, 0x4C, 0x39, 0x26, 0x9A, 0xC9, 0x17, 0x3D, 0x71, 0x54, - 0x1A, 0x83, 0xF0, 0x11, 0x4E, 0x1C, 0xAA, 0x76, 0x01, 0x7F, 0xF5, 0xDB, - 0xA8, 0x60, 0x21, 0x8B, 0x09, 0x4C, 0x2F, 0x2B, 0x74, 0x69, 0x5E, 0xCC, - 0xC4, 0x83, 0xE2, 0xFD, 0x94, 0x6B, 0x9E, 0x8B, 0xCA, 0x89, 0x1A, 0x80, - 0xC0, 0x11, 0x1B, 0x65, 0xCD, 0x41, 0x0D, 0x36, 0xD6, 0x43, 0x24, 0xBF, - 0xD5, 0x1F, 0x80, 0x79, 0xB3, 0x25, 0x5F, 0xD9, 0x85, 0xD7, 0x49, 0xB8, - 0xF3, 0xC5, 0xC7, 0x5F, 0x00, 0x3D, 0x8D, 0x36, 0xC2, 0xEE, 0xC5, 0x85, - 0x20, 0x55, 0x2F, 0x7E, 0xDC, 0x2A, 0xBA, 0x41, 0x48, 0x98, 0x50, 0x5C, - 0x80, 0xDC, 0x61, 0x07, 0xA4, 0x83, 0x27, 0x87, 0x7C, 0x90, 0xCE, 0x71, - 0xA8, 0x1F, 0x80, 0x52, 0xF4, 0xE3, 0xE8, 0x64, 0x1E, 0xD5, 0x21, 0x5D, - 0xBA, 0x0D, 0x93, 0xF4, 0x02, 0x70, 0x34, 0x3B, 0x32, 0xBD, 0xB6, 0x4E, - 0x3A, 0x5A, 0x58, 0xF9, 0xBD, 0xFA, 0x60, 0x7A, 0x7A, 0xF9, 0xEC, 0x49, - 0xEB, 0xCA, 0xFC, 0x82, 0x5C, 0xAB, 0xB8, 0xFF, 0xE2, 0xCE, 0x44, 0x18, - 0xA6, 0x5C, 0x1F, 0x16, 0xAB, 0xFC, 0x5C, 0xAF, 0xD6, 0x95, 0x2C, 0x33, - 0x1D, 0x98, 0xB5, 0xA5, 0xE6, 0xD9, 0xD8, 0x99, 0xCB, 0xEF, 0x95, 0x60, - 0x28, 0xE4, 0xE6, 0xAD, 0x40, 0x11, 0x0A, 0x29, 0x45, 0x2B, 0x82, 0x67, - 0x66, 0xC3, 0x9A, 0x35, 0x54, 0x34, 0x25, 0xFB, 0x3C, 0x75, 0x8E, 0x8B, - 0xF6, 0x12, 0xAB, 0x7C, 0xA6, 0x00, 0x50, 0xE1, 0x96, 0x08, 0xF4, 0x4A, - 0x32, 0xB1, 0x6F, 0x5B, 0x9B, 0xB1, 0x84, 0xFD, 0x02, 0x1D, 0x3A, 0xA4, - 0x25, 0x37, 0x2C, 0x67, 0x42, 0xAC, 0x21, 0x9D, 0x70, 0xCC, 0xF4, 0x3F, - 0x65, 0xA4, 0x1E, 0xE4, 0x64, 0x20, 0xBB, 0xE3, 0x9D, 0xD7, 0xC4, 0x44, - 0x93, 0xE8, 0xD6, 0x44, 0xC6, 0x85, 0x63, 0x43, 0x6E, 0xD0, 0x10, 0xB3, - 0x48, 0xE5, 0x8B, 0xDF, 0xC6, 0xDF, 0x92, 0x29, 0xE4, 0xD9, 0xCB, 0xB2, - 0x15, 0xB9, 0xB4, 0x80, 0x66, 0x5C, 0xFC, 0xB3, 0xB2, 0x5B, 0x72, 0x7A, - 0x84, 0x5B, 0x65, 0x4C, 0x64, 0xD7, 0xD1, 0x1A, 0xEB, 0x43, 0x30, 0x1D, - 0x6B, 0x33, 0xCC, 0xB0, 0x38, 0x45, 0x2F, 0x6B, 0x9B, 0x66, 0x29, 0x3D, - 0xF3, 0xAC, 0x75, 0x62, 0x4F, 0xD6, 0xDF, 0x08, 0x01, 0x82, 0x65, 0x36, - 0xA3, 0x96, 0x7E, 0x00, 0xF5, 0x02, 0x3A, 0x00, 0x8F, 0x8A, 0xF3, 0xDB, - 0xEE, 0x30, 0x55, 0x20, 0x33, 0x03, 0x31, 0xB3, 0x7F, 0x8C, 0xFC, 0x7D, - 0x22, 0x2A, 0xB2, 0x10, 0xCC, 0x7B, 0xC1, 0x9C, 0x71, 0x19, 0xBA, 0xC6, - 0xAC, 0xE2, 0x30, 0xC2, 0xC6, 0x06, 0x5E, 0xDD, 0x49, 0xEC, 0x07, 0x3F, - 0xD5, 0xD9, 0xD3, 0x1A, 0xBA, 0x0D, 0x5F, 0x76, 0x24, 0x81, 0x41, 0xC5, - 0x54, 0xED, 0x0D, 0x06, 0x9B, 0x31, 0x55, 0xFA, 0x01, 0x31, 0x56, 0x5B, - 0x14, 0xAD, 0x31, 0xB8, 0x23, 0xC3, 0x7D, 0x9C, 0xF1, 0xBA, 0x99, 0xE0, - 0x9A, 0x1C, 0x08, 0x7F, 0x3C, 0xA2, 0xCF, 0xB7, 0x46, 0x85, 0xE4, 0xD7, - 0xBE, 0x94, 0xBB, 0x4F, 0x29, 0x5D, 0x0B, 0xB1, 0xB2, 0xC9, 0x53, 0x7C, - 0x6E, 0xAD, 0x35, 0x09, 0x02, 0xFF, 0x5F, 0xCC, 0xD5, 0x02, 0x48, 0xE3, - 0x32, 0x98, 0x35, 0x03, 0xDB, 0x20, 0xAC, 0x4D, 0x6D, 0x40, 0xF0, 0xBA, - 0xB4, 0x65, 0xD5, 0x15, 0xD0, 0x1F, 0xDF, 0x1B, 0x4F, 0x8A, 0x4B, 0x39, - 0xED, 0xA9, 0x7E, 0x2E, 0xE4, 0x69, 0x29, 0x0F, 0x0C, 0x74, 0x0A, 0x89, - 0x16, 0x25, 0x34, 0xDE, 0x7E, 0xD9, 0x26, 0x90, 0x5F, 0x82, 0x21, 0x95, - 0x39, 0x9A, 0x35, 0x6F, 0x8B, 0x3F, 0xCB, 0x98, 0xAB, 0xD8, 0xC0, 0x02, - 0x7D, 0x34, 0x2B, 0x90, 0x04, 0x0E, 0xFE, 0x1F, 0xF1, 0xBD, 0x60, 0xF4, - 0x56, 0x6E, 0xDC, 0xA7, 0xBF, 0x7E, 0xCB, 0x17, 0x6D, 0x01, 0x26, 0xB0, - 0x3B, 0x96, 0x6E, 0xED, 0x7B, 0x76, 0xEB, 0x72, 0xEA, 0x3E, 0xF6, 0xBE, - 0x10, 0x18, 0x46, 0x6F, 0xAD, 0x5E, 0xBA, 0x7B, 0xEA, 0x00, 0x3C, 0x5D, - 0x54, 0xD2, 0xFD, 0x4C, 0xAE, 0xC8, 0x5C, 0x67, 0xBE, 0xFA, 0x7F, 0xB9, - 0x76, 0xD4, 0x92, 0x24, 0x0A, 0x93, 0x83, 0x4E, 0x4D, 0x77, 0xF0, 0x26, - 0xDE, 0xA4, 0x90, 0x4B, 0x81, 0xCE, 0xE6, 0x6B, 0x58, 0x21, 0xCA, 0x19, - 0x94, 0xEB, 0x58, 0xA3, 0xD7, 0x9C, 0xD1, 0x42, 0xAE, 0x1E, 0x04, 0xC7, - 0x27, 0xF6, 0xB4, 0xE8, 0x6F, 0x7B, 0xE1, 0x02, 0x99, 0x0E, 0x8A, 0xFB, - 0x7B, 0x4C, 0x60, 0x9E, 0x0D, 0xDA, 0x1E, 0xC0, 0x00, 0xA9, 0xD4, 0xEA, - 0xC4, 0x31, 0x21, 0x84, 0x94, 0xD9, 0x2F, 0x47, 0x0F, 0xD2, 0xAC, 0xC6, - 0x79, 0xFF, 0xD3, 0x44, 0xCE, 0x4F, 0xC0, 0x05, 0x17, 0x8B, 0x64, 0x67, - 0x0D, 0x4D, 0x7C, 0xF2, 0x6F, 0xE8, 0x16, 0x00, 0xA4, 0xCF, 0x29, 0x16, - 0x8F, 0x0B, 0x45, 0xAC, 0xB9, 0xEA, 0xB3, 0x5A, 0x24, 0x5E, 0xC7, 0xF4, - 0xBD, 0x71, 0xC8, 0x25, 0xFA, 0x6F, 0xE1, 0xBA, 0x29, 0xFA, 0x49, 0x62, - 0x18, 0x9E, 0xC2, 0xC5, 0x7A, 0xF5, 0x58, 0xA6, 0xBD, 0x8F, 0x0F, 0xC9, - 0x1D, 0xB7, 0x7C, 0x34, 0x74, 0x3F, 0xC3, 0x96, 0xFB, 0x9A, 0x4C, 0xCC, - 0xC2, 0x41, 0x4F, 0x89, 0xEF, 0x1D, 0x25, 0x52, 0xAF, 0x1F, 0x07, 0x5F, - 0x24, 0x9C, 0xC9, 0x0F, 0xB5, 0xA8, 0xFF, 0xB3, 0xE9, 0x06, 0x52, 0x99, - 0x79, 0xD6, 0x6F, 0x29, 0x21, 0xCD, 0x8A, 0xB0, 0x22, 0x66, 0x1B, 0x30, - 0x8D, 0x4A, 0x0B, 0x30, 0xF3, 0x00, 0x26, 0x18, 0x81, 0x7A, 0x04, 0x56, - 0x99, 0x05, 0x66, 0xD6, 0x4B, 0x9A, 0x15, 0xB0, 0x2A, 0xDC, 0x64, 0x19, - 0x6C, 0x42, 0x02, 0x4D, 0x95, 0x61, 0x0F, 0x68, 0x69, 0xD7, 0x4C, 0xB0, - 0xBD, 0x84, 0x17, 0x11, 0xAE, 0x04, 0x73, 0x26, 0x48, 0x2F, 0x45, 0x7E, - 0xED, 0xF7, 0xCF, 0x02, 0x89, 0x78, 0x6E, 0xCC, 0x5A, 0x53, 0x3A, 0x7D, - 0xC0, 0xE3, 0x8E, 0x36, 0x2C, 0x80, 0x4D, 0x3F, 0x9E, 0x9E, 0x18, 0xEE, - 0x0E, 0x35, 0x6D, 0x63, 0xBF, 0x99, 0xFD, 0x59, 0x83, 0x29, 0xA2, 0xC5, - 0x5B, 0x5D, 0x9A, 0x4B, 0xDB, 0x09, 0x47, 0xC4, 0xFD, 0xFF, 0x63, 0x89, - 0x4A, 0xDF, 0x4C, 0xE5, 0xA6, 0x9D, 0xFC, 0x6E, 0xD5, 0x47, 0x27, 0x34, - 0xC1, 0xE6, 0x59, 0x60, 0x56, 0x06, 0xF4, 0x90, 0x3A, 0x6B, 0x85, 0x4B, - 0x10, 0x80, 0x93, 0xD4, 0x58, 0x5D, 0xFD, 0xA4, 0x85, 0xB8, 0xB0, 0xA4, - 0x23, 0x11, 0xA9, 0xD9, 0x6E, 0x4B, 0xE0, 0x1E, 0xCA, 0x79, 0x11, 0x43, - 0x52, 0xC0, 0x6C, 0x5D, 0xA5, 0x54, 0x91, 0xFA, 0x2E, 0x17, 0xD4, 0x8C, - 0xC5, 0x70, 0x73, 0xD4, 0x76, 0x76, 0xD1, 0xAC, 0x6C, 0x34, 0xFD, 0xAA, - 0x2E, 0x71, 0x30, 0x07, 0x8F, 0xAE, 0x93, 0x47, 0x02, 0xE5, 0x8D, 0x1C, - 0x2A, 0xFC, 0x9C, 0x0B, 0x3C, 0x9D, 0xDD, 0x64, 0xB9, 0x2E, 0x66, 0x51, - 0x40, 0xBC, 0xAF, 0xC9, 0xED, 0xE1, 0x75, 0x1E, 0x58, 0xB0, 0xD4, 0x4F, - 0x97, 0xC1, 0x70, 0xB3, 0xC3, 0x7B, 0x5A, 0xE1, 0xDD, 0x20, 0x2E, 0x38, - 0x83, 0x33, 0x03, 0x0F, 0x0E, 0xDC, 0x00, 0xCB, 0xFE, 0x4C, 0x04, 0xEF, - 0x3A, 0xBE, 0xF5, 0xAA, 0x5C, 0x17, 0x25, 0xF2, 0x88, 0x31, 0x76, 0x8A, - 0x14, 0x69, 0x6A, 0x4B, 0xAF, 0xC1, 0x8B, 0x7A, 0x5B, 0x7C, 0x5C, 0x05, - 0x25, 0x64, 0x80, 0xFE, 0x94, 0xA4, 0xF9, 0x4B, 0xDF, 0x37, 0x62, 0x01, - 0xED, 0xC2, 0xB7, 0xE2, 0x50, 0x88, 0x1E, 0x6F, 0x0B, 0xEA, 0x5B, 0x7B, - 0x13, 0x06, 0x35, 0x1D, 0xD7, 0x29, 0x4E, 0xF9, 0xC1, 0x2F, 0xE9, 0x55, - 0xEA, 0x5D, 0x91, 0xD2, 0x6A, 0x05, 0xF3, 0xF9, 0x69, 0x3F, 0x1B, 0x12, - 0x8D, 0xFD, 0x72, 0xC3, 0x64, 0x1E, 0x35, 0xD0, 0x16, 0x39, 0x04, 0xCA, - 0x2E, 0xD6, 0x3F, 0x33, 0x5C, 0x67, 0xC4, 0x17, 0xA2, 0x8E, 0x30, 0xA3, - 0x95, 0x7F, 0xD0, 0x13, 0x4F, 0xE1, 0xF2, 0x09, 0x0F, 0xC8, 0x8A, 0x46, - 0xAA, 0x50, 0x13, 0xE5, 0xB5, 0xB3, 0xDC, 0x85, 0xDE, 0xA9, 0xEF, 0xC1, - 0x5E, 0x5C, 0xB4, 0xFA, 0xEA, 0x75, 0x07, 0xAA, 0xE2, 0xA4, 0xB6, 0x70, - 0x84, 0xCE, 0x3D, 0x5B, 0x69, 0x95, 0xC5, 0xE8, 0xE9, 0xCC, 0x6D, 0xE1, - 0x03, 0xC9, 0xC9, 0xEA, 0xE9, 0xD5, 0x99, 0x16, 0x2D, 0x75, 0xCE, 0xB5, - 0xF0, 0x48, 0x8A, 0x30, 0xC1, 0xC1, 0xD5, 0xBC, 0xD1, 0xE2, 0xC4, 0x3C, - 0x10, 0xA8, 0x52, 0xE3, 0x88, 0xC6, 0xB0, 0xD6, 0x45, 0x1F, 0x5E, 0x63, - 0x56, 0x38, 0xFF, 0x16, 0x89, 0x19, 0x53, 0x26, 0xD0, 0x5D, 0xCE, 0x71, - 0x13, 0x16, 0x03, 0x65, 0x4A, 0xC8, 0x5C, 0x42, 0xFA, 0xF9, 0xB8, 0xFD, - 0x99, 0x87, 0x64, 0x6B, 0x39, 0xA6, 0xE1, 0x4E, 0xD8, 0x08, 0x6E, 0xEB, - 0x58, 0xA2, 0x88, 0x6A, 0x21, 0x2D, 0x05, 0xA6, 0x29, 0x30, 0xFF, 0x1D, - 0x72, 0x39, 0x41, 0x05, 0x17, 0x89, 0xB8, 0xDE, 0xB6, 0xFA, 0x4E, 0x17, - 0x47, 0x6A, 0x4C, 0xA0, 0x81, 0x3F, 0xE6, 0x63, 0x6C, 0x16, 0x89, 0x70, - 0xAD, 0x28, 0x32, 0x89, 0xB0, 0xEA, 0x4A, 0xEB, 0xCE, 0x9B, 0xA0, 0x10, - 0x63, 0x6D, 0xB4, 0x79, 0x9D, 0x91, 0xCC, 0x69, 0x2E, 0x30, 0x7E, 0xC1, - 0x6E, 0xE5, 0x7E, 0x50, 0x35, 0x57, 0xCE, 0x07, 0x8F, 0xD8, 0x3C, 0xF6, - 0x5A, 0x82, 0xA8, 0xFE, 0xE0, 0x12, 0xD2, 0xEB, 0x9B, 0xDD, 0xFF, 0x75, - 0x67, 0xC9, 0x9E, 0xBD, 0x23, 0xF7, 0xBE, 0xF2, 0xB3, 0x70, 0x98, 0x02, - 0x8B, 0xD0, 0xAB, 0x3A, 0x64, 0x77, 0x39, 0x64, 0x11, 0x34, 0xCE, 0x08, - 0xCF, 0x47, 0xBC, 0x49, 0x04, 0xAC, 0xC3, 0xEB, 0xD4, 0xE3, 0xE2, 0x0D, - 0x37, 0xE4, 0x28, 0x38, 0x53, 0x92, 0x2F, 0x1F, 0xA8, 0x57, 0x2A, 0x3F, - 0x32, 0xDA, 0x1B, 0xB5, 0x86, 0x8E, 0x49, 0xED, 0xAC, 0xF6, 0xC9, 0xD2, - 0x81, 0x73, 0x27, 0xA6, 0xD7, 0x6A, 0xA4, 0x15, 0x57, 0xE6, 0x54, 0xFA, - 0xB8, 0x79, 0x94, 0xB4, 0x95, 0xB1, 0xF4, 0x95, 0x03, 0x17, 0x4F, 0xDB, - 0x14, 0x5A, 0x74, 0x54, 0xBC, 0xC3, 0xB8, 0x02, 0x78, 0x49, 0xA1, 0xFE, - 0xAE, 0x80, 0xAA, 0xAD, 0xED, 0xFC, 0x32, 0x24, 0xC2, 0x0F, 0xBB, 0xF4, - 0x07, 0xA4, 0xF6, 0x87, 0x4C, 0xF2, 0x15, 0x0C, 0xF4, 0xAD, 0x0F, 0x79, - 0x28, 0x8D, 0x76, 0x50, 0xC7, 0x13, 0x96, 0x34, 0x90, 0x6F, 0x70, 0x37, - 0xB6, 0xB5, 0x47, 0xE0, 0xD1, 0x55, 0x29, 0x16, 0x62, 0xE5, 0xC6, 0x46, - 0x94, 0x56, 0x70, 0xCF, 0x4B, 0x78, 0xA3, 0x92, 0xE0, 0x4C, 0xD2, 0x4C, - 0x9D, 0x52, 0x63, 0x3A, 0x39, 0xD9, 0x80, 0xC9, 0xC4, 0x65, 0x6E, 0x91, - 0x1E, 0x2D, 0xEA, 0x27, 0x39, 0x23, 0xAD, 0x77, 0xC2, 0x61, 0x7A, 0x35, - 0x91, 0x3C, 0x6A, 0x13, 0x25, 0xF9, 0x95, 0xDC, 0xB8, 0xAA, 0x8E, 0x8B, - 0x60, 0xAD, 0x2A, 0x6E, 0xD6, 0xCB, 0xEA, 0xC3, 0xDA, 0xC6, 0x73, 0x10, - 0xAA, 0x3D, 0x56, 0x4D, 0x5E, 0x29, 0xD0, 0x1A, 0x54, 0xDA, 0x3F, 0xF2, - 0x44, 0xD7, 0xFB, 0x4F, 0x8C, 0x80, 0x78, 0xD0, 0x7E, 0x9D, 0xDF, 0xA6, - 0x0B, 0xF3, 0x07, 0x3A, 0xBB, 0x15, 0xD2, 0xD4, 0x12, 0x07, 0x50, 0x9E, - 0x87, 0x15, 0x0F, 0x87, 0xB3, 0x99, 0xDF, 0x03, 0x93, 0xA8, 0x69, 0xE1, - 0x7A, 0x02, 0x2A, 0x5D, 0xC3, 0x4E, 0xB4, 0x4A, 0x7C, 0xB2, 0x62, 0xCC, - 0xA2, 0x6C, 0xBA, 0x20, 0x20, 0x75, 0x7A, 0xD8, 0xA6, 0xE0, 0xEF, 0x76, - 0x4D, 0xD7, 0xCF, 0x31, 0xFB, 0xEC, 0x4A, 0xB6, 0x75, 0xB0, 0x0E, 0x94, - 0xCC, 0xE8, 0x49, 0xAB, 0xE4, 0x97, 0x11, 0x70, 0xDF, 0xF8, 0x27, 0xC7, - 0xD1, 0x41, 0xBD, 0x46, 0x57, 0x4B, 0xBC, 0x71, 0x7E, 0xB2, 0x4F, 0x55, - 0xB8, 0x95, 0xB4, 0x12, 0x2D, 0x18, 0x21, 0x98, 0x4E, 0x60, 0xA0, 0x57, - 0x6E, 0x4A, 0xAE, 0x65, 0xE7, 0xE5, 0x97, 0xAD, 0xB1, 0x62, 0xE7, 0x16, - 0x34, 0x8F, 0xFA, 0xFC, 0x54, 0x8F, 0xA1, 0x5C, 0x83, 0xA0, 0x06, 0x34, - 0xA6, 0x94, 0xB1, 0xA1, 0x96, 0xB2, 0x2D, 0x25, 0xD6, 0x0F, 0xEC, 0x43, - 0x29, 0x74, 0x94, 0x26, 0xA2, 0x2F, 0xB1, 0x6C, 0xB2, 0xA4, 0x38, 0x6D, - 0xA9, 0x37, 0x2A, 0x4A, 0x01, 0xD1, 0x6E, 0x6B, 0x37, 0x84, 0x18, 0xFD, - 0x76, 0xCA, 0xD7, 0xED, 0x33, 0x85, 0x30, 0x96, 0x86, 0x8D, 0x5C, 0xC8, - 0x36, 0xBC, 0x79, 0x41, 0x8E, 0x37, 0xF7, 0x35, 0x66, 0xB4, 0x6D, 0x0B, - 0x39, 0xAC, 0x48, 0x1C, 0x96, 0x69, 0x1F, 0x0C, 0xA9, 0x10, 0x58, 0x71, - 0x07, 0xD0, 0xAE, 0x7A, 0x6A, 0x53, 0x3F, 0x10, 0x3F, 0x46, 0xA9, 0x89, - 0x28, 0xDD, 0x25, 0x03, 0x7F, 0xB5, 0x97, 0x5E, 0xB6, 0x9B, 0xFA, 0x4C, - 0x4F, 0x08, 0xE5, 0x24, 0x9D, 0xE5, 0xC9, 0x65, 0x45, 0x29, 0xCD, 0xC4, - 0xC4, 0x84, 0x91, 0x7F, 0x8A, 0xDE, 0xAA, 0xC1, 0x0B, 0xAE, 0xE5, 0x10, - 0xDD, 0xCA, 0xB2, 0x35, 0x11, 0xE2, 0xF5, 0xEA, 0xA6, 0x8C, 0xDE, 0x8F, - 0x77, 0x22, 0xC8, 0x5F, 0x81, 0x11, 0xAD, 0x58, 0x71, 0x0A, 0x71, 0x3D, - 0x2F, 0xC3, 0x10, 0x0B, 0xD6, 0x36, 0xBB, 0x94, 0x09, 0x05, 0xD8, 0x71, - 0x48, 0x2B, 0xD2, 0x44, 0xF3, 0x00, 0x26, 0x18, 0x01, 0x00, 0x00, 0x00, +const static isaac_ctx_t expected_initialised_ctx = { + .next32_index = ISAAC_U32_ELEMENTS - 1, + .next8_index = 0, + .a = 0x44D22B48UL, + .b = 0x182600F3UL, + .c = 0x00000001UL, + .result = { + 0xE76DD339UL, 0xD91AA738UL, 0xD32956E5UL, 0xA264E933UL, + 0x3DD20023UL, 0x456F1EDDUL, 0x96C59CF4UL, 0xD3A388FCUL, + 0x5D89A1C1UL, 0x49F413FCUL, 0x4873D91EUL, 0x2F840E43UL, + 0xED6ABD62UL, 0x10C8A5ABUL, 0x43C1A57BUL, 0xD70B1E10UL, + 0x8173DC04UL, 0x53F78EAAUL, 0x89651D84UL, 0xD5BE7FFAUL, + 0x6F57E7CEUL, 0x9C8AC447UL, 0x0073E342UL, 0x365AA66CUL, + 0x97661C5EUL, 0xAF90E49EUL, 0x8C090A23UL, 0x0E864542UL, + 0x3DE0DF39UL, 0xBF7AF48EUL, 0x13871BE7UL, 0x3E7A8B49UL, + 0x4207D36FUL, 0x4A8EC630UL, 0x0A06B272UL, 0x66907654UL, + 0x9DED8244UL, 0x32028BB8UL, 0x4C3901C6UL, 0xB6470834UL, + 0x621BD7CAUL, 0xF313ADECUL, 0x2F659883UL, 0x9E979702UL, + 0xBBADD184UL, 0x03DD14A5UL, 0x43ABC21CUL, 0x565E2229UL, + 0x89DAE927UL, 0x60060AFBUL, 0xCA890B31UL, 0xD5253552UL, + 0xAD2BA480UL, 0xE1194B0EUL, 0x2D845C0DUL, 0x97A48E53UL, + 0xC7EFBC2FUL, 0x9971E496UL, 0x80D8C2DEUL, 0xA0E5710BUL, + 0x0F955969UL, 0xB566E14CUL, 0x0B0CD6DAUL, 0xE5F489F6UL, + 0x2C907ADEUL, 0x7BE3F02EUL, 0x71F63B07UL, 0x09E6E57FUL, + 0x4C373E7AUL, 0xC99A2639UL, 0x54713D17UL, 0x11F0831AUL, + 0x76AA1C4EUL, 0xDBF57F01UL, 0x8B2160A8UL, 0x2B2F4C09UL, + 0xCC5E6974UL, 0xFDE283C4UL, 0x8B9E6B94UL, 0x801A89CAUL, + 0x651B11C0UL, 0x360D41CDUL, 0xBF2443D6UL, 0x79801FD5UL, + 0xD95F25B3UL, 0xB849D785UL, 0x5FC7C5F3UL, 0x368D3D00UL, + 0x85C5EEC2UL, 0x7E2F5520UL, 0x41BA2ADCUL, 0x5C509848UL, + 0x0761DC80UL, 0x872783A4UL, 0x71CE907CUL, 0x52801FA8UL, + 0x64E8E3F4UL, 0x5D21D51EUL, 0xF4930DBAUL, 0x3B347002UL, + 0x4EB6BD32UL, 0xF9585A3AUL, 0x7A60FABDUL, 0x49ECF97AUL, + 0x82FCCAEBUL, 0xFFB8AB5CUL, 0x1844CEE2UL, 0x161F5CA6UL, + 0xAF5CFCABUL, 0x332C95D6UL, 0xA5B5981DUL, 0x99D8D9E6UL, + 0x6095EFCBUL, 0xADE6E428UL, 0x290A1140UL, 0x67822B45UL, + 0x359AC366UL, 0xFB253454UL, 0x8B8E753CUL, 0x7CAB12F6UL, + 0xE15000A6UL, 0x4AF40896UL, 0x5B6FB132UL, 0xFD84B19BUL, + 0xA43A1D02UL, 0x672C3725UL, 0x9D21AC42UL, 0x3FF4CC70UL, + 0xE41EA465UL, 0xE3BB2064UL, 0x44C4D79DUL, 0x44D6E893UL, + 0x436385C6UL, 0xB310D06EUL, 0xDF8BE548UL, 0x2992DFC6UL, + 0xB2CBD9E4UL, 0x80B4B915UL, 0xB3FC5C66UL, 0x7A725BB2UL, + 0x4C655B84UL, 0x1AD1D764UL, 0x1D3043EBUL, 0xB0CC336BUL, + 0x6B2F4538UL, 0x3D29669BUL, 0x6275ACF3UL, 0x08DFD64FUL, + 0x36658201UL, 0x007E96A3UL, 0x003A02F5UL, 0xDBF38A8FUL, + 0x205530EEUL, 0xB3310333UL, 0x7DFC8C7FUL, 0x10B22A22UL, + 0x9CC17BCCUL, 0xC6BA1971UL, 0xC230E2ACUL, 0xDD5E06C6UL, + 0x3F07EC49UL, 0x1AD3D9D5UL, 0x765F0DBAUL, 0xC5418124UL, + 0x060DED54UL, 0xFA55319BUL, 0x5B563101UL, 0xB831AD14UL, + 0x9C7DC323UL, 0xE099BAF1UL, 0x7F081C9AUL, 0xB7CFA23CUL, + 0xD7E48546UL, 0x4FBB94BEUL, 0xB10B5D29UL, 0x7C53C9B2UL, + 0x0935AD6EUL, 0xCC5FFF02UL, 0xE34802D5UL, 0x03359832UL, + 0x4DAC20DBUL, 0xBAF0406DUL, 0x15D565B4UL, 0x1BDF1FD0UL, + 0x394B8A4FUL, 0x2E7EA9EDUL, 0x0F2969E4UL, 0x890A740CUL, + 0xDE342516UL, 0x9026D97EUL, 0x9521825FUL, 0x6F359A39UL, + 0x98CB3F8BUL, 0x02C0D8ABUL, 0x902B347DUL, 0x1FFE0E04UL, + 0xF460BDF1UL, 0xA7DC6E56UL, 0x17CB7EBFUL, 0xB026016DUL, + 0xED6E963BUL, 0x72EB767BUL, 0xBEF63EEAUL, 0x6F461810UL, + 0x7BBA5EADUL, 0x5D3C00EAUL, 0x4CFDD254UL, 0x675CC8AEUL, + 0xB97FFABEUL, 0x2492D476UL, 0x4E83930AUL, 0x26F0774DUL, + 0x4B90A4DEUL, 0x6BE6CE81UL, 0x19CA2158UL, 0xA358EB94UL, + 0x42D19CD7UL, 0xC7041EAEUL, 0xE8B4F627UL, 0x02E17B6FUL, + 0xFB8A0E99UL, 0x9E604C7BUL, 0xC01EDA0DUL, 0xEAD4A900UL, + 0x842131C4UL, 0x472FD994UL, 0xC6ACD20FUL, 0x44D3FF79UL, + 0x05C04FCEUL, 0x67648B17UL, 0xF27C4D0DUL, 0x0016E86FUL, + 0x1629CFA4UL, 0xAC450B8FUL, 0x5AB3EAB9UL, 0xF4C75E24UL, + 0x25C871BDUL, 0xBAE16FFAUL, 0x6249FA29UL, 0xC5C29E18UL, + 0xA658F57AUL, 0xC90F8FBDUL, 0x347CB71DUL, 0x96C33F74UL, + 0xCC4C9AFBUL, 0x894F41C2UL, 0x52251DEFUL, 0x5F071FAFUL, + 0x0FC99C24UL, 0xB3FFA8B5UL, 0x995206E9UL, 0x296FD679UL, + 0xB08ACD21UL, 0x301B6622UL, 0x300B4A8DUL, 0x182600F3UL, + }, + .mem = { + 0x56047A81UL, 0xD6660599UL, 0xB0159A4BUL, 0x1964DC2AUL, + 0x4D02426CUL, 0x680F6195UL, 0xB04CD769UL, 0x111784BDUL, + 0x267304AEUL, 0x7E452F48UL, 0x02CFF7EDUL, 0xCC6E7889UL, + 0x7D3A535AUL, 0x368EE3C0UL, 0x3F4D802CUL, 0xEE189E9EUL, + 0x636D350EUL, 0x59FD99BFUL, 0xC5A22983UL, 0x4B9A5D5BUL, + 0xC44709DBUL, 0x8963FFFDUL, 0xE54CDF4AUL, 0x6EFC9DA6UL, + 0x342747D5UL, 0x6059E6C1UL, 0x90F40656UL, 0x4B856B3AUL, + 0xD4938010UL, 0xA4FD5D58UL, 0xA4B0B885UL, 0xD9A91123UL, + 0x1EE04B6EUL, 0x431179CAUL, 0x5D6CC052UL, 0xFA9154A5UL, + 0x8CD4172EUL, 0xD47370C5UL, 0xACD17676UL, 0xAAFD346CUL, + 0x0730712EUL, 0x4793AE8FUL, 0x1C8DE502UL, 0x0B9CFC2AUL, + 0x64DD9D3CUL, 0x51662EB9UL, 0xC9AFBC40UL, 0x1E75E1EDUL, + 0x4FD4B058UL, 0xB370C197UL, 0xE15A7BC3UL, 0x382E20DDUL, + 0x0F033383UL, 0xCB00DC0EUL, 0xEF044CFEUL, 0xAAF5BE3AUL, + 0xF225175CUL, 0x8A763188UL, 0x4B6A6914UL, 0x7A8BC1AFUL, + 0x055C7C5BUL, 0xFE806425UL, 0x4BF9A494UL, 0x016237DFUL, + 0xE2B7C2EDUL, 0x6F1E8850UL, 0x7B5BEA0BUL, 0x1D350613UL, + 0xF94E29D7UL, 0x55E92FC1UL, 0xD2915DEAUL, 0xF9F3056AUL, + 0x121B3F69UL, 0xC372FD8DUL, 0xD0351E64UL, 0xCA043916UL, + 0x333FD62EUL, 0x17C4675CUL, 0xA3308EA2UL, 0x13D07F95UL, + 0x09F2E14FUL, 0x468AC80FUL, 0xE51350AAUL, 0x85DCB3B5UL, + 0xC1EFA9DEUL, 0xFAB45C5EUL, 0xAA0775EAUL, 0x70B6A4E2UL, + 0x5B3DCE84UL, 0xE8C59569UL, 0xE16DCCE9UL, 0xEAC9C903UL, + 0x1699D5E9UL, 0xB5CE752DUL, 0x308A48F0UL, 0xBCD5C1C1UL, + 0x3CC4E2D1UL, 0xE352A810UL, 0xD6B0C688UL, 0x635E1F45UL, + 0x16FF3856UL, 0x26531989UL, 0x71CE5DD0UL, 0x65031613UL, + 0x425CC84AUL, 0xFDB8F9FAUL, 0x6B648799UL, 0x4EE1A639UL, + 0xEB6E08D8UL, 0x6A88A258UL, 0xA6052D21UL, 0x1DFF3029UL, + 0x05413972UL, 0xDEB88917UL, 0x174EFAB6UL, 0xA04C6A47UL, + 0x63E63F81UL, 0x7089166CUL, 0x893228ADUL, 0xEB4AEAB0UL, + 0x10A09BCEUL, 0x79B46D63UL, 0x69CC919DUL, 0xC17E302EUL, + 0x507EE56EUL, 0x07CE5735UL, 0xF63CD88FUL, 0xFEA8825AUL, + 0xEBD212E0UL, 0x75FFDD9BUL, 0xBD9EC967UL, 0xF2BEF723UL, + 0x029870B3UL, 0x3AABD08BUL, 0x64397764UL, 0x08CE3411UL, + 0x49BC47CFUL, 0xEBC3AC04UL, 0x0DE2E3D4UL, 0x3828E437UL, + 0x1F2F9253UL, 0x3F2A57A8UL, 0xB51BDA32UL, 0xED498E86UL, + 0xD2C9F6ACUL, 0xA6277381UL, 0x15A46AD7UL, 0xFA54E657UL, + 0xB49479B8UL, 0x95F4B195UL, 0xDB4F1703UL, 0x54745A14UL, + 0x02B8C3BCUL, 0xFEA14978UL, 0xADAA80AEUL, 0x2432FCEDUL, + 0xF4BB0FC2UL, 0x87F6A407UL, 0x0C15F24CUL, 0x790FADF4UL, + 0x50768D28UL, 0x349613C7UL, 0x37706F90UL, 0xE047B5B6UL, + 0x162955D1UL, 0x46C6E562UL, 0xCF705694UL, 0x92A3784BUL, + 0x4CD24CE0UL, 0x3A63529DUL, 0xC980D939UL, 0x916E65C4UL, + 0x27EA2D1EUL, 0x77AD2339UL, 0x357A61C2UL, 0x136A3C91UL, + 0xDC95F925UL, 0x8B8EAAB8UL, 0x6E2AAD60UL, 0xC3EACBD6UL, + 0x1073C6DAUL, 0x4D563DAAUL, 0x1AD0295EUL, 0xF23FDA54UL, + 0x4FFBD744UL, 0xD078808CUL, 0xA6DF9D7EUL, 0x3A07F30BUL, + 0xD4D215BBUL, 0x9E500712UL, 0x870F1587UL, 0x03DF99B3UL, + 0xE169A893UL, 0x5D2A027AUL, 0x4AB44EC3UL, 0xCC62B27CUL, + 0x20BA6CA2UL, 0xD87A7520UL, 0x76EFE0A6UL, 0x31CFD74DUL, + 0xB64AECFBUL, 0x940EB075UL, 0xAB49E8CCUL, 0x701197E4UL, + 0xC727F8DFUL, 0x46BD41D1UL, 0x71BC4B57UL, 0x554FB27EUL, + 0x12B495B8UL, 0x9821182DUL, 0x57A0604EUL, 0x65AE4A6EUL, + 0xAD97E5E7UL, 0x16E762B1UL, 0xFCFA8F34UL, 0x5CA18F54UL, + 0x3406A083UL, 0xA1B194A6UL, 0x252DB296UL, 0x43EC0FD6UL, + 0x26947429UL, 0x6CB12FA2UL, 0x6D38A4B2UL, 0x4A2A37A9UL, + 0x6B6ED101UL, 0xFD188437UL, 0xEDD7CA76UL, 0x96308533UL, + 0xC85C8D86UL, 0x4179BC36UL, 0x35F7378EUL, 0x0B6DB466UL, + 0x1C48AC39UL, 0x0C1F6996UL, 0x715810A9UL, 0x7AAED007UL, + 0x103F536AUL, 0x89A9463FUL, 0x0325DD28UL, 0x5E97B57FUL, + 0x4CFA9BB6UL, 0x24E5084FUL, 0x65C9E59DUL, 0xC4CD2945UL, + 0x7F9184C4UL, 0xC1AADE8AUL, 0x10E5AE0BUL, 0x35B2CADDUL, + 0xEAF5E211UL, 0x8FDE8CA6UL, 0x5FC82277UL, 0x58AD1181UL, + 0x3D710A71UL, 0x0B10C32FUL, 0x94BB36D6UL, 0x71D80509UL, + } }; static void test_init_against_reference(void) { isaac_ctx_t ctx; - memset(ctx.result, 0, ISAAC_SIZE); // Zero seed + memset(ctx.result, 0, ISAAC_U32_ELEMENTS); // Zero seed isaac_init(&ctx, true); atto_eq(sizeof(ctx), sizeof(expected_initialised_ctx)); - atto_memeq(&ctx, expected_initialised_ctx, sizeof(ctx)); + atto_memeq(&ctx, &expected_initialised_ctx, sizeof(ctx)); } void test_isaac_init(void) diff --git a/tst/test_next.c b/tst/test_next.c index e805a51..9d06ab9 100644 --- a/tst/test_next.c +++ b/tst/test_next.c @@ -138,18 +138,24 @@ const static uint32_t expected_next_results[EXPECTED_NEXT_ELEMENTS] = { 0xE448E96DUL, 0xF650E4C8UL, }; -static void test_next_once(void) +static void test_next32_a_few(void) { isaac_ctx_t ctx; memset(&ctx, 0, sizeof(ctx)); // Zero seed isaac_init(&ctx, true); + uint32_t next; - const uint32_t next = isaac_next(&ctx); - + next = isaac_next32(&ctx); atto_eq(next, expected_next_results[0]); + + next = isaac_next32(&ctx); + atto_eq(next, expected_next_results[1]); + + next = isaac_next32(&ctx); + atto_eq(next, expected_next_results[2]); } -static void test_next_all(void) +static void test_next32_all(void) { uint32_t result; isaac_ctx_t ctx; @@ -157,14 +163,66 @@ static void test_next_all(void) isaac_init(&ctx, true); for (uint_fast32_t i = 0; i < EXPECTED_NEXT_ELEMENTS; i++) { - result = isaac_next(&ctx); + result = isaac_next32(&ctx); atto_eq(result, expected_next_results[i]); } - puts(""); +} + +static void test_next8_four_times(void) +{ + isaac_ctx_t ctx; + memset(&ctx, 0, sizeof(ctx)); // Zero seed + isaac_init(&ctx, true); + uint8_t next; + + next = isaac_next8(&ctx); + atto_eq(next, (expected_next_results[0] >> 0U) & 0xFFU); + next = isaac_next8(&ctx); + atto_eq(next, (expected_next_results[0] >> 8U) & 0xFFU); + next = isaac_next8(&ctx); + atto_eq(next, (expected_next_results[0] >> 16U) & 0xFFU); + next = isaac_next8(&ctx); + atto_eq(next, (expected_next_results[0] >> 24U) & 0xFFU); + + next = isaac_next8(&ctx); + atto_eq(next, (expected_next_results[1] >> 0U) & 0xFFU); + next = isaac_next8(&ctx); + atto_eq(next, (expected_next_results[1] >> 8U) & 0xFFU); + next = isaac_next8(&ctx); + atto_eq(next, (expected_next_results[1] >> 16U) & 0xFFU); + next = isaac_next8(&ctx); + atto_eq(next, (expected_next_results[1] >> 24U) & 0xFFU); + + next = isaac_next8(&ctx); + atto_eq(next, (expected_next_results[2] >> 0U) & 0xFFU); + next = isaac_next8(&ctx); + atto_eq(next, (expected_next_results[2] >> 8U) & 0xFFU); + next = isaac_next8(&ctx); + atto_eq(next, (expected_next_results[2] >> 16U) & 0xFFU); + next = isaac_next8(&ctx); + atto_eq(next, (expected_next_results[2] >> 24U) & 0xFFU); +} + +static void test_next8_all(void) +{ + uint8_t result; + isaac_ctx_t ctx; + memset(&ctx, 0, sizeof(ctx)); + isaac_init(&ctx, true); + for (uint_fast32_t i = 0; i < EXPECTED_NEXT_ELEMENTS; i++) + { + for (uint_fast8_t byte = 0; byte < 4; byte++) + { + result = isaac_next8(&ctx); + atto_eq(result, (expected_next_results[i] >> byte * 8U) & 0xFFU); + } + } } void test_isaac_next(void) { - test_next_once(); - test_next_all(); + test_next32_a_few(); + test_next32_all(); + test_next8_four_times(); + test_next8_all(); } From d70281de8bc5b320c62cffb535830e11905d560a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matjaz=CC=8C?= Date: Sun, 26 Apr 2020 22:04:53 +0200 Subject: [PATCH 06/27] Add test for no seed, add code to generate test vectors --- CMakeLists.txt | 10 ++- tst/original/generate.c | 84 +++++++++++++++++++++ tst/test_init.c | 161 ++++++++++++++++++++++++++++++++++++++-- 3 files changed, 248 insertions(+), 7 deletions(-) create mode 100644 tst/original/generate.c diff --git a/CMakeLists.txt b/CMakeLists.txt index ccf61d1..fc32a09 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -42,13 +42,19 @@ set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} \ include_directories(inc/) set(LIB_FILES src/isaac.c) include_directories(tst/ tst/atto/) -set(TEST_FILES tst/test.c tst/test_init.c tst/test_next.c tst/atto/atto.c) +set(TEST_FILES + tst/test.c + tst/test_init.c + tst/test_next.c + tst/atto/atto.c) add_library("isaac" STATIC ${LIB_FILES}) add_executable("testisaac" ${LIB_FILES} ${TEST_FILES}) include_directories(tst/original/) -add_executable("orig" tst/original/randport.c) +add_executable("generatevectors" + tst/original/generate.c + tst/original/randport.c) # Doxygen documentation builder find_package(Doxygen) diff --git a/tst/original/generate.c b/tst/original/generate.c new file mode 100644 index 0000000..3daacbf --- /dev/null +++ b/tst/original/generate.c @@ -0,0 +1,84 @@ +/** + * @file + * + * Code used to generate the test vectors used in other + * test files of LibISAAC. It requires the original implementation of ISAAC, + * that is: + * - rand.h + * - standard.h + * - rand.c or randport.c + * + * Compile into an executable and run it. + * + * @copyright Copyright © 2020, Matjaž Guštin + * . All rights reserved. + * @license BSD 3-clause license. + */ + +#include "standard.h" +#include "rand.h" + +static void print_ctx(const randctx* const ctx) +{ + printf(".cnt = 0x%08XUL,\n", ctx->randcnt); + printf(".a = 0x%08XUL,\n", ctx->randa); + printf(".b = 0x%08XUL,\n", ctx->randb); + printf(".c = 0x%08XUL,\n", ctx->randc); + printf(".rsl = {"); + for (unsigned int i = 0; i < RANDSIZ; i++) + { + printf("0x%08XUL, ", ctx->randrsl[i]); + } + printf("\n},\n.mem = {"); + for (unsigned int i = 0; i < RANDSIZ; i++) + { + printf("0x%08XUL, ", ctx->randmem[i]); + } + puts("\n}\n\n"); +} + +static void ctx_zero_seed(void) +{ + randctx ctx; + for (unsigned long int i = 0; i < 256; i++) + { + ctx.randrsl[i] = 0; // Zero seed + } + randinit(&ctx, 1); // Init ISAAC with zero seed + puts("Context with zero-initialised seed:"); + print_ctx(&ctx); +} + +static void ctx_no_init(void) +{ + randctx ctx; + randinit(&ctx, 0); // Init ISAAC without a seed + puts("Context with no seed:"); + print_ctx(&ctx); +} + +static void next_values(void) +{ + randctx ctx; + unsigned long int i; + unsigned long int next; + for (i = 0; i < 256; i++) + { + ctx.randrsl[i] = 0; // Zero seed + } + randinit(&ctx, 1); // Init ISAAC with zero seed + puts("Running next() 512 times"); + for (i = 0; i < 512; i++) + { + next = rand(&ctx); + printf("0x%08lXUL, ", next); + } +} + +int main(void) +{ + ctx_zero_seed(); + ctx_no_init(); + next_values(); + return 0; +} diff --git a/tst/test_init.c b/tst/test_init.c index 1279142..2d5140f 100644 --- a/tst/test_init.c +++ b/tst/test_init.c @@ -10,7 +10,7 @@ #include "test.h" -const static isaac_ctx_t expected_initialised_ctx = { +const static isaac_ctx_t zero_initialised_ctx = { .next32_index = ISAAC_U32_ELEMENTS - 1, .next8_index = 0, .a = 0x44D22B48UL, @@ -150,18 +150,169 @@ const static isaac_ctx_t expected_initialised_ctx = { } }; -static void test_init_against_reference(void) +const static isaac_ctx_t no_seed_ctx = { + .next32_index = ISAAC_U32_ELEMENTS - 1, + .next8_index = 0, + .a = 0x3923441EUL, + .b = 0x71D71FD2UL, + .c = 0x00000001UL, + .result = { + 0x9FC09148UL, 0xF989E740UL, 0x0898E634UL, 0x6E4D10EFUL, + 0xFEE2D7E8UL, 0xECD81B8FUL, 0xCF5E308AUL, 0x1719F4FDUL, + 0xAB8FAE88UL, 0xAEC1B3CFUL, 0x61CC2C63UL, 0xB656F150UL, + 0xCB74716DUL, 0x90BB5ED4UL, 0xA72976AFUL, 0x5CAD2ED8UL, + 0x78A26D4FUL, 0x8C482122UL, 0x91E4717CUL, 0x0CF4970DUL, + 0x39E42A43UL, 0x02FCDCA2UL, 0x5256916FUL, 0x91381311UL, + 0x41F93691UL, 0xF0EF1488UL, 0x57891E14UL, 0x48E0C613UL, + 0x79BA733AUL, 0x9B53E178UL, 0xDDB946FBUL, 0x1F05D840UL, + 0x73579EA5UL, 0xEBF5E15EUL, 0x2AAD2C2DUL, 0x251A36BBUL, + 0x0F981EBEUL, 0xE4CEDF21UL, 0x3EE87A9EUL, 0xD80D0FABUL, + 0x1FB3199EUL, 0x4EA70E5CUL, 0x9E4B911AUL, 0x4DA6F464UL, + 0xF8B2D53EUL, 0x7BB70B9AUL, 0x29E7F406UL, 0xB1FC7819UL, + 0x5D014587UL, 0xE4DE0148UL, 0xFEB7C855UL, 0xB2FA0FFCUL, + 0x418D4BC3UL, 0x62E70953UL, 0x624B9C48UL, 0xC61BFE6AUL, + 0x026C202BUL, 0x61328608UL, 0x797D8B28UL, 0xBE162273UL, + 0x31321C2CUL, 0x77A77AB8UL, 0x55B5C622UL, 0xA75F163EUL, + 0x67743A32UL, 0x85A4A491UL, 0x4FE51302UL, 0x9A9B17ECUL, + 0x1CBCF183UL, 0x34CC217AUL, 0x7070E101UL, 0x0A278BC0UL, + 0x8116D3F9UL, 0x6EB2973AUL, 0x3F73DE7EUL, 0x71BF9B92UL, + 0x93CB9F61UL, 0x7A39691AUL, 0x0485BD0BUL, 0xE268E87BUL, + 0xEE736DC5UL, 0xECDA90E5UL, 0x03DC7F8CUL, 0xA0CFA011UL, + 0x65D958E9UL, 0x0E847B4BUL, 0xB996C3CAUL, 0x69A6BF3DUL, + 0x4A205172UL, 0x42D22CEEUL, 0xF238E206UL, 0x0AA0C112UL, + 0xB24CD963UL, 0xA9F19EBAUL, 0xFB98D55DUL, 0x509E3635UL, + 0xB837CE71UL, 0x33FCE310UL, 0xA9B4EC9BUL, 0xA41408CEUL, + 0xAC150FF7UL, 0xD5F89FA6UL, 0xC0CD0E93UL, 0x90176730UL, + 0x98EC0CB2UL, 0xF6509C35UL, 0x485C8EFBUL, 0xFB5D456DUL, + 0x695488D6UL, 0xB02827E2UL, 0x163CEA45UL, 0xFCDD8FCEUL, + 0xC6CDE1C5UL, 0xC4932E36UL, 0x7F0A3358UL, 0x17AB9860UL, + 0x8E837DC6UL, 0x9A29EA38UL, 0x0D20E049UL, 0x1B332947UL, + 0x9E8C0D05UL, 0x398E45E5UL, 0x6AA570C2UL, 0x5FAA6738UL, + 0x39BA563EUL, 0xA71FB21AUL, 0xE801B9ADUL, 0xA16AC508UL, + 0x79838C09UL, 0x3474D6DEUL, 0xC3F2B2FFUL, 0x07ED8F34UL, + 0x32DA22F0UL, 0xFD831042UL, 0x1584BD04UL, 0x2CD293A9UL, + 0x87DBF4E5UL, 0x4B269588UL, 0x697452B7UL, 0xA376B729UL, + 0x756D762DUL, 0xD1654BAAUL, 0xFD5B3AECUL, 0xF627EC4EUL, + 0xE458CB02UL, 0xFD781E36UL, 0x6FD5690EUL, 0x5C4ED5E6UL, + 0x6F4120C6UL, 0xAF19EDFEUL, 0x40B4E8E6UL, 0xA4D7A224UL, + 0xE7104EF7UL, 0xAAEF5AF3UL, 0x4B7B246AUL, 0xDF8CA205UL, + 0xD5E81B49UL, 0xDFFC0229UL, 0x7494BD80UL, 0x6476151AUL, + 0x38BED333UL, 0xC7E2DD29UL, 0x4ACC13BBUL, 0x9752832EUL, + 0x58F74DB6UL, 0xA89E3B40UL, 0x5B120E3BUL, 0x693B4D7EUL, + 0x48A9330EUL, 0xE1BD4C66UL, 0xB2D27583UL, 0x9F3C34A0UL, + 0xD030C942UL, 0x091265A7UL, 0x90BF5097UL, 0x4518E821UL, + 0x8256F385UL, 0xAD99916DUL, 0x9FCAA17BUL, 0xC99DC8D3UL, + 0xD3788783UL, 0x200CFD47UL, 0xA50C05ACUL, 0x66740461UL, + 0x48A9C0E8UL, 0x573FCAAEUL, 0xE8FAD070UL, 0x7F7F906FUL, + 0x22E0F93CUL, 0xB4499FA2UL, 0x65EEC6D2UL, 0xB3F7EAF3UL, + 0x65788F47UL, 0x1567656AUL, 0x2584CD66UL, 0xA56F2AA4UL, + 0x49653A25UL, 0xA21D52B4UL, 0xCC05180CUL, 0xC7827819UL, + 0x64A35A26UL, 0xED0FB8F5UL, 0x132CC5FBUL, 0x77A1D4AEUL, + 0xA94B48EEUL, 0x9126BD16UL, 0x5541717CUL, 0xC492C7D3UL, + 0xC5D0DE7EUL, 0x62D07F04UL, 0xCAAD4883UL, 0xD68C4E70UL, + 0x6472F663UL, 0x834773A4UL, 0x3A5E9B4FUL, 0xB00F8A99UL, + 0xF4915642UL, 0x1ADD11ECUL, 0x3419BF00UL, 0x4F075A5CUL, + 0x3F06822BUL, 0x70EE28F7UL, 0x556E9B66UL, 0xD7F84AD0UL, + 0x616A5931UL, 0x756D2200UL, 0x408641EDUL, 0x76466653UL, + 0xD87A6368UL, 0xDB2E4911UL, 0xC9C2B65EUL, 0xAECB15CCUL, + 0x902EB5F8UL, 0x68392DDEUL, 0xF571A73DUL, 0x5344CB78UL, + 0x0ED850C9UL, 0x6EF0A079UL, 0xEF585AAEUL, 0xECB934D7UL, + 0xBC12C17FUL, 0x00D6B993UL, 0x0EEFF940UL, 0x500F972EUL, + 0xCA20E846UL, 0xDB452848UL, 0xD82E9489UL, 0x8D048509UL, + 0xFA3CE5BDUL, 0xD83B237FUL, 0x3CB879CAUL, 0x21DC1EA9UL, + 0xC36129FAUL, 0xD4788559UL, 0xB54ADAE7UL, 0x71D71FD2UL, + }, + .mem = { + 0xC372C203UL, 0xECCD9922UL, 0x6F30EF44UL, 0xAF33DFF9UL, + 0x1E1B61ECUL, 0x0D86FB19UL, 0xDA03D964UL, 0x782D3C57UL, + 0x3407B931UL, 0xC4BAA225UL, 0x72549105UL, 0x847FD17AUL, + 0x076C1D0CUL, 0x6B010A26UL, 0x6D77745EUL, 0xED57AF4CUL, + 0xA6F9F250UL, 0x188F8828UL, 0x0CF9FC47UL, 0xCD3D7664UL, + 0x1E2C6372UL, 0x061830DBUL, 0x53B2FDB8UL, 0x4AB3E0CEUL, + 0x3EF35D41UL, 0xD2481849UL, 0xC52D7312UL, 0xD8041E56UL, + 0x7EECBF78UL, 0x9EEE08B1UL, 0x9B3C8574UL, 0xF2AE1D65UL, + 0xE436B3E5UL, 0x9CEE4FCDUL, 0xC66D9030UL, 0xA10CE247UL, + 0xFD3C313DUL, 0x2D7C9FEFUL, 0x054C5266UL, 0x77918017UL, + 0x399767B2UL, 0xE97F31E1UL, 0x0A25EF16UL, 0xD83E6180UL, + 0xDEFC1853UL, 0x5DA6954AUL, 0x86292F0DUL, 0x9A8B6CDAUL, + 0x9843A8A0UL, 0xC8843D82UL, 0x079A993CUL, 0x266A5312UL, + 0x50FD4A23UL, 0xBA14E180UL, 0xD0301AB0UL, 0x9A53059AUL, + 0x56253FB8UL, 0xB3F7655EUL, 0xA2E6465BUL, 0x116CD98EUL, + 0xACF9E18EUL, 0xA8EDE934UL, 0x6C8B7242UL, 0x7B5EC05DUL, + 0xF9C89CA5UL, 0x00DA0325UL, 0xC8388FECUL, 0xFBA7A112UL, + 0x5130D868UL, 0xD2C23C28UL, 0x0B3C1C03UL, 0xC9E96B8AUL, + 0xECFCC4FFUL, 0x25E20594UL, 0x49D95173UL, 0xCA1F5727UL, + 0x0C19582EUL, 0x75EF1A7BUL, 0x606CAD17UL, 0x4776D2D9UL, + 0xE9630322UL, 0xB7BAA0ACUL, 0x03B4869CUL, 0xFB6AABF5UL, + 0x4CD91FB1UL, 0xC6EB55D2UL, 0xEFF70AE2UL, 0x806C07E0UL, + 0xFB506AE0UL, 0x9503D4CAUL, 0x7F22FA25UL, 0x67A27F78UL, + 0x76D56B96UL, 0x402D3191UL, 0xCD1F0267UL, 0x78B4913BUL, + 0x975D23A2UL, 0x0BA7C5ADUL, 0xADB16579UL, 0x430F9FE5UL, + 0xEA0F55AEUL, 0xA4E30828UL, 0x73818E23UL, 0x0921CB37UL, + 0x04A619EBUL, 0xD192BDC2UL, 0xE9FB8FDDUL, 0x996D07CCUL, + 0x6F77A27EUL, 0x5881183BUL, 0x16B4B0D7UL, 0x172D2FFAUL, + 0xF805F811UL, 0xB892D079UL, 0x7455BC99UL, 0x79757EFEUL, + 0x24E92C48UL, 0x16AF555AUL, 0x0F8012E6UL, 0x8E12FED6UL, + 0x8AA6FC6BUL, 0x093E87FCUL, 0xB1F3F7B9UL, 0x28B1BC3CUL, + 0x68E7D212UL, 0xBF0601A2UL, 0x5074D661UL, 0x9BF31996UL, + 0x98B943A1UL, 0xD68BB777UL, 0x3CAABD0DUL, 0x640A7865UL, + 0x267E947FUL, 0x219D4627UL, 0x2A7ED2BEUL, 0x4A1566DFUL, + 0x909D9F1FUL, 0x08BC3013UL, 0x419493E1UL, 0x8057D0FFUL, + 0xAED234D6UL, 0x701ECFE1UL, 0xD3DE5093UL, 0xF528D3EFUL, + 0xA2C0839EUL, 0x73E1268BUL, 0x184D1CB5UL, 0xBCA40018UL, + 0x1C6F2470UL, 0x411021C5UL, 0x470010A5UL, 0x2E70A808UL, + 0xDED43F94UL, 0xD2B88E84UL, 0xA1A402C2UL, 0x186A4763UL, + 0xABC09A42UL, 0x5D108F08UL, 0xF6EF7C02UL, 0xDAFD9D4FUL, + 0x25830052UL, 0x376C9A77UL, 0x3AF7CDA0UL, 0x1A464D20UL, + 0xCECC55BBUL, 0xDB42D2F4UL, 0xC0A7591BUL, 0x223D49E9UL, + 0xCFC9EBC4UL, 0x3C4B6CB9UL, 0x89D8FD16UL, 0x8B10782DUL, + 0x76349749UL, 0x5C99F0D4UL, 0xE337681AUL, 0xF6D693FAUL, + 0x621542E1UL, 0x85F2A4DBUL, 0x240053F2UL, 0x459478F3UL, + 0xCA6DC332UL, 0xE4136659UL, 0x90B2C780UL, 0x08E52078UL, + 0xF93B1362UL, 0x81A93EB2UL, 0x7BB2ECD5UL, 0x68AF6FE0UL, + 0x89E3F308UL, 0x4ABDEE7AUL, 0x1A25EDEDUL, 0xB8FFD191UL, + 0x6A6C42F7UL, 0x4F45DCCBUL, 0x7AF2F606UL, 0x8D5A74C9UL, + 0x717EC71AUL, 0x6D9494B5UL, 0xC1A47207UL, 0xCA49B53FUL, + 0xED4D5C9BUL, 0x34A2F6BCUL, 0x0053055AUL, 0xD143A962UL, + 0x9FBD6B13UL, 0x0758F93CUL, 0x36A0CA9EUL, 0x7A354260UL, + 0xD0530604UL, 0xBEAB7F62UL, 0xE0D772A4UL, 0xF2703B87UL, + 0x9E284DC6UL, 0x36FE8CFAUL, 0xD50FCE1DUL, 0xDFBB03B9UL, + 0x646C5FC8UL, 0x110121AAUL, 0x3C680320UL, 0x3B23E8D5UL, + 0x872654AEUL, 0xC788D396UL, 0x9C942EF4UL, 0xFB964A94UL, + 0x3CF3BF40UL, 0xE058EE68UL, 0xDADFAB68UL, 0x38A62019UL, + 0x87FF0BD1UL, 0xD49F27C9UL, 0xAF17CB57UL, 0x0693D16FUL, + 0x609FC1E7UL, 0xC79BA0CEUL, 0x567B7E00UL, 0x7F148C47UL, + 0x2CFADE44UL, 0xBD5521DFUL, 0x4D6E4314UL, 0x1C722B5BUL, + 0x9A27F479UL, 0xEDD85679UL, 0x135E1125UL, 0xCFE6C353UL, + 0x0A81E053UL, 0x90133DE1UL, 0x10EBBCBFUL, 0x3F405E94UL, + 0xB45AA902UL, 0x40F01CE3UL, 0x86A44128UL, 0x9DBDC9E6UL, + 0x4B0124A1UL, 0x79AC34C8UL, 0x7A8E5D89UL, 0xDB6AE404UL, + } +}; + +static void test_init_zero_seed(void) { isaac_ctx_t ctx; memset(ctx.result, 0, ISAAC_U32_ELEMENTS); // Zero seed isaac_init(&ctx, true); - atto_eq(sizeof(ctx), sizeof(expected_initialised_ctx)); - atto_memeq(&ctx, &expected_initialised_ctx, sizeof(ctx)); + atto_eq(sizeof(ctx), sizeof(zero_initialised_ctx)); + atto_memeq(&ctx, &zero_initialised_ctx, sizeof(ctx)); +} + +static void test_init_no_seed(void) +{ + isaac_ctx_t ctx; + + isaac_init(&ctx, false); + + atto_eq(sizeof(ctx), sizeof(no_seed_ctx)); + atto_memeq(&ctx, &no_seed_ctx, sizeof(ctx)); } void test_isaac_init(void) { - test_init_against_reference(); + test_init_zero_seed(); + test_init_no_seed(); } From ff136332ef5d3b336df8934c1ffeb8b32ec552cc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matjaz=CC=8C?= Date: Sun, 26 Apr 2020 22:29:34 +0200 Subject: [PATCH 07/27] Remove the default seed: either use given seed or zero-seed The constant seed provided by the original implementation is not needed. Generally either a zero seed is used for non cryptographic use-cases or for dummy CPRNG values where the real seed is not known yet during development, or an actual secure seed should be used instead. --- inc/isaac.h | 30 ++++++--- src/isaac.c | 107 ++++++++++++++++---------------- tst/test_init.c | 158 ++---------------------------------------------- tst/test_next.c | 12 ++-- 4 files changed, 84 insertions(+), 223 deletions(-) diff --git a/inc/isaac.h b/inc/isaac.h index 3b1ace3..88d8c64 100644 --- a/inc/isaac.h +++ b/inc/isaac.h @@ -37,9 +37,10 @@ extern "C" #define LIBISAAC_VERSION "1.0.0" #include -#include +#include #define ISAAC_U32_ELEMENTS 256U +#define ISAAC_SEED_MAX_BYTES (ISAAC_U32_ELEMENTS * sizeof(uint32_t)) /** * Context of the ISAAC CPRNG. @@ -58,17 +59,30 @@ typedef struct } isaac_ctx_t; /** - * Initialises the ISAAC CPRNG. - * - * Uses the `rsl` field as initial seed if the flag is TRUE. Otherwise ??? + * Initialises the ISAAC CPRNG with a seed. * * Maps to `void randinit(randctx *r, word flag)` from the original * implementation. * - * @param ctx - * @param flag + * @warning + * Failing to provide a seed (NULL or long 0 bytes), will make the whole CSPRNG + * insecure as a zero-seed is used instead. This is only useful if a + * **non-cryptographic** PRNG is required. + * + * @warning + * Providing a seed with low entropy will result in the whole CSPRNG to be + * weak. + * + * @param ctx the ISAAC state to be initialised. + * @param seed pointer to the seed to use, which is copied into the context. + * - If NULL, then a zero seed is used instead (**insecure!**) + * @param seed_len amount of bytes in the seed, max #ISAAC_SEED_MAX_BYTES. + * - If 0, then a zero seed is used instead (**insecure!**) + * - If > #ISAAC_SEED_MAX_BYTES, then only #ISAAC_SEED_MAX_BYTES will be used + * - If < #ISAAC_SEED_MAX_BYTES, then the provided bytes will be used and the + * rest will be zero-padded. */ -void isaac_init(isaac_ctx_t* ctx, bool flag); +void isaac_init(isaac_ctx_t* ctx, const uint8_t* seed, uint16_t seed_len); /** * Provides the next pseudo-random 32-bit integer. @@ -85,7 +99,7 @@ void isaac_init(isaac_ctx_t* ctx, bool flag); * then isaac_next32() will produce the same byte twice, which is **unsecure** * and predictable. * - * @param ctx + * @param ctx the ISAAC state, already initialised. * @return a pseudo-random 32-bit integer. */ uint32_t isaac_next32(isaac_ctx_t* ctx); diff --git a/src/isaac.c b/src/isaac.c index 52ebd0c..4ab8711 100644 --- a/src/isaac.c +++ b/src/isaac.c @@ -44,7 +44,9 @@ static void isaac_shuffle(isaac_ctx_t* const ctx); -void isaac_init(isaac_ctx_t* const ctx, const bool flag) +void isaac_init(isaac_ctx_t* const ctx, + const uint8_t* const seed, + const uint16_t seed_len) { uint32_t a, b, c, d, e, f, g, h; unsigned int i; /* Fastest integer type */ @@ -57,67 +59,64 @@ void isaac_init(isaac_ctx_t* const ctx, const bool flag) { ISAAC_MIX(a, b, c, d, e, f, g, h); } - /* If (flag==TRUE), then use the contents of result[] to initialize mm[]. */ - if (flag) + if (seed != NULL) { - /* Initialise using the contents of result[] as the seed. */ - for (i = 0; i < ISAAC_U32_ELEMENTS; i += 8) + /* Copy seed into result[] with zero-padding. */ + if (seed_len >= ISAAC_SEED_MAX_BYTES) { - a += ctx->result[i]; - b += ctx->result[i + 1]; - c += ctx->result[i + 2]; - d += ctx->result[i + 3]; - e += ctx->result[i + 4]; - f += ctx->result[i + 5]; - g += ctx->result[i + 6]; - h += ctx->result[i + 7]; - ISAAC_MIX(a, b, c, d, e, f, g, h); - ctx->mem[i] = a; - ctx->mem[i + 1] = b; - ctx->mem[i + 2] = c; - ctx->mem[i + 3] = d; - ctx->mem[i + 4] = e; - ctx->mem[i + 5] = f; - ctx->mem[i + 6] = g; - ctx->mem[i + 7] = h; + memcpy(ctx->result, seed, ISAAC_SEED_MAX_BYTES); } - /* Do a second pass to make all of the seed affect all of ctx->mem. */ - for (i = 0; i < ISAAC_U32_ELEMENTS; i += 8) + else { - a += ctx->mem[i]; - b += ctx->mem[i + 1]; - c += ctx->mem[i + 2]; - d += ctx->mem[i + 3]; - e += ctx->mem[i + 4]; - f += ctx->mem[i + 5]; - g += ctx->mem[i + 6]; - h += ctx->mem[i + 7]; - ISAAC_MIX(a, b, c, d, e, f, g, h); - ctx->mem[i] = a; - ctx->mem[i + 1] = b; - ctx->mem[i + 2] = c; - ctx->mem[i + 3] = d; - ctx->mem[i + 4] = e; - ctx->mem[i + 5] = f; - ctx->mem[i + 6] = g; - ctx->mem[i + 7] = h; + memcpy(ctx->result, seed, seed_len); + memset(&ctx->result[seed_len], 0, ISAAC_SEED_MAX_BYTES - seed_len); } } else { - for (i = 0; i < ISAAC_U32_ELEMENTS; i += 8) - { - /* Fill in ctx->mem[] with messy stuff. */ - ISAAC_MIX(a, b, c, d, e, f, g, h); - ctx->mem[i] = a; - ctx->mem[i + 1] = b; - ctx->mem[i + 2] = c; - ctx->mem[i + 3] = d; - ctx->mem[i + 4] = e; - ctx->mem[i + 5] = f; - ctx->mem[i + 6] = g; - ctx->mem[i + 7] = h; - } + memset(&ctx->result[seed_len], 0, ISAAC_SEED_MAX_BYTES); + } + /* Initialise using the contents of result[] as the seed. */ + for (i = 0; i < ISAAC_U32_ELEMENTS; i += 8) + { + a += ctx->result[i]; + b += ctx->result[i + 1]; + c += ctx->result[i + 2]; + d += ctx->result[i + 3]; + e += ctx->result[i + 4]; + f += ctx->result[i + 5]; + g += ctx->result[i + 6]; + h += ctx->result[i + 7]; + ISAAC_MIX(a, b, c, d, e, f, g, h); + ctx->mem[i] = a; + ctx->mem[i + 1] = b; + ctx->mem[i + 2] = c; + ctx->mem[i + 3] = d; + ctx->mem[i + 4] = e; + ctx->mem[i + 5] = f; + ctx->mem[i + 6] = g; + ctx->mem[i + 7] = h; + } + /* Do a second pass to make all of the seed affect all of ctx->mem. */ + for (i = 0; i < ISAAC_U32_ELEMENTS; i += 8) + { + a += ctx->mem[i]; + b += ctx->mem[i + 1]; + c += ctx->mem[i + 2]; + d += ctx->mem[i + 3]; + e += ctx->mem[i + 4]; + f += ctx->mem[i + 5]; + g += ctx->mem[i + 6]; + h += ctx->mem[i + 7]; + ISAAC_MIX(a, b, c, d, e, f, g, h); + ctx->mem[i] = a; + ctx->mem[i + 1] = b; + ctx->mem[i + 2] = c; + ctx->mem[i + 3] = d; + ctx->mem[i + 4] = e; + ctx->mem[i + 5] = f; + ctx->mem[i + 6] = g; + ctx->mem[i + 7] = h; } /* Fill in the first set of results. */ isaac_shuffle(ctx); diff --git a/tst/test_init.c b/tst/test_init.c index 2d5140f..bed69ba 100644 --- a/tst/test_init.c +++ b/tst/test_init.c @@ -150,169 +150,21 @@ const static isaac_ctx_t zero_initialised_ctx = { } }; -const static isaac_ctx_t no_seed_ctx = { - .next32_index = ISAAC_U32_ELEMENTS - 1, - .next8_index = 0, - .a = 0x3923441EUL, - .b = 0x71D71FD2UL, - .c = 0x00000001UL, - .result = { - 0x9FC09148UL, 0xF989E740UL, 0x0898E634UL, 0x6E4D10EFUL, - 0xFEE2D7E8UL, 0xECD81B8FUL, 0xCF5E308AUL, 0x1719F4FDUL, - 0xAB8FAE88UL, 0xAEC1B3CFUL, 0x61CC2C63UL, 0xB656F150UL, - 0xCB74716DUL, 0x90BB5ED4UL, 0xA72976AFUL, 0x5CAD2ED8UL, - 0x78A26D4FUL, 0x8C482122UL, 0x91E4717CUL, 0x0CF4970DUL, - 0x39E42A43UL, 0x02FCDCA2UL, 0x5256916FUL, 0x91381311UL, - 0x41F93691UL, 0xF0EF1488UL, 0x57891E14UL, 0x48E0C613UL, - 0x79BA733AUL, 0x9B53E178UL, 0xDDB946FBUL, 0x1F05D840UL, - 0x73579EA5UL, 0xEBF5E15EUL, 0x2AAD2C2DUL, 0x251A36BBUL, - 0x0F981EBEUL, 0xE4CEDF21UL, 0x3EE87A9EUL, 0xD80D0FABUL, - 0x1FB3199EUL, 0x4EA70E5CUL, 0x9E4B911AUL, 0x4DA6F464UL, - 0xF8B2D53EUL, 0x7BB70B9AUL, 0x29E7F406UL, 0xB1FC7819UL, - 0x5D014587UL, 0xE4DE0148UL, 0xFEB7C855UL, 0xB2FA0FFCUL, - 0x418D4BC3UL, 0x62E70953UL, 0x624B9C48UL, 0xC61BFE6AUL, - 0x026C202BUL, 0x61328608UL, 0x797D8B28UL, 0xBE162273UL, - 0x31321C2CUL, 0x77A77AB8UL, 0x55B5C622UL, 0xA75F163EUL, - 0x67743A32UL, 0x85A4A491UL, 0x4FE51302UL, 0x9A9B17ECUL, - 0x1CBCF183UL, 0x34CC217AUL, 0x7070E101UL, 0x0A278BC0UL, - 0x8116D3F9UL, 0x6EB2973AUL, 0x3F73DE7EUL, 0x71BF9B92UL, - 0x93CB9F61UL, 0x7A39691AUL, 0x0485BD0BUL, 0xE268E87BUL, - 0xEE736DC5UL, 0xECDA90E5UL, 0x03DC7F8CUL, 0xA0CFA011UL, - 0x65D958E9UL, 0x0E847B4BUL, 0xB996C3CAUL, 0x69A6BF3DUL, - 0x4A205172UL, 0x42D22CEEUL, 0xF238E206UL, 0x0AA0C112UL, - 0xB24CD963UL, 0xA9F19EBAUL, 0xFB98D55DUL, 0x509E3635UL, - 0xB837CE71UL, 0x33FCE310UL, 0xA9B4EC9BUL, 0xA41408CEUL, - 0xAC150FF7UL, 0xD5F89FA6UL, 0xC0CD0E93UL, 0x90176730UL, - 0x98EC0CB2UL, 0xF6509C35UL, 0x485C8EFBUL, 0xFB5D456DUL, - 0x695488D6UL, 0xB02827E2UL, 0x163CEA45UL, 0xFCDD8FCEUL, - 0xC6CDE1C5UL, 0xC4932E36UL, 0x7F0A3358UL, 0x17AB9860UL, - 0x8E837DC6UL, 0x9A29EA38UL, 0x0D20E049UL, 0x1B332947UL, - 0x9E8C0D05UL, 0x398E45E5UL, 0x6AA570C2UL, 0x5FAA6738UL, - 0x39BA563EUL, 0xA71FB21AUL, 0xE801B9ADUL, 0xA16AC508UL, - 0x79838C09UL, 0x3474D6DEUL, 0xC3F2B2FFUL, 0x07ED8F34UL, - 0x32DA22F0UL, 0xFD831042UL, 0x1584BD04UL, 0x2CD293A9UL, - 0x87DBF4E5UL, 0x4B269588UL, 0x697452B7UL, 0xA376B729UL, - 0x756D762DUL, 0xD1654BAAUL, 0xFD5B3AECUL, 0xF627EC4EUL, - 0xE458CB02UL, 0xFD781E36UL, 0x6FD5690EUL, 0x5C4ED5E6UL, - 0x6F4120C6UL, 0xAF19EDFEUL, 0x40B4E8E6UL, 0xA4D7A224UL, - 0xE7104EF7UL, 0xAAEF5AF3UL, 0x4B7B246AUL, 0xDF8CA205UL, - 0xD5E81B49UL, 0xDFFC0229UL, 0x7494BD80UL, 0x6476151AUL, - 0x38BED333UL, 0xC7E2DD29UL, 0x4ACC13BBUL, 0x9752832EUL, - 0x58F74DB6UL, 0xA89E3B40UL, 0x5B120E3BUL, 0x693B4D7EUL, - 0x48A9330EUL, 0xE1BD4C66UL, 0xB2D27583UL, 0x9F3C34A0UL, - 0xD030C942UL, 0x091265A7UL, 0x90BF5097UL, 0x4518E821UL, - 0x8256F385UL, 0xAD99916DUL, 0x9FCAA17BUL, 0xC99DC8D3UL, - 0xD3788783UL, 0x200CFD47UL, 0xA50C05ACUL, 0x66740461UL, - 0x48A9C0E8UL, 0x573FCAAEUL, 0xE8FAD070UL, 0x7F7F906FUL, - 0x22E0F93CUL, 0xB4499FA2UL, 0x65EEC6D2UL, 0xB3F7EAF3UL, - 0x65788F47UL, 0x1567656AUL, 0x2584CD66UL, 0xA56F2AA4UL, - 0x49653A25UL, 0xA21D52B4UL, 0xCC05180CUL, 0xC7827819UL, - 0x64A35A26UL, 0xED0FB8F5UL, 0x132CC5FBUL, 0x77A1D4AEUL, - 0xA94B48EEUL, 0x9126BD16UL, 0x5541717CUL, 0xC492C7D3UL, - 0xC5D0DE7EUL, 0x62D07F04UL, 0xCAAD4883UL, 0xD68C4E70UL, - 0x6472F663UL, 0x834773A4UL, 0x3A5E9B4FUL, 0xB00F8A99UL, - 0xF4915642UL, 0x1ADD11ECUL, 0x3419BF00UL, 0x4F075A5CUL, - 0x3F06822BUL, 0x70EE28F7UL, 0x556E9B66UL, 0xD7F84AD0UL, - 0x616A5931UL, 0x756D2200UL, 0x408641EDUL, 0x76466653UL, - 0xD87A6368UL, 0xDB2E4911UL, 0xC9C2B65EUL, 0xAECB15CCUL, - 0x902EB5F8UL, 0x68392DDEUL, 0xF571A73DUL, 0x5344CB78UL, - 0x0ED850C9UL, 0x6EF0A079UL, 0xEF585AAEUL, 0xECB934D7UL, - 0xBC12C17FUL, 0x00D6B993UL, 0x0EEFF940UL, 0x500F972EUL, - 0xCA20E846UL, 0xDB452848UL, 0xD82E9489UL, 0x8D048509UL, - 0xFA3CE5BDUL, 0xD83B237FUL, 0x3CB879CAUL, 0x21DC1EA9UL, - 0xC36129FAUL, 0xD4788559UL, 0xB54ADAE7UL, 0x71D71FD2UL, - }, - .mem = { - 0xC372C203UL, 0xECCD9922UL, 0x6F30EF44UL, 0xAF33DFF9UL, - 0x1E1B61ECUL, 0x0D86FB19UL, 0xDA03D964UL, 0x782D3C57UL, - 0x3407B931UL, 0xC4BAA225UL, 0x72549105UL, 0x847FD17AUL, - 0x076C1D0CUL, 0x6B010A26UL, 0x6D77745EUL, 0xED57AF4CUL, - 0xA6F9F250UL, 0x188F8828UL, 0x0CF9FC47UL, 0xCD3D7664UL, - 0x1E2C6372UL, 0x061830DBUL, 0x53B2FDB8UL, 0x4AB3E0CEUL, - 0x3EF35D41UL, 0xD2481849UL, 0xC52D7312UL, 0xD8041E56UL, - 0x7EECBF78UL, 0x9EEE08B1UL, 0x9B3C8574UL, 0xF2AE1D65UL, - 0xE436B3E5UL, 0x9CEE4FCDUL, 0xC66D9030UL, 0xA10CE247UL, - 0xFD3C313DUL, 0x2D7C9FEFUL, 0x054C5266UL, 0x77918017UL, - 0x399767B2UL, 0xE97F31E1UL, 0x0A25EF16UL, 0xD83E6180UL, - 0xDEFC1853UL, 0x5DA6954AUL, 0x86292F0DUL, 0x9A8B6CDAUL, - 0x9843A8A0UL, 0xC8843D82UL, 0x079A993CUL, 0x266A5312UL, - 0x50FD4A23UL, 0xBA14E180UL, 0xD0301AB0UL, 0x9A53059AUL, - 0x56253FB8UL, 0xB3F7655EUL, 0xA2E6465BUL, 0x116CD98EUL, - 0xACF9E18EUL, 0xA8EDE934UL, 0x6C8B7242UL, 0x7B5EC05DUL, - 0xF9C89CA5UL, 0x00DA0325UL, 0xC8388FECUL, 0xFBA7A112UL, - 0x5130D868UL, 0xD2C23C28UL, 0x0B3C1C03UL, 0xC9E96B8AUL, - 0xECFCC4FFUL, 0x25E20594UL, 0x49D95173UL, 0xCA1F5727UL, - 0x0C19582EUL, 0x75EF1A7BUL, 0x606CAD17UL, 0x4776D2D9UL, - 0xE9630322UL, 0xB7BAA0ACUL, 0x03B4869CUL, 0xFB6AABF5UL, - 0x4CD91FB1UL, 0xC6EB55D2UL, 0xEFF70AE2UL, 0x806C07E0UL, - 0xFB506AE0UL, 0x9503D4CAUL, 0x7F22FA25UL, 0x67A27F78UL, - 0x76D56B96UL, 0x402D3191UL, 0xCD1F0267UL, 0x78B4913BUL, - 0x975D23A2UL, 0x0BA7C5ADUL, 0xADB16579UL, 0x430F9FE5UL, - 0xEA0F55AEUL, 0xA4E30828UL, 0x73818E23UL, 0x0921CB37UL, - 0x04A619EBUL, 0xD192BDC2UL, 0xE9FB8FDDUL, 0x996D07CCUL, - 0x6F77A27EUL, 0x5881183BUL, 0x16B4B0D7UL, 0x172D2FFAUL, - 0xF805F811UL, 0xB892D079UL, 0x7455BC99UL, 0x79757EFEUL, - 0x24E92C48UL, 0x16AF555AUL, 0x0F8012E6UL, 0x8E12FED6UL, - 0x8AA6FC6BUL, 0x093E87FCUL, 0xB1F3F7B9UL, 0x28B1BC3CUL, - 0x68E7D212UL, 0xBF0601A2UL, 0x5074D661UL, 0x9BF31996UL, - 0x98B943A1UL, 0xD68BB777UL, 0x3CAABD0DUL, 0x640A7865UL, - 0x267E947FUL, 0x219D4627UL, 0x2A7ED2BEUL, 0x4A1566DFUL, - 0x909D9F1FUL, 0x08BC3013UL, 0x419493E1UL, 0x8057D0FFUL, - 0xAED234D6UL, 0x701ECFE1UL, 0xD3DE5093UL, 0xF528D3EFUL, - 0xA2C0839EUL, 0x73E1268BUL, 0x184D1CB5UL, 0xBCA40018UL, - 0x1C6F2470UL, 0x411021C5UL, 0x470010A5UL, 0x2E70A808UL, - 0xDED43F94UL, 0xD2B88E84UL, 0xA1A402C2UL, 0x186A4763UL, - 0xABC09A42UL, 0x5D108F08UL, 0xF6EF7C02UL, 0xDAFD9D4FUL, - 0x25830052UL, 0x376C9A77UL, 0x3AF7CDA0UL, 0x1A464D20UL, - 0xCECC55BBUL, 0xDB42D2F4UL, 0xC0A7591BUL, 0x223D49E9UL, - 0xCFC9EBC4UL, 0x3C4B6CB9UL, 0x89D8FD16UL, 0x8B10782DUL, - 0x76349749UL, 0x5C99F0D4UL, 0xE337681AUL, 0xF6D693FAUL, - 0x621542E1UL, 0x85F2A4DBUL, 0x240053F2UL, 0x459478F3UL, - 0xCA6DC332UL, 0xE4136659UL, 0x90B2C780UL, 0x08E52078UL, - 0xF93B1362UL, 0x81A93EB2UL, 0x7BB2ECD5UL, 0x68AF6FE0UL, - 0x89E3F308UL, 0x4ABDEE7AUL, 0x1A25EDEDUL, 0xB8FFD191UL, - 0x6A6C42F7UL, 0x4F45DCCBUL, 0x7AF2F606UL, 0x8D5A74C9UL, - 0x717EC71AUL, 0x6D9494B5UL, 0xC1A47207UL, 0xCA49B53FUL, - 0xED4D5C9BUL, 0x34A2F6BCUL, 0x0053055AUL, 0xD143A962UL, - 0x9FBD6B13UL, 0x0758F93CUL, 0x36A0CA9EUL, 0x7A354260UL, - 0xD0530604UL, 0xBEAB7F62UL, 0xE0D772A4UL, 0xF2703B87UL, - 0x9E284DC6UL, 0x36FE8CFAUL, 0xD50FCE1DUL, 0xDFBB03B9UL, - 0x646C5FC8UL, 0x110121AAUL, 0x3C680320UL, 0x3B23E8D5UL, - 0x872654AEUL, 0xC788D396UL, 0x9C942EF4UL, 0xFB964A94UL, - 0x3CF3BF40UL, 0xE058EE68UL, 0xDADFAB68UL, 0x38A62019UL, - 0x87FF0BD1UL, 0xD49F27C9UL, 0xAF17CB57UL, 0x0693D16FUL, - 0x609FC1E7UL, 0xC79BA0CEUL, 0x567B7E00UL, 0x7F148C47UL, - 0x2CFADE44UL, 0xBD5521DFUL, 0x4D6E4314UL, 0x1C722B5BUL, - 0x9A27F479UL, 0xEDD85679UL, 0x135E1125UL, 0xCFE6C353UL, - 0x0A81E053UL, 0x90133DE1UL, 0x10EBBCBFUL, 0x3F405E94UL, - 0xB45AA902UL, 0x40F01CE3UL, 0x86A44128UL, 0x9DBDC9E6UL, - 0x4B0124A1UL, 0x79AC34C8UL, 0x7A8E5D89UL, 0xDB6AE404UL, - } -}; - static void test_init_zero_seed(void) { isaac_ctx_t ctx; - memset(ctx.result, 0, ISAAC_U32_ELEMENTS); // Zero seed - - isaac_init(&ctx, true); + isaac_init(&ctx, NULL, 42); atto_eq(sizeof(ctx), sizeof(zero_initialised_ctx)); atto_memeq(&ctx, &zero_initialised_ctx, sizeof(ctx)); -} - -static void test_init_no_seed(void) -{ - isaac_ctx_t ctx; - - isaac_init(&ctx, false); - atto_eq(sizeof(ctx), sizeof(no_seed_ctx)); - atto_memeq(&ctx, &no_seed_ctx, sizeof(ctx)); + uint8_t dummy[3] = {1, 2, 3}; + isaac_init(&ctx, dummy, 0); + atto_eq(sizeof(ctx), sizeof(zero_initialised_ctx)); + atto_memeq(&ctx, &zero_initialised_ctx, sizeof(ctx)); } void test_isaac_init(void) { test_init_zero_seed(); - test_init_no_seed(); } diff --git a/tst/test_next.c b/tst/test_next.c index 9d06ab9..e867da6 100644 --- a/tst/test_next.c +++ b/tst/test_next.c @@ -141,8 +141,7 @@ const static uint32_t expected_next_results[EXPECTED_NEXT_ELEMENTS] = { static void test_next32_a_few(void) { isaac_ctx_t ctx; - memset(&ctx, 0, sizeof(ctx)); // Zero seed - isaac_init(&ctx, true); + isaac_init(&ctx, NULL, 0); // Zero seed uint32_t next; next = isaac_next32(&ctx); @@ -159,8 +158,7 @@ static void test_next32_all(void) { uint32_t result; isaac_ctx_t ctx; - memset(&ctx, 0, sizeof(ctx)); - isaac_init(&ctx, true); + isaac_init(&ctx, NULL, 0); // Zero seed for (uint_fast32_t i = 0; i < EXPECTED_NEXT_ELEMENTS; i++) { result = isaac_next32(&ctx); @@ -171,8 +169,7 @@ static void test_next32_all(void) static void test_next8_four_times(void) { isaac_ctx_t ctx; - memset(&ctx, 0, sizeof(ctx)); // Zero seed - isaac_init(&ctx, true); + isaac_init(&ctx, NULL, 0); // Zero seed uint8_t next; next = isaac_next8(&ctx); @@ -207,8 +204,7 @@ static void test_next8_all(void) { uint8_t result; isaac_ctx_t ctx; - memset(&ctx, 0, sizeof(ctx)); - isaac_init(&ctx, true); + isaac_init(&ctx, NULL, 0); // Zero seed for (uint_fast32_t i = 0; i < EXPECTED_NEXT_ELEMENTS; i++) { for (uint_fast8_t byte = 0; byte < 4; byte++) From b18e24a2bc51f3a38ab0aac993fc3e58732dea4a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matjaz=CC=8C?= Date: Sun, 26 Apr 2020 22:38:51 +0200 Subject: [PATCH 08/27] Add test with non-zero seed, based on output of original ISAAC --- inc/isaac.h | 4 +- src/isaac.c | 14 ++-- tst/original/generate.c | 28 +++++++- tst/test_next.c | 137 ++++++++++++++++++++++++++++++++++++++++ 4 files changed, 171 insertions(+), 12 deletions(-) diff --git a/inc/isaac.h b/inc/isaac.h index 88d8c64..8b615d8 100644 --- a/inc/isaac.h +++ b/inc/isaac.h @@ -76,13 +76,13 @@ typedef struct * @param ctx the ISAAC state to be initialised. * @param seed pointer to the seed to use, which is copied into the context. * - If NULL, then a zero seed is used instead (**insecure!**) - * @param seed_len amount of bytes in the seed, max #ISAAC_SEED_MAX_BYTES. + * @param seed_bytes amount of **bytes** in the seed, max #ISAAC_SEED_MAX_BYTES. * - If 0, then a zero seed is used instead (**insecure!**) * - If > #ISAAC_SEED_MAX_BYTES, then only #ISAAC_SEED_MAX_BYTES will be used * - If < #ISAAC_SEED_MAX_BYTES, then the provided bytes will be used and the * rest will be zero-padded. */ -void isaac_init(isaac_ctx_t* ctx, const uint8_t* seed, uint16_t seed_len); +void isaac_init(isaac_ctx_t* ctx, const void* seed, uint16_t seed_bytes); /** * Provides the next pseudo-random 32-bit integer. diff --git a/src/isaac.c b/src/isaac.c index 4ab8711..5e9d242 100644 --- a/src/isaac.c +++ b/src/isaac.c @@ -42,11 +42,11 @@ */ #define GOLDEN_RATIO 0x9e3779b9 -static void isaac_shuffle(isaac_ctx_t* const ctx); +static void isaac_shuffle(isaac_ctx_t* ctx); void isaac_init(isaac_ctx_t* const ctx, - const uint8_t* const seed, - const uint16_t seed_len) + const void* const seed, + const uint16_t seed_bytes) { uint32_t a, b, c, d, e, f, g, h; unsigned int i; /* Fastest integer type */ @@ -62,19 +62,19 @@ void isaac_init(isaac_ctx_t* const ctx, if (seed != NULL) { /* Copy seed into result[] with zero-padding. */ - if (seed_len >= ISAAC_SEED_MAX_BYTES) + if (seed_bytes >= ISAAC_SEED_MAX_BYTES) { memcpy(ctx->result, seed, ISAAC_SEED_MAX_BYTES); } else { - memcpy(ctx->result, seed, seed_len); - memset(&ctx->result[seed_len], 0, ISAAC_SEED_MAX_BYTES - seed_len); + memcpy(ctx->result, seed, seed_bytes); + memset(&ctx->result[seed_bytes], 0, ISAAC_SEED_MAX_BYTES - seed_bytes); } } else { - memset(&ctx->result[seed_len], 0, ISAAC_SEED_MAX_BYTES); + memset(&ctx->result[seed_bytes], 0, ISAAC_SEED_MAX_BYTES); } /* Initialise using the contents of result[] as the seed. */ for (i = 0; i < ISAAC_U32_ELEMENTS; i += 8) diff --git a/tst/original/generate.c b/tst/original/generate.c index 3daacbf..ed28740 100644 --- a/tst/original/generate.c +++ b/tst/original/generate.c @@ -57,7 +57,7 @@ static void ctx_no_init(void) print_ctx(&ctx); } -static void next_values(void) +static void next_values_zero_seed(void) { randctx ctx; unsigned long int i; @@ -67,7 +67,28 @@ static void next_values(void) ctx.randrsl[i] = 0; // Zero seed } randinit(&ctx, 1); // Init ISAAC with zero seed - puts("Running next() 512 times"); + puts("Running next() 512 times with zero seed"); + for (i = 0; i < 512; i++) + { + next = rand(&ctx); + printf("0x%08lXUL, ", next); + } + puts(""); +} + +static void next_values_nonzero_seed(void) +{ + randctx ctx; + unsigned long int i; + unsigned long int next; + ctx.randrsl[0] = 0x01020304UL; + ctx.randrsl[1] = 0x05060708UL; + for (i = 2; i < 256; i++) + { + ctx.randrsl[i] = 0; // Zero padding + } + randinit(&ctx, 1); // Init ISAAC with non-zero seed + puts("Running next() 512 times with non-zero seed"); for (i = 0; i < 512; i++) { next = rand(&ctx); @@ -79,6 +100,7 @@ int main(void) { ctx_zero_seed(); ctx_no_init(); - next_values(); + next_values_zero_seed(); + next_values_nonzero_seed(); return 0; } diff --git a/tst/test_next.c b/tst/test_next.c index e867da6..a64e9e1 100644 --- a/tst/test_next.c +++ b/tst/test_next.c @@ -138,6 +138,112 @@ const static uint32_t expected_next_results[EXPECTED_NEXT_ELEMENTS] = { 0xE448E96DUL, 0xF650E4C8UL, }; +const static uint32_t expected_next32_with_seed_0102030405060708[EXPECTED_NEXT_ELEMENTS] = { + 0x9EF2353DUL, 0x8CA8EFF9UL, 0x731BEC3EUL, 0xE7FBB85EUL, 0x1D3A7EF0UL, + 0x2C13F9D6UL, 0x681CC488UL, 0x09903CB7UL, 0xB8F9B3F2UL, 0x27AA5806UL, + 0xAE3D2F71UL, 0x5A4473B0UL, 0x4658E42EUL, 0x67A3AE5BUL, 0xACDF7F8BUL, + 0xB90A51C9UL, 0x2C6F8CC0UL, 0x4BC146A3UL, 0xEC48D263UL, 0x688A1F65UL, + 0xFF1B7812UL, 0xBE9B0BF7UL, 0x1D629DF7UL, 0x535620D0UL, 0xE3746550UL, + 0xB3F7A943UL, 0xB6C5C147UL, 0x69F2440BUL, 0x487B2BA5UL, 0x6526BC65UL, + 0x6F9263F1UL, 0xF228D86DUL, 0xAA6A5844UL, 0x46C92529UL, 0x9D65F839UL, + 0xCF4AB0B4UL, 0x0C83896CUL, 0x5C738844UL, 0x8CFFA3D1UL, 0x199B499FUL, + 0x8789FA0BUL, 0x0372057DUL, 0x28867679UL, 0x6F93E6A2UL, 0x97E8756FUL, + 0xAF33E361UL, 0x5DBDBC99UL, 0x1D4C15CEUL, 0x0C57A358UL, 0x50DEEE79UL, + 0x37D61DDDUL, 0x139B3957UL, 0x7EDDA8FEUL, 0xBB94809EUL, 0xF6F812B6UL, + 0x387A24C3UL, 0xBAFE202FUL, 0x82A05EBDUL, 0xB4716592UL, 0x7238CD40UL, + 0x3D94A157UL, 0x43665763UL, 0x1F78C676UL, 0x951B519BUL, 0x8DE401EBUL, + 0x34DBE945UL, 0xD6EE43FEUL, 0x6A3B158BUL, 0x65FBB769UL, 0xEB25D76AUL, + 0xB25B4D9BUL, 0x619CED1CUL, 0x48AFBF93UL, 0x3BC657A6UL, 0x3139C8B9UL, + 0x51E4749CUL, 0x8D06E82AUL, 0xBF975284UL, 0x32724D41UL, 0xC2E92DC8UL, + 0x1A9C5015UL, 0xB2D89894UL, 0x4D8B8AC0UL, 0x216259BFUL, 0xD6E083F4UL, + 0xD7828769UL, 0x91936D17UL, 0x45E1F674UL, 0xBACF0D8BUL, 0xEBD3A0CDUL, + 0xA053D933UL, 0xD5BF0E1EUL, 0xD7548B35UL, 0xFB1310B7UL, 0xB0FF866EUL, + 0x6BFFBD41UL, 0xB9E03C59UL, 0x23BBF0C7UL, 0xD454C194UL, 0x0B6813F7UL, + 0xE9DA9054UL, 0x81CF8C63UL, 0x07F0F891UL, 0xC49B0C18UL, 0xBCC92368UL, + 0xFDBFA92CUL, 0x4464348FUL, 0x2469DCA8UL, 0xEE7CF360UL, 0xB060F137UL, + 0xB55D05DDUL, 0x92274019UL, 0x7A9631D5UL, 0x736869A1UL, 0x0704D9A3UL, + 0x2DBD564EUL, 0xF75559C5UL, 0x5674B67CUL, 0x64959697UL, 0x0BDEE025UL, + 0x33D1785BUL, 0x65D37901UL, 0x8600892CUL, 0x9A2C10EBUL, 0x92FAEC4AUL, + 0x1DF63F2CUL, 0x995CC9E6UL, 0x4A4F7C49UL, 0x9BA3AAEBUL, 0x173C26A1UL, + 0xD4BE3C17UL, 0x97F9946AUL, 0x0741E3C7UL, 0xE61D8AD4UL, 0xEC045EABUL, + 0x9AFDDCB0UL, 0xDCA781D5UL, 0xA8ACB435UL, 0xFB534FFBUL, 0xFBC3AD97UL, + 0x4C4E41E9UL, 0x55F86417UL, 0x7FE91F5BUL, 0x27E36B71UL, 0x85150B8DUL, + 0x778567C7UL, 0x1CC02EA9UL, 0x66A790FAUL, 0xCBFC4E40UL, 0x1247E23EUL, + 0xDF5B3E46UL, 0xDD08DD87UL, 0x18B090E8UL, 0xC122C7FDUL, 0xA6585981UL, + 0xDBAD5BB3UL, 0xADB66F36UL, 0x7EF8FF9FUL, 0xBBD985A1UL, 0xA5B48C0DUL, + 0x1D4E12A7UL, 0x759631D6UL, 0x43353992UL, 0xCCE3E886UL, 0x5CC43D97UL, + 0x80D8282CUL, 0xBA805A97UL, 0x6ACF9F72UL, 0x20B0D2BEUL, 0xEEA93F4CUL, + 0xDFB5E952UL, 0x3813DEB0UL, 0xB70A8A17UL, 0x6AD90124UL, 0x4EF1FB26UL, + 0xC944710FUL, 0x62044F7FUL, 0x26D2D3C6UL, 0x98EE543DUL, 0x91C1D1F2UL, + 0xE6AFB21BUL, 0x15B90C52UL, 0x5ECAC126UL, 0x0A394F4BUL, 0xE505DF84UL, + 0xADD14CB1UL, 0xE3FD1403UL, 0x99732B96UL, 0xE6C8A1DCUL, 0x7B67E186UL, + 0xF85BF48EUL, 0xC8335F68UL, 0xBBE9405DUL, 0x1E3E191EUL, 0x6EE1EC8BUL, + 0x97A7571BUL, 0x9B7961AAUL, 0x6979CFFEUL, 0x98C874C6UL, 0xD0373732UL, + 0x8B3A6B15UL, 0xF09C1ABFUL, 0xFEC85689UL, 0x38600F5BUL, 0x46A6B5C8UL, + 0x7A75AE2CUL, 0xC5291F23UL, 0xF1B4E879UL, 0x4F8F7C5CUL, 0x9ACB8790UL, + 0x9AB4E178UL, 0x03F5D855UL, 0xDF2A7E55UL, 0x2405A484UL, 0xF7DCF8C2UL, + 0xE890B234UL, 0xDDD670B7UL, 0x46E89237UL, 0xC032C2F8UL, 0xB63C05D4UL, + 0x6359E564UL, 0x577DDDB9UL, 0x20861B06UL, 0x52608227UL, 0x6DDD98E8UL, + 0xA4AEC741UL, 0x6C3FC2E4UL, 0xF3971A26UL, 0x58DDD730UL, 0xE6A73BBAUL, + 0xE702E37CUL, 0x182B3ED8UL, 0xDF48B563UL, 0xF65D1059UL, 0x79C32160UL, + 0xDD06B6CBUL, 0x83B5DB69UL, 0x16E24382UL, 0x828FEAE2UL, 0xDCCF0C2AUL, + 0x61DF0665UL, 0x14D5AEC7UL, 0x52D52484UL, 0xEC722B37UL, 0x69ED4CCDUL, + 0x127E1EB0UL, 0x5955CFD4UL, 0x966F95BFUL, 0x537D0636UL, 0x6355DA5DUL, + 0x2EE495DEUL, 0xFDFAC66AUL, 0xFC26F025UL, 0x7DD3A9C8UL, 0x03E787AFUL, + 0xDD7C3683UL, 0xE5DEDC9EUL, 0xB63D7671UL, 0x1107C37DUL, 0x0E78FBF2UL, + 0xF0DAA375UL, 0x7D715D49UL, 0xCDD5B5B2UL, 0x8C53E8ACUL, 0x1DBA428AUL, + 0x3F24D7EFUL, 0x81DC4721UL, 0xA737A755UL, 0xC566563DUL, 0x91A05D44UL, + 0x2CAE02A7UL, 0x590135BFUL, 0x5C1345DBUL, 0x23EC1E11UL, 0xD3561990UL, + 0xD4D9B0BAUL, 0x7EDD3F03UL, 0xA3FF1778UL, 0x7514E5FDUL, 0x83AB7A03UL, + 0x5BFF57AEUL, 0xB0773894UL, 0xE5EC6FCFUL, 0x89E5DAA2UL, 0xAFC24E6EUL, + 0xD5666D12UL, 0x77FD07FCUL, 0xBA94911FUL, 0x1D2F0C89UL, 0x83DEAD52UL, + 0x33F5C418UL, 0xAD53B173UL, 0x163D1D79UL, 0xDF874847UL, 0x9EEB5FD0UL, + 0xF4F2EB1CUL, 0xF74F8E20UL, 0x63167D3CUL, 0xBE229573UL, 0xE72B7B57UL, + 0x09736603UL, 0x09583AE1UL, 0x99BF192CUL, 0x5A5943DAUL, 0xB404C249UL, + 0x9DC7066BUL, 0xCB00ED6EUL, 0xB99B2F69UL, 0x8D6BBA37UL, 0x8EDBC624UL, + 0xC4EA6334UL, 0x1BB00FD0UL, 0x37DB8CCCUL, 0xAF12C2E9UL, 0x2455228CUL, + 0xEC2D3121UL, 0x1B8BC18AUL, 0x02208D63UL, 0x0AE92801UL, 0xDE488E63UL, + 0x6AA6A568UL, 0xD17C42DDUL, 0xC34B2F5EUL, 0xD3F9BAF1UL, 0xCA92EDC4UL, + 0x4D103A43UL, 0xCA89986DUL, 0xC7BF6DA3UL, 0xAC935820UL, 0x854DF417UL, + 0x311D2183UL, 0xE3F1B467UL, 0xB5A4EFB5UL, 0x8450BFD3UL, 0x3B04D360UL, + 0xB2B0FFA9UL, 0xE614A69FUL, 0x3B993967UL, 0x8DB77BDCUL, 0x9330CB44UL, + 0x0A1CF76AUL, 0x8ED3446AUL, 0xB6B4C579UL, 0x3F9B01C2UL, 0x63EB8267UL, + 0xEF9DA522UL, 0x15DA9F1CUL, 0x789EBC59UL, 0x71CC4F16UL, 0x119318B3UL, + 0x10E79E90UL, 0x51BD6ECDUL, 0x5371682BUL, 0x165B7B79UL, 0x323FE264UL, + 0x2A76FBD3UL, 0x86DF196BUL, 0x94BBD2CEUL, 0x6C46D2EDUL, 0xB1883447UL, + 0xBB13DE3BUL, 0x8ADDC197UL, 0x9556D09EUL, 0x030B563BUL, 0xD686F68CUL, + 0x5469F2F5UL, 0x891E2F20UL, 0x25787746UL, 0xD9942A33UL, 0xA19A5A68UL, + 0xB6CF342BUL, 0xA733DC1FUL, 0x104C55F7UL, 0xAD6C7341UL, 0x6656C241UL, + 0xE3CCBB69UL, 0x0DDCE368UL, 0x520B6F6AUL, 0x55315A35UL, 0xD234756AUL, + 0x465E0527UL, 0x3DC24BA6UL, 0xFC6178BFUL, 0xA2F80FD3UL, 0x84DBFE36UL, + 0x5C8FE754UL, 0x0D6212D5UL, 0x1C37D918UL, 0x86363E6EUL, 0xC918E5BDUL, + 0xCC7816E6UL, 0x53FA3586UL, 0x2E64524CUL, 0x876B5D0EUL, 0x2173F16AUL, + 0x897FE705UL, 0x31C5EF7DUL, 0x6B3E92D5UL, 0xBA3F7A24UL, 0x7E1F1DEDUL, + 0x4B9C657CUL, 0x83FC370FUL, 0x3329B3B2UL, 0xBDF76ACDUL, 0x1DD30B1BUL, + 0x74049B06UL, 0x4BD3B442UL, 0x1AE04771UL, 0x0372BEB6UL, 0x4D95A377UL, + 0xD227206CUL, 0x4B9A72D1UL, 0xF5BE4855UL, 0x17183048UL, 0xBB595B6FUL, + 0x7138B3A0UL, 0x08BE5C12UL, 0xF3398A64UL, 0xF914FE73UL, 0xD1DE807BUL, + 0x87FBF90BUL, 0x54EE27C3UL, 0x1336BE7BUL, 0xF1C19EA5UL, 0xC485A94EUL, + 0x1BA0D2D0UL, 0x0B60C9C1UL, 0xB2DED633UL, 0x115EA7B8UL, 0x0F425630UL, + 0xD5AE2640UL, 0x0503D4E7UL, 0xBB6D2AB0UL, 0x814A58C7UL, 0x37BA8300UL, + 0x07F21920UL, 0x61E01F2CUL, 0x703F964FUL, 0x656E5C1AUL, 0x0FA897D7UL, + 0xE68E6FACUL, 0x1DFB365DUL, 0xA8DA9756UL, 0xA3278885UL, 0x7959FB41UL, + 0x1C27B117UL, 0xD4B5D32AUL, 0x9E67EF3EUL, 0xC498DAF8UL, 0x70620133UL, + 0x25792A4FUL, 0x29AEEC47UL, 0x84A57562UL, 0xF1D56C08UL, 0x7788DEDCUL, + 0x77F7265FUL, 0xFA109A11UL, 0xD51289FBUL, 0xF46F0638UL, 0x2FFB63A5UL, + 0xE88671C1UL, 0x83C3026AUL, 0xF751D95CUL, 0x097D91A0UL, 0x4E9E98AFUL, + 0x130E47B8UL, 0xCF0413D8UL, 0x2D3EF687UL, 0x96509050UL, 0x364471C6UL, + 0xB4A48218UL, 0xE2AE8A91UL, 0x4F4880F8UL, 0xDDC1C586UL, 0xF56C79EFUL, + 0x9E93926EUL, 0x66FE25D7UL, 0x923404F0UL, 0x361A7B67UL, 0x1FCA36ABUL, + 0x02A675BDUL, 0x4C2F282FUL, 0x9F1A9A42UL, 0x10966A91UL, 0xEA55BE80UL, + 0x38BF6C8AUL, 0x31C71056UL, 0x2D48D95AUL, 0xCBD6191AUL, 0x3FDF8E41UL, + 0x1AA1585CUL, 0xE44BB7A7UL, 0xED9A86D3UL, 0x941D2792UL, 0x77E7D56FUL, + 0x860063EBUL, 0x80D224CAUL, 0x9CEE2975UL, 0xB26E704BUL, 0x240482DDUL, + 0xA47317BCUL, 0x5AC3BB7EUL, 0x97A50DD1UL, 0x50915453UL, 0xAC744894UL, + 0xE3D484ADUL, 0x3461B25AUL, 0xCE7CE64EUL, 0xFC7AB12CUL, 0x5D40B54AUL, + 0x75695FD3UL, 0x61497BD6UL, +}; + static void test_next32_a_few(void) { isaac_ctx_t ctx; @@ -215,10 +321,41 @@ static void test_next8_all(void) } } +static void test_next32_a_few_with_nonzero_seed(void) +{ + isaac_ctx_t ctx; + uint32_t seed[] = {0x01020304UL, 0x05060708UL}; + isaac_init(&ctx, &seed, 8); + uint32_t next; + + next = isaac_next32(&ctx); + atto_eq(next, expected_next32_with_seed_0102030405060708[0]); + + next = isaac_next32(&ctx); + atto_eq(next, expected_next32_with_seed_0102030405060708[1]); + + next = isaac_next32(&ctx); + atto_eq(next, expected_next32_with_seed_0102030405060708[2]); +} + +static void test_next32_all_with_nonzero_seed(void) +{ + uint32_t result; + isaac_ctx_t ctx; + uint32_t seed[] = {0x01020304UL, 0x05060708UL}; + isaac_init(&ctx, &seed, 8); + for (uint_fast32_t i = 0; i < EXPECTED_NEXT_ELEMENTS; i++) + { + result = isaac_next32(&ctx); + atto_eq(result, expected_next32_with_seed_0102030405060708[i]); + } +} + void test_isaac_next(void) { test_next32_a_few(); test_next32_all(); test_next8_four_times(); test_next8_all(); + test_next32_all_with_nonzero_seed(); } From e2e0b219b34444963db9e7eaa8edd61ba693f4ce Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matjaz=CC=8C?= Date: Sun, 26 Apr 2020 22:47:03 +0200 Subject: [PATCH 09/27] Avoid issues with endianness in non-zero seed --- tst/original/generate.c | 7 +- tst/test_next.c | 240 ++++++++++++++++++++-------------------- 2 files changed, 123 insertions(+), 124 deletions(-) diff --git a/tst/original/generate.c b/tst/original/generate.c index ed28740..401ef99 100644 --- a/tst/original/generate.c +++ b/tst/original/generate.c @@ -81,8 +81,11 @@ static void next_values_nonzero_seed(void) randctx ctx; unsigned long int i; unsigned long int next; - ctx.randrsl[0] = 0x01020304UL; - ctx.randrsl[1] = 0x05060708UL; + const unsigned char seed[8] = {1,2,3,4,5,6,7,8}; + for (i = 0; i < 8; i++) + { + ((unsigned char*) ctx.randrsl)[i] = seed[i]; + } for (i = 2; i < 256; i++) { ctx.randrsl[i] = 0; // Zero padding diff --git a/tst/test_next.c b/tst/test_next.c index a64e9e1..e4b439e 100644 --- a/tst/test_next.c +++ b/tst/test_next.c @@ -16,21 +16,8 @@ * This is the stream of uint32 values obtained by calling isaac_next() * repeatedly after the isaac_ctx_t has been initialised with a zero seed. * - * The value is obtained by taking the original ISAAC implementation - * (in particular `randport.c`), zero-initialising the seed - * and calling `rand(&ctx)` repeatedly. - * - * randctx ctx; - * unsigned long int i; - * unsigned long int next; - * for (i = 0; i < 256; i++) { - * ctx.randrsl[i] = 0; // Zero seed - * } - * randinit(&ctx, TRUE); // Init ISAAC with zero seed - * for (i = 0; i < 512; i++) { - * next = rand(&ctx); - * printf("0x%08lXUL, ", next); - * } + * In particular this is the value printed by next_values_zero_seed() + * in generate.c */ const static uint32_t expected_next_results[EXPECTED_NEXT_ELEMENTS] = { 0x182600F3UL, 0x300B4A8DUL, 0x301B6622UL, 0xB08ACD21UL, 0x296FD679UL, @@ -138,110 +125,118 @@ const static uint32_t expected_next_results[EXPECTED_NEXT_ELEMENTS] = { 0xE448E96DUL, 0xF650E4C8UL, }; +/* + * This is the stream of uint32 values obtained by calling isaac_next() + * repeatedly after the isaac_ctx_t has been initialised with a + * seed of {1,2,3,4,5,6,7,8} (in bytes, not uint32_t) + * + * In particular this is the value printed by next_values_nonzero_seed() + * in generate.c + */ const static uint32_t expected_next32_with_seed_0102030405060708[EXPECTED_NEXT_ELEMENTS] = { - 0x9EF2353DUL, 0x8CA8EFF9UL, 0x731BEC3EUL, 0xE7FBB85EUL, 0x1D3A7EF0UL, - 0x2C13F9D6UL, 0x681CC488UL, 0x09903CB7UL, 0xB8F9B3F2UL, 0x27AA5806UL, - 0xAE3D2F71UL, 0x5A4473B0UL, 0x4658E42EUL, 0x67A3AE5BUL, 0xACDF7F8BUL, - 0xB90A51C9UL, 0x2C6F8CC0UL, 0x4BC146A3UL, 0xEC48D263UL, 0x688A1F65UL, - 0xFF1B7812UL, 0xBE9B0BF7UL, 0x1D629DF7UL, 0x535620D0UL, 0xE3746550UL, - 0xB3F7A943UL, 0xB6C5C147UL, 0x69F2440BUL, 0x487B2BA5UL, 0x6526BC65UL, - 0x6F9263F1UL, 0xF228D86DUL, 0xAA6A5844UL, 0x46C92529UL, 0x9D65F839UL, - 0xCF4AB0B4UL, 0x0C83896CUL, 0x5C738844UL, 0x8CFFA3D1UL, 0x199B499FUL, - 0x8789FA0BUL, 0x0372057DUL, 0x28867679UL, 0x6F93E6A2UL, 0x97E8756FUL, - 0xAF33E361UL, 0x5DBDBC99UL, 0x1D4C15CEUL, 0x0C57A358UL, 0x50DEEE79UL, - 0x37D61DDDUL, 0x139B3957UL, 0x7EDDA8FEUL, 0xBB94809EUL, 0xF6F812B6UL, - 0x387A24C3UL, 0xBAFE202FUL, 0x82A05EBDUL, 0xB4716592UL, 0x7238CD40UL, - 0x3D94A157UL, 0x43665763UL, 0x1F78C676UL, 0x951B519BUL, 0x8DE401EBUL, - 0x34DBE945UL, 0xD6EE43FEUL, 0x6A3B158BUL, 0x65FBB769UL, 0xEB25D76AUL, - 0xB25B4D9BUL, 0x619CED1CUL, 0x48AFBF93UL, 0x3BC657A6UL, 0x3139C8B9UL, - 0x51E4749CUL, 0x8D06E82AUL, 0xBF975284UL, 0x32724D41UL, 0xC2E92DC8UL, - 0x1A9C5015UL, 0xB2D89894UL, 0x4D8B8AC0UL, 0x216259BFUL, 0xD6E083F4UL, - 0xD7828769UL, 0x91936D17UL, 0x45E1F674UL, 0xBACF0D8BUL, 0xEBD3A0CDUL, - 0xA053D933UL, 0xD5BF0E1EUL, 0xD7548B35UL, 0xFB1310B7UL, 0xB0FF866EUL, - 0x6BFFBD41UL, 0xB9E03C59UL, 0x23BBF0C7UL, 0xD454C194UL, 0x0B6813F7UL, - 0xE9DA9054UL, 0x81CF8C63UL, 0x07F0F891UL, 0xC49B0C18UL, 0xBCC92368UL, - 0xFDBFA92CUL, 0x4464348FUL, 0x2469DCA8UL, 0xEE7CF360UL, 0xB060F137UL, - 0xB55D05DDUL, 0x92274019UL, 0x7A9631D5UL, 0x736869A1UL, 0x0704D9A3UL, - 0x2DBD564EUL, 0xF75559C5UL, 0x5674B67CUL, 0x64959697UL, 0x0BDEE025UL, - 0x33D1785BUL, 0x65D37901UL, 0x8600892CUL, 0x9A2C10EBUL, 0x92FAEC4AUL, - 0x1DF63F2CUL, 0x995CC9E6UL, 0x4A4F7C49UL, 0x9BA3AAEBUL, 0x173C26A1UL, - 0xD4BE3C17UL, 0x97F9946AUL, 0x0741E3C7UL, 0xE61D8AD4UL, 0xEC045EABUL, - 0x9AFDDCB0UL, 0xDCA781D5UL, 0xA8ACB435UL, 0xFB534FFBUL, 0xFBC3AD97UL, - 0x4C4E41E9UL, 0x55F86417UL, 0x7FE91F5BUL, 0x27E36B71UL, 0x85150B8DUL, - 0x778567C7UL, 0x1CC02EA9UL, 0x66A790FAUL, 0xCBFC4E40UL, 0x1247E23EUL, - 0xDF5B3E46UL, 0xDD08DD87UL, 0x18B090E8UL, 0xC122C7FDUL, 0xA6585981UL, - 0xDBAD5BB3UL, 0xADB66F36UL, 0x7EF8FF9FUL, 0xBBD985A1UL, 0xA5B48C0DUL, - 0x1D4E12A7UL, 0x759631D6UL, 0x43353992UL, 0xCCE3E886UL, 0x5CC43D97UL, - 0x80D8282CUL, 0xBA805A97UL, 0x6ACF9F72UL, 0x20B0D2BEUL, 0xEEA93F4CUL, - 0xDFB5E952UL, 0x3813DEB0UL, 0xB70A8A17UL, 0x6AD90124UL, 0x4EF1FB26UL, - 0xC944710FUL, 0x62044F7FUL, 0x26D2D3C6UL, 0x98EE543DUL, 0x91C1D1F2UL, - 0xE6AFB21BUL, 0x15B90C52UL, 0x5ECAC126UL, 0x0A394F4BUL, 0xE505DF84UL, - 0xADD14CB1UL, 0xE3FD1403UL, 0x99732B96UL, 0xE6C8A1DCUL, 0x7B67E186UL, - 0xF85BF48EUL, 0xC8335F68UL, 0xBBE9405DUL, 0x1E3E191EUL, 0x6EE1EC8BUL, - 0x97A7571BUL, 0x9B7961AAUL, 0x6979CFFEUL, 0x98C874C6UL, 0xD0373732UL, - 0x8B3A6B15UL, 0xF09C1ABFUL, 0xFEC85689UL, 0x38600F5BUL, 0x46A6B5C8UL, - 0x7A75AE2CUL, 0xC5291F23UL, 0xF1B4E879UL, 0x4F8F7C5CUL, 0x9ACB8790UL, - 0x9AB4E178UL, 0x03F5D855UL, 0xDF2A7E55UL, 0x2405A484UL, 0xF7DCF8C2UL, - 0xE890B234UL, 0xDDD670B7UL, 0x46E89237UL, 0xC032C2F8UL, 0xB63C05D4UL, - 0x6359E564UL, 0x577DDDB9UL, 0x20861B06UL, 0x52608227UL, 0x6DDD98E8UL, - 0xA4AEC741UL, 0x6C3FC2E4UL, 0xF3971A26UL, 0x58DDD730UL, 0xE6A73BBAUL, - 0xE702E37CUL, 0x182B3ED8UL, 0xDF48B563UL, 0xF65D1059UL, 0x79C32160UL, - 0xDD06B6CBUL, 0x83B5DB69UL, 0x16E24382UL, 0x828FEAE2UL, 0xDCCF0C2AUL, - 0x61DF0665UL, 0x14D5AEC7UL, 0x52D52484UL, 0xEC722B37UL, 0x69ED4CCDUL, - 0x127E1EB0UL, 0x5955CFD4UL, 0x966F95BFUL, 0x537D0636UL, 0x6355DA5DUL, - 0x2EE495DEUL, 0xFDFAC66AUL, 0xFC26F025UL, 0x7DD3A9C8UL, 0x03E787AFUL, - 0xDD7C3683UL, 0xE5DEDC9EUL, 0xB63D7671UL, 0x1107C37DUL, 0x0E78FBF2UL, - 0xF0DAA375UL, 0x7D715D49UL, 0xCDD5B5B2UL, 0x8C53E8ACUL, 0x1DBA428AUL, - 0x3F24D7EFUL, 0x81DC4721UL, 0xA737A755UL, 0xC566563DUL, 0x91A05D44UL, - 0x2CAE02A7UL, 0x590135BFUL, 0x5C1345DBUL, 0x23EC1E11UL, 0xD3561990UL, - 0xD4D9B0BAUL, 0x7EDD3F03UL, 0xA3FF1778UL, 0x7514E5FDUL, 0x83AB7A03UL, - 0x5BFF57AEUL, 0xB0773894UL, 0xE5EC6FCFUL, 0x89E5DAA2UL, 0xAFC24E6EUL, - 0xD5666D12UL, 0x77FD07FCUL, 0xBA94911FUL, 0x1D2F0C89UL, 0x83DEAD52UL, - 0x33F5C418UL, 0xAD53B173UL, 0x163D1D79UL, 0xDF874847UL, 0x9EEB5FD0UL, - 0xF4F2EB1CUL, 0xF74F8E20UL, 0x63167D3CUL, 0xBE229573UL, 0xE72B7B57UL, - 0x09736603UL, 0x09583AE1UL, 0x99BF192CUL, 0x5A5943DAUL, 0xB404C249UL, - 0x9DC7066BUL, 0xCB00ED6EUL, 0xB99B2F69UL, 0x8D6BBA37UL, 0x8EDBC624UL, - 0xC4EA6334UL, 0x1BB00FD0UL, 0x37DB8CCCUL, 0xAF12C2E9UL, 0x2455228CUL, - 0xEC2D3121UL, 0x1B8BC18AUL, 0x02208D63UL, 0x0AE92801UL, 0xDE488E63UL, - 0x6AA6A568UL, 0xD17C42DDUL, 0xC34B2F5EUL, 0xD3F9BAF1UL, 0xCA92EDC4UL, - 0x4D103A43UL, 0xCA89986DUL, 0xC7BF6DA3UL, 0xAC935820UL, 0x854DF417UL, - 0x311D2183UL, 0xE3F1B467UL, 0xB5A4EFB5UL, 0x8450BFD3UL, 0x3B04D360UL, - 0xB2B0FFA9UL, 0xE614A69FUL, 0x3B993967UL, 0x8DB77BDCUL, 0x9330CB44UL, - 0x0A1CF76AUL, 0x8ED3446AUL, 0xB6B4C579UL, 0x3F9B01C2UL, 0x63EB8267UL, - 0xEF9DA522UL, 0x15DA9F1CUL, 0x789EBC59UL, 0x71CC4F16UL, 0x119318B3UL, - 0x10E79E90UL, 0x51BD6ECDUL, 0x5371682BUL, 0x165B7B79UL, 0x323FE264UL, - 0x2A76FBD3UL, 0x86DF196BUL, 0x94BBD2CEUL, 0x6C46D2EDUL, 0xB1883447UL, - 0xBB13DE3BUL, 0x8ADDC197UL, 0x9556D09EUL, 0x030B563BUL, 0xD686F68CUL, - 0x5469F2F5UL, 0x891E2F20UL, 0x25787746UL, 0xD9942A33UL, 0xA19A5A68UL, - 0xB6CF342BUL, 0xA733DC1FUL, 0x104C55F7UL, 0xAD6C7341UL, 0x6656C241UL, - 0xE3CCBB69UL, 0x0DDCE368UL, 0x520B6F6AUL, 0x55315A35UL, 0xD234756AUL, - 0x465E0527UL, 0x3DC24BA6UL, 0xFC6178BFUL, 0xA2F80FD3UL, 0x84DBFE36UL, - 0x5C8FE754UL, 0x0D6212D5UL, 0x1C37D918UL, 0x86363E6EUL, 0xC918E5BDUL, - 0xCC7816E6UL, 0x53FA3586UL, 0x2E64524CUL, 0x876B5D0EUL, 0x2173F16AUL, - 0x897FE705UL, 0x31C5EF7DUL, 0x6B3E92D5UL, 0xBA3F7A24UL, 0x7E1F1DEDUL, - 0x4B9C657CUL, 0x83FC370FUL, 0x3329B3B2UL, 0xBDF76ACDUL, 0x1DD30B1BUL, - 0x74049B06UL, 0x4BD3B442UL, 0x1AE04771UL, 0x0372BEB6UL, 0x4D95A377UL, - 0xD227206CUL, 0x4B9A72D1UL, 0xF5BE4855UL, 0x17183048UL, 0xBB595B6FUL, - 0x7138B3A0UL, 0x08BE5C12UL, 0xF3398A64UL, 0xF914FE73UL, 0xD1DE807BUL, - 0x87FBF90BUL, 0x54EE27C3UL, 0x1336BE7BUL, 0xF1C19EA5UL, 0xC485A94EUL, - 0x1BA0D2D0UL, 0x0B60C9C1UL, 0xB2DED633UL, 0x115EA7B8UL, 0x0F425630UL, - 0xD5AE2640UL, 0x0503D4E7UL, 0xBB6D2AB0UL, 0x814A58C7UL, 0x37BA8300UL, - 0x07F21920UL, 0x61E01F2CUL, 0x703F964FUL, 0x656E5C1AUL, 0x0FA897D7UL, - 0xE68E6FACUL, 0x1DFB365DUL, 0xA8DA9756UL, 0xA3278885UL, 0x7959FB41UL, - 0x1C27B117UL, 0xD4B5D32AUL, 0x9E67EF3EUL, 0xC498DAF8UL, 0x70620133UL, - 0x25792A4FUL, 0x29AEEC47UL, 0x84A57562UL, 0xF1D56C08UL, 0x7788DEDCUL, - 0x77F7265FUL, 0xFA109A11UL, 0xD51289FBUL, 0xF46F0638UL, 0x2FFB63A5UL, - 0xE88671C1UL, 0x83C3026AUL, 0xF751D95CUL, 0x097D91A0UL, 0x4E9E98AFUL, - 0x130E47B8UL, 0xCF0413D8UL, 0x2D3EF687UL, 0x96509050UL, 0x364471C6UL, - 0xB4A48218UL, 0xE2AE8A91UL, 0x4F4880F8UL, 0xDDC1C586UL, 0xF56C79EFUL, - 0x9E93926EUL, 0x66FE25D7UL, 0x923404F0UL, 0x361A7B67UL, 0x1FCA36ABUL, - 0x02A675BDUL, 0x4C2F282FUL, 0x9F1A9A42UL, 0x10966A91UL, 0xEA55BE80UL, - 0x38BF6C8AUL, 0x31C71056UL, 0x2D48D95AUL, 0xCBD6191AUL, 0x3FDF8E41UL, - 0x1AA1585CUL, 0xE44BB7A7UL, 0xED9A86D3UL, 0x941D2792UL, 0x77E7D56FUL, - 0x860063EBUL, 0x80D224CAUL, 0x9CEE2975UL, 0xB26E704BUL, 0x240482DDUL, - 0xA47317BCUL, 0x5AC3BB7EUL, 0x97A50DD1UL, 0x50915453UL, 0xAC744894UL, - 0xE3D484ADUL, 0x3461B25AUL, 0xCE7CE64EUL, 0xFC7AB12CUL, 0x5D40B54AUL, - 0x75695FD3UL, 0x61497BD6UL, + 0xC987111FUL, 0x33949FA5UL, 0x72F289B6UL, 0x00861702UL, 0xCB5D7A6EUL, + 0x5291E936UL, 0x79879ADEUL, 0xBB6EF9CFUL, 0x8F8DD09DUL, 0xA44B1A6CUL, + 0xB3C78167UL, 0x9020783BUL, 0xD96F29CAUL, 0x3A6AFE88UL, 0xD5EB7091UL, + 0xB61ECEB4UL, 0x2F3EA2B7UL, 0x1B42FAF8UL, 0xC3206714UL, 0xDE2CC0F2UL, + 0x6D6CF2F5UL, 0xC21F5ABBUL, 0x801851E3UL, 0xE8AD45B3UL, 0x07109ADCUL, + 0x4102234AUL, 0x9A190E08UL, 0x18A72F1CUL, 0xB0E2B8DAUL, 0x3C95A998UL, + 0x95BACD29UL, 0x5812E873UL, 0x02198D64UL, 0x4AAD18F4UL, 0x7CE73151UL, + 0x72C34521UL, 0x14CB27E6UL, 0x5244AEDCUL, 0xEF3CAE74UL, 0xE7B3824AUL, + 0x2F9D6B9EUL, 0x7D8A44C3UL, 0xD1201B3FUL, 0x25CBD94EUL, 0xC7E826DCUL, + 0x3346749DUL, 0x856509D1UL, 0x57DA3982UL, 0xFA26FD63UL, 0x1C672264UL, + 0xC10A02AAUL, 0x67B1E46EUL, 0x285AAAD7UL, 0x8093DC57UL, 0x9F00DBC5UL, + 0xA191268DUL, 0x23F5BE25UL, 0xC84CB5C8UL, 0x6E27FDD7UL, 0xE5462908UL, + 0x8BA5889AUL, 0xBDA4DE39UL, 0x84F2C60AUL, 0x11A4F036UL, 0x89BFAF02UL, + 0x4D0B3FA9UL, 0xA1166856UL, 0xD61DCCABUL, 0x61C5F7CBUL, 0x2DDEE8FCUL, + 0xD2854C55UL, 0xC4196AC9UL, 0x0A92D424UL, 0xBFA77683UL, 0x6437FFC9UL, + 0x7E4264E4UL, 0x30CA3DF0UL, 0xF9A01C7AUL, 0xFA8CFCFAUL, 0xC5241BFEUL, + 0xFA00E8BDUL, 0x7E522085UL, 0x63553457UL, 0x045D82B8UL, 0x27CDC1ABUL, + 0x871DF567UL, 0xF30AF872UL, 0x95B5B19DUL, 0xF3E36970UL, 0x94464CFFUL, + 0x32CCC4EDUL, 0xF76E828AUL, 0xE0F1700AUL, 0xB346BC60UL, 0x5CFD2F14UL, + 0xC2632062UL, 0x616ADBAEUL, 0xE73F18E9UL, 0x941F5843UL, 0x2A5CA2C8UL, + 0xDEB519ACUL, 0x19606B42UL, 0x28F80B82UL, 0xE19EBB47UL, 0xB31AA32FUL, + 0x94A3ACB2UL, 0x4DE2B784UL, 0x3EF326EAUL, 0x134CDD3BUL, 0xD739A2CDUL, + 0x97D51E1DUL, 0x594F975FUL, 0xF48CAC1AUL, 0x5F2EDC8FUL, 0x225DFDD4UL, + 0xA57E36A8UL, 0xFA32CF4DUL, 0xA58BF76DUL, 0x6D55628AUL, 0x923A1AEFUL, + 0xE0011522UL, 0x30FFAFF5UL, 0x001986ECUL, 0xEB16E097UL, 0xC403FC60UL, + 0x510566B6UL, 0x72FAB07CUL, 0x804457ACUL, 0x58A8506FUL, 0xE770B14EUL, + 0x2D83C753UL, 0x53BDD8B5UL, 0x54138AB6UL, 0x1638F87AUL, 0x1A2A834CUL, + 0x2A9F0BF4UL, 0x69E13398UL, 0x65296112UL, 0x7486F9B3UL, 0x91F0E9A1UL, + 0xF3D7C990UL, 0x754FF4ADUL, 0xBE47CE95UL, 0x409329D9UL, 0x334D3867UL, + 0x1E18D2F4UL, 0x462A0B83UL, 0x96C5A1B6UL, 0x577EBA9CUL, 0x1D2B0B09UL, + 0x681DDAB0UL, 0xC6C78665UL, 0x0179A71CUL, 0x4614AB27UL, 0x75C83725UL, + 0x35ED5CB5UL, 0xF2811F31UL, 0xECE7839FUL, 0x969F7D8EUL, 0xF92AE295UL, + 0xC6B413C5UL, 0x78E126ABUL, 0xB8227AF3UL, 0xF6BBF1EBUL, 0x22586EE0UL, + 0x4003DB22UL, 0xBC1DB747UL, 0xA0016F76UL, 0x3455F76DUL, 0xE3B9F85EUL, + 0xBD6DC736UL, 0xD7ECD061UL, 0x374094EFUL, 0x75B9074EUL, 0x73BC5ED7UL, + 0x995049CAUL, 0x0AC8FD47UL, 0xEF557607UL, 0xD19632B3UL, 0x609649B4UL, + 0xBF11FAEDUL, 0xD6F93CC5UL, 0x98BDDBEBUL, 0x9226F4D5UL, 0xC71E5F66UL, + 0x03A87846UL, 0x17366CADUL, 0x9EC3CD34UL, 0xC8C117D3UL, 0x2AC1D182UL, + 0xC188454CUL, 0x5AFB09C2UL, 0xF4375831UL, 0xB1D4FF64UL, 0x14EA480AUL, + 0xED891E9AUL, 0xB0F7D772UL, 0x92D09662UL, 0x4C0206F9UL, 0xFBCA7BD3UL, + 0xDEA0CFB2UL, 0xBDE4D3CCUL, 0x2E248D9EUL, 0xEC597682UL, 0x74E3B0DAUL, + 0x8FE9004FUL, 0x611B883EUL, 0x3515F508UL, 0x25A000CAUL, 0x7ACB9D11UL, + 0x880B875DUL, 0x2E132954UL, 0xD9BCC32CUL, 0x50F782DEUL, 0xE6ECDFA4UL, + 0xD2B774A4UL, 0x1D4FC93EUL, 0xA43329D1UL, 0x039E24C3UL, 0x0C0F343DUL, + 0x37C742F9UL, 0xA68F6920UL, 0xD913640CUL, 0xC130B1AFUL, 0x403F5CB5UL, + 0xF4AD9AC9UL, 0x7FB1B5A1UL, 0xB9717A59UL, 0x394F7918UL, 0x647E8AD8UL, + 0x22662D97UL, 0x700AE372UL, 0x4203B72EUL, 0x6DE606E2UL, 0xE1DB8AFCUL, + 0xB3F23FE7UL, 0xA22B58EDUL, 0x61B69E36UL, 0xBF2D4B76UL, 0xDD85BE5CUL, + 0x11304761UL, 0x0E121E85UL, 0xBC506172UL, 0x82605046UL, 0xA7DD8E74UL, + 0x7CE5A040UL, 0x8331A767UL, 0xE2266B16UL, 0x5E59F68AUL, 0x5E1CB8A2UL, + 0x40117235UL, 0xF795B85DUL, 0x42183AB9UL, 0x0790D1E5UL, 0xC1FF8E2CUL, + 0x971CD9C6UL, 0xBA9734AAUL, 0xAE5F7197UL, 0xEAB168BFUL, 0xAC290E78UL, + 0x44F712A6UL, 0x60D40A4BUL, 0xB2B86D44UL, 0x50CFF015UL, 0x4823F1D5UL, + 0xC332D13AUL, 0x0F00F80FUL, 0x6541C275UL, 0x78F2085BUL, 0x92FBAF98UL, + 0x4A6BCF1EUL, 0x3497D087UL, 0x9944B1F2UL, 0x0840DE1BUL, 0x20638EAEUL, + 0x6F530DD2UL, 0x4767A37CUL, 0x8ACDEC6FUL, 0x29E305B7UL, 0x26A04156UL, + 0x00E4C02CUL, 0xAA672809UL, 0x40D58097UL, 0x5F532BFAUL, 0xF71CEE7CUL, + 0xA95696BEUL, 0xCEAFA260UL, 0xAF65A0D1UL, 0x81322EC2UL, 0xCFE77E16UL, + 0xAD57C024UL, 0x77E31ACAUL, 0x6E8C4AB1UL, 0x6A000C48UL, 0xF8F026FCUL, + 0xB4148DAFUL, 0x4B12DBD3UL, 0xBD208EF8UL, 0xABDDC53AUL, 0x41320656UL, + 0xF29BAD80UL, 0xF701A783UL, 0x9F970355UL, 0xC6878C36UL, 0x8A6B25E5UL, + 0x63F39C5EUL, 0x0FB067B6UL, 0x8187E50AUL, 0xF997E711UL, 0x14CC84D3UL, + 0x8A16EFE7UL, 0x97FA0BB1UL, 0xF5872C93UL, 0xD67B28D9UL, 0xA0511087UL, + 0xFC82795BUL, 0x4C95E4AAUL, 0xE2EFE242UL, 0x9895B7BCUL, 0x2C4F6D69UL, + 0x5D762413UL, 0xD284FFA5UL, 0xE1210AE0UL, 0x08EDBAF9UL, 0x76E76F43UL, + 0x80FB6287UL, 0x8711ED8EUL, 0x849B3882UL, 0xE7B98423UL, 0xBD3FE74CUL, + 0x4392AA3BUL, 0xD88854D9UL, 0x9BB42193UL, 0x9B212735UL, 0x12FD3D1FUL, + 0xE5399B4FUL, 0xC3E392B2UL, 0x52E8A282UL, 0xD255AC25UL, 0xBD2782AEUL, + 0x3F283E49UL, 0xFD25E81AUL, 0xFFD3F4A0UL, 0x48622CFAUL, 0xB0FBEE60UL, + 0x6B555300UL, 0x279525D5UL, 0x8BC4C146UL, 0xC94CDB6DUL, 0x443DC33AUL, + 0x8F47BD4CUL, 0x97E40C3EUL, 0xFE8C0C3CUL, 0x49240BB2UL, 0xF39AAB73UL, + 0xD050DBF9UL, 0x3E8D41E1UL, 0x8D980943UL, 0xFC31FD17UL, 0x604082AAUL, + 0xBBE37F04UL, 0x0615C2D3UL, 0x31B7B137UL, 0xBEE43720UL, 0xD4EA5B72UL, + 0x91413A8FUL, 0x3ADAAE59UL, 0x2577FE7EUL, 0xFD488664UL, 0x92F1EE09UL, + 0xE7E79BD5UL, 0xC49EB8ABUL, 0x5A88F979UL, 0x2A972D99UL, 0x4DCC212AUL, + 0x21E77EF8UL, 0xE647C5DCUL, 0x69753C6CUL, 0x28FA5EFBUL, 0x662BFF5FUL, + 0x594CB517UL, 0xEBD9652BUL, 0xD742ECF1UL, 0x3961D895UL, 0x052C9414UL, + 0xD8308354UL, 0x6F348D54UL, 0x4BB16D47UL, 0xEFA5966AUL, 0xA13C3FA4UL, + 0x908E9A01UL, 0x1B1094C3UL, 0x36E57C4FUL, 0x0972EF22UL, 0x3B847C74UL, + 0xF8D1CAC0UL, 0xD245604CUL, 0xEBF27EB2UL, 0x6F59E622UL, 0x08022691UL, + 0xD9476B67UL, 0xD1A68C66UL, 0x264C453AUL, 0xFF0B1A4AUL, 0x9CC93145UL, + 0xB9DF3ACBUL, 0x6B6D6D04UL, 0xA9EA3A92UL, 0xBB625CD8UL, 0x422F887AUL, + 0x9231139BUL, 0xA566A405UL, 0x5C9AABD3UL, 0xF5860C7DUL, 0x85807D4DUL, + 0x9BB32AD9UL, 0x5E634B34UL, 0xFA87AC98UL, 0x75D83341UL, 0x4B4BE607UL, + 0xFC5FADD3UL, 0x2B3070F4UL, 0x23F23218UL, 0x601F9DB9UL, 0x2784940AUL, + 0xF99E6B58UL, 0xE9DD16C7UL, 0xDA3D4D05UL, 0x28752620UL, 0x156F46A0UL, + 0xF2C5FDE9UL, 0x91D48724UL, 0xA72EFF7DUL, 0xF90248EEUL, 0xBE7441B1UL, + 0xBAAFE2EFUL, 0x53AD384CUL, 0xF5D21F72UL, 0x36396351UL, 0xC3A347C8UL, + 0x0B6F59A1UL, 0x45889AD9UL, 0x7DE08BF8UL, 0xAFA9D792UL, 0xA92F42BAUL, + 0xFB3826FAUL, 0xACDFEE35UL, 0xA07311DBUL, 0x5F35A4DEUL, 0x21203064UL, + 0x6939C35AUL, 0xF81ED55AUL, 0x9438873AUL, 0x0B59F77AUL, 0x6C949316UL, + 0x8079CEA9UL, 0x8C6EF6ADUL, 0x547514EFUL, 0x36FFC3F5UL, 0x3051D1FEUL, + 0xCB1ECC07UL, 0xFEEEDC69UL, 0xE7D5D98CUL, 0x9AB41450UL, 0x455285F7UL, + 0x23397700UL, 0xF066DC78UL, 0xAB484604UL, 0x36C0A277UL, 0xF1F17714UL, + 0x493B98B3UL, 0xE3B24E47UL, 0xD5DC4EFDUL, 0x86D972DEUL, 0x3BC8BD09UL, + 0x04AB93D2UL, 0xF50B3B4BUL, 0x0EDAEEDBUL, 0x639721D5UL, 0xE0024ADAUL, + 0x49D24EAAUL, 0x4BC4CE39UL, 0xD08C9F5CUL, 0x24A9E662UL, 0x49B0A56FUL, + 0x904601D8UL, 0xB7900FEBUL, 0x22C18C51UL, 0x8A5A00F8UL, 0xF833B05FUL, + 0x5D20530CUL, 0x24AECD14UL, 0xBDEC3FF8UL, 0x14F8A820UL, 0x7F635121UL, + 0x6C834AA3UL, 0x539ED0FFUL, 0xE991D664UL, 0x453A9E69UL, 0x664BE282UL, + 0x14EF5FB2UL, 0x7E8B6881UL, 0xA033BF4AUL, 0x6D579D32UL, 0x0778DAB4UL, + 0xC3C1EA27UL, 0x0B8EE3E3UL, 0x4348FEA0UL, 0x5FFDEB1FUL, 0x49BC902EUL, + 0xDA3A4B2EUL, 0x37A3C216UL, }; static void test_next32_a_few(void) @@ -324,8 +319,8 @@ static void test_next8_all(void) static void test_next32_a_few_with_nonzero_seed(void) { isaac_ctx_t ctx; - uint32_t seed[] = {0x01020304UL, 0x05060708UL}; - isaac_init(&ctx, &seed, 8); + const uint8_t seed[8] = {1,2,3,4,5,6,7,8}; + isaac_init(&ctx, seed, 8); uint32_t next; next = isaac_next32(&ctx); @@ -342,8 +337,8 @@ static void test_next32_all_with_nonzero_seed(void) { uint32_t result; isaac_ctx_t ctx; - uint32_t seed[] = {0x01020304UL, 0x05060708UL}; - isaac_init(&ctx, &seed, 8); + const uint8_t seed[8] = {1,2,3,4,5,6,7,8}; + isaac_init(&ctx, seed, 8); for (uint_fast32_t i = 0; i < EXPECTED_NEXT_ELEMENTS; i++) { result = isaac_next32(&ctx); @@ -357,5 +352,6 @@ void test_isaac_next(void) test_next32_all(); test_next8_four_times(); test_next8_all(); + test_next32_a_few_with_nonzero_seed(); test_next32_all_with_nonzero_seed(); } From 7b4e25c290843bba49e7213fe81d0fb84684e5f8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matjaz=CC=8C?= Date: Sun, 26 Apr 2020 22:52:14 +0200 Subject: [PATCH 10/27] Documentation improvements --- inc/isaac.h | 34 +++++++++++++++++++++++++++------- tst/test_next.c | 4 ++-- 2 files changed, 29 insertions(+), 9 deletions(-) diff --git a/inc/isaac.h b/inc/isaac.h index 8b615d8..38b8cb3 100644 --- a/inc/isaac.h +++ b/inc/isaac.h @@ -40,7 +40,8 @@ extern "C" #include #define ISAAC_U32_ELEMENTS 256U -#define ISAAC_SEED_MAX_BYTES (ISAAC_U32_ELEMENTS * sizeof(uint32_t)) +#define ISAAC_U8_ELEMENTS (ISAAC_U32_ELEMENTS * sizeof(uint32_t)) +#define ISAAC_SEED_MAX_BYTES ISAAC_U8_ELEMENTS /** * Context of the ISAAC CPRNG. @@ -87,10 +88,10 @@ void isaac_init(isaac_ctx_t* ctx, const void* seed, uint16_t seed_bytes); /** * Provides the next pseudo-random 32-bit integer. * - * After #ISAAC_ELEMENTS calls it will automatically reshuffle the ISAAC state - * to provide #ISAAC_ELEMENTS new elements. This means that #ISAAC_ELEMENTS - * calls are very cheap (just reading the uint32_t value from the state), - * and the #ISAAC_ELEMENTS+1 call is expensive. + * After #ISAAC_U32_ELEMENTS calls it will automatically reshuffle the ISAAC + * state to provide #ISAAC_U32_ELEMENTS new elements. This means that + * #ISAAC_U32_ELEMENTS calls are very cheap (just reading the uint32_t value + * from the state), and the #ISAAC_U32_ELEMENTS+1st call is expensive. * * @warning * **Use either isaac_next32() or isaac_next8(), never both**, especially not @@ -104,8 +105,27 @@ void isaac_init(isaac_ctx_t* ctx, const void* seed, uint16_t seed_bytes); */ uint32_t isaac_next32(isaac_ctx_t* ctx); -// Compared to the next32, this provides the bytes in little endian order -// DO NOT MIX USAGE OF NEXT8 and NEXT32 +/** + * Provides the next pseudo-random byte. + * + * Basically provides the isaac_next32() output byte-by-byte. The order + * of the bytes is from (uint32_t*)[0] to (uint32_t*)[3]. + * + * After #ISAAC_U8_ELEMENTS calls it will automatically reshuffle the ISAAC + * state to provide #ISAAC_U8_ELEMENTS new elements. This means that + * #ISAAC_U8_ELEMENTS calls are very cheap (just reading the uint8_t value + * from the state), and the #ISAAC_U8_ELEMENTS+1st call is expensive. + * + * @warning + * **Use either isaac_next32() or isaac_next8(), never both**, especially not + * in an interleaved manner. The issue is that isaac_next8() reads bytes + * from the isaac_next32() output; this means that calling isaac_next8() and + * then isaac_next32() will produce the same byte twice, which is **unsecure** + * and predictable. + * + * @param ctx the ISAAC state, already initialised. + * @return a pseudo-random byte. + */ uint8_t isaac_next8(isaac_ctx_t* ctx); diff --git a/tst/test_next.c b/tst/test_next.c index e4b439e..9936c6e 100644 --- a/tst/test_next.c +++ b/tst/test_next.c @@ -319,7 +319,7 @@ static void test_next8_all(void) static void test_next32_a_few_with_nonzero_seed(void) { isaac_ctx_t ctx; - const uint8_t seed[8] = {1,2,3,4,5,6,7,8}; + const uint8_t seed[8] = {1, 2, 3, 4, 5, 6, 7, 8}; isaac_init(&ctx, seed, 8); uint32_t next; @@ -337,7 +337,7 @@ static void test_next32_all_with_nonzero_seed(void) { uint32_t result; isaac_ctx_t ctx; - const uint8_t seed[8] = {1,2,3,4,5,6,7,8}; + const uint8_t seed[8] = {1, 2, 3, 4, 5, 6, 7, 8}; isaac_init(&ctx, seed, 8); for (uint_fast32_t i = 0; i < EXPECTED_NEXT_ELEMENTS; i++) { From 2ca1662d90afcfe58ab2da0c5bb8d5c5c6b5327f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matjaz=CC=8C?= Date: Sun, 26 Apr 2020 22:56:40 +0200 Subject: [PATCH 11/27] Add test for non-zero seed initialisation --- tst/original/generate.c | 21 +++++- tst/test_init.c | 152 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 172 insertions(+), 1 deletion(-) diff --git a/tst/original/generate.c b/tst/original/generate.c index 401ef99..a7a73c8 100644 --- a/tst/original/generate.c +++ b/tst/original/generate.c @@ -57,6 +57,24 @@ static void ctx_no_init(void) print_ctx(&ctx); } +static void ctx_nonzero_seed(void) +{ + randctx ctx; + const unsigned char seed[8] = {1, 2, 3, 4, 5, 6, 7, 8}; + unsigned long int i; + for (i = 0; i < 8; i++) + { + ((unsigned char*) ctx.randrsl)[i] = seed[i]; + } + for (i = 2; i < 256; i++) + { + ctx.randrsl[i] = 0; // Zero padding + } + randinit(&ctx, 1); // Init ISAAC with a non-zero seed + puts("Context with seed {1,2,3,4,5,6,7,8}:"); + print_ctx(&ctx); +} + static void next_values_zero_seed(void) { randctx ctx; @@ -81,7 +99,7 @@ static void next_values_nonzero_seed(void) randctx ctx; unsigned long int i; unsigned long int next; - const unsigned char seed[8] = {1,2,3,4,5,6,7,8}; + const unsigned char seed[8] = {1, 2, 3, 4, 5, 6, 7, 8}; for (i = 0; i < 8; i++) { ((unsigned char*) ctx.randrsl)[i] = seed[i]; @@ -103,6 +121,7 @@ int main(void) { ctx_zero_seed(); ctx_no_init(); + ctx_nonzero_seed(); next_values_zero_seed(); next_values_nonzero_seed(); return 0; diff --git a/tst/test_init.c b/tst/test_init.c index bed69ba..9b59423 100644 --- a/tst/test_init.c +++ b/tst/test_init.c @@ -150,6 +150,146 @@ const static isaac_ctx_t zero_initialised_ctx = { } }; +const static isaac_ctx_t nonzero_initialised_ctx = { + .next32_index = ISAAC_U32_ELEMENTS - 1, + .next8_index = 0 - 1, + .a = 0x3FCFDFDAUL, + .b = 0xC987111FUL, + .c = 0x00000001UL, + .result = { + 0x971CD9C6UL, 0xC1FF8E2CUL, 0x0790D1E5UL, 0x42183AB9UL, + 0xF795B85DUL, 0x40117235UL, 0x5E1CB8A2UL, 0x5E59F68AUL, + 0xE2266B16UL, 0x8331A767UL, 0x7CE5A040UL, 0xA7DD8E74UL, + 0x82605046UL, 0xBC506172UL, 0x0E121E85UL, 0x11304761UL, + 0xDD85BE5CUL, 0xBF2D4B76UL, 0x61B69E36UL, 0xA22B58EDUL, + 0xB3F23FE7UL, 0xE1DB8AFCUL, 0x6DE606E2UL, 0x4203B72EUL, + 0x700AE372UL, 0x22662D97UL, 0x647E8AD8UL, 0x394F7918UL, + 0xB9717A59UL, 0x7FB1B5A1UL, 0xF4AD9AC9UL, 0x403F5CB5UL, + 0xC130B1AFUL, 0xD913640CUL, 0xA68F6920UL, 0x37C742F9UL, + 0x0C0F343DUL, 0x039E24C3UL, 0xA43329D1UL, 0x1D4FC93EUL, + 0xD2B774A4UL, 0xE6ECDFA4UL, 0x50F782DEUL, 0xD9BCC32CUL, + 0x2E132954UL, 0x880B875DUL, 0x7ACB9D11UL, 0x25A000CAUL, + 0x3515F508UL, 0x611B883EUL, 0x8FE9004FUL, 0x74E3B0DAUL, + 0xEC597682UL, 0x2E248D9EUL, 0xBDE4D3CCUL, 0xDEA0CFB2UL, + 0xFBCA7BD3UL, 0x4C0206F9UL, 0x92D09662UL, 0xB0F7D772UL, + 0xED891E9AUL, 0x14EA480AUL, 0xB1D4FF64UL, 0xF4375831UL, + 0x5AFB09C2UL, 0xC188454CUL, 0x2AC1D182UL, 0xC8C117D3UL, + 0x9EC3CD34UL, 0x17366CADUL, 0x03A87846UL, 0xC71E5F66UL, + 0x9226F4D5UL, 0x98BDDBEBUL, 0xD6F93CC5UL, 0xBF11FAEDUL, + 0x609649B4UL, 0xD19632B3UL, 0xEF557607UL, 0x0AC8FD47UL, + 0x995049CAUL, 0x73BC5ED7UL, 0x75B9074EUL, 0x374094EFUL, + 0xD7ECD061UL, 0xBD6DC736UL, 0xE3B9F85EUL, 0x3455F76DUL, + 0xA0016F76UL, 0xBC1DB747UL, 0x4003DB22UL, 0x22586EE0UL, + 0xF6BBF1EBUL, 0xB8227AF3UL, 0x78E126ABUL, 0xC6B413C5UL, + 0xF92AE295UL, 0x969F7D8EUL, 0xECE7839FUL, 0xF2811F31UL, + 0x35ED5CB5UL, 0x75C83725UL, 0x4614AB27UL, 0x0179A71CUL, + 0xC6C78665UL, 0x681DDAB0UL, 0x1D2B0B09UL, 0x577EBA9CUL, + 0x96C5A1B6UL, 0x462A0B83UL, 0x1E18D2F4UL, 0x334D3867UL, + 0x409329D9UL, 0xBE47CE95UL, 0x754FF4ADUL, 0xF3D7C990UL, + 0x91F0E9A1UL, 0x7486F9B3UL, 0x65296112UL, 0x69E13398UL, + 0x2A9F0BF4UL, 0x1A2A834CUL, 0x1638F87AUL, 0x54138AB6UL, + 0x53BDD8B5UL, 0x2D83C753UL, 0xE770B14EUL, 0x58A8506FUL, + 0x804457ACUL, 0x72FAB07CUL, 0x510566B6UL, 0xC403FC60UL, + 0xEB16E097UL, 0x001986ECUL, 0x30FFAFF5UL, 0xE0011522UL, + 0x923A1AEFUL, 0x6D55628AUL, 0xA58BF76DUL, 0xFA32CF4DUL, + 0xA57E36A8UL, 0x225DFDD4UL, 0x5F2EDC8FUL, 0xF48CAC1AUL, + 0x594F975FUL, 0x97D51E1DUL, 0xD739A2CDUL, 0x134CDD3BUL, + 0x3EF326EAUL, 0x4DE2B784UL, 0x94A3ACB2UL, 0xB31AA32FUL, + 0xE19EBB47UL, 0x28F80B82UL, 0x19606B42UL, 0xDEB519ACUL, + 0x2A5CA2C8UL, 0x941F5843UL, 0xE73F18E9UL, 0x616ADBAEUL, + 0xC2632062UL, 0x5CFD2F14UL, 0xB346BC60UL, 0xE0F1700AUL, + 0xF76E828AUL, 0x32CCC4EDUL, 0x94464CFFUL, 0xF3E36970UL, + 0x95B5B19DUL, 0xF30AF872UL, 0x871DF567UL, 0x27CDC1ABUL, + 0x045D82B8UL, 0x63553457UL, 0x7E522085UL, 0xFA00E8BDUL, + 0xC5241BFEUL, 0xFA8CFCFAUL, 0xF9A01C7AUL, 0x30CA3DF0UL, + 0x7E4264E4UL, 0x6437FFC9UL, 0xBFA77683UL, 0x0A92D424UL, + 0xC4196AC9UL, 0xD2854C55UL, 0x2DDEE8FCUL, 0x61C5F7CBUL, + 0xD61DCCABUL, 0xA1166856UL, 0x4D0B3FA9UL, 0x89BFAF02UL, + 0x11A4F036UL, 0x84F2C60AUL, 0xBDA4DE39UL, 0x8BA5889AUL, + 0xE5462908UL, 0x6E27FDD7UL, 0xC84CB5C8UL, 0x23F5BE25UL, + 0xA191268DUL, 0x9F00DBC5UL, 0x8093DC57UL, 0x285AAAD7UL, + 0x67B1E46EUL, 0xC10A02AAUL, 0x1C672264UL, 0xFA26FD63UL, + 0x57DA3982UL, 0x856509D1UL, 0x3346749DUL, 0xC7E826DCUL, + 0x25CBD94EUL, 0xD1201B3FUL, 0x7D8A44C3UL, 0x2F9D6B9EUL, + 0xE7B3824AUL, 0xEF3CAE74UL, 0x5244AEDCUL, 0x14CB27E6UL, + 0x72C34521UL, 0x7CE73151UL, 0x4AAD18F4UL, 0x02198D64UL, + 0x5812E873UL, 0x95BACD29UL, 0x3C95A998UL, 0xB0E2B8DAUL, + 0x18A72F1CUL, 0x9A190E08UL, 0x4102234AUL, 0x07109ADCUL, + 0xE8AD45B3UL, 0x801851E3UL, 0xC21F5ABBUL, 0x6D6CF2F5UL, + 0xDE2CC0F2UL, 0xC3206714UL, 0x1B42FAF8UL, 0x2F3EA2B7UL, + 0xB61ECEB4UL, 0xD5EB7091UL, 0x3A6AFE88UL, 0xD96F29CAUL, + 0x9020783BUL, 0xB3C78167UL, 0xA44B1A6CUL, 0x8F8DD09DUL, + 0xBB6EF9CFUL, 0x79879ADEUL, 0x5291E936UL, 0xCB5D7A6EUL, + 0x00861702UL, 0x72F289B6UL, 0x33949FA5UL, 0xC987111FUL, + }, + .mem = { + 0x4A15F141UL, 0x4FB84986UL, 0x4F575580UL, 0x359CF336UL, + 0xCC3518A7UL, 0x7B627467UL, 0x12616700UL, 0x9064F4BBUL, + 0x87BDB854UL, 0x95F7FED9UL, 0x54FC4DD6UL, 0x9D00978BUL, + 0x20A3B20FUL, 0x4334548CUL, 0xECD0252FUL, 0x4030D8C0UL, + 0x6E4A3695UL, 0x810CCDDEUL, 0x14730E2DUL, 0x2D7CED75UL, + 0x5507D5C7UL, 0xED8DD0D5UL, 0x6F928237UL, 0x96FB76A8UL, + 0x600AC89EUL, 0x56FD3355UL, 0x11788D24UL, 0x63645FBEUL, + 0x835634FEUL, 0x216310E7UL, 0x12BE624FUL, 0xA11B2F54UL, + 0x83AC0A81UL, 0xEDC852B8UL, 0x39066BEAUL, 0x4ED3AB9AUL, + 0xB8B3C6D4UL, 0x3223B8D4UL, 0x97B68A08UL, 0x5C8B2229UL, + 0x05EB5855UL, 0x7D7ADD8CUL, 0x2D19F9E3UL, 0xB573F6B8UL, + 0x1703653FUL, 0xD5D482F1UL, 0x50BCC180UL, 0x1AF18E0EUL, + 0xE8E48682UL, 0x5F07A0C1UL, 0x9643AEBDUL, 0x3546D827UL, + 0xE64C45B1UL, 0x3C8281BDUL, 0x0E7DF5E7UL, 0x814CABBFUL, + 0x79512CD4UL, 0x8D532C12UL, 0xD448D862UL, 0x0DD4EE4EUL, + 0x1BEC7306UL, 0x0DEFDEF8UL, 0x6AA1843CUL, 0x31ECD3A8UL, + 0x572D75B1UL, 0x37111F18UL, 0x32739AF5UL, 0xFE2E6403UL, + 0xA604D35DUL, 0x8A8201A8UL, 0x707F29E9UL, 0x906F5283UL, + 0xA3D647A7UL, 0x4537AC7AUL, 0xC8894E3CUL, 0x194C330AUL, + 0x35970FAAUL, 0xC06F2407UL, 0x65DAE40AUL, 0xD4B09BD9UL, + 0x09A50435UL, 0xF42C0E69UL, 0x06043378UL, 0x39523D4AUL, + 0x298F1AABUL, 0xA0CE3887UL, 0xC188C6BFUL, 0xA8B71F56UL, + 0xBECBEC55UL, 0x74EBD468UL, 0x97C39AD7UL, 0x07AA99D5UL, + 0x020649DDUL, 0xF4B513FEUL, 0xFA653AAEUL, 0x54278AC3UL, + 0xECF7F289UL, 0x7E57DB78UL, 0xD50970F0UL, 0x6B98F4FCUL, + 0xC8C48C05UL, 0x0D184056UL, 0x4BF7CCFEUL, 0xB3201C48UL, + 0x0896892EUL, 0xBADBFAA1UL, 0x44A95A1DUL, 0xB3E22215UL, + 0x6334EA5DUL, 0x136DF83FUL, 0x7A88C2C1UL, 0x865D2BD4UL, + 0x5753F437UL, 0x4A058C4DUL, 0x561A8AD2UL, 0x62F5F4BFUL, + 0xAF298E75UL, 0x8CC94424UL, 0x79695F77UL, 0xE913CA4FUL, + 0x1C72B0CCUL, 0xC4D77D31UL, 0x66DB3A62UL, 0xD27E63A4UL, + 0xB88A0863UL, 0x12DE4CFBUL, 0x2073FA2BUL, 0x936CD61DUL, + 0xF4B7A0B6UL, 0x8E2D84EEUL, 0x3DD28F36UL, 0xA0342CB6UL, + 0x1341BFCCUL, 0xE9776B5BUL, 0x1FCD0021UL, 0xA134C24CUL, + 0xB0F560F4UL, 0x123FA862UL, 0x8CF0EAFFUL, 0x52EA3F93UL, + 0x7713E5F9UL, 0x68AB2DACUL, 0x4D797CE5UL, 0xBA5BC382UL, + 0x49459C2AUL, 0xB74EA93BUL, 0x179FAD75UL, 0x1E4753A1UL, + 0x75CECF1DUL, 0x3815A499UL, 0x9444E0C5UL, 0xDF416704UL, + 0x45F71F08UL, 0x18E01C18UL, 0x2CDB31A3UL, 0x008599F3UL, + 0x7ECD74B4UL, 0x223AF86FUL, 0x0B224AEEUL, 0x7B00071EUL, + 0x4660A4F9UL, 0x1FBF6A03UL, 0xDB5D0F83UL, 0x6092DC96UL, + 0xD098DF2CUL, 0x70F21E04UL, 0x6F885349UL, 0xB67EAC28UL, + 0x079EB9E6UL, 0xF9A20C9EUL, 0xD73E299CUL, 0x7535E0AEUL, + 0x866398ECUL, 0xB7C3529EUL, 0xFE568343UL, 0x4950E38BUL, + 0xFCC1B135UL, 0x3A610542UL, 0xDFF5451BUL, 0x32FA22BCUL, + 0x0728A1D5UL, 0xFA7D4238UL, 0xB652687FUL, 0x932764E4UL, + 0xFBCCFFB7UL, 0x15410B80UL, 0xECA50EDDUL, 0x07A51948UL, + 0x6B47785FUL, 0xCBC0BB27UL, 0x2956623BUL, 0xB79E9F94UL, + 0xFE9DE3F7UL, 0x0F6B1328UL, 0x9DDCDEB2UL, 0xB2AECD08UL, + 0x88CE38CBUL, 0x9BD62FEDUL, 0x9FB73F17UL, 0xA153B164UL, + 0x7DA4AE9DUL, 0x7426982EUL, 0x49156803UL, 0x111FFCF7UL, + 0x4DD1B200UL, 0xA6378FB1UL, 0xEF22E8D6UL, 0x01C9F7BDUL, + 0x19B8F0EBUL, 0x3E01C0C4UL, 0xC9F25D9BUL, 0xAE73CC6AUL, + 0x3E6EB616UL, 0x52402A43UL, 0x902C6F7CUL, 0x782F7492UL, + 0x647FF515UL, 0x9DA6429AUL, 0xAF065DB0UL, 0x417D00C9UL, + 0x571DC9A5UL, 0x79A18D1AUL, 0xE8E70F30UL, 0xCFA6F74DUL, + 0xB1608327UL, 0x0631E802UL, 0x88A12E28UL, 0xAB00DEB7UL, + 0x3F82F3A0UL, 0x77EEC827UL, 0xFD988CBEUL, 0xDC8FA5CEUL, + 0xB1CF8DCEUL, 0xDDC6F5F2UL, 0xB29230E6UL, 0x42ECC2E2UL, + 0xF35E8A50UL, 0xDCA21800UL, 0x0A3BC071UL, 0x5C564059UL, + 0x68E0B3B7UL, 0x990DE98AUL, 0x52383C84UL, 0x5B49E462UL, + 0x991858FFUL, 0xE4A00026UL, 0xE7006EE6UL, 0x89D14DA3UL, + 0x8518D345UL, 0x7BF48382UL, 0x2A60F7E9UL, 0xEB34B41BUL, + 0xE599E4DEUL, 0xD96CD8F3UL, 0xAFC58217UL, 0x8D1D706AUL, + } +}; + static void test_init_zero_seed(void) { isaac_ctx_t ctx; @@ -164,7 +304,19 @@ static void test_init_zero_seed(void) atto_memeq(&ctx, &zero_initialised_ctx, sizeof(ctx)); } +static void test_init_nonzero_seed(void) +{ + isaac_ctx_t ctx; + const uint8_t seed[8] = {1, 2, 3, 4, 5, 6, 7, 8}; + + isaac_init(&ctx, seed, 8); + + atto_eq(sizeof(ctx), sizeof(nonzero_initialised_ctx)); + atto_memeq(&ctx, &nonzero_initialised_ctx, sizeof(ctx)); +} + void test_isaac_init(void) { test_init_zero_seed(); + test_init_nonzero_seed(); } From 053968e98404e85c2830b85c39d38b69add7826f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matjaz=CC=8C?= Date: Sun, 26 Apr 2020 23:17:35 +0200 Subject: [PATCH 12/27] Fix bug in non-zero seed init test --- inc/isaac.h | 4 ++-- src/isaac.c | 29 +++++++++++------------------ tst/original/generate.c | 2 +- tst/test_init.c | 2 +- 4 files changed, 15 insertions(+), 22 deletions(-) diff --git a/inc/isaac.h b/inc/isaac.h index 38b8cb3..8c6013b 100644 --- a/inc/isaac.h +++ b/inc/isaac.h @@ -55,8 +55,8 @@ typedef struct uint32_t a; uint32_t b; uint32_t c; - uint16_t next32_index; // cound be uint8 - uint16_t next8_index; // cound be uint8 + uint16_t next32_index; + uint16_t next8_index; } isaac_ctx_t; /** diff --git a/src/isaac.c b/src/isaac.c index 5e9d242..075d507 100644 --- a/src/isaac.c +++ b/src/isaac.c @@ -46,7 +46,7 @@ static void isaac_shuffle(isaac_ctx_t* ctx); void isaac_init(isaac_ctx_t* const ctx, const void* const seed, - const uint16_t seed_bytes) + uint16_t seed_bytes) { uint32_t a, b, c, d, e, f, g, h; unsigned int i; /* Fastest integer type */ @@ -59,27 +59,20 @@ void isaac_init(isaac_ctx_t* const ctx, { ISAAC_MIX(a, b, c, d, e, f, g, h); } - if (seed != NULL) + memset(ctx->result, 0, ISAAC_SEED_MAX_BYTES); + if (seed != NULL && seed_bytes > 0) { - /* Copy seed into result[] with zero-padding. */ - if (seed_bytes >= ISAAC_SEED_MAX_BYTES) + /* Copy seed into result[]. */ + if (seed_bytes > ISAAC_SEED_MAX_BYTES) { - memcpy(ctx->result, seed, ISAAC_SEED_MAX_BYTES); + seed_bytes = ISAAC_SEED_MAX_BYTES; } - else - { - memcpy(ctx->result, seed, seed_bytes); - memset(&ctx->result[seed_bytes], 0, ISAAC_SEED_MAX_BYTES - seed_bytes); - } - } - else - { - memset(&ctx->result[seed_bytes], 0, ISAAC_SEED_MAX_BYTES); + memcpy(ctx->result, seed, seed_bytes); } /* Initialise using the contents of result[] as the seed. */ for (i = 0; i < ISAAC_U32_ELEMENTS; i += 8) { - a += ctx->result[i]; + a += ctx->result[i + 0]; b += ctx->result[i + 1]; c += ctx->result[i + 2]; d += ctx->result[i + 3]; @@ -88,7 +81,7 @@ void isaac_init(isaac_ctx_t* const ctx, g += ctx->result[i + 6]; h += ctx->result[i + 7]; ISAAC_MIX(a, b, c, d, e, f, g, h); - ctx->mem[i] = a; + ctx->mem[i + 0] = a; ctx->mem[i + 1] = b; ctx->mem[i + 2] = c; ctx->mem[i + 3] = d; @@ -100,7 +93,7 @@ void isaac_init(isaac_ctx_t* const ctx, /* Do a second pass to make all of the seed affect all of ctx->mem. */ for (i = 0; i < ISAAC_U32_ELEMENTS; i += 8) { - a += ctx->mem[i]; + a += ctx->mem[i + 0]; b += ctx->mem[i + 1]; c += ctx->mem[i + 2]; d += ctx->mem[i + 3]; @@ -109,7 +102,7 @@ void isaac_init(isaac_ctx_t* const ctx, g += ctx->mem[i + 6]; h += ctx->mem[i + 7]; ISAAC_MIX(a, b, c, d, e, f, g, h); - ctx->mem[i] = a; + ctx->mem[i + 0] = a; ctx->mem[i + 1] = b; ctx->mem[i + 2] = c; ctx->mem[i + 3] = d; diff --git a/tst/original/generate.c b/tst/original/generate.c index a7a73c8..ef4ab10 100644 --- a/tst/original/generate.c +++ b/tst/original/generate.c @@ -70,7 +70,7 @@ static void ctx_nonzero_seed(void) { ctx.randrsl[i] = 0; // Zero padding } - randinit(&ctx, 1); // Init ISAAC with a non-zero seed + randinit(&ctx, 1); // Init ISAAC with a non-zero seed puts("Context with seed {1,2,3,4,5,6,7,8}:"); print_ctx(&ctx); } diff --git a/tst/test_init.c b/tst/test_init.c index 9b59423..5b96e70 100644 --- a/tst/test_init.c +++ b/tst/test_init.c @@ -152,7 +152,7 @@ const static isaac_ctx_t zero_initialised_ctx = { const static isaac_ctx_t nonzero_initialised_ctx = { .next32_index = ISAAC_U32_ELEMENTS - 1, - .next8_index = 0 - 1, + .next8_index = 0, .a = 0x3FCFDFDAUL, .b = 0xC987111FUL, .c = 0x00000001UL, From e36342a661a70d81c1d491bedb8f60d49b372fbf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matjaz=CC=8C?= Date: Sun, 26 Apr 2020 23:22:12 +0200 Subject: [PATCH 13/27] Add test for next8 with nonzero seed --- tst/test_next.c | 71 +++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 63 insertions(+), 8 deletions(-) diff --git a/tst/test_next.c b/tst/test_next.c index 9936c6e..a57a155 100644 --- a/tst/test_next.c +++ b/tst/test_next.c @@ -128,12 +128,12 @@ const static uint32_t expected_next_results[EXPECTED_NEXT_ELEMENTS] = { /* * This is the stream of uint32 values obtained by calling isaac_next() * repeatedly after the isaac_ctx_t has been initialised with a - * seed of {1,2,3,4,5,6,7,8} (in bytes, not uint32_t) + * seed of {1, 2, 3, 4, 5, 6, 7, 8} (in bytes, not uint32_t) * * In particular this is the value printed by next_values_nonzero_seed() * in generate.c */ -const static uint32_t expected_next32_with_seed_0102030405060708[EXPECTED_NEXT_ELEMENTS] = { +const static uint32_t expected_next32_with_nonzero_seed[EXPECTED_NEXT_ELEMENTS] = { 0xC987111FUL, 0x33949FA5UL, 0x72F289B6UL, 0x00861702UL, 0xCB5D7A6EUL, 0x5291E936UL, 0x79879ADEUL, 0xBB6EF9CFUL, 0x8F8DD09DUL, 0xA44B1A6CUL, 0xB3C78167UL, 0x9020783BUL, 0xD96F29CAUL, 0x3A6AFE88UL, 0xD5EB7091UL, @@ -267,7 +267,7 @@ static void test_next32_all(void) } } -static void test_next8_four_times(void) +static void test_next8_a_few(void) { isaac_ctx_t ctx; isaac_init(&ctx, NULL, 0); // Zero seed @@ -324,13 +324,13 @@ static void test_next32_a_few_with_nonzero_seed(void) uint32_t next; next = isaac_next32(&ctx); - atto_eq(next, expected_next32_with_seed_0102030405060708[0]); + atto_eq(next, expected_next32_with_nonzero_seed[0]); next = isaac_next32(&ctx); - atto_eq(next, expected_next32_with_seed_0102030405060708[1]); + atto_eq(next, expected_next32_with_nonzero_seed[1]); next = isaac_next32(&ctx); - atto_eq(next, expected_next32_with_seed_0102030405060708[2]); + atto_eq(next, expected_next32_with_nonzero_seed[2]); } static void test_next32_all_with_nonzero_seed(void) @@ -342,7 +342,60 @@ static void test_next32_all_with_nonzero_seed(void) for (uint_fast32_t i = 0; i < EXPECTED_NEXT_ELEMENTS; i++) { result = isaac_next32(&ctx); - atto_eq(result, expected_next32_with_seed_0102030405060708[i]); + atto_eq(result, expected_next32_with_nonzero_seed[i]); + } +} + +static void test_next8_a_few_with_nonzero_seed(void) +{ + isaac_ctx_t ctx; + const uint8_t seed[8] = {1, 2, 3, 4, 5, 6, 7, 8}; + isaac_init(&ctx, seed, 8); + uint8_t next; + + next = isaac_next8(&ctx); + atto_eq(next, (expected_next32_with_nonzero_seed[0] >> 0U) & 0xFFU); + next = isaac_next8(&ctx); + atto_eq(next, (expected_next32_with_nonzero_seed[0] >> 8U) & 0xFFU); + next = isaac_next8(&ctx); + atto_eq(next, (expected_next32_with_nonzero_seed[0] >> 16U) & 0xFFU); + next = isaac_next8(&ctx); + atto_eq(next, (expected_next32_with_nonzero_seed[0] >> 24U) & 0xFFU); + + next = isaac_next8(&ctx); + atto_eq(next, (expected_next32_with_nonzero_seed[1] >> 0U) & 0xFFU); + next = isaac_next8(&ctx); + atto_eq(next, (expected_next32_with_nonzero_seed[1] >> 8U) & 0xFFU); + next = isaac_next8(&ctx); + atto_eq(next, (expected_next32_with_nonzero_seed[1] >> 16U) & 0xFFU); + next = isaac_next8(&ctx); + atto_eq(next, (expected_next32_with_nonzero_seed[1] >> 24U) & 0xFFU); + + next = isaac_next8(&ctx); + atto_eq(next, (expected_next32_with_nonzero_seed[2] >> 0U) & 0xFFU); + next = isaac_next8(&ctx); + atto_eq(next, (expected_next32_with_nonzero_seed[2] >> 8U) & 0xFFU); + next = isaac_next8(&ctx); + atto_eq(next, (expected_next32_with_nonzero_seed[2] >> 16U) & 0xFFU); + next = isaac_next8(&ctx); + atto_eq(next, (expected_next32_with_nonzero_seed[2] >> 24U) & 0xFFU); +} + +static void test_next8_all_with_nonzero_seed(void) +{ + uint8_t result; + isaac_ctx_t ctx; + const uint8_t seed[8] = {1, 2, 3, 4, 5, 6, 7, 8}; + isaac_init(&ctx, seed, 8); + for (uint_fast16_t i = 0; i < EXPECTED_NEXT_ELEMENTS; i++) + { + for (uint_fast8_t byte = 0; byte < 4; byte++) + { + result = isaac_next8(&ctx); + atto_eq(result, + (expected_next32_with_nonzero_seed[i] >> byte * 8U) & + 0xFFU); + } } } @@ -350,8 +403,10 @@ void test_isaac_next(void) { test_next32_a_few(); test_next32_all(); - test_next8_four_times(); + test_next8_a_few(); test_next8_all(); test_next32_a_few_with_nonzero_seed(); test_next32_all_with_nonzero_seed(); + test_next8_a_few_with_nonzero_seed(); + test_next8_all_with_nonzero_seed(); } From 5a809e73c06e7b085225a50e55c49483aba12490 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matjaz=CC=8C?= Date: Mon, 27 Apr 2020 16:29:18 +0200 Subject: [PATCH 14/27] Implement seed copy value-wise rather than byte-wise The idea is to avoid issues with endianness as a 256 byte (not bit) seed is anyway more than enough for anyone. More details in the doxygen of the isaac_seed() function. Test it against the reference implementation as well. --- inc/isaac.h | 29 +++-- src/isaac.c | 74 +++++++++--- tst/original/generate.c | 12 +- tst/test_init.c | 260 ++++++++++++++++++++-------------------- tst/test_next.c | 206 +++++++++++++++---------------- 5 files changed, 316 insertions(+), 265 deletions(-) diff --git a/inc/isaac.h b/inc/isaac.h index 8c6013b..21f51e6 100644 --- a/inc/isaac.h +++ b/inc/isaac.h @@ -1,8 +1,8 @@ /** * @file * - * ISAAC, the fast cryptographic pseudo random number generator (CPRNG) wrapped - * into a C11, modern, documented API and package. Quoting from its + * ISAAC, the fast cryptographic pseudo random number generator (CPRNG), wrapped + * into a modern, C11, documented API and package. Quoting from its * [web page](https://www.burtleburtle.net/bob/rand/isaacafa.html): * * > ISAAC (Indirection, Shift, Accumulate, Add, and Count) generates 32-bit @@ -32,7 +32,7 @@ extern "C" #endif /** - * Version of the isaac.h API using semantic versioning. + * Version of the LibISAAC API using semantic versioning. */ #define LIBISAAC_VERSION "1.0.0" @@ -40,8 +40,7 @@ extern "C" #include #define ISAAC_U32_ELEMENTS 256U -#define ISAAC_U8_ELEMENTS (ISAAC_U32_ELEMENTS * sizeof(uint32_t)) -#define ISAAC_SEED_MAX_BYTES ISAAC_U8_ELEMENTS +#define ISAAC_SEED_MAX_BYTES ISAAC_U32_ELEMENTS /** * Context of the ISAAC CPRNG. @@ -62,8 +61,24 @@ typedef struct /** * Initialises the ISAAC CPRNG with a seed. * + * The seed is copied value-wise into the ISAAC state, not byte-wise. That + * means that a uint8_t array {1,2,3,4} is copied into the ctx->result[] + * uint32_t array as {1,2,3,4,0,...,0}, where each value is a uint32_t value. + * Looking at the bytes and assuming little Endian byte order, the result is + * {1,2,3,4} --> {1,0,0,0,2,0,0,0,3,0,0,0,4,0,0,0,0,...,0}. + * + * The reason behind this choice is to avoid issues with endianness; as ISAAC + * works on uint32_t values rather than their bytes, setting the uint32_t values + * and not their bytes, shall produce the same CPRNG stream on architectures + * with different endianness. A uint32_t* could also be a valid choice as seed + * input, but seeds are usually cryptographic keys and those are byte arrays, + * so a developer could be confused on how to insert a uint8_t* seed into + * a uint32_t*. + * * Maps to `void randinit(randctx *r, word flag)` from the original - * implementation. + * implementation. Equivalent to a true `flag` with a seed provided. The + * false `flag` is not available, as it should not be used for security + * purposes. * * @warning * Failing to provide a seed (NULL or long 0 bytes), will make the whole CSPRNG @@ -83,7 +98,7 @@ typedef struct * - If < #ISAAC_SEED_MAX_BYTES, then the provided bytes will be used and the * rest will be zero-padded. */ -void isaac_init(isaac_ctx_t* ctx, const void* seed, uint16_t seed_bytes); +void isaac_init(isaac_ctx_t* ctx, const uint8_t* seed, uint16_t seed_bytes); /** * Provides the next pseudo-random 32-bit integer. diff --git a/src/isaac.c b/src/isaac.c index 075d507..4b1de7c 100644 --- a/src/isaac.c +++ b/src/isaac.c @@ -44,31 +44,24 @@ static void isaac_shuffle(isaac_ctx_t* ctx); +static void set_seed(isaac_ctx_t* ctx, + const uint8_t* seed, + uint16_t seed_bytes); + void isaac_init(isaac_ctx_t* const ctx, - const void* const seed, - uint16_t seed_bytes) + const uint8_t* const seed, + const uint16_t seed_bytes) { uint32_t a, b, c, d, e, f, g, h; - unsigned int i; /* Fastest integer type */ - + uint_fast16_t i; /* Fastest index over elements in result[] and mem[]. */ ctx->a = ctx->b = ctx->c = 0; a = b = c = d = e = f = g = h = GOLDEN_RATIO; - /* Scramble it */ for (i = 0; i < 4; i++) { ISAAC_MIX(a, b, c, d, e, f, g, h); } - memset(ctx->result, 0, ISAAC_SEED_MAX_BYTES); - if (seed != NULL && seed_bytes > 0) - { - /* Copy seed into result[]. */ - if (seed_bytes > ISAAC_SEED_MAX_BYTES) - { - seed_bytes = ISAAC_SEED_MAX_BYTES; - } - memcpy(ctx->result, seed, seed_bytes); - } + set_seed(ctx, seed, seed_bytes); /* Initialise using the contents of result[] as the seed. */ for (i = 0; i < ISAAC_U32_ELEMENTS; i += 8) { @@ -113,13 +106,55 @@ void isaac_init(isaac_ctx_t* const ctx, } /* Fill in the first set of results. */ isaac_shuffle(ctx); - /* Prepare to use the first set of results. */ + /* Prepare to use the first set of results with next32() and next8(). */ ctx->next32_index = ISAAC_U32_ELEMENTS - 1; ctx->next8_index = 0; } -/* +/** + * @internal + * Copies the seed into ctx->result[], padding it with zeros. + * + * @param ctx the ISAAC state + * @param seed bytes of the seed. If NULL, a zero-seed is used. + * @param seed_bytes amount of bytes in the seed. + */ +static void set_seed(isaac_ctx_t* const ctx, + const uint8_t* const seed, + uint16_t seed_bytes) +{ + uint_fast16_t i; + if (seed != NULL) + { + if (seed_bytes > ISAAC_SEED_MAX_BYTES) + { + seed_bytes = ISAAC_SEED_MAX_BYTES; + } + for (i = 0; i < seed_bytes; i++) + { + /* The copy is performed VALUE-wise, not byte wise. + * By doing so we have same result[] on architectures with different + * endianness. */ + ctx->result[i] = seed[i]; + } + } + else + { + seed_bytes = 0; + } + for (i = seed_bytes; i < ISAAC_SEED_MAX_BYTES; i++) + { + ctx->result[i] = 0; + } +} + +/** + * @internal + * Permutes the ISAAC state. + * * Maps to `void isaac(randctx*)` from the original implementation. + * + * @param ctx the ISAAC state */ static void isaac_shuffle(isaac_ctx_t* const ctx) { @@ -167,10 +202,11 @@ uint32_t isaac_next32(isaac_ctx_t* const ctx) return next32; } -/* We read the same next32 value 4 times and extract 4 different bytes from - * it, one per next8 call. */ + uint8_t isaac_next8(isaac_ctx_t* const ctx) { + /* We read the same next32 value 4 times and extract 4 different bytes from + * it, one per next8 call. */ const uint8_t next8 = (uint8_t) ( ctx->result[ctx->next32_index] >> ctx->next8_index * 8U ); diff --git a/tst/original/generate.c b/tst/original/generate.c index ef4ab10..7311f48 100644 --- a/tst/original/generate.c +++ b/tst/original/generate.c @@ -64,9 +64,9 @@ static void ctx_nonzero_seed(void) unsigned long int i; for (i = 0; i < 8; i++) { - ((unsigned char*) ctx.randrsl)[i] = seed[i]; + ctx.randrsl[i] = seed[i]; // Value-wise copy, not byte-wise } - for (i = 2; i < 256; i++) + for (i = 8; i < 256; i++) { ctx.randrsl[i] = 0; // Zero padding } @@ -84,7 +84,7 @@ static void next_values_zero_seed(void) { ctx.randrsl[i] = 0; // Zero seed } - randinit(&ctx, 1); // Init ISAAC with zero seed + randinit(&ctx, 1); // Init ISAAC with zero seed puts("Running next() 512 times with zero seed"); for (i = 0; i < 512; i++) { @@ -102,13 +102,13 @@ static void next_values_nonzero_seed(void) const unsigned char seed[8] = {1, 2, 3, 4, 5, 6, 7, 8}; for (i = 0; i < 8; i++) { - ((unsigned char*) ctx.randrsl)[i] = seed[i]; + ctx.randrsl[i] = seed[i]; // Value-wise copy, not byte-wise } - for (i = 2; i < 256; i++) + for (i = 8; i < 256; i++) { ctx.randrsl[i] = 0; // Zero padding } - randinit(&ctx, 1); // Init ISAAC with non-zero seed + randinit(&ctx, 1); // Init ISAAC with non-zero seed puts("Running next() 512 times with non-zero seed"); for (i = 0; i < 512; i++) { diff --git a/tst/test_init.c b/tst/test_init.c index 5b96e70..2a7b387 100644 --- a/tst/test_init.c +++ b/tst/test_init.c @@ -153,140 +153,140 @@ const static isaac_ctx_t zero_initialised_ctx = { const static isaac_ctx_t nonzero_initialised_ctx = { .next32_index = ISAAC_U32_ELEMENTS - 1, .next8_index = 0, - .a = 0x3FCFDFDAUL, - .b = 0xC987111FUL, + .a = 0xD131EDD6UL, + .b = 0x23956226UL, .c = 0x00000001UL, .result = { - 0x971CD9C6UL, 0xC1FF8E2CUL, 0x0790D1E5UL, 0x42183AB9UL, - 0xF795B85DUL, 0x40117235UL, 0x5E1CB8A2UL, 0x5E59F68AUL, - 0xE2266B16UL, 0x8331A767UL, 0x7CE5A040UL, 0xA7DD8E74UL, - 0x82605046UL, 0xBC506172UL, 0x0E121E85UL, 0x11304761UL, - 0xDD85BE5CUL, 0xBF2D4B76UL, 0x61B69E36UL, 0xA22B58EDUL, - 0xB3F23FE7UL, 0xE1DB8AFCUL, 0x6DE606E2UL, 0x4203B72EUL, - 0x700AE372UL, 0x22662D97UL, 0x647E8AD8UL, 0x394F7918UL, - 0xB9717A59UL, 0x7FB1B5A1UL, 0xF4AD9AC9UL, 0x403F5CB5UL, - 0xC130B1AFUL, 0xD913640CUL, 0xA68F6920UL, 0x37C742F9UL, - 0x0C0F343DUL, 0x039E24C3UL, 0xA43329D1UL, 0x1D4FC93EUL, - 0xD2B774A4UL, 0xE6ECDFA4UL, 0x50F782DEUL, 0xD9BCC32CUL, - 0x2E132954UL, 0x880B875DUL, 0x7ACB9D11UL, 0x25A000CAUL, - 0x3515F508UL, 0x611B883EUL, 0x8FE9004FUL, 0x74E3B0DAUL, - 0xEC597682UL, 0x2E248D9EUL, 0xBDE4D3CCUL, 0xDEA0CFB2UL, - 0xFBCA7BD3UL, 0x4C0206F9UL, 0x92D09662UL, 0xB0F7D772UL, - 0xED891E9AUL, 0x14EA480AUL, 0xB1D4FF64UL, 0xF4375831UL, - 0x5AFB09C2UL, 0xC188454CUL, 0x2AC1D182UL, 0xC8C117D3UL, - 0x9EC3CD34UL, 0x17366CADUL, 0x03A87846UL, 0xC71E5F66UL, - 0x9226F4D5UL, 0x98BDDBEBUL, 0xD6F93CC5UL, 0xBF11FAEDUL, - 0x609649B4UL, 0xD19632B3UL, 0xEF557607UL, 0x0AC8FD47UL, - 0x995049CAUL, 0x73BC5ED7UL, 0x75B9074EUL, 0x374094EFUL, - 0xD7ECD061UL, 0xBD6DC736UL, 0xE3B9F85EUL, 0x3455F76DUL, - 0xA0016F76UL, 0xBC1DB747UL, 0x4003DB22UL, 0x22586EE0UL, - 0xF6BBF1EBUL, 0xB8227AF3UL, 0x78E126ABUL, 0xC6B413C5UL, - 0xF92AE295UL, 0x969F7D8EUL, 0xECE7839FUL, 0xF2811F31UL, - 0x35ED5CB5UL, 0x75C83725UL, 0x4614AB27UL, 0x0179A71CUL, - 0xC6C78665UL, 0x681DDAB0UL, 0x1D2B0B09UL, 0x577EBA9CUL, - 0x96C5A1B6UL, 0x462A0B83UL, 0x1E18D2F4UL, 0x334D3867UL, - 0x409329D9UL, 0xBE47CE95UL, 0x754FF4ADUL, 0xF3D7C990UL, - 0x91F0E9A1UL, 0x7486F9B3UL, 0x65296112UL, 0x69E13398UL, - 0x2A9F0BF4UL, 0x1A2A834CUL, 0x1638F87AUL, 0x54138AB6UL, - 0x53BDD8B5UL, 0x2D83C753UL, 0xE770B14EUL, 0x58A8506FUL, - 0x804457ACUL, 0x72FAB07CUL, 0x510566B6UL, 0xC403FC60UL, - 0xEB16E097UL, 0x001986ECUL, 0x30FFAFF5UL, 0xE0011522UL, - 0x923A1AEFUL, 0x6D55628AUL, 0xA58BF76DUL, 0xFA32CF4DUL, - 0xA57E36A8UL, 0x225DFDD4UL, 0x5F2EDC8FUL, 0xF48CAC1AUL, - 0x594F975FUL, 0x97D51E1DUL, 0xD739A2CDUL, 0x134CDD3BUL, - 0x3EF326EAUL, 0x4DE2B784UL, 0x94A3ACB2UL, 0xB31AA32FUL, - 0xE19EBB47UL, 0x28F80B82UL, 0x19606B42UL, 0xDEB519ACUL, - 0x2A5CA2C8UL, 0x941F5843UL, 0xE73F18E9UL, 0x616ADBAEUL, - 0xC2632062UL, 0x5CFD2F14UL, 0xB346BC60UL, 0xE0F1700AUL, - 0xF76E828AUL, 0x32CCC4EDUL, 0x94464CFFUL, 0xF3E36970UL, - 0x95B5B19DUL, 0xF30AF872UL, 0x871DF567UL, 0x27CDC1ABUL, - 0x045D82B8UL, 0x63553457UL, 0x7E522085UL, 0xFA00E8BDUL, - 0xC5241BFEUL, 0xFA8CFCFAUL, 0xF9A01C7AUL, 0x30CA3DF0UL, - 0x7E4264E4UL, 0x6437FFC9UL, 0xBFA77683UL, 0x0A92D424UL, - 0xC4196AC9UL, 0xD2854C55UL, 0x2DDEE8FCUL, 0x61C5F7CBUL, - 0xD61DCCABUL, 0xA1166856UL, 0x4D0B3FA9UL, 0x89BFAF02UL, - 0x11A4F036UL, 0x84F2C60AUL, 0xBDA4DE39UL, 0x8BA5889AUL, - 0xE5462908UL, 0x6E27FDD7UL, 0xC84CB5C8UL, 0x23F5BE25UL, - 0xA191268DUL, 0x9F00DBC5UL, 0x8093DC57UL, 0x285AAAD7UL, - 0x67B1E46EUL, 0xC10A02AAUL, 0x1C672264UL, 0xFA26FD63UL, - 0x57DA3982UL, 0x856509D1UL, 0x3346749DUL, 0xC7E826DCUL, - 0x25CBD94EUL, 0xD1201B3FUL, 0x7D8A44C3UL, 0x2F9D6B9EUL, - 0xE7B3824AUL, 0xEF3CAE74UL, 0x5244AEDCUL, 0x14CB27E6UL, - 0x72C34521UL, 0x7CE73151UL, 0x4AAD18F4UL, 0x02198D64UL, - 0x5812E873UL, 0x95BACD29UL, 0x3C95A998UL, 0xB0E2B8DAUL, - 0x18A72F1CUL, 0x9A190E08UL, 0x4102234AUL, 0x07109ADCUL, - 0xE8AD45B3UL, 0x801851E3UL, 0xC21F5ABBUL, 0x6D6CF2F5UL, - 0xDE2CC0F2UL, 0xC3206714UL, 0x1B42FAF8UL, 0x2F3EA2B7UL, - 0xB61ECEB4UL, 0xD5EB7091UL, 0x3A6AFE88UL, 0xD96F29CAUL, - 0x9020783BUL, 0xB3C78167UL, 0xA44B1A6CUL, 0x8F8DD09DUL, - 0xBB6EF9CFUL, 0x79879ADEUL, 0x5291E936UL, 0xCB5D7A6EUL, - 0x00861702UL, 0x72F289B6UL, 0x33949FA5UL, 0xC987111FUL, + 0x953A7425UL, 0x7864DE8DUL, 0x40B4E071UL, 0xE3789964UL, + 0x3DF06B31UL, 0x2E653888UL, 0x38777CFEUL, 0xE13F9A4DUL, + 0xFF344EA9UL, 0x23D46470UL, 0x7C3837D3UL, 0xDBA2B1A6UL, + 0x3CCC8D13UL, 0x1E8365A1UL, 0x525D5B72UL, 0x41B38BA2UL, + 0x3B8BBF4DUL, 0x3C02CD0EUL, 0xB9E5E431UL, 0x1A657203UL, + 0xB33F34D2UL, 0x11C078D1UL, 0x49529EB0UL, 0x20D2C863UL, + 0x62CBE77EUL, 0x7BB3B391UL, 0x60ADDF8FUL, 0x21A7B79BUL, + 0x5F12277FUL, 0x6DFF5D0FUL, 0xF660CB52UL, 0xF495799AUL, + 0x3500511CUL, 0xFFCC9D0DUL, 0x39C15C5EUL, 0xF9B83492UL, + 0xAF408615UL, 0x893CBE90UL, 0x67C5264BUL, 0x97F7A9C8UL, + 0x3FC3A488UL, 0x2763BF0CUL, 0x2B0DA294UL, 0x8DB85D64UL, + 0x919F5B18UL, 0xCDE1EDBDUL, 0xA00F02A2UL, 0x37EB562FUL, + 0xF2C72AB0UL, 0x0532FB9BUL, 0x0DD6E029UL, 0xE6C61DADUL, + 0x0315E9C0UL, 0xE6F63522UL, 0xFE945574UL, 0x99CE6B82UL, + 0x81E5CC75UL, 0xE2DD2B60UL, 0x584B13E5UL, 0xBB6ABA64UL, + 0x9A1B7282UL, 0xBFB9E202UL, 0x2F199C58UL, 0xCE3B407BUL, + 0xF38B6968UL, 0x52F5DD57UL, 0xB3E2535AUL, 0x00CDFEDAUL, + 0xF8C5F834UL, 0x79140B9BUL, 0x686C382CUL, 0xC52E6B7AUL, + 0xAE028C9BUL, 0xE6E11073UL, 0x2950EE3EUL, 0x0AEF3B0DUL, + 0xB37693D1UL, 0xD13B506AUL, 0x09359360UL, 0x629BCEC3UL, + 0x2EECCD6BUL, 0xF2D499F3UL, 0xD5A20325UL, 0xC6104017UL, + 0x1580045AUL, 0xFD87ACA3UL, 0x4E859A2CUL, 0x5066E4A3UL, + 0x246D45A6UL, 0xC2BF97E0UL, 0xCF62EBD5UL, 0xD6617C47UL, + 0x3B0F2F18UL, 0x8C21D6A3UL, 0x940568A0UL, 0x80FA85E3UL, + 0x42BAE3AFUL, 0x62928BBBUL, 0x91474D54UL, 0xFD0356D6UL, + 0xB855EDD5UL, 0x4AFC5002UL, 0xDEB54D1FUL, 0x36A95AFFUL, + 0x9F11F572UL, 0x7B6EEFDCUL, 0xF385BB7FUL, 0x0F07ED2BUL, + 0xA903AAE9UL, 0x04B020B7UL, 0x43D13242UL, 0x86EC53A7UL, + 0x45A76DCEUL, 0x79AB9CF2UL, 0xC29A190CUL, 0x23C03C70UL, + 0x910E46B2UL, 0xE6C73EB6UL, 0xDA3B78CDUL, 0xB4AE30F3UL, + 0x484A0CE8UL, 0xB74DE086UL, 0x5092A1A2UL, 0x2B8A286BUL, + 0xB5700F3AUL, 0x05CF8AC6UL, 0x0076F1F8UL, 0x61F3E920UL, + 0x18543E12UL, 0xA627343DUL, 0x0DBF5471UL, 0x31703EB0UL, + 0x5D4FD5E5UL, 0xBA39E19FUL, 0xB4D2939DUL, 0x9D330411UL, + 0x327741D7UL, 0xFCC9512CUL, 0x265BE277UL, 0xAB0399C9UL, + 0x7353E11CUL, 0x6C80F470UL, 0x126E12E5UL, 0x76F5BECAUL, + 0x7D856AF1UL, 0x1B7BDD70UL, 0x74FD76C8UL, 0x6076530BUL, + 0x8E0A13ACUL, 0xBB58FC69UL, 0xCDEDC3BCUL, 0xDC1F5DD4UL, + 0xE89DC0C9UL, 0x04AF4A7AUL, 0x768D44E0UL, 0x69C37A6FUL, + 0x34303E4CUL, 0xC5EFF0AFUL, 0x47F98DB2UL, 0x0BB4FC08UL, + 0x82C960C7UL, 0xD6C2572AUL, 0x797B8919UL, 0x01385B37UL, + 0x7FF40241UL, 0x0027F31CUL, 0x554E6275UL, 0x4CA2C7D2UL, + 0x961C8CBEUL, 0xFBE0A6E4UL, 0xB47ECCD6UL, 0xC98EACECUL, + 0xD889EFEFUL, 0x9EB538D6UL, 0x544E0EFAUL, 0x032C2A28UL, + 0xFF72B1F8UL, 0xE172AD89UL, 0xE5FA4583UL, 0x98DE0CA2UL, + 0x532CD994UL, 0xDBEB6C64UL, 0x8741EC19UL, 0x3C2FD293UL, + 0xA2E3FD84UL, 0x0EC205BFUL, 0x8B59DD25UL, 0x4F673CDEUL, + 0xB480EF7DUL, 0x9B66E6AAUL, 0xFF3D3663UL, 0xED9683A4UL, + 0x9FD07C61UL, 0x5F3F4788UL, 0xBD47F5A8UL, 0x9C80D3FDUL, + 0x1D9ABC53UL, 0x2807AA6CUL, 0x424748B0UL, 0xD94B043EUL, + 0x19E4169FUL, 0x377C8E8FUL, 0xFD8B4308UL, 0x7ABAB891UL, + 0x48048BC8UL, 0x01277E65UL, 0xE1307B9EUL, 0x715266D8UL, + 0xBB28F7F9UL, 0x72CB5E56UL, 0xE96231BCUL, 0x313B191FUL, + 0x0341975CUL, 0xF7D26163UL, 0x6BA120C4UL, 0x90126434UL, + 0x8EDFB785UL, 0x82782882UL, 0xBDEBE62AUL, 0x0ABE8344UL, + 0xE6F53EEFUL, 0x0B10807FUL, 0x921D9AFBUL, 0x193D85F3UL, + 0xE05C4F99UL, 0x20A41472UL, 0x7A07619FUL, 0xCCCC97F0UL, + 0x677E9BD8UL, 0xB881AC9FUL, 0x0A040BBAUL, 0x96CCC60DUL, + 0x95104798UL, 0x89C2C933UL, 0xF5F8CA46UL, 0xD87221CDUL, + 0x401EB5D1UL, 0x4F022DDAUL, 0x4DE25414UL, 0x3FF7BF83UL, + 0x0D50B3C2UL, 0x3EAF2975UL, 0x342846F3UL, 0xB7A31E4FUL, + 0x01B103BDUL, 0x4A03FAD4UL, 0x3258B530UL, 0x6F7B8DCDUL, + 0xAEEB9340UL, 0xB23790CFUL, 0xB4F5C36AUL, 0xD8B699F5UL, + 0x8175D70DUL, 0x3EA230EBUL, 0xA9E1CEBFUL, 0x23956226UL, }, .mem = { - 0x4A15F141UL, 0x4FB84986UL, 0x4F575580UL, 0x359CF336UL, - 0xCC3518A7UL, 0x7B627467UL, 0x12616700UL, 0x9064F4BBUL, - 0x87BDB854UL, 0x95F7FED9UL, 0x54FC4DD6UL, 0x9D00978BUL, - 0x20A3B20FUL, 0x4334548CUL, 0xECD0252FUL, 0x4030D8C0UL, - 0x6E4A3695UL, 0x810CCDDEUL, 0x14730E2DUL, 0x2D7CED75UL, - 0x5507D5C7UL, 0xED8DD0D5UL, 0x6F928237UL, 0x96FB76A8UL, - 0x600AC89EUL, 0x56FD3355UL, 0x11788D24UL, 0x63645FBEUL, - 0x835634FEUL, 0x216310E7UL, 0x12BE624FUL, 0xA11B2F54UL, - 0x83AC0A81UL, 0xEDC852B8UL, 0x39066BEAUL, 0x4ED3AB9AUL, - 0xB8B3C6D4UL, 0x3223B8D4UL, 0x97B68A08UL, 0x5C8B2229UL, - 0x05EB5855UL, 0x7D7ADD8CUL, 0x2D19F9E3UL, 0xB573F6B8UL, - 0x1703653FUL, 0xD5D482F1UL, 0x50BCC180UL, 0x1AF18E0EUL, - 0xE8E48682UL, 0x5F07A0C1UL, 0x9643AEBDUL, 0x3546D827UL, - 0xE64C45B1UL, 0x3C8281BDUL, 0x0E7DF5E7UL, 0x814CABBFUL, - 0x79512CD4UL, 0x8D532C12UL, 0xD448D862UL, 0x0DD4EE4EUL, - 0x1BEC7306UL, 0x0DEFDEF8UL, 0x6AA1843CUL, 0x31ECD3A8UL, - 0x572D75B1UL, 0x37111F18UL, 0x32739AF5UL, 0xFE2E6403UL, - 0xA604D35DUL, 0x8A8201A8UL, 0x707F29E9UL, 0x906F5283UL, - 0xA3D647A7UL, 0x4537AC7AUL, 0xC8894E3CUL, 0x194C330AUL, - 0x35970FAAUL, 0xC06F2407UL, 0x65DAE40AUL, 0xD4B09BD9UL, - 0x09A50435UL, 0xF42C0E69UL, 0x06043378UL, 0x39523D4AUL, - 0x298F1AABUL, 0xA0CE3887UL, 0xC188C6BFUL, 0xA8B71F56UL, - 0xBECBEC55UL, 0x74EBD468UL, 0x97C39AD7UL, 0x07AA99D5UL, - 0x020649DDUL, 0xF4B513FEUL, 0xFA653AAEUL, 0x54278AC3UL, - 0xECF7F289UL, 0x7E57DB78UL, 0xD50970F0UL, 0x6B98F4FCUL, - 0xC8C48C05UL, 0x0D184056UL, 0x4BF7CCFEUL, 0xB3201C48UL, - 0x0896892EUL, 0xBADBFAA1UL, 0x44A95A1DUL, 0xB3E22215UL, - 0x6334EA5DUL, 0x136DF83FUL, 0x7A88C2C1UL, 0x865D2BD4UL, - 0x5753F437UL, 0x4A058C4DUL, 0x561A8AD2UL, 0x62F5F4BFUL, - 0xAF298E75UL, 0x8CC94424UL, 0x79695F77UL, 0xE913CA4FUL, - 0x1C72B0CCUL, 0xC4D77D31UL, 0x66DB3A62UL, 0xD27E63A4UL, - 0xB88A0863UL, 0x12DE4CFBUL, 0x2073FA2BUL, 0x936CD61DUL, - 0xF4B7A0B6UL, 0x8E2D84EEUL, 0x3DD28F36UL, 0xA0342CB6UL, - 0x1341BFCCUL, 0xE9776B5BUL, 0x1FCD0021UL, 0xA134C24CUL, - 0xB0F560F4UL, 0x123FA862UL, 0x8CF0EAFFUL, 0x52EA3F93UL, - 0x7713E5F9UL, 0x68AB2DACUL, 0x4D797CE5UL, 0xBA5BC382UL, - 0x49459C2AUL, 0xB74EA93BUL, 0x179FAD75UL, 0x1E4753A1UL, - 0x75CECF1DUL, 0x3815A499UL, 0x9444E0C5UL, 0xDF416704UL, - 0x45F71F08UL, 0x18E01C18UL, 0x2CDB31A3UL, 0x008599F3UL, - 0x7ECD74B4UL, 0x223AF86FUL, 0x0B224AEEUL, 0x7B00071EUL, - 0x4660A4F9UL, 0x1FBF6A03UL, 0xDB5D0F83UL, 0x6092DC96UL, - 0xD098DF2CUL, 0x70F21E04UL, 0x6F885349UL, 0xB67EAC28UL, - 0x079EB9E6UL, 0xF9A20C9EUL, 0xD73E299CUL, 0x7535E0AEUL, - 0x866398ECUL, 0xB7C3529EUL, 0xFE568343UL, 0x4950E38BUL, - 0xFCC1B135UL, 0x3A610542UL, 0xDFF5451BUL, 0x32FA22BCUL, - 0x0728A1D5UL, 0xFA7D4238UL, 0xB652687FUL, 0x932764E4UL, - 0xFBCCFFB7UL, 0x15410B80UL, 0xECA50EDDUL, 0x07A51948UL, - 0x6B47785FUL, 0xCBC0BB27UL, 0x2956623BUL, 0xB79E9F94UL, - 0xFE9DE3F7UL, 0x0F6B1328UL, 0x9DDCDEB2UL, 0xB2AECD08UL, - 0x88CE38CBUL, 0x9BD62FEDUL, 0x9FB73F17UL, 0xA153B164UL, - 0x7DA4AE9DUL, 0x7426982EUL, 0x49156803UL, 0x111FFCF7UL, - 0x4DD1B200UL, 0xA6378FB1UL, 0xEF22E8D6UL, 0x01C9F7BDUL, - 0x19B8F0EBUL, 0x3E01C0C4UL, 0xC9F25D9BUL, 0xAE73CC6AUL, - 0x3E6EB616UL, 0x52402A43UL, 0x902C6F7CUL, 0x782F7492UL, - 0x647FF515UL, 0x9DA6429AUL, 0xAF065DB0UL, 0x417D00C9UL, - 0x571DC9A5UL, 0x79A18D1AUL, 0xE8E70F30UL, 0xCFA6F74DUL, - 0xB1608327UL, 0x0631E802UL, 0x88A12E28UL, 0xAB00DEB7UL, - 0x3F82F3A0UL, 0x77EEC827UL, 0xFD988CBEUL, 0xDC8FA5CEUL, - 0xB1CF8DCEUL, 0xDDC6F5F2UL, 0xB29230E6UL, 0x42ECC2E2UL, - 0xF35E8A50UL, 0xDCA21800UL, 0x0A3BC071UL, 0x5C564059UL, - 0x68E0B3B7UL, 0x990DE98AUL, 0x52383C84UL, 0x5B49E462UL, - 0x991858FFUL, 0xE4A00026UL, 0xE7006EE6UL, 0x89D14DA3UL, - 0x8518D345UL, 0x7BF48382UL, 0x2A60F7E9UL, 0xEB34B41BUL, - 0xE599E4DEUL, 0xD96CD8F3UL, 0xAFC58217UL, 0x8D1D706AUL, + 0x9099D73FUL, 0xDDBEED88UL, 0x41942F5FUL, 0x2AA05AC7UL, + 0xA789AF2EUL, 0x5A8CD969UL, 0x88477ABBUL, 0x1AFAD5A6UL, + 0xB6438657UL, 0x0C6B92CFUL, 0x89D7B1A0UL, 0xEC4F542BUL, + 0xAFF4B0F4UL, 0x53ED9498UL, 0xF195DFDFUL, 0xA0ED9155UL, + 0x33F95441UL, 0xD46FBFE5UL, 0xB97C98ABUL, 0xE934DAADUL, + 0x312D3E1EUL, 0x34DFC0C5UL, 0x296D18F0UL, 0x3ED7BCA8UL, + 0x8488A729UL, 0x8423C8B4UL, 0x6A8E015BUL, 0x6348E92FUL, + 0xD1D527FBUL, 0x55791556UL, 0x1661DF8EUL, 0xEC211513UL, + 0x4B543AABUL, 0x300BB0EBUL, 0xC6891EC7UL, 0xFF67FE87UL, + 0x629E31DDUL, 0xF7C88C5DUL, 0x3525B15EUL, 0x1869F94FUL, + 0x88757A41UL, 0x1BE9E588UL, 0xCA82EC82UL, 0xD93148DCUL, + 0x7305DE91UL, 0x832F5FF4UL, 0x2D3E43D3UL, 0x6DACDD32UL, + 0x3001906DUL, 0x9279CA59UL, 0x6FBAF044UL, 0x1412210DUL, + 0x2BB7604FUL, 0x26D391D2UL, 0x7B7B802FUL, 0xA9B75CC6UL, + 0x047ACBE3UL, 0x9028465CUL, 0x7CD7F122UL, 0xB90BAD3BUL, + 0x481DC053UL, 0x9129CCF9UL, 0xC974299CUL, 0x9EDC71B0UL, + 0xB1348E2BUL, 0x2AB533F4UL, 0x06759368UL, 0x9362DD4BUL, + 0xFC4170A2UL, 0xF66E7091UL, 0x238B2CEBUL, 0x311FE30EUL, + 0x93684901UL, 0x8F47D600UL, 0xCF116EFDUL, 0x8C495F42UL, + 0x64CE727CUL, 0x6E6776FEUL, 0xD3E14A5EUL, 0xF809E6DDUL, + 0xA93E9EB3UL, 0x718C3D8DUL, 0x8A15D035UL, 0x76F17789UL, + 0x6D214646UL, 0xD1F50355UL, 0xFAECEA92UL, 0x4688EBABUL, + 0xE7E15223UL, 0x5954F98DUL, 0xC4CD938EUL, 0xC8B715E4UL, + 0xBC68F9F3UL, 0x6BA2CDECUL, 0x50D53AC6UL, 0x78A300C2UL, + 0xAB1C8FE0UL, 0xBBBC76A1UL, 0x8EA245BCUL, 0x54562A8FUL, + 0x2350668FUL, 0xCCD26B51UL, 0x08E26A41UL, 0x0050F94EUL, + 0xD68B8063UL, 0xBC26C616UL, 0x19BC32A1UL, 0xA537E0D9UL, + 0xA8BA91E7UL, 0x65E23AAEUL, 0x829110BDUL, 0xED63F9DAUL, + 0xD185364AUL, 0x8BE50815UL, 0x55E4D048UL, 0x6A305F8CUL, + 0x156616A9UL, 0xB9450B9AUL, 0x9DBCEE1CUL, 0x3A737FDBUL, + 0xD6A366DEUL, 0xA952BF24UL, 0x0FEE7F8AUL, 0xF677E6D1UL, + 0x8B17C671UL, 0xB21974FAUL, 0x9B45916DUL, 0x934A148EUL, + 0xE7121D61UL, 0xE0524132UL, 0xDEF0F5DCUL, 0x9CA9BB89UL, + 0x5A2D4775UL, 0x878F9FC8UL, 0x9C86AEE6UL, 0x9052855FUL, + 0x0B5D9C27UL, 0xB5644D7DUL, 0x3286762EUL, 0x7A101303UL, + 0x4893CDABUL, 0x797B9954UL, 0x3D9C2768UL, 0x46E3F68FUL, + 0x46DD122BUL, 0xB0E76629UL, 0xF1A0E0ABUL, 0x82B44106UL, + 0xF2BA691AUL, 0x233DBB1AUL, 0x01482A7DUL, 0x9905046BUL, + 0x1AC077A7UL, 0xEEC6EAF4UL, 0x09F9CEC3UL, 0x3F0B1953UL, + 0xFC136154UL, 0xAB8993A1UL, 0x107533D5UL, 0xFAE1DE43UL, + 0x5A1B5433UL, 0x63B3F094UL, 0x91197863UL, 0x6B2061EAUL, + 0x1323429FUL, 0xB234B4E2UL, 0x9EBA643AUL, 0x672FE3F9UL, + 0xFCBA50EBUL, 0xDAAFC7C3UL, 0xC9F9276CUL, 0x3674797AUL, + 0x26915821UL, 0xA1DB39C4UL, 0x7A7E4E6BUL, 0xC96962E8UL, + 0x2561C7D9UL, 0x254ABAABUL, 0x65AB090DUL, 0x43B83A80UL, + 0xA97C0C01UL, 0x649736D9UL, 0x83C659C7UL, 0xAC63E6D9UL, + 0x455B9C9CUL, 0xA122E631UL, 0xB47981BEUL, 0x58E2D5EBUL, + 0xA4E5C6C4UL, 0x9A994CBEUL, 0x95D91085UL, 0x564E5990UL, + 0x7D95A25BUL, 0xF44AB71FUL, 0x7401FFE8UL, 0x7C638AEBUL, + 0x8FDFB709UL, 0x4AB250B9UL, 0x219B5E7CUL, 0x084F2A0DUL, + 0xD4FA3FACUL, 0x3515808AUL, 0x99D75295UL, 0x2962CF91UL, + 0x21D08ED4UL, 0x9B9E8B75UL, 0x0E2E0DA8UL, 0xCD55557DUL, + 0x0A7CF045UL, 0x9C1E560AUL, 0xEFDA69D4UL, 0x4CB42BF7UL, + 0x3337BEC7UL, 0xBCE66300UL, 0x55E51D85UL, 0x2CEB9670UL, + 0x472278D4UL, 0xCF866B3AUL, 0xF8D82F55UL, 0x571C0738UL, + 0x71CDA49AUL, 0x7BF8AF7EUL, 0x8C5A2805UL, 0x0820CD67UL, + 0xA99E9853UL, 0x303EB277UL, 0x2F91F776UL, 0x41CB812CUL, + 0x6A522A2EUL, 0xB0F9604FUL, 0xCF649A2FUL, 0x83147843UL, + 0x9AD43711UL, 0xC734F720UL, 0x68C5FD9EUL, 0x2E17A475UL, + 0x233F9EF8UL, 0xDA873CFDUL, 0x320779F2UL, 0x27A3EB64UL, + 0xBBE0E9C7UL, 0x609BEBBEUL, 0xBD1F8A39UL, 0x15F0B60EUL, + 0x0972E425UL, 0x35E6176CUL, 0x096441FFUL, 0x50DFC237UL, + 0x0BD804E7UL, 0x6CD788BAUL, 0x95A621E6UL, 0x4145855EUL, + 0xA1DB38E7UL, 0x4E63CED0UL, 0xA84175E9UL, 0xA7FF5305UL, } }; diff --git a/tst/test_next.c b/tst/test_next.c index a57a155..e8353c3 100644 --- a/tst/test_next.c +++ b/tst/test_next.c @@ -134,109 +134,109 @@ const static uint32_t expected_next_results[EXPECTED_NEXT_ELEMENTS] = { * in generate.c */ const static uint32_t expected_next32_with_nonzero_seed[EXPECTED_NEXT_ELEMENTS] = { - 0xC987111FUL, 0x33949FA5UL, 0x72F289B6UL, 0x00861702UL, 0xCB5D7A6EUL, - 0x5291E936UL, 0x79879ADEUL, 0xBB6EF9CFUL, 0x8F8DD09DUL, 0xA44B1A6CUL, - 0xB3C78167UL, 0x9020783BUL, 0xD96F29CAUL, 0x3A6AFE88UL, 0xD5EB7091UL, - 0xB61ECEB4UL, 0x2F3EA2B7UL, 0x1B42FAF8UL, 0xC3206714UL, 0xDE2CC0F2UL, - 0x6D6CF2F5UL, 0xC21F5ABBUL, 0x801851E3UL, 0xE8AD45B3UL, 0x07109ADCUL, - 0x4102234AUL, 0x9A190E08UL, 0x18A72F1CUL, 0xB0E2B8DAUL, 0x3C95A998UL, - 0x95BACD29UL, 0x5812E873UL, 0x02198D64UL, 0x4AAD18F4UL, 0x7CE73151UL, - 0x72C34521UL, 0x14CB27E6UL, 0x5244AEDCUL, 0xEF3CAE74UL, 0xE7B3824AUL, - 0x2F9D6B9EUL, 0x7D8A44C3UL, 0xD1201B3FUL, 0x25CBD94EUL, 0xC7E826DCUL, - 0x3346749DUL, 0x856509D1UL, 0x57DA3982UL, 0xFA26FD63UL, 0x1C672264UL, - 0xC10A02AAUL, 0x67B1E46EUL, 0x285AAAD7UL, 0x8093DC57UL, 0x9F00DBC5UL, - 0xA191268DUL, 0x23F5BE25UL, 0xC84CB5C8UL, 0x6E27FDD7UL, 0xE5462908UL, - 0x8BA5889AUL, 0xBDA4DE39UL, 0x84F2C60AUL, 0x11A4F036UL, 0x89BFAF02UL, - 0x4D0B3FA9UL, 0xA1166856UL, 0xD61DCCABUL, 0x61C5F7CBUL, 0x2DDEE8FCUL, - 0xD2854C55UL, 0xC4196AC9UL, 0x0A92D424UL, 0xBFA77683UL, 0x6437FFC9UL, - 0x7E4264E4UL, 0x30CA3DF0UL, 0xF9A01C7AUL, 0xFA8CFCFAUL, 0xC5241BFEUL, - 0xFA00E8BDUL, 0x7E522085UL, 0x63553457UL, 0x045D82B8UL, 0x27CDC1ABUL, - 0x871DF567UL, 0xF30AF872UL, 0x95B5B19DUL, 0xF3E36970UL, 0x94464CFFUL, - 0x32CCC4EDUL, 0xF76E828AUL, 0xE0F1700AUL, 0xB346BC60UL, 0x5CFD2F14UL, - 0xC2632062UL, 0x616ADBAEUL, 0xE73F18E9UL, 0x941F5843UL, 0x2A5CA2C8UL, - 0xDEB519ACUL, 0x19606B42UL, 0x28F80B82UL, 0xE19EBB47UL, 0xB31AA32FUL, - 0x94A3ACB2UL, 0x4DE2B784UL, 0x3EF326EAUL, 0x134CDD3BUL, 0xD739A2CDUL, - 0x97D51E1DUL, 0x594F975FUL, 0xF48CAC1AUL, 0x5F2EDC8FUL, 0x225DFDD4UL, - 0xA57E36A8UL, 0xFA32CF4DUL, 0xA58BF76DUL, 0x6D55628AUL, 0x923A1AEFUL, - 0xE0011522UL, 0x30FFAFF5UL, 0x001986ECUL, 0xEB16E097UL, 0xC403FC60UL, - 0x510566B6UL, 0x72FAB07CUL, 0x804457ACUL, 0x58A8506FUL, 0xE770B14EUL, - 0x2D83C753UL, 0x53BDD8B5UL, 0x54138AB6UL, 0x1638F87AUL, 0x1A2A834CUL, - 0x2A9F0BF4UL, 0x69E13398UL, 0x65296112UL, 0x7486F9B3UL, 0x91F0E9A1UL, - 0xF3D7C990UL, 0x754FF4ADUL, 0xBE47CE95UL, 0x409329D9UL, 0x334D3867UL, - 0x1E18D2F4UL, 0x462A0B83UL, 0x96C5A1B6UL, 0x577EBA9CUL, 0x1D2B0B09UL, - 0x681DDAB0UL, 0xC6C78665UL, 0x0179A71CUL, 0x4614AB27UL, 0x75C83725UL, - 0x35ED5CB5UL, 0xF2811F31UL, 0xECE7839FUL, 0x969F7D8EUL, 0xF92AE295UL, - 0xC6B413C5UL, 0x78E126ABUL, 0xB8227AF3UL, 0xF6BBF1EBUL, 0x22586EE0UL, - 0x4003DB22UL, 0xBC1DB747UL, 0xA0016F76UL, 0x3455F76DUL, 0xE3B9F85EUL, - 0xBD6DC736UL, 0xD7ECD061UL, 0x374094EFUL, 0x75B9074EUL, 0x73BC5ED7UL, - 0x995049CAUL, 0x0AC8FD47UL, 0xEF557607UL, 0xD19632B3UL, 0x609649B4UL, - 0xBF11FAEDUL, 0xD6F93CC5UL, 0x98BDDBEBUL, 0x9226F4D5UL, 0xC71E5F66UL, - 0x03A87846UL, 0x17366CADUL, 0x9EC3CD34UL, 0xC8C117D3UL, 0x2AC1D182UL, - 0xC188454CUL, 0x5AFB09C2UL, 0xF4375831UL, 0xB1D4FF64UL, 0x14EA480AUL, - 0xED891E9AUL, 0xB0F7D772UL, 0x92D09662UL, 0x4C0206F9UL, 0xFBCA7BD3UL, - 0xDEA0CFB2UL, 0xBDE4D3CCUL, 0x2E248D9EUL, 0xEC597682UL, 0x74E3B0DAUL, - 0x8FE9004FUL, 0x611B883EUL, 0x3515F508UL, 0x25A000CAUL, 0x7ACB9D11UL, - 0x880B875DUL, 0x2E132954UL, 0xD9BCC32CUL, 0x50F782DEUL, 0xE6ECDFA4UL, - 0xD2B774A4UL, 0x1D4FC93EUL, 0xA43329D1UL, 0x039E24C3UL, 0x0C0F343DUL, - 0x37C742F9UL, 0xA68F6920UL, 0xD913640CUL, 0xC130B1AFUL, 0x403F5CB5UL, - 0xF4AD9AC9UL, 0x7FB1B5A1UL, 0xB9717A59UL, 0x394F7918UL, 0x647E8AD8UL, - 0x22662D97UL, 0x700AE372UL, 0x4203B72EUL, 0x6DE606E2UL, 0xE1DB8AFCUL, - 0xB3F23FE7UL, 0xA22B58EDUL, 0x61B69E36UL, 0xBF2D4B76UL, 0xDD85BE5CUL, - 0x11304761UL, 0x0E121E85UL, 0xBC506172UL, 0x82605046UL, 0xA7DD8E74UL, - 0x7CE5A040UL, 0x8331A767UL, 0xE2266B16UL, 0x5E59F68AUL, 0x5E1CB8A2UL, - 0x40117235UL, 0xF795B85DUL, 0x42183AB9UL, 0x0790D1E5UL, 0xC1FF8E2CUL, - 0x971CD9C6UL, 0xBA9734AAUL, 0xAE5F7197UL, 0xEAB168BFUL, 0xAC290E78UL, - 0x44F712A6UL, 0x60D40A4BUL, 0xB2B86D44UL, 0x50CFF015UL, 0x4823F1D5UL, - 0xC332D13AUL, 0x0F00F80FUL, 0x6541C275UL, 0x78F2085BUL, 0x92FBAF98UL, - 0x4A6BCF1EUL, 0x3497D087UL, 0x9944B1F2UL, 0x0840DE1BUL, 0x20638EAEUL, - 0x6F530DD2UL, 0x4767A37CUL, 0x8ACDEC6FUL, 0x29E305B7UL, 0x26A04156UL, - 0x00E4C02CUL, 0xAA672809UL, 0x40D58097UL, 0x5F532BFAUL, 0xF71CEE7CUL, - 0xA95696BEUL, 0xCEAFA260UL, 0xAF65A0D1UL, 0x81322EC2UL, 0xCFE77E16UL, - 0xAD57C024UL, 0x77E31ACAUL, 0x6E8C4AB1UL, 0x6A000C48UL, 0xF8F026FCUL, - 0xB4148DAFUL, 0x4B12DBD3UL, 0xBD208EF8UL, 0xABDDC53AUL, 0x41320656UL, - 0xF29BAD80UL, 0xF701A783UL, 0x9F970355UL, 0xC6878C36UL, 0x8A6B25E5UL, - 0x63F39C5EUL, 0x0FB067B6UL, 0x8187E50AUL, 0xF997E711UL, 0x14CC84D3UL, - 0x8A16EFE7UL, 0x97FA0BB1UL, 0xF5872C93UL, 0xD67B28D9UL, 0xA0511087UL, - 0xFC82795BUL, 0x4C95E4AAUL, 0xE2EFE242UL, 0x9895B7BCUL, 0x2C4F6D69UL, - 0x5D762413UL, 0xD284FFA5UL, 0xE1210AE0UL, 0x08EDBAF9UL, 0x76E76F43UL, - 0x80FB6287UL, 0x8711ED8EUL, 0x849B3882UL, 0xE7B98423UL, 0xBD3FE74CUL, - 0x4392AA3BUL, 0xD88854D9UL, 0x9BB42193UL, 0x9B212735UL, 0x12FD3D1FUL, - 0xE5399B4FUL, 0xC3E392B2UL, 0x52E8A282UL, 0xD255AC25UL, 0xBD2782AEUL, - 0x3F283E49UL, 0xFD25E81AUL, 0xFFD3F4A0UL, 0x48622CFAUL, 0xB0FBEE60UL, - 0x6B555300UL, 0x279525D5UL, 0x8BC4C146UL, 0xC94CDB6DUL, 0x443DC33AUL, - 0x8F47BD4CUL, 0x97E40C3EUL, 0xFE8C0C3CUL, 0x49240BB2UL, 0xF39AAB73UL, - 0xD050DBF9UL, 0x3E8D41E1UL, 0x8D980943UL, 0xFC31FD17UL, 0x604082AAUL, - 0xBBE37F04UL, 0x0615C2D3UL, 0x31B7B137UL, 0xBEE43720UL, 0xD4EA5B72UL, - 0x91413A8FUL, 0x3ADAAE59UL, 0x2577FE7EUL, 0xFD488664UL, 0x92F1EE09UL, - 0xE7E79BD5UL, 0xC49EB8ABUL, 0x5A88F979UL, 0x2A972D99UL, 0x4DCC212AUL, - 0x21E77EF8UL, 0xE647C5DCUL, 0x69753C6CUL, 0x28FA5EFBUL, 0x662BFF5FUL, - 0x594CB517UL, 0xEBD9652BUL, 0xD742ECF1UL, 0x3961D895UL, 0x052C9414UL, - 0xD8308354UL, 0x6F348D54UL, 0x4BB16D47UL, 0xEFA5966AUL, 0xA13C3FA4UL, - 0x908E9A01UL, 0x1B1094C3UL, 0x36E57C4FUL, 0x0972EF22UL, 0x3B847C74UL, - 0xF8D1CAC0UL, 0xD245604CUL, 0xEBF27EB2UL, 0x6F59E622UL, 0x08022691UL, - 0xD9476B67UL, 0xD1A68C66UL, 0x264C453AUL, 0xFF0B1A4AUL, 0x9CC93145UL, - 0xB9DF3ACBUL, 0x6B6D6D04UL, 0xA9EA3A92UL, 0xBB625CD8UL, 0x422F887AUL, - 0x9231139BUL, 0xA566A405UL, 0x5C9AABD3UL, 0xF5860C7DUL, 0x85807D4DUL, - 0x9BB32AD9UL, 0x5E634B34UL, 0xFA87AC98UL, 0x75D83341UL, 0x4B4BE607UL, - 0xFC5FADD3UL, 0x2B3070F4UL, 0x23F23218UL, 0x601F9DB9UL, 0x2784940AUL, - 0xF99E6B58UL, 0xE9DD16C7UL, 0xDA3D4D05UL, 0x28752620UL, 0x156F46A0UL, - 0xF2C5FDE9UL, 0x91D48724UL, 0xA72EFF7DUL, 0xF90248EEUL, 0xBE7441B1UL, - 0xBAAFE2EFUL, 0x53AD384CUL, 0xF5D21F72UL, 0x36396351UL, 0xC3A347C8UL, - 0x0B6F59A1UL, 0x45889AD9UL, 0x7DE08BF8UL, 0xAFA9D792UL, 0xA92F42BAUL, - 0xFB3826FAUL, 0xACDFEE35UL, 0xA07311DBUL, 0x5F35A4DEUL, 0x21203064UL, - 0x6939C35AUL, 0xF81ED55AUL, 0x9438873AUL, 0x0B59F77AUL, 0x6C949316UL, - 0x8079CEA9UL, 0x8C6EF6ADUL, 0x547514EFUL, 0x36FFC3F5UL, 0x3051D1FEUL, - 0xCB1ECC07UL, 0xFEEEDC69UL, 0xE7D5D98CUL, 0x9AB41450UL, 0x455285F7UL, - 0x23397700UL, 0xF066DC78UL, 0xAB484604UL, 0x36C0A277UL, 0xF1F17714UL, - 0x493B98B3UL, 0xE3B24E47UL, 0xD5DC4EFDUL, 0x86D972DEUL, 0x3BC8BD09UL, - 0x04AB93D2UL, 0xF50B3B4BUL, 0x0EDAEEDBUL, 0x639721D5UL, 0xE0024ADAUL, - 0x49D24EAAUL, 0x4BC4CE39UL, 0xD08C9F5CUL, 0x24A9E662UL, 0x49B0A56FUL, - 0x904601D8UL, 0xB7900FEBUL, 0x22C18C51UL, 0x8A5A00F8UL, 0xF833B05FUL, - 0x5D20530CUL, 0x24AECD14UL, 0xBDEC3FF8UL, 0x14F8A820UL, 0x7F635121UL, - 0x6C834AA3UL, 0x539ED0FFUL, 0xE991D664UL, 0x453A9E69UL, 0x664BE282UL, - 0x14EF5FB2UL, 0x7E8B6881UL, 0xA033BF4AUL, 0x6D579D32UL, 0x0778DAB4UL, - 0xC3C1EA27UL, 0x0B8EE3E3UL, 0x4348FEA0UL, 0x5FFDEB1FUL, 0x49BC902EUL, - 0xDA3A4B2EUL, 0x37A3C216UL, + 0x23956226UL, 0xA9E1CEBFUL, 0x3EA230EBUL, 0x8175D70DUL, 0xD8B699F5UL, + 0xB4F5C36AUL, 0xB23790CFUL, 0xAEEB9340UL, 0x6F7B8DCDUL, 0x3258B530UL, + 0x4A03FAD4UL, 0x01B103BDUL, 0xB7A31E4FUL, 0x342846F3UL, 0x3EAF2975UL, + 0x0D50B3C2UL, 0x3FF7BF83UL, 0x4DE25414UL, 0x4F022DDAUL, 0x401EB5D1UL, + 0xD87221CDUL, 0xF5F8CA46UL, 0x89C2C933UL, 0x95104798UL, 0x96CCC60DUL, + 0x0A040BBAUL, 0xB881AC9FUL, 0x677E9BD8UL, 0xCCCC97F0UL, 0x7A07619FUL, + 0x20A41472UL, 0xE05C4F99UL, 0x193D85F3UL, 0x921D9AFBUL, 0x0B10807FUL, + 0xE6F53EEFUL, 0x0ABE8344UL, 0xBDEBE62AUL, 0x82782882UL, 0x8EDFB785UL, + 0x90126434UL, 0x6BA120C4UL, 0xF7D26163UL, 0x0341975CUL, 0x313B191FUL, + 0xE96231BCUL, 0x72CB5E56UL, 0xBB28F7F9UL, 0x715266D8UL, 0xE1307B9EUL, + 0x01277E65UL, 0x48048BC8UL, 0x7ABAB891UL, 0xFD8B4308UL, 0x377C8E8FUL, + 0x19E4169FUL, 0xD94B043EUL, 0x424748B0UL, 0x2807AA6CUL, 0x1D9ABC53UL, + 0x9C80D3FDUL, 0xBD47F5A8UL, 0x5F3F4788UL, 0x9FD07C61UL, 0xED9683A4UL, + 0xFF3D3663UL, 0x9B66E6AAUL, 0xB480EF7DUL, 0x4F673CDEUL, 0x8B59DD25UL, + 0x0EC205BFUL, 0xA2E3FD84UL, 0x3C2FD293UL, 0x8741EC19UL, 0xDBEB6C64UL, + 0x532CD994UL, 0x98DE0CA2UL, 0xE5FA4583UL, 0xE172AD89UL, 0xFF72B1F8UL, + 0x032C2A28UL, 0x544E0EFAUL, 0x9EB538D6UL, 0xD889EFEFUL, 0xC98EACECUL, + 0xB47ECCD6UL, 0xFBE0A6E4UL, 0x961C8CBEUL, 0x4CA2C7D2UL, 0x554E6275UL, + 0x0027F31CUL, 0x7FF40241UL, 0x01385B37UL, 0x797B8919UL, 0xD6C2572AUL, + 0x82C960C7UL, 0x0BB4FC08UL, 0x47F98DB2UL, 0xC5EFF0AFUL, 0x34303E4CUL, + 0x69C37A6FUL, 0x768D44E0UL, 0x04AF4A7AUL, 0xE89DC0C9UL, 0xDC1F5DD4UL, + 0xCDEDC3BCUL, 0xBB58FC69UL, 0x8E0A13ACUL, 0x6076530BUL, 0x74FD76C8UL, + 0x1B7BDD70UL, 0x7D856AF1UL, 0x76F5BECAUL, 0x126E12E5UL, 0x6C80F470UL, + 0x7353E11CUL, 0xAB0399C9UL, 0x265BE277UL, 0xFCC9512CUL, 0x327741D7UL, + 0x9D330411UL, 0xB4D2939DUL, 0xBA39E19FUL, 0x5D4FD5E5UL, 0x31703EB0UL, + 0x0DBF5471UL, 0xA627343DUL, 0x18543E12UL, 0x61F3E920UL, 0x0076F1F8UL, + 0x05CF8AC6UL, 0xB5700F3AUL, 0x2B8A286BUL, 0x5092A1A2UL, 0xB74DE086UL, + 0x484A0CE8UL, 0xB4AE30F3UL, 0xDA3B78CDUL, 0xE6C73EB6UL, 0x910E46B2UL, + 0x23C03C70UL, 0xC29A190CUL, 0x79AB9CF2UL, 0x45A76DCEUL, 0x86EC53A7UL, + 0x43D13242UL, 0x04B020B7UL, 0xA903AAE9UL, 0x0F07ED2BUL, 0xF385BB7FUL, + 0x7B6EEFDCUL, 0x9F11F572UL, 0x36A95AFFUL, 0xDEB54D1FUL, 0x4AFC5002UL, + 0xB855EDD5UL, 0xFD0356D6UL, 0x91474D54UL, 0x62928BBBUL, 0x42BAE3AFUL, + 0x80FA85E3UL, 0x940568A0UL, 0x8C21D6A3UL, 0x3B0F2F18UL, 0xD6617C47UL, + 0xCF62EBD5UL, 0xC2BF97E0UL, 0x246D45A6UL, 0x5066E4A3UL, 0x4E859A2CUL, + 0xFD87ACA3UL, 0x1580045AUL, 0xC6104017UL, 0xD5A20325UL, 0xF2D499F3UL, + 0x2EECCD6BUL, 0x629BCEC3UL, 0x09359360UL, 0xD13B506AUL, 0xB37693D1UL, + 0x0AEF3B0DUL, 0x2950EE3EUL, 0xE6E11073UL, 0xAE028C9BUL, 0xC52E6B7AUL, + 0x686C382CUL, 0x79140B9BUL, 0xF8C5F834UL, 0x00CDFEDAUL, 0xB3E2535AUL, + 0x52F5DD57UL, 0xF38B6968UL, 0xCE3B407BUL, 0x2F199C58UL, 0xBFB9E202UL, + 0x9A1B7282UL, 0xBB6ABA64UL, 0x584B13E5UL, 0xE2DD2B60UL, 0x81E5CC75UL, + 0x99CE6B82UL, 0xFE945574UL, 0xE6F63522UL, 0x0315E9C0UL, 0xE6C61DADUL, + 0x0DD6E029UL, 0x0532FB9BUL, 0xF2C72AB0UL, 0x37EB562FUL, 0xA00F02A2UL, + 0xCDE1EDBDUL, 0x919F5B18UL, 0x8DB85D64UL, 0x2B0DA294UL, 0x2763BF0CUL, + 0x3FC3A488UL, 0x97F7A9C8UL, 0x67C5264BUL, 0x893CBE90UL, 0xAF408615UL, + 0xF9B83492UL, 0x39C15C5EUL, 0xFFCC9D0DUL, 0x3500511CUL, 0xF495799AUL, + 0xF660CB52UL, 0x6DFF5D0FUL, 0x5F12277FUL, 0x21A7B79BUL, 0x60ADDF8FUL, + 0x7BB3B391UL, 0x62CBE77EUL, 0x20D2C863UL, 0x49529EB0UL, 0x11C078D1UL, + 0xB33F34D2UL, 0x1A657203UL, 0xB9E5E431UL, 0x3C02CD0EUL, 0x3B8BBF4DUL, + 0x41B38BA2UL, 0x525D5B72UL, 0x1E8365A1UL, 0x3CCC8D13UL, 0xDBA2B1A6UL, + 0x7C3837D3UL, 0x23D46470UL, 0xFF344EA9UL, 0xE13F9A4DUL, 0x38777CFEUL, + 0x2E653888UL, 0x3DF06B31UL, 0xE3789964UL, 0x40B4E071UL, 0x7864DE8DUL, + 0x953A7425UL, 0x83898930UL, 0x17D3D13BUL, 0x09729780UL, 0x270CD1BEUL, + 0x917836E1UL, 0xEF39C021UL, 0xC66B26F5UL, 0x8FF1CA2FUL, 0x8B70CE31UL, + 0x71C9F6A0UL, 0x8618C8EFUL, 0x8326376AUL, 0xCEDABC6CUL, 0x78E28436UL, + 0x8A36209FUL, 0x9276C391UL, 0x6098B381UL, 0x37869E2DUL, 0xAFD6DD31UL, + 0xCB3EF1FDUL, 0xC4D59F44UL, 0x6C9E94F5UL, 0x6F591D9EUL, 0x87373E7EUL, + 0x556F0990UL, 0xF36F9072UL, 0x0DCD6CBBUL, 0xBDE00A1AUL, 0x929942D3UL, + 0x1F8EC2F7UL, 0x7EB28F7DUL, 0xD12042BBUL, 0xDA7B5EB4UL, 0x973663F3UL, + 0x34E366C2UL, 0x178EE281UL, 0xD5CFA8CFUL, 0x9C6F970EUL, 0x69B8A3A3UL, + 0x6FE79BEAUL, 0x23DBF263UL, 0x288BE545UL, 0x180D72A2UL, 0xAF306E45UL, + 0xEE8F64DEUL, 0x5D85FF69UL, 0xF1B05655UL, 0x8E96B58DUL, 0x5286EE54UL, + 0xBA35737FUL, 0x691C367BUL, 0x9B83E219UL, 0x2B27810CUL, 0x756188C0UL, + 0x5C972AF2UL, 0xA45ED9DBUL, 0x7F0491ACUL, 0x54D31D43UL, 0xFBABB108UL, + 0x3B6B2904UL, 0x3949EDEBUL, 0x1F25E2B7UL, 0xE44782A0UL, 0xA6F871ECUL, + 0xB95CCC4CUL, 0xFDD0A134UL, 0x6A1FB7F8UL, 0x723B1C41UL, 0x09279B14UL, + 0x95A228A8UL, 0x091A76E0UL, 0x8F18F340UL, 0x3C439DE2UL, 0x534CC501UL, + 0xB56919E7UL, 0x02F92E83UL, 0x963B782AUL, 0xA03C1507UL, 0x6AA65747UL, + 0xB060CE26UL, 0x5F6BD15FUL, 0xB3731688UL, 0xD512F88BUL, 0x1F698776UL, + 0xB2D04075UL, 0xCF784BA7UL, 0x85D3AA92UL, 0xFBE30CA0UL, 0x8DC13C1AUL, + 0x1BA22E53UL, 0x6613C020UL, 0xA60CE71BUL, 0x1ED71566UL, 0x32F4B14AUL, + 0x45A9CDBCUL, 0x29A1BF6DUL, 0x449F34E7UL, 0xAB0E8093UL, 0xBEACD640UL, + 0x66658B82UL, 0x659C7174UL, 0xB3986716UL, 0x2D74F7B7UL, 0xF80D6865UL, + 0x54E5EE32UL, 0x8354CD54UL, 0xA0258533UL, 0x887E7CE4UL, 0x603E7393UL, + 0xC346532BUL, 0x7E3CBBA6UL, 0x030246A2UL, 0x164890BEUL, 0x901F6512UL, + 0xB01F29F3UL, 0xE74E31E5UL, 0x23AEAB56UL, 0x8DAD85D0UL, 0x15014318UL, + 0x87564BA5UL, 0xB59D400AUL, 0xCCC5615DUL, 0x2263D6D9UL, 0x97C96EDDUL, + 0x38C81193UL, 0x6DBF2AD5UL, 0xE5D1656DUL, 0x6E5F3D27UL, 0x9F221975UL, + 0xEC2553A4UL, 0xA955B0E4UL, 0xF4E49A76UL, 0xB397710AUL, 0xD4768266UL, + 0x346A8595UL, 0x373F529CUL, 0x0C18F25BUL, 0x39027F89UL, 0x722FC2DEUL, + 0xE2BB6C26UL, 0x971BF5FCUL, 0xEBE73EBFUL, 0xFFE707FDUL, 0xD0ADF1FFUL, + 0xBF096C5AUL, 0x05A58900UL, 0x07BD7472UL, 0x2BCF0A2AUL, 0x0B3486C3UL, + 0xCDDC7921UL, 0xA57A6596UL, 0x40BBDFEFUL, 0xAA8FB1E6UL, 0x60790FEDUL, + 0xEEE46E65UL, 0xB21E9B88UL, 0x8141C0FFUL, 0x60277C06UL, 0x26EA94AAUL, + 0x10C5B331UL, 0x22419915UL, 0x8B48BAA1UL, 0x4BF50F1EUL, 0x612AE87BUL, + 0x4232AF38UL, 0x60EBE998UL, 0x5ED41DC8UL, 0x6D2545CDUL, 0x10821317UL, + 0x5E1B5F63UL, 0x7C33BBEDUL, 0xAC2C5F99UL, 0x130FCD93UL, 0x3E8F51F3UL, + 0xEE7407A6UL, 0xE7ECAB76UL, 0xB3EAD0A4UL, 0xFB72843FUL, 0x093BAE0FUL, + 0x63F72E31UL, 0xBF811E09UL, 0x6B2FC507UL, 0x5E5944FDUL, 0xC87DC98BUL, + 0x2929C9EBUL, 0xF2EFC71AUL, 0xCCF9F0F4UL, 0xB8225A69UL, 0x655324B0UL, + 0xC29C597EUL, 0x5A472B6AUL, 0x79EBA40FUL, 0x7C993125UL, 0x73B2E234UL, + 0xC5A33334UL, 0xE4C77BDCUL, 0x4EE4BDC0UL, 0xF7563F8DUL, 0x773A63BDUL, + 0x5B96D31BUL, 0xA28F8C1BUL, 0xE5CDAA5DUL, 0x8CB5CC80UL, 0xA532F9A3UL, + 0xF464623FUL, 0xD2E96515UL, 0xC399AD67UL, 0xE0FAF0BCUL, 0x943E3553UL, + 0xD8C7D774UL, 0x4D288760UL, 0x302568CAUL, 0xDA797359UL, 0x66A1428CUL, + 0x8DB78A22UL, 0x63254204UL, 0x3453DED7UL, 0x8E7AAAEBUL, 0x6630035BUL, + 0x0E27C57EUL, 0x554D1C0CUL, 0xE0455168UL, 0x569D090CUL, 0x3E0EA3C5UL, + 0x116BCFBEUL, 0xF3EC121BUL, 0xCEF4AEAAUL, 0xEDBF0D83UL, 0xDFAC741AUL, + 0x1CA77655UL, 0x28E5B73CUL, 0xD5686960UL, 0xCF2A4207UL, 0x4556FE78UL, + 0xD6BAF9ACUL, 0x3275689BUL, 0x7C9D23AEUL, 0x35E02396UL, 0xCAE7A6B6UL, + 0x4FE339C9UL, 0xFA428AE2UL, 0x6C142E4AUL, 0xA9D264E0UL, 0x9706CE55UL, + 0x5AB6CB29UL, 0x5E477185UL, 0x333F24A1UL, 0xAA8E3D76UL, 0xA28A756EUL, + 0xF5F457EDUL, 0x0CA64E63UL, 0xF01D7CD9UL, 0xADB4D30AUL, 0xD2BDFC58UL, + 0xDE0FE6D6UL, 0x5521DA1BUL, }; static void test_next32_a_few(void) From 379bc05bf78cee64d25d11556d92e1170e09192d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matjaz=CC=8C?= Date: Mon, 27 Apr 2020 17:40:37 +0200 Subject: [PATCH 15/27] Replace next32() and next8() with stream32() Add utility functions to convert uint32 buffers to uint8 LE/BE. This simplifies the API by a lot. ISAAC works on 32-bit integers, so it also provide the output in this format. If the user wants, they can convert the values into whatever format they desire. --- CMakeLists.txt | 3 +- inc/isaac.h | 80 +++++++------ src/isaac.c | 84 +++++++++++++- tst/test.c | 1 + tst/test.h | 1 + tst/test_convert.c | 52 +++++++++ tst/{test_next.c => test_stream.c} | 174 ++++++----------------------- 7 files changed, 221 insertions(+), 174 deletions(-) create mode 100644 tst/test_convert.c rename tst/{test_next.c => test_stream.c} (77%) diff --git a/CMakeLists.txt b/CMakeLists.txt index fc32a09..f5fff38 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -45,7 +45,8 @@ include_directories(tst/ tst/atto/) set(TEST_FILES tst/test.c tst/test_init.c - tst/test_next.c + tst/test_stream.c + tst/test_convert.c tst/atto/atto.c) add_library("isaac" STATIC ${LIB_FILES}) diff --git a/inc/isaac.h b/inc/isaac.h index 21f51e6..3ee0553 100644 --- a/inc/isaac.h +++ b/inc/isaac.h @@ -37,7 +37,7 @@ extern "C" #define LIBISAAC_VERSION "1.0.0" #include -#include +#include #define ISAAC_U32_ELEMENTS 256U #define ISAAC_SEED_MAX_BYTES ISAAC_U32_ELEMENTS @@ -101,47 +101,59 @@ typedef struct void isaac_init(isaac_ctx_t* ctx, const uint8_t* seed, uint16_t seed_bytes); /** - * Provides the next pseudo-random 32-bit integer. + * Provides the next pseudo-random 32-bit integers. + * + * Because ISAAC works on 32-bit values, the stream is in 32-bit integers. + * To convert them to bytes: + * - get some values into a uint32_t buffer with isaac_stream32() + * - allocate a uint8_t buffer + * - convert the uint32_t buffer to the uint8_t one using the utility functions + * isaac_uint32_to_le() or isaac_uint32_to_be() for little and big endian + * respectively. + * + * Every #ISAAC_U32_ELEMENTS uint32_t provided it will automatically reshuffle + * the ISAAC state to cache #ISAAC_U32_ELEMENTS new elements. This means that + * the first #ISAAC_U32_ELEMENTS values after seeding are very cheap (just + * copying values from the state) and the #ISAAC_U32_ELEMENTS+1st value is + * more expensive. + * + * @param[in, out] ctx the ISAAC state, already initialised. + * @param[out] ints pseudo-random integers. + * @param[in] amount quantity of 32-bit integers to generate. + */ +void isaac_stream32(isaac_ctx_t* ctx, uint32_t* ints, size_t amount); + +/** + * Utility function, converting an array of 32-bit integers into bytes using + * **little endian** byte order. * - * After #ISAAC_U32_ELEMENTS calls it will automatically reshuffle the ISAAC - * state to provide #ISAAC_U32_ELEMENTS new elements. This means that - * #ISAAC_U32_ELEMENTS calls are very cheap (just reading the uint32_t value - * from the state), and the #ISAAC_U32_ELEMENTS+1st call is expensive. + * Useful to convert a stream of 32-bit integers to 8-bit values. * - * @warning - * **Use either isaac_next32() or isaac_next8(), never both**, especially not - * in an interleaved manner. The issue is that isaac_next8() reads bytes - * from the isaac_next32() output; this means that calling isaac_next8() and - * then isaac_next32() will produce the same byte twice, which is **unsecure** - * and predictable. - * - * @param ctx the ISAAC state, already initialised. - * @return a pseudo-random 32-bit integer. + * @param[out] bytes 8-bit integers. Must be at least \p amount_of_values*4 + * bytes long. + * @param[in] values 32-bit integers, as obtained from isaac_stream32() + * @param[in] amount_of_values quantity of 32-bit integers in the \p values + * buffer. */ -uint32_t isaac_next32(isaac_ctx_t* ctx); +void isaac_uint32_to_little_endian(uint8_t* bytes, + const uint32_t* values, + size_t amount_of_values); /** - * Provides the next pseudo-random byte. - * - * Basically provides the isaac_next32() output byte-by-byte. The order - * of the bytes is from (uint32_t*)[0] to (uint32_t*)[3]. + * Utility function, converting an array of 32-bit integers into bytes using + * **big endian** byte order. * - * After #ISAAC_U8_ELEMENTS calls it will automatically reshuffle the ISAAC - * state to provide #ISAAC_U8_ELEMENTS new elements. This means that - * #ISAAC_U8_ELEMENTS calls are very cheap (just reading the uint8_t value - * from the state), and the #ISAAC_U8_ELEMENTS+1st call is expensive. + * Useful to convert a stream of 32-bit integers to 8-bit values. * - * @warning - * **Use either isaac_next32() or isaac_next8(), never both**, especially not - * in an interleaved manner. The issue is that isaac_next8() reads bytes - * from the isaac_next32() output; this means that calling isaac_next8() and - * then isaac_next32() will produce the same byte twice, which is **unsecure** - * and predictable. - * - * @param ctx the ISAAC state, already initialised. - * @return a pseudo-random byte. + * @param[out] bytes 8-bit integers. Must be at least \p amount_of_values*4 + * bytes long. + * @param[in] values 32-bit integers, as obtained from isaac_stream32() + * @param[in] amount_of_values quantity of 32-bit integers in the \p values + * buffer */ -uint8_t isaac_next8(isaac_ctx_t* ctx); +void isaac_uint32_to_big_endian(uint8_t* bytes, + const uint32_t* values, + size_t amount_of_values); #ifdef __cplusplus diff --git a/src/isaac.c b/src/isaac.c index 4b1de7c..0ee28ac 100644 --- a/src/isaac.c +++ b/src/isaac.c @@ -52,6 +52,10 @@ void isaac_init(isaac_ctx_t* const ctx, const uint8_t* const seed, const uint16_t seed_bytes) { + if (ctx == NULL) + { + return; + } uint32_t a, b, c, d, e, f, g, h; uint_fast16_t i; /* Fastest index over elements in result[] and mem[]. */ ctx->a = ctx->b = ctx->c = 0; @@ -202,7 +206,6 @@ uint32_t isaac_next32(isaac_ctx_t* const ctx) return next32; } - uint8_t isaac_next8(isaac_ctx_t* const ctx) { /* We read the same next32 value 4 times and extract 4 different bytes from @@ -221,3 +224,82 @@ uint8_t isaac_next8(isaac_ctx_t* const ctx) } return next8; } + +#define isaac_min(a, b) ((a) < (b)) ? (a) : (b) + +void isaac_stream32(isaac_ctx_t* const ctx, uint32_t* ints, size_t amount) +{ + if (ctx == NULL || ints == NULL) + { + return; + } + do + { + const size_t available = isaac_min(ctx->next32_index + 1, amount); + for (uint_fast16_t i = 0; i < available; i++) + { + *ints++ = ctx->result[ctx->next32_index--]; + } + amount -= available; + if (ctx->next32_index >= ISAAC_U32_ELEMENTS) + { + /* next32_index underflow, thus out of elements. Reshuffling + * and preparing new batch of elements. */ + isaac_shuffle(ctx); + ctx->next32_index = ISAAC_U32_ELEMENTS - 1; + } + } + while (amount); +} + +static inline void uint32_to_le(uint8_t* bytes, uint32_t value) +{ + *bytes++ = (uint8_t) (value); + value >>= 8U; + *bytes++ = (uint8_t) (value); + value >>= 8U; + *bytes++ = (uint8_t) (value); + value >>= 8U; + *bytes = (uint8_t) (value); +} + +static inline void uint32_to_be(uint8_t* bytes, uint32_t value) +{ + +} + +void isaac_uint32_to_little_endian(uint8_t* bytes, + const uint32_t* values, + size_t amount_of_values) +{ + if (bytes == NULL || values == NULL) + { + return; + } + { + while (amount_of_values--) + { + *bytes++ = (uint8_t) (*values); + *bytes++ = (uint8_t) (*values >> 8U); + *bytes++ = (uint8_t) (*values >> 16U); + *bytes++ = (uint8_t) (*values++ >> 24U); + } + } +} + +void isaac_uint32_to_big_endian(uint8_t* bytes, + const uint32_t* values, + size_t amount_of_values) +{ + if (bytes == NULL || values == NULL) + { + return; + } + while (amount_of_values--) + { + *bytes++ = (uint8_t) (*values >> 24U); + *bytes++ = (uint8_t) (*values >> 16U); + *bytes++ = (uint8_t) (*values >> 8U); + *bytes++ = (uint8_t) (*values++); + } +} diff --git a/tst/test.c b/tst/test.c index 49e3226..bb89686 100644 --- a/tst/test.c +++ b/tst/test.c @@ -14,5 +14,6 @@ int main(void) { test_isaac_init(); test_isaac_next(); + test_isaac_convert(); return atto_at_least_one_fail; } diff --git a/tst/test.h b/tst/test.h index dcf44fb..04804a7 100644 --- a/tst/test.h +++ b/tst/test.h @@ -23,6 +23,7 @@ extern "C" void test_isaac_init(void); void test_isaac_next(void); +void test_isaac_convert(void); #ifdef __cplusplus } diff --git a/tst/test_convert.c b/tst/test_convert.c new file mode 100644 index 0000000..5165928 --- /dev/null +++ b/tst/test_convert.c @@ -0,0 +1,52 @@ +/** + * @file + * + * Test suite of LibISAAC + * + * @copyright Copyright © 2020, Matjaž Guštin + * . All rights reserved. + * @license BSD 3-clause license. + */ + +#include "test.h" + +static void test_to_little_endian(void) +{ + const uint32_t values[2] = {0x01020304UL, 0xAABBCCDDUL}; + uint8_t bytes[8] = {0}; + + isaac_uint32_to_little_endian(bytes, values, 2); + + atto_eq(4, sizeof(uint32_t)); + atto_eq(bytes[0], 0x04); + atto_eq(bytes[1], 0x03); + atto_eq(bytes[2], 0x02); + atto_eq(bytes[3], 0x01); + atto_eq(bytes[4], 0xDD); + atto_eq(bytes[5], 0xCC); + atto_eq(bytes[6], 0xBB); + atto_eq(bytes[7], 0xAA); +} + +static void test_to_big_endian(void) +{ + const uint32_t values[2] = {0x01020304UL, 0xAABBCCDDUL}; + uint8_t bytes[2 * sizeof(uint32_t)] = {0}; + + isaac_uint32_to_big_endian(bytes, values, 2); + + atto_eq(bytes[0], 0x01); + atto_eq(bytes[1], 0x02); + atto_eq(bytes[2], 0x03); + atto_eq(bytes[3], 0x04); + atto_eq(bytes[4], 0xAA); + atto_eq(bytes[5], 0xBB); + atto_eq(bytes[6], 0xCC); + atto_eq(bytes[7], 0xDD); +} + +void test_isaac_convert(void) +{ + test_to_little_endian(); + test_to_big_endian(); +} diff --git a/tst/test_next.c b/tst/test_stream.c similarity index 77% rename from tst/test_next.c rename to tst/test_stream.c index e8353c3..4b76600 100644 --- a/tst/test_next.c +++ b/tst/test_stream.c @@ -19,7 +19,7 @@ * In particular this is the value printed by next_values_zero_seed() * in generate.c */ -const static uint32_t expected_next_results[EXPECTED_NEXT_ELEMENTS] = { +const static uint32_t expected_stream_with_zero_seed[EXPECTED_NEXT_ELEMENTS] = { 0x182600F3UL, 0x300B4A8DUL, 0x301B6622UL, 0xB08ACD21UL, 0x296FD679UL, 0x995206E9UL, 0xB3FFA8B5UL, 0x0FC99C24UL, 0x5F071FAFUL, 0x52251DEFUL, 0x894F41C2UL, 0xCC4C9AFBUL, 0x96C33F74UL, 0x347CB71DUL, 0xC90F8FBDUL, @@ -133,7 +133,7 @@ const static uint32_t expected_next_results[EXPECTED_NEXT_ELEMENTS] = { * In particular this is the value printed by next_values_nonzero_seed() * in generate.c */ -const static uint32_t expected_next32_with_nonzero_seed[EXPECTED_NEXT_ELEMENTS] = { +const static uint32_t expected_stream_with_nonzero_seed[EXPECTED_NEXT_ELEMENTS] = { 0x23956226UL, 0xA9E1CEBFUL, 0x3EA230EBUL, 0x8175D70DUL, 0xD8B699F5UL, 0xB4F5C36AUL, 0xB23790CFUL, 0xAEEB9340UL, 0x6F7B8DCDUL, 0x3258B530UL, 0x4A03FAD4UL, 0x01B103BDUL, 0xB7A31E4FUL, 0x342846F3UL, 0x3EAF2975UL, @@ -239,174 +239,72 @@ const static uint32_t expected_next32_with_nonzero_seed[EXPECTED_NEXT_ELEMENTS] 0xDE0FE6D6UL, 0x5521DA1BUL, }; -static void test_next32_a_few(void) +static void test_stream_with_zero_seed(void) { isaac_ctx_t ctx; isaac_init(&ctx, NULL, 0); // Zero seed - uint32_t next; + uint32_t stream[300] = {0}; - next = isaac_next32(&ctx); - atto_eq(next, expected_next_results[0]); + isaac_stream32(&ctx, stream, 300); - next = isaac_next32(&ctx); - atto_eq(next, expected_next_results[1]); - - next = isaac_next32(&ctx); - atto_eq(next, expected_next_results[2]); + atto_neq(stream[0], 0); + atto_memeq(stream, expected_stream_with_zero_seed, 300 * sizeof(uint32_t)); + atto_eq(ctx.next32_index, 256 * 2 - 300 - 1); } -static void test_next32_all(void) +static void test_stream_with_zero_seed_multiple_calls(void) { - uint32_t result; isaac_ctx_t ctx; isaac_init(&ctx, NULL, 0); // Zero seed - for (uint_fast32_t i = 0; i < EXPECTED_NEXT_ELEMENTS; i++) - { - result = isaac_next32(&ctx); - atto_eq(result, expected_next_results[i]); - } -} - -static void test_next8_a_few(void) -{ - isaac_ctx_t ctx; - isaac_init(&ctx, NULL, 0); // Zero seed - uint8_t next; - - next = isaac_next8(&ctx); - atto_eq(next, (expected_next_results[0] >> 0U) & 0xFFU); - next = isaac_next8(&ctx); - atto_eq(next, (expected_next_results[0] >> 8U) & 0xFFU); - next = isaac_next8(&ctx); - atto_eq(next, (expected_next_results[0] >> 16U) & 0xFFU); - next = isaac_next8(&ctx); - atto_eq(next, (expected_next_results[0] >> 24U) & 0xFFU); + uint32_t stream[300] = {0}; - next = isaac_next8(&ctx); - atto_eq(next, (expected_next_results[1] >> 0U) & 0xFFU); - next = isaac_next8(&ctx); - atto_eq(next, (expected_next_results[1] >> 8U) & 0xFFU); - next = isaac_next8(&ctx); - atto_eq(next, (expected_next_results[1] >> 16U) & 0xFFU); - next = isaac_next8(&ctx); - atto_eq(next, (expected_next_results[1] >> 24U) & 0xFFU); - - next = isaac_next8(&ctx); - atto_eq(next, (expected_next_results[2] >> 0U) & 0xFFU); - next = isaac_next8(&ctx); - atto_eq(next, (expected_next_results[2] >> 8U) & 0xFFU); - next = isaac_next8(&ctx); - atto_eq(next, (expected_next_results[2] >> 16U) & 0xFFU); - next = isaac_next8(&ctx); - atto_eq(next, (expected_next_results[2] >> 24U) & 0xFFU); -} - -static void test_next8_all(void) -{ - uint8_t result; - isaac_ctx_t ctx; - isaac_init(&ctx, NULL, 0); // Zero seed - for (uint_fast32_t i = 0; i < EXPECTED_NEXT_ELEMENTS; i++) + for (uint16_t i = 0; i < 100; i++) { - for (uint_fast8_t byte = 0; byte < 4; byte++) - { - result = isaac_next8(&ctx); - atto_eq(result, (expected_next_results[i] >> byte * 8U) & 0xFFU); - } + isaac_stream32(&ctx, &stream[3 * i], 3); } -} - -static void test_next32_a_few_with_nonzero_seed(void) -{ - isaac_ctx_t ctx; - const uint8_t seed[8] = {1, 2, 3, 4, 5, 6, 7, 8}; - isaac_init(&ctx, seed, 8); - uint32_t next; - - next = isaac_next32(&ctx); - atto_eq(next, expected_next32_with_nonzero_seed[0]); - next = isaac_next32(&ctx); - atto_eq(next, expected_next32_with_nonzero_seed[1]); - - next = isaac_next32(&ctx); - atto_eq(next, expected_next32_with_nonzero_seed[2]); + atto_neq(stream[0], 0); + atto_memeq(stream, expected_stream_with_zero_seed, 300 * sizeof(uint32_t)); + atto_eq(ctx.next32_index, 256 * 2 - 300 - 1); } -static void test_next32_all_with_nonzero_seed(void) +static void test_stream_with_nonzero_seed(void) { - uint32_t result; isaac_ctx_t ctx; const uint8_t seed[8] = {1, 2, 3, 4, 5, 6, 7, 8}; isaac_init(&ctx, seed, 8); - for (uint_fast32_t i = 0; i < EXPECTED_NEXT_ELEMENTS; i++) - { - result = isaac_next32(&ctx); - atto_eq(result, expected_next32_with_nonzero_seed[i]); - } -} + uint32_t stream[300] = {0}; -static void test_next8_a_few_with_nonzero_seed(void) -{ - isaac_ctx_t ctx; - const uint8_t seed[8] = {1, 2, 3, 4, 5, 6, 7, 8}; - isaac_init(&ctx, seed, 8); - uint8_t next; + isaac_stream32(&ctx, stream, 300); - next = isaac_next8(&ctx); - atto_eq(next, (expected_next32_with_nonzero_seed[0] >> 0U) & 0xFFU); - next = isaac_next8(&ctx); - atto_eq(next, (expected_next32_with_nonzero_seed[0] >> 8U) & 0xFFU); - next = isaac_next8(&ctx); - atto_eq(next, (expected_next32_with_nonzero_seed[0] >> 16U) & 0xFFU); - next = isaac_next8(&ctx); - atto_eq(next, (expected_next32_with_nonzero_seed[0] >> 24U) & 0xFFU); - - next = isaac_next8(&ctx); - atto_eq(next, (expected_next32_with_nonzero_seed[1] >> 0U) & 0xFFU); - next = isaac_next8(&ctx); - atto_eq(next, (expected_next32_with_nonzero_seed[1] >> 8U) & 0xFFU); - next = isaac_next8(&ctx); - atto_eq(next, (expected_next32_with_nonzero_seed[1] >> 16U) & 0xFFU); - next = isaac_next8(&ctx); - atto_eq(next, (expected_next32_with_nonzero_seed[1] >> 24U) & 0xFFU); - - next = isaac_next8(&ctx); - atto_eq(next, (expected_next32_with_nonzero_seed[2] >> 0U) & 0xFFU); - next = isaac_next8(&ctx); - atto_eq(next, (expected_next32_with_nonzero_seed[2] >> 8U) & 0xFFU); - next = isaac_next8(&ctx); - atto_eq(next, (expected_next32_with_nonzero_seed[2] >> 16U) & 0xFFU); - next = isaac_next8(&ctx); - atto_eq(next, (expected_next32_with_nonzero_seed[2] >> 24U) & 0xFFU); + atto_neq(stream[0], 0); + atto_memeq(stream, expected_stream_with_nonzero_seed, + 300 * sizeof(uint32_t)); + atto_eq(ctx.next32_index, 256 * 2 - 300 - 1); } -static void test_next8_all_with_nonzero_seed(void) +static void test_stream_with_nonzero_seed_multiple_calls(void) { - uint8_t result; isaac_ctx_t ctx; const uint8_t seed[8] = {1, 2, 3, 4, 5, 6, 7, 8}; isaac_init(&ctx, seed, 8); - for (uint_fast16_t i = 0; i < EXPECTED_NEXT_ELEMENTS; i++) + uint32_t stream[300] = {0}; + + for (uint16_t i = 0; i < 100; i++) { - for (uint_fast8_t byte = 0; byte < 4; byte++) - { - result = isaac_next8(&ctx); - atto_eq(result, - (expected_next32_with_nonzero_seed[i] >> byte * 8U) & - 0xFFU); - } + isaac_stream32(&ctx, &stream[3 * i], 3); } + + atto_neq(stream[0], 0); + atto_memeq(stream, expected_stream_with_nonzero_seed, + 300 * sizeof(uint32_t)); + atto_eq(ctx.next32_index, 256 * 2 - 300 - 1); } void test_isaac_next(void) { - test_next32_a_few(); - test_next32_all(); - test_next8_a_few(); - test_next8_all(); - test_next32_a_few_with_nonzero_seed(); - test_next32_all_with_nonzero_seed(); - test_next8_a_few_with_nonzero_seed(); - test_next8_all_with_nonzero_seed(); + test_stream_with_zero_seed(); + test_stream_with_zero_seed_multiple_calls(); + test_stream_with_nonzero_seed(); + test_stream_with_nonzero_seed_multiple_calls(); } From 3cf0ce96387cc05c6638aaeb1fdcf0297ee52747 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matjaz=CC=8C?= Date: Mon, 27 Apr 2020 17:48:38 +0200 Subject: [PATCH 16/27] Remove unused 32-bit masks for portability They originate from the randport.c version of ISAAC; which uses 32-bit words on "long ints", which can be 64-bits wide on some machines. For this reason they are masked with 0xFFFFFFFFUL. This implementation of ISAAC does not have this issue as uint32_t types are used, which are fixed length and always 32 bits. --- src/isaac.c | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/src/isaac.c b/src/isaac.c index 0ee28ac..1f3960b 100644 --- a/src/isaac.c +++ b/src/isaac.c @@ -19,21 +19,21 @@ #define ISAAC_STEP(mix, a, b, mm, m, m2, r, x) \ { \ x = *m; \ - a = ((a^(mix)) + *(m2++)); \ - *(m++) = y = (ISAAC_IND(mm, x) + a + b); \ - *(r++) = b = (ISAAC_IND(mm, y >> 8U) + x) & UINT32_MAX; \ + a = (a^(mix)) + *(m2++); \ + *(m++) = y = ISAAC_IND(mm, x) + a + b; \ + *(r++) = b = ISAAC_IND(mm, y >> 8U) + x; \ } #define ISAAC_MIX(a, b, c, d, e, f, g, h) \ { \ - a ^= b << 11U; d += a; b += c; \ - b ^= (c & UINT32_MAX) >> 2U; e += b; c += d; \ - c ^= d << 8U; f += c; d += e; \ - d ^= (e & UINT32_MAX) >> 16U; g += d; e += f; \ - e ^= f << 10U; h += e; f += g; \ - f ^= (g & UINT32_MAX) >> 4U; a += f; g += h; \ - g ^= h << 8U; b += g; h += a; \ - h ^= (a & UINT32_MAX) >> 9U; c += h; a += b; \ + a ^= b << 11U; d += a; b += c; \ + b ^= c >> 2U; e += b; c += d; \ + c ^= d << 8U; f += c; d += e; \ + d ^= e >> 16U; g += d; e += f; \ + e ^= f << 10U; h += e; f += g; \ + f ^= g >> 4U; a += f; g += h; \ + g ^= h << 8U; b += g; h += a; \ + h ^= a >> 9U; c += h; a += b; \ } /* Explanations why it does not look like 1.618033988749894848...: @@ -175,16 +175,16 @@ static void isaac_shuffle(isaac_ctx_t* const ctx) for (m = mm, mend = m2 = m + (ISAAC_U32_ELEMENTS / 2U); m < mend;) { ISAAC_STEP(a << 13U, a, b, mm, m, m2, r, x); - ISAAC_STEP((a & UINT32_MAX) >> 6U, a, b, mm, m, m2, r, x); + ISAAC_STEP(a >> 6U, a, b, mm, m, m2, r, x); ISAAC_STEP(a << 2U, a, b, mm, m, m2, r, x); - ISAAC_STEP((a & UINT32_MAX) >> 16U, a, b, mm, m, m2, r, x); + ISAAC_STEP(a >> 16U, a, b, mm, m, m2, r, x); } for (m2 = mm; m2 < mend;) { ISAAC_STEP(a << 13U, a, b, mm, m, m2, r, x); - ISAAC_STEP((a & UINT32_MAX) >> 6U, a, b, mm, m, m2, r, x); + ISAAC_STEP(a >> 6U, a, b, mm, m, m2, r, x); ISAAC_STEP(a << 2U, a, b, mm, m, m2, r, x); - ISAAC_STEP((a & UINT32_MAX) >> 16U, a, b, mm, m, m2, r, x); + ISAAC_STEP(a >> 16U, a, b, mm, m, m2, r, x); } ctx->b = b; ctx->a = a; From 8911ff6ca181f15e61e8e3b31c35850c5183df1c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matjaz=CC=8C?= Date: Mon, 27 Apr 2020 17:54:32 +0200 Subject: [PATCH 17/27] Delete dead code --- src/isaac.c | 51 --------------------------------------------------- 1 file changed, 51 deletions(-) diff --git a/src/isaac.c b/src/isaac.c index 1f3960b..cc12c5f 100644 --- a/src/isaac.c +++ b/src/isaac.c @@ -190,41 +190,6 @@ static void isaac_shuffle(isaac_ctx_t* const ctx) ctx->a = a; } -uint32_t isaac_next32(isaac_ctx_t* const ctx) -{ - const uint32_t next32 = ctx->result[ctx->next32_index]; - if (ctx->next32_index == 0) - { - /* This is the last value we could extract before the reshuffle. */ - isaac_shuffle(ctx); - ctx->next32_index = ISAAC_U32_ELEMENTS - 1; - } - else - { - ctx->next32_index--; - } - return next32; -} - -uint8_t isaac_next8(isaac_ctx_t* const ctx) -{ - /* We read the same next32 value 4 times and extract 4 different bytes from - * it, one per next8 call. */ - const uint8_t next8 = (uint8_t) ( - ctx->result[ctx->next32_index] >> ctx->next8_index * 8U - ); - if (ctx->next8_index >= 3) - { - ctx->next8_index = 0; - isaac_next32(ctx); - } - else - { - ctx->next8_index++; - } - return next8; -} - #define isaac_min(a, b) ((a) < (b)) ? (a) : (b) void isaac_stream32(isaac_ctx_t* const ctx, uint32_t* ints, size_t amount) @@ -252,22 +217,6 @@ void isaac_stream32(isaac_ctx_t* const ctx, uint32_t* ints, size_t amount) while (amount); } -static inline void uint32_to_le(uint8_t* bytes, uint32_t value) -{ - *bytes++ = (uint8_t) (value); - value >>= 8U; - *bytes++ = (uint8_t) (value); - value >>= 8U; - *bytes++ = (uint8_t) (value); - value >>= 8U; - *bytes = (uint8_t) (value); -} - -static inline void uint32_to_be(uint8_t* bytes, uint32_t value) -{ - -} - void isaac_uint32_to_little_endian(uint8_t* bytes, const uint32_t* values, size_t amount_of_values) From 1cb5efef76bc9e39a852fa80d709ba21073418ed Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matjaz=CC=8C?= Date: Mon, 27 Apr 2020 18:15:25 +0200 Subject: [PATCH 18/27] Add untested 64-bit ISAAC version - Taken from isaac64.c and isaac64.h original implementation - Renamed pretty much everything in the API to avoid having the number 32 in the names of the functions. This allows to have the same API names regardless of the implementation. The only change is in the uint32_t vs. uint64_t data types --- CMakeLists.txt | 9 +- inc/isaac.h | 35 +++--- src/isaac.c | 35 +++--- src/isaac64.c | 262 +++++++++++++++++++++++++++++++++++++++++++++ tst/test_convert.c | 4 +- tst/test_init.c | 6 +- tst/test_stream.c | 16 +-- 7 files changed, 317 insertions(+), 50 deletions(-) create mode 100644 src/isaac64.c diff --git a/CMakeLists.txt b/CMakeLists.txt index f5fff38..0d58648 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -40,7 +40,8 @@ set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} \ -funroll-loops") include_directories(inc/) -set(LIB_FILES src/isaac.c) +set(LIB32_FILES src/isaac.c) +set(LIB64_FILES src/isaac64.c) include_directories(tst/ tst/atto/) set(TEST_FILES tst/test.c @@ -49,8 +50,10 @@ set(TEST_FILES tst/test_convert.c tst/atto/atto.c) -add_library("isaac" STATIC ${LIB_FILES}) -add_executable("testisaac" ${LIB_FILES} ${TEST_FILES}) +add_library("isaac32" STATIC ${LIB32_FILES}) +add_library("isaac64" STATIC ${LIB64_FILES}) +add_executable("testisaac32" ${LIB32_FILES} ${TEST_FILES}) +add_executable("testisaac64" ${LIB64_FILES} ${TEST_FILES}) include_directories(tst/original/) add_executable("generatevectors" diff --git a/inc/isaac.h b/inc/isaac.h index 3ee0553..5cf7e02 100644 --- a/inc/isaac.h +++ b/inc/isaac.h @@ -15,8 +15,8 @@ * ISAAC and its original source code is created by Bob Jenkins and * released into the public domain. * - * This implementation is based on the `randport.c` implementation, which uses - * 32-bit words while being portable onto 64 bit machines. + * This implementation is based on the original `rand.c` implementation, which + * uses 32-bit words. * * @copyright Copyright © 2020, Matjaž Guštin * . All rights reserved. @@ -39,8 +39,8 @@ extern "C" #include #include -#define ISAAC_U32_ELEMENTS 256U -#define ISAAC_SEED_MAX_BYTES ISAAC_U32_ELEMENTS +#define ISAAC_ELEMENTS 256U +#define ISAAC_SEED_MAX_BYTES ISAAC_ELEMENTS /** * Context of the ISAAC CPRNG. @@ -49,13 +49,18 @@ extern "C" */ typedef struct { - uint32_t result[ISAAC_U32_ELEMENTS]; - uint32_t mem[ISAAC_U32_ELEMENTS]; + uint32_t result[ISAAC_ELEMENTS]; + uint32_t mem[ISAAC_ELEMENTS]; uint32_t a; uint32_t b; uint32_t c; - uint16_t next32_index; - uint16_t next8_index; + /** + * Index of the next 32-bit value to output in the stream. + * + * Note: this value could be a uint16_t instead of a uint32_t, but by using + * a uint32_t we avoid any padding at the end of the struct. + */ + uint32_t next_index; } isaac_ctx_t; /** @@ -121,7 +126,7 @@ void isaac_init(isaac_ctx_t* ctx, const uint8_t* seed, uint16_t seed_bytes); * @param[out] ints pseudo-random integers. * @param[in] amount quantity of 32-bit integers to generate. */ -void isaac_stream32(isaac_ctx_t* ctx, uint32_t* ints, size_t amount); +void isaac_stream(isaac_ctx_t* const ctx, uint32_t* ints, size_t amount); /** * Utility function, converting an array of 32-bit integers into bytes using @@ -135,9 +140,9 @@ void isaac_stream32(isaac_ctx_t* ctx, uint32_t* ints, size_t amount); * @param[in] amount_of_values quantity of 32-bit integers in the \p values * buffer. */ -void isaac_uint32_to_little_endian(uint8_t* bytes, - const uint32_t* values, - size_t amount_of_values); +void isaac_to_little_endian(uint8_t* bytes, + const uint32_t* values, + size_t amount_of_values); /** * Utility function, converting an array of 32-bit integers into bytes using @@ -151,9 +156,9 @@ void isaac_uint32_to_little_endian(uint8_t* bytes, * @param[in] amount_of_values quantity of 32-bit integers in the \p values * buffer */ -void isaac_uint32_to_big_endian(uint8_t* bytes, - const uint32_t* values, - size_t amount_of_values); +void isaac_to_big_endian(uint8_t* bytes, + const uint32_t* values, + size_t amount_of_values); #ifdef __cplusplus diff --git a/src/isaac.c b/src/isaac.c index cc12c5f..20be8c0 100644 --- a/src/isaac.c +++ b/src/isaac.c @@ -14,7 +14,7 @@ #include "isaac.h" -#define ISAAC_IND(mm, x) ((mm)[(x >> 2U) & (ISAAC_U32_ELEMENTS - 1)]) +#define ISAAC_IND(mm, x) ((mm)[(x >> 2U) & (ISAAC_ELEMENTS - 1)]) #define ISAAC_STEP(mix, a, b, mm, m, m2, r, x) \ { \ @@ -67,7 +67,7 @@ void isaac_init(isaac_ctx_t* const ctx, } set_seed(ctx, seed, seed_bytes); /* Initialise using the contents of result[] as the seed. */ - for (i = 0; i < ISAAC_U32_ELEMENTS; i += 8) + for (i = 0; i < ISAAC_ELEMENTS; i += 8) { a += ctx->result[i + 0]; b += ctx->result[i + 1]; @@ -88,7 +88,7 @@ void isaac_init(isaac_ctx_t* const ctx, ctx->mem[i + 7] = h; } /* Do a second pass to make all of the seed affect all of ctx->mem. */ - for (i = 0; i < ISAAC_U32_ELEMENTS; i += 8) + for (i = 0; i < ISAAC_ELEMENTS; i += 8) { a += ctx->mem[i + 0]; b += ctx->mem[i + 1]; @@ -111,8 +111,7 @@ void isaac_init(isaac_ctx_t* const ctx, /* Fill in the first set of results. */ isaac_shuffle(ctx); /* Prepare to use the first set of results with next32() and next8(). */ - ctx->next32_index = ISAAC_U32_ELEMENTS - 1; - ctx->next8_index = 0; + ctx->next_index = ISAAC_ELEMENTS - 1; } /** @@ -172,7 +171,7 @@ static void isaac_shuffle(isaac_ctx_t* const ctx) uint32_t x; uint32_t y; - for (m = mm, mend = m2 = m + (ISAAC_U32_ELEMENTS / 2U); m < mend;) + for (m = mm, mend = m2 = m + (ISAAC_ELEMENTS / 2U); m < mend;) { ISAAC_STEP(a << 13U, a, b, mm, m, m2, r, x); ISAAC_STEP(a >> 6U, a, b, mm, m, m2, r, x); @@ -192,7 +191,7 @@ static void isaac_shuffle(isaac_ctx_t* const ctx) #define isaac_min(a, b) ((a) < (b)) ? (a) : (b) -void isaac_stream32(isaac_ctx_t* const ctx, uint32_t* ints, size_t amount) +void isaac_stream(isaac_ctx_t* const ctx, uint32_t* ints, size_t amount) { if (ctx == NULL || ints == NULL) { @@ -200,26 +199,26 @@ void isaac_stream32(isaac_ctx_t* const ctx, uint32_t* ints, size_t amount) } do { - const size_t available = isaac_min(ctx->next32_index + 1, amount); + const size_t available = isaac_min(ctx->next_index + 1, amount); for (uint_fast16_t i = 0; i < available; i++) { - *ints++ = ctx->result[ctx->next32_index--]; + *ints++ = ctx->result[ctx->next_index--]; } amount -= available; - if (ctx->next32_index >= ISAAC_U32_ELEMENTS) + if (ctx->next_index >= ISAAC_ELEMENTS) { - /* next32_index underflow, thus out of elements. Reshuffling + /* next_index underflow, thus out of elements. Reshuffling * and preparing new batch of elements. */ isaac_shuffle(ctx); - ctx->next32_index = ISAAC_U32_ELEMENTS - 1; + ctx->next_index = ISAAC_ELEMENTS - 1; } } while (amount); } -void isaac_uint32_to_little_endian(uint8_t* bytes, - const uint32_t* values, - size_t amount_of_values) +void isaac_to_little_endian(uint8_t* bytes, + const uint32_t* values, + size_t amount_of_values) { if (bytes == NULL || values == NULL) { @@ -236,9 +235,9 @@ void isaac_uint32_to_little_endian(uint8_t* bytes, } } -void isaac_uint32_to_big_endian(uint8_t* bytes, - const uint32_t* values, - size_t amount_of_values) +void isaac_to_big_endian(uint8_t* bytes, + const uint32_t* values, + size_t amount_of_values) { if (bytes == NULL || values == NULL) { diff --git a/src/isaac64.c b/src/isaac64.c new file mode 100644 index 0000000..3c92bb6 --- /dev/null +++ b/src/isaac64.c @@ -0,0 +1,262 @@ +/** + * @file + * + * LibISAAC implementation. + * + * Basic on the 32-bit portable implementation by Bob Jenkins, originally + * public domain: + * https://www.burtleburtle.net/bob/c/randport.c + * + * @copyright Copyright © 2020, Matjaž Guštin + * . All rights reserved. + * @license BSD 3-clause license. + */ + +#include "isaac64.h" + +#define ISAAC_IND(mm, x) (*(uint64_t*)((uint8_t*)(mm) \ + + ((x) & ((ISAAC_ELEMENTS - 1) << 3)))) + +#define ISAAC_STEP(mix, a, b, mm, m, m2, r, x) \ +{ \ + x = *m; \ + a = (mix) + *(m2++); \ + *(m++) = y = ISAAC_IND(mm, x) + a + b; \ + *(r++) = b = ISAAC_IND(mm, y >> 8U) + x; \ +} + +#define ISAAC_MIX(a, b, c, d, e, f, g, h) \ +{ \ + a -= e; f ^= h >> 9U; h += a; \ + b -= f; g ^= a << 9U; a += b; \ + c -= g; h ^= b >> 23U; b += c; \ + d -= h; a ^= c << 15U; c += d; \ + e -= a; b ^= d >> 14U; d += e; \ + f -= b; c ^= e << 20U; e += f; \ + g -= c; d ^= f >> 17U; f += g; \ + h -= d; e ^= g << 14U; g += h; \ +} + +/* Explanations why it does not look like 1.618033988749894848...: + * https://stackoverflow.com/a/4948967 + * https://softwareengineering.stackexchange.com/a/63605 + */ +#define GOLDEN_RATIO 0x9e3779b97f4a7c13LL + +static void isaac_shuffle(isaac_ctx_t* ctx); + +static void set_seed(isaac_ctx_t* ctx, + const uint8_t* seed, + uint16_t seed_bytes); + +void isaac_init(isaac_ctx_t* const ctx, + const uint8_t* const seed, + const uint16_t seed_bytes) +{ + if (ctx == NULL) + { + return; + } + uint64_t a, b, c, d, e, f, g, h; + uint_fast16_t i; /* Fastest index over elements in result[] and mem[]. */ + ctx->a = ctx->b = ctx->c = 0; + a = b = c = d = e = f = g = h = GOLDEN_RATIO; + /* Scramble it */ + for (i = 0; i < 4; i++) + { + ISAAC_MIX(a, b, c, d, e, f, g, h); + } + set_seed(ctx, seed, seed_bytes); + /* Initialise using the contents of result[] as the seed. */ + for (i = 0; i < ISAAC_ELEMENTS; i += 8) + { + a += ctx->result[i + 0]; + b += ctx->result[i + 1]; + c += ctx->result[i + 2]; + d += ctx->result[i + 3]; + e += ctx->result[i + 4]; + f += ctx->result[i + 5]; + g += ctx->result[i + 6]; + h += ctx->result[i + 7]; + ISAAC_MIX(a, b, c, d, e, f, g, h); + ctx->mem[i + 0] = a; + ctx->mem[i + 1] = b; + ctx->mem[i + 2] = c; + ctx->mem[i + 3] = d; + ctx->mem[i + 4] = e; + ctx->mem[i + 5] = f; + ctx->mem[i + 6] = g; + ctx->mem[i + 7] = h; + } + /* Do a second pass to make all of the seed affect all of ctx->mem. */ + for (i = 0; i < ISAAC_ELEMENTS; i += 8) + { + a += ctx->mem[i + 0]; + b += ctx->mem[i + 1]; + c += ctx->mem[i + 2]; + d += ctx->mem[i + 3]; + e += ctx->mem[i + 4]; + f += ctx->mem[i + 5]; + g += ctx->mem[i + 6]; + h += ctx->mem[i + 7]; + ISAAC_MIX(a, b, c, d, e, f, g, h); + ctx->mem[i + 0] = a; + ctx->mem[i + 1] = b; + ctx->mem[i + 2] = c; + ctx->mem[i + 3] = d; + ctx->mem[i + 4] = e; + ctx->mem[i + 5] = f; + ctx->mem[i + 6] = g; + ctx->mem[i + 7] = h; + } + /* Fill in the first set of results. */ + isaac_shuffle(ctx); + /* Prepare to use the first set of results with next32() and next8(). */ + ctx->next64_index = ISAAC_ELEMENTS - 1; +} + +/** + * @internal + * Copies the seed into ctx->result[], padding it with zeros. + * + * @param ctx the ISAAC state + * @param seed bytes of the seed. If NULL, a zero-seed is used. + * @param seed_bytes amount of bytes in the seed. + */ +static void set_seed(isaac_ctx_t* const ctx, + const uint8_t* const seed, + uint16_t seed_bytes) +{ + uint_fast16_t i; + if (seed != NULL) + { + if (seed_bytes > ISAAC_SEED_MAX_BYTES) + { + seed_bytes = ISAAC_SEED_MAX_BYTES; + } + for (i = 0; i < seed_bytes; i++) + { + /* The copy is performed VALUE-wise, not byte wise. + * By doing so we have same result[] on architectures with different + * endianness. */ + ctx->result[i] = seed[i]; + } + } + else + { + seed_bytes = 0; + } + for (i = seed_bytes; i < ISAAC_SEED_MAX_BYTES; i++) + { + ctx->result[i] = 0; + } +} + +/** + * @internal + * Permutes the ISAAC state. + * + * Maps to `void isaac(randctx*)` from the original implementation. + * + * @param ctx the ISAAC state + */ +static void isaac_shuffle(isaac_ctx_t* const ctx) +{ + uint64_t* m; + uint64_t* mm = ctx->mem; + uint64_t* m2; + uint64_t* r = ctx->result; + uint64_t* mend; + uint64_t a = ctx->a; + uint64_t b = ctx->b + (++ctx->c); + uint64_t x; + uint64_t y; + + for (m = mm, mend = m2 = m + (ISAAC_ELEMENTS / 2U); m < mend;) + { + ISAAC_STEP(~(a ^ (a << 21U)), a, b, mm, m, m2, r, x); + ISAAC_STEP(a ^ (a >> 5U), a, b, mm, m, m2, r, x); + ISAAC_STEP(a ^ (a << 12U), a, b, mm, m, m2, r, x); + ISAAC_STEP(a ^ (a >> 33U), a, b, mm, m, m2, r, x); + } + for (m2 = mm; m2 < mend;) + { + ISAAC_STEP(~(a ^ (a << 21U)), a, b, mm, m, m2, r, x); + ISAAC_STEP(a ^ (a >> 5U), a, b, mm, m, m2, r, x); + ISAAC_STEP(a ^ (a << 12U), a, b, mm, m, m2, r, x); + ISAAC_STEP(a ^ (a >> 33U), a, b, mm, m, m2, r, x); + } + ctx->b = b; + ctx->a = a; +} + +#define isaac_min(a, b) ((a) < (b)) ? (a) : (b) + +void isaac_stream(isaac_ctx_t* const ctx, uint64_t* ints, size_t amount) +{ + if (ctx == NULL || ints == NULL) + { + return; + } + do + { + const size_t available = isaac_min(ctx->next_index + 1, amount); + for (uint_fast16_t i = 0; i < available; i++) + { + *ints++ = ctx->result[ctx->next_index--]; + } + amount -= available; + if (ctx->next_index >= ISAAC_ELEMENTS) + { + /* next_index underflow, thus out of elements. Reshuffling + * and preparing new batch of elements. */ + isaac_shuffle(ctx); + ctx->next_index = ISAAC_ELEMENTS - 1; + } + } + while (amount); +} + +void isaac_to_little_endian(uint8_t* bytes, + const uint64_t* values, + size_t amount_of_values) +{ + if (bytes == NULL || values == NULL) + { + return; + } + { + while (amount_of_values--) + { + *bytes++ = (uint8_t) (*values); + *bytes++ = (uint8_t) (*values >> 8U); + *bytes++ = (uint8_t) (*values >> 16U); + *bytes++ = (uint8_t) (*values >> 24U); + *bytes++ = (uint8_t) (*values >> 32U); + *bytes++ = (uint8_t) (*values >> 40U); + *bytes++ = (uint8_t) (*values >> 48U); + *bytes++ = (uint8_t) (*values++ >> 56U); + } + } +} + +void isaac_to_big_endian(uint8_t* bytes, + const uint64_t* values, + size_t amount_of_values) +{ + if (bytes == NULL || values == NULL) + { + return; + } + while (amount_of_values--) + { + *bytes++ = (uint8_t) (*values >> 56U); + *bytes++ = (uint8_t) (*values >> 48U); + *bytes++ = (uint8_t) (*values >> 40U); + *bytes++ = (uint8_t) (*values >> 32U); + *bytes++ = (uint8_t) (*values >> 24U); + *bytes++ = (uint8_t) (*values >> 16U); + *bytes++ = (uint8_t) (*values >> 8U); + *bytes++ = (uint8_t) (*values++); + } +} diff --git a/tst/test_convert.c b/tst/test_convert.c index 5165928..32eb753 100644 --- a/tst/test_convert.c +++ b/tst/test_convert.c @@ -15,7 +15,7 @@ static void test_to_little_endian(void) const uint32_t values[2] = {0x01020304UL, 0xAABBCCDDUL}; uint8_t bytes[8] = {0}; - isaac_uint32_to_little_endian(bytes, values, 2); + isaac_to_little_endian(bytes, values, 2); atto_eq(4, sizeof(uint32_t)); atto_eq(bytes[0], 0x04); @@ -33,7 +33,7 @@ static void test_to_big_endian(void) const uint32_t values[2] = {0x01020304UL, 0xAABBCCDDUL}; uint8_t bytes[2 * sizeof(uint32_t)] = {0}; - isaac_uint32_to_big_endian(bytes, values, 2); + isaac_to_big_endian(bytes, values, 2); atto_eq(bytes[0], 0x01); atto_eq(bytes[1], 0x02); diff --git a/tst/test_init.c b/tst/test_init.c index 2a7b387..049dd9d 100644 --- a/tst/test_init.c +++ b/tst/test_init.c @@ -11,8 +11,7 @@ #include "test.h" const static isaac_ctx_t zero_initialised_ctx = { - .next32_index = ISAAC_U32_ELEMENTS - 1, - .next8_index = 0, + .next_index = ISAAC_ELEMENTS - 1, .a = 0x44D22B48UL, .b = 0x182600F3UL, .c = 0x00000001UL, @@ -151,8 +150,7 @@ const static isaac_ctx_t zero_initialised_ctx = { }; const static isaac_ctx_t nonzero_initialised_ctx = { - .next32_index = ISAAC_U32_ELEMENTS - 1, - .next8_index = 0, + .next_index = ISAAC_ELEMENTS - 1, .a = 0xD131EDD6UL, .b = 0x23956226UL, .c = 0x00000001UL, diff --git a/tst/test_stream.c b/tst/test_stream.c index 4b76600..4e411f2 100644 --- a/tst/test_stream.c +++ b/tst/test_stream.c @@ -245,11 +245,11 @@ static void test_stream_with_zero_seed(void) isaac_init(&ctx, NULL, 0); // Zero seed uint32_t stream[300] = {0}; - isaac_stream32(&ctx, stream, 300); + isaac_stream(&ctx, stream, 300); atto_neq(stream[0], 0); atto_memeq(stream, expected_stream_with_zero_seed, 300 * sizeof(uint32_t)); - atto_eq(ctx.next32_index, 256 * 2 - 300 - 1); + atto_eq(ctx.next_index, 256 * 2 - 300 - 1); } static void test_stream_with_zero_seed_multiple_calls(void) @@ -260,12 +260,12 @@ static void test_stream_with_zero_seed_multiple_calls(void) for (uint16_t i = 0; i < 100; i++) { - isaac_stream32(&ctx, &stream[3 * i], 3); + isaac_stream(&ctx, &stream[3 * i], 3); } atto_neq(stream[0], 0); atto_memeq(stream, expected_stream_with_zero_seed, 300 * sizeof(uint32_t)); - atto_eq(ctx.next32_index, 256 * 2 - 300 - 1); + atto_eq(ctx.next_index, 256 * 2 - 300 - 1); } static void test_stream_with_nonzero_seed(void) @@ -275,12 +275,12 @@ static void test_stream_with_nonzero_seed(void) isaac_init(&ctx, seed, 8); uint32_t stream[300] = {0}; - isaac_stream32(&ctx, stream, 300); + isaac_stream(&ctx, stream, 300); atto_neq(stream[0], 0); atto_memeq(stream, expected_stream_with_nonzero_seed, 300 * sizeof(uint32_t)); - atto_eq(ctx.next32_index, 256 * 2 - 300 - 1); + atto_eq(ctx.next_index, 256 * 2 - 300 - 1); } static void test_stream_with_nonzero_seed_multiple_calls(void) @@ -292,13 +292,13 @@ static void test_stream_with_nonzero_seed_multiple_calls(void) for (uint16_t i = 0; i < 100; i++) { - isaac_stream32(&ctx, &stream[3 * i], 3); + isaac_stream(&ctx, &stream[3 * i], 3); } atto_neq(stream[0], 0); atto_memeq(stream, expected_stream_with_nonzero_seed, 300 * sizeof(uint32_t)); - atto_eq(ctx.next32_index, 256 * 2 - 300 - 1); + atto_eq(ctx.next_index, 256 * 2 - 300 - 1); } void test_isaac_next(void) From e7e0ce5abe2954ef71ed7e355913f6cc7f7d1f41 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matjaz=CC=8C?= Date: Mon, 27 Apr 2020 23:44:42 +0200 Subject: [PATCH 19/27] Combine 32 and 64 bit implementation into one .h and one .c file --- CMakeLists.txt | 15 +++++--- inc/isaac.h | 96 ++++++++++++++++++++++++++-------------------- src/isaac64.c | 87 +++++++++++++++++++++++++++++++++-------- tst/test_convert.c | 58 ++++++++++++++++++++++++++++ tst/test_stream.c | 16 ++++---- 5 files changed, 199 insertions(+), 73 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 0d58648..bc0be1b 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -40,8 +40,7 @@ set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} \ -funroll-loops") include_directories(inc/) -set(LIB32_FILES src/isaac.c) -set(LIB64_FILES src/isaac64.c) +set(LIB_FILES src/isaac64.c) include_directories(tst/ tst/atto/) set(TEST_FILES tst/test.c @@ -50,10 +49,14 @@ set(TEST_FILES tst/test_convert.c tst/atto/atto.c) -add_library("isaac32" STATIC ${LIB32_FILES}) -add_library("isaac64" STATIC ${LIB64_FILES}) -add_executable("testisaac32" ${LIB32_FILES} ${TEST_FILES}) -add_executable("testisaac64" ${LIB64_FILES} ${TEST_FILES}) +add_library(isaac32 STATIC ${LIB_FILES}) +target_compile_definitions(isaac32 PUBLIC ISAAC_BITS=32) +add_library(isaac64 STATIC ${LIB_FILES}) +target_compile_definitions(isaac64 PUBLIC ISAAC_BITS=64) +add_executable(testisaac32 ${LIB_FILES} ${TEST_FILES}) +target_compile_definitions(testisaac32 PUBLIC ISAAC_BITS=32) +add_executable(testisaac64 ${LIB_FILES} ${TEST_FILES}) +target_compile_definitions(testisaac64 PUBLIC ISAAC_BITS=64) include_directories(tst/original/) add_executable("generatevectors" diff --git a/inc/isaac.h b/inc/isaac.h index 5cf7e02..241cb3f 100644 --- a/inc/isaac.h +++ b/inc/isaac.h @@ -15,8 +15,8 @@ * ISAAC and its original source code is created by Bob Jenkins and * released into the public domain. * - * This implementation is based on the original `rand.c` implementation, which - * uses 32-bit words. + * This implementation is based on the original `rand.c` and + * `isaac64.c`, which uses 32-bit and 64-bit words respectively. * * @copyright Copyright © 2020, Matjaž Guštin * . All rights reserved. @@ -39,6 +39,17 @@ extern "C" #include #include +#ifndef ISAAC_BITS + #define ISAAC_BITS 64 +#endif +#if (ISAAC_BITS == 32) +typedef uint32_t isaac_uint_t; +#elif (ISAAC_BITS == 64) +typedef uint64_t isaac_uint_t; +#else +_Static_assert(0, "Only 32 or 64 bit words are supported."); +#endif + #define ISAAC_ELEMENTS 256U #define ISAAC_SEED_MAX_BYTES ISAAC_ELEMENTS @@ -49,18 +60,18 @@ extern "C" */ typedef struct { - uint32_t result[ISAAC_ELEMENTS]; - uint32_t mem[ISAAC_ELEMENTS]; - uint32_t a; - uint32_t b; - uint32_t c; + isaac_uint_t result[ISAAC_ELEMENTS]; + isaac_uint_t mem[ISAAC_ELEMENTS]; + isaac_uint_t a; + isaac_uint_t b; + isaac_uint_t c; /** - * Index of the next 32-bit value to output in the stream. + * Index of the next value to output in the stream. * - * Note: this value could be a uint16_t instead of a uint32_t, but by using - * a uint32_t we avoid any padding at the end of the struct. + * Note: this value could be a uint16_t instead of a isaac_uint_t, but by using + * a isaac_uint_t we avoid any padding at the end of the struct. */ - uint32_t next_index; + isaac_uint_t next_index; } isaac_ctx_t; /** @@ -68,17 +79,17 @@ typedef struct * * The seed is copied value-wise into the ISAAC state, not byte-wise. That * means that a uint8_t array {1,2,3,4} is copied into the ctx->result[] - * uint32_t array as {1,2,3,4,0,...,0}, where each value is a uint32_t value. + * isaac_uint_t array as {1,2,3,4,0,...,0}, where each value is a isaac_uint_t value. * Looking at the bytes and assuming little Endian byte order, the result is * {1,2,3,4} --> {1,0,0,0,2,0,0,0,3,0,0,0,4,0,0,0,0,...,0}. * * The reason behind this choice is to avoid issues with endianness; as ISAAC - * works on uint32_t values rather than their bytes, setting the uint32_t values + * works on isaac_uint_t values rather than their bytes, setting the isaac_uint_t values * and not their bytes, shall produce the same CPRNG stream on architectures - * with different endianness. A uint32_t* could also be a valid choice as seed + * with different endianness. A isaac_uint_t* could also be a valid choice as seed * input, but seeds are usually cryptographic keys and those are byte arrays, * so a developer could be confused on how to insert a uint8_t* seed into - * a uint32_t*. + * a isaac_uint_t*. * * Maps to `void randinit(randctx *r, word flag)` from the original * implementation. Equivalent to a true `flag` with a seed provided. The @@ -106,58 +117,59 @@ typedef struct void isaac_init(isaac_ctx_t* ctx, const uint8_t* seed, uint16_t seed_bytes); /** - * Provides the next pseudo-random 32-bit integers. + * Provides the next pseudo-random integer. * - * Because ISAAC works on 32-bit values, the stream is in 32-bit integers. + * Because ISAAC works on 32 or 64 bit values, the stream is in integers + * instead of bytes. * To convert them to bytes: - * - get some values into a uint32_t buffer with isaac_stream32() + * - get some values into a isaac_uint_t buffer with isaac_stream() * - allocate a uint8_t buffer - * - convert the uint32_t buffer to the uint8_t one using the utility functions - * isaac_uint32_to_le() or isaac_uint32_to_be() for little and big endian - * respectively. - * - * Every #ISAAC_U32_ELEMENTS uint32_t provided it will automatically reshuffle - * the ISAAC state to cache #ISAAC_U32_ELEMENTS new elements. This means that - * the first #ISAAC_U32_ELEMENTS values after seeding are very cheap (just - * copying values from the state) and the #ISAAC_U32_ELEMENTS+1st value is + * - convert the isaac_uint_t buffer to the uint8_t one using the utility functions + * isaac_to_little_endian() or isaac_to_big_endian() for little and big + * endian respectively. + * + * Every #ISAAC_ELEMENTS values provided it will automatically reshuffle + * the ISAAC state to cache #ISAAC_ELEMENTS new elements. This means that + * the first #ISAAC_ELEMENTS values after seeding are very cheap (just + * copying values from the state) and the #ISAAC_ELEMENTS+1st value is * more expensive. * * @param[in, out] ctx the ISAAC state, already initialised. * @param[out] ints pseudo-random integers. - * @param[in] amount quantity of 32-bit integers to generate. + * @param[in] amount quantity of 32-bit/64-bit integers to generate. */ -void isaac_stream(isaac_ctx_t* const ctx, uint32_t* ints, size_t amount); +void isaac_stream(isaac_ctx_t* const ctx, isaac_uint_t* ints, size_t amount); /** - * Utility function, converting an array of 32-bit integers into bytes using - * **little endian** byte order. + * Utility function, converting an array of 32-bit/64-bit integers into bytes + * using **little endian** byte order. * - * Useful to convert a stream of 32-bit integers to 8-bit values. + * Useful to convert a stream of 32-bit/64-bit integers to 8-bit values. * * @param[out] bytes 8-bit integers. Must be at least \p amount_of_values*4 * bytes long. - * @param[in] values 32-bit integers, as obtained from isaac_stream32() - * @param[in] amount_of_values quantity of 32-bit integers in the \p values - * buffer. + * @param[in] values 32-bit/64-bit integers, as obtained from isaac_stream() + * @param[in] amount_of_values quantity of 32-bit/64-bit integers in the + * \p values buffer. */ void isaac_to_little_endian(uint8_t* bytes, - const uint32_t* values, + const isaac_uint_t* values, size_t amount_of_values); /** - * Utility function, converting an array of 32-bit integers into bytes using - * **big endian** byte order. + * Utility function, converting an array of 32-bit/64-bit integers into bytes + * using **big endian** byte order. * - * Useful to convert a stream of 32-bit integers to 8-bit values. + * Useful to convert a stream of 32-bit/64-bit integers to 8-bit values. * * @param[out] bytes 8-bit integers. Must be at least \p amount_of_values*4 * bytes long. - * @param[in] values 32-bit integers, as obtained from isaac_stream32() - * @param[in] amount_of_values quantity of 32-bit integers in the \p values - * buffer + * @param[in] values 32-bit/64-bit integers, as obtained from isaac_stream() + * @param[in] amount_of_values quantity of 32-bit/64-bit integers in the + * \p values buffer. */ void isaac_to_big_endian(uint8_t* bytes, - const uint32_t* values, + const isaac_uint_t* values, size_t amount_of_values); diff --git a/src/isaac64.c b/src/isaac64.c index 3c92bb6..8150db4 100644 --- a/src/isaac64.c +++ b/src/isaac64.c @@ -12,8 +12,9 @@ * @license BSD 3-clause license. */ -#include "isaac64.h" +#include "isaac.h" +#if ISAAC_BITS > 32 #define ISAAC_IND(mm, x) (*(uint64_t*)((uint8_t*)(mm) \ + ((x) & ((ISAAC_ELEMENTS - 1) << 3)))) @@ -42,6 +43,37 @@ * https://softwareengineering.stackexchange.com/a/63605 */ #define GOLDEN_RATIO 0x9e3779b97f4a7c13LL +#else +#define ISAAC_IND(mm, x) ((mm)[(x >> 2U) & (ISAAC_ELEMENTS - 1)]) + +#define ISAAC_STEP(mix, a, b, mm, m, m2, r, x) \ +{ \ + x = *m; \ + a = (a^(mix)) + *(m2++); \ + *(m++) = y = ISAAC_IND(mm, x) + a + b; \ + *(r++) = b = ISAAC_IND(mm, y >> 8U) + x; \ +} + +#define ISAAC_MIX(a, b, c, d, e, f, g, h) \ +{ \ + a ^= b << 11U; d += a; b += c; \ + b ^= c >> 2U; e += b; c += d; \ + c ^= d << 8U; f += c; d += e; \ + d ^= e >> 16U; g += d; e += f; \ + e ^= f << 10U; h += e; f += g; \ + f ^= g >> 4U; a += f; g += h; \ + g ^= h << 8U; b += g; h += a; \ + h ^= a >> 9U; c += h; a += b; \ +} + +/* Explanations why it does not look like 1.618033988749894848...: + * https://stackoverflow.com/a/4948967 + * https://softwareengineering.stackexchange.com/a/63605 + */ +#define GOLDEN_RATIO 0x9e3779b9L +#endif + + static void isaac_shuffle(isaac_ctx_t* ctx); @@ -57,7 +89,7 @@ void isaac_init(isaac_ctx_t* const ctx, { return; } - uint64_t a, b, c, d, e, f, g, h; + isaac_uint_t a, b, c, d, e, f, g, h; uint_fast16_t i; /* Fastest index over elements in result[] and mem[]. */ ctx->a = ctx->b = ctx->c = 0; a = b = c = d = e = f = g = h = GOLDEN_RATIO; @@ -112,7 +144,7 @@ void isaac_init(isaac_ctx_t* const ctx, /* Fill in the first set of results. */ isaac_shuffle(ctx); /* Prepare to use the first set of results with next32() and next8(). */ - ctx->next64_index = ISAAC_ELEMENTS - 1; + ctx->next_index = ISAAC_ELEMENTS - 1; } /** @@ -162,16 +194,16 @@ static void set_seed(isaac_ctx_t* const ctx, */ static void isaac_shuffle(isaac_ctx_t* const ctx) { - uint64_t* m; - uint64_t* mm = ctx->mem; - uint64_t* m2; - uint64_t* r = ctx->result; - uint64_t* mend; - uint64_t a = ctx->a; - uint64_t b = ctx->b + (++ctx->c); - uint64_t x; - uint64_t y; - + isaac_uint_t* m; + isaac_uint_t* mm = ctx->mem; + isaac_uint_t* m2; + isaac_uint_t* r = ctx->result; + isaac_uint_t* mend; + isaac_uint_t a = ctx->a; + isaac_uint_t b = ctx->b + (++ctx->c); + isaac_uint_t x; + isaac_uint_t y; +#if ISAAC_BITS > 32 for (m = mm, mend = m2 = m + (ISAAC_ELEMENTS / 2U); m < mend;) { ISAAC_STEP(~(a ^ (a << 21U)), a, b, mm, m, m2, r, x); @@ -186,13 +218,29 @@ static void isaac_shuffle(isaac_ctx_t* const ctx) ISAAC_STEP(a ^ (a << 12U), a, b, mm, m, m2, r, x); ISAAC_STEP(a ^ (a >> 33U), a, b, mm, m, m2, r, x); } +#else + for (m = mm, mend = m2 = m + (ISAAC_ELEMENTS / 2U); m < mend;) + { + ISAAC_STEP(a << 13U, a, b, mm, m, m2, r, x); + ISAAC_STEP(a >> 6U, a, b, mm, m, m2, r, x); + ISAAC_STEP(a << 2U, a, b, mm, m, m2, r, x); + ISAAC_STEP(a >> 16U, a, b, mm, m, m2, r, x); + } + for (m2 = mm; m2 < mend;) + { + ISAAC_STEP(a << 13U, a, b, mm, m, m2, r, x); + ISAAC_STEP(a >> 6U, a, b, mm, m, m2, r, x); + ISAAC_STEP(a << 2U, a, b, mm, m, m2, r, x); + ISAAC_STEP(a >> 16U, a, b, mm, m, m2, r, x); + } +#endif ctx->b = b; ctx->a = a; } #define isaac_min(a, b) ((a) < (b)) ? (a) : (b) -void isaac_stream(isaac_ctx_t* const ctx, uint64_t* ints, size_t amount) +void isaac_stream(isaac_ctx_t* const ctx, isaac_uint_t* ints, size_t amount) { if (ctx == NULL || ints == NULL) { @@ -218,7 +266,7 @@ void isaac_stream(isaac_ctx_t* const ctx, uint64_t* ints, size_t amount) } void isaac_to_little_endian(uint8_t* bytes, - const uint64_t* values, + const isaac_uint_t* values, size_t amount_of_values) { if (bytes == NULL || values == NULL) @@ -232,16 +280,19 @@ void isaac_to_little_endian(uint8_t* bytes, *bytes++ = (uint8_t) (*values >> 8U); *bytes++ = (uint8_t) (*values >> 16U); *bytes++ = (uint8_t) (*values >> 24U); +#if ISAAC_BITS > 32 *bytes++ = (uint8_t) (*values >> 32U); *bytes++ = (uint8_t) (*values >> 40U); *bytes++ = (uint8_t) (*values >> 48U); - *bytes++ = (uint8_t) (*values++ >> 56U); + *bytes++ = (uint8_t) (*values >> 56U); +#endif + values++; } } } void isaac_to_big_endian(uint8_t* bytes, - const uint64_t* values, + const isaac_uint_t* values, size_t amount_of_values) { if (bytes == NULL || values == NULL) @@ -250,10 +301,12 @@ void isaac_to_big_endian(uint8_t* bytes, } while (amount_of_values--) { +#if ISAAC_BITS > 32 *bytes++ = (uint8_t) (*values >> 56U); *bytes++ = (uint8_t) (*values >> 48U); *bytes++ = (uint8_t) (*values >> 40U); *bytes++ = (uint8_t) (*values >> 32U); +#endif *bytes++ = (uint8_t) (*values >> 24U); *bytes++ = (uint8_t) (*values >> 16U); *bytes++ = (uint8_t) (*values >> 8U); diff --git a/tst/test_convert.c b/tst/test_convert.c index 32eb753..29c79d2 100644 --- a/tst/test_convert.c +++ b/tst/test_convert.c @@ -10,6 +10,61 @@ #include "test.h" +#if ISAAC_BITS > 32 + +static void test_to_little_endian(void) +{ + const uint64_t values[2] = {0x0102030405060708ULL, 0xAABBCCDD11223344ULL}; + uint8_t bytes[16] = {0}; + + isaac_to_little_endian(bytes, values, 2); + + atto_eq(8, sizeof(uint64_t)); + atto_eq(bytes[0], 0x08); + atto_eq(bytes[1], 0x07); + atto_eq(bytes[2], 0x06); + atto_eq(bytes[3], 0x05); + atto_eq(bytes[4], 0x04); + atto_eq(bytes[5], 0x03); + atto_eq(bytes[6], 0x02); + atto_eq(bytes[7], 0x01); + atto_eq(bytes[8], 0x44); + atto_eq(bytes[9], 0x33); + atto_eq(bytes[10], 0x22); + atto_eq(bytes[11], 0x11); + atto_eq(bytes[12], 0xDD); + atto_eq(bytes[13], 0xCC); + atto_eq(bytes[14], 0xBB); + atto_eq(bytes[15], 0xAA); +} + +static void test_to_big_endian(void) +{ + const uint64_t values[2] = {0x0102030405060708ULL, 0xAABBCCDD11223344ULL}; + uint8_t bytes[2 * sizeof(uint64_t)] = {0}; + + isaac_to_big_endian(bytes, values, 2); + + atto_eq(8, sizeof(uint64_t)); + atto_eq(bytes[0], 0x01); + atto_eq(bytes[1], 0x02); + atto_eq(bytes[2], 0x03); + atto_eq(bytes[3], 0x04); + atto_eq(bytes[4], 0x05); + atto_eq(bytes[5], 0x06); + atto_eq(bytes[6], 0x07); + atto_eq(bytes[7], 0x08); + atto_eq(bytes[8], 0xAA); + atto_eq(bytes[9], 0xBB); + atto_eq(bytes[10], 0xCC); + atto_eq(bytes[11], 0xDD); + atto_eq(bytes[12], 0x11); + atto_eq(bytes[13], 0x22); + atto_eq(bytes[14], 0x33); + atto_eq(bytes[15], 0x44); +} +#else + static void test_to_little_endian(void) { const uint32_t values[2] = {0x01020304UL, 0xAABBCCDDUL}; @@ -45,6 +100,9 @@ static void test_to_big_endian(void) atto_eq(bytes[7], 0xDD); } +#endif + + void test_isaac_convert(void) { test_to_little_endian(); diff --git a/tst/test_stream.c b/tst/test_stream.c index 4e411f2..4406fc8 100644 --- a/tst/test_stream.c +++ b/tst/test_stream.c @@ -243,12 +243,12 @@ static void test_stream_with_zero_seed(void) { isaac_ctx_t ctx; isaac_init(&ctx, NULL, 0); // Zero seed - uint32_t stream[300] = {0}; + isaac_uint_t stream[300] = {0}; isaac_stream(&ctx, stream, 300); atto_neq(stream[0], 0); - atto_memeq(stream, expected_stream_with_zero_seed, 300 * sizeof(uint32_t)); + atto_memeq(stream, expected_stream_with_zero_seed, 300 * sizeof(isaac_uint_t)); atto_eq(ctx.next_index, 256 * 2 - 300 - 1); } @@ -256,7 +256,7 @@ static void test_stream_with_zero_seed_multiple_calls(void) { isaac_ctx_t ctx; isaac_init(&ctx, NULL, 0); // Zero seed - uint32_t stream[300] = {0}; + isaac_uint_t stream[300] = {0}; for (uint16_t i = 0; i < 100; i++) { @@ -264,7 +264,7 @@ static void test_stream_with_zero_seed_multiple_calls(void) } atto_neq(stream[0], 0); - atto_memeq(stream, expected_stream_with_zero_seed, 300 * sizeof(uint32_t)); + atto_memeq(stream, expected_stream_with_zero_seed, 300 * sizeof(isaac_uint_t)); atto_eq(ctx.next_index, 256 * 2 - 300 - 1); } @@ -273,13 +273,13 @@ static void test_stream_with_nonzero_seed(void) isaac_ctx_t ctx; const uint8_t seed[8] = {1, 2, 3, 4, 5, 6, 7, 8}; isaac_init(&ctx, seed, 8); - uint32_t stream[300] = {0}; + isaac_uint_t stream[300] = {0}; isaac_stream(&ctx, stream, 300); atto_neq(stream[0], 0); atto_memeq(stream, expected_stream_with_nonzero_seed, - 300 * sizeof(uint32_t)); + 300 * sizeof(isaac_uint_t)); atto_eq(ctx.next_index, 256 * 2 - 300 - 1); } @@ -288,7 +288,7 @@ static void test_stream_with_nonzero_seed_multiple_calls(void) isaac_ctx_t ctx; const uint8_t seed[8] = {1, 2, 3, 4, 5, 6, 7, 8}; isaac_init(&ctx, seed, 8); - uint32_t stream[300] = {0}; + isaac_uint_t stream[300] = {0}; for (uint16_t i = 0; i < 100; i++) { @@ -297,7 +297,7 @@ static void test_stream_with_nonzero_seed_multiple_calls(void) atto_neq(stream[0], 0); atto_memeq(stream, expected_stream_with_nonzero_seed, - 300 * sizeof(uint32_t)); + 300 * sizeof(isaac_uint_t)); atto_eq(ctx.next_index, 256 * 2 - 300 - 1); } From 8e6ba8c541e98c1fd9c9285b95bea5e8ffa8ec16 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matjaz=CC=8C?= Date: Tue, 28 Apr 2020 20:29:16 +0200 Subject: [PATCH 20/27] Combine 32 and 64 bit version into one file, add 64-bit test vectors --- CMakeLists.txt | 7 +- src/isaac.c | 94 ++++++-- src/isaac64.c | 315 --------------------------- tst/test_init.c | 540 ++++++++++++++++++++++++++++++++++++++++++++++ tst/test_stream.c | 388 +++++++++++++++++++++++++++++++-- 5 files changed, 997 insertions(+), 347 deletions(-) delete mode 100644 src/isaac64.c diff --git a/CMakeLists.txt b/CMakeLists.txt index bc0be1b..de362c1 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -40,7 +40,7 @@ set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} \ -funroll-loops") include_directories(inc/) -set(LIB_FILES src/isaac64.c) +set(LIB_FILES src/isaac.c) include_directories(tst/ tst/atto/) set(TEST_FILES tst/test.c @@ -59,9 +59,12 @@ add_executable(testisaac64 ${LIB_FILES} ${TEST_FILES}) target_compile_definitions(testisaac64 PUBLIC ISAAC_BITS=64) include_directories(tst/original/) -add_executable("generatevectors" +add_executable("generatevectors32" tst/original/generate.c tst/original/randport.c) +add_executable("generatevectors64" + tst/original/generate64.c + tst/original/isaac64.c) # Doxygen documentation builder find_package(Doxygen) diff --git a/src/isaac.c b/src/isaac.c index 20be8c0..8150db4 100644 --- a/src/isaac.c +++ b/src/isaac.c @@ -14,6 +14,36 @@ #include "isaac.h" +#if ISAAC_BITS > 32 +#define ISAAC_IND(mm, x) (*(uint64_t*)((uint8_t*)(mm) \ + + ((x) & ((ISAAC_ELEMENTS - 1) << 3)))) + +#define ISAAC_STEP(mix, a, b, mm, m, m2, r, x) \ +{ \ + x = *m; \ + a = (mix) + *(m2++); \ + *(m++) = y = ISAAC_IND(mm, x) + a + b; \ + *(r++) = b = ISAAC_IND(mm, y >> 8U) + x; \ +} + +#define ISAAC_MIX(a, b, c, d, e, f, g, h) \ +{ \ + a -= e; f ^= h >> 9U; h += a; \ + b -= f; g ^= a << 9U; a += b; \ + c -= g; h ^= b >> 23U; b += c; \ + d -= h; a ^= c << 15U; c += d; \ + e -= a; b ^= d >> 14U; d += e; \ + f -= b; c ^= e << 20U; e += f; \ + g -= c; d ^= f >> 17U; f += g; \ + h -= d; e ^= g << 14U; g += h; \ +} + +/* Explanations why it does not look like 1.618033988749894848...: + * https://stackoverflow.com/a/4948967 + * https://softwareengineering.stackexchange.com/a/63605 + */ +#define GOLDEN_RATIO 0x9e3779b97f4a7c13LL +#else #define ISAAC_IND(mm, x) ((mm)[(x >> 2U) & (ISAAC_ELEMENTS - 1)]) #define ISAAC_STEP(mix, a, b, mm, m, m2, r, x) \ @@ -40,7 +70,10 @@ * https://stackoverflow.com/a/4948967 * https://softwareengineering.stackexchange.com/a/63605 */ -#define GOLDEN_RATIO 0x9e3779b9 +#define GOLDEN_RATIO 0x9e3779b9L +#endif + + static void isaac_shuffle(isaac_ctx_t* ctx); @@ -56,7 +89,7 @@ void isaac_init(isaac_ctx_t* const ctx, { return; } - uint32_t a, b, c, d, e, f, g, h; + isaac_uint_t a, b, c, d, e, f, g, h; uint_fast16_t i; /* Fastest index over elements in result[] and mem[]. */ ctx->a = ctx->b = ctx->c = 0; a = b = c = d = e = f = g = h = GOLDEN_RATIO; @@ -161,16 +194,31 @@ static void set_seed(isaac_ctx_t* const ctx, */ static void isaac_shuffle(isaac_ctx_t* const ctx) { - uint32_t* m; - uint32_t* mm = ctx->mem; - uint32_t* m2; - uint32_t* r = ctx->result; - uint32_t* mend; - uint32_t a = ctx->a; - uint32_t b = ctx->b + (++ctx->c); - uint32_t x; - uint32_t y; - + isaac_uint_t* m; + isaac_uint_t* mm = ctx->mem; + isaac_uint_t* m2; + isaac_uint_t* r = ctx->result; + isaac_uint_t* mend; + isaac_uint_t a = ctx->a; + isaac_uint_t b = ctx->b + (++ctx->c); + isaac_uint_t x; + isaac_uint_t y; +#if ISAAC_BITS > 32 + for (m = mm, mend = m2 = m + (ISAAC_ELEMENTS / 2U); m < mend;) + { + ISAAC_STEP(~(a ^ (a << 21U)), a, b, mm, m, m2, r, x); + ISAAC_STEP(a ^ (a >> 5U), a, b, mm, m, m2, r, x); + ISAAC_STEP(a ^ (a << 12U), a, b, mm, m, m2, r, x); + ISAAC_STEP(a ^ (a >> 33U), a, b, mm, m, m2, r, x); + } + for (m2 = mm; m2 < mend;) + { + ISAAC_STEP(~(a ^ (a << 21U)), a, b, mm, m, m2, r, x); + ISAAC_STEP(a ^ (a >> 5U), a, b, mm, m, m2, r, x); + ISAAC_STEP(a ^ (a << 12U), a, b, mm, m, m2, r, x); + ISAAC_STEP(a ^ (a >> 33U), a, b, mm, m, m2, r, x); + } +#else for (m = mm, mend = m2 = m + (ISAAC_ELEMENTS / 2U); m < mend;) { ISAAC_STEP(a << 13U, a, b, mm, m, m2, r, x); @@ -185,13 +233,14 @@ static void isaac_shuffle(isaac_ctx_t* const ctx) ISAAC_STEP(a << 2U, a, b, mm, m, m2, r, x); ISAAC_STEP(a >> 16U, a, b, mm, m, m2, r, x); } +#endif ctx->b = b; ctx->a = a; } #define isaac_min(a, b) ((a) < (b)) ? (a) : (b) -void isaac_stream(isaac_ctx_t* const ctx, uint32_t* ints, size_t amount) +void isaac_stream(isaac_ctx_t* const ctx, isaac_uint_t* ints, size_t amount) { if (ctx == NULL || ints == NULL) { @@ -217,7 +266,7 @@ void isaac_stream(isaac_ctx_t* const ctx, uint32_t* ints, size_t amount) } void isaac_to_little_endian(uint8_t* bytes, - const uint32_t* values, + const isaac_uint_t* values, size_t amount_of_values) { if (bytes == NULL || values == NULL) @@ -230,13 +279,20 @@ void isaac_to_little_endian(uint8_t* bytes, *bytes++ = (uint8_t) (*values); *bytes++ = (uint8_t) (*values >> 8U); *bytes++ = (uint8_t) (*values >> 16U); - *bytes++ = (uint8_t) (*values++ >> 24U); + *bytes++ = (uint8_t) (*values >> 24U); +#if ISAAC_BITS > 32 + *bytes++ = (uint8_t) (*values >> 32U); + *bytes++ = (uint8_t) (*values >> 40U); + *bytes++ = (uint8_t) (*values >> 48U); + *bytes++ = (uint8_t) (*values >> 56U); +#endif + values++; } } } void isaac_to_big_endian(uint8_t* bytes, - const uint32_t* values, + const isaac_uint_t* values, size_t amount_of_values) { if (bytes == NULL || values == NULL) @@ -245,6 +301,12 @@ void isaac_to_big_endian(uint8_t* bytes, } while (amount_of_values--) { +#if ISAAC_BITS > 32 + *bytes++ = (uint8_t) (*values >> 56U); + *bytes++ = (uint8_t) (*values >> 48U); + *bytes++ = (uint8_t) (*values >> 40U); + *bytes++ = (uint8_t) (*values >> 32U); +#endif *bytes++ = (uint8_t) (*values >> 24U); *bytes++ = (uint8_t) (*values >> 16U); *bytes++ = (uint8_t) (*values >> 8U); diff --git a/src/isaac64.c b/src/isaac64.c deleted file mode 100644 index 8150db4..0000000 --- a/src/isaac64.c +++ /dev/null @@ -1,315 +0,0 @@ -/** - * @file - * - * LibISAAC implementation. - * - * Basic on the 32-bit portable implementation by Bob Jenkins, originally - * public domain: - * https://www.burtleburtle.net/bob/c/randport.c - * - * @copyright Copyright © 2020, Matjaž Guštin - * . All rights reserved. - * @license BSD 3-clause license. - */ - -#include "isaac.h" - -#if ISAAC_BITS > 32 -#define ISAAC_IND(mm, x) (*(uint64_t*)((uint8_t*)(mm) \ - + ((x) & ((ISAAC_ELEMENTS - 1) << 3)))) - -#define ISAAC_STEP(mix, a, b, mm, m, m2, r, x) \ -{ \ - x = *m; \ - a = (mix) + *(m2++); \ - *(m++) = y = ISAAC_IND(mm, x) + a + b; \ - *(r++) = b = ISAAC_IND(mm, y >> 8U) + x; \ -} - -#define ISAAC_MIX(a, b, c, d, e, f, g, h) \ -{ \ - a -= e; f ^= h >> 9U; h += a; \ - b -= f; g ^= a << 9U; a += b; \ - c -= g; h ^= b >> 23U; b += c; \ - d -= h; a ^= c << 15U; c += d; \ - e -= a; b ^= d >> 14U; d += e; \ - f -= b; c ^= e << 20U; e += f; \ - g -= c; d ^= f >> 17U; f += g; \ - h -= d; e ^= g << 14U; g += h; \ -} - -/* Explanations why it does not look like 1.618033988749894848...: - * https://stackoverflow.com/a/4948967 - * https://softwareengineering.stackexchange.com/a/63605 - */ -#define GOLDEN_RATIO 0x9e3779b97f4a7c13LL -#else -#define ISAAC_IND(mm, x) ((mm)[(x >> 2U) & (ISAAC_ELEMENTS - 1)]) - -#define ISAAC_STEP(mix, a, b, mm, m, m2, r, x) \ -{ \ - x = *m; \ - a = (a^(mix)) + *(m2++); \ - *(m++) = y = ISAAC_IND(mm, x) + a + b; \ - *(r++) = b = ISAAC_IND(mm, y >> 8U) + x; \ -} - -#define ISAAC_MIX(a, b, c, d, e, f, g, h) \ -{ \ - a ^= b << 11U; d += a; b += c; \ - b ^= c >> 2U; e += b; c += d; \ - c ^= d << 8U; f += c; d += e; \ - d ^= e >> 16U; g += d; e += f; \ - e ^= f << 10U; h += e; f += g; \ - f ^= g >> 4U; a += f; g += h; \ - g ^= h << 8U; b += g; h += a; \ - h ^= a >> 9U; c += h; a += b; \ -} - -/* Explanations why it does not look like 1.618033988749894848...: - * https://stackoverflow.com/a/4948967 - * https://softwareengineering.stackexchange.com/a/63605 - */ -#define GOLDEN_RATIO 0x9e3779b9L -#endif - - - -static void isaac_shuffle(isaac_ctx_t* ctx); - -static void set_seed(isaac_ctx_t* ctx, - const uint8_t* seed, - uint16_t seed_bytes); - -void isaac_init(isaac_ctx_t* const ctx, - const uint8_t* const seed, - const uint16_t seed_bytes) -{ - if (ctx == NULL) - { - return; - } - isaac_uint_t a, b, c, d, e, f, g, h; - uint_fast16_t i; /* Fastest index over elements in result[] and mem[]. */ - ctx->a = ctx->b = ctx->c = 0; - a = b = c = d = e = f = g = h = GOLDEN_RATIO; - /* Scramble it */ - for (i = 0; i < 4; i++) - { - ISAAC_MIX(a, b, c, d, e, f, g, h); - } - set_seed(ctx, seed, seed_bytes); - /* Initialise using the contents of result[] as the seed. */ - for (i = 0; i < ISAAC_ELEMENTS; i += 8) - { - a += ctx->result[i + 0]; - b += ctx->result[i + 1]; - c += ctx->result[i + 2]; - d += ctx->result[i + 3]; - e += ctx->result[i + 4]; - f += ctx->result[i + 5]; - g += ctx->result[i + 6]; - h += ctx->result[i + 7]; - ISAAC_MIX(a, b, c, d, e, f, g, h); - ctx->mem[i + 0] = a; - ctx->mem[i + 1] = b; - ctx->mem[i + 2] = c; - ctx->mem[i + 3] = d; - ctx->mem[i + 4] = e; - ctx->mem[i + 5] = f; - ctx->mem[i + 6] = g; - ctx->mem[i + 7] = h; - } - /* Do a second pass to make all of the seed affect all of ctx->mem. */ - for (i = 0; i < ISAAC_ELEMENTS; i += 8) - { - a += ctx->mem[i + 0]; - b += ctx->mem[i + 1]; - c += ctx->mem[i + 2]; - d += ctx->mem[i + 3]; - e += ctx->mem[i + 4]; - f += ctx->mem[i + 5]; - g += ctx->mem[i + 6]; - h += ctx->mem[i + 7]; - ISAAC_MIX(a, b, c, d, e, f, g, h); - ctx->mem[i + 0] = a; - ctx->mem[i + 1] = b; - ctx->mem[i + 2] = c; - ctx->mem[i + 3] = d; - ctx->mem[i + 4] = e; - ctx->mem[i + 5] = f; - ctx->mem[i + 6] = g; - ctx->mem[i + 7] = h; - } - /* Fill in the first set of results. */ - isaac_shuffle(ctx); - /* Prepare to use the first set of results with next32() and next8(). */ - ctx->next_index = ISAAC_ELEMENTS - 1; -} - -/** - * @internal - * Copies the seed into ctx->result[], padding it with zeros. - * - * @param ctx the ISAAC state - * @param seed bytes of the seed. If NULL, a zero-seed is used. - * @param seed_bytes amount of bytes in the seed. - */ -static void set_seed(isaac_ctx_t* const ctx, - const uint8_t* const seed, - uint16_t seed_bytes) -{ - uint_fast16_t i; - if (seed != NULL) - { - if (seed_bytes > ISAAC_SEED_MAX_BYTES) - { - seed_bytes = ISAAC_SEED_MAX_BYTES; - } - for (i = 0; i < seed_bytes; i++) - { - /* The copy is performed VALUE-wise, not byte wise. - * By doing so we have same result[] on architectures with different - * endianness. */ - ctx->result[i] = seed[i]; - } - } - else - { - seed_bytes = 0; - } - for (i = seed_bytes; i < ISAAC_SEED_MAX_BYTES; i++) - { - ctx->result[i] = 0; - } -} - -/** - * @internal - * Permutes the ISAAC state. - * - * Maps to `void isaac(randctx*)` from the original implementation. - * - * @param ctx the ISAAC state - */ -static void isaac_shuffle(isaac_ctx_t* const ctx) -{ - isaac_uint_t* m; - isaac_uint_t* mm = ctx->mem; - isaac_uint_t* m2; - isaac_uint_t* r = ctx->result; - isaac_uint_t* mend; - isaac_uint_t a = ctx->a; - isaac_uint_t b = ctx->b + (++ctx->c); - isaac_uint_t x; - isaac_uint_t y; -#if ISAAC_BITS > 32 - for (m = mm, mend = m2 = m + (ISAAC_ELEMENTS / 2U); m < mend;) - { - ISAAC_STEP(~(a ^ (a << 21U)), a, b, mm, m, m2, r, x); - ISAAC_STEP(a ^ (a >> 5U), a, b, mm, m, m2, r, x); - ISAAC_STEP(a ^ (a << 12U), a, b, mm, m, m2, r, x); - ISAAC_STEP(a ^ (a >> 33U), a, b, mm, m, m2, r, x); - } - for (m2 = mm; m2 < mend;) - { - ISAAC_STEP(~(a ^ (a << 21U)), a, b, mm, m, m2, r, x); - ISAAC_STEP(a ^ (a >> 5U), a, b, mm, m, m2, r, x); - ISAAC_STEP(a ^ (a << 12U), a, b, mm, m, m2, r, x); - ISAAC_STEP(a ^ (a >> 33U), a, b, mm, m, m2, r, x); - } -#else - for (m = mm, mend = m2 = m + (ISAAC_ELEMENTS / 2U); m < mend;) - { - ISAAC_STEP(a << 13U, a, b, mm, m, m2, r, x); - ISAAC_STEP(a >> 6U, a, b, mm, m, m2, r, x); - ISAAC_STEP(a << 2U, a, b, mm, m, m2, r, x); - ISAAC_STEP(a >> 16U, a, b, mm, m, m2, r, x); - } - for (m2 = mm; m2 < mend;) - { - ISAAC_STEP(a << 13U, a, b, mm, m, m2, r, x); - ISAAC_STEP(a >> 6U, a, b, mm, m, m2, r, x); - ISAAC_STEP(a << 2U, a, b, mm, m, m2, r, x); - ISAAC_STEP(a >> 16U, a, b, mm, m, m2, r, x); - } -#endif - ctx->b = b; - ctx->a = a; -} - -#define isaac_min(a, b) ((a) < (b)) ? (a) : (b) - -void isaac_stream(isaac_ctx_t* const ctx, isaac_uint_t* ints, size_t amount) -{ - if (ctx == NULL || ints == NULL) - { - return; - } - do - { - const size_t available = isaac_min(ctx->next_index + 1, amount); - for (uint_fast16_t i = 0; i < available; i++) - { - *ints++ = ctx->result[ctx->next_index--]; - } - amount -= available; - if (ctx->next_index >= ISAAC_ELEMENTS) - { - /* next_index underflow, thus out of elements. Reshuffling - * and preparing new batch of elements. */ - isaac_shuffle(ctx); - ctx->next_index = ISAAC_ELEMENTS - 1; - } - } - while (amount); -} - -void isaac_to_little_endian(uint8_t* bytes, - const isaac_uint_t* values, - size_t amount_of_values) -{ - if (bytes == NULL || values == NULL) - { - return; - } - { - while (amount_of_values--) - { - *bytes++ = (uint8_t) (*values); - *bytes++ = (uint8_t) (*values >> 8U); - *bytes++ = (uint8_t) (*values >> 16U); - *bytes++ = (uint8_t) (*values >> 24U); -#if ISAAC_BITS > 32 - *bytes++ = (uint8_t) (*values >> 32U); - *bytes++ = (uint8_t) (*values >> 40U); - *bytes++ = (uint8_t) (*values >> 48U); - *bytes++ = (uint8_t) (*values >> 56U); -#endif - values++; - } - } -} - -void isaac_to_big_endian(uint8_t* bytes, - const isaac_uint_t* values, - size_t amount_of_values) -{ - if (bytes == NULL || values == NULL) - { - return; - } - while (amount_of_values--) - { -#if ISAAC_BITS > 32 - *bytes++ = (uint8_t) (*values >> 56U); - *bytes++ = (uint8_t) (*values >> 48U); - *bytes++ = (uint8_t) (*values >> 40U); - *bytes++ = (uint8_t) (*values >> 32U); -#endif - *bytes++ = (uint8_t) (*values >> 24U); - *bytes++ = (uint8_t) (*values >> 16U); - *bytes++ = (uint8_t) (*values >> 8U); - *bytes++ = (uint8_t) (*values++); - } -} diff --git a/tst/test_init.c b/tst/test_init.c index 049dd9d..2090ba2 100644 --- a/tst/test_init.c +++ b/tst/test_init.c @@ -10,6 +10,544 @@ #include "test.h" +#if ISAAC_BITS > 32 + +const static isaac_ctx_t zero_initialised_ctx = { + .next_index = ISAAC_ELEMENTS - 1U, + .a = 0xCE150DF74800329AULL, + .b = 0x9D39247E33776D41ULL, + .c = 0x0000000000000001ULL, + .result = { + 0x48CBFF086DDF285AULL, 0x99E7AFEABE000731ULL, + 0x93C42566AEF98FFBULL, 0xA865A54EDCC0F019ULL, + 0x0D151D86ADB73615ULL, 0xDAB9FE6525D89021ULL, + 0x1B85D488D0F20CC5ULL, 0xF678647E3519AC6EULL, + 0x5E11E86D5873D484ULL, 0x0ED9B915C66ED37EULL, + 0xB0183DB56FFC6A79ULL, 0x506E6744CD974924ULL, + 0x881B82A13B51B9E2ULL, 0x9A9632E65904AD3CULL, + 0x742E1E651C60BA83ULL, 0x04FEABFBBDB619CBULL, + 0x284C847B9D887AAEULL, 0x56FD23C8F9715A4CULL, + 0x0CD9A497658A5698ULL, 0x5A110C6058B920A0ULL, + 0x04208FE9E8F7F2D6ULL, 0x7A249A57EC0C9BA2ULL, + 0x1D1260A51107FE97ULL, 0x722FF175F572C348ULL, + 0x9D1DFA2EFC557F73ULL, 0x52AB92BEB9613989ULL, + 0x528F7C8602C5807BULL, 0xD941ACA44B20A45BULL, + 0x4361C0CA3F692F12ULL, 0x513E5E634C70E331ULL, + 0x77A225A07CC2C6BDULL, 0xA90B24499FCFAFB1ULL, + 0x35CAB62109DD038AULL, 0x32095B6D4AB5F9B1ULL, + 0x3810E399B6F65BA2ULL, 0x9D1D60E5076F5B6FULL, + 0x7A1EE967D27579E2ULL, 0x68CA39053261169FULL, + 0x8CFFA9412EB642C1ULL, 0x40E087931A00930DULL, + 0x4C0563B89F495AC3ULL, 0x18FCF680573FA594ULL, + 0xFCAF55C1BF8A4424ULL, 0x39B0BF7DDE437BA2ULL, + 0xF3A678CAD9A2E38CULL, 0x7BA2484C8A0FD54EULL, + 0x16B9F7E06C453A21ULL, 0x87D380BDA5BF7859ULL, + 0x4F2A5CB07F6A35B3ULL, 0xA2F61BB6E437FDB5ULL, + 0xA74049DAC312AC71ULL, 0x336F52F8FF4728E7ULL, + 0xD95BE88CD210FFA7ULL, 0xD7F4F2448C0CEB81ULL, + 0xF7A255D83BC373F8ULL, 0xD2B7ADEEDED1F73FULL, + 0x3BBA57B68871B59DULL, 0xDF1D9F9D784BA010ULL, + 0x94061B871E04DF75ULL, 0x9315E5EB3A129ACEULL, + 0x08BD35CC38336615ULL, 0xFE9A44E9362F05FAULL, + 0x78E37644E7CAD29EULL, 0xC547F57E42A7444EULL, + 0x6703DF9D2924E97EULL, 0x8EC97D2917456ED0ULL, + 0x9C684CB6C4D24417ULL, 0xFC6A82D64B8655FBULL, + 0xF9B5B7C4ACC67C96ULL, 0x69B97DB1A4C03DFEULL, + 0xE755178D58FC4E76ULL, 0xA4FC4BD4FC5558CAULL, + 0x9AE182C8BC9474E8ULL, 0xB05CA3F564268D99ULL, + 0xCFC447F1E53C8E1BULL, 0x4850E73E03EB6064ULL, + 0x2C604A7A177326B3ULL, 0x0BF692B38D079F23ULL, + 0xDE336A2A4BC1C44BULL, 0xD7288E012AEB8D31ULL, + 0xF793C46702E086A0ULL, 0x763C4A1371B368FDULL, + 0x2DF16F761598AA4FULL, 0x21A007933A522A20ULL, + 0xB3819A42ABE61C87ULL, 0xB46EE9C5E64A6E7CULL, + 0xC07A3F80C31FB4B4ULL, 0x51039AB7712457C3ULL, + 0x4DC4DE189B671A1CULL, 0x066F70B33FE09017ULL, + 0x9DA4243DE836994FULL, 0xBCE5D2248682C115ULL, + 0x11379625747D5AF3ULL, 0xF4F076E65F2CE6F0ULL, + 0x52593803DFF1E840ULL, 0x19AFE59AE451497FULL, + 0xAEF3AF4A563DFE43ULL, 0x480412BAB7F5BE2AULL, + 0xAF2042F5CC5C2858ULL, 0xEF2F054308F6A2BCULL, + 0x9BC5A38EF729ABD4ULL, 0x2D255069F0B7DAB3ULL, + 0x5648F680F11A2741ULL, 0xC5CC1D89724FA456ULL, + 0x28AED140BE0BB7DDULL, 0x10CFF333E0ED804AULL, + 0x91B859E59ECB6350ULL, 0xB415938D7DA94E3CULL, + 0x21F08570F420E565ULL, 0xDED2D633CAD004F6ULL, + 0x65942C7B3C7E11AEULL, 0xA87832D392EFEE56ULL, + 0xAA969B5C691CCB7AULL, 0x43539603D6C55602ULL, + 0x1BEDE3A3AEF53302ULL, 0xDEC468145B7605F6ULL, + 0x808BD68E6AC10365ULL, 0xC91800E98FB99929ULL, + 0x22FE545401165F1CULL, 0x7EED120D54CF2DD9ULL, + 0xDD2C5BC84BC8D8FCULL, 0xAE623FD67468AA70ULL, + 0xFF6712FFCFD75EA1ULL, 0x930F80F4E8EB7462ULL, + 0x45F20042F24F1768ULL, 0xBB215798D45DF7AFULL, + 0xEFAC4B70633B8F81ULL, 0x56436C9FE1A1AA8DULL, + 0x73A1921916591CBDULL, 0x70EB093B15B290CCULL, + 0x920E449535DD359EULL, 0x043FCAE60CC0EBA0ULL, + 0xA246637CFF328532ULL, 0x97D7374C60087B73ULL, + 0x86536B8CF3428A8CULL, 0x799E81F05BC93F31ULL, + 0xEDE6C87F8477609DULL, 0x3C79A0FF5580EF7FULL, + 0xF538639CE705B824ULL, 0xCF464CEC899A2F8AULL, + 0x4A750A09CE9573F7ULL, 0xB5889C6E15630A75ULL, + 0x05A7E8A57DB91B77ULL, 0xB9FD7620E7316243ULL, + 0x7B32F7D1E03680ECULL, 0xEF927DBCF00C20F2ULL, + 0xDFD395339CDBF4A7ULL, 0x6503080440750644ULL, + 0x1881AFC9A3A701D6ULL, 0x506AACF489889342ULL, + 0x5B9B63EB9CEFF80CULL, 0x2171E64683023A08ULL, + 0x6304D09A0B3738C4ULL, 0x4F80F7A035DAFB04ULL, + 0x9A74ACB964E78CB3ULL, 0x1E1032911FA78984ULL, + 0x5BFEA5B4712768E9ULL, 0x390E5FB44D01144BULL, + 0xB3F22C3D0B0B38EDULL, 0x9C1633264DB49C89ULL, + 0x8DE8DCA9F03CC54EULL, 0xFF07F64EF8ED14D0ULL, + 0x092237AC237F3859ULL, 0x87BF02C6B49E2AE9ULL, + 0x1920C04D47267BBDULL, 0xAE4A9346CC3F7CF2ULL, + 0xA366E5B8C54F48B8ULL, 0x87B3E2B2B5C907B1ULL, + 0xF9B89D3E99A075C2ULL, 0x70AC4CD9F04F21F5ULL, + 0x9A85AC909A24EAA1ULL, 0xEE954D3C7B411F47ULL, + 0x72B12C32127FED2BULL, 0x54B3F4FA5F40D873ULL, + 0x8535F040B9744FF1ULL, 0x27E6AD7891165C3FULL, + 0xE99D662AF4243939ULL, 0xA49CD132BFBF7CC4ULL, + 0x0CE26C0B95C980D9ULL, 0xBB6E2924F03912EAULL, + 0x24C3C94DF9C8D3F6ULL, 0xDABF2AC8201752FCULL, + 0xF145B6BECCDEA195ULL, 0x14ACBAF4777D5776ULL, + 0x79AD695501E7D1E8ULL, 0x8249A47AEE0E41F7ULL, + 0x637A7780DECFC0D9ULL, 0x19FC8A768CF4B6D4ULL, + 0x7BCBC38DA25A7F3CULL, 0x5093417AA8A7ED5EULL, + 0x07FB9F855A997142ULL, 0x5355F900C2A82DC7ULL, + 0xEC16CA8AEA98AD76ULL, 0x63DC359D8D231B78ULL, + 0x93C5B5F47356388BULL, 0x39F890F579F92F88ULL, + 0x5F0F4A5898171BB6ULL, 0x42880B0236E4D951ULL, + 0x6D2BDCDAE2919661ULL, 0x42E240CB63689F2FULL, + 0x96D693460CC37E5DULL, 0x4DE0B0F40F32A7B8ULL, + 0x6568FCA92C76A243ULL, 0x11D505D4C351BD7FULL, + 0x7EF48F2B83024E20ULL, 0xB9BC6C87167C33E7ULL, + 0x8C74C368081B3075ULL, 0x3253A729B9BA3DDEULL, + 0xFCF7FE8A3430B241ULL, 0x5C82C505DB9AB0FAULL, + 0x51EBDC4AB9BA3035ULL, 0x9F74D14F7454A824ULL, + 0xBF983FE0FE5D8244ULL, 0xD310A7C2CE9B6555ULL, + 0x1FCBACD259BF02E7ULL, 0x18727070F1BD400BULL, + 0x735E2B97A4C45A23ULL, 0x3575668334A1DD3BULL, + 0x09D1BC9A3DD90A94ULL, 0x637B2B34FF93C040ULL, + 0x03488B95B0F1850FULL, 0xA71B9B83461CBD93ULL, + 0x14A68FD73C910841ULL, 0x4C9F34427501B447ULL, + 0x24AA6C514DA27500ULL, 0xC9452CA81A09D85DULL, + 0x7B0500AC42047AC4ULL, 0xB4AB30F062B19ABFULL, + 0x19F3C751D3E92AE1ULL, 0x87D2074B81D79217ULL, + 0x8DBD98A352AFD40BULL, 0xAA649C6EBCFD50FCULL, + 0x4BB38DE5E7219443ULL, 0x331478F3AF51BBE6ULL, + 0xF3218F1C9510786CULL, 0x82C7709E781EB7CCULL, + 0x7D11CDB1C3B7ADF0ULL, 0x7449BBFF801FED0BULL, + 0x679F848F6E8FC971ULL, 0x05D1A1AE85B49AA1ULL, + 0x239F8B2D7FF719CCULL, 0x5DB4832046F3D9E5ULL, + 0x011355146FD56395ULL, 0x40BDF15D4A672E32ULL, + 0xD021FF5CD13A2ED5ULL, 0x9605D5F0E25EC3B0ULL, + 0x1A083822CEAFE02DULL, 0x0D7E765D58755C10ULL, + 0xE83A908FF2FB60CAULL, 0x0FBBAD1F61042279ULL, + 0x3290AC3A203001BFULL, 0x75834465489C0C89ULL, + 0x9C15F73E62A76AE2ULL, 0x44DB015024623547ULL, + 0x2AF7398005AAA5C7ULL, 0x9D39247E33776D41ULL, + }, + .mem = { + 0xB52EB91CB50ACF2CULL, 0x81DC6CF11A25FE50ULL, + 0xB80B709D9D0EAED7ULL, 0x68CCB96ED190B461ULL, + 0x1C234EB454BF5D34ULL, 0x15583AB77356EDC0ULL, + 0xEF35315C0AA99069ULL, 0xCEE930F4B9EA9D65ULL, + 0xA863B074CF2B1DA5ULL, 0x75D69E1076C2DFDCULL, + 0xADDDB772E79769D2ULL, 0x65ABEF4D0D2AC285ULL, + 0x543CE3E471E042E8ULL, 0xF1FE9B9DCE6620BEULL, + 0x792F472B4FF90D3CULL, 0x912FB799D38F2963ULL, + 0xF7040AE6874D5ACDULL, 0x4E9F992062E2D9C9ULL, + 0x25C4FFBA66833F34ULL, 0x52B992D8AD9E0F69ULL, + 0xE2F6BEC4D04B4B28ULL, 0x2BA878E83221A418ULL, + 0xE2E16DD5FDB0B564ULL, 0x80568F05D6436175ULL, + 0xAEF5A616F3EC30B1ULL, 0x792CBDA42065820BULL, + 0x168A4CAFAA1275BAULL, 0x2B227FAD580F3341ULL, + 0xC95C165E01456A11ULL, 0xE8962BC8D5CEE22BULL, + 0xED4D10AAE684422EULL, 0xE379E5F0F4548DA9ULL, + 0x3344FBE7E3113B35ULL, 0x3781A43A7C4063E3ULL, + 0x8852B05DF2EFDA16ULL, 0x4979652FFC8C1196ULL, + 0x49B280330713F15AULL, 0x7F9CA4CF46E98BB9ULL, + 0x551E9482A8623BB1ULL, 0xA64608FFCDBA985CULL, + 0x566BC690E05E2C92ULL, 0x8231B977DFB4B20AULL, + 0x2B9B5F42548F05EAULL, 0xD42982F21E873684ULL, + 0xCAA6A438C0FC824AULL, 0x799CC3A7975D4334ULL, + 0xA60A79C2E7739EF6ULL, 0xC757C43715C508D6ULL, + 0xCD6969DF80744A2FULL, 0x60F2197965D4E75AULL, + 0x64904D5C96264CF5ULL, 0x10C426EE49F19E17ULL, + 0x85C5E1588392A814ULL, 0xDCE8A9D163E55F37ULL, + 0x4C4BCD679D446B4FULL, 0x8ECC14ADFB870BA9ULL, + 0x8F600BD2F5F482A8ULL, 0x685A7893F34F0A06ULL, + 0xC6E6DB925A2128A0ULL, 0x92071DD32CE8256BULL, + 0x5023BAD1CBD68DDDULL, 0x8C5EEE94905870ACULL, + 0x3A794F68E0F04FC7ULL, 0x0134AE21A563C72BULL, + 0xE961F807182C336EULL, 0x50E85C0E016ED6DFULL, + 0xB053222258E375F9ULL, 0x247501D1547FE58DULL, + 0x68BA5A9C1940E0DFULL, 0x266A69FB06E19945ULL, + 0x49FB14A8FCCA9811ULL, 0x3C2E86EAD7FA14E1ULL, + 0xBA13D94054E08335ULL, 0xE70769E5B05A2C9CULL, + 0x6A4E5B1973D2D74AULL, 0x422D7976DB4C4842ULL, + 0x58576C42F70E78BFULL, 0xADDB1A9E16E827D3ULL, + 0x2BBA0FF86BCF2B9CULL, 0x45573405A7951AA7ULL, + 0xD9B88E94E95227A2ULL, 0x69C6CBB45188243FULL, + 0xF8E9779B99BB2EE4ULL, 0x6CB103FB14ABE975ULL, + 0x65793D8E114390C9ULL, 0x37E4B1AA90723935ULL, + 0xCE2A716A7AB759BEULL, 0xC898D8B86286C851ULL, + 0xD4E6DEDB2D736622ULL, 0x1EE61E62F79A90C1ULL, + 0x20B3BB90FEFD3023ULL, 0xEAD971A67455BAE9ULL, + 0x7C345C2B6F5C9638ULL, 0xA9929F3A253F2493ULL, + 0x45A2A97AFC31A187ULL, 0x1B251A308417DCD4ULL, + 0xC67605B45CDEC85FULL, 0x526C9DE40CCB45E1ULL, + 0x86BD5587ED0D850FULL, 0x04211481C639AB46ULL, + 0x381B416BD58D857DULL, 0x03B11243C1E92CCBULL, + 0x5C324422C5DAE23AULL, 0xFC038FE265CCFDD1ULL, + 0x531930C042D44BA8ULL, 0x6B52DD2C0F6D1819ULL, + 0xC17D7EF61287FF3FULL, 0xFC98421C0822078CULL, + 0x4A57E25835BF55EDULL, 0xDE46F8E83C4E829BULL, + 0xCFB287BB29D50E0BULL, 0xC004E9D0A242078CULL, + 0xD7E0A63A41CADDAEULL, 0x746EB3A85B246B8BULL, + 0x1EFD1C1E554ED7BBULL, 0x807FB6ADDDF2164CULL, + 0x7221E493711430E4ULL, 0x45DC412663A8E8CCULL, + 0xF720744B52430073ULL, 0xDE5A2FA9A24C94D6ULL, + 0xEE95225A3C86D258ULL, 0x3B19241B4A20E438ULL, + 0x3A32A18DE85C09C4ULL, 0xFC90CA9BF7FA6B5FULL, + 0x1A1CD5CA7CB24C48ULL, 0xCDC3ACF3B57E3241ULL, + 0x38C11605EA536916ULL, 0x6CA31FFE1DDAD82DULL, + 0xEFA39A6C824AE021ULL, 0x5983D43909717562ULL, + 0x03375BF34FC5FC45ULL, 0x6FFBE8B6A7899522ULL, + 0x1ABF26190A51468EULL, 0x8FF97FC19C733306ULL, + 0xE5FEA11D7C0A69A5ULL, 0xBE2BD7FC84629C21ULL, + 0x9A1934A8D85E9FDBULL, 0x62506DA595058845ULL, + 0xEE04582E69CCA6A6ULL, 0x418486C4F5982B00ULL, + 0xC2705B2647D64377ULL, 0x5671FC2739EE025AULL, + 0x2BE4F8B94376FBB4ULL, 0x0673E37830526520ULL, + 0xDA6EA8C1CB07BFEFULL, 0x549ADB7CD82916D8ULL, + 0x1DD9DC7631972398ULL, 0x60661DB4F535551CULL, + 0x8FC66718D29ECA06ULL, 0x54D32F68672D4B7AULL, + 0x3185C1DB22A42906ULL, 0xA238C62022DC819FULL, + 0xF2792BB41321008EULL, 0xF9F2B1765D0D60F7ULL, + 0x684734A992C44732ULL, 0x6C684CCF1DE15289ULL, + 0xBEB6EEC55DD28F84ULL, 0xF39B1FB8E084332FULL, + 0x1D00B93625588462ULL, 0x03F6FE9E7527E690ULL, + 0xD25E291241108938ULL, 0xDFC079DFB6A8F951ULL, + 0xE56B90C446142448ULL, 0x1A573EF08DFBD0CBULL, + 0x1404FF8ED95C0E16ULL, 0xED0CE7B8BA59500BULL, + 0xD5850CF700541023ULL, 0xF105EAD922CBC7B1ULL, + 0x18410BC6354E31AAULL, 0x78BAF37892B7410CULL, + 0xD1917D851F09451FULL, 0x86243864E1ADFB68ULL, + 0xAB072F525937FB24ULL, 0xEBA8005C65114FD5ULL, + 0x7AD0B8DFB348A4C8ULL, 0x92D49CB12CDB0778ULL, + 0xCC23898C010241FEULL, 0x7FB1D872DF486616ULL, + 0x065C36E017A7ECDFULL, 0xFBE4B062BD827EB2ULL, + 0x86106091F50640DFULL, 0xA68693501831F748ULL, + 0xD2949F2B66A1C98DULL, 0x9EA6372549B74FFCULL, + 0xC43CA4BAD265AC85ULL, 0x30C1DEBAB1732372ULL, + 0x0962A9A46A801C21ULL, 0xA1E0C6FD83D4F7B2ULL, + 0x5D7A38F9FA894996ULL, 0xD72834573612CB8FULL, + 0xFD684B0BA22B8DE9ULL, 0x03863EB971619B6FULL, + 0x4246DB69329457BBULL, 0x1D760A5799E7E64DULL, + 0xA4F9D1B34A28FABDULL, 0xF5DEEB288A6B361CULL, + 0x1AF61DACB82A563BULL, 0x103E30CAE0DC7128ULL, + 0x01C86861134D6B33ULL, 0x43F4088280EA57ADULL, + 0x38959F241D348461ULL, 0x49F2AF646ACDB800ULL, + 0x5214C7B95A5A84EEULL, 0x2EE77B20544AEDA6ULL, + 0x175ACDB9DA60554AULL, 0x0B9239DC3538424EULL, + 0x7E63E416D8AECBD5ULL, 0x74179140237EC4D1ULL, + 0xAEFFC57A95D5F3D5ULL, 0x287ACAFE2C7DF22FULL, + 0xEB50B92188C4AC5CULL, 0x13EC68DDE3AEE9C7ULL, + 0xBB23C3C7B05B83D1ULL, 0xA20BD26001EFF747ULL, + 0x10D4957BC2242B25ULL, 0xE5A76361DB10DB27ULL, + 0x39BA7AD106D6FE0FULL, 0xCFE8572E9224DE50ULL, + 0x937E63522973F0A3ULL, 0xF80D6AD35B3045CBULL, + 0xF3D270CE090CC4A4ULL, 0x9F69DE6A9047CFB3ULL, + 0x310DBC20F26F638AULL, 0x989022FBA72F8A83ULL, + 0xAED37CF213460B15ULL, 0xC1F063C6247C40A2ULL, + 0xC742796BED6B0DC5ULL, 0xB44B5E54FCD6E741ULL, + 0xBC5BB2BA0C433502ULL, 0xE521ADB01933CCC1ULL, + 0xD6B2105C40971F76ULL, 0xDA933082C1C3D833ULL, + 0xCE1077A47CF34A33ULL, 0x3117A29776DE31C0ULL, + 0x617520676F4E8AEBULL, 0xDDACAEE358B85387ULL, + 0x7F2B9CA498CF0F18ULL, 0xB137A94E5C54693BULL, + 0x8976743A6706DD87ULL, 0x211B08981587D3DAULL, + 0xB5C5535F3279396DULL, 0xC81F27238D7796C4ULL, + 0x92585BB5F0AF79D3ULL, 0xB4A213591A190C33ULL, + 0x34204537A458AB64ULL, 0x339C0D19FC1B19A5ULL, + 0x2A32E2716614CDABULL, 0x904C0CB259A7C989ULL, + 0x8E1F76975DD07085ULL, 0xC1FFEF565532DC82ULL, + 0xABF0F6EEFBF3006CULL, 0x61A235E62F345DDAULL, + 0xA7163E334AE7DD60ULL, 0x7FA6EB6999FBA1D4ULL, + 0xA2507F2BA4CCDFA9ULL, 0x7837E41BE679E779ULL, + } +}; + +const static isaac_ctx_t nonzero_initialised_ctx = { + .next_index = ISAAC_ELEMENTS - 1U, + .a = 0x206E5B8744408867ULL, + .b = 0x0F5268BA58C45B3DULL, + .c = 0x0000000000000001ULL, + .result = { + 0xB3891B01375810CCULL, 0xDA96A425DA703312ULL, + 0xDD5B6A7476AB8569ULL, 0xF8554A3AA49F36E7ULL, + 0x822DE2A73CAE6733ULL, 0xD9C905B02CF51766ULL, + 0x6BEFD4C8A7D50825ULL, 0x2ED44884B6E11C35ULL, + 0xF4728A064CB520F5ULL, 0x3BCADDE6C4EC8E96ULL, + 0x3F89E183398D5940ULL, 0xDA2F43D111423313ULL, + 0x242EA73DF7CA0860ULL, 0xCBA3B02E3BAD0948ULL, + 0xFA0F6583FB1F5E01ULL, 0x309018B4D9149F96ULL, + 0x834DB9CC2F420C86ULL, 0xBEF83DCAA6D1190BULL, + 0x078F1B90F89F3FE6ULL, 0x6011EA83A8714BA8ULL, + 0x259958AC44D0BBFEULL, 0x2534DB160EAFC593ULL, + 0x8AF9D5ADF07B33F7ULL, 0xDC7B502CC32BC77EULL, + 0x33372718EB75D6ADULL, 0x89786EDCC2D94AA2ULL, + 0x6A39183F04BFEB5EULL, 0x88DFC98EE270013AULL, + 0x98B4B58B108AD734ULL, 0x9C4A937F3159BA74ULL, + 0xE22C78A51A3E67EAULL, 0x4A16BFCA28113F08ULL, + 0xED174D340C810216ULL, 0xD50B0628F4F731D2ULL, + 0x6C014B77CC39AF37ULL, 0x17D2F37F03F5C0DAULL, + 0x81E601F222BECD12ULL, 0x4204A0CEC4F4BE52ULL, + 0xEC45281930D33BD2ULL, 0x6597FA6C39BB1E54ULL, + 0x493641090A01DC06ULL, 0x2FA3F4BAC8A1AFE8ULL, + 0x3F26B6F479F0AE52ULL, 0xA615310B08B68291ULL, + 0x206A59347BC6E9D5ULL, 0x399F26F5C3970AE4ULL, + 0x551AB6DA27DC63DEULL, 0x0A59EB2B496CD44BULL, + 0xBADCBAB1A446C8F5ULL, 0x24C46C6B7FBDD86BULL, + 0xC3F32E9B485C27D7ULL, 0x9C022AB38642172AULL, + 0x6B55312F5AF150F5ULL, 0x7F5FA5557B924002ULL, + 0x377B586F01441DFFULL, 0x4CC5028796FB93B7ULL, + 0x8AA78A7640AEA2D1ULL, 0x113612A59D1E75C5ULL, + 0x920E5F8D74BD03E4ULL, 0x6FF9AE736431EFB7ULL, + 0xFDF6FD0B61CF989BULL, 0x7D7BB2F48D4AFB97ULL, + 0x5B4C3A83A62BFB8AULL, 0xC97E529227587D27ULL, + 0xAF326587C6004EC5ULL, 0x3E32CF90D6D906EFULL, + 0x4A62A8F4C3715CB3ULL, 0x90268314EFA4E871ULL, + 0xD8F3715B26E46A83ULL, 0x5D2B9304BF7E6C93ULL, + 0x6D2D8D9D0DBEE19EULL, 0xB4A6C753B8128B46ULL, + 0x6377D659A4B26BEBULL, 0xF8EE87D6949BE2E8ULL, + 0x9A73C51AD3570E87ULL, 0x501294AE6549F9A3ULL, + 0x61A93B8855668BC1ULL, 0x5974EB02B5C0BA3DULL, + 0xCEB9DDB84ED120AAULL, 0xFE5F62889B61932AULL, + 0x7546A69A2EA94D29ULL, 0x6C0E62542E0439E4ULL, + 0x484D9F68FA5215CCULL, 0x8606513970A3A52CULL, + 0x58CAEFDC4E8E7231ULL, 0x74379793CCEB8245ULL, + 0x0AD037BA9B7670A2ULL, 0xBA15B44C027B2ECCULL, + 0xABFA9F6E86AAEFB8ULL, 0xF970EEA853412742ULL, + 0x3318E2051B1257A5ULL, 0x49C0724F0D1855C8ULL, + 0xD1321A04764071BEULL, 0xBB0DB172A6E76658ULL, + 0xA6A1647FCCF3D5E7ULL, 0x194DDF7D97414D9DULL, + 0x6CC091C7E7180A82ULL, 0x3A0A620CFD2BA9CBULL, + 0x9E77BE037DDE48C6ULL, 0x6D9D8AC2E1833141ULL, + 0x6862F171E0DAF32BULL, 0x31B52B078346F8A1ULL, + 0x738A7181CE63126DULL, 0x2D6469A7B5432AEFULL, + 0x3CABF03A65D3ADB7ULL, 0x2C806C2905EC8713ULL, + 0x1C3BA696916B718DULL, 0x007CA7B87307E602ULL, + 0x4528C8387F1D0081ULL, 0x62E6B98BA6116448ULL, + 0xECD75C6D93BB6DF5ULL, 0xC2AC1D8E2F2EB5CEULL, + 0xA7C9E67CB8F63BD5ULL, 0x6F8729EF946F71A6ULL, + 0x957B5D3D3BCA6188ULL, 0x67614FD77E630039ULL, + 0xE9106325BF20A386ULL, 0xEE15E2CEF989D75AULL, + 0x3E34F2B924CC4C2DULL, 0xDC030073BD362B5AULL, + 0x29AAD64DAD0E025EULL, 0x04A82DE3B187F8FEULL, + 0xB37CA8D4A7C02239ULL, 0xBF0B576B634BF6B3ULL, + 0x93AB7E6B54E75133ULL, 0x959B6BE4E24884A6ULL, + 0xF3CC60A1AC3E1ACDULL, 0x2AD69EAA75138A36ULL, + 0xE2E8770C4C1781CAULL, 0xF60EC787A39A9D71ULL, + 0x4069DE08359C7A24ULL, 0xCE3E52A9EC12F233ULL, + 0x7AD2ADDDFECC7789ULL, 0xBC3F347FFC3F5CF4ULL, + 0xA641CFA106B0BC70ULL, 0x9DCCF828FF910928ULL, + 0xDAEE6BC29548E7C3ULL, 0x42AB69C1F8D3DB3FULL, + 0x88238CAE89E99F9FULL, 0x1DE97A6C0CE8D551ULL, + 0xBF0BF81388CC129DULL, 0xB5D8065D7B3EFE59ULL, + 0x726C87954507C8C1ULL, 0x200614CF86134154ULL, + 0x1DFBD256B0E5C2C6ULL, 0x0E792A3B86EADCC3ULL, + 0x5D3E6F261CE70F7CULL, 0x8BFF928A2971393DULL, + 0x0B195AD821E1E4FAULL, 0x1803DF8C99C59332ULL, + 0x174E9F2D0CE39045ULL, 0x9D084D97981E33D9ULL, + 0xC940263A84626786ULL, 0x39AF8BAB29F47821ULL, + 0x6128FAFEF2E659BEULL, 0xB10460F7D51AC2B3ULL, + 0x20E006C6C8A57285ULL, 0x6A4A77154E5653CAULL, + 0x46EDCBAF25A7A14DULL, 0x00487151150521A1ULL, + 0x1529629E312DABC3ULL, 0x78750BC889C6E005ULL, + 0xA845EF8ED936AFBEULL, 0xCE6FA3C4F2F8A81BULL, + 0x559582636A99BCEDULL, 0xFD0AA02C6EE9F662ULL, + 0x544D081E0E3F0D62ULL, 0xD515D078241B7060ULL, + 0xADA077E2CD24E1D6ULL, 0x708520FFAA2F05CCULL, + 0x6C30EDD49B09E39BULL, 0xC1A893D5BF9D0659ULL, + 0x07EF9D86A21F0548ULL, 0xAFA4DD97E65FDC73ULL, + 0x5B5965F0E5E89A8EULL, 0x6FF2CE860253DDD4ULL, + 0xC0E85C3A394C17CAULL, 0x3B7667D1862E87EFULL, + 0xC8BB74DD1661AD89ULL, 0xD8628607512B7583ULL, + 0xBA4ACB545CE4150FULL, 0x1A110E0E71F5D90AULL, + 0xFA528A3ADD7E3A15ULL, 0xFF3C5D7035831AF5ULL, + 0x750E49613F047E1AULL, 0x0EFA6418A8D2883AULL, + 0x0AC3558595BE5352ULL, 0x57D056EE6E2C298BULL, + 0xE208970D787544ACULL, 0x9C180A8D0317D1F8ULL, + 0x8BA5133DCF598711ULL, 0x657F2A31A236E584ULL, + 0x6C6FBB93EA65D834ULL, 0x24CFBAF947D7B42FULL, + 0xF6A3DFBF389016BAULL, 0xA33332D29DBC2353ULL, + 0x610030816CC841B1ULL, 0x21C461AC68A0B673ULL, + 0x19C2AF969E1231FBULL, 0x53D2A1146BBE2BC1ULL, + 0xF27954CB5F22874DULL, 0x61244739DE0DAC4DULL, + 0xEB53CDC97F315397ULL, 0x0A80E8E34BA10CBEULL, + 0xD881A75AC36B54FFULL, 0x62E4784B7D36CD0EULL, + 0xBCE9A220A91B2552ULL, 0x16A6C644BE241EC3ULL, + 0x5982DA6A7F9F8F62ULL, 0x6F2DFD6C84577A2CULL, + 0xDA216E54A6537E5BULL, 0xB66F4EDB3EDCD5FBULL, + 0xC7231EB8C5300D11ULL, 0x49CE7EF38D4657FEULL, + 0x9F5FCD72661AF37CULL, 0x3883721F124956F5ULL, + 0xA80934E782C45553ULL, 0xDB6860E8D8D468DEULL, + 0xF027109C0D61A29CULL, 0x8F8DA924B956CE58ULL, + 0xC93CBFFE2D6DB5DBULL, 0x8E50E1AB75C0A317ULL, + 0x66635E992E4BA14FULL, 0x950A6CA3C35F816DULL, + 0x70C70B3203A8FF7CULL, 0x186798553F6C1148ULL, + 0xA2F4455DC87BB11EULL, 0x4CF748F770030E0EULL, + 0x5F726792BE3D98DDULL, 0x9DC16F987B049328ULL, + 0x6C6187B93B9D7FA5ULL, 0xC66F12E0FE2E5E1EULL, + 0x50AC786FB63F7355ULL, 0x98D2ED17F7058770ULL, + 0xAE885FF2572C58C0ULL, 0x301FB96AA8D1EDE0ULL, + 0xAFD1AE61260838B0ULL, 0xF9D87622B0847807ULL, + 0x9BDE97911B890B8CULL, 0xFAD649325678F286ULL, + 0x9EFC4B47B145D2D1ULL, 0xA7E0947D65695D7CULL, + 0x14084D4D8132538FULL, 0x6F59A6EC8E3DBD7BULL, + 0xB9AE22E3115E1603ULL, 0x2FF5D0C8C87A7D56ULL, + 0x5FE03BA570090E6FULL, 0x4EEA58453C803E30ULL, + 0x76453924F4D5F2ADULL, 0x3702BB9DD2894586ULL, + 0xE71A07E7802B8D98ULL, 0xDFC8FD288ACAAD1BULL, + 0xB006E4207EE68CBAULL, 0xA7B0CA2A348E6B95ULL, + 0x045046C18ECB8502ULL, 0x0F5268BA58C45B3DULL, + }, + .mem = { + 0x0C79919E82E71CBEULL, 0x0F7A5B364CB529D7ULL, + 0x7B3F6CC9935CC350ULL, 0xCF14240A93F14D91ULL, + 0xE40AE330D970C696ULL, 0xD7A054E2831003B7ULL, + 0x8CFC099900430FD3ULL, 0x0BB3E7C54F9A3F9EULL, + 0xDCB532D27669F189ULL, 0x0A1ED326BB7DC152ULL, + 0xE14D510043A6A442ULL, 0x194D407AA2F7C5D0ULL, + 0x0C5F114C6B4957F0ULL, 0xBF7359A4E419D067ULL, + 0x9C81324A027A0CFCULL, 0xE54DDC05001A6ED5ULL, + 0x232FA0DD4484E418ULL, 0x77E8FAA385A92D87ULL, + 0x0E66BF4C28749F06ULL, 0x3FA396DF90B4B5F3ULL, + 0xF53E38C50AB34277ULL, 0xF77D14DE7C1767B5ULL, + 0x6F335ACA45160F11ULL, 0xFB9D674D5EC06E7FULL, + 0xE2AEFFBFAA9EAC92ULL, 0x57124BCAFAC5AEBCULL, + 0x3C6A66C66842F85BULL, 0x9D8439C785FC2601ULL, + 0x9D88DC6772384F64ULL, 0xEDC501105BB30722ULL, + 0x8D3D48D3EEEB92D9ULL, 0xB8FF13C6CFFD0070ULL, + 0xC1FBB496FB79E4B8ULL, 0xC597264680B9C787ULL, + 0x61E2FE4FF6B65797ULL, 0xCB100924F18466FFULL, + 0xC3A65D7BF53BA515ULL, 0x790FEA5D17D189DCULL, + 0xBA2A2A785F524A19ULL, 0x469AC2398958B433ULL, + 0x7DCEE9AA1C35D825ULL, 0xA43F85FCEE85F462ULL, + 0xAEEB15EC05F90690ULL, 0x2502B9C7D7FE541BULL, + 0x276BE3EC5DB93D98ULL, 0x30E4C8CD9936791CULL, + 0xE6EE41FE2EA0DAC4ULL, 0x518518E0F925032CULL, + 0xB789850619F71CB6ULL, 0x0EFE4C699D353420ULL, + 0x370ACD808E01C7C2ULL, 0x618516BB5E21133BULL, + 0x983E758F28B774AFULL, 0x35CFDF21FB804F85ULL, + 0xD683E57E00840D0BULL, 0x0822E977E2794805ULL, + 0xCEA34F5A0719A4D1ULL, 0x95A386640ED9EE98ULL, + 0x30BC01C796A0F610ULL, 0xE87065049B8CAF8AULL, + 0xD1B2275C9D85F665ULL, 0xE2F552B228754951ULL, + 0x13C54371B86AA82AULL, 0xCA67EB69EA397702ULL, + 0x855A165AF29B82B4ULL, 0x5735B38F77BADB5AULL, + 0x26D129DD2CD70556ULL, 0x84099138AC4EDF8EULL, + 0x36559EF24E352BE2ULL, 0x44BFD1BD313F44C6ULL, + 0x8E7AD252F4F4D845ULL, 0xF3B234F6B7AC7694ULL, + 0x77F3153F179A011FULL, 0x873542F0A046056AULL, + 0x2201BD290CA836B8ULL, 0x13B9A249463A2A11ULL, + 0xB7AFE96E5B543891ULL, 0x7A98F82C9EA2DF75ULL, + 0xD554A32A8A3327BAULL, 0x02E488347E48DEF9ULL, + 0xADDCFC2B92112C16ULL, 0x7587B98EBDD38CF3ULL, + 0x0BB35E6227D6D59BULL, 0xB116E68B2F54C3FAULL, + 0x5DB167A1F3CF318DULL, 0x90BB633A7B4546ECULL, + 0xF78130F4365C5F5EULL, 0x7152FFCF54E3A084ULL, + 0xDE4B9060EE0FC0E4ULL, 0xD8848F6DC3CAE0C4ULL, + 0xDD841F587C9BFE2AULL, 0xDD5189B797FB37C8ULL, + 0x47A1CB1AC3524A01ULL, 0x17260EC701FDF3F0ULL, + 0x75632D0248DBC48EULL, 0x32DB8E840B2B8099ULL, + 0xCB701E07E98F290FULL, 0x339D9AF0A6F04632ULL, + 0xCBD3128823F3C484ULL, 0xEC0726A03738FABFULL, + 0xD7D9903C9639DFDCULL, 0x3BC3FDB942B0C043ULL, + 0xD071578B9EE253A5ULL, 0x5C389BB2EABEA563ULL, + 0xD39D2A410EC89783ULL, 0xEA5D8200B54040A0ULL, + 0x794EB983D446731FULL, 0x0CFFEC96AF09FE19ULL, + 0x0DFE666C01D7E162ULL, 0x8A5BF9F690B6D27BULL, + 0x06988AAC4E4B7F60ULL, 0xBA7C09FD2C6C43C2ULL, + 0x1D2BEE9E3B5DF8A3ULL, 0x4EB82703F5A560A6ULL, + 0x61AF9315FC9ABAAAULL, 0xB269184AB9F28E4DULL, + 0xFF8A9D1D5C14407DULL, 0x2B748D94BF7DC6CDULL, + 0x2B8A390DF2E7EA1DULL, 0x0C8541C747D4B583ULL, + 0x2F834BF34C611C46ULL, 0x80C686497471AE70ULL, + 0x5635CAAF93856644ULL, 0xD0EFB84EFE446612ULL, + 0x0292B7EF97B2A86DULL, 0xF30F3AA1BA60D82AULL, + 0x0A3C0E1B7C237B93ULL, 0x187B9AB3FFC91230ULL, + 0x5F623B92A2163E6AULL, 0x1D1FE92B75935077ULL, + 0x9E18E79B668D2918ULL, 0x85E82D860B36AA8DULL, + 0x270A42246B5A7491ULL, 0x2D6BC7B7E81A5E09ULL, + 0x18F12288CA3F92D6ULL, 0xB77BCF7DAA80179CULL, + 0xA5D3BDB08067A8A0ULL, 0xDEA261C861BA66F0ULL, + 0x225F9A8B66D5502FULL, 0xDDF4819587D614C8ULL, + 0x2CCD8B231C268603ULL, 0x4D31DD6619BFBF9FULL, + 0xA9FB2CBD1ACE8857ULL, 0x85E9945DCA2A3E27ULL, + 0x25F349C5C5BF7DE5ULL, 0xD5A6FB93642EAFFFULL, + 0xD595354B59E7CE4BULL, 0xA175181285BF068BULL, + 0x3EE93F28D6FAF411ULL, 0x0FFFEAD8A4E6F41DULL, + 0xAFC353DB1BEADE0BULL, 0x7520F29F62C0ECEFULL, + 0x5250D771A50B7E11ULL, 0x5C67B087D502ACF8ULL, + 0x2759892EAFB5D037ULL, 0xDDBB32B13B4AC6CEULL, + 0x2D40B988E2D9BFB4ULL, 0xF93248E8DB9E8842ULL, + 0xEE25D908C882BAEDULL, 0x4977E48B49529ADBULL, + 0x467CA066A0E27F6DULL, 0xA7E50826EF0E3F8CULL, + 0xE3A2E07AA08BFE53ULL, 0x306B93BD4C096F95ULL, + 0xEA8BDFE2834CA832ULL, 0xCF4B51ECC372A681ULL, + 0x04F83C7380EA268EULL, 0xB22E610CAE19E887ULL, + 0x8E891CE5A4318F02ULL, 0x2077487F3992496BULL, + 0x497837F539DB2184ULL, 0x181D86C7C156081AULL, + 0xDB7FCAC935E91B6FULL, 0x4EE87FAF7D559285ULL, + 0xEDB92A92DC3DAD7FULL, 0x1473537C7D228544ULL, + 0x036176D061DEF6DEULL, 0x3986E56238BCC548ULL, + 0x2FBEB24115F16605ULL, 0xFB10F464E2BE7B73ULL, + 0xE46CD38F2088E2C4ULL, 0x8BFD3EE597EDA395ULL, + 0x644F0352EBC53389ULL, 0x51C13EE7F57C5A9FULL, + 0x7E5CD4E079F9CB4CULL, 0x0CF607376B4341B0ULL, + 0x4ABC75A3AE4E6FCBULL, 0xB97EDBEFE9472CA2ULL, + 0xA05E6A47971A65BDULL, 0x182987101B39936AULL, + 0x59FD15ECB6B75EEEULL, 0xCD7137EDD3AAAA0FULL, + 0xB89F7B766F6E77E3ULL, 0x2419A797D3FE122EULL, + 0xE1E71D60DBEF2DE0ULL, 0x96E6C432F0B858A0ULL, + 0xDE3DE6C39781C3E0ULL, 0x0D64CDE6AB1BA544ULL, + 0xB7A0CCB83D671B25ULL, 0xD28507A8FE21BA52ULL, + 0x3CEB8AC041216716ULL, 0x97642B8E097CA38DULL, + 0x19182754F8B908BFULL, 0x51B72A192C79E366ULL, + 0xE58C3B42A6249D0FULL, 0xDBF9B3F8E28E0957ULL, + 0xD231BA2CC4315938ULL, 0xE4249C8829B3DD01ULL, + 0x569E0559633D6908ULL, 0xA4BD8E5C1BC74F16ULL, + 0x94CABBF22482D3F9ULL, 0xFB795EAF2C705998ULL, + 0x4406C0F3A21C9909ULL, 0x500F64C95F945074ULL, + 0xD74BC591B23826D2ULL, 0x235872A1E6F76BF7ULL, + 0x31F0D2BEF6049F25ULL, 0x67D07CA991673143ULL, + 0x279A7D212B0A3684ULL, 0x2EB3C6E383F45B8FULL, + 0x8FAC09A344320703ULL, 0x7DEED3EB96433729ULL, + 0x0758F7D8F7F93501ULL, 0xA1FC4CAED895F20AULL, + 0xD126DDA1A3607B30ULL, 0x8034344EAF397944ULL, + 0x8A38ED123C707C5EULL, 0x0169907A64D2AE4DULL, + 0x342D9BD529802E12ULL, 0xE56E06686DC5E011ULL, + 0xFDDBAF65EE0CEF9BULL, 0x6A54E266E4898DA6ULL, + 0x05B14F2B6EF6A8A2ULL, 0x9C7A6CE690810500ULL, + 0xAAAAA6300C92E7ADULL, 0x746F7E694A1A2558ULL, + 0x292827D4FB6C2438ULL, 0xB7E6D7D1CB21A0D9ULL, + 0x22985E0BD3C4D496ULL, 0x8D0112E4017CD2FAULL, + 0x49436E297D6181C4ULL, 0x9F79632B1A812B1EULL, + 0x60ACF3E8F44F95FBULL, 0x4D5AC22865A3D666ULL, + 0x9AF7EEBA53E74F73ULL, 0xFABCDE5759ED94A7ULL, + 0x7C2898C7E7D16FEEULL, 0x03EAC968C08730FBULL, + 0x762080A2AB6C91E5ULL, 0xF452365F45AFC579ULL, + 0x2F346D934DCB2F9DULL, 0x37B2F28592EECF4FULL, + 0x0D950E3F1FBF8D1DULL, 0xE689A5CFFCF32AA4ULL, + 0xBC029C49E765D9E3ULL, 0x2CE18BC0B585556EULL, + } +}; + +#else + const static isaac_ctx_t zero_initialised_ctx = { .next_index = ISAAC_ELEMENTS - 1, .a = 0x44D22B48UL, @@ -288,6 +826,8 @@ const static isaac_ctx_t nonzero_initialised_ctx = { } }; +#endif + static void test_init_zero_seed(void) { isaac_ctx_t ctx; diff --git a/tst/test_stream.c b/tst/test_stream.c index 4406fc8..1003406 100644 --- a/tst/test_stream.c +++ b/tst/test_stream.c @@ -12,14 +12,373 @@ #define EXPECTED_NEXT_ELEMENTS 512 +#if ISAAC_BITS > 32 /* - * This is the stream of uint32 values obtained by calling isaac_next() - * repeatedly after the isaac_ctx_t has been initialised with a zero seed. - * - * In particular this is the value printed by next_values_zero_seed() - * in generate.c + * This is the stream of values obtained from ISAAC 64-bits + * repeatedly after the isaac_ctx_t has been initialised with a + * zero-seed. + */ +const static isaac_uint_t + expected_stream_with_zero_seed[EXPECTED_NEXT_ELEMENTS] = { + 0x48CBFF086DDF285AULL, 0x99E7AFEABE000731ULL, 0x93C42566AEF98FFBULL, + 0xA865A54EDCC0F019ULL, 0x0D151D86ADB73615ULL, 0xDAB9FE6525D89021ULL, + 0x1B85D488D0F20CC5ULL, 0xF678647E3519AC6EULL, 0x5E11E86D5873D484ULL, + 0x0ED9B915C66ED37EULL, 0xB0183DB56FFC6A79ULL, 0x506E6744CD974924ULL, + 0x881B82A13B51B9E2ULL, 0x9A9632E65904AD3CULL, 0x742E1E651C60BA83ULL, + 0x04FEABFBBDB619CBULL, 0x284C847B9D887AAEULL, 0x56FD23C8F9715A4CULL, + 0x0CD9A497658A5698ULL, 0x5A110C6058B920A0ULL, 0x04208FE9E8F7F2D6ULL, + 0x7A249A57EC0C9BA2ULL, 0x1D1260A51107FE97ULL, 0x722FF175F572C348ULL, + 0x9D1DFA2EFC557F73ULL, 0x52AB92BEB9613989ULL, 0x528F7C8602C5807BULL, + 0xD941ACA44B20A45BULL, 0x4361C0CA3F692F12ULL, 0x513E5E634C70E331ULL, + 0x77A225A07CC2C6BDULL, 0xA90B24499FCFAFB1ULL, 0x35CAB62109DD038AULL, + 0x32095B6D4AB5F9B1ULL, 0x3810E399B6F65BA2ULL, 0x9D1D60E5076F5B6FULL, + 0x7A1EE967D27579E2ULL, 0x68CA39053261169FULL, 0x8CFFA9412EB642C1ULL, + 0x40E087931A00930DULL, 0x4C0563B89F495AC3ULL, 0x18FCF680573FA594ULL, + 0xFCAF55C1BF8A4424ULL, 0x39B0BF7DDE437BA2ULL, 0xF3A678CAD9A2E38CULL, + 0x7BA2484C8A0FD54EULL, 0x16B9F7E06C453A21ULL, 0x87D380BDA5BF7859ULL, + 0x4F2A5CB07F6A35B3ULL, 0xA2F61BB6E437FDB5ULL, 0xA74049DAC312AC71ULL, + 0x336F52F8FF4728E7ULL, 0xD95BE88CD210FFA7ULL, 0xD7F4F2448C0CEB81ULL, + 0xF7A255D83BC373F8ULL, 0xD2B7ADEEDED1F73FULL, 0x3BBA57B68871B59DULL, + 0xDF1D9F9D784BA010ULL, 0x94061B871E04DF75ULL, 0x9315E5EB3A129ACEULL, + 0x08BD35CC38336615ULL, 0xFE9A44E9362F05FAULL, 0x78E37644E7CAD29EULL, + 0xC547F57E42A7444EULL, 0x6703DF9D2924E97EULL, 0x8EC97D2917456ED0ULL, + 0x9C684CB6C4D24417ULL, 0xFC6A82D64B8655FBULL, 0xF9B5B7C4ACC67C96ULL, + 0x69B97DB1A4C03DFEULL, 0xE755178D58FC4E76ULL, 0xA4FC4BD4FC5558CAULL, + 0x9AE182C8BC9474E8ULL, 0xB05CA3F564268D99ULL, 0xCFC447F1E53C8E1BULL, + 0x4850E73E03EB6064ULL, 0x2C604A7A177326B3ULL, 0x0BF692B38D079F23ULL, + 0xDE336A2A4BC1C44BULL, 0xD7288E012AEB8D31ULL, 0xF793C46702E086A0ULL, + 0x763C4A1371B368FDULL, 0x2DF16F761598AA4FULL, 0x21A007933A522A20ULL, + 0xB3819A42ABE61C87ULL, 0xB46EE9C5E64A6E7CULL, 0xC07A3F80C31FB4B4ULL, + 0x51039AB7712457C3ULL, 0x4DC4DE189B671A1CULL, 0x066F70B33FE09017ULL, + 0x9DA4243DE836994FULL, 0xBCE5D2248682C115ULL, 0x11379625747D5AF3ULL, + 0xF4F076E65F2CE6F0ULL, 0x52593803DFF1E840ULL, 0x19AFE59AE451497FULL, + 0xAEF3AF4A563DFE43ULL, 0x480412BAB7F5BE2AULL, 0xAF2042F5CC5C2858ULL, + 0xEF2F054308F6A2BCULL, 0x9BC5A38EF729ABD4ULL, 0x2D255069F0B7DAB3ULL, + 0x5648F680F11A2741ULL, 0xC5CC1D89724FA456ULL, 0x28AED140BE0BB7DDULL, + 0x10CFF333E0ED804AULL, 0x91B859E59ECB6350ULL, 0xB415938D7DA94E3CULL, + 0x21F08570F420E565ULL, 0xDED2D633CAD004F6ULL, 0x65942C7B3C7E11AEULL, + 0xA87832D392EFEE56ULL, 0xAA969B5C691CCB7AULL, 0x43539603D6C55602ULL, + 0x1BEDE3A3AEF53302ULL, 0xDEC468145B7605F6ULL, 0x808BD68E6AC10365ULL, + 0xC91800E98FB99929ULL, 0x22FE545401165F1CULL, 0x7EED120D54CF2DD9ULL, + 0xDD2C5BC84BC8D8FCULL, 0xAE623FD67468AA70ULL, 0xFF6712FFCFD75EA1ULL, + 0x930F80F4E8EB7462ULL, 0x45F20042F24F1768ULL, 0xBB215798D45DF7AFULL, + 0xEFAC4B70633B8F81ULL, 0x56436C9FE1A1AA8DULL, 0x73A1921916591CBDULL, + 0x70EB093B15B290CCULL, 0x920E449535DD359EULL, 0x043FCAE60CC0EBA0ULL, + 0xA246637CFF328532ULL, 0x97D7374C60087B73ULL, 0x86536B8CF3428A8CULL, + 0x799E81F05BC93F31ULL, 0xEDE6C87F8477609DULL, 0x3C79A0FF5580EF7FULL, + 0xF538639CE705B824ULL, 0xCF464CEC899A2F8AULL, 0x4A750A09CE9573F7ULL, + 0xB5889C6E15630A75ULL, 0x05A7E8A57DB91B77ULL, 0xB9FD7620E7316243ULL, + 0x7B32F7D1E03680ECULL, 0xEF927DBCF00C20F2ULL, 0xDFD395339CDBF4A7ULL, + 0x6503080440750644ULL, 0x1881AFC9A3A701D6ULL, 0x506AACF489889342ULL, + 0x5B9B63EB9CEFF80CULL, 0x2171E64683023A08ULL, 0x6304D09A0B3738C4ULL, + 0x4F80F7A035DAFB04ULL, 0x9A74ACB964E78CB3ULL, 0x1E1032911FA78984ULL, + 0x5BFEA5B4712768E9ULL, 0x390E5FB44D01144BULL, 0xB3F22C3D0B0B38EDULL, + 0x9C1633264DB49C89ULL, 0x8DE8DCA9F03CC54EULL, 0xFF07F64EF8ED14D0ULL, + 0x092237AC237F3859ULL, 0x87BF02C6B49E2AE9ULL, 0x1920C04D47267BBDULL, + 0xAE4A9346CC3F7CF2ULL, 0xA366E5B8C54F48B8ULL, 0x87B3E2B2B5C907B1ULL, + 0xF9B89D3E99A075C2ULL, 0x70AC4CD9F04F21F5ULL, 0x9A85AC909A24EAA1ULL, + 0xEE954D3C7B411F47ULL, 0x72B12C32127FED2BULL, 0x54B3F4FA5F40D873ULL, + 0x8535F040B9744FF1ULL, 0x27E6AD7891165C3FULL, 0xE99D662AF4243939ULL, + 0xA49CD132BFBF7CC4ULL, 0x0CE26C0B95C980D9ULL, 0xBB6E2924F03912EAULL, + 0x24C3C94DF9C8D3F6ULL, 0xDABF2AC8201752FCULL, 0xF145B6BECCDEA195ULL, + 0x14ACBAF4777D5776ULL, 0x79AD695501E7D1E8ULL, 0x8249A47AEE0E41F7ULL, + 0x637A7780DECFC0D9ULL, 0x19FC8A768CF4B6D4ULL, 0x7BCBC38DA25A7F3CULL, + 0x5093417AA8A7ED5EULL, 0x07FB9F855A997142ULL, 0x5355F900C2A82DC7ULL, + 0xEC16CA8AEA98AD76ULL, 0x63DC359D8D231B78ULL, 0x93C5B5F47356388BULL, + 0x39F890F579F92F88ULL, 0x5F0F4A5898171BB6ULL, 0x42880B0236E4D951ULL, + 0x6D2BDCDAE2919661ULL, 0x42E240CB63689F2FULL, 0x96D693460CC37E5DULL, + 0x4DE0B0F40F32A7B8ULL, 0x6568FCA92C76A243ULL, 0x11D505D4C351BD7FULL, + 0x7EF48F2B83024E20ULL, 0xB9BC6C87167C33E7ULL, 0x8C74C368081B3075ULL, + 0x3253A729B9BA3DDEULL, 0xFCF7FE8A3430B241ULL, 0x5C82C505DB9AB0FAULL, + 0x51EBDC4AB9BA3035ULL, 0x9F74D14F7454A824ULL, 0xBF983FE0FE5D8244ULL, + 0xD310A7C2CE9B6555ULL, 0x1FCBACD259BF02E7ULL, 0x18727070F1BD400BULL, + 0x735E2B97A4C45A23ULL, 0x3575668334A1DD3BULL, 0x09D1BC9A3DD90A94ULL, + 0x637B2B34FF93C040ULL, 0x03488B95B0F1850FULL, 0xA71B9B83461CBD93ULL, + 0x14A68FD73C910841ULL, 0x4C9F34427501B447ULL, 0x24AA6C514DA27500ULL, + 0xC9452CA81A09D85DULL, 0x7B0500AC42047AC4ULL, 0xB4AB30F062B19ABFULL, + 0x19F3C751D3E92AE1ULL, 0x87D2074B81D79217ULL, 0x8DBD98A352AFD40BULL, + 0xAA649C6EBCFD50FCULL, 0x4BB38DE5E7219443ULL, 0x331478F3AF51BBE6ULL, + 0xF3218F1C9510786CULL, 0x82C7709E781EB7CCULL, 0x7D11CDB1C3B7ADF0ULL, + 0x7449BBFF801FED0BULL, 0x679F848F6E8FC971ULL, 0x05D1A1AE85B49AA1ULL, + 0x239F8B2D7FF719CCULL, 0x5DB4832046F3D9E5ULL, 0x011355146FD56395ULL, + 0x40BDF15D4A672E32ULL, 0xD021FF5CD13A2ED5ULL, 0x9605D5F0E25EC3B0ULL, + 0x1A083822CEAFE02DULL, 0x0D7E765D58755C10ULL, 0xE83A908FF2FB60CAULL, + 0x0FBBAD1F61042279ULL, 0x3290AC3A203001BFULL, 0x75834465489C0C89ULL, + 0x9C15F73E62A76AE2ULL, 0x44DB015024623547ULL, 0x2AF7398005AAA5C7ULL, + 0x9D39247E33776D41ULL, 0x12A8F216AF9418C2ULL, 0xD4490AD526F14431ULL, + 0xB49C3B3995091A36ULL, 0x5B45E522E4B1B4EFULL, 0xA1E9300CD8520548ULL, + 0x49787FEF17AF9924ULL, 0x03219A39EE587A30ULL, 0xEBE9EA2ADF4321C7ULL, + 0x804456AF10F5FB53ULL, 0xD74BBE77E6116AC7ULL, 0x7C0828DD624EC390ULL, + 0x14A195640116F336ULL, 0x2EAB8CA63CE802D7ULL, 0xC6E57A78FBD986E0ULL, + 0x58EFC10B06A2068DULL, 0xABEEDDB2DDE06FF1ULL, 0x0B090A7560A968E3ULL, + 0x2CF9C8CA052F6E9FULL, 0x116D0016CB948F09ULL, 0xA59E0BD101731A28ULL, + 0x63767572AE3D6174ULL, 0xAB4F6451CC1D45ECULL, 0xC2A1E7B5B459AEB5ULL, + 0x2472F6207C2D0484ULL, 0xE699ED85B0DFB40DULL, 0xD4347F66EC8941C3ULL, + 0xF4D14597E660F855ULL, 0x8B889D624D44885DULL, 0x258E5A80C7204C4BULL, + 0xAF0C317D32ADAA8AULL, 0x9C4CD6257C5A3603ULL, 0xEB3593803173E0CEULL, + 0x36F60E2BA4FA6800ULL, 0x38B6525C21A42B0EULL, 0xF4F5D05C10CAB243ULL, + 0xCF3F4688801EB9AAULL, 0x1DDC0325259B27DEULL, 0xB9571FA04DC089C8ULL, + 0xD7504DFA8816EDBBULL, 0x1FE2CCA76517DB90ULL, 0x261E4E4C0A333A9DULL, + 0x219B97E26FFC81BDULL, 0x66B4835D9EAFEA22ULL, 0x4CC317FB9CDDD023ULL, + 0x50B704CAB602C329ULL, 0xEDB454E7BADC0805ULL, 0x9E17E49642A3E4C1ULL, + 0x66C1A2A1A60CD889ULL, 0x7983EED3740847D5ULL, 0x298AF231C85BAFABULL, + 0x2680B122BAA28D97ULL, 0x734DE8181F6EC39AULL, 0x53898E4C3910DA55ULL, + 0x1761F93A44D5AEFEULL, 0xE4DBF0634473F5D2ULL, 0x4ED0FE7E9DC91335ULL, + 0xD18D8549D140CAEAULL, 0x1CFC8BED0D681639ULL, 0xCA1E3785A9E724E5ULL, + 0xB67C1FA481680AF8ULL, 0xDFEA21EA9E7557E3ULL, 0xD6B6D0ECC617C699ULL, + 0xFA7E393983325753ULL, 0xA09E8C8C35AB96DEULL, 0x8FE88B57305E2AB6ULL, + 0x89039D79D6FC5C5CULL, 0x9BFB227EBDF4C5CEULL, 0x7F7CC39420A3A545ULL, + 0x3F6C6AF859D80055ULL, 0xC8763C5B08D1908CULL, 0x469356C504EC9F9DULL, + 0x26E6DB8FFDF5ADFEULL, 0x3A938FEE32D29981ULL, 0x2C5E9DEB57EF4743ULL, + 0x1E99B96E70A9BE8BULL, 0x764DBEAE7FA4F3A6ULL, 0xAAC40A2703D9BEA0ULL, + 0x1A8C1E992B941148ULL, 0x73AA8A564FB7AC9EULL, 0x604D51B25FBF70E2ULL, + 0xDD69A0D8AB3B546DULL, 0x65CA5B96B7552210ULL, 0x2FD7E4B9E72CD38CULL, + 0x51D2B1AB2DDFB636ULL, 0x9D1D84FCCE371425ULL, 0xA44CFE79AE538BBEULL, + 0xDE68A2355B93CAE6ULL, 0x9FC10D0F989993E0ULL, 0x94EBC8ABCFB56DAEULL, + 0xD7A023A73260B45CULL, 0x72C8834A5957B511ULL, 0x8F8419A348F296BFULL, + 0x1E152328F3318DEAULL, 0x4838D65F6EF6748FULL, 0xD6BF7BAEE43CAC40ULL, + 0x13328503DF48229FULL, 0x7440FB816508C4FEULL, 0x9D266D6A1CC0542CULL, + 0x4DDA48153C94938AULL, 0x74C04BF1790C0EFEULL, 0xE1925C71285279F5ULL, + 0x8A8E849EB32781A5ULL, 0x073973751F12DD5EULL, 0xA319CE15B0B4DB31ULL, + 0x6DD856D94D259236ULL, 0x67378D8ECCEF96CBULL, 0x9FC477DE4ED681DAULL, + 0xF3B8B6675A6507FFULL, 0xC3A9DC228CAAC9E9ULL, 0xC37B45B3F8D6F2BAULL, + 0xB559EB1D04E5E932ULL, 0x1B0CAB936E65C744ULL, 0xAF08DA9177DDA93DULL, + 0xAC12FB171817EEE7ULL, 0x1FFF7AC80904BF45ULL, 0xA9119B60369FFEBDULL, + 0xBFCED1B0048EAC50ULL, 0xB67B7896167B4C84ULL, 0x9B3CDB65F82CA382ULL, + 0xDBC27AB5447822BFULL, 0x10DCD78E3851A492ULL, 0xB438C2B67F98E5E9ULL, + 0x43954B3252DC25E5ULL, 0xAB9090168DD05F34ULL, 0xCE68341F79893389ULL, + 0x36833336D068F707ULL, 0xDCDD7D20903D0C25ULL, 0xDA3A361B1C5157B1ULL, + 0x7F9D1A2E1EBE1327ULL, 0x5D0A12F27AD310D1ULL, 0x3BC36E078F7515D7ULL, + 0x4DA8979A0041E8A9ULL, 0x950113646D1D6E03ULL, 0x7B4A38E32537DF62ULL, + 0x8A1B083821F40CB4ULL, 0x3D5774A11D31AB39ULL, 0x7A76956C3EAFB413ULL, + 0x7F5126DBBA5E0CA7ULL, 0x12153635B2C0CF57ULL, 0x7B3F0195FC6F290FULL, + 0x5544F7D774B14AEFULL, 0x56C074A581EA17FEULL, 0xE7F28ECD2D49EECDULL, + 0xE479EE5B9930578CULL, 0x9FF38FED72E9052FULL, 0x9F65789A6509A440ULL, + 0x0981DCD296A8736DULL, 0x5873888850659AE7ULL, 0xC678B6D860284A1CULL, + 0x63E22C147B9C3403ULL, 0x92FAE24291F2B3F1ULL, 0x829626E3892D95D7ULL, + 0xCFFE1939438E9B24ULL, 0x79999CDFF70902CBULL, 0x8547EDDFB81CCB94ULL, + 0x7B77497B32503B12ULL, 0x97FCAACBF030BC24ULL, 0x6CED1983376FA72BULL, + 0x7E75D99D94A70F4DULL, 0xD2733C4335C6A72FULL, 0xDBC0D2B6AB90A559ULL, + 0x94628D38D0C20584ULL, 0x64972D68DEE33360ULL, 0xB9C11D5B1E43A07EULL, + 0x2DE0966DAF2F8B1CULL, 0x2E18BC1AD9704A68ULL, 0xD4DBA84729AF48ADULL, + 0xB7A0B174CFF6F36EULL, 0xE94C39A54A98307FULL, 0xAA70B5B4F89695A2ULL, + 0x3BDBB92C43B17F26ULL, 0xCCCB7005C6B9C28DULL, 0x18A6A990C8B35EBDULL, + 0xFC7C95D827357AFAULL, 0x1FCA8A92FD719F85ULL, 0x1DD01AAFCD53486AULL, + 0x49353FEA39BA63B1ULL, 0xF85B2B4FBCDE44B7ULL, 0xBE7444E39328A0ACULL, + 0x3E2B8BCBF016D66DULL, 0x964E915CD5E2B207ULL, 0x1725CABFCB045B00ULL, + 0x7FBF21EC8A1F45ECULL, 0x11317BA87905E790ULL, 0x2FE4B17170E59750ULL, + 0xE8D9ECBE2CF3D73FULL, 0xB57D2E985E1419C7ULL, 0x0572B974F03CE0BBULL, + 0xA8D7E4DAB780A08DULL, 0x4715ED43E8A45C0AULL, 0xC330DE426430F69DULL, + 0x23B70EDB1955C4BFULL, 0x098954D51FFF6580ULL, 0x8107FCCF064FCF56ULL, + 0x852F54934DA55CC9ULL, 0x09C7E552BC76492FULL, 0xE9F6760E32CD8021ULL, + 0xA3BC941D0A5061CBULL, 0xBA89142E007503B8ULL, 0xDC842B7E2819E230ULL, + 0xBBE83F4ECC2BDECBULL, 0xCD454F8F19C5126AULL, 0xC62C58F97DD949BFULL, + 0x693501D628297551ULL, 0xB9AB4CE57F2D34F3ULL, 0x9255ABB50D532280ULL, + 0xEBFAFA33D7254B59ULL, 0xE9F6082B05542E4EULL, 0x35DD37D5871448AFULL, + 0xB03031A8B4516E84ULL, 0xB3F256D8ACA0B0B9ULL, 0x0FD22063EDC29FCAULL, + 0xD9A11FBB3D9808E4ULL, 0x3A9BF55BA91F81CAULL, 0xC8C93882F9475F5FULL, + 0x947AE053EE56E63CULL, 0xC7D9F16864A76E94ULL, 0x7BD94E1D8E17DEBCULL, + 0xD873DB391292ED4FULL, 0x30F5611484119414ULL, 0x565C31F7DE89EA27ULL, + 0xD0E4366228B03343ULL, 0x325928EE6E6F8794ULL, 0x6F423357E7C6A9F9ULL, + 0x99170A5DC3115544ULL, 0x59B97885E2F2EA28ULL, 0xBC4097B116C524D2ULL, + 0x7A13F18BBEDC4FF5ULL, 0x071582401C38434DULL, 0xB422061193D6F6A7ULL, + 0xB4B81B3FA97511E2ULL, 0x65D34954DAF3CEBDULL, 0xB344C470397BBA52ULL, + 0xBAC7A9A18531294BULL, 0xECB53939887E8175ULL, 0x565601C0364E3228ULL, + 0xEF1955914B609F93ULL, 0x16F50EDF91E513AFULL, 0x56963B0DCA418FC0ULL, + 0xD60F6DCEDC314222ULL, 0x364F6FFA464EE52EULL, 0x6C3B8E3E336139D3ULL, + 0xF943AEE7FEBF21B8ULL, 0x088E049589C432E0ULL, 0xD49503536ABCA345ULL, + 0x3A6C27934E31188AULL, 0x957BAF61700CFF4EULL, 0x37624AE5A48FA6E9ULL, + 0x501F65EDB3034D07ULL, 0x907F30421D78C5DEULL, 0x1A804AADB9CFA741ULL, + 0x0CE2A38C344A6EEDULL, 0xD363EFF5F0977996ULL, 0x2CD16E2ABD791E33ULL, + 0x58627E1A149BBA21ULL, 0x7F9B6AF1EBF78BAFULL, +}; +/* + * This is the stream of values obtained from ISAAC 32-bits + * repeatedly after the isaac_ctx_t has been initialised with a + * seed of {1, 2, 3, 4, 5, 6, 7, 8} (in bytes) */ -const static uint32_t expected_stream_with_zero_seed[EXPECTED_NEXT_ELEMENTS] = { +const static isaac_uint_t + expected_stream_with_nonzero_seed[EXPECTED_NEXT_ELEMENTS] = { + 0xB3891B01375810CCULL, 0xDA96A425DA703312ULL, 0xDD5B6A7476AB8569ULL, + 0xF8554A3AA49F36E7ULL, 0x822DE2A73CAE6733ULL, 0xD9C905B02CF51766ULL, + 0x6BEFD4C8A7D50825ULL, 0x2ED44884B6E11C35ULL, 0xF4728A064CB520F5ULL, + 0x3BCADDE6C4EC8E96ULL, 0x3F89E183398D5940ULL, 0xDA2F43D111423313ULL, + 0x242EA73DF7CA0860ULL, 0xCBA3B02E3BAD0948ULL, 0xFA0F6583FB1F5E01ULL, + 0x309018B4D9149F96ULL, 0x834DB9CC2F420C86ULL, 0xBEF83DCAA6D1190BULL, + 0x078F1B90F89F3FE6ULL, 0x6011EA83A8714BA8ULL, 0x259958AC44D0BBFEULL, + 0x2534DB160EAFC593ULL, 0x8AF9D5ADF07B33F7ULL, 0xDC7B502CC32BC77EULL, + 0x33372718EB75D6ADULL, 0x89786EDCC2D94AA2ULL, 0x6A39183F04BFEB5EULL, + 0x88DFC98EE270013AULL, 0x98B4B58B108AD734ULL, 0x9C4A937F3159BA74ULL, + 0xE22C78A51A3E67EAULL, 0x4A16BFCA28113F08ULL, 0xED174D340C810216ULL, + 0xD50B0628F4F731D2ULL, 0x6C014B77CC39AF37ULL, 0x17D2F37F03F5C0DAULL, + 0x81E601F222BECD12ULL, 0x4204A0CEC4F4BE52ULL, 0xEC45281930D33BD2ULL, + 0x6597FA6C39BB1E54ULL, 0x493641090A01DC06ULL, 0x2FA3F4BAC8A1AFE8ULL, + 0x3F26B6F479F0AE52ULL, 0xA615310B08B68291ULL, 0x206A59347BC6E9D5ULL, + 0x399F26F5C3970AE4ULL, 0x551AB6DA27DC63DEULL, 0x0A59EB2B496CD44BULL, + 0xBADCBAB1A446C8F5ULL, 0x24C46C6B7FBDD86BULL, 0xC3F32E9B485C27D7ULL, + 0x9C022AB38642172AULL, 0x6B55312F5AF150F5ULL, 0x7F5FA5557B924002ULL, + 0x377B586F01441DFFULL, 0x4CC5028796FB93B7ULL, 0x8AA78A7640AEA2D1ULL, + 0x113612A59D1E75C5ULL, 0x920E5F8D74BD03E4ULL, 0x6FF9AE736431EFB7ULL, + 0xFDF6FD0B61CF989BULL, 0x7D7BB2F48D4AFB97ULL, 0x5B4C3A83A62BFB8AULL, + 0xC97E529227587D27ULL, 0xAF326587C6004EC5ULL, 0x3E32CF90D6D906EFULL, + 0x4A62A8F4C3715CB3ULL, 0x90268314EFA4E871ULL, 0xD8F3715B26E46A83ULL, + 0x5D2B9304BF7E6C93ULL, 0x6D2D8D9D0DBEE19EULL, 0xB4A6C753B8128B46ULL, + 0x6377D659A4B26BEBULL, 0xF8EE87D6949BE2E8ULL, 0x9A73C51AD3570E87ULL, + 0x501294AE6549F9A3ULL, 0x61A93B8855668BC1ULL, 0x5974EB02B5C0BA3DULL, + 0xCEB9DDB84ED120AAULL, 0xFE5F62889B61932AULL, 0x7546A69A2EA94D29ULL, + 0x6C0E62542E0439E4ULL, 0x484D9F68FA5215CCULL, 0x8606513970A3A52CULL, + 0x58CAEFDC4E8E7231ULL, 0x74379793CCEB8245ULL, 0x0AD037BA9B7670A2ULL, + 0xBA15B44C027B2ECCULL, 0xABFA9F6E86AAEFB8ULL, 0xF970EEA853412742ULL, + 0x3318E2051B1257A5ULL, 0x49C0724F0D1855C8ULL, 0xD1321A04764071BEULL, + 0xBB0DB172A6E76658ULL, 0xA6A1647FCCF3D5E7ULL, 0x194DDF7D97414D9DULL, + 0x6CC091C7E7180A82ULL, 0x3A0A620CFD2BA9CBULL, 0x9E77BE037DDE48C6ULL, + 0x6D9D8AC2E1833141ULL, 0x6862F171E0DAF32BULL, 0x31B52B078346F8A1ULL, + 0x738A7181CE63126DULL, 0x2D6469A7B5432AEFULL, 0x3CABF03A65D3ADB7ULL, + 0x2C806C2905EC8713ULL, 0x1C3BA696916B718DULL, 0x007CA7B87307E602ULL, + 0x4528C8387F1D0081ULL, 0x62E6B98BA6116448ULL, 0xECD75C6D93BB6DF5ULL, + 0xC2AC1D8E2F2EB5CEULL, 0xA7C9E67CB8F63BD5ULL, 0x6F8729EF946F71A6ULL, + 0x957B5D3D3BCA6188ULL, 0x67614FD77E630039ULL, 0xE9106325BF20A386ULL, + 0xEE15E2CEF989D75AULL, 0x3E34F2B924CC4C2DULL, 0xDC030073BD362B5AULL, + 0x29AAD64DAD0E025EULL, 0x04A82DE3B187F8FEULL, 0xB37CA8D4A7C02239ULL, + 0xBF0B576B634BF6B3ULL, 0x93AB7E6B54E75133ULL, 0x959B6BE4E24884A6ULL, + 0xF3CC60A1AC3E1ACDULL, 0x2AD69EAA75138A36ULL, 0xE2E8770C4C1781CAULL, + 0xF60EC787A39A9D71ULL, 0x4069DE08359C7A24ULL, 0xCE3E52A9EC12F233ULL, + 0x7AD2ADDDFECC7789ULL, 0xBC3F347FFC3F5CF4ULL, 0xA641CFA106B0BC70ULL, + 0x9DCCF828FF910928ULL, 0xDAEE6BC29548E7C3ULL, 0x42AB69C1F8D3DB3FULL, + 0x88238CAE89E99F9FULL, 0x1DE97A6C0CE8D551ULL, 0xBF0BF81388CC129DULL, + 0xB5D8065D7B3EFE59ULL, 0x726C87954507C8C1ULL, 0x200614CF86134154ULL, + 0x1DFBD256B0E5C2C6ULL, 0x0E792A3B86EADCC3ULL, 0x5D3E6F261CE70F7CULL, + 0x8BFF928A2971393DULL, 0x0B195AD821E1E4FAULL, 0x1803DF8C99C59332ULL, + 0x174E9F2D0CE39045ULL, 0x9D084D97981E33D9ULL, 0xC940263A84626786ULL, + 0x39AF8BAB29F47821ULL, 0x6128FAFEF2E659BEULL, 0xB10460F7D51AC2B3ULL, + 0x20E006C6C8A57285ULL, 0x6A4A77154E5653CAULL, 0x46EDCBAF25A7A14DULL, + 0x00487151150521A1ULL, 0x1529629E312DABC3ULL, 0x78750BC889C6E005ULL, + 0xA845EF8ED936AFBEULL, 0xCE6FA3C4F2F8A81BULL, 0x559582636A99BCEDULL, + 0xFD0AA02C6EE9F662ULL, 0x544D081E0E3F0D62ULL, 0xD515D078241B7060ULL, + 0xADA077E2CD24E1D6ULL, 0x708520FFAA2F05CCULL, 0x6C30EDD49B09E39BULL, + 0xC1A893D5BF9D0659ULL, 0x07EF9D86A21F0548ULL, 0xAFA4DD97E65FDC73ULL, + 0x5B5965F0E5E89A8EULL, 0x6FF2CE860253DDD4ULL, 0xC0E85C3A394C17CAULL, + 0x3B7667D1862E87EFULL, 0xC8BB74DD1661AD89ULL, 0xD8628607512B7583ULL, + 0xBA4ACB545CE4150FULL, 0x1A110E0E71F5D90AULL, 0xFA528A3ADD7E3A15ULL, + 0xFF3C5D7035831AF5ULL, 0x750E49613F047E1AULL, 0x0EFA6418A8D2883AULL, + 0x0AC3558595BE5352ULL, 0x57D056EE6E2C298BULL, 0xE208970D787544ACULL, + 0x9C180A8D0317D1F8ULL, 0x8BA5133DCF598711ULL, 0x657F2A31A236E584ULL, + 0x6C6FBB93EA65D834ULL, 0x24CFBAF947D7B42FULL, 0xF6A3DFBF389016BAULL, + 0xA33332D29DBC2353ULL, 0x610030816CC841B1ULL, 0x21C461AC68A0B673ULL, + 0x19C2AF969E1231FBULL, 0x53D2A1146BBE2BC1ULL, 0xF27954CB5F22874DULL, + 0x61244739DE0DAC4DULL, 0xEB53CDC97F315397ULL, 0x0A80E8E34BA10CBEULL, + 0xD881A75AC36B54FFULL, 0x62E4784B7D36CD0EULL, 0xBCE9A220A91B2552ULL, + 0x16A6C644BE241EC3ULL, 0x5982DA6A7F9F8F62ULL, 0x6F2DFD6C84577A2CULL, + 0xDA216E54A6537E5BULL, 0xB66F4EDB3EDCD5FBULL, 0xC7231EB8C5300D11ULL, + 0x49CE7EF38D4657FEULL, 0x9F5FCD72661AF37CULL, 0x3883721F124956F5ULL, + 0xA80934E782C45553ULL, 0xDB6860E8D8D468DEULL, 0xF027109C0D61A29CULL, + 0x8F8DA924B956CE58ULL, 0xC93CBFFE2D6DB5DBULL, 0x8E50E1AB75C0A317ULL, + 0x66635E992E4BA14FULL, 0x950A6CA3C35F816DULL, 0x70C70B3203A8FF7CULL, + 0x186798553F6C1148ULL, 0xA2F4455DC87BB11EULL, 0x4CF748F770030E0EULL, + 0x5F726792BE3D98DDULL, 0x9DC16F987B049328ULL, 0x6C6187B93B9D7FA5ULL, + 0xC66F12E0FE2E5E1EULL, 0x50AC786FB63F7355ULL, 0x98D2ED17F7058770ULL, + 0xAE885FF2572C58C0ULL, 0x301FB96AA8D1EDE0ULL, 0xAFD1AE61260838B0ULL, + 0xF9D87622B0847807ULL, 0x9BDE97911B890B8CULL, 0xFAD649325678F286ULL, + 0x9EFC4B47B145D2D1ULL, 0xA7E0947D65695D7CULL, 0x14084D4D8132538FULL, + 0x6F59A6EC8E3DBD7BULL, 0xB9AE22E3115E1603ULL, 0x2FF5D0C8C87A7D56ULL, + 0x5FE03BA570090E6FULL, 0x4EEA58453C803E30ULL, 0x76453924F4D5F2ADULL, + 0x3702BB9DD2894586ULL, 0xE71A07E7802B8D98ULL, 0xDFC8FD288ACAAD1BULL, + 0xB006E4207EE68CBAULL, 0xA7B0CA2A348E6B95ULL, 0x045046C18ECB8502ULL, + 0x0F5268BA58C45B3DULL, 0x3F5520228E129D57ULL, 0x58F23FC19607C4B2ULL, + 0xEFAEEB32DD76E8A8ULL, 0x86B4F0C2D15868B6ULL, 0xD85D19901F208C0FULL, + 0xD33DBC2FE1D07236ULL, 0x12E59DF6CA6D4DFAULL, 0x1AB2342EECCF73BEULL, + 0xCFC46D7430CAC9B3ULL, 0xF844AC2F84007C3FULL, 0x28EF1C1B06F8EE43ULL, + 0x10CE716ED954252EULL, 0xDBAA63392EBBFE71ULL, 0xE89B8179DF85F49FULL, + 0x1CB56698B1B38640ULL, 0x5B6E5CA7AB8700BAULL, 0x0F36C77D7BBDDED7ULL, + 0x195E12B60B683412ULL, 0x18A2CD67A4981A99ULL, 0xC58BC4659BEB6080ULL, + 0xD2F96B7645FE0945ULL, 0xD5013436F8B365DFULL, 0x061A1EFD35CE67B1ULL, + 0x51D331FCF245D4C3ULL, 0x435BF3A89EEE428DULL, 0x3F82B0CF96525E46ULL, + 0xD9EEA08DEE3F1E5CULL, 0x387C2881D9E37574ULL, 0x3A03494E02B95464ULL, + 0x986FA7406845EECFULL, 0x909EBFA450CA89B7ULL, 0x0AB63DDFFC76E3D6ULL, + 0xFB8299F93436AA00ULL, 0x77C587532ED3B00EULL, 0xF05DD0A2EBAB2FDCULL, + 0x82BFF2934CD89F90ULL, 0x56F520D20A36A345ULL, 0x333A14D57723D3F5ULL, + 0x2E99A8E1A96C6F71ULL, 0x015DC495E5B5F2F5ULL, 0xF5C1FEE933CFD944ULL, + 0xD4FB87C48526EA72ULL, 0x928DF666A68504E3ULL, 0x30B61829FFD529B6ULL, + 0xE0EABFDC47006A3AULL, 0x56D812935EF5F701ULL, 0xCF5EA702CA2D8A4EULL, + 0xC6A60B805BE5F01BULL, 0x3F36E224AA643259ULL, 0xF1F39F1BC5AA7D71ULL, + 0x6776613DDA0B3757ULL, 0x32ABF45D01818E6BULL, 0x4FBA450CD3378C4BULL, + 0x1353FE7A781C4DAFULL, 0x55E2B58F6566E1FEULL, 0x69D27C8DDF1402AFULL, + 0xB198A20C2F8EEE22ULL, 0x413EAB9629E1BB3FULL, 0xCED4E962FD2E1F28ULL, + 0xCC13457F3C18ADDDULL, 0x5961405F3F07DB75ULL, 0x717E6F97CCA6D853ULL, + 0xB53A5B843E29AEB5ULL, 0x84EFB9964084959FULL, 0xFBCED2A7B235BA0EULL, + 0xE191AD860871ADD5ULL, 0x9206BDE7ABB3C0BEULL, 0x31E68D643E600BA4ULL, + 0x650965D5D2298771ULL, 0x2CF69EEB50EE5433ULL, 0x78D85453AA3518E5ULL, + 0x7F6FF26E1289FD5FULL, 0xED1407DE7A5AEE0EULL, 0xB6B88EE3ECA721B0ULL, + 0x8A792B943CBB1C8BULL, 0x2FB8BA28D1DCDF98ULL, 0x565F7A4482F4E1E7ULL, + 0xAF9B01BC673912BAULL, 0x33060ACC7E025947ULL, 0xBDA78A90DAA61DBBULL, + 0x69DF9875797705F9ULL, 0x269EA019ED2850EDULL, 0x4D992E54B573C6A3ULL, + 0x0D4F823E1A13695DULL, 0xAC698EA5E9749233ULL, 0x32307B4D01044D77ULL, + 0xA9EA493EF04EEDABULL, 0xE5C27E389EFDC5DCULL, 0x0B191B840A3646E7ULL, + 0xDFDD8746BBC415C5ULL, 0x6C883F80BA669777ULL, 0x6500A2BA397D1CD8ULL, + 0xF7651EF5DF3D280CULL, 0xC7E94990FF615C7AULL, 0x810827A453D79624ULL, + 0xAF8D36EB1CCAE440ULL, 0xCE02D5F78141D17CULL, 0x522A1BF379B866B2ULL, + 0x4B31E29988D69977ULL, 0x354A94C9B49A7C83ULL, 0xBE63360C932D0A80ULL, + 0x82409E1FE3933FB0ULL, 0x89F0337B88298047ULL, 0x72AA9E88D6687A5EULL, + 0xE357B4A7A92D30DFULL, 0xE5D6E0AFE1B09A38ULL, 0xD34BCF708AFDD20DULL, + 0x39CD77B9CB30841CULL, 0xECA0C83463924852ULL, 0x8F54366A11A0F909ULL, + 0x82C12374361CEF4EULL, 0x0C33341658E62728ULL, 0xD4A7BE1BE5DE103FULL, + 0x88E1DE94908E0E24ULL, 0xE7992773C6C4F8D1ULL, 0x6A4FF01C85142F26ULL, + 0xED43C7B03851EDFCULL, 0xFABFDF8182F06D4EULL, 0x478950ED7E8A9FA4ULL, + 0xA5B011D6FB459524ULL, 0xC211CD7937216506ULL, 0x8427FD19D650A54EULL, + 0x3B931D098A3EEF78ULL, 0xA374BFF7FC662064ULL, 0xF0B890F86035635AULL, + 0x4069FCCA2004AE90ULL, 0x7571A225FB0036FBULL, 0x79288E9CF418A82BULL, + 0x5A732FF784D4B9DDULL, 0x514D85009F137E89ULL, 0xFA8098233B8FD610ULL, + 0xC2D3B8464C5811A3ULL, 0x0B26690DD8A0AE7DULL, 0x1D81F860C1A93BC3ULL, + 0xBA663A9B4FFE9961ULL, 0x3A7AE6BB78388B46ULL, 0x82E924ACFDB4C579ULL, + 0x49D7F5D2E0972258ULL, 0x9A72D9E003D09958ULL, 0xE973EF5BDB9430D0ULL, + 0x99FC454E04CEA1F6ULL, 0xFF8778F6B26C21F6ULL, 0xBE6E803997F10D9BULL, + 0x03D86849606D7550ULL, 0x54A710A949B3D974ULL, 0x6DBB28F1CD4DD396ULL, + 0xCEC77E343586568DULL, 0x786D93411BB13DB3ULL, 0x69D74045633F8F25ULL, + 0xE126C87A48476F4DULL, 0x03408E2EEBF39B66ULL, 0x119B5F85F341F1EFULL, + 0xF1244036861E93B6ULL, 0x69A7C79A834698A1ULL, 0x0514BBDFEB009705ULL, + 0x2437D317DC2D463BULL, 0xE406A8159C1953EEULL, 0xE1691616FB4D97AFULL, + 0xBF4CB6AA6BE3361DULL, 0xAA24D8743DA230D6ULL, 0xC46B74523725B696ULL, + 0x1513C251D7B65B7FULL, 0xD29738B187EB8ED3ULL, 0xB32996135F7BB73AULL, + 0x7526A4D31C472E44ULL, 0xD3361B5583F9D77CULL, 0x87B63EC9945C6E33ULL, + 0x12F0618BD10EEA06ULL, 0xB2A2C47D782FA130ULL, 0xD9F6246F22D9760DULL, + 0x6C1FD5B3D8375D40ULL, 0x25D61E29837F1159ULL, 0xBFA467515F9CF870ULL, + 0xD9216CC1B9C60EE3ULL, 0x042B2D68C7E7827AULL, 0xCF3655D8D97FC406ULL, + 0x131C0136FC43903AULL, 0xCC1566E8237D0E08ULL, 0x748C38F09328512FULL, + 0xE07EFACD50845B84ULL, 0x2F294932CED7528FULL, 0x1230FD04D25A7D0FULL, + 0xFF46F20D3FAC82FCULL, 0xD2B18140A3C3A6FEULL, 0x7C3884466806BAE7ULL, + 0x9F8488BD56038A70ULL, 0xCBACB7FC5C95BC2AULL, 0xB77E3188821A0343ULL, + 0xDD3DE6ED12A1BD7AULL, 0xDE184524E1625326ULL, 0x1FEBD4017CE01EAAULL, + 0x0F5707E061479B17ULL, 0x4B08C4B997B4D094ULL, 0x0835CE8141444C1AULL, + 0x69276FFEF2B00033ULL, 0x66FA10B39B4CD6D9ULL, 0xEB41AD3D1D5B67C3ULL, + 0x9022D03CBE8DECE9ULL, 0xBF04B81C582E9D8EULL, 0x1BC875D27B833C16ULL, + 0x4A8098FF60E0F433ULL, 0x84A1F0B3CEDE2129ULL, 0x0655EC7ABE1A865BULL, + 0x896A1C9EBF68B2B5ULL, 0x838523E76B2A1D69ULL, 0xF9FE553E328EFE6DULL, + 0x9D74CB259140B7BFULL, 0xE223F220C286B3A2ULL, 0xA2A69AA71FC27EE6ULL, + 0x0C0DC6FFEB845471ULL, 0x2940264896F14CE5ULL, 0x4C4E7F8F004BE5EAULL, + 0xDD950917D4ECF575ULL, 0xB189AC5B57504929ULL, 0xAE872C746C7C87AEULL, + 0xFA59D338BDC440C5ULL, 0x2B3160C93474A3CBULL, 0xE3F915717938A131ULL, + 0x30BB018BB81F8701ULL, 0x90A0FEBE7C63B8A1ULL, 0xC9F2537A5A2F3C3FULL, + 0xEA858C5E6A2D5BC7ULL, 0x3D94EB86DB3D6E14ULL, 0x9B3CDAB91705F6B0ULL, + 0xFA4F05769ECC9F68ULL, 0xAC54021CD021FC48ULL, 0x84F5CB69965E1105ULL, + 0xB22CCB44623616D7ULL, 0x6BE08E5ABC6EFD61ULL, 0xEF50B598A989D669ULL, + 0xBBC25CF386287AECULL, 0x508328E8731C1ACBULL, 0x1A29A0C781B272C8ULL, + 0x74C46AC39AAF5F0AULL, 0xA87CDE1ADB78C2CBULL, 0xE10636DC1E0449F6ULL, + 0x330AD70537301A90ULL, 0x9EF242A77B33BD1BULL, 0x154F6522CA9CC799ULL, + 0xE07E4D37D1859055ULL, 0xFA2851F63979B162ULL, 0xA9E5CE980705F45AULL, + 0x4FA14C1FDBAF267BULL, 0x9EEA2C98DF4B0149ULL, 0xDCDDBEACE184407BULL, + 0xC8611CF4815A537AULL, 0x3D0FD70878D2A3D5ULL, 0x7986A8447F18DE68ULL, + 0xADD373283E5B6134ULL, 0x6370DF3DD21CEF37ULL, 0xBB499791033A32C5ULL, + 0xA02A60F0C301B522ULL, 0xE4D07521DA03EDF9ULL, 0x1CC5997DE03763B7ULL, + 0xDA073D8F3766CEF9ULL, 0x2C755D436DC115B9ULL, +}; +#else + +/* + * This is the stream of values obtained from ISAAC 32-bits + * repeatedly after the isaac_ctx_t has been initialised with a + * zero-seed. + */ +const static isaac_uint_t expected_stream_with_zero_seed[EXPECTED_NEXT_ELEMENTS] = { 0x182600F3UL, 0x300B4A8DUL, 0x301B6622UL, 0xB08ACD21UL, 0x296FD679UL, 0x995206E9UL, 0xB3FFA8B5UL, 0x0FC99C24UL, 0x5F071FAFUL, 0x52251DEFUL, 0x894F41C2UL, 0xCC4C9AFBUL, 0x96C33F74UL, 0x347CB71DUL, 0xC90F8FBDUL, @@ -126,14 +485,11 @@ const static uint32_t expected_stream_with_zero_seed[EXPECTED_NEXT_ELEMENTS] = { }; /* - * This is the stream of uint32 values obtained by calling isaac_next() + * This is the stream of values obtained from ISAAC 32-bits * repeatedly after the isaac_ctx_t has been initialised with a - * seed of {1, 2, 3, 4, 5, 6, 7, 8} (in bytes, not uint32_t) - * - * In particular this is the value printed by next_values_nonzero_seed() - * in generate.c + * seed of {1, 2, 3, 4, 5, 6, 7, 8} (in bytes) */ -const static uint32_t expected_stream_with_nonzero_seed[EXPECTED_NEXT_ELEMENTS] = { +const static isaac_uint_t expected_stream_with_nonzero_seed[EXPECTED_NEXT_ELEMENTS] = { 0x23956226UL, 0xA9E1CEBFUL, 0x3EA230EBUL, 0x8175D70DUL, 0xD8B699F5UL, 0xB4F5C36AUL, 0xB23790CFUL, 0xAEEB9340UL, 0x6F7B8DCDUL, 0x3258B530UL, 0x4A03FAD4UL, 0x01B103BDUL, 0xB7A31E4FUL, 0x342846F3UL, 0x3EAF2975UL, @@ -239,6 +595,8 @@ const static uint32_t expected_stream_with_nonzero_seed[EXPECTED_NEXT_ELEMENTS] 0xDE0FE6D6UL, 0x5521DA1BUL, }; +#endif + static void test_stream_with_zero_seed(void) { isaac_ctx_t ctx; @@ -248,7 +606,8 @@ static void test_stream_with_zero_seed(void) isaac_stream(&ctx, stream, 300); atto_neq(stream[0], 0); - atto_memeq(stream, expected_stream_with_zero_seed, 300 * sizeof(isaac_uint_t)); + atto_memeq(stream, expected_stream_with_zero_seed, + 300 * sizeof(isaac_uint_t)); atto_eq(ctx.next_index, 256 * 2 - 300 - 1); } @@ -264,7 +623,8 @@ static void test_stream_with_zero_seed_multiple_calls(void) } atto_neq(stream[0], 0); - atto_memeq(stream, expected_stream_with_zero_seed, 300 * sizeof(isaac_uint_t)); + atto_memeq(stream, expected_stream_with_zero_seed, + 300 * sizeof(isaac_uint_t)); atto_eq(ctx.next_index, 256 * 2 - 300 - 1); } From 91fac4e4f4f26881270e81a502a98c4e37b1f8cc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matjaz=CC=8C?= Date: Tue, 28 Apr 2020 21:05:01 +0200 Subject: [PATCH 21/27] Add ctx cleanup function It's only added as a utility, so there is no need to import memset. Additionally it writes one isaac_uint_t at the time, which should make it fast. Add slightly more text to the test files file-level doxygen header. --- CMakeLists.txt | 4 +-- inc/isaac.h | 21 ++++++++++++--- src/isaac.c | 29 +++++++++++++++++--- tst/original/{generate.c => generate32.c} | 0 tst/test.c | 1 + tst/test.h | 1 + tst/test_cleanup.c | 33 +++++++++++++++++++++++ tst/test_convert.c | 3 +-- tst/test_init.c | 2 +- tst/test_stream.c | 3 ++- 10 files changed, 84 insertions(+), 13 deletions(-) rename tst/original/{generate.c => generate32.c} (100%) create mode 100644 tst/test_cleanup.c diff --git a/CMakeLists.txt b/CMakeLists.txt index de362c1..bb83ef9 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -47,7 +47,7 @@ set(TEST_FILES tst/test_init.c tst/test_stream.c tst/test_convert.c - tst/atto/atto.c) + tst/atto/atto.c tst/test_cleanup.c) add_library(isaac32 STATIC ${LIB_FILES}) target_compile_definitions(isaac32 PUBLIC ISAAC_BITS=32) @@ -60,7 +60,7 @@ target_compile_definitions(testisaac64 PUBLIC ISAAC_BITS=64) include_directories(tst/original/) add_executable("generatevectors32" - tst/original/generate.c + tst/original/generate32.c tst/original/randport.c) add_executable("generatevectors64" tst/original/generate64.c diff --git a/inc/isaac.h b/inc/isaac.h index 241cb3f..ec45c16 100644 --- a/inc/isaac.h +++ b/inc/isaac.h @@ -47,7 +47,7 @@ typedef uint32_t isaac_uint_t; #elif (ISAAC_BITS == 64) typedef uint64_t isaac_uint_t; #else -_Static_assert(0, "Only 32 or 64 bit words are supported."); +_Static_assert(0, "ISAAC: only 32 or 64 bit words are supported."); #endif #define ISAAC_ELEMENTS 256U @@ -68,8 +68,8 @@ typedef struct /** * Index of the next value to output in the stream. * - * Note: this value could be a uint16_t instead of a isaac_uint_t, but by using - * a isaac_uint_t we avoid any padding at the end of the struct. + * Note: this value could be a uint16_t instead of a isaac_uint_t, but by + * using an isaac_uint_t we avoid any padding at the end of the struct. */ isaac_uint_t next_index; } isaac_ctx_t; @@ -138,7 +138,20 @@ void isaac_init(isaac_ctx_t* ctx, const uint8_t* seed, uint16_t seed_bytes); * @param[out] ints pseudo-random integers. * @param[in] amount quantity of 32-bit/64-bit integers to generate. */ -void isaac_stream(isaac_ctx_t* const ctx, isaac_uint_t* ints, size_t amount); +void isaac_stream(isaac_ctx_t* ctx, isaac_uint_t* ints, size_t amount); + +/** + * Safely erases the context. + * + * Useful to avoid leaking information about the seed or the state after + * finishing using ISAAC. + * + * There is no need to call this function before using isaac_init(), including + * when re-initing an existing context. + * + * @param[in] ctx the ISAAC state to cleanup. + */ +void isaac_cleanup(isaac_ctx_t* ctx); /** * Utility function, converting an array of 32-bit/64-bit integers into bytes diff --git a/src/isaac.c b/src/isaac.c index 8150db4..a05d742 100644 --- a/src/isaac.c +++ b/src/isaac.c @@ -74,7 +74,6 @@ #endif - static void isaac_shuffle(isaac_ctx_t* ctx); static void set_seed(isaac_ctx_t* ctx, @@ -238,7 +237,10 @@ static void isaac_shuffle(isaac_ctx_t* const ctx) ctx->a = a; } -#define isaac_min(a, b) ((a) < (b)) ? (a) : (b) +#define ISAAC_MIN(a, b) ((a) < (b)) ? (a) : (b) + +// TODO consider inverting the stream, i.e. reading from result from index 0 +// towards the end instead of vice versa, to improve cache usage. void isaac_stream(isaac_ctx_t* const ctx, isaac_uint_t* ints, size_t amount) { @@ -248,7 +250,7 @@ void isaac_stream(isaac_ctx_t* const ctx, isaac_uint_t* ints, size_t amount) } do { - const size_t available = isaac_min(ctx->next_index + 1, amount); + const size_t available = ISAAC_MIN(ctx->next_index + 1, amount); for (uint_fast16_t i = 0; i < available; i++) { *ints++ = ctx->result[ctx->next_index--]; @@ -265,6 +267,27 @@ void isaac_stream(isaac_ctx_t* const ctx, isaac_uint_t* ints, size_t amount) while (amount); } +#define ISAAC_CTX_LEN_IN_UINTS (sizeof(isaac_ctx_t) / sizeof(isaac_uint_t)) +_Static_assert( + sizeof(isaac_ctx_t) % sizeof(isaac_uint_t) == 0, + "The ISAAC context size must be divisible by isaac_uint_t, otherwise " + "the cleanup function will write beyond its end."); + +void isaac_cleanup(isaac_ctx_t* const ctx) +{ + if (ctx == NULL) + { + return; + } + isaac_uint_t* casted = (isaac_uint_t*) ctx; + const isaac_uint_t* const end = casted + ISAAC_CTX_LEN_IN_UINTS; + do + { + *casted++ = 0UL; + } + while (casted < end); +} + void isaac_to_little_endian(uint8_t* bytes, const isaac_uint_t* values, size_t amount_of_values) diff --git a/tst/original/generate.c b/tst/original/generate32.c similarity index 100% rename from tst/original/generate.c rename to tst/original/generate32.c diff --git a/tst/test.c b/tst/test.c index bb89686..bae1f5e 100644 --- a/tst/test.c +++ b/tst/test.c @@ -15,5 +15,6 @@ int main(void) test_isaac_init(); test_isaac_next(); test_isaac_convert(); + test_isaac_cleanup(); return atto_at_least_one_fail; } diff --git a/tst/test.h b/tst/test.h index 04804a7..d3baeb0 100644 --- a/tst/test.h +++ b/tst/test.h @@ -24,6 +24,7 @@ extern "C" void test_isaac_init(void); void test_isaac_next(void); void test_isaac_convert(void); +void test_isaac_cleanup(void); #ifdef __cplusplus } diff --git a/tst/test_cleanup.c b/tst/test_cleanup.c new file mode 100644 index 0000000..bc0cc38 --- /dev/null +++ b/tst/test_cleanup.c @@ -0,0 +1,33 @@ +/** + * @file + * + * Test suite of LibISAAC, testing isaac_cleanup(). + * + * @copyright Copyright © 2020, Matjaž Guštin + * . All rights reserved. + * @license BSD 3-clause license. + */ + +#include "test.h" + +static void test_cleanup_null(void) +{ + isaac_cleanup(NULL); +} + + +static void test_cleanup(void) +{ + isaac_ctx_t ctx; + memset(&ctx, 0xFFU, sizeof(ctx)); + + isaac_cleanup(&ctx); + + atto_zeros((uint8_t*) &ctx, sizeof(ctx)); +} + +void test_isaac_cleanup(void) +{ + test_cleanup_null(); + test_cleanup(); +} diff --git a/tst/test_convert.c b/tst/test_convert.c index 29c79d2..2e6fe26 100644 --- a/tst/test_convert.c +++ b/tst/test_convert.c @@ -1,7 +1,7 @@ /** * @file * - * Test suite of LibISAAC + * Test suite of LibISAAC, testing functions converting isaac_uint_t to bytes. * * @copyright Copyright © 2020, Matjaž Guštin * . All rights reserved. @@ -102,7 +102,6 @@ static void test_to_big_endian(void) #endif - void test_isaac_convert(void) { test_to_little_endian(); diff --git a/tst/test_init.c b/tst/test_init.c index 2090ba2..d01f2eb 100644 --- a/tst/test_init.c +++ b/tst/test_init.c @@ -1,7 +1,7 @@ /** * @file * - * Test suite of LibISAAC + * Test suite of LibISAAC, testing isaac_init(). * * @copyright Copyright © 2020, Matjaž Guštin * . All rights reserved. diff --git a/tst/test_stream.c b/tst/test_stream.c index 1003406..b1f62fe 100644 --- a/tst/test_stream.c +++ b/tst/test_stream.c @@ -1,7 +1,7 @@ /** * @file * - * Test suite of LibISAAC + * Test suite of LibISAAC, testing isaac_stream(). * * @copyright Copyright © 2020, Matjaž Guštin * . All rights reserved. @@ -606,6 +606,7 @@ static void test_stream_with_zero_seed(void) isaac_stream(&ctx, stream, 300); atto_neq(stream[0], 0); + atto_eq(stream[0], expected_stream_with_zero_seed[0]); atto_memeq(stream, expected_stream_with_zero_seed, 300 * sizeof(isaac_uint_t)); atto_eq(ctx.next_index, 256 * 2 - 300 - 1); From 33ef033968489e1fcd9a24ad5bbf02d1821770e1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matjaz=CC=8C?= Date: Tue, 28 Apr 2020 21:07:59 +0200 Subject: [PATCH 22/27] Add notes about NULL function arguments, simplify init of next_index --- inc/isaac.h | 17 ++++++++++------- src/isaac.c | 4 ++-- 2 files changed, 12 insertions(+), 9 deletions(-) diff --git a/inc/isaac.h b/inc/isaac.h index ec45c16..85a2e32 100644 --- a/inc/isaac.h +++ b/inc/isaac.h @@ -105,7 +105,7 @@ typedef struct * Providing a seed with low entropy will result in the whole CSPRNG to be * weak. * - * @param ctx the ISAAC state to be initialised. + * @param ctx the ISAAC state to be initialised. Does nothing when NULL. * @param seed pointer to the seed to use, which is copied into the context. * - If NULL, then a zero seed is used instead (**insecure!**) * @param seed_bytes amount of **bytes** in the seed, max #ISAAC_SEED_MAX_BYTES. @@ -135,7 +135,8 @@ void isaac_init(isaac_ctx_t* ctx, const uint8_t* seed, uint16_t seed_bytes); * more expensive. * * @param[in, out] ctx the ISAAC state, already initialised. - * @param[out] ints pseudo-random integers. + * Does nothing when NULL. + * @param[out] ints pseudo-random integers. Does nothing when NULL. * @param[in] amount quantity of 32-bit/64-bit integers to generate. */ void isaac_stream(isaac_ctx_t* ctx, isaac_uint_t* ints, size_t amount); @@ -149,7 +150,7 @@ void isaac_stream(isaac_ctx_t* ctx, isaac_uint_t* ints, size_t amount); * There is no need to call this function before using isaac_init(), including * when re-initing an existing context. * - * @param[in] ctx the ISAAC state to cleanup. + * @param[in] ctx the ISAAC state to cleanup. Does nothing when NULL. */ void isaac_cleanup(isaac_ctx_t* ctx); @@ -160,8 +161,9 @@ void isaac_cleanup(isaac_ctx_t* ctx); * Useful to convert a stream of 32-bit/64-bit integers to 8-bit values. * * @param[out] bytes 8-bit integers. Must be at least \p amount_of_values*4 - * bytes long. - * @param[in] values 32-bit/64-bit integers, as obtained from isaac_stream() + * bytes long. Does nothing when NULL. + * @param[in] values 32-bit/64-bit integers, as obtained from isaac_stream(). + * Does nothing when NULL. * @param[in] amount_of_values quantity of 32-bit/64-bit integers in the * \p values buffer. */ @@ -176,8 +178,9 @@ void isaac_to_little_endian(uint8_t* bytes, * Useful to convert a stream of 32-bit/64-bit integers to 8-bit values. * * @param[out] bytes 8-bit integers. Must be at least \p amount_of_values*4 - * bytes long. - * @param[in] values 32-bit/64-bit integers, as obtained from isaac_stream() + * bytes long. Does nothing when NULL. + * @param[in] values 32-bit/64-bit integers, as obtained from isaac_stream(). + * Does nothing when NULL. * @param[in] amount_of_values quantity of 32-bit/64-bit integers in the * \p values buffer. */ diff --git a/src/isaac.c b/src/isaac.c index a05d742..52943fb 100644 --- a/src/isaac.c +++ b/src/isaac.c @@ -90,7 +90,7 @@ void isaac_init(isaac_ctx_t* const ctx, } isaac_uint_t a, b, c, d, e, f, g, h; uint_fast16_t i; /* Fastest index over elements in result[] and mem[]. */ - ctx->a = ctx->b = ctx->c = 0; + ctx->next_index = ctx->a = ctx->b = ctx->c = 0; a = b = c = d = e = f = g = h = GOLDEN_RATIO; /* Scramble it */ for (i = 0; i < 4; i++) @@ -143,7 +143,7 @@ void isaac_init(isaac_ctx_t* const ctx, /* Fill in the first set of results. */ isaac_shuffle(ctx); /* Prepare to use the first set of results with next32() and next8(). */ - ctx->next_index = ISAAC_ELEMENTS - 1; + } /** From fbf2ff6f80781a2aa9fdec329c5b00e009a9441b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matjaz=CC=8C?= Date: Tue, 28 Apr 2020 21:34:42 +0200 Subject: [PATCH 23/27] Invert stream (now reading result[] from 0 to end) Done for performance: better cache usage in reading result[] from 0 to end instead of backwards. From security perspective both are valid, as the author of the original version does both anyway. This makes also the 64-bit tests pass, as the 64-bit test vectors were also generated from 0 to end instead of vice versa, as were the 32-bit versions. --- src/isaac.c | 22 +- tst/original/generate32.c | 50 ++--- tst/test_init.c | 8 +- tst/test_stream.c | 427 +++++++++++++++++++------------------- 4 files changed, 250 insertions(+), 257 deletions(-) diff --git a/src/isaac.c b/src/isaac.c index 52943fb..666e121 100644 --- a/src/isaac.c +++ b/src/isaac.c @@ -239,32 +239,28 @@ static void isaac_shuffle(isaac_ctx_t* const ctx) #define ISAAC_MIN(a, b) ((a) < (b)) ? (a) : (b) -// TODO consider inverting the stream, i.e. reading from result from index 0 -// towards the end instead of vice versa, to improve cache usage. - void isaac_stream(isaac_ctx_t* const ctx, isaac_uint_t* ints, size_t amount) { if (ctx == NULL || ints == NULL) { return; } - do + uint_fast16_t available; + while (amount) { - const size_t available = ISAAC_MIN(ctx->next_index + 1, amount); - for (uint_fast16_t i = 0; i < available; i++) - { - *ints++ = ctx->result[ctx->next_index--]; - } + available = ISAAC_MIN(ISAAC_ELEMENTS - ctx->next_index, amount); amount -= available; + while (available--) + { + *ints++ = ctx->result[ctx->next_index++]; + }; if (ctx->next_index >= ISAAC_ELEMENTS) { - /* next_index underflow, thus out of elements. Reshuffling - * and preparing new batch of elements. */ + /* Out of elements. Reshuffling and preparing new batch. */ isaac_shuffle(ctx); - ctx->next_index = ISAAC_ELEMENTS - 1; + ctx->next_index = 0; } } - while (amount); } #define ISAAC_CTX_LEN_IN_UINTS (sizeof(isaac_ctx_t) / sizeof(isaac_uint_t)) diff --git a/tst/original/generate32.c b/tst/original/generate32.c index 7311f48..955fdc5 100644 --- a/tst/original/generate32.c +++ b/tst/original/generate32.c @@ -20,11 +20,11 @@ static void print_ctx(const randctx* const ctx) { - printf(".cnt = 0x%08XUL,\n", ctx->randcnt); + printf(".next_index = 0x%08XUL,\n", 0); printf(".a = 0x%08XUL,\n", ctx->randa); printf(".b = 0x%08XUL,\n", ctx->randb); printf(".c = 0x%08XUL,\n", ctx->randc); - printf(".rsl = {"); + printf(".result = {"); for (unsigned int i = 0; i < RANDSIZ; i++) { printf("0x%08XUL, ", ctx->randrsl[i]); @@ -49,14 +49,6 @@ static void ctx_zero_seed(void) print_ctx(&ctx); } -static void ctx_no_init(void) -{ - randctx ctx; - randinit(&ctx, 0); // Init ISAAC without a seed - puts("Context with no seed:"); - print_ctx(&ctx); -} - static void ctx_nonzero_seed(void) { randctx ctx; @@ -75,30 +67,31 @@ static void ctx_nonzero_seed(void) print_ctx(&ctx); } -static void next_values_zero_seed(void) +static void stream_from_zero_seed(void) { randctx ctx; - unsigned long int i; - unsigned long int next; + unsigned long int i, j; for (i = 0; i < 256; i++) { ctx.randrsl[i] = 0; // Zero seed } randinit(&ctx, 1); // Init ISAAC with zero seed - puts("Running next() 512 times with zero seed"); - for (i = 0; i < 512; i++) + puts("Getting stream of 512 values from zero seed"); + for (j = 0; j < 2; j++) { - next = rand(&ctx); - printf("0x%08lXUL, ", next); + for (i = 0; i < 256; i++) + { + printf("0x%08XUL, ", ctx.randrsl[i]); + } + isaac(&ctx); } puts(""); } -static void next_values_nonzero_seed(void) +static void stream_from_nonzero_seed(void) { randctx ctx; - unsigned long int i; - unsigned long int next; + unsigned long int i, j; const unsigned char seed[8] = {1, 2, 3, 4, 5, 6, 7, 8}; for (i = 0; i < 8; i++) { @@ -109,20 +102,23 @@ static void next_values_nonzero_seed(void) ctx.randrsl[i] = 0; // Zero padding } randinit(&ctx, 1); // Init ISAAC with non-zero seed - puts("Running next() 512 times with non-zero seed"); - for (i = 0; i < 512; i++) + puts("Getting stream of 512 values from non-zero seed"); + for (j = 0; j < 2; j++) { - next = rand(&ctx); - printf("0x%08lXUL, ", next); + for (i = 0; i < 256; i++) + { + printf("0x%08XUL, ", ctx.randrsl[i]); + } + isaac(&ctx); } + puts(""); } int main(void) { ctx_zero_seed(); - ctx_no_init(); ctx_nonzero_seed(); - next_values_zero_seed(); - next_values_nonzero_seed(); + stream_from_zero_seed(); + stream_from_nonzero_seed(); return 0; } diff --git a/tst/test_init.c b/tst/test_init.c index d01f2eb..c146752 100644 --- a/tst/test_init.c +++ b/tst/test_init.c @@ -13,7 +13,7 @@ #if ISAAC_BITS > 32 const static isaac_ctx_t zero_initialised_ctx = { - .next_index = ISAAC_ELEMENTS - 1U, + .next_index = 0, .a = 0xCE150DF74800329AULL, .b = 0x9D39247E33776D41ULL, .c = 0x0000000000000001ULL, @@ -280,7 +280,7 @@ const static isaac_ctx_t zero_initialised_ctx = { }; const static isaac_ctx_t nonzero_initialised_ctx = { - .next_index = ISAAC_ELEMENTS - 1U, + .next_index = 0, .a = 0x206E5B8744408867ULL, .b = 0x0F5268BA58C45B3DULL, .c = 0x0000000000000001ULL, @@ -549,7 +549,7 @@ const static isaac_ctx_t nonzero_initialised_ctx = { #else const static isaac_ctx_t zero_initialised_ctx = { - .next_index = ISAAC_ELEMENTS - 1, + .next_index = 0, .a = 0x44D22B48UL, .b = 0x182600F3UL, .c = 0x00000001UL, @@ -688,7 +688,7 @@ const static isaac_ctx_t zero_initialised_ctx = { }; const static isaac_ctx_t nonzero_initialised_ctx = { - .next_index = ISAAC_ELEMENTS - 1, + .next_index = 0, .a = 0xD131EDD6UL, .b = 0x23956226UL, .c = 0x00000001UL, diff --git a/tst/test_stream.c b/tst/test_stream.c index b1f62fe..d2d0508 100644 --- a/tst/test_stream.c +++ b/tst/test_stream.c @@ -375,224 +375,225 @@ const static isaac_uint_t /* * This is the stream of values obtained from ISAAC 32-bits - * repeatedly after the isaac_ctx_t has been initialised with a - * zero-seed. + * after the isaac_ctx_t has been initialised with a zero-seed + * and by reading the result[] from index 0 to end. */ const static isaac_uint_t expected_stream_with_zero_seed[EXPECTED_NEXT_ELEMENTS] = { - 0x182600F3UL, 0x300B4A8DUL, 0x301B6622UL, 0xB08ACD21UL, 0x296FD679UL, - 0x995206E9UL, 0xB3FFA8B5UL, 0x0FC99C24UL, 0x5F071FAFUL, 0x52251DEFUL, - 0x894F41C2UL, 0xCC4C9AFBUL, 0x96C33F74UL, 0x347CB71DUL, 0xC90F8FBDUL, - 0xA658F57AUL, 0xC5C29E18UL, 0x6249FA29UL, 0xBAE16FFAUL, 0x25C871BDUL, - 0xF4C75E24UL, 0x5AB3EAB9UL, 0xAC450B8FUL, 0x1629CFA4UL, 0x0016E86FUL, - 0xF27C4D0DUL, 0x67648B17UL, 0x05C04FCEUL, 0x44D3FF79UL, 0xC6ACD20FUL, - 0x472FD994UL, 0x842131C4UL, 0xEAD4A900UL, 0xC01EDA0DUL, 0x9E604C7BUL, - 0xFB8A0E99UL, 0x02E17B6FUL, 0xE8B4F627UL, 0xC7041EAEUL, 0x42D19CD7UL, - 0xA358EB94UL, 0x19CA2158UL, 0x6BE6CE81UL, 0x4B90A4DEUL, 0x26F0774DUL, - 0x4E83930AUL, 0x2492D476UL, 0xB97FFABEUL, 0x675CC8AEUL, 0x4CFDD254UL, - 0x5D3C00EAUL, 0x7BBA5EADUL, 0x6F461810UL, 0xBEF63EEAUL, 0x72EB767BUL, - 0xED6E963BUL, 0xB026016DUL, 0x17CB7EBFUL, 0xA7DC6E56UL, 0xF460BDF1UL, - 0x1FFE0E04UL, 0x902B347DUL, 0x02C0D8ABUL, 0x98CB3F8BUL, 0x6F359A39UL, - 0x9521825FUL, 0x9026D97EUL, 0xDE342516UL, 0x890A740CUL, 0x0F2969E4UL, - 0x2E7EA9EDUL, 0x394B8A4FUL, 0x1BDF1FD0UL, 0x15D565B4UL, 0xBAF0406DUL, - 0x4DAC20DBUL, 0x03359832UL, 0xE34802D5UL, 0xCC5FFF02UL, 0x0935AD6EUL, - 0x7C53C9B2UL, 0xB10B5D29UL, 0x4FBB94BEUL, 0xD7E48546UL, 0xB7CFA23CUL, - 0x7F081C9AUL, 0xE099BAF1UL, 0x9C7DC323UL, 0xB831AD14UL, 0x5B563101UL, - 0xFA55319BUL, 0x060DED54UL, 0xC5418124UL, 0x765F0DBAUL, 0x1AD3D9D5UL, - 0x3F07EC49UL, 0xDD5E06C6UL, 0xC230E2ACUL, 0xC6BA1971UL, 0x9CC17BCCUL, - 0x10B22A22UL, 0x7DFC8C7FUL, 0xB3310333UL, 0x205530EEUL, 0xDBF38A8FUL, - 0x003A02F5UL, 0x007E96A3UL, 0x36658201UL, 0x08DFD64FUL, 0x6275ACF3UL, - 0x3D29669BUL, 0x6B2F4538UL, 0xB0CC336BUL, 0x1D3043EBUL, 0x1AD1D764UL, - 0x4C655B84UL, 0x7A725BB2UL, 0xB3FC5C66UL, 0x80B4B915UL, 0xB2CBD9E4UL, - 0x2992DFC6UL, 0xDF8BE548UL, 0xB310D06EUL, 0x436385C6UL, 0x44D6E893UL, - 0x44C4D79DUL, 0xE3BB2064UL, 0xE41EA465UL, 0x3FF4CC70UL, 0x9D21AC42UL, - 0x672C3725UL, 0xA43A1D02UL, 0xFD84B19BUL, 0x5B6FB132UL, 0x4AF40896UL, - 0xE15000A6UL, 0x7CAB12F6UL, 0x8B8E753CUL, 0xFB253454UL, 0x359AC366UL, - 0x67822B45UL, 0x290A1140UL, 0xADE6E428UL, 0x6095EFCBUL, 0x99D8D9E6UL, - 0xA5B5981DUL, 0x332C95D6UL, 0xAF5CFCABUL, 0x161F5CA6UL, 0x1844CEE2UL, - 0xFFB8AB5CUL, 0x82FCCAEBUL, 0x49ECF97AUL, 0x7A60FABDUL, 0xF9585A3AUL, - 0x4EB6BD32UL, 0x3B347002UL, 0xF4930DBAUL, 0x5D21D51EUL, 0x64E8E3F4UL, - 0x52801FA8UL, 0x71CE907CUL, 0x872783A4UL, 0x0761DC80UL, 0x5C509848UL, - 0x41BA2ADCUL, 0x7E2F5520UL, 0x85C5EEC2UL, 0x368D3D00UL, 0x5FC7C5F3UL, - 0xB849D785UL, 0xD95F25B3UL, 0x79801FD5UL, 0xBF2443D6UL, 0x360D41CDUL, - 0x651B11C0UL, 0x801A89CAUL, 0x8B9E6B94UL, 0xFDE283C4UL, 0xCC5E6974UL, - 0x2B2F4C09UL, 0x8B2160A8UL, 0xDBF57F01UL, 0x76AA1C4EUL, 0x11F0831AUL, - 0x54713D17UL, 0xC99A2639UL, 0x4C373E7AUL, 0x09E6E57FUL, 0x71F63B07UL, - 0x7BE3F02EUL, 0x2C907ADEUL, 0xE5F489F6UL, 0x0B0CD6DAUL, 0xB566E14CUL, - 0x0F955969UL, 0xA0E5710BUL, 0x80D8C2DEUL, 0x9971E496UL, 0xC7EFBC2FUL, - 0x97A48E53UL, 0x2D845C0DUL, 0xE1194B0EUL, 0xAD2BA480UL, 0xD5253552UL, - 0xCA890B31UL, 0x60060AFBUL, 0x89DAE927UL, 0x565E2229UL, 0x43ABC21CUL, - 0x03DD14A5UL, 0xBBADD184UL, 0x9E979702UL, 0x2F659883UL, 0xF313ADECUL, - 0x621BD7CAUL, 0xB6470834UL, 0x4C3901C6UL, 0x32028BB8UL, 0x9DED8244UL, - 0x66907654UL, 0x0A06B272UL, 0x4A8EC630UL, 0x4207D36FUL, 0x3E7A8B49UL, - 0x13871BE7UL, 0xBF7AF48EUL, 0x3DE0DF39UL, 0x0E864542UL, 0x8C090A23UL, - 0xAF90E49EUL, 0x97661C5EUL, 0x365AA66CUL, 0x0073E342UL, 0x9C8AC447UL, - 0x6F57E7CEUL, 0xD5BE7FFAUL, 0x89651D84UL, 0x53F78EAAUL, 0x8173DC04UL, - 0xD70B1E10UL, 0x43C1A57BUL, 0x10C8A5ABUL, 0xED6ABD62UL, 0x2F840E43UL, - 0x4873D91EUL, 0x49F413FCUL, 0x5D89A1C1UL, 0xD3A388FCUL, 0x96C59CF4UL, - 0x456F1EDDUL, 0x3DD20023UL, 0xA264E933UL, 0xD32956E5UL, 0xD91AA738UL, - 0xE76DD339UL, 0x7A68710FUL, 0x6554ABDAUL, 0x90C10757UL, 0x0B5E435FUL, - 0xAF7D1FB8UL, 0x01913FD3UL, 0x6A158D10UL, 0xB8F6FD4AUL, 0xC2B9AA36UL, - 0x96DA2655UL, 0xFE1E42D5UL, 0x56E6CD21UL, 0xD5B2D750UL, 0x7229EA81UL, - 0x5DE87ABBUL, 0xB6B9D766UL, 0x1E16614CUL, 0x3B708F99UL, 0x5CF824CDUL, - 0xA4CA0CF1UL, 0x62D31911UL, 0x7CDD662FUL, 0xCB9E1563UL, 0x79AE4C10UL, - 0x080C79ECUL, 0x18080C8EUL, 0x4A0A283CUL, 0x3DDE9F39UL, 0x09C36F90UL, - 0xAD567643UL, 0x08294766UL, 0xB4415F7DUL, 0x5597EC0FUL, 0x78FFA568UL, - 0x8BACE62EUL, 0x4188BFCDUL, 0xC87C8006UL, 0xAFA92A6DUL, 0x50FC8194UL, - 0xCAE8DEBAUL, 0x33F6D7B1UL, 0x53245B79UL, 0x61119A5AUL, 0x7E315AEBUL, - 0xE75B41C9UL, 0xD2A93B51UL, 0xEC46B0B6UL, 0x1ED3FF4EUL, 0x5D023E65UL, - 0xADF6BC23UL, 0xF7F58F7BUL, 0xE4F3A26AUL, 0x0C571A7DUL, 0xED35E5EEUL, - 0xEADEBEACUL, 0x30BCC764UL, 0x66F1E0ABUL, 0x826DFA89UL, 0x0D9C7E7EUL, - 0xE7E26581UL, 0xD5990DFBUL, 0x02C9B944UL, 0x4112D96CUL, 0x3FF1E524UL, - 0xC35E4580UL, 0xFDFEF62DUL, 0xB83F957AUL, 0xBFC7F7CCUL, 0xB510CE0EUL, - 0xCD7411A7UL, 0x04DB4E13UL, 0x76904B6DUL, 0x08607F04UL, 0x3718D597UL, - 0x46C0A6F5UL, 0x8406B137UL, 0x309BFB78UL, 0xF7D3F39FUL, 0x8C2F0D55UL, - 0xC613F157UL, 0x127DD430UL, 0x72C9137DUL, 0x68A39358UL, 0x07C28CD1UL, - 0x848F520AUL, 0xDD2DC1D5UL, 0x9388B13BUL, 0x28E7CB78UL, 0x03FB88F4UL, - 0xB0B84E7BUL, 0x14C8009BUL, 0x884D6825UL, 0x21C171ECUL, 0x0809E494UL, - 0x6A107589UL, 0x12595A19UL, 0x0BB3263FUL, 0x4D8FAE82UL, 0x2A98121AUL, - 0xB00960BAUL, 0x6708A2BCUL, 0x35A124B5UL, 0xBCCAAEEDUL, 0x294D37E5UL, - 0xD405DED8UL, 0x9F39E2D9UL, 0x21835C4DUL, 0xE89B1A3BUL, 0x7364944BUL, - 0xBD2E5024UL, 0x6A123F57UL, 0x34105A8CUL, 0x5AD0D3B0UL, 0xCC033CE3UL, - 0xD51F093DUL, 0x56A001E3UL, 0x01A9BD70UL, 0x8891B3DBUL, 0x13ADD922UL, - 0x3D77D9A2UL, 0x0E7E0E67UL, 0xD73F72D4UL, 0x917BDEC2UL, 0xA37F63FFUL, - 0x23D74F4EUL, 0x3A6CE389UL, 0x0606CF9FUL, 0xDE11ED34UL, 0x70CC94AEUL, - 0xCB0EEE4AUL, 0x13EDC0CBUL, 0xFE29661CUL, 0xDB6DBE96UL, 0xB388D96CUL, - 0x33BC405DUL, 0xA6D12101UL, 0x2F36FA86UL, 0x7DED386FUL, 0xE6344451UL, - 0xCD57C7F7UL, 0x1B0DCDC1UL, 0xCD49EBDBUL, 0x9E8A51DAUL, 0x12A0594BUL, - 0x60D4D5F8UL, 0x91C8D925UL, 0xE43D0FBBUL, 0x5D2A542FUL, 0x451E7EC8UL, - 0x2B36505CUL, 0x37C0ED05UL, 0x2364A1AAUL, 0x814BC24CUL, 0xE3A662D9UL, - 0xF2B5CC05UL, 0xB8B0CCFCUL, 0xB058BAFBUL, 0x3AEA3DECUL, 0x0D028684UL, - 0x64AF0FEFUL, 0x210F3925UL, 0xB67EC13AUL, 0x97166D14UL, 0xF7E1CDD0UL, - 0x5ADB60E7UL, 0xD5295EBCUL, 0x28833522UL, 0x60EDA8DAUL, 0x7BC76811UL, - 0xAC9FE69DUL, 0x30AB93ECUL, 0x03696614UL, 0x15E3A5B9UL, 0xECC5DC91UL, - 0x1D3B8E97UL, 0x7275E277UL, 0x538E1F4EUL, 0x6CB167DBUL, 0xA7A2F402UL, - 0x2DB35DFEUL, 0xA8BCC22DUL, 0xD8C58A6AUL, 0x6A529B0BUL, 0x0FD43963UL, - 0xAFC17A97UL, 0x943C3C74UL, 0x95138769UL, 0x6F4E0772UL, 0xB143B688UL, - 0x3B18E752UL, 0x69D2E4AEUL, 0x8107C9FFUL, 0xCDBC62E2UL, 0x5781414FUL, - 0x8B87437EUL, 0xA70E1101UL, 0x91DABC65UL, 0x4E232CD0UL, 0x229749B5UL, - 0xD7386806UL, 0xB3C3F24BUL, 0x60DC5207UL, 0x0BDB9C30UL, 0x1A70E7E9UL, - 0xF37C71D5UL, 0x44B89B08UL, 0xB4D2F976UL, 0xB40E27BCUL, 0xFFDF8A80UL, - 0x9C411A2AUL, 0xD0F7B37DUL, 0xEF53CEC4UL, 0xECA4D58AUL, 0x0B923200UL, - 0xCF22E064UL, 0x8EBFA303UL, 0xF7CF814CUL, 0x32AE2A2BUL, 0xB5E13DAEUL, - 0xC998F9FFUL, 0x349947B0UL, 0x29CF72CEUL, 0x17E38F85UL, 0xF3B26129UL, - 0xD45D6D81UL, 0x09B3CE98UL, 0x860536B8UL, 0xE5792E1BUL, 0x12AD6419UL, - 0xF5F71C69UL, 0xCBC8B7C2UL, 0x8F651659UL, 0xA0CC74F3UL, 0xD78CB99EUL, - 0x51C08D83UL, 0x29F55449UL, 0x002ED713UL, 0x38A824F3UL, 0x57161DF6UL, - 0x7452E319UL, 0x25890E2EUL, 0xC7442433UL, 0x4A5F6355UL, 0x6A83E1E0UL, - 0x823CEDB6UL, 0xF1D444EBUL, 0x88381097UL, 0x5DE3743EUL, 0x46CA4F9AUL, - 0xD8370487UL, 0xEDEC154AUL, 0x433F1AFBUL, 0xF5FAD54FUL, 0x98DB2FB4UL, - 0xE448E96DUL, 0xF650E4C8UL, + 0xE76DD339UL, 0xD91AA738UL, 0xD32956E5UL, 0xA264E933UL, 0x3DD20023UL, + 0x456F1EDDUL, 0x96C59CF4UL, 0xD3A388FCUL, 0x5D89A1C1UL, 0x49F413FCUL, + 0x4873D91EUL, 0x2F840E43UL, 0xED6ABD62UL, 0x10C8A5ABUL, 0x43C1A57BUL, + 0xD70B1E10UL, 0x8173DC04UL, 0x53F78EAAUL, 0x89651D84UL, 0xD5BE7FFAUL, + 0x6F57E7CEUL, 0x9C8AC447UL, 0x0073E342UL, 0x365AA66CUL, 0x97661C5EUL, + 0xAF90E49EUL, 0x8C090A23UL, 0x0E864542UL, 0x3DE0DF39UL, 0xBF7AF48EUL, + 0x13871BE7UL, 0x3E7A8B49UL, 0x4207D36FUL, 0x4A8EC630UL, 0x0A06B272UL, + 0x66907654UL, 0x9DED8244UL, 0x32028BB8UL, 0x4C3901C6UL, 0xB6470834UL, + 0x621BD7CAUL, 0xF313ADECUL, 0x2F659883UL, 0x9E979702UL, 0xBBADD184UL, + 0x03DD14A5UL, 0x43ABC21CUL, 0x565E2229UL, 0x89DAE927UL, 0x60060AFBUL, + 0xCA890B31UL, 0xD5253552UL, 0xAD2BA480UL, 0xE1194B0EUL, 0x2D845C0DUL, + 0x97A48E53UL, 0xC7EFBC2FUL, 0x9971E496UL, 0x80D8C2DEUL, 0xA0E5710BUL, + 0x0F955969UL, 0xB566E14CUL, 0x0B0CD6DAUL, 0xE5F489F6UL, 0x2C907ADEUL, + 0x7BE3F02EUL, 0x71F63B07UL, 0x09E6E57FUL, 0x4C373E7AUL, 0xC99A2639UL, + 0x54713D17UL, 0x11F0831AUL, 0x76AA1C4EUL, 0xDBF57F01UL, 0x8B2160A8UL, + 0x2B2F4C09UL, 0xCC5E6974UL, 0xFDE283C4UL, 0x8B9E6B94UL, 0x801A89CAUL, + 0x651B11C0UL, 0x360D41CDUL, 0xBF2443D6UL, 0x79801FD5UL, 0xD95F25B3UL, + 0xB849D785UL, 0x5FC7C5F3UL, 0x368D3D00UL, 0x85C5EEC2UL, 0x7E2F5520UL, + 0x41BA2ADCUL, 0x5C509848UL, 0x0761DC80UL, 0x872783A4UL, 0x71CE907CUL, + 0x52801FA8UL, 0x64E8E3F4UL, 0x5D21D51EUL, 0xF4930DBAUL, 0x3B347002UL, + 0x4EB6BD32UL, 0xF9585A3AUL, 0x7A60FABDUL, 0x49ECF97AUL, 0x82FCCAEBUL, + 0xFFB8AB5CUL, 0x1844CEE2UL, 0x161F5CA6UL, 0xAF5CFCABUL, 0x332C95D6UL, + 0xA5B5981DUL, 0x99D8D9E6UL, 0x6095EFCBUL, 0xADE6E428UL, 0x290A1140UL, + 0x67822B45UL, 0x359AC366UL, 0xFB253454UL, 0x8B8E753CUL, 0x7CAB12F6UL, + 0xE15000A6UL, 0x4AF40896UL, 0x5B6FB132UL, 0xFD84B19BUL, 0xA43A1D02UL, + 0x672C3725UL, 0x9D21AC42UL, 0x3FF4CC70UL, 0xE41EA465UL, 0xE3BB2064UL, + 0x44C4D79DUL, 0x44D6E893UL, 0x436385C6UL, 0xB310D06EUL, 0xDF8BE548UL, + 0x2992DFC6UL, 0xB2CBD9E4UL, 0x80B4B915UL, 0xB3FC5C66UL, 0x7A725BB2UL, + 0x4C655B84UL, 0x1AD1D764UL, 0x1D3043EBUL, 0xB0CC336BUL, 0x6B2F4538UL, + 0x3D29669BUL, 0x6275ACF3UL, 0x08DFD64FUL, 0x36658201UL, 0x007E96A3UL, + 0x003A02F5UL, 0xDBF38A8FUL, 0x205530EEUL, 0xB3310333UL, 0x7DFC8C7FUL, + 0x10B22A22UL, 0x9CC17BCCUL, 0xC6BA1971UL, 0xC230E2ACUL, 0xDD5E06C6UL, + 0x3F07EC49UL, 0x1AD3D9D5UL, 0x765F0DBAUL, 0xC5418124UL, 0x060DED54UL, + 0xFA55319BUL, 0x5B563101UL, 0xB831AD14UL, 0x9C7DC323UL, 0xE099BAF1UL, + 0x7F081C9AUL, 0xB7CFA23CUL, 0xD7E48546UL, 0x4FBB94BEUL, 0xB10B5D29UL, + 0x7C53C9B2UL, 0x0935AD6EUL, 0xCC5FFF02UL, 0xE34802D5UL, 0x03359832UL, + 0x4DAC20DBUL, 0xBAF0406DUL, 0x15D565B4UL, 0x1BDF1FD0UL, 0x394B8A4FUL, + 0x2E7EA9EDUL, 0x0F2969E4UL, 0x890A740CUL, 0xDE342516UL, 0x9026D97EUL, + 0x9521825FUL, 0x6F359A39UL, 0x98CB3F8BUL, 0x02C0D8ABUL, 0x902B347DUL, + 0x1FFE0E04UL, 0xF460BDF1UL, 0xA7DC6E56UL, 0x17CB7EBFUL, 0xB026016DUL, + 0xED6E963BUL, 0x72EB767BUL, 0xBEF63EEAUL, 0x6F461810UL, 0x7BBA5EADUL, + 0x5D3C00EAUL, 0x4CFDD254UL, 0x675CC8AEUL, 0xB97FFABEUL, 0x2492D476UL, + 0x4E83930AUL, 0x26F0774DUL, 0x4B90A4DEUL, 0x6BE6CE81UL, 0x19CA2158UL, + 0xA358EB94UL, 0x42D19CD7UL, 0xC7041EAEUL, 0xE8B4F627UL, 0x02E17B6FUL, + 0xFB8A0E99UL, 0x9E604C7BUL, 0xC01EDA0DUL, 0xEAD4A900UL, 0x842131C4UL, + 0x472FD994UL, 0xC6ACD20FUL, 0x44D3FF79UL, 0x05C04FCEUL, 0x67648B17UL, + 0xF27C4D0DUL, 0x0016E86FUL, 0x1629CFA4UL, 0xAC450B8FUL, 0x5AB3EAB9UL, + 0xF4C75E24UL, 0x25C871BDUL, 0xBAE16FFAUL, 0x6249FA29UL, 0xC5C29E18UL, + 0xA658F57AUL, 0xC90F8FBDUL, 0x347CB71DUL, 0x96C33F74UL, 0xCC4C9AFBUL, + 0x894F41C2UL, 0x52251DEFUL, 0x5F071FAFUL, 0x0FC99C24UL, 0xB3FFA8B5UL, + 0x995206E9UL, 0x296FD679UL, 0xB08ACD21UL, 0x301B6622UL, 0x300B4A8DUL, + 0x182600F3UL, 0xF650E4C8UL, 0xE448E96DUL, 0x98DB2FB4UL, 0xF5FAD54FUL, + 0x433F1AFBUL, 0xEDEC154AUL, 0xD8370487UL, 0x46CA4F9AUL, 0x5DE3743EUL, + 0x88381097UL, 0xF1D444EBUL, 0x823CEDB6UL, 0x6A83E1E0UL, 0x4A5F6355UL, + 0xC7442433UL, 0x25890E2EUL, 0x7452E319UL, 0x57161DF6UL, 0x38A824F3UL, + 0x002ED713UL, 0x29F55449UL, 0x51C08D83UL, 0xD78CB99EUL, 0xA0CC74F3UL, + 0x8F651659UL, 0xCBC8B7C2UL, 0xF5F71C69UL, 0x12AD6419UL, 0xE5792E1BUL, + 0x860536B8UL, 0x09B3CE98UL, 0xD45D6D81UL, 0xF3B26129UL, 0x17E38F85UL, + 0x29CF72CEUL, 0x349947B0UL, 0xC998F9FFUL, 0xB5E13DAEUL, 0x32AE2A2BUL, + 0xF7CF814CUL, 0x8EBFA303UL, 0xCF22E064UL, 0x0B923200UL, 0xECA4D58AUL, + 0xEF53CEC4UL, 0xD0F7B37DUL, 0x9C411A2AUL, 0xFFDF8A80UL, 0xB40E27BCUL, + 0xB4D2F976UL, 0x44B89B08UL, 0xF37C71D5UL, 0x1A70E7E9UL, 0x0BDB9C30UL, + 0x60DC5207UL, 0xB3C3F24BUL, 0xD7386806UL, 0x229749B5UL, 0x4E232CD0UL, + 0x91DABC65UL, 0xA70E1101UL, 0x8B87437EUL, 0x5781414FUL, 0xCDBC62E2UL, + 0x8107C9FFUL, 0x69D2E4AEUL, 0x3B18E752UL, 0xB143B688UL, 0x6F4E0772UL, + 0x95138769UL, 0x943C3C74UL, 0xAFC17A97UL, 0x0FD43963UL, 0x6A529B0BUL, + 0xD8C58A6AUL, 0xA8BCC22DUL, 0x2DB35DFEUL, 0xA7A2F402UL, 0x6CB167DBUL, + 0x538E1F4EUL, 0x7275E277UL, 0x1D3B8E97UL, 0xECC5DC91UL, 0x15E3A5B9UL, + 0x03696614UL, 0x30AB93ECUL, 0xAC9FE69DUL, 0x7BC76811UL, 0x60EDA8DAUL, + 0x28833522UL, 0xD5295EBCUL, 0x5ADB60E7UL, 0xF7E1CDD0UL, 0x97166D14UL, + 0xB67EC13AUL, 0x210F3925UL, 0x64AF0FEFUL, 0x0D028684UL, 0x3AEA3DECUL, + 0xB058BAFBUL, 0xB8B0CCFCUL, 0xF2B5CC05UL, 0xE3A662D9UL, 0x814BC24CUL, + 0x2364A1AAUL, 0x37C0ED05UL, 0x2B36505CUL, 0x451E7EC8UL, 0x5D2A542FUL, + 0xE43D0FBBUL, 0x91C8D925UL, 0x60D4D5F8UL, 0x12A0594BUL, 0x9E8A51DAUL, + 0xCD49EBDBUL, 0x1B0DCDC1UL, 0xCD57C7F7UL, 0xE6344451UL, 0x7DED386FUL, + 0x2F36FA86UL, 0xA6D12101UL, 0x33BC405DUL, 0xB388D96CUL, 0xDB6DBE96UL, + 0xFE29661CUL, 0x13EDC0CBUL, 0xCB0EEE4AUL, 0x70CC94AEUL, 0xDE11ED34UL, + 0x0606CF9FUL, 0x3A6CE389UL, 0x23D74F4EUL, 0xA37F63FFUL, 0x917BDEC2UL, + 0xD73F72D4UL, 0x0E7E0E67UL, 0x3D77D9A2UL, 0x13ADD922UL, 0x8891B3DBUL, + 0x01A9BD70UL, 0x56A001E3UL, 0xD51F093DUL, 0xCC033CE3UL, 0x5AD0D3B0UL, + 0x34105A8CUL, 0x6A123F57UL, 0xBD2E5024UL, 0x7364944BUL, 0xE89B1A3BUL, + 0x21835C4DUL, 0x9F39E2D9UL, 0xD405DED8UL, 0x294D37E5UL, 0xBCCAAEEDUL, + 0x35A124B5UL, 0x6708A2BCUL, 0xB00960BAUL, 0x2A98121AUL, 0x4D8FAE82UL, + 0x0BB3263FUL, 0x12595A19UL, 0x6A107589UL, 0x0809E494UL, 0x21C171ECUL, + 0x884D6825UL, 0x14C8009BUL, 0xB0B84E7BUL, 0x03FB88F4UL, 0x28E7CB78UL, + 0x9388B13BUL, 0xDD2DC1D5UL, 0x848F520AUL, 0x07C28CD1UL, 0x68A39358UL, + 0x72C9137DUL, 0x127DD430UL, 0xC613F157UL, 0x8C2F0D55UL, 0xF7D3F39FUL, + 0x309BFB78UL, 0x8406B137UL, 0x46C0A6F5UL, 0x3718D597UL, 0x08607F04UL, + 0x76904B6DUL, 0x04DB4E13UL, 0xCD7411A7UL, 0xB510CE0EUL, 0xBFC7F7CCUL, + 0xB83F957AUL, 0xFDFEF62DUL, 0xC35E4580UL, 0x3FF1E524UL, 0x4112D96CUL, + 0x02C9B944UL, 0xD5990DFBUL, 0xE7E26581UL, 0x0D9C7E7EUL, 0x826DFA89UL, + 0x66F1E0ABUL, 0x30BCC764UL, 0xEADEBEACUL, 0xED35E5EEUL, 0x0C571A7DUL, + 0xE4F3A26AUL, 0xF7F58F7BUL, 0xADF6BC23UL, 0x5D023E65UL, 0x1ED3FF4EUL, + 0xEC46B0B6UL, 0xD2A93B51UL, 0xE75B41C9UL, 0x7E315AEBUL, 0x61119A5AUL, + 0x53245B79UL, 0x33F6D7B1UL, 0xCAE8DEBAUL, 0x50FC8194UL, 0xAFA92A6DUL, + 0xC87C8006UL, 0x4188BFCDUL, 0x8BACE62EUL, 0x78FFA568UL, 0x5597EC0FUL, + 0xB4415F7DUL, 0x08294766UL, 0xAD567643UL, 0x09C36F90UL, 0x3DDE9F39UL, + 0x4A0A283CUL, 0x18080C8EUL, 0x080C79ECUL, 0x79AE4C10UL, 0xCB9E1563UL, + 0x7CDD662FUL, 0x62D31911UL, 0xA4CA0CF1UL, 0x5CF824CDUL, 0x3B708F99UL, + 0x1E16614CUL, 0xB6B9D766UL, 0x5DE87ABBUL, 0x7229EA81UL, 0xD5B2D750UL, + 0x56E6CD21UL, 0xFE1E42D5UL, 0x96DA2655UL, 0xC2B9AA36UL, 0xB8F6FD4AUL, + 0x6A158D10UL, 0x01913FD3UL, 0xAF7D1FB8UL, 0x0B5E435FUL, 0x90C10757UL, + 0x6554ABDAUL, 0x7A68710FUL, }; /* * This is the stream of values obtained from ISAAC 32-bits - * repeatedly after the isaac_ctx_t has been initialised with a + * after the isaac_ctx_t has been initialised with a * seed of {1, 2, 3, 4, 5, 6, 7, 8} (in bytes) + * and by reading the result[] from index 0 to end. */ const static isaac_uint_t expected_stream_with_nonzero_seed[EXPECTED_NEXT_ELEMENTS] = { - 0x23956226UL, 0xA9E1CEBFUL, 0x3EA230EBUL, 0x8175D70DUL, 0xD8B699F5UL, - 0xB4F5C36AUL, 0xB23790CFUL, 0xAEEB9340UL, 0x6F7B8DCDUL, 0x3258B530UL, - 0x4A03FAD4UL, 0x01B103BDUL, 0xB7A31E4FUL, 0x342846F3UL, 0x3EAF2975UL, - 0x0D50B3C2UL, 0x3FF7BF83UL, 0x4DE25414UL, 0x4F022DDAUL, 0x401EB5D1UL, - 0xD87221CDUL, 0xF5F8CA46UL, 0x89C2C933UL, 0x95104798UL, 0x96CCC60DUL, - 0x0A040BBAUL, 0xB881AC9FUL, 0x677E9BD8UL, 0xCCCC97F0UL, 0x7A07619FUL, - 0x20A41472UL, 0xE05C4F99UL, 0x193D85F3UL, 0x921D9AFBUL, 0x0B10807FUL, - 0xE6F53EEFUL, 0x0ABE8344UL, 0xBDEBE62AUL, 0x82782882UL, 0x8EDFB785UL, - 0x90126434UL, 0x6BA120C4UL, 0xF7D26163UL, 0x0341975CUL, 0x313B191FUL, - 0xE96231BCUL, 0x72CB5E56UL, 0xBB28F7F9UL, 0x715266D8UL, 0xE1307B9EUL, - 0x01277E65UL, 0x48048BC8UL, 0x7ABAB891UL, 0xFD8B4308UL, 0x377C8E8FUL, - 0x19E4169FUL, 0xD94B043EUL, 0x424748B0UL, 0x2807AA6CUL, 0x1D9ABC53UL, - 0x9C80D3FDUL, 0xBD47F5A8UL, 0x5F3F4788UL, 0x9FD07C61UL, 0xED9683A4UL, - 0xFF3D3663UL, 0x9B66E6AAUL, 0xB480EF7DUL, 0x4F673CDEUL, 0x8B59DD25UL, - 0x0EC205BFUL, 0xA2E3FD84UL, 0x3C2FD293UL, 0x8741EC19UL, 0xDBEB6C64UL, - 0x532CD994UL, 0x98DE0CA2UL, 0xE5FA4583UL, 0xE172AD89UL, 0xFF72B1F8UL, - 0x032C2A28UL, 0x544E0EFAUL, 0x9EB538D6UL, 0xD889EFEFUL, 0xC98EACECUL, - 0xB47ECCD6UL, 0xFBE0A6E4UL, 0x961C8CBEUL, 0x4CA2C7D2UL, 0x554E6275UL, - 0x0027F31CUL, 0x7FF40241UL, 0x01385B37UL, 0x797B8919UL, 0xD6C2572AUL, - 0x82C960C7UL, 0x0BB4FC08UL, 0x47F98DB2UL, 0xC5EFF0AFUL, 0x34303E4CUL, - 0x69C37A6FUL, 0x768D44E0UL, 0x04AF4A7AUL, 0xE89DC0C9UL, 0xDC1F5DD4UL, - 0xCDEDC3BCUL, 0xBB58FC69UL, 0x8E0A13ACUL, 0x6076530BUL, 0x74FD76C8UL, - 0x1B7BDD70UL, 0x7D856AF1UL, 0x76F5BECAUL, 0x126E12E5UL, 0x6C80F470UL, - 0x7353E11CUL, 0xAB0399C9UL, 0x265BE277UL, 0xFCC9512CUL, 0x327741D7UL, - 0x9D330411UL, 0xB4D2939DUL, 0xBA39E19FUL, 0x5D4FD5E5UL, 0x31703EB0UL, - 0x0DBF5471UL, 0xA627343DUL, 0x18543E12UL, 0x61F3E920UL, 0x0076F1F8UL, - 0x05CF8AC6UL, 0xB5700F3AUL, 0x2B8A286BUL, 0x5092A1A2UL, 0xB74DE086UL, - 0x484A0CE8UL, 0xB4AE30F3UL, 0xDA3B78CDUL, 0xE6C73EB6UL, 0x910E46B2UL, - 0x23C03C70UL, 0xC29A190CUL, 0x79AB9CF2UL, 0x45A76DCEUL, 0x86EC53A7UL, - 0x43D13242UL, 0x04B020B7UL, 0xA903AAE9UL, 0x0F07ED2BUL, 0xF385BB7FUL, - 0x7B6EEFDCUL, 0x9F11F572UL, 0x36A95AFFUL, 0xDEB54D1FUL, 0x4AFC5002UL, - 0xB855EDD5UL, 0xFD0356D6UL, 0x91474D54UL, 0x62928BBBUL, 0x42BAE3AFUL, - 0x80FA85E3UL, 0x940568A0UL, 0x8C21D6A3UL, 0x3B0F2F18UL, 0xD6617C47UL, - 0xCF62EBD5UL, 0xC2BF97E0UL, 0x246D45A6UL, 0x5066E4A3UL, 0x4E859A2CUL, - 0xFD87ACA3UL, 0x1580045AUL, 0xC6104017UL, 0xD5A20325UL, 0xF2D499F3UL, - 0x2EECCD6BUL, 0x629BCEC3UL, 0x09359360UL, 0xD13B506AUL, 0xB37693D1UL, - 0x0AEF3B0DUL, 0x2950EE3EUL, 0xE6E11073UL, 0xAE028C9BUL, 0xC52E6B7AUL, - 0x686C382CUL, 0x79140B9BUL, 0xF8C5F834UL, 0x00CDFEDAUL, 0xB3E2535AUL, - 0x52F5DD57UL, 0xF38B6968UL, 0xCE3B407BUL, 0x2F199C58UL, 0xBFB9E202UL, - 0x9A1B7282UL, 0xBB6ABA64UL, 0x584B13E5UL, 0xE2DD2B60UL, 0x81E5CC75UL, - 0x99CE6B82UL, 0xFE945574UL, 0xE6F63522UL, 0x0315E9C0UL, 0xE6C61DADUL, - 0x0DD6E029UL, 0x0532FB9BUL, 0xF2C72AB0UL, 0x37EB562FUL, 0xA00F02A2UL, - 0xCDE1EDBDUL, 0x919F5B18UL, 0x8DB85D64UL, 0x2B0DA294UL, 0x2763BF0CUL, - 0x3FC3A488UL, 0x97F7A9C8UL, 0x67C5264BUL, 0x893CBE90UL, 0xAF408615UL, - 0xF9B83492UL, 0x39C15C5EUL, 0xFFCC9D0DUL, 0x3500511CUL, 0xF495799AUL, - 0xF660CB52UL, 0x6DFF5D0FUL, 0x5F12277FUL, 0x21A7B79BUL, 0x60ADDF8FUL, - 0x7BB3B391UL, 0x62CBE77EUL, 0x20D2C863UL, 0x49529EB0UL, 0x11C078D1UL, - 0xB33F34D2UL, 0x1A657203UL, 0xB9E5E431UL, 0x3C02CD0EUL, 0x3B8BBF4DUL, - 0x41B38BA2UL, 0x525D5B72UL, 0x1E8365A1UL, 0x3CCC8D13UL, 0xDBA2B1A6UL, - 0x7C3837D3UL, 0x23D46470UL, 0xFF344EA9UL, 0xE13F9A4DUL, 0x38777CFEUL, - 0x2E653888UL, 0x3DF06B31UL, 0xE3789964UL, 0x40B4E071UL, 0x7864DE8DUL, - 0x953A7425UL, 0x83898930UL, 0x17D3D13BUL, 0x09729780UL, 0x270CD1BEUL, - 0x917836E1UL, 0xEF39C021UL, 0xC66B26F5UL, 0x8FF1CA2FUL, 0x8B70CE31UL, - 0x71C9F6A0UL, 0x8618C8EFUL, 0x8326376AUL, 0xCEDABC6CUL, 0x78E28436UL, - 0x8A36209FUL, 0x9276C391UL, 0x6098B381UL, 0x37869E2DUL, 0xAFD6DD31UL, - 0xCB3EF1FDUL, 0xC4D59F44UL, 0x6C9E94F5UL, 0x6F591D9EUL, 0x87373E7EUL, - 0x556F0990UL, 0xF36F9072UL, 0x0DCD6CBBUL, 0xBDE00A1AUL, 0x929942D3UL, - 0x1F8EC2F7UL, 0x7EB28F7DUL, 0xD12042BBUL, 0xDA7B5EB4UL, 0x973663F3UL, - 0x34E366C2UL, 0x178EE281UL, 0xD5CFA8CFUL, 0x9C6F970EUL, 0x69B8A3A3UL, - 0x6FE79BEAUL, 0x23DBF263UL, 0x288BE545UL, 0x180D72A2UL, 0xAF306E45UL, - 0xEE8F64DEUL, 0x5D85FF69UL, 0xF1B05655UL, 0x8E96B58DUL, 0x5286EE54UL, - 0xBA35737FUL, 0x691C367BUL, 0x9B83E219UL, 0x2B27810CUL, 0x756188C0UL, - 0x5C972AF2UL, 0xA45ED9DBUL, 0x7F0491ACUL, 0x54D31D43UL, 0xFBABB108UL, - 0x3B6B2904UL, 0x3949EDEBUL, 0x1F25E2B7UL, 0xE44782A0UL, 0xA6F871ECUL, - 0xB95CCC4CUL, 0xFDD0A134UL, 0x6A1FB7F8UL, 0x723B1C41UL, 0x09279B14UL, - 0x95A228A8UL, 0x091A76E0UL, 0x8F18F340UL, 0x3C439DE2UL, 0x534CC501UL, - 0xB56919E7UL, 0x02F92E83UL, 0x963B782AUL, 0xA03C1507UL, 0x6AA65747UL, - 0xB060CE26UL, 0x5F6BD15FUL, 0xB3731688UL, 0xD512F88BUL, 0x1F698776UL, - 0xB2D04075UL, 0xCF784BA7UL, 0x85D3AA92UL, 0xFBE30CA0UL, 0x8DC13C1AUL, - 0x1BA22E53UL, 0x6613C020UL, 0xA60CE71BUL, 0x1ED71566UL, 0x32F4B14AUL, - 0x45A9CDBCUL, 0x29A1BF6DUL, 0x449F34E7UL, 0xAB0E8093UL, 0xBEACD640UL, - 0x66658B82UL, 0x659C7174UL, 0xB3986716UL, 0x2D74F7B7UL, 0xF80D6865UL, - 0x54E5EE32UL, 0x8354CD54UL, 0xA0258533UL, 0x887E7CE4UL, 0x603E7393UL, - 0xC346532BUL, 0x7E3CBBA6UL, 0x030246A2UL, 0x164890BEUL, 0x901F6512UL, - 0xB01F29F3UL, 0xE74E31E5UL, 0x23AEAB56UL, 0x8DAD85D0UL, 0x15014318UL, - 0x87564BA5UL, 0xB59D400AUL, 0xCCC5615DUL, 0x2263D6D9UL, 0x97C96EDDUL, - 0x38C81193UL, 0x6DBF2AD5UL, 0xE5D1656DUL, 0x6E5F3D27UL, 0x9F221975UL, - 0xEC2553A4UL, 0xA955B0E4UL, 0xF4E49A76UL, 0xB397710AUL, 0xD4768266UL, - 0x346A8595UL, 0x373F529CUL, 0x0C18F25BUL, 0x39027F89UL, 0x722FC2DEUL, - 0xE2BB6C26UL, 0x971BF5FCUL, 0xEBE73EBFUL, 0xFFE707FDUL, 0xD0ADF1FFUL, - 0xBF096C5AUL, 0x05A58900UL, 0x07BD7472UL, 0x2BCF0A2AUL, 0x0B3486C3UL, - 0xCDDC7921UL, 0xA57A6596UL, 0x40BBDFEFUL, 0xAA8FB1E6UL, 0x60790FEDUL, - 0xEEE46E65UL, 0xB21E9B88UL, 0x8141C0FFUL, 0x60277C06UL, 0x26EA94AAUL, - 0x10C5B331UL, 0x22419915UL, 0x8B48BAA1UL, 0x4BF50F1EUL, 0x612AE87BUL, - 0x4232AF38UL, 0x60EBE998UL, 0x5ED41DC8UL, 0x6D2545CDUL, 0x10821317UL, - 0x5E1B5F63UL, 0x7C33BBEDUL, 0xAC2C5F99UL, 0x130FCD93UL, 0x3E8F51F3UL, - 0xEE7407A6UL, 0xE7ECAB76UL, 0xB3EAD0A4UL, 0xFB72843FUL, 0x093BAE0FUL, - 0x63F72E31UL, 0xBF811E09UL, 0x6B2FC507UL, 0x5E5944FDUL, 0xC87DC98BUL, - 0x2929C9EBUL, 0xF2EFC71AUL, 0xCCF9F0F4UL, 0xB8225A69UL, 0x655324B0UL, - 0xC29C597EUL, 0x5A472B6AUL, 0x79EBA40FUL, 0x7C993125UL, 0x73B2E234UL, - 0xC5A33334UL, 0xE4C77BDCUL, 0x4EE4BDC0UL, 0xF7563F8DUL, 0x773A63BDUL, - 0x5B96D31BUL, 0xA28F8C1BUL, 0xE5CDAA5DUL, 0x8CB5CC80UL, 0xA532F9A3UL, - 0xF464623FUL, 0xD2E96515UL, 0xC399AD67UL, 0xE0FAF0BCUL, 0x943E3553UL, - 0xD8C7D774UL, 0x4D288760UL, 0x302568CAUL, 0xDA797359UL, 0x66A1428CUL, - 0x8DB78A22UL, 0x63254204UL, 0x3453DED7UL, 0x8E7AAAEBUL, 0x6630035BUL, - 0x0E27C57EUL, 0x554D1C0CUL, 0xE0455168UL, 0x569D090CUL, 0x3E0EA3C5UL, - 0x116BCFBEUL, 0xF3EC121BUL, 0xCEF4AEAAUL, 0xEDBF0D83UL, 0xDFAC741AUL, - 0x1CA77655UL, 0x28E5B73CUL, 0xD5686960UL, 0xCF2A4207UL, 0x4556FE78UL, - 0xD6BAF9ACUL, 0x3275689BUL, 0x7C9D23AEUL, 0x35E02396UL, 0xCAE7A6B6UL, - 0x4FE339C9UL, 0xFA428AE2UL, 0x6C142E4AUL, 0xA9D264E0UL, 0x9706CE55UL, - 0x5AB6CB29UL, 0x5E477185UL, 0x333F24A1UL, 0xAA8E3D76UL, 0xA28A756EUL, - 0xF5F457EDUL, 0x0CA64E63UL, 0xF01D7CD9UL, 0xADB4D30AUL, 0xD2BDFC58UL, - 0xDE0FE6D6UL, 0x5521DA1BUL, + 0x953A7425UL, 0x7864DE8DUL, 0x40B4E071UL, 0xE3789964UL, 0x3DF06B31UL, + 0x2E653888UL, 0x38777CFEUL, 0xE13F9A4DUL, 0xFF344EA9UL, 0x23D46470UL, + 0x7C3837D3UL, 0xDBA2B1A6UL, 0x3CCC8D13UL, 0x1E8365A1UL, 0x525D5B72UL, + 0x41B38BA2UL, 0x3B8BBF4DUL, 0x3C02CD0EUL, 0xB9E5E431UL, 0x1A657203UL, + 0xB33F34D2UL, 0x11C078D1UL, 0x49529EB0UL, 0x20D2C863UL, 0x62CBE77EUL, + 0x7BB3B391UL, 0x60ADDF8FUL, 0x21A7B79BUL, 0x5F12277FUL, 0x6DFF5D0FUL, + 0xF660CB52UL, 0xF495799AUL, 0x3500511CUL, 0xFFCC9D0DUL, 0x39C15C5EUL, + 0xF9B83492UL, 0xAF408615UL, 0x893CBE90UL, 0x67C5264BUL, 0x97F7A9C8UL, + 0x3FC3A488UL, 0x2763BF0CUL, 0x2B0DA294UL, 0x8DB85D64UL, 0x919F5B18UL, + 0xCDE1EDBDUL, 0xA00F02A2UL, 0x37EB562FUL, 0xF2C72AB0UL, 0x0532FB9BUL, + 0x0DD6E029UL, 0xE6C61DADUL, 0x0315E9C0UL, 0xE6F63522UL, 0xFE945574UL, + 0x99CE6B82UL, 0x81E5CC75UL, 0xE2DD2B60UL, 0x584B13E5UL, 0xBB6ABA64UL, + 0x9A1B7282UL, 0xBFB9E202UL, 0x2F199C58UL, 0xCE3B407BUL, 0xF38B6968UL, + 0x52F5DD57UL, 0xB3E2535AUL, 0x00CDFEDAUL, 0xF8C5F834UL, 0x79140B9BUL, + 0x686C382CUL, 0xC52E6B7AUL, 0xAE028C9BUL, 0xE6E11073UL, 0x2950EE3EUL, + 0x0AEF3B0DUL, 0xB37693D1UL, 0xD13B506AUL, 0x09359360UL, 0x629BCEC3UL, + 0x2EECCD6BUL, 0xF2D499F3UL, 0xD5A20325UL, 0xC6104017UL, 0x1580045AUL, + 0xFD87ACA3UL, 0x4E859A2CUL, 0x5066E4A3UL, 0x246D45A6UL, 0xC2BF97E0UL, + 0xCF62EBD5UL, 0xD6617C47UL, 0x3B0F2F18UL, 0x8C21D6A3UL, 0x940568A0UL, + 0x80FA85E3UL, 0x42BAE3AFUL, 0x62928BBBUL, 0x91474D54UL, 0xFD0356D6UL, + 0xB855EDD5UL, 0x4AFC5002UL, 0xDEB54D1FUL, 0x36A95AFFUL, 0x9F11F572UL, + 0x7B6EEFDCUL, 0xF385BB7FUL, 0x0F07ED2BUL, 0xA903AAE9UL, 0x04B020B7UL, + 0x43D13242UL, 0x86EC53A7UL, 0x45A76DCEUL, 0x79AB9CF2UL, 0xC29A190CUL, + 0x23C03C70UL, 0x910E46B2UL, 0xE6C73EB6UL, 0xDA3B78CDUL, 0xB4AE30F3UL, + 0x484A0CE8UL, 0xB74DE086UL, 0x5092A1A2UL, 0x2B8A286BUL, 0xB5700F3AUL, + 0x05CF8AC6UL, 0x0076F1F8UL, 0x61F3E920UL, 0x18543E12UL, 0xA627343DUL, + 0x0DBF5471UL, 0x31703EB0UL, 0x5D4FD5E5UL, 0xBA39E19FUL, 0xB4D2939DUL, + 0x9D330411UL, 0x327741D7UL, 0xFCC9512CUL, 0x265BE277UL, 0xAB0399C9UL, + 0x7353E11CUL, 0x6C80F470UL, 0x126E12E5UL, 0x76F5BECAUL, 0x7D856AF1UL, + 0x1B7BDD70UL, 0x74FD76C8UL, 0x6076530BUL, 0x8E0A13ACUL, 0xBB58FC69UL, + 0xCDEDC3BCUL, 0xDC1F5DD4UL, 0xE89DC0C9UL, 0x04AF4A7AUL, 0x768D44E0UL, + 0x69C37A6FUL, 0x34303E4CUL, 0xC5EFF0AFUL, 0x47F98DB2UL, 0x0BB4FC08UL, + 0x82C960C7UL, 0xD6C2572AUL, 0x797B8919UL, 0x01385B37UL, 0x7FF40241UL, + 0x0027F31CUL, 0x554E6275UL, 0x4CA2C7D2UL, 0x961C8CBEUL, 0xFBE0A6E4UL, + 0xB47ECCD6UL, 0xC98EACECUL, 0xD889EFEFUL, 0x9EB538D6UL, 0x544E0EFAUL, + 0x032C2A28UL, 0xFF72B1F8UL, 0xE172AD89UL, 0xE5FA4583UL, 0x98DE0CA2UL, + 0x532CD994UL, 0xDBEB6C64UL, 0x8741EC19UL, 0x3C2FD293UL, 0xA2E3FD84UL, + 0x0EC205BFUL, 0x8B59DD25UL, 0x4F673CDEUL, 0xB480EF7DUL, 0x9B66E6AAUL, + 0xFF3D3663UL, 0xED9683A4UL, 0x9FD07C61UL, 0x5F3F4788UL, 0xBD47F5A8UL, + 0x9C80D3FDUL, 0x1D9ABC53UL, 0x2807AA6CUL, 0x424748B0UL, 0xD94B043EUL, + 0x19E4169FUL, 0x377C8E8FUL, 0xFD8B4308UL, 0x7ABAB891UL, 0x48048BC8UL, + 0x01277E65UL, 0xE1307B9EUL, 0x715266D8UL, 0xBB28F7F9UL, 0x72CB5E56UL, + 0xE96231BCUL, 0x313B191FUL, 0x0341975CUL, 0xF7D26163UL, 0x6BA120C4UL, + 0x90126434UL, 0x8EDFB785UL, 0x82782882UL, 0xBDEBE62AUL, 0x0ABE8344UL, + 0xE6F53EEFUL, 0x0B10807FUL, 0x921D9AFBUL, 0x193D85F3UL, 0xE05C4F99UL, + 0x20A41472UL, 0x7A07619FUL, 0xCCCC97F0UL, 0x677E9BD8UL, 0xB881AC9FUL, + 0x0A040BBAUL, 0x96CCC60DUL, 0x95104798UL, 0x89C2C933UL, 0xF5F8CA46UL, + 0xD87221CDUL, 0x401EB5D1UL, 0x4F022DDAUL, 0x4DE25414UL, 0x3FF7BF83UL, + 0x0D50B3C2UL, 0x3EAF2975UL, 0x342846F3UL, 0xB7A31E4FUL, 0x01B103BDUL, + 0x4A03FAD4UL, 0x3258B530UL, 0x6F7B8DCDUL, 0xAEEB9340UL, 0xB23790CFUL, + 0xB4F5C36AUL, 0xD8B699F5UL, 0x8175D70DUL, 0x3EA230EBUL, 0xA9E1CEBFUL, + 0x23956226UL, 0x5521DA1BUL, 0xDE0FE6D6UL, 0xD2BDFC58UL, 0xADB4D30AUL, + 0xF01D7CD9UL, 0x0CA64E63UL, 0xF5F457EDUL, 0xA28A756EUL, 0xAA8E3D76UL, + 0x333F24A1UL, 0x5E477185UL, 0x5AB6CB29UL, 0x9706CE55UL, 0xA9D264E0UL, + 0x6C142E4AUL, 0xFA428AE2UL, 0x4FE339C9UL, 0xCAE7A6B6UL, 0x35E02396UL, + 0x7C9D23AEUL, 0x3275689BUL, 0xD6BAF9ACUL, 0x4556FE78UL, 0xCF2A4207UL, + 0xD5686960UL, 0x28E5B73CUL, 0x1CA77655UL, 0xDFAC741AUL, 0xEDBF0D83UL, + 0xCEF4AEAAUL, 0xF3EC121BUL, 0x116BCFBEUL, 0x3E0EA3C5UL, 0x569D090CUL, + 0xE0455168UL, 0x554D1C0CUL, 0x0E27C57EUL, 0x6630035BUL, 0x8E7AAAEBUL, + 0x3453DED7UL, 0x63254204UL, 0x8DB78A22UL, 0x66A1428CUL, 0xDA797359UL, + 0x302568CAUL, 0x4D288760UL, 0xD8C7D774UL, 0x943E3553UL, 0xE0FAF0BCUL, + 0xC399AD67UL, 0xD2E96515UL, 0xF464623FUL, 0xA532F9A3UL, 0x8CB5CC80UL, + 0xE5CDAA5DUL, 0xA28F8C1BUL, 0x5B96D31BUL, 0x773A63BDUL, 0xF7563F8DUL, + 0x4EE4BDC0UL, 0xE4C77BDCUL, 0xC5A33334UL, 0x73B2E234UL, 0x7C993125UL, + 0x79EBA40FUL, 0x5A472B6AUL, 0xC29C597EUL, 0x655324B0UL, 0xB8225A69UL, + 0xCCF9F0F4UL, 0xF2EFC71AUL, 0x2929C9EBUL, 0xC87DC98BUL, 0x5E5944FDUL, + 0x6B2FC507UL, 0xBF811E09UL, 0x63F72E31UL, 0x093BAE0FUL, 0xFB72843FUL, + 0xB3EAD0A4UL, 0xE7ECAB76UL, 0xEE7407A6UL, 0x3E8F51F3UL, 0x130FCD93UL, + 0xAC2C5F99UL, 0x7C33BBEDUL, 0x5E1B5F63UL, 0x10821317UL, 0x6D2545CDUL, + 0x5ED41DC8UL, 0x60EBE998UL, 0x4232AF38UL, 0x612AE87BUL, 0x4BF50F1EUL, + 0x8B48BAA1UL, 0x22419915UL, 0x10C5B331UL, 0x26EA94AAUL, 0x60277C06UL, + 0x8141C0FFUL, 0xB21E9B88UL, 0xEEE46E65UL, 0x60790FEDUL, 0xAA8FB1E6UL, + 0x40BBDFEFUL, 0xA57A6596UL, 0xCDDC7921UL, 0x0B3486C3UL, 0x2BCF0A2AUL, + 0x07BD7472UL, 0x05A58900UL, 0xBF096C5AUL, 0xD0ADF1FFUL, 0xFFE707FDUL, + 0xEBE73EBFUL, 0x971BF5FCUL, 0xE2BB6C26UL, 0x722FC2DEUL, 0x39027F89UL, + 0x0C18F25BUL, 0x373F529CUL, 0x346A8595UL, 0xD4768266UL, 0xB397710AUL, + 0xF4E49A76UL, 0xA955B0E4UL, 0xEC2553A4UL, 0x9F221975UL, 0x6E5F3D27UL, + 0xE5D1656DUL, 0x6DBF2AD5UL, 0x38C81193UL, 0x97C96EDDUL, 0x2263D6D9UL, + 0xCCC5615DUL, 0xB59D400AUL, 0x87564BA5UL, 0x15014318UL, 0x8DAD85D0UL, + 0x23AEAB56UL, 0xE74E31E5UL, 0xB01F29F3UL, 0x901F6512UL, 0x164890BEUL, + 0x030246A2UL, 0x7E3CBBA6UL, 0xC346532BUL, 0x603E7393UL, 0x887E7CE4UL, + 0xA0258533UL, 0x8354CD54UL, 0x54E5EE32UL, 0xF80D6865UL, 0x2D74F7B7UL, + 0xB3986716UL, 0x659C7174UL, 0x66658B82UL, 0xBEACD640UL, 0xAB0E8093UL, + 0x449F34E7UL, 0x29A1BF6DUL, 0x45A9CDBCUL, 0x32F4B14AUL, 0x1ED71566UL, + 0xA60CE71BUL, 0x6613C020UL, 0x1BA22E53UL, 0x8DC13C1AUL, 0xFBE30CA0UL, + 0x85D3AA92UL, 0xCF784BA7UL, 0xB2D04075UL, 0x1F698776UL, 0xD512F88BUL, + 0xB3731688UL, 0x5F6BD15FUL, 0xB060CE26UL, 0x6AA65747UL, 0xA03C1507UL, + 0x963B782AUL, 0x02F92E83UL, 0xB56919E7UL, 0x534CC501UL, 0x3C439DE2UL, + 0x8F18F340UL, 0x091A76E0UL, 0x95A228A8UL, 0x09279B14UL, 0x723B1C41UL, + 0x6A1FB7F8UL, 0xFDD0A134UL, 0xB95CCC4CUL, 0xA6F871ECUL, 0xE44782A0UL, + 0x1F25E2B7UL, 0x3949EDEBUL, 0x3B6B2904UL, 0xFBABB108UL, 0x54D31D43UL, + 0x7F0491ACUL, 0xA45ED9DBUL, 0x5C972AF2UL, 0x756188C0UL, 0x2B27810CUL, + 0x9B83E219UL, 0x691C367BUL, 0xBA35737FUL, 0x5286EE54UL, 0x8E96B58DUL, + 0xF1B05655UL, 0x5D85FF69UL, 0xEE8F64DEUL, 0xAF306E45UL, 0x180D72A2UL, + 0x288BE545UL, 0x23DBF263UL, 0x6FE79BEAUL, 0x69B8A3A3UL, 0x9C6F970EUL, + 0xD5CFA8CFUL, 0x178EE281UL, 0x34E366C2UL, 0x973663F3UL, 0xDA7B5EB4UL, + 0xD12042BBUL, 0x7EB28F7DUL, 0x1F8EC2F7UL, 0x929942D3UL, 0xBDE00A1AUL, + 0x0DCD6CBBUL, 0xF36F9072UL, 0x556F0990UL, 0x87373E7EUL, 0x6F591D9EUL, + 0x6C9E94F5UL, 0xC4D59F44UL, 0xCB3EF1FDUL, 0xAFD6DD31UL, 0x37869E2DUL, + 0x6098B381UL, 0x9276C391UL, 0x8A36209FUL, 0x78E28436UL, 0xCEDABC6CUL, + 0x8326376AUL, 0x8618C8EFUL, 0x71C9F6A0UL, 0x8B70CE31UL, 0x8FF1CA2FUL, + 0xC66B26F5UL, 0xEF39C021UL, 0x917836E1UL, 0x270CD1BEUL, 0x09729780UL, + 0x17D3D13BUL, 0x83898930UL, }; #endif @@ -609,7 +610,7 @@ static void test_stream_with_zero_seed(void) atto_eq(stream[0], expected_stream_with_zero_seed[0]); atto_memeq(stream, expected_stream_with_zero_seed, 300 * sizeof(isaac_uint_t)); - atto_eq(ctx.next_index, 256 * 2 - 300 - 1); + atto_eq(ctx.next_index, 300 - 256); } static void test_stream_with_zero_seed_multiple_calls(void) @@ -626,7 +627,7 @@ static void test_stream_with_zero_seed_multiple_calls(void) atto_neq(stream[0], 0); atto_memeq(stream, expected_stream_with_zero_seed, 300 * sizeof(isaac_uint_t)); - atto_eq(ctx.next_index, 256 * 2 - 300 - 1); + atto_eq(ctx.next_index, 300 - 256); } static void test_stream_with_nonzero_seed(void) @@ -641,7 +642,7 @@ static void test_stream_with_nonzero_seed(void) atto_neq(stream[0], 0); atto_memeq(stream, expected_stream_with_nonzero_seed, 300 * sizeof(isaac_uint_t)); - atto_eq(ctx.next_index, 256 * 2 - 300 - 1); + atto_eq(ctx.next_index, 300 - 256); } static void test_stream_with_nonzero_seed_multiple_calls(void) @@ -659,7 +660,7 @@ static void test_stream_with_nonzero_seed_multiple_calls(void) atto_neq(stream[0], 0); atto_memeq(stream, expected_stream_with_nonzero_seed, 300 * sizeof(isaac_uint_t)); - atto_eq(ctx.next_index, 256 * 2 - 300 - 1); + atto_eq(ctx.next_index, 300 - 256); } void test_isaac_next(void) From 6d4fdf771079b3cb2c009a27ac735adbba1e8ff4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matjaz=CC=8C?= Date: Tue, 28 Apr 2020 21:53:22 +0200 Subject: [PATCH 24/27] Fix doxygen warnings, improve doxygen text, especially on file-level - Fix some broken test, missed fixing some values due to inverting the stream - Rename next_index field to stream_index for clarity --- inc/isaac.h | 87 ++++++++++++++++++++++++++++++++++++++--------- src/isaac.c | 10 +++--- tst/test_init.c | 8 ++--- tst/test_stream.c | 8 ++--- 4 files changed, 84 insertions(+), 29 deletions(-) diff --git a/inc/isaac.h b/inc/isaac.h index 85a2e32..949e372 100644 --- a/inc/isaac.h +++ b/inc/isaac.h @@ -1,8 +1,26 @@ /** * @file * - * ISAAC, the fast cryptographic pseudo random number generator (CPRNG), wrapped - * into a modern, C11, documented API and package. Quoting from its + * This library offers the tiny and fast ISAAC cryptographically secure pseudo + * random number generator (CSPRNG), in its 32-bit and 64-bit version wrapped + * into a modern, ISO C11, documented API, ready for embedded usage. + * + * Use the #ISAAC_BITS macro to compile LibISAAC optimised for 32 or 64 bits. + * The 32 bit is the classic ISAAC; the 64 bit is ISAAC-64. Note that the output + * differs between the two and the context grows twice in size when using the 64 + * bit version, but you also get twice the bytes per reshuffling. + * + * Then the usage of ISAAC is easy: + * - init the context with a secret seed with isaac_init() + * - get any amount of pseudo-random numbers with isaac_stream() + * - if you need bytes instead of numbers, convert them using the utility + * functions isaac_to_big_endian() or isaac_to_little_endian() + * - When you are done using ISAAC, cleanup the context to avoid leaking secret + * data with isaac_cleanup() + * + * **About ISAAC** + * + * Quoting from its * [web page](https://www.burtleburtle.net/bob/rand/isaacafa.html): * * > ISAAC (Indirection, Shift, Accumulate, Add, and Count) generates 32-bit @@ -11,6 +29,11 @@ * > values long, and they are 28295 values long on average. The results are * > uniformly distributed, unbiased, and unpredictable unless you know the * > seed. + * > [...] + * > ISAAC-64 generates a different sequence than ISAAC, but it uses the same + * > principles. It uses 64-bit arithmetic. It generates a 64-bit result every + * > 19 instructions. All cycles are at least 272 values, and the average + * > cycle length is 216583. * * ISAAC and its original source code is created by Bob Jenkins and * released into the public domain. @@ -39,6 +62,18 @@ extern "C" #include #include +/** + * @property #ISAAC_BITS + * Set it to 32 or 64 to optimise ISAAC for 32 or 64 bit words respectively. + * + * The 32 bit is the classic ISAAC; the 64 bit is ISAAC-64. Note that the output + * differs between the two and the context grows twice in size when using the 64 + * bit version, but you also get twice the bytes per reshuffling. + */ +/** + * @property isaac_uint_t + * An integer or word used by ISAAC, either a uint32_t or uint64_t. + */ #ifndef ISAAC_BITS #define ISAAC_BITS 64 #endif @@ -50,20 +85,36 @@ typedef uint64_t isaac_uint_t; _Static_assert(0, "ISAAC: only 32 or 64 bit words are supported."); #endif +/** + * Amount of elements in ISAAC's context arrays. + */ #define ISAAC_ELEMENTS 256U + +/** + * Max bytes supported in the seed. + */ #define ISAAC_SEED_MAX_BYTES ISAAC_ELEMENTS /** * Context of the ISAAC CPRNG. * + * No need to inspect it manually, use the functions instead. + * * Maps to `randctx` from the original implementation. */ typedef struct { + /** + * In this field the pseudo-random data is generated. + */ isaac_uint_t result[ISAAC_ELEMENTS]; + /** Internal field. */ isaac_uint_t mem[ISAAC_ELEMENTS]; + /** Internal field. */ isaac_uint_t a; + /** Internal field. */ isaac_uint_t b; + /** Internal field. */ isaac_uint_t c; /** * Index of the next value to output in the stream. @@ -71,7 +122,7 @@ typedef struct * Note: this value could be a uint16_t instead of a isaac_uint_t, but by * using an isaac_uint_t we avoid any padding at the end of the struct. */ - isaac_uint_t next_index; + isaac_uint_t stream_index; } isaac_ctx_t; /** @@ -79,14 +130,16 @@ typedef struct * * The seed is copied value-wise into the ISAAC state, not byte-wise. That * means that a uint8_t array {1,2,3,4} is copied into the ctx->result[] - * isaac_uint_t array as {1,2,3,4,0,...,0}, where each value is a isaac_uint_t value. + * isaac_uint_t array as {1,2,3,4,0,...,0}, where each value is a isaac_uint_t + * value. * Looking at the bytes and assuming little Endian byte order, the result is * {1,2,3,4} --> {1,0,0,0,2,0,0,0,3,0,0,0,4,0,0,0,0,...,0}. * * The reason behind this choice is to avoid issues with endianness; as ISAAC - * works on isaac_uint_t values rather than their bytes, setting the isaac_uint_t values - * and not their bytes, shall produce the same CPRNG stream on architectures - * with different endianness. A isaac_uint_t* could also be a valid choice as seed + * works on isaac_uint_t values rather than their bytes, setting the + * isaac_uint_t values and not their bytes, shall produce the same CPRNG stream + * on architectures with different endianness. + * An isaac_uint_t* could also be a valid choice as seed * input, but seeds are usually cryptographic keys and those are byte arrays, * so a developer could be confused on how to insert a uint8_t* seed into * a isaac_uint_t*. @@ -105,10 +158,12 @@ typedef struct * Providing a seed with low entropy will result in the whole CSPRNG to be * weak. * - * @param ctx the ISAAC state to be initialised. Does nothing when NULL. - * @param seed pointer to the seed to use, which is copied into the context. + * @param[in, out] ctx the ISAAC state to be initialised. Does nothing when + * NULL. + * @param[in] seed pointer to the seed to use, which is copied into the context. * - If NULL, then a zero seed is used instead (**insecure!**) - * @param seed_bytes amount of **bytes** in the seed, max #ISAAC_SEED_MAX_BYTES. + * @param[in] seed_bytes amount of **bytes** in the seed, max + * #ISAAC_SEED_MAX_BYTES. * - If 0, then a zero seed is used instead (**insecure!**) * - If > #ISAAC_SEED_MAX_BYTES, then only #ISAAC_SEED_MAX_BYTES will be used * - If < #ISAAC_SEED_MAX_BYTES, then the provided bytes will be used and the @@ -124,15 +179,15 @@ void isaac_init(isaac_ctx_t* ctx, const uint8_t* seed, uint16_t seed_bytes); * To convert them to bytes: * - get some values into a isaac_uint_t buffer with isaac_stream() * - allocate a uint8_t buffer - * - convert the isaac_uint_t buffer to the uint8_t one using the utility functions - * isaac_to_little_endian() or isaac_to_big_endian() for little and big - * endian respectively. + * - convert the isaac_uint_t buffer to the uint8_t one using the utility + * functions isaac_to_little_endian() or isaac_to_big_endian() for little and + * big endian respectively. * - * Every #ISAAC_ELEMENTS values provided it will automatically reshuffle + * Every #ISAAC_ELEMENTS values generated it will automatically reshuffle * the ISAAC state to cache #ISAAC_ELEMENTS new elements. This means that * the first #ISAAC_ELEMENTS values after seeding are very cheap (just * copying values from the state) and the #ISAAC_ELEMENTS+1st value is - * more expensive. + * more expensive and so on. * * @param[in, out] ctx the ISAAC state, already initialised. * Does nothing when NULL. @@ -150,7 +205,7 @@ void isaac_stream(isaac_ctx_t* ctx, isaac_uint_t* ints, size_t amount); * There is no need to call this function before using isaac_init(), including * when re-initing an existing context. * - * @param[in] ctx the ISAAC state to cleanup. Does nothing when NULL. + * @param[in, out] ctx the ISAAC state to cleanup. Does nothing when NULL. */ void isaac_cleanup(isaac_ctx_t* ctx); diff --git a/src/isaac.c b/src/isaac.c index 666e121..35fd7e8 100644 --- a/src/isaac.c +++ b/src/isaac.c @@ -90,7 +90,7 @@ void isaac_init(isaac_ctx_t* const ctx, } isaac_uint_t a, b, c, d, e, f, g, h; uint_fast16_t i; /* Fastest index over elements in result[] and mem[]. */ - ctx->next_index = ctx->a = ctx->b = ctx->c = 0; + ctx->stream_index = ctx->a = ctx->b = ctx->c = 0; a = b = c = d = e = f = g = h = GOLDEN_RATIO; /* Scramble it */ for (i = 0; i < 4; i++) @@ -248,17 +248,17 @@ void isaac_stream(isaac_ctx_t* const ctx, isaac_uint_t* ints, size_t amount) uint_fast16_t available; while (amount) { - available = ISAAC_MIN(ISAAC_ELEMENTS - ctx->next_index, amount); + available = ISAAC_MIN(ISAAC_ELEMENTS - ctx->stream_index, amount); amount -= available; while (available--) { - *ints++ = ctx->result[ctx->next_index++]; + *ints++ = ctx->result[ctx->stream_index++]; }; - if (ctx->next_index >= ISAAC_ELEMENTS) + if (ctx->stream_index >= ISAAC_ELEMENTS) { /* Out of elements. Reshuffling and preparing new batch. */ isaac_shuffle(ctx); - ctx->next_index = 0; + ctx->stream_index = 0; } } } diff --git a/tst/test_init.c b/tst/test_init.c index c146752..c3d196c 100644 --- a/tst/test_init.c +++ b/tst/test_init.c @@ -13,7 +13,7 @@ #if ISAAC_BITS > 32 const static isaac_ctx_t zero_initialised_ctx = { - .next_index = 0, + .stream_index = 0, .a = 0xCE150DF74800329AULL, .b = 0x9D39247E33776D41ULL, .c = 0x0000000000000001ULL, @@ -280,7 +280,7 @@ const static isaac_ctx_t zero_initialised_ctx = { }; const static isaac_ctx_t nonzero_initialised_ctx = { - .next_index = 0, + .stream_index = 0, .a = 0x206E5B8744408867ULL, .b = 0x0F5268BA58C45B3DULL, .c = 0x0000000000000001ULL, @@ -549,7 +549,7 @@ const static isaac_ctx_t nonzero_initialised_ctx = { #else const static isaac_ctx_t zero_initialised_ctx = { - .next_index = 0, + .stream_index = 0, .a = 0x44D22B48UL, .b = 0x182600F3UL, .c = 0x00000001UL, @@ -688,7 +688,7 @@ const static isaac_ctx_t zero_initialised_ctx = { }; const static isaac_ctx_t nonzero_initialised_ctx = { - .next_index = 0, + .stream_index = 0, .a = 0xD131EDD6UL, .b = 0x23956226UL, .c = 0x00000001UL, diff --git a/tst/test_stream.c b/tst/test_stream.c index d2d0508..e4d281b 100644 --- a/tst/test_stream.c +++ b/tst/test_stream.c @@ -610,7 +610,7 @@ static void test_stream_with_zero_seed(void) atto_eq(stream[0], expected_stream_with_zero_seed[0]); atto_memeq(stream, expected_stream_with_zero_seed, 300 * sizeof(isaac_uint_t)); - atto_eq(ctx.next_index, 300 - 256); + atto_eq(ctx.stream_index, 300 - 256); } static void test_stream_with_zero_seed_multiple_calls(void) @@ -627,7 +627,7 @@ static void test_stream_with_zero_seed_multiple_calls(void) atto_neq(stream[0], 0); atto_memeq(stream, expected_stream_with_zero_seed, 300 * sizeof(isaac_uint_t)); - atto_eq(ctx.next_index, 300 - 256); + atto_eq(ctx.stream_index, 300 - 256); } static void test_stream_with_nonzero_seed(void) @@ -642,7 +642,7 @@ static void test_stream_with_nonzero_seed(void) atto_neq(stream[0], 0); atto_memeq(stream, expected_stream_with_nonzero_seed, 300 * sizeof(isaac_uint_t)); - atto_eq(ctx.next_index, 300 - 256); + atto_eq(ctx.stream_index, 300 - 256); } static void test_stream_with_nonzero_seed_multiple_calls(void) @@ -660,7 +660,7 @@ static void test_stream_with_nonzero_seed_multiple_calls(void) atto_neq(stream[0], 0); atto_memeq(stream, expected_stream_with_nonzero_seed, 300 * sizeof(isaac_uint_t)); - atto_eq(ctx.next_index, 300 - 256); + atto_eq(ctx.stream_index, 300 - 256); } void test_isaac_next(void) From 209a5211e19c347ad6cae84d1e790656dbc7aa51 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matjaz=CC=8C?= Date: Tue, 28 Apr 2020 21:58:41 +0200 Subject: [PATCH 25/27] Ignore original source code used to generate test vectors --- .gitignore | 1 + CMakeLists.txt | 15 ++--- tst/original/generate32.c | 124 -------------------------------------- 3 files changed, 5 insertions(+), 135 deletions(-) delete mode 100644 tst/original/generate32.c diff --git a/.gitignore b/.gitignore index a16c57e..924cb27 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1,2 @@ cmake-build-*/ +tst/original/ diff --git a/CMakeLists.txt b/CMakeLists.txt index bb83ef9..168b4af 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,9 +1,9 @@ cmake_minimum_required(VERSION 3.5) project(LibISAAC - VERSION 0.1.0 + VERSION 1.0.0 LANGUAGES C DESCRIPTION - "A modern wrapping of the ISAAC CPRNG.") + "A modern reimplementation of the ISAAC CPRNG.") # Unless specified, by default create Release builds if (NOT CMAKE_BUILD_TYPE) @@ -43,11 +43,12 @@ include_directories(inc/) set(LIB_FILES src/isaac.c) include_directories(tst/ tst/atto/) set(TEST_FILES + tst/atto/atto.c tst/test.c tst/test_init.c tst/test_stream.c tst/test_convert.c - tst/atto/atto.c tst/test_cleanup.c) + tst/test_cleanup.c) add_library(isaac32 STATIC ${LIB_FILES}) target_compile_definitions(isaac32 PUBLIC ISAAC_BITS=32) @@ -58,14 +59,6 @@ target_compile_definitions(testisaac32 PUBLIC ISAAC_BITS=32) add_executable(testisaac64 ${LIB_FILES} ${TEST_FILES}) target_compile_definitions(testisaac64 PUBLIC ISAAC_BITS=64) -include_directories(tst/original/) -add_executable("generatevectors32" - tst/original/generate32.c - tst/original/randport.c) -add_executable("generatevectors64" - tst/original/generate64.c - tst/original/isaac64.c) - # Doxygen documentation builder find_package(Doxygen) if (DOXYGEN_FOUND) diff --git a/tst/original/generate32.c b/tst/original/generate32.c deleted file mode 100644 index 955fdc5..0000000 --- a/tst/original/generate32.c +++ /dev/null @@ -1,124 +0,0 @@ -/** - * @file - * - * Code used to generate the test vectors used in other - * test files of LibISAAC. It requires the original implementation of ISAAC, - * that is: - * - rand.h - * - standard.h - * - rand.c or randport.c - * - * Compile into an executable and run it. - * - * @copyright Copyright © 2020, Matjaž Guštin - * . All rights reserved. - * @license BSD 3-clause license. - */ - -#include "standard.h" -#include "rand.h" - -static void print_ctx(const randctx* const ctx) -{ - printf(".next_index = 0x%08XUL,\n", 0); - printf(".a = 0x%08XUL,\n", ctx->randa); - printf(".b = 0x%08XUL,\n", ctx->randb); - printf(".c = 0x%08XUL,\n", ctx->randc); - printf(".result = {"); - for (unsigned int i = 0; i < RANDSIZ; i++) - { - printf("0x%08XUL, ", ctx->randrsl[i]); - } - printf("\n},\n.mem = {"); - for (unsigned int i = 0; i < RANDSIZ; i++) - { - printf("0x%08XUL, ", ctx->randmem[i]); - } - puts("\n}\n\n"); -} - -static void ctx_zero_seed(void) -{ - randctx ctx; - for (unsigned long int i = 0; i < 256; i++) - { - ctx.randrsl[i] = 0; // Zero seed - } - randinit(&ctx, 1); // Init ISAAC with zero seed - puts("Context with zero-initialised seed:"); - print_ctx(&ctx); -} - -static void ctx_nonzero_seed(void) -{ - randctx ctx; - const unsigned char seed[8] = {1, 2, 3, 4, 5, 6, 7, 8}; - unsigned long int i; - for (i = 0; i < 8; i++) - { - ctx.randrsl[i] = seed[i]; // Value-wise copy, not byte-wise - } - for (i = 8; i < 256; i++) - { - ctx.randrsl[i] = 0; // Zero padding - } - randinit(&ctx, 1); // Init ISAAC with a non-zero seed - puts("Context with seed {1,2,3,4,5,6,7,8}:"); - print_ctx(&ctx); -} - -static void stream_from_zero_seed(void) -{ - randctx ctx; - unsigned long int i, j; - for (i = 0; i < 256; i++) - { - ctx.randrsl[i] = 0; // Zero seed - } - randinit(&ctx, 1); // Init ISAAC with zero seed - puts("Getting stream of 512 values from zero seed"); - for (j = 0; j < 2; j++) - { - for (i = 0; i < 256; i++) - { - printf("0x%08XUL, ", ctx.randrsl[i]); - } - isaac(&ctx); - } - puts(""); -} - -static void stream_from_nonzero_seed(void) -{ - randctx ctx; - unsigned long int i, j; - const unsigned char seed[8] = {1, 2, 3, 4, 5, 6, 7, 8}; - for (i = 0; i < 8; i++) - { - ctx.randrsl[i] = seed[i]; // Value-wise copy, not byte-wise - } - for (i = 8; i < 256; i++) - { - ctx.randrsl[i] = 0; // Zero padding - } - randinit(&ctx, 1); // Init ISAAC with non-zero seed - puts("Getting stream of 512 values from non-zero seed"); - for (j = 0; j < 2; j++) - { - for (i = 0; i < 256; i++) - { - printf("0x%08XUL, ", ctx.randrsl[i]); - } - isaac(&ctx); - } - puts(""); -} - -int main(void) -{ - ctx_zero_seed(); - ctx_nonzero_seed(); - stream_from_zero_seed(); - stream_from_nonzero_seed(); - return 0; -} From bc55582e50e3449fbb0f6533acac2692d9599600 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matjaz=CC=8C?= Date: Tue, 28 Apr 2020 22:28:01 +0200 Subject: [PATCH 26/27] Add changelog and readme --- tst/test_init.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/tst/test_init.c b/tst/test_init.c index c3d196c..dd86caa 100644 --- a/tst/test_init.c +++ b/tst/test_init.c @@ -836,6 +836,10 @@ static void test_init_zero_seed(void) atto_eq(sizeof(ctx), sizeof(zero_initialised_ctx)); atto_memeq(&ctx, &zero_initialised_ctx, sizeof(ctx)); + isaac_init(&ctx, NULL, 0); + atto_eq(sizeof(ctx), sizeof(zero_initialised_ctx)); + atto_memeq(&ctx, &zero_initialised_ctx, sizeof(ctx)); + uint8_t dummy[3] = {1, 2, 3}; isaac_init(&ctx, dummy, 0); atto_eq(sizeof(ctx), sizeof(zero_initialised_ctx)); From ec46ab5e9bc31ac6396233d8f021e3105b59e52d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Matjaz=CC=8C?= Date: Tue, 28 Apr 2020 22:28:14 +0200 Subject: [PATCH 27/27] Add changelog and readme --- CHANGELOG.md | 25 +++++++++++ README.md | 125 +++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 150 insertions(+) create mode 100644 CHANGELOG.md create mode 100644 README.md diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..6d660eb --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,25 @@ +Changelog +=============================================================================== + +All notable changes to this project will be documented in this file. + +The format is based on +[Keep a Changelog](https://keepachangelog.com/en/1.0.0/), +and this project adheres to +[Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +******************************************************************************* + +[1.0.0] - 2020-04-28 +---------------------------------------- + +Initial version. + + +### Added + +- ISAAC and ISAAC-64, choose version with `ISAAC_BITS` +- Initialise context +- Generate stream of integers of arbitrary length +- Convert integers to bytes LE/BE +- Cleanup context diff --git a/README.md b/README.md new file mode 100644 index 0000000..52395dd --- /dev/null +++ b/README.md @@ -0,0 +1,125 @@ +ISAAC, the fast CSPRNG, reimplemented in a nicer, documented, modern C11 API +=============================================================================== + +LibISAAC offers the tiny and fast +[ISAAC](https://www.burtleburtle.net/bob/rand/isaacafa.html) cryptographically +secure pseudo random number generator (CSPRNG), in its 32-bit and 64-bit version +wrapped into a modern, ISO C11, documented API, ready for embedded usage. + + + +About ISAAC +---------------------------------------- + +Quoting from [its website](https://www.burtleburtle.net/bob/rand/isaacafa.html): + +> ISAAC (Indirection, Shift, Accumulate, Add, and Count) generates 32-bit +> random numbers. Averaged out, it requires 18.75 machine cycles to +> generate each 32-bit value. Cycles are guaranteed to be at least 240 +> values long, and they are 28295 values long on average. The results are +> uniformly distributed, unbiased, and unpredictable unless you know the +> seed. +> [...] +> ISAAC-64 generates a different sequence than ISAAC, but it uses the same +> principles. It uses 64-bit arithmetic. It generates a 64-bit result every +> 19 instructions. All cycles are at least 272 values, and the average +> cycle length is 216583. + +ISAAC and its original source code (on which this version is based on) +were created by Bob Jenkins and released into the public domain. + + + +Usage example +---------------------------------------- + +```c +// Init the context with a secret seed +isaac_ctx_t ctx; +const uint8_t seed[16] = {1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16}; +isaac_init(&ctx, seed, sizeof(seed)); + +// If you DON'T need ISAAC for security purposes, an all-zero +// seed may also be of interested. Just pass a NULL seed. +isaac_init(&ctx, NULL, 0); + +// Extract ANY amount of pseudo-random integers +isaac_uint_t stream[300] = {0}; +isaac_stream(&ctx, stream, 300); +isaac_uint_t another_stream[5000] = {0}; +isaac_stream(&ctx, stream, 5000); + +// Note that ISAAC provides integers, not bytes. +// If you need bytes, convert the integers to little endian- +// or big endian-encoded stream of bytes. +uint8_t bytes[300 * sizeof(isaac_uint_t)]; +isaac_to_big_endian(bytes, stream, 300); +// or isaac_to_little_endian(bytes, stream, 300); + +// Done using ISAAC? Cleanup the context to avoid leaving traces +// of the state and of the seed. +isaac_cleanup(&ctx); +``` + + + +Include it in your project +---------------------------------------- + +### Bitness + +Depending on your architecture, you may want to use the version of ISAAC +optimised for 32 or 64 bit words. To do so, set the `#define ISAAC_BITS` +to `32` or `64` during compilation or directly in the header file. It defaults +to 64 when unspecified. + +Differences: +- the output differs between the two (it's expected to differ) +- the context grows twice in size when using the 64 bit version + - 32 bit: 2064 B + - 64 bit: 4128 B +- in the 64 bit version, twice the amount of bytes is provided per reshuffling + of the state + +Please note that altering `ISAAC_BITS` does not set your compiler to +compile LibISAAC for a 32 or 64 target architecture, it simply chooses which +integers to use based on **your** choice, not the compiler's. You may want to +choose the best version for your system, but you can compile both versions on +any system. + +Examples: + +- a 32-bit microcontroller works best with `ISAAC_BITS=32` +- a 64-bit desktop works best with `ISAAC_BITS=64` +- a 64-bit desktop that has to test the output of ISAAC coming from a 32-bit + microcontroller (assuming the same seed is known to both), should compile with + `ISAAC=BITS=32` to get the same output. + + +### Static source inclusion + +Copy the `inc/isaac.h` and `src/isaac.c` files into your existing +C project, add them to the source folders and compile.. + +If you prefer a specific bitness, redefine `ISAAC_BITS` in the header file. + + +### Compiling into all possible targets + +``` +mkdir build && cd build +cmake .. -DCMAKE_BUILD_TYPE=Release -DISAAC_BITS=32 +cmake --build . +``` + +This will build all targets: + +- a `libisaac32.a` static library +- a test runner executable `testisaac32` +- the Doxygen documentation (if Doxygen is installed) + +To compile with the optimisation for size, use the +`-DCMAKE_BUILD_TYPE=MinSizeRel` flag instead. + +If you prefer using 64 bit integers, set `-DISAAC_BITS=64`.