pcompress/crypto/keccak/genKAT.c

714 lines
22 KiB
C
Raw Normal View History

/*
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, const char *str);
void fprintBstr(FILE *fp, const 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, rv;
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);
fclose(fp_in);
return KAT_FILE_OPEN_ERROR;
}
fprintf(fp_out, "# %s\n", fn);
if ( FindMarker(fp_in, "# Algorithm Name:") ) {
rv = fscanf(fp_in, "%[^\n]\n", line);
fprintf(fp_out, "# Algorithm Name:%s\n", line);
}
else {
printf("genShortMsg: Couldn't read Algorithm Name\n");
fclose(fp_in);
fclose(fp_out);
return KAT_HEADER_ERROR;
}
if ( FindMarker(fp_in, "# Principal Submitter:") ) {
rv = 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 = ") )
rv = 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;
}
Keccak_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, rv;
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);
fclose(fp_in);
return KAT_FILE_OPEN_ERROR;
}
fprintf(fp_out, "# %s\n", fileName);
if ( FindMarker(fp_in, "# Algorithm Name:") ) {
rv = fscanf(fp_in, "%[^\n]\n", line);
fprintf(fp_out, "# Algorithm Name:%s\n", line);
}
else {
printf("genShortMsg: Couldn't read Algorithm Name\n");
fclose(fp_in);
fclose(fp_out);
return KAT_HEADER_ERROR;
}
if ( FindMarker(fp_in, "# Principal Submitter:") ) {
rv = 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 = ") )
rv = 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, rv;
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);
fclose(fp_in);
return KAT_FILE_OPEN_ERROR;
}
fprintf(fp_out, "# %s\n", fn);
if ( FindMarker(fp_in, "# Algorithm Name:") ) {
rv = fscanf(fp_in, "%[^\n]\n", line);
fprintf(fp_out, "# Algorithm Name:%s\n", line);
}
else {
printf("genLongMsg: Couldn't read Algorithm Name\n");
fclose(fp_in);
fclose(fp_out);
return KAT_HEADER_ERROR;
}
if ( FindMarker(fp_in, "# Principal Submitter:") ) {
rv = 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 = ") )
rv = 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)
Keccak_Hash(hashbitlen, Msg, msglen, MD);
else {
Keccak_Init(&state, hashbitlen);
Keccak_Update(&state, Msg, msglen);
Keccak_Final(&state, 0);
Squeeze(&state, Squeezed, SqueezingOutputLength);
}
#else
Keccak_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, rv;
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);
fclose(fp_in);
return KAT_FILE_OPEN_ERROR;
}
fprintf(fp_out, "# %s\n", fn);
if ( FindMarker(fp_in, "# Algorithm Name:") ) {
rv = fscanf(fp_in, "%[^\n]\n", line);
fprintf(fp_out, "# Algorithm Name:%s\n", line);
}
else {
printf("genExtremelyLongMsg: Couldn't read Algorithm Name\n");
fclose(fp_in);
fclose(fp_out);
return KAT_HEADER_ERROR;
}
if ( FindMarker(fp_in, "# Principal Submitter:") ) {
rv = 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 = ") )
rv = 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 = ") )
rv = 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 = Keccak_Init(&state, hashbitlen)) != KAT_SUCCESS ) {
printf("Keccak_Init returned <%d> in genExtremelyLongMsg\n", retval);
return KAT_HASH_ERROR;
}
for ( i=0; i<repeat; i++ )
if ( (retval = Keccak_Update(&state, Text, 512)) != KAT_SUCCESS ) {
printf("Keccak_Update returned <%d> in genExtremelyLongMsg\n", retval);
return KAT_HASH_ERROR;
}
if ( (retval = Keccak_Final(&state, MD)) != KAT_SUCCESS ) {
printf("Keccak_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, rv;
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);
fclose(fp_in);
return KAT_FILE_OPEN_ERROR;
}
fprintf(fp_out, "# %s\n", fn);
if ( FindMarker(fp_in, "# Algorithm Name:") ) {
rv = fscanf(fp_in, "%[^\n]\n", line);
fprintf(fp_out, "# Algorithm Name:%s\n", line);
}
else {
printf("genMonteCarlo: Couldn't read Algorithm Name\n");
fclose(fp_in);
fclose(fp_out);
return KAT_HEADER_ERROR;
}
if ( FindMarker(fp_in, "# Principal Submitter:") ) {
rv = 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++ ) {
Keccak_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, rv;
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);
fclose(fp_in);
return KAT_FILE_OPEN_ERROR;
}
fprintf(fp_out, "# %s\n", fn);
if ( FindMarker(fp_in, "# Algorithm Name:") ) {
rv = fscanf(fp_in, "%[^\n]\n", line);
fprintf(fp_out, "# Algorithm Name:%s\n", line);
}
else {
printf("genMonteCarlo: Couldn't read Algorithm Name\n");
fclose(fp_in);
fclose(fp_out);
return KAT_HEADER_ERROR;
}
if ( FindMarker(fp_in, "# Principal Submitter:") ) {
rv = 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 = Keccak_Init(&state, hashbitlen)) != KAT_SUCCESS ) {
printf("Keccak_Init returned <%d> in genMonteCarloSqueezing\n", retval);
return KAT_HASH_ERROR;
}
if ( (retval = Keccak_Update(&state, Seed, 128*8)) != KAT_SUCCESS ) {
printf("Keccak_Update returned <%d> in genMonteCarloSqueezing\n", retval);
return KAT_HASH_ERROR;
}
if ( (retval = Keccak_Final(&state, 0)) != KAT_SUCCESS ) {
printf("Keccak_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 = (HashReturn)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, rv;
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);
fclose(fp_in);
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 = ") )
rv = 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, const 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;
else
return 1;
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, const 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");
}