sha3-ruby 0.0.1

data/ext/sha3/KeccakReferenceAndOptimized/Sources/brg_endian.h

@@ -0,0 +1,142 @@
+/*
+ ---------------------------------------------------------------------------
+ Copyright (c) 1998-2008, Brian Gladman, Worcester, UK. All rights reserved.
+
+ LICENSE TERMS
+
+ The redistribution and use of this software (with or without changes)
+ is allowed without the payment of fees or royalties provided that:
+
+  1. source code distributions include the above copyright notice, this
+     list of conditions and the following disclaimer;
+
+  2. binary distributions include the above copyright notice, this list
+     of conditions and the following disclaimer in their documentation;
+
+  3. the name of the copyright holder is not used to endorse products
+     built using this software without specific written permission.
+
+ DISCLAIMER
+
+ This software is provided 'as is' with no explicit or implied warranties
+ in respect of its properties, including, but not limited to, correctness
+ and/or fitness for purpose.
+ ---------------------------------------------------------------------------
+ Issue Date: 20/12/2007
+ Changes for ARM 9/9/2010
+*/
+
+#ifndef _BRG_ENDIAN_H
+#define _BRG_ENDIAN_H
+
+#define IS_BIG_ENDIAN      4321 /* byte 0 is most significant (mc68k) */
+#define IS_LITTLE_ENDIAN   1234 /* byte 0 is least significant (i386) */
+
+#if 0
+/* Include files where endian defines and byteswap functions may reside */
+#if defined( __sun )
+#  include <sys/isa_defs.h>
+#elif defined( __FreeBSD__ ) || defined( __OpenBSD__ ) || defined( __NetBSD__ )
+#  include <sys/endian.h>
+#elif defined( BSD ) && ( BSD >= 199103 ) || defined( __APPLE__ ) || \
+      defined( __CYGWIN32__ ) || defined( __DJGPP__ ) || defined( __osf__ )
+#  include <machine/endian.h>
+#elif defined( __linux__ ) || defined( __GNUC__ ) || defined( __GNU_LIBRARY__ )
+#  if !defined( __MINGW32__ ) && !defined( _AIX )
+#    include <endian.h>
+#    if !defined( __BEOS__ )
+#      include <byteswap.h>
+#    endif
+#  endif
+#endif
+#endif
+
+/* Now attempt to set the define for platform byte order using any  */
+/* of the four forms SYMBOL, _SYMBOL, __SYMBOL & __SYMBOL__, which  */
+/* seem to encompass most endian symbol definitions                 */
+
+#if defined( BIG_ENDIAN ) && defined( LITTLE_ENDIAN )
+#  if defined( BYTE_ORDER ) && BYTE_ORDER == BIG_ENDIAN
+#    define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#  elif defined( BYTE_ORDER ) && BYTE_ORDER == LITTLE_ENDIAN
+#    define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#  endif
+#elif defined( BIG_ENDIAN )
+#  define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#elif defined( LITTLE_ENDIAN )
+#  define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#endif
+
+#if defined( _BIG_ENDIAN ) && defined( _LITTLE_ENDIAN )
+#  if defined( _BYTE_ORDER ) && _BYTE_ORDER == _BIG_ENDIAN
+#    define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#  elif defined( _BYTE_ORDER ) && _BYTE_ORDER == _LITTLE_ENDIAN
+#    define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#  endif
+#elif defined( _BIG_ENDIAN )
+#  define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#elif defined( _LITTLE_ENDIAN )
+#  define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#endif
+
+#if defined( __BIG_ENDIAN ) && defined( __LITTLE_ENDIAN )
+#  if defined( __BYTE_ORDER ) && __BYTE_ORDER == __BIG_ENDIAN
+#    define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#  elif defined( __BYTE_ORDER ) && __BYTE_ORDER == __LITTLE_ENDIAN
+#    define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#  endif
+#elif defined( __BIG_ENDIAN )
+#  define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#elif defined( __LITTLE_ENDIAN )
+#  define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#endif
+
+#if defined( __BIG_ENDIAN__ ) && defined( __LITTLE_ENDIAN__ )
+#  if defined( __BYTE_ORDER__ ) && __BYTE_ORDER__ == __BIG_ENDIAN__
+#    define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#  elif defined( __BYTE_ORDER__ ) && __BYTE_ORDER__ == __LITTLE_ENDIAN__
+#    define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#  endif
+#elif defined( __BIG_ENDIAN__ )
+#  define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#elif defined( __LITTLE_ENDIAN__ )
+#  define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#endif
+
+/*  if the platform byte order could not be determined, then try to */
+/*  set this define using common machine defines                    */
+#if !defined(PLATFORM_BYTE_ORDER)
+
+#if   defined( __alpha__ ) || defined( __alpha ) || defined( i386 )       || \
+      defined( __i386__ )  || defined( _M_I86 )  || defined( _M_IX86 )    || \
+      defined( __OS2__ )   || defined( sun386 )  || defined( __TURBOC__ ) || \
+      defined( vax )       || defined( vms )     || defined( VMS )        || \
+      defined( __VMS )     || defined( _M_X64 )
+#  define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+
+#elif defined( AMIGA )   || defined( applec )    || defined( __AS400__ )  || \
+      defined( _CRAY )   || defined( __hppa )    || defined( __hp9000 )   || \
+      defined( ibm370 )  || defined( mc68000 )   || defined( m68k )       || \
+      defined( __MRC__ ) || defined( __MVS__ )   || defined( __MWERKS__ ) || \
+      defined( sparc )   || defined( __sparc)    || defined( SYMANTEC_C ) || \
+      defined( __VOS__ ) || defined( __TIGCC__ ) || defined( __TANDEM )   || \
+      defined( THINK_C ) || defined( __VMCMS__ ) || defined( _AIX )
+#  define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+
+#elif defined(__arm__)
+# ifdef __BIG_ENDIAN
+#  define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+# else
+#  define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+# endif
+#elif 1     /* **** EDIT HERE IF NECESSARY **** */
+#  define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#elif 0     /* **** EDIT HERE IF NECESSARY **** */
+#  define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#else
+#  error Please edit lines 132 or 134 in brg_endian.h to set the platform byte order
+#endif
+
+#endif
+
+#endif

data/ext/sha3/KeccakReferenceAndOptimized/Sources/displayIntermediateValues.c

@@ -0,0 +1,117 @@
+/*
+The Keccak sponge function, designed by Guido Bertoni, Joan Daemen,
+Michaël Peeters and Gilles Van Assche. For more information, feedback or
+questions, please refer to our website: http://keccak.noekeon.org/
+
+Implementation by the designers,
+hereby denoted as "the implementer".
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#include <stdio.h>
+#include "displayIntermediateValues.h"
+#include "KeccakNISTInterface.h"
+
+FILE *intermediateValueFile = 0;
+int displayLevel = 0;
+
+void displaySetIntermediateValueFile(FILE *f)
+{
+    intermediateValueFile = f;
+}
+
+void displaySetLevel(int level)
+{
+    displayLevel = level;
+}
+
+void displayBytes(int level, const char *text, const unsigned char *bytes, unsigned int size)
+{
+    unsigned int i;
+
+    if ((intermediateValueFile) && (level <= displayLevel)) {
+        fprintf(intermediateValueFile, "%s:\n", text);
+        for(i=0; i<size; i++)
+            fprintf(intermediateValueFile, "%02X ", bytes[i]);
+        fprintf(intermediateValueFile, "\n");
+        fprintf(intermediateValueFile, "\n");
+    }
+}
+
+void displayBits(int level, const char *text, const unsigned char *data, unsigned int size, int MSBfirst)
+{
+    unsigned int i, iByte, iBit;
+
+    if ((intermediateValueFile) && (level <= displayLevel)) {
+        fprintf(intermediateValueFile, "%s:\n", text);
+        for(i=0; i<size; i++) {
+            iByte = i/8;
+            iBit = i%8;
+            if (MSBfirst)
+                fprintf(intermediateValueFile, "%d ", ((data[iByte] << iBit) & 0x80) != 0);
+            else
+                fprintf(intermediateValueFile, "%d ", ((data[iByte] >> iBit) & 0x01) != 0);
+        }
+        fprintf(intermediateValueFile, "\n");
+        fprintf(intermediateValueFile, "\n");
+    }
+}
+
+void displayStateAsBytes(int level, const char *text, const unsigned char *state)
+{
+    displayBytes(level, text, state, KeccakPermutationSizeInBytes);
+}
+
+void displayStateAs32bitWords(int level, const char *text, const unsigned int *state)
+{
+    unsigned int i;
+
+    if ((intermediateValueFile) && (level <= displayLevel)) {
+        fprintf(intermediateValueFile, "%s:\n", text);
+        for(i=0; i<KeccakPermutationSize/64; i++) {
+            fprintf(intermediateValueFile, "%08X:%08X", (unsigned int)state[2*i+0], (unsigned int)state[2*i+1]);
+            if ((i%5) == 4)
+                fprintf(intermediateValueFile, "\n");
+            else
+                fprintf(intermediateValueFile, " ");
+        }
+    }
+}
+
+void displayStateAs64bitWords(int level, const char *text, const unsigned long long int *state)
+{
+    unsigned int i;
+
+    if ((intermediateValueFile) && (level <= displayLevel)) {
+        fprintf(intermediateValueFile, "%s:\n", text);
+        for(i=0; i<KeccakPermutationSize/64; i++) {
+            fprintf(intermediateValueFile, "%08X", (unsigned int)(state[i] >> 32));
+            fprintf(intermediateValueFile, "%08X", (unsigned int)(state[i] & 0xFFFFFFFFULL));
+            if ((i%5) == 4)
+                fprintf(intermediateValueFile, "\n");
+            else
+                fprintf(intermediateValueFile, " ");
+        }
+    }
+}
+
+void displayRoundNumber(int level, unsigned int i)
+{
+    if ((intermediateValueFile) && (level <= displayLevel)) {
+        fprintf(intermediateValueFile, "\n");
+        fprintf(intermediateValueFile, "--- Round %d ---\n", i);
+        fprintf(intermediateValueFile, "\n");
+    }
+}
+
+void displayText(int level, const char *text)
+{
+    if ((intermediateValueFile) && (level <= displayLevel)) {
+        fprintf(intermediateValueFile, text);
+        fprintf(intermediateValueFile, "\n");
+        fprintf(intermediateValueFile, "\n");
+    }
+}

data/ext/sha3/KeccakReferenceAndOptimized/Sources/displayIntermediateValues.h

@@ -0,0 +1,29 @@
+/*
+The Keccak sponge function, designed by Guido Bertoni, Joan Daemen,
+Michaël Peeters and Gilles Van Assche. For more information, feedback or
+questions, please refer to our website: http://keccak.noekeon.org/
+
+Implementation by the designers,
+hereby denoted as "the implementer".
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#ifndef _displayIntermediateValues_h_
+#define _displayIntermediateValues_h_
+
+#include <stdio.h>
+
+void displaySetIntermediateValueFile(FILE *f);
+void displaySetLevel(int level);
+void displayBytes(int level, const char *text, const unsigned char *bytes, unsigned int size);
+void displayBits(int level, const char *text, const unsigned char *data, unsigned int size, int MSBfirst);
+void displayStateAsBytes(int level, const char *text, const unsigned char *state);
+void displayStateAs32bitWords(int level, const char *text, const unsigned int *state);
+void displayStateAs64bitWords(int level, const char *text, const unsigned long long int *state);
+void displayRoundNumber(int level, unsigned int i);
+void displayText(int level, const char *text);
+
+#endif

data/ext/sha3/KeccakReferenceAndOptimized/Sources/genKAT.c

@@ -0,0 +1,692 @@
+/*
+The Keccak sponge function, designed by Guido Bertoni, Joan Daemen,
+Michaël Peeters and Gilles Van Assche. For more information, feedback or
+questions, please refer to our website: http://keccak.noekeon.org/
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <ctype.h>
+
+#include "KeccakDuplex.h"
+#include "KeccakNISTInterface.h"
+#include "KeccakSponge.h"
+
+#define MAX_MARKER_LEN      50
+#define SUBMITTER_INFO_LEN  128
+
+typedef enum { KAT_SUCCESS = 0, KAT_FILE_OPEN_ERROR = 1, KAT_HEADER_ERROR = 2, KAT_DATA_ERROR = 3, KAT_HASH_ERROR = 4 } STATUS_CODES;
+
+#define AllowExtendedFunctions
+#define ExcludeExtremelyLong
+
+#ifdef AllowExtendedFunctions
+#define SqueezingOutputLength 4096
+#endif
+
+STATUS_CODES    genShortMsg(int hashbitlen);
+STATUS_CODES    genLongMsg(int hashbitlen);
+STATUS_CODES    genExtremelyLongMsg(int hashbitlen);
+STATUS_CODES    genMonteCarlo(int hashbitlen);
+#ifdef AllowExtendedFunctions
+STATUS_CODES    genMonteCarloSqueezing(int hashbitlen);
+STATUS_CODES    genShortMsgSponge(unsigned int rate, unsigned int capacity, int outputLength, const char *fileName);
+STATUS_CODES    genDuplexKAT(unsigned int rate, unsigned int capacity, const char *fileName);
+#endif
+int     FindMarker(FILE *infile, const char *marker);
+int     ReadHex(FILE *infile, BitSequence *A, int Length, char *str);
+void    fprintBstr(FILE *fp, char *S, BitSequence *A, int L);
+
+
+STATUS_CODES
+genKAT_main()
+{
+    int     i, ret_val,  bitlens[4] = { 224, 256, 384, 512 };
+
+#ifdef AllowExtendedFunctions
+    if ( (ret_val = genShortMsgSponge(1024, 576, 4096, "ShortMsgKAT_0.txt")) != KAT_SUCCESS )
+        return (STATUS_CODES)ret_val;
+    if ( (ret_val = genLongMsg(0)) != KAT_SUCCESS )
+        return (STATUS_CODES)ret_val;
+#ifndef ExcludeExtremelyLong
+    if ( (ret_val = genExtremelyLongMsg(0)) != KAT_SUCCESS )
+        return (STATUS_CODES)ret_val;
+#endif
+    if ( (ret_val = genMonteCarloSqueezing(0)) != KAT_SUCCESS )
+        return (STATUS_CODES)ret_val;
+#endif
+
+    for ( i=0; i<4; i++ ) {
+        if ( (ret_val = genShortMsg(bitlens[i])) != KAT_SUCCESS )
+            return (STATUS_CODES)ret_val;
+        if ( (ret_val = genLongMsg(bitlens[i])) != KAT_SUCCESS )
+            return (STATUS_CODES)ret_val;
+#ifndef ExcludeExtremelyLong
+        if ( (ret_val = genExtremelyLongMsg(bitlens[i])) != KAT_SUCCESS )
+            return (STATUS_CODES)ret_val;
+#endif
+        if ( (ret_val = genMonteCarlo(bitlens[i])) != KAT_SUCCESS )
+            return (STATUS_CODES)ret_val;
+    }
+
+#ifdef AllowExtendedFunctions
+    /* Other case examples */
+    genShortMsgSponge(1344, 256, 4096, "ShortMsgKAT_r1344c256.txt");
+    /* Duplexing */
+    //genDuplexKAT(1024, 576, "DuplexKAT_r1024c576.txt");
+    //genDuplexKAT(1025, 575, "DuplexKAT_r1025c575.txt");
+    genDuplexKAT(1026, 574, "DuplexKAT_r1026c574.txt");
+    genDuplexKAT(1027, 573, "DuplexKAT_r1027c573.txt");
+    //genDuplexKAT(1028, 572, "DuplexKAT_r1028c572.txt");
+    //genDuplexKAT(1029, 571, "DuplexKAT_r1029c571.txt");
+    //genDuplexKAT(1030, 570, "DuplexKAT_r1030c570.txt");
+    //genDuplexKAT(1031, 569, "DuplexKAT_r1031c569.txt");
+    //genDuplexKAT(1032, 568, "DuplexKAT_r1032c568.txt");
+#endif
+
+    return KAT_SUCCESS;
+}
+
+STATUS_CODES
+genShortMsg(int hashbitlen)
+{
+    char        fn[32], line[SUBMITTER_INFO_LEN];
+    int         msglen, msgbytelen, done;
+    BitSequence Msg[256], MD[64];
+    FILE        *fp_in, *fp_out;
+    
+    if ( (fp_in = fopen("ShortMsgKAT.txt", "r")) == NULL ) {
+        printf("Couldn't open <ShortMsgKAT.txt> for read\n");
+        return KAT_FILE_OPEN_ERROR;
+    }
+    
+    sprintf(fn, "ShortMsgKAT_%d.txt", hashbitlen);
+    if ( (fp_out = fopen(fn, "w")) == NULL ) {
+        printf("Couldn't open <%s> for write\n", fn);
+        return KAT_FILE_OPEN_ERROR;
+    }
+    fprintf(fp_out, "# %s\n", fn);
+    if ( FindMarker(fp_in, "# Algorithm Name:") ) {
+        fscanf(fp_in, "%[^\n]\n", line);
+        fprintf(fp_out, "# Algorithm Name:%s\n", line);
+    }
+    else {
+        printf("genShortMsg: Couldn't read Algorithm Name\n");
+        return KAT_HEADER_ERROR;
+    }
+    if ( FindMarker(fp_in, "# Principal Submitter:") ) {
+        fscanf(fp_in, "%[^\n]\n", line);
+        fprintf(fp_out, "# Principal Submitter:%s\n", line);
+    }
+    else {
+        printf("genShortMsg: Couldn't read Principal Submitter\n");
+        return KAT_HEADER_ERROR;
+    }
+    
+    done = 0;
+    do {
+        if ( FindMarker(fp_in, "Len = ") )
+            fscanf(fp_in, "%d", &msglen);
+        else {
+            done = 1;
+            break;
+        }
+        msgbytelen = (msglen+7)/8;
+
+        if ( !ReadHex(fp_in, Msg, msgbytelen, "Msg = ") ) {
+            printf("ERROR: unable to read 'Msg' from <ShortMsgKAT.txt>\n");
+            return KAT_DATA_ERROR;
+        }
+        Hash(hashbitlen, Msg, msglen, MD);
+        fprintf(fp_out, "\nLen = %d\n", msglen);
+        fprintBstr(fp_out, "Msg = ", Msg, msgbytelen);
+        fprintBstr(fp_out, "MD = ", MD, hashbitlen/8);
+    } while ( !done );
+    printf("finished ShortMsgKAT for <%d>\n", hashbitlen);
+    
+    fclose(fp_in);
+    fclose(fp_out);
+    
+    return KAT_SUCCESS;
+}
+
+#ifdef AllowExtendedFunctions
+STATUS_CODES
+genShortMsgSponge(unsigned int rate, unsigned int capacity, int outputLength, const char *fileName)
+{
+    char        line[SUBMITTER_INFO_LEN];
+    int         msglen, msgbytelen, done;
+    BitSequence Msg[256];
+    BitSequence Squeezed[SqueezingOutputLength/8];
+    spongeState   state;
+    FILE        *fp_in, *fp_out;
+    
+    if (outputLength > SqueezingOutputLength) {
+        printf("Requested output length too long.\n");
+        return KAT_HASH_ERROR;
+    }
+
+    if ( (fp_in = fopen("ShortMsgKAT.txt", "r")) == NULL ) {
+        printf("Couldn't open <ShortMsgKAT.txt> for read\n");
+        return KAT_FILE_OPEN_ERROR;
+    }
+    
+    if ( (fp_out = fopen(fileName, "w")) == NULL ) {
+        printf("Couldn't open <%s> for write\n", fileName);
+        return KAT_FILE_OPEN_ERROR;
+    }
+    fprintf(fp_out, "# %s\n", fileName);
+    if ( FindMarker(fp_in, "# Algorithm Name:") ) {
+        fscanf(fp_in, "%[^\n]\n", line);
+        fprintf(fp_out, "# Algorithm Name:%s\n", line);
+    }
+    else {
+        printf("genShortMsg: Couldn't read Algorithm Name\n");
+        return KAT_HEADER_ERROR;
+    }
+    if ( FindMarker(fp_in, "# Principal Submitter:") ) {
+        fscanf(fp_in, "%[^\n]\n", line);
+        fprintf(fp_out, "# Principal Submitter:%s\n", line);
+    }
+    else {
+        printf("genShortMsg: Couldn't read Principal Submitter\n");
+        return KAT_HEADER_ERROR;
+    }
+    
+    done = 0;
+    do {
+        if ( FindMarker(fp_in, "Len = ") )
+            fscanf(fp_in, "%d", &msglen);
+        else {
+            done = 1;
+            break;
+        }
+        msgbytelen = (msglen+7)/8;
+
+        if ( !ReadHex(fp_in, Msg, msgbytelen, "Msg = ") ) {
+            printf("ERROR: unable to read 'Msg' from <ShortMsgKAT.txt>\n");
+            return KAT_DATA_ERROR;
+        }
+        fprintf(fp_out, "\nLen = %d\n", msglen);
+        fprintBstr(fp_out, "Msg = ", Msg, msgbytelen);
+        InitSponge(&state, rate, capacity);
+        if ((msglen % 8 ) != 0)
+            // From NIST convention to internal convention for last byte
+            Msg[msgbytelen - 1] >>= 8 - (msglen % 8);
+        Absorb(&state, Msg, msglen);
+        Squeeze(&state, Squeezed, outputLength);
+        fprintBstr(fp_out, "Squeezed = ", Squeezed, SqueezingOutputLength/8);
+    } while ( !done );
+    printf("finished ShortMsgKAT for <%s>\n", fileName);
+    
+    fclose(fp_in);
+    fclose(fp_out);
+    
+    return KAT_SUCCESS;
+}
+#endif
+
+STATUS_CODES
+genLongMsg(int hashbitlen)
+{
+    char        fn[32], line[SUBMITTER_INFO_LEN];
+    int         msglen, msgbytelen, done;
+    BitSequence Msg[4288], MD[64];
+#ifdef AllowExtendedFunctions
+    BitSequence Squeezed[SqueezingOutputLength/8];
+    hashState   state;
+#endif
+    FILE        *fp_in, *fp_out;
+    
+    if ( (fp_in = fopen("LongMsgKAT.txt", "r")) == NULL ) {
+        printf("Couldn't open <LongMsgKAT.txt> for read\n");
+        return KAT_FILE_OPEN_ERROR;
+    }
+    
+    sprintf(fn, "LongMsgKAT_%d.txt", hashbitlen);
+    if ( (fp_out = fopen(fn, "w")) == NULL ) {
+        printf("Couldn't open <%s> for write\n", fn);
+        return KAT_FILE_OPEN_ERROR;
+    }
+    fprintf(fp_out, "# %s\n", fn);
+    if ( FindMarker(fp_in, "# Algorithm Name:") ) {
+        fscanf(fp_in, "%[^\n]\n", line);
+        fprintf(fp_out, "# Algorithm Name:%s\n", line);
+    }
+    else {
+        printf("genLongMsg: Couldn't read Algorithm Name\n");
+        return KAT_HEADER_ERROR;
+    }
+    if ( FindMarker(fp_in, "# Principal Submitter:") ) {
+        fscanf(fp_in, "%[^\n]\n", line);
+        fprintf(fp_out, "# Principal Submitter:%s\n\n", line);
+    }
+    else {
+        printf("genLongMsg: Couldn't read Principal Submitter\n");
+        return KAT_HEADER_ERROR;
+    }
+    
+    done = 0;
+    do {
+        if ( FindMarker(fp_in, "Len = ") )
+            fscanf(fp_in, "%d", &msglen);
+        else
+            break;
+        msgbytelen = (msglen+7)/8;
+
+        if ( !ReadHex(fp_in, Msg, msgbytelen, "Msg = ") ) {
+            printf("ERROR: unable to read 'Msg' from <LongMsgKAT.txt>\n");
+            return KAT_DATA_ERROR;
+        }
+#ifdef AllowExtendedFunctions
+        if (hashbitlen > 0)
+            Hash(hashbitlen, Msg, msglen, MD);
+        else {
+            Init(&state, hashbitlen);
+            Update(&state, Msg, msglen);
+            Final(&state, 0);
+            Squeeze(&state, Squeezed, SqueezingOutputLength);
+        }
+#else
+        Hash(hashbitlen, Msg, msglen, MD);
+#endif
+        fprintf(fp_out, "Len = %d\n", msglen);
+        fprintBstr(fp_out, "Msg = ", Msg, msgbytelen);
+#ifdef AllowExtendedFunctions
+        if (hashbitlen > 0)
+            fprintBstr(fp_out, "MD = ", MD, hashbitlen/8);
+        else
+            fprintBstr(fp_out, "Squeezed = ", Squeezed, SqueezingOutputLength/8);
+#else
+        fprintBstr(fp_out, "MD = ", MD, hashbitlen/8);
+#endif
+    } while ( !done );
+    printf("finished LongMsgKAT for <%d>\n", hashbitlen);
+    
+    fclose(fp_in);
+    fclose(fp_out);
+    
+    return KAT_SUCCESS;
+}
+
+STATUS_CODES
+genExtremelyLongMsg(int hashbitlen)
+{
+    char        fn[32], line[SUBMITTER_INFO_LEN];
+    BitSequence Text[65], MD[64];
+#ifdef AllowExtendedFunctions
+    BitSequence Squeezed[SqueezingOutputLength/8];
+#endif
+    int         i, repeat;
+    FILE        *fp_in, *fp_out;
+    hashState   state;
+    HashReturn  retval;
+    
+    if ( (fp_in = fopen("ExtremelyLongMsgKAT.txt", "r")) == NULL ) {
+        printf("Couldn't open <ExtremelyLongMsgKAT.txt> for read\n");
+        return KAT_FILE_OPEN_ERROR;
+    }
+    
+    sprintf(fn, "ExtremelyLongMsgKAT_%d.txt", hashbitlen);
+    if ( (fp_out = fopen(fn, "w")) == NULL ) {
+        printf("Couldn't open <%s> for write\n", fn);
+        return KAT_FILE_OPEN_ERROR;
+    }
+    fprintf(fp_out, "# %s\n", fn);
+    if ( FindMarker(fp_in, "# Algorithm Name:") ) {
+        fscanf(fp_in, "%[^\n]\n", line);
+        fprintf(fp_out, "# Algorithm Name:%s\n", line);
+    }
+    else {
+        printf("genExtremelyLongMsg: Couldn't read Algorithm Name\n");
+        return KAT_HEADER_ERROR;
+    }
+    if ( FindMarker(fp_in, "# Principal Submitter:") ) {
+        fscanf(fp_in, "%[^\n]\n", line);
+        fprintf(fp_out, "# Principal Submitter:%s\n\n", line);
+    }
+    else {
+        printf("genExtremelyLongMsg: Couldn't read Principal Submitter\n");
+        return KAT_HEADER_ERROR;
+    }
+    
+    if ( FindMarker(fp_in, "Repeat = ") )
+        fscanf(fp_in, "%d", &repeat);
+    else {
+        printf("ERROR: unable to read 'Repeat' from <ExtremelyLongMsgKAT.txt>\n");
+        return KAT_DATA_ERROR;
+    }
+    
+    if ( FindMarker(fp_in, "Text = ") )
+        fscanf(fp_in, "%s", Text);
+    else {
+        printf("ERROR: unable to read 'Text' from <ExtremelyLongMsgKAT.txt>\n");
+        return KAT_DATA_ERROR;
+    }
+    
+//  memcpy(Text, "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmno", 64);
+    
+    if ( (retval = Init(&state, hashbitlen)) != KAT_SUCCESS ) {
+        printf("Init returned <%d> in genExtremelyLongMsg\n", retval);
+        return KAT_HASH_ERROR;
+    }
+    for ( i=0; i<repeat; i++ )
+        if ( (retval = Update(&state, Text, 512)) != KAT_SUCCESS ) {
+            printf("Update returned <%d> in genExtremelyLongMsg\n", retval);
+            return KAT_HASH_ERROR;
+        }
+    if ( (retval = Final(&state, MD)) != KAT_SUCCESS ) {
+        printf("Final returned <%d> in genExtremelyLongMsg\n", retval);
+        return KAT_HASH_ERROR;
+    }
+#ifdef AllowExtendedFunctions
+    if (hashbitlen == 0)
+        Squeeze(&state, Squeezed, SqueezingOutputLength);
+#endif
+    fprintf(fp_out, "Repeat = %d\n", repeat);
+    fprintf(fp_out, "Text = %s\n", Text);
+#ifdef AllowExtendedFunctions
+    if (hashbitlen > 0)
+        fprintBstr(fp_out, "MD = ", MD, hashbitlen/8);
+    else
+        fprintBstr(fp_out, "Squeezed = ", Squeezed, SqueezingOutputLength/8);
+#else
+    fprintBstr(fp_out, "MD = ", MD, hashbitlen/8);
+#endif
+    printf("finished ExtremelyLongMsgKAT for <%d>\n", hashbitlen);
+    
+    fclose(fp_in);
+    fclose(fp_out);
+    
+    return KAT_SUCCESS;
+}
+
+STATUS_CODES
+genMonteCarlo(int hashbitlen)
+{
+    char        fn[32], line[SUBMITTER_INFO_LEN];
+    BitSequence Seed[128], Msg[128], MD[64], Temp[128];
+    int         i, j, bytelen;
+    FILE        *fp_in, *fp_out;
+    
+    if ( (fp_in = fopen("MonteCarlo.txt", "r")) == NULL ) {
+        printf("Couldn't open <MonteCarlo.txt> for read\n");
+        return KAT_FILE_OPEN_ERROR;
+    }
+    
+    sprintf(fn, "MonteCarlo_%d.txt", hashbitlen);
+    if ( (fp_out = fopen(fn, "w")) == NULL ) {
+        printf("Couldn't open <%s> for write\n", fn);
+        return KAT_FILE_OPEN_ERROR;
+    }
+    fprintf(fp_out, "# %s\n", fn);
+    if ( FindMarker(fp_in, "# Algorithm Name:") ) {
+        fscanf(fp_in, "%[^\n]\n", line);
+        fprintf(fp_out, "# Algorithm Name:%s\n", line);
+    }
+    else {
+        printf("genMonteCarlo: Couldn't read Algorithm Name\n");
+        return KAT_HEADER_ERROR;
+    }
+    if ( FindMarker(fp_in, "# Principal Submitter:") ) {
+        fscanf(fp_in, "%[^\n]\n", line);
+        fprintf(fp_out, "# Principal Submitter:%s\n\n", line);
+    }
+    else {
+        printf("genMonteCarlo: Couldn't read Principal Submitter\n");
+        return KAT_HEADER_ERROR;
+    }
+    
+    if ( !ReadHex(fp_in, Seed, 128, "Seed = ") ) {
+        printf("ERROR: unable to read 'Seed' from <MonteCarlo.txt>\n");
+        return KAT_DATA_ERROR;
+    }
+    
+    bytelen = hashbitlen / 8;
+    memcpy(Msg, Seed, 128);
+    fprintBstr(fp_out, "Seed = ", Seed, 128);
+    for ( j=0; j<100; j++ ) {
+        for ( i=0; i<1000; i++ ) {
+            Hash(hashbitlen, Msg, 1024, MD);
+            memcpy(Temp, Msg, 128-bytelen);
+            memcpy(Msg, MD, bytelen);
+            memcpy(Msg+bytelen, Temp, 128-bytelen);
+        }
+        fprintf(fp_out, "\nj = %d\n", j);
+        fprintBstr(fp_out, "MD = ", MD, bytelen);
+    }
+    printf("finished MonteCarloKAT for <%d>\n", hashbitlen);
+
+    fclose(fp_in);
+    fclose(fp_out);
+    
+    return KAT_SUCCESS;
+}
+
+#ifdef AllowExtendedFunctions
+STATUS_CODES
+genMonteCarloSqueezing(int hashbitlen)
+{
+    char        fn[32], line[SUBMITTER_INFO_LEN];
+    BitSequence Seed[128], MD[64];
+    int         i, j, bytelen;
+    FILE        *fp_in, *fp_out;
+    hashState   state;
+    HashReturn  retval;
+    
+    if ( (fp_in = fopen("MonteCarlo.txt", "r")) == NULL ) {
+        printf("Couldn't open <MonteCarlo.txt> for read\n");
+        return KAT_FILE_OPEN_ERROR;
+    }
+    
+    sprintf(fn, "MonteCarlo_%d.txt", hashbitlen);
+    if ( (fp_out = fopen(fn, "w")) == NULL ) {
+        printf("Couldn't open <%s> for write\n", fn);
+        return KAT_FILE_OPEN_ERROR;
+    }
+    fprintf(fp_out, "# %s\n", fn);
+    if ( FindMarker(fp_in, "# Algorithm Name:") ) {
+        fscanf(fp_in, "%[^\n]\n", line);
+        fprintf(fp_out, "# Algorithm Name:%s\n", line);
+    }
+    else {
+        printf("genMonteCarlo: Couldn't read Algorithm Name\n");
+        return KAT_HEADER_ERROR;
+    }
+    if ( FindMarker(fp_in, "# Principal Submitter:") ) {
+        fscanf(fp_in, "%[^\n]\n", line);
+        fprintf(fp_out, "# Principal Submitter:%s\n\n", line);
+    }
+    else {
+        printf("genMonteCarlo: Couldn't read Principal Submitter\n");
+        return KAT_HEADER_ERROR;
+    }
+    
+    if ( !ReadHex(fp_in, Seed, 128, "Seed = ") ) {
+        printf("ERROR: unable to read 'Seed' from <MonteCarlo.txt>\n");
+        return KAT_DATA_ERROR;
+    }
+    
+    fprintBstr(fp_out, "Seed = ", Seed, 128);
+
+    if ( (retval = Init(&state, hashbitlen)) != KAT_SUCCESS ) {
+        printf("Init returned <%d> in genMonteCarloSqueezing\n", retval);
+        return KAT_HASH_ERROR;
+    }
+    if ( (retval = Update(&state, Seed, 128*8)) != KAT_SUCCESS ) {
+        printf("Update returned <%d> in genMonteCarloSqueezing\n", retval);
+        return KAT_HASH_ERROR;
+    }
+    if ( (retval = Final(&state, 0)) != KAT_SUCCESS ) {
+        printf("Final returned <%d> in genMonteCarloSqueezing\n", retval);
+        return KAT_HASH_ERROR;
+    }
+    bytelen = 64;
+    for ( j=0; j<100; j++ ) {
+        for ( i=0; i<1000; i++ ) {
+            if ( (retval = Squeeze(&state, MD, bytelen*8)) != KAT_SUCCESS ) {
+                printf("Squeeze returned <%d> in genMonteCarloSqueezing\n", retval);
+                return KAT_HASH_ERROR;
+            }
+        }
+        fprintf(fp_out, "\nj = %d\n", j);
+        fprintBstr(fp_out, "MD = ", MD, bytelen);
+    }
+    printf("finished MonteCarloKAT for <%d>\n", hashbitlen);
+
+    fclose(fp_in);
+    fclose(fp_out);
+    
+    return KAT_SUCCESS;
+}
+
+STATUS_CODES
+genDuplexKAT(unsigned int rate, unsigned int capacity, const char *fileName)
+{
+    int inLen, inByteLen, outLen, outByteLen, done;
+    BitSequence in[256];
+    BitSequence out[256];
+    FILE *fp_in, *fp_out;
+    duplexState   state;
+    
+    if ( (fp_in = fopen("DuplexKAT.txt", "r")) == NULL ) {
+        printf("Couldn't open <DuplexKAT.txt> for read\n");
+        return KAT_FILE_OPEN_ERROR;
+    }
+    
+    if ( (fp_out = fopen(fileName, "w")) == NULL ) {
+        printf("Couldn't open <%s> for write\n", fileName);
+        return KAT_FILE_OPEN_ERROR;
+    }
+    fprintf(fp_out, "# %s\n", fileName);
+    fprintf(fp_out, "# Algorithm: Duplex[f=Keccak-f[1600], pad=pad10*1, r=%d, c=%d, \xCF\x81max=%d]\n", rate, capacity, rate-2);
+  
+    InitDuplex(&state, rate, capacity);
+    done = 0;
+    outLen = rate;
+    outByteLen = (outLen+7)/8;
+    do {
+        if ( FindMarker(fp_in, "InLen = ") )
+            fscanf(fp_in, "%d", &inLen);
+        else {
+            done = 1;
+            break;
+        }
+        inByteLen = (inLen+7)/8;
+
+        if ( !ReadHex(fp_in, in, inByteLen, "In = ") ) {
+            printf("ERROR: unable to read 'In' from <DuplexKAT.txt>\n");
+            return KAT_DATA_ERROR;
+        }
+        if (inLen <= rate-2) {
+            fprintf(fp_out, "\nInLen = %d\n", inLen);
+            fprintBstr(fp_out, "In = ", in, inByteLen);
+            Duplexing(&state, in, inLen, out, outLen);
+            fprintf(fp_out, "OutLen = %d\n", outLen);
+            fprintBstr(fp_out, "Out = ", out, outByteLen);
+        }
+    } while ( !done );
+    printf("finished DuplexKAT for <%s>\n", fileName);
+    
+    fclose(fp_in);
+    fclose(fp_out);
+    
+    return KAT_SUCCESS;
+}
+#endif
+
+//
+// ALLOW TO READ HEXADECIMAL ENTRY (KEYS, DATA, TEXT, etc.)
+//
+int
+FindMarker(FILE *infile, const char *marker)
+{
+    char    line[MAX_MARKER_LEN];
+    int     i, len;
+
+    len = (int)strlen(marker);
+    if ( len > MAX_MARKER_LEN-1 )
+        len = MAX_MARKER_LEN-1;
+
+    for ( i=0; i<len; i++ )
+        if ( (line[i] = fgetc(infile)) == EOF )
+            return 0;
+    line[len] = '\0';
+
+    while ( 1 ) {
+        if ( !strncmp(line, marker, len) )
+            return 1;
+
+        for ( i=0; i<len-1; i++ )
+            line[i] = line[i+1];
+        if ( (line[len-1] = fgetc(infile)) == EOF )
+            return 0;
+        line[len] = '\0';
+    }
+
+    // shouldn't get here
+    return 0;
+}
+
+//
+// ALLOW TO READ HEXADECIMAL ENTRY (KEYS, DATA, TEXT, etc.)
+//
+int
+ReadHex(FILE *infile, BitSequence *A, int Length, char *str)
+{
+    int         i, ch, started;
+    BitSequence ich;
+
+    if ( Length == 0 ) {
+        A[0] = 0x00;
+        return 1;
+    }
+    memset(A, 0x00, Length);
+    started = 0;
+    if ( FindMarker(infile, str) )
+        while ( (ch = fgetc(infile)) != EOF ) {
+            if ( !isxdigit(ch) ) {
+                if ( !started ) {
+                    if ( ch == '\n' )
+                        break;
+                    else
+                        continue;
+                }
+                else
+                    break;
+            }
+            started = 1;
+            if ( (ch >= '0') && (ch <= '9') )
+                ich = ch - '0';
+            else if ( (ch >= 'A') && (ch <= 'F') )
+                ich = ch - 'A' + 10;
+            else if ( (ch >= 'a') && (ch <= 'f') )
+                ich = ch - 'a' + 10;
+            
+            for ( i=0; i<Length-1; i++ )
+                A[i] = (A[i] << 4) | (A[i+1] >> 4);
+            A[Length-1] = (A[Length-1] << 4) | ich;
+        }
+    else
+        return 0;
+
+    return 1;
+}
+
+void
+fprintBstr(FILE *fp, char *S, BitSequence *A, int L)
+{
+    int     i;
+
+    fprintf(fp, "%s", S);
+
+    for ( i=0; i<L; i++ )
+        fprintf(fp, "%02X", A[i]);
+
+    if ( L == 0 )
+        fprintf(fp, "00");
+
+    fprintf(fp, "\n");
+}