@pinkparrot/qsafe-mayo-wasm 0.0.3

package/mayo-c/test/CMakeLists.txt

@@ -0,0 +1,51 @@
+# SPDX-License-Identifier: Apache-2.0
+
+if (ENABLE_PARAMS_DYNAMIC)
+    add_executable(mayo_test_kat test_kat.c)
+    target_link_libraries(mayo_test_kat mayo_test)
+
+    add_executable(mayo_bench bench.c m1cycles.c)
+    target_link_libraries(mayo_bench mayo)
+
+    add_executable(mayo_test_scheme test_mayo.c)
+    target_link_libraries(mayo_test_scheme mayo)
+    target_include_directories(mayo_test_scheme PUBLIC ../src/common)
+
+    add_test(MAYO_1_KAT mayo_test_kat MAYO-1)
+    add_test(MAYO_2_KAT mayo_test_kat MAYO-2)
+    add_test(MAYO_3_KAT mayo_test_kat MAYO-3)
+    add_test(MAYO_5_KAT mayo_test_kat MAYO-5)
+    add_test(MAYO_1_SELFTEST mayo_test_scheme MAYO-1)
+    add_test(MAYO_2_SELFTEST mayo_test_scheme MAYO-2)
+    add_test(MAYO_3_SELFTEST mayo_test_scheme MAYO-3)
+    add_test(MAYO_5_SELFTEST mayo_test_scheme MAYO-5)
+else()
+    FOREACH(MVARIANT ${MVARIANT_S})
+        string(TOLOWER ${MVARIANT} MVARIANT_LOWER)
+        add_executable(mayo_test_kat_${MVARIANT} test_kat.c)
+        target_link_libraries(mayo_test_kat_${MVARIANT} ${MVARIANT_LOWER}_test)
+
+        add_executable(mayo_bench_${MVARIANT} bench.c m1cycles.c)
+        target_link_libraries(mayo_bench_${MVARIANT} ${MVARIANT_LOWER})
+
+        add_executable(mayo_test_scheme_${MVARIANT} test_mayo.c)
+        target_link_libraries(mayo_test_scheme_${MVARIANT} ${MVARIANT_LOWER})
+        target_include_directories(mayo_test_scheme_${MVARIANT} PUBLIC ../src/common ${INC_PLATFORM})
+
+        add_executable(mayo_test_sample_solution_${MVARIANT} test_sample_solution.c)
+        target_link_libraries(mayo_test_sample_solution_${MVARIANT} ${MVARIANT_LOWER}_test_nistapi)
+        target_include_directories(mayo_test_sample_solution_${MVARIANT} PRIVATE ../include ../src/${MVARIANT_LOWER})
+
+        add_executable(mayo_test_various_${MVARIANT} test_various.c)
+        target_link_libraries(mayo_test_various_${MVARIANT} ${MVARIANT_LOWER})
+
+        target_include_directories(mayo_test_various_${MVARIANT} PUBLIC ../src/common ../src/generic ${INC_PLATFORM})
+
+        add_test(${MVARIANT}_KAT mayo_test_kat_${MVARIANT} ${MVARIANT})
+        add_test(${MVARIANT}_SELFTEST mayo_test_scheme_${MVARIANT} ${MVARIANT})
+        add_test(${MVARIANT}_VARIOUS mayo_test_various_${MVARIANT} ${MVARIANT})
+        add_test(${MVARIANT}_SAMPLE_SOLUTION mayo_test_sample_solution_${MVARIANT})
+    ENDFOREACH()
+
+endif()
+

package/mayo-c/test/bench.c

@@ -0,0 +1,166 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include <mayo.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <inttypes.h>
+
+#include "m1cycles.h"
+
+#if (defined(TARGET_OS_UNIX) && (defined(TARGET_ARM) || defined(TARGET_ARM64)) || defined(TARGET_OTHER)) \
+    || (!defined(TARGET_OS_MAC) && defined(TARGET_ARM64))
+#include <time.h>
+#endif
+
+static int bench_sig(const mayo_params_t *p, int runs, int csv);
+static inline int64_t cpucycles(void);
+
+int main(int argc, char *argv[]) {
+    int rc = 0;
+
+#if defined(TARGET_OS_MAC) && defined(TARGET_ARM64)
+    setup_rdtsc();
+#endif
+
+#ifdef ENABLE_PARAMS_DYNAMIC
+    if (argc < 3) {
+        printf("Two arguments needed\n");
+        rc = 1;
+        goto end;
+    }
+    int runs = atoi(argv[2]);
+    if (!strcmp(argv[1], "MAYO-1")) {
+        rc = bench_sig(&MAYO_1, runs, 0);
+    } else if (!strcmp(argv[1], "MAYO-2")) {
+        rc = bench_sig(&MAYO_2, runs, 0);
+    } else if (!strcmp(argv[1], "MAYO-3")) {
+        rc = bench_sig(&MAYO_3, runs, 0);
+    } else if (!strcmp(argv[1], "MAYO-5")) {
+        rc = bench_sig(&MAYO_5, runs, 0);
+    }
+#else
+    if (argc < 2) {
+        printf("One argument needed\n");
+        rc = 1;
+        goto end;
+    }
+    int runs = atoi(argv[1]);
+    rc = bench_sig(0, runs, 0);
+#endif
+
+
+
+end:
+    return rc;
+}
+
+#if (defined(TARGET_ARM) || defined(TARGET_S390X) || (defined(TARGET_ARM64) && defined(TARGET_OS_UNIX)))
+#define BENCH_UNITS "nsec"
+#else
+#define BENCH_UNITS "cycles"
+#endif
+
+int cmpfunc (const void *a, const void *b) {
+    return ( *(uint64_t *)a - * (uint64_t *)b );
+}
+
+#define BENCH_CODE_1(r) \
+    cycles = 0; \
+    for (i = 0; i < (r); ++i) { \
+        cycles1 = cpucycles();
+
+#define BENCH_CODE_2(name, csv) \
+        cycles2 = cpucycles(); \
+        if(i < LIST_SIZE) \
+          cycles_list[i] = (cycles2 - cycles1);\
+        cycles = cycles + (cycles2 - cycles1); \
+    } \
+    qsort(cycles_list, (runs < LIST_SIZE)? runs : LIST_SIZE, sizeof(uint64_t), cmpfunc);\
+    if (csv) \
+      printf("%2" PRId64 ",", cycles_list[(runs < LIST_SIZE)? runs/2 : LIST_SIZE/2]); \
+    else { \
+      printf("  %-20s-> median: %2" PRId64 ", average: %2" PRId64 " ", name, \
+      cycles_list[(runs < LIST_SIZE)? runs/2 : LIST_SIZE/2], (cycles / runs)); \
+      printf("%s\n", BENCH_UNITS); \
+    }
+
+#define LIST_SIZE 10000
+
+static int bench_sig(const mayo_params_t *p, int runs, int csv) {
+
+    int rc = 0;
+    int i;
+
+    int64_t cycles, cycles1, cycles2;
+    int64_t cycles_list[10000];
+
+    const int m_len = 32;
+
+    unsigned char *pk  = calloc(PARAM_cpk_bytes(p), 1);
+    uint64_t *epk  = calloc(1, sizeof(pk_t));
+    unsigned char *sk  = calloc(PARAM_csk_bytes(p), 1);
+    sk_t *esk  = calloc(1, sizeof(sk_t));
+    unsigned char *sig = calloc(PARAM_sig_bytes(p) + m_len, 1);
+    unsigned char *m   = calloc(m_len, 1);
+    size_t len = PARAM_sig_bytes(p);
+
+    if (csv) {
+        printf("%s,", PARAM_name(p));
+    } else {
+        printf("Benchmarking %s\n", PARAM_name(p));
+    }
+
+    BENCH_CODE_1(runs);
+    mayo_keypair(p, pk, sk);
+    BENCH_CODE_2("mayo_keypair", csv);
+
+    BENCH_CODE_1(runs);
+    mayo_expand_sk(p, sk, esk);
+    BENCH_CODE_2("mayo_expand_sk", csv);
+
+    BENCH_CODE_1(runs);
+    mayo_expand_pk(p, pk, epk);
+    BENCH_CODE_2("mayo_expand_pk", csv);
+
+    BENCH_CODE_1(runs);
+    mayo_sign(p, sig, &len, m, m_len, sk);
+    BENCH_CODE_2("mayo_sign", csv);
+
+    len = 32;
+    BENCH_CODE_1(runs);
+    mayo_open(p, m, &len, sig, PARAM_sig_bytes(p), pk);
+    BENCH_CODE_2("mayo_verify", csv);
+
+    if (csv) {
+        printf("\n");
+    }
+
+    free(esk);
+    free(epk);
+    free(pk);
+    free(sk);
+    free(sig);
+    free(m);
+    return rc;
+}
+
+static inline int64_t cpucycles(void) {
+#if (defined(TARGET_AMD64) || defined(TARGET_X86))
+    unsigned int hi, lo;
+
+    asm volatile ("rdtsc" : "=a" (lo), "=d"(hi));
+    return ((int64_t) lo) | (((int64_t) hi) << 32);
+#elif (defined(TARGET_S390X))
+    uint64_t tod;
+    asm volatile("stckf %0\n" : "=Q" (tod) : : "cc");
+    return (tod * 1000 / 4096);
+#elif (defined(TARGET_OS_MAC) && defined(TARGET_ARM64))
+    return rdtsc();
+#else
+    struct timespec time;
+    clock_gettime(CLOCK_REALTIME, &time);
+    return (int64_t)(time.tv_sec * 1e9 + time.tv_nsec);
+#endif
+}
+

package/mayo-c/test/m1cycles.c

@@ -0,0 +1,155 @@
+// SPDX-License-Identifier: Apache-2.0 and Public Domain
+
+/*
+ * Modified from
+ * https://github.com/GMUCERG/PQC_NEON/blob/main/neon/kyber/m1cycles.c, Duc Tri Nguyen (CERG GMU)
+ * which was modified from M1
+ * https://gist.github.com/dougallj/5bafb113492047c865c0c8cfbc930155#file-m1_robsize-c-L390
+ */
+
+#if defined(TARGET_OS_MAC) && defined(TARGET_ARM64)
+
+#include <dlfcn.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "m1cycles.h"
+
+#define KPERF_LIST                               \
+    /*  ret, name, params */                     \
+    F(int, kpc_get_counting, void)               \
+    F(int, kpc_force_all_ctrs_set, int)          \
+    F(int, kpc_set_counting, uint32_t)           \
+    F(int, kpc_set_thread_counting, uint32_t)    \
+    F(int, kpc_set_config, uint32_t, void *)     \
+    F(int, kpc_get_config, uint32_t, void *)     \
+    F(int, kpc_set_period, uint32_t, void *)     \
+    F(int, kpc_get_period, uint32_t, void *)     \
+    F(uint32_t, kpc_get_counter_count, uint32_t) \
+    F(uint32_t, kpc_get_config_count, uint32_t)  \
+    F(int, kperf_sample_get, int *)              \
+    F(int, kpc_get_thread_counters, int, unsigned int, void *)
+
+#define F(ret, name, ...)                \
+    typedef ret name##proc(__VA_ARGS__); \
+    static name##proc *name;
+KPERF_LIST
+#undef F
+
+#define CFGWORD_EL0A32EN_MASK (0x10000)
+#define CFGWORD_EL0A64EN_MASK (0x20000)
+#define CFGWORD_EL1EN_MASK (0x40000)
+#define CFGWORD_EL3EN_MASK (0x80000)
+#define CFGWORD_ALLMODES_MASK (0xf0000)
+
+#define CPMU_NONE 0
+#define CPMU_CORE_CYCLE 0x02
+#define CPMU_INST_A64 0x8c
+#define CPMU_INST_BRANCH 0x8d
+#define CPMU_SYNC_DC_LOAD_MISS 0xbf
+#define CPMU_SYNC_DC_STORE_MISS 0xc0
+#define CPMU_SYNC_DTLB_MISS 0xc1
+#define CPMU_SYNC_ST_HIT_YNGR_LD 0xc4
+#define CPMU_SYNC_BR_ANY_MISP 0xcb
+#define CPMU_FED_IC_MISS_DEM 0xd3
+#define CPMU_FED_ITLB_MISS 0xd4
+
+#define KPC_CLASS_FIXED (0)
+#define KPC_CLASS_CONFIGURABLE (1)
+#define KPC_CLASS_POWER (2)
+#define KPC_CLASS_RAWPMU (3)
+#define KPC_CLASS_FIXED_MASK (1u << KPC_CLASS_FIXED)
+#define KPC_CLASS_CONFIGURABLE_MASK (1u << KPC_CLASS_CONFIGURABLE)
+#define KPC_CLASS_POWER_MASK (1u << KPC_CLASS_POWER)
+#define KPC_CLASS_RAWPMU_MASK (1u << KPC_CLASS_RAWPMU)
+
+// COUNTERS_COUNT may vary
+#define COUNTERS_COUNT 10
+#define CONFIG_COUNT 8
+#define KPC_MASK (KPC_CLASS_CONFIGURABLE_MASK | KPC_CLASS_FIXED_MASK)
+uint64_t g_counters[COUNTERS_COUNT];
+uint64_t g_config[COUNTERS_COUNT];
+
+static void configure_rdtsc(void)
+{
+    if (kpc_set_config(KPC_MASK, g_config))
+    {
+        printf("kpc_set_config failed\n");
+        return;
+    }
+
+    if (kpc_force_all_ctrs_set(1))
+    {
+        printf("kpc_force_all_ctrs_set failed\n");
+        return;
+    }
+
+    if (kpc_set_counting(KPC_MASK))
+    {
+        printf("kpc_set_counting failed\n");
+        return;
+    }
+
+    if (kpc_set_thread_counting(KPC_MASK))
+    {
+        printf("kpc_set_thread_counting failed\n");
+        return;
+    }
+}
+
+static void init_rdtsc(void)
+{
+    void *kperf = dlopen(
+        "/System/Library/PrivateFrameworks/kperf.framework/Versions/A/kperf",
+        RTLD_LAZY);
+    if (!kperf)
+    {
+        printf("kperf = %p\n", kperf);
+        return;
+    }
+#define F(ret, name, ...)                         \
+    name = (name##proc *)(dlsym(kperf, #name));   \
+    if (!name)                                    \
+    {                                             \
+        printf("%s = %p\n", #name, (void *)name); \
+        return;                                   \
+    }
+    KPERF_LIST
+#undef F
+
+    g_config[0] = CPMU_CORE_CYCLE | CFGWORD_EL0A64EN_MASK;
+
+    configure_rdtsc();
+}
+
+void setup_rdtsc(void)
+{
+    int test_high_perf_cores = 1;
+
+    if (test_high_perf_cores)
+    {
+        pthread_set_qos_class_self_np(QOS_CLASS_USER_INTERACTIVE, 0);
+    }
+    else
+    {
+        pthread_set_qos_class_self_np(QOS_CLASS_BACKGROUND, 0);
+    }
+    init_rdtsc();
+    configure_rdtsc();
+}
+
+extern unsigned long long int rdtsc(void)
+{
+    if (kpc_get_thread_counters(0, COUNTERS_COUNT, g_counters))
+    {
+        printf("kpc_get_thread_counters failed\n");
+        return 1;
+    }
+    return g_counters[2];
+}
+
+#endif
+
+
+
+

package/mayo-c/test/m1cycles.h

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef M1CYCLES_H
+#define M1CYCLES_H
+
+#ifdef TARGET_ARM64
+
+void setup_rdtsc(void);
+unsigned long long int rdtsc(void);
+
+#endif
+
+#endif

package/mayo-c/test/test_kat.c

@@ -0,0 +1,271 @@
+// SPDX-License-Identifier: Apache-2.0 and Unknown
+
+/*
+NIST-developed software is provided by NIST as a public service. You may use, copy, and distribute copies of the software in any medium, provided that you keep intact this entire notice. You may improve, modify, and create derivative works of the software or any portion of the software, and you may copy and distribute such modifications or works. Modified works should carry a notice stating that you changed the software and should note the date and nature of any such change. Please explicitly acknowledge the National Institute of Standards and Technology as the source of the software.
+
+NIST-developed software is expressly provided "AS IS." NIST MAKES NO WARRANTY OF ANY KIND, EXPRESS, IMPLIED, IN FACT, OR ARISING BY OPERATION OF LAW, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND DATA ACCURACY. NIST NEITHER REPRESENTS NOR WARRANTS THAT THE OPERATION OF THE SOFTWARE WILL BE UNINTERRUPTED OR ERROR-FREE, OR THAT ANY DEFECTS WILL BE CORRECTED. NIST DOES NOT WARRANT OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF THE SOFTWARE OR THE RESULTS THEREOF, INCLUDING BUT NOT LIMITED TO THE CORRECTNESS, ACCURACY, RELIABILITY, OR USEFULNESS OF THE SOFTWARE.
+
+You are solely responsible for determining the appropriateness of using and distributing the software and you assume all risks associated with its use, including but not limited to the risks and costs of program errors, compliance with applicable laws, damage to or loss of data, programs or equipment, and the unavailability or interruption of operation. This software is not intended to be used in any situation where a failure could cause risk of injury or damage to property. The software developed by NIST employees is not subject to copyright protection within the United States.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <randombytes.h>
+#include <mayo.h>
+
+#define MAX_MARKER_LEN         50
+
+#define KAT_SUCCESS             0
+#define KAT_FILE_OPEN_ERROR    -1
+#define KAT_DATA_ERROR         -3
+#define KAT_CRYPTO_FAILURE     -4
+#define KAT_VERIFICATION_ERROR -5
+
+static int      FindMarker(FILE *infile, const char *marker);
+static int      ReadHex(FILE *infile, unsigned char *A, int Length, char *str);
+static int      test_sig_kat(const mayo_params_t *p);
+
+int main(int argc, char *argv[]) {
+    int rc = 0;
+
+#ifdef ENABLE_PARAMS_DYNAMIC
+    if (argc < 2) {
+        printf("One argument needed\n");
+        rc = 1;
+        goto end;
+    }
+
+    if (!strcmp(argv[1], "MAYO-1")) {
+        rc = test_sig_kat(&MAYO_1);
+    } else if (!strcmp(argv[1], "MAYO-2")) {
+        rc = test_sig_kat(&MAYO_2);
+    } else if (!strcmp(argv[1], "MAYO-3")) {
+        rc = test_sig_kat(&MAYO_3);
+    } else if (!strcmp(argv[1], "MAYO-5")) {
+        rc = test_sig_kat(&MAYO_5);
+    } else {
+        return -1;
+    }
+end:
+#else
+    rc = test_sig_kat(0);
+#endif
+    return rc;
+}
+
+static int test_sig_kat(const mayo_params_t *p) {
+    unsigned char       seed[48];
+    unsigned char       *m, *sm, *m1, *sm_rsp;
+    size_t  mlen, smlen, mlen1;
+    int                 count;
+    int                 done;
+    unsigned char       pk[PARAM_cpk_bytes(p)], sk[PARAM_csk_bytes(p)];
+    int                 ret_val;
+
+    char                fn_rsp[64];
+    FILE                *fp_rsp;
+    unsigned char       pk_rsp[PARAM_cpk_bytes(p)], sk_rsp[PARAM_csk_bytes(p)];
+
+    sprintf(fn_rsp, "../../KAT/PQCsignKAT_%d_%s.rsp", PARAM_csk_bytes(p), PARAM_name(p));
+    if ( (fp_rsp = fopen(fn_rsp, "r")) == NULL ) {
+        printf("Couldn't open <%s> for read\n", fn_rsp);
+        return KAT_FILE_OPEN_ERROR;
+    }
+
+    done = 0;
+    do {
+        if ( FindMarker(fp_rsp, "count = ") ) {
+            ret_val = fscanf(fp_rsp, "%d", &count);
+        } else {
+            done = 1;
+            break;
+        }
+
+        if ( !ReadHex(fp_rsp, seed, 48, "seed = ") ) {
+            printf("ERROR: unable to read 'seed' from <%s>\n", fn_rsp);
+            return KAT_DATA_ERROR;
+        }
+
+        randombytes_init(seed, NULL, 256);
+
+        if ( FindMarker(fp_rsp, "mlen = ") ) {
+            ret_val = fscanf(fp_rsp, "%zu", &mlen);
+        } else {
+            printf("ERROR: unable to read 'mlen' from <%s>\n", fn_rsp);
+            return KAT_DATA_ERROR;
+        }
+
+        m = (unsigned char *)calloc(mlen, sizeof(unsigned char));
+        m1 = (unsigned char *)calloc(mlen, sizeof(unsigned char));
+        sm = (unsigned char *)calloc(mlen + PARAM_sig_bytes(p), sizeof(unsigned char));
+        sm_rsp = (unsigned char *)calloc(mlen + PARAM_sig_bytes(p), sizeof(unsigned char));
+
+        if ( !ReadHex(fp_rsp, m, (int)mlen, "msg = ") ) {
+            printf("ERROR: unable to read 'msg' from <%s>\n", fn_rsp);
+            return KAT_DATA_ERROR;
+        }
+
+        // Generate the public/private keypair
+        if ( (ret_val = mayo_keypair(p, pk, sk)) != 0) {
+            printf("crypto_sign_keypair returned <%d>\n", ret_val);
+            return KAT_CRYPTO_FAILURE;
+        }
+        if ( !ReadHex(fp_rsp, pk_rsp, PARAM_cpk_bytes(p), "pk = ") ) {
+            printf("ERROR: unable to read 'pk' from <%s>\n", fn_rsp);
+            return KAT_DATA_ERROR;
+        }
+        if ( !ReadHex(fp_rsp, sk_rsp, PARAM_csk_bytes(p), "sk = ") ) {
+            printf("ERROR: unable to read 'sk' from <%s>\n", fn_rsp);
+            return KAT_DATA_ERROR;
+        }
+
+        if (memcmp(pk, pk_rsp, PARAM_cpk_bytes(p)) != 0) {
+            printf("ERROR: pk is different from <%s>\n", fn_rsp);
+            return KAT_VERIFICATION_ERROR;
+        }
+        if (memcmp(sk, sk_rsp, PARAM_csk_bytes(p)) != 0) {
+            printf("ERROR: sk is different from <%s>\n", fn_rsp);
+            return KAT_VERIFICATION_ERROR;
+        }
+
+        if ( (ret_val = mayo_sign(p, sm, &smlen, m, mlen, sk)) != 0) {
+            printf("crypto_sign returned <%d>\n", ret_val);
+            return KAT_CRYPTO_FAILURE;
+        }
+
+        if ( !ReadHex(fp_rsp, sm_rsp, smlen, "sm = ") ) {
+            printf("ERROR: unable to read 'sm' from <%s>\n", fn_rsp);
+            return KAT_DATA_ERROR;
+        }
+
+        if (memcmp(sm, sm_rsp, smlen) != 0) {
+            printf("ERROR: sm is different from <%s>\n", fn_rsp);
+            return KAT_VERIFICATION_ERROR;
+        }
+
+
+        if ( (ret_val = mayo_open(p, m1, &mlen1, sm, smlen, pk)) != 0) {
+            printf("crypto_sign_open returned <%d>\n", ret_val);
+            return KAT_CRYPTO_FAILURE;
+        }
+
+        if ( mlen != mlen1 ) {
+            printf("crypto_sign_open returned bad 'mlen': Got <%zu>, expected <%zu>\n", mlen1, mlen);
+            return KAT_CRYPTO_FAILURE;
+        }
+
+        if ( memcmp(m, m1, mlen) ) {
+            printf("crypto_sign_open returned bad 'm' value\n");
+            return KAT_CRYPTO_FAILURE;
+        }
+
+        free(m);
+        free(m1);
+        free(sm);
+        free(sm_rsp);
+
+    } while ( !done );
+
+    fclose(fp_rsp);
+
+    printf("Known Answer Tests PASSED. \n");
+    printf("\n\n");
+
+    return KAT_SUCCESS;
+}
+
+
+//
+// ALLOW TO READ HEXADECIMAL ENTRY (KEYS, DATA, TEXT, etc.)
+//
+static int
+FindMarker(FILE *infile, const char *marker) {
+    char    line[MAX_MARKER_LEN];
+    int     i, len;
+    int curr_line;
+
+    len = (int)strlen(marker);
+    if ( len > MAX_MARKER_LEN - 1 ) {
+        len = MAX_MARKER_LEN - 1;
+    }
+
+    for ( i = 0; i < len; i++ ) {
+        curr_line = fgetc(infile);
+        line[i] = curr_line;
+        if (curr_line == 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];
+        }
+        curr_line = fgetc(infile);
+        line[len - 1] = curr_line;
+        if (curr_line == EOF ) {
+            return 0;
+        }
+        line[len] = '\0';
+    }
+
+    // shouldn't get here
+    return 0;
+}
+
+//
+// ALLOW TO READ HEXADECIMAL ENTRY (KEYS, DATA, TEXT, etc.)
+//
+static int
+ReadHex(FILE *infile, unsigned char *A, int Length, char *str) {
+    int         i, ch, started;
+    unsigned char   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 { // shouldn't ever get here
+                ich = 0;
+            }
+
+            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;
+}
+