sleeping_kangaroo12 0.0.3 → 0.0.4

data/ext/xkcp/support/Kernel-PMU/Kernel-pmu.md

@@ -1,133 +0,0 @@
-# XKCP ARM cycle count extension with a Cortex-A57 / RPIB3+ example
-
-**By Bruno Pairault, 2019**
-
-![MacDown logo](https://www.enggwave.com/wp-content/uploads/2015/06/ARM-Logo-150x127.png)
-
-**ARM** allow the counting of cycles via few techniques :
-**DWT** or nowdays **Performance Monitor Unit** (PMU). There is several versions of PMU for the different
-Cortex processor.
-
-The **ARM cycle count implementation** is Linux Kernel dependant to allow the PMU managment for User.
-Enabling the PMU on user-mode is provided per **Kernel-PMU** and is independent of XKCP.
-
-The XKCP PMU implementation supports two architectures yet **Aarch64** and **ARMv7-A**. The two XKCP
-PMU implementations to read cycles are coded in the XKCP file `tests/UnitTest/Timing.h` This file
-is only updated using the several native preprocessor compilation options. **Performance Monitors Cycle
-Counters** are then read when required.
-
-
-
-## Principle of Kernel-PMU
-**Kernel-PMU** is a Linux dependant module that has to be loaded to allow the PMU user-mode.
-XKCP `tests/UnitTest/Timing.h` will then be abble to read the register.
-
-The [Cortex-A57](https://en.wikipedia.org/wiki/ARM_Cortex-A57)
-documentation can be found on the ARM site for details on the [PMU](https://developer.arm.com/docs/ddi0488/latest/preface) . The Chapter 11
-describes the Performance Monitor Unit. For all the **Cortex A**, you can reach the [Cortex-A](https://developer.arm.com/products/processors/cortex-a) technical library.
-##Principle of the computation
-When the  **Kernel-PMU** is loaded, the processor is likely to answer with the current cycle count for PMU 32
-or 64 Architecture. Obviously similar PMU thread exist on Internet however this integration in XKCP follow exactly the principle introduced initially in `Timing.h` by **Doug Whiting**
-for Intel via `RTDSC`. Minimal changes are required in **XKCP**. We added the few ASM instructions to read the PMU according to the precompilations options.
-The number of cycles of an operation is the difference between the cycle counter before and the cycle
-counter after.
-
-## Install
-
-1. Install the kernel-header version for your kernel release number given per the command `#uname -r`.
-The method is dependant on your Packet Manager (zypper, apt-get, dpkg).
-
-	* Raspbian  (32 bits): `sudo apt-get install raspberrypi-kernel-headers`
-
-	* OpenSuse Leap 15 (64 bits): Likely on a fresh install `nothing to do` or if the OS has been updated you will have probably to run  `sudo zypper in kernel-dev`.
-
-2. Compile Kernel-PMU
-
-		#cd Kernel-PMU
-		#make
-			
-3. Load Kernel-PMU and Check
-
-
-		#sudo ./load-module
-		#dmesg
-	
-	
-	The expect result for **Cortex-a57** is similar to :
-	
-	
-	
-		[ 6014.689804] ENABLE_ARM_PMU enabling user PMU access on CPU-Core #0
-		[ 6014.689809] ENABLE_ARM_PMU enabling user PMU access on CPU-Core #2
-		[ 6014.689813] ENABLE_ARM_PMU enabling user PMU access on CPU-Core #3
-		[ 6014.689820] ENABLE_ARM_PMU enabling user PMU access on CPU-Core #1
-	
-###Know-Issues	
-* Depending on your Linux OS (Raspbian, Ubuntu Mate, OpenSuse) and your OS release you may also
-be required to download from source the kernel files to compile the module. The module will not load if
-the matching is not correct. Modify the path in the makefile if required.
-
-* The module must be reload after rebooting if you do not implement auto-load @reboot.
-
-
-##Check the CPU configuration and the native GCC options
-* The objective is to understand the compilation you need to added if you use `-mnative`.
-* Sanity check the CPU configuration and check all the native `-mXXX` compilations options like `march`,`
-mtune`.
-
-		# lscpu
-		# cat /proc/cpuinfo
-		# gcc -v
-		
-###Know-Issues Raspbian case with Updated system OS on 2019-01-01
-* On Raspbian the Cortex-a53 is declared as an ARMv7l with 4 cores as per `lscpu`. GCC [(gcc
-version 6.3.0 20170516 (Raspbian 6.3.0-18+rpi1+deb9u1)] come with native ARMv6 `-march`
-option. This is due to the implementation. Type `cat /proc/cpuinfo` and you will discover the
-**BCM2835** CPU which is the ARMv6 of the first RPI1(2010). It looks like it’s an ARMv6 for each of the 4
-cores. The impact is that we have to force the precompiler options to use the PMU 32 bits for ARM.
-
-* **Cortex-a53** RPIB3+ is an **ARMV8-a 64 bits** running mostly 32 bits as most OS for RPI are 32 bits.
-
-
-* The preprocessor options `-D__ARM_xx` have to be consistent with the processor and the OS. On a
-32 bits implementation the PMU register is the 32 bits PMU while the 64 bits PMU counter will be used
-on Aarch64.
-
-##XKCP Compilation options tips for Cortex-a53 and RPIB3+
-
-Depending on what you are trying to achieve you may like to check the compilation options for gcc or
-modify the XKCP `lib/LowLevel.build`. Below some suggestions.
-
-For 32 bits OS on ARM PMU on target
-
-The RPI3 on 32Bits OS is declared as a ARMv6 per GCC precompilation options. We have then to force
-the `ARM_ARCH_7A` option to read the 32 bit Cycle counter.
-
-
-	▪ <gcc>-v</gcc> This option add verbose
-	▪ <gcc>-D__ARM_ARCH_7A_</gcc>
-	
-For 64 bits OS on ARM on target : `-mnative` will likely implement natively `__aarch64` . it is
-suggested per GCC as good practice to enable `fix-cortex-a53-835769` and
-`fix-cortex-a53-843419`.
-
-For Cross Compilation 32 bits
-
-	▪ <gcc>-march=armv8-a+crc</gcc>
-	▪ <gcc>-mtune=cortex-a53</gcc>
-	▪ <gcc>-mlittle-endian</gcc>
-
-For Cross Compilation 64 bits using aarch64-linux-gnu-gcc
-
-	▪ <gcc>-march=armv8-a+crc</gcc>
-	▪ <gcc>-mtune=cortex-a53</gcc>
-	▪ <gcc>-mlittle-endian</gcc>
-	▪ <gcc>-mabi=lp64</gcc>
-
-
-Finally compile **KeccakTests**.
-
-
-##License
-This code is for GNU General Public License (GNU GPL or GPL) which guarantees end users the freedom
-to run, study, share and modify the Kernel-PMU.

data/ext/xkcp/support/Kernel-PMU/Makefile

@@ -1,8 +0,0 @@
-obj-m	:= enable_arm_pmu.o
-KDIR	:= /lib/modules/$(shell uname -r)/build
-PWD	:= $(shell pwd)
-
-all:
-	$(MAKE) -C $(KDIR) SUBDIRS=$(PWD) modules
-clean:
-	$(MAKE) -C $(KDIR) SUBDIRS=$(PWD) clean

data/ext/xkcp/support/Kernel-PMU/enable_arm_pmu.c

@@ -1,129 +0,0 @@
-/*
-    Kernel-PMU
-    Enabling user-mode access to the performance monitor unit (PMU) on ARMv8 Aarch64 and ARMv7
-    Copyright (C) 2019 Bruno Pairault
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/* Inspired with
-        https://community.arm.com/dev-platforms/f/discussions/10366/help-configuring-pmu-s
-        https://patchwork.kernel.org/patch/5217341/
-*/
-
-/* Enable user-mode ARM performance counter access on ARMv7 & Armv8 Aarch64 */
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/smp.h>
-
-
-#if !defined(__arm__) && !defined(__aarch64__)
-#error Module can only be compiled on ARM.
-#endif
-
-/* #define from /lib/modules/uname-r/source/arch/arm64/include/asm/perf_event.h in ASM Aarch 64 */
-#define ARMV8_PMCR_MASK         0x3f
-#define ARMV8_PMCR_E            (1 << 0) /*  Enable all counters */
-#define ARMV8_PMCR_P            (1 << 1) /*  Reset all counters */
-#define ARMV8_PMCR_C            (1 << 2) /*  Cycle counter reset */
-#define ARMV8_PMCR_N_MASK       0x1f
-
-#define ARMV8_PMUSERENR_EN_EL0  (1 << 0) /*  EL0 access enable */
-#define ARMV8_PMUSERENR_CR      (1 << 2) /*  Cycle counter read enable */
-#define ARMV8_PMUSERENR_ER      (1 << 3) /*  Event counter read enable */
-
-#define ARMV8_PMCNTENSET_EL0_ENABLE (1<<31) /* *< Enable Perf count reg */
-
-#define PERF_DEF_OPTS (1 | 16)
-
-static inline u32 armv8pmu_read(void)
-{
-        u64 val=0;
-        asm volatile("MRS %0, pmcr_el0" : "=r" (val));
-        return (u32)val;
-}
-static inline void armv8pmu_write(u32 val)
-{
-        val &= ARMV8_PMCR_MASK;
-        asm volatile("isb" : : : "memory");
-        asm volatile("MSR pmcr_el0, %0" : : "r" ((u64)val));
-}
-
-static void
-enable_cpu_counters(void* data)
-{
-    printk(KERN_INFO "ENABLE_ARM_PMU enabling user PMU access on CPU-Core #%d", smp_processor_id());
-#if __aarch64__
-        /* Enable user-mode access to counters. */
-        asm volatile("MSR pmuserenr_el0, %0" : : "r"((u64)ARMV8_PMUSERENR_EN_EL0|ARMV8_PMUSERENR_ER|ARMV8_PMUSERENR_CR));
-        /* Initialize & Reset PMNC: C and P bits. */
-        armv8pmu_write(ARMV8_PMCR_P | ARMV8_PMCR_C);
-        asm volatile("MSR pmintenset_el1, %0" : : "r" ((u64)(0 << 31)));
-        /* Count Enable Set register bit  31 enable */
-        asm volatile("MSR pmcntenset_el0, %0" : : "r" (ARMV8_PMCNTENSET_EL0_ENABLE));
-        armv8pmu_write(armv8pmu_read() | ARMV8_PMCR_E);
-
-#elif defined(__ARM_ARCH_7A__)
-
-        /* Enable user-mode access to counters. */
-        asm volatile("MCR p15, 0, %0, c9, c14, 0" :: "r"(1));
-        /* Program PMU and enable all counters */
-        asm volatile("MCR p15, 0, %0, c9, c12, 0" :: "r"(PERF_DEF_OPTS));
-        asm volatile("MCR p15, 0, %0, c9, c12, 1" :: "r"(0x8000000f));
-#else
-#error Module Does Not Support your ARM
-#endif
-}
-
-static void
-disable_cpu_counters(void* data)
-{
-        printk(KERN_INFO "ENABLE_ARM_PMU disabling user PMU access on CPU-Core #%d", smp_processor_id());
-
-#if __aarch64__
-        /*  Performance Monitors Count Enable Set register bit 31:0 disable */
-        asm volatile("MSR pmcntenset_el0, %0" : : "r" (0<<31));
-        /*  Disable all counters and user-mode access to counters. */
-        armv8pmu_write(armv8pmu_read() |~ ARMV8_PMCR_E);
-        asm volatile("MSR pmuserenr_el0, %0" : : "r"((u64)0));
-#elif defined(__ARM_ARCH_7A__)
-        asm volatile("MCR p15, 0, %0, c9, c12, 0" :: "r"(0));
-        /*  Disable all counters and user-mode access to counters. */
-        asm volatile("MCR p15, 0, %0, c9, c12, 2" :: "r"(0x8000000f));
-        asm volatile("MCR p15, 0, %0, c9, c14, 0" :: "r"(0));
-#else
-#error Module Does Not Support your ARM
-#endif
-}
-
-static int __init
-init(void)
-{
-        on_each_cpu(enable_cpu_counters, NULL, 1);
-        printk(KERN_INFO "ENABLE_ARM_PMU Initialized");
-        return 0;
-}
-
-static void __exit
-leave(void)
-{
-        on_each_cpu(disable_cpu_counters, NULL, 1);
-        printk(KERN_INFO "ENABLE_ARM_PMU Unloaded");
-}
-
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("Enables user-mode access to ARMv7A-v8 Aarch64 PMU counters");
-MODULE_VERSION("1:0.0-dev");
-module_init(init);
-module_exit(leave);

data/ext/xkcp/support/Kernel-PMU/load-module

@@ -1 +0,0 @@
-sudo insmod ./enable_arm_pmu.ko 

data/ext/xkcp/util/KeccakSum/KeccakSum.c

@@ -1,394 +0,0 @@
-/*
-Implementation by Gilles Van Assche and Ronny Van Keer, hereby denoted as "the implementer".
-
-For more information, feedback or questions, please refer to our website:
-https://keccak.team/
-
-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 <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "base64.h"
-#include "KeccakHash.h"
-#include "KangarooTwelve.h"
-#include "SP800-185.h"
-
-int hexencode(const void* data_buf, size_t dataLength, char* result, size_t resultSize)
-{
-   const char hexchars[] = "0123456789abcdef";
-   const uint8_t *data = (const uint8_t *)data_buf;
-   size_t resultIndex = 0;
-   size_t x;
-
-    for(x=0; x<dataLength; x++) {
-        if (resultIndex >= resultSize) return 1;   /* indicate failure: buffer too small */
-        result[resultIndex++] = hexchars[(data[x] / 16) % 16];
-        if (resultIndex >= resultSize) return 1;   /* indicate failure: buffer too small */
-        result[resultIndex++] = hexchars[data[x] % 16];
-   }
-   if(resultIndex >= resultSize) return 1;   /* indicate failure: buffer too small */
-   result[resultIndex] = 0;
-   return 0;   /* indicate success */
-}
-
-#define bufferSize 65536
-#define algorithm_Keccak    0
-#define algorithm_K12       1
-#define algorithm_ParallelHash  2
-
-typedef struct {
-    unsigned int algorithm;
-    unsigned int rate;
-    unsigned int capacity;
-    unsigned int hashbitlen;
-    unsigned char delimitedSuffix;
-    unsigned int blockByteLen;
-} Specifications;
-
-typedef union {
-    Keccak_HashInstance keccak;
-    KangarooTwelve_Instance k12;
-    ParallelHash_Instance ph;
-} Instance;
-
-int hashInitialize(Instance *instance, const Specifications *specs)
-{
-    if (specs->algorithm == algorithm_Keccak) {
-        if (Keccak_HashInitialize(&instance->keccak, specs->rate, specs->capacity, specs->hashbitlen, specs->delimitedSuffix)) {
-            printf("Incorrect Keccak parameters (%d, %d, %d, 0x%02x).\n", specs->rate, specs->capacity, specs->hashbitlen, specs->delimitedSuffix);
-            return -1;
-        }
-        else
-            return 0;
-    }
-    else if (specs->algorithm == algorithm_K12) {
-        if (KangarooTwelve_Initialize(&instance->k12, specs->hashbitlen/8)) {
-            printf("Incorrect KangarooTwelve parameters.\n");
-            return -1;
-        }
-        else
-            return 0;
-    }
-    else if (specs->algorithm == algorithm_ParallelHash) {
-        if (specs->capacity == 256) {
-            if (ParallelHash128_Initialize(&instance->ph, specs->blockByteLen, specs->hashbitlen, "", 0)) {
-                printf("Incorrect ParallelHash128 parameters.\n");
-                return -1;
-            }
-            else
-                return 0;
-        }
-       else if (specs->capacity == 512) {
-            if (ParallelHash256_Initialize(&instance->ph, specs->blockByteLen, specs->hashbitlen, "", 0)) {
-                printf("Incorrect ParallelHash256 parameters.\n");
-                return -1;
-            }
-            else
-                return 0;
-        }
-        else {
-            printf("Incorrect ParallelHash parameters.\n");
-            return -1;
-        }
-    }
-    else
-        return -1;
-}
-
-int hashUpdate(Instance *instance, const Specifications *specs, const unsigned char *buffer, size_t size)
-{
-    if (specs->algorithm == algorithm_Keccak)
-        Keccak_HashUpdate(&instance->keccak, buffer, size*8);
-    else if (specs->algorithm == algorithm_K12)
-        KangarooTwelve_Update(&instance->k12, buffer, size);
-    else if ((specs->algorithm == algorithm_ParallelHash) && (specs->capacity == 256))
-        ParallelHash128_Update(&instance->ph, buffer, size*8);
-    else if ((specs->algorithm == algorithm_ParallelHash) && (specs->capacity == 512))
-        ParallelHash256_Update(&instance->ph, buffer, size*8);
-    return 0;
-}
-
-int hashFinal(Instance *instance, const Specifications *specs, unsigned char *buffer)
-{
-    if (specs->algorithm == algorithm_Keccak)
-        Keccak_HashFinal(&instance->keccak, buffer);
-    else if (specs->algorithm == algorithm_K12)
-        KangarooTwelve_Final(&instance->k12, buffer, "", 0);
-    else if ((specs->algorithm == algorithm_ParallelHash) && (specs->capacity == 256))
-        ParallelHash128_Final(&instance->ph, buffer);
-    else if ((specs->algorithm == algorithm_ParallelHash) && (specs->capacity == 512))
-        ParallelHash256_Final(&instance->ph, buffer);
-    return 0;
-}
-
-int processFile(const char *fileName, const Specifications *specs, int base64)
-{
-    FILE *fp;
-    Instance instance;
-    size_t read;
-    unsigned char buffer[bufferSize];
-    char display[bufferSize*2+1];
-
-    if (specs->hashbitlen > (bufferSize*8)) {
-        printf("The requested digest length (%d bits) does not fit in the buffer.\n", specs->hashbitlen);
-        return -1;
-    }
-    if (strcmp("-", fileName) == 0) {
-        fp = stdin;
-    }
-    else {
-        fp = fopen(fileName, "rb");
-        if (fp == NULL) {
-            printf("File '%s' could not be opened.\n", fileName);
-            return -1;
-        }
-    }
-    if (hashInitialize(&instance, specs)) {
-        fclose(fp);
-        return -1;
-    }
-    do {
-        read = fread(buffer, 1, bufferSize, fp);
-        if (read > 0)
-            hashUpdate(&instance, specs, buffer, read);
-    } while(read>0);
-    if (fp != stdin) {
-        fclose(fp);
-    }
-    hashFinal(&instance, specs, buffer);
-    if (base64) {
-        if (base64encode(buffer, (specs->hashbitlen+7)/8, display, bufferSize*2)) {
-            printf("Error while converting to base64.\n");
-            return -1;
-        }
-    }
-    else {
-        if (hexencode(buffer, (specs->hashbitlen+7)/8, display, bufferSize*2)) {
-            printf("Error while converting to hex.\n");
-            return -1;
-        }
-    }
-    printf("%s  ", display);
-    printf("%s\n", fileName);
-    return 0;
-}
-
-int processString(const char *input, const Specifications *specs, int base64)
-{
-    Instance instance;
-    unsigned char buffer[bufferSize];
-    char display[bufferSize*2+1];
-
-    if (specs->hashbitlen > (bufferSize*8)) {
-        printf("The requested digest length (%d bits) does not fit in the buffer.\n", specs->hashbitlen);
-        return -1;
-    }
-    if (hashInitialize(&instance, specs)) {
-        return -1;
-    }
-    hashUpdate(&instance, specs, input, strlen(input));
-    hashFinal(&instance, specs, buffer);
-    if (base64) {
-        if (base64encode(buffer, (specs->hashbitlen+7)/8, display, bufferSize*2)) {
-            printf("Error while converting to base64.\n");
-            return -1;
-        }
-    }
-    else {
-        if (hexencode(buffer, (specs->hashbitlen+7)/8, display, bufferSize*2)) {
-            printf("Error while converting to hex.\n");
-            return -1;
-        }
-    }
-    printf("%s  ", display);
-    printf("\"%s\"\n", input);
-    return 0;
-}
-
-void printHelp()
-{
-    printf("Usage: KeccakSum [options] [file names] [options] [file names] ...\n\n");
-    printf("  --help or -h                To display this page\n");
-    printf("  --base64                    Print in base64\n");
-    printf("  --hex                       Print in hexadecimal\n");
-    printf("  --outputbits <numberOfBits> Number of bits as output\n");
-    printf("  --shake128                  Use SHAKE128\n");
-    printf("  --shake256                  Use SHAKE256\n");
-    printf("  --sha3-224                  Use SHA3-224\n");
-    printf("  --sha3-256                  Use SHA3-256\n");
-    printf("  --sha3-384                  Use SHA3-384\n");
-    printf("  --sha3-512                  Use SHA3-512\n");
-    printf("  --no-suffix                 Use 0x01 as delimited suffix (pure Keccak)\n");
-    printf("  --ethereum                  Equivalent to --sha3-256 --no-suffix\n");
-    printf("  --kangarootwelve or --k12   Use KangarooTwelve\n");
-    printf("  --ph128                     Use ParallelHash128\n");
-    printf("  --ph256                     Use ParallelHash256\n");
-    printf("  -B <block size in bytes>    ParallelHash's B parameter\n");
-    printf("  --string <string>           String to hash\n");
-    printf("  <file name>                 File to hash\n\n");
-    printf("The options are processed in order.\nBy default, it uses SHAKE128 and base64 display.\n");
-    printf("With no file names, or when file name is -, it reads standard input.\n"); 
-}
-
-int process(int argc, char* argv[])
-{
-    Specifications specs;
-    int base64 = 1;
-    int i, r;
-    int was_filename = 0;
-    specs.algorithm = algorithm_Keccak;
-    specs.rate = 1344;
-    specs.capacity = 256;
-    specs.hashbitlen = 264;
-    specs.delimitedSuffix = 0x1F;
-
-    for(i=1; i<argc; i++) {
-        int outputbits;
-        if (strcmp("--base64", argv[i]) == 0)
-            base64 = 1;
-        else if (strcmp("--hex", argv[i]) == 0)
-            base64 = 0;
-        else if ((strcmp("--outputbits", argv[i]) == 0) || (strcmp("-n", argv[i]) == 0)) {
-            if ((i+1) >= argc) {
-                printf("Error: missing argument for --outputbits\n");
-                return -1;
-            }
-            outputbits = 0;
-            if (sscanf(argv[i+1], "%d", &outputbits) && (outputbits > 0) && ((outputbits % 8) == 0)) {
-                specs.hashbitlen = outputbits;
-                i++;
-            }
-            else {
-                printf("Error: argument for --outputbits option must be a positive integer multiple of 8\n");
-                return -1;
-            }
-        }
-        else if (strcmp("--shake128", argv[i]) == 0) {
-            specs.rate = 1344;
-            specs.capacity = 256;
-            specs.hashbitlen = 264;
-            specs.delimitedSuffix = 0x1F;
-            base64 = 1;
-        }
-        else if (strcmp("--shake256", argv[i]) == 0) {
-            specs.rate = 1088;
-            specs.capacity = 512;
-            specs.hashbitlen = 528;
-            specs.delimitedSuffix = 0x1F;
-            base64 = 1;
-        }
-        else if (strcmp("--sha3-224", argv[i]) == 0) {
-            specs.rate = 1152;
-            specs.capacity = 448;
-            specs.hashbitlen = 224;
-            specs.delimitedSuffix = 0x06;
-            base64 = 0;
-        }
-        else if (strcmp("--sha3-256", argv[i]) == 0) {
-            specs.rate = 1088;
-            specs.capacity = 512;
-            specs.hashbitlen = 256;
-            specs.delimitedSuffix = 0x06;
-            base64 = 0;
-        }
-        else if (strcmp("--sha3-384", argv[i]) == 0) {
-            specs.rate = 832;
-            specs.capacity = 768;
-            specs.hashbitlen = 384;
-            specs.delimitedSuffix = 0x06;
-            base64 = 0;
-        }
-        else if (strcmp("--sha3-512", argv[i]) == 0) {
-            specs.rate = 576;
-            specs.capacity = 1024;
-            specs.hashbitlen = 512;
-            specs.delimitedSuffix = 0x06;
-            base64 = 0;
-        }
-        else if (strcmp("--no-suffix", argv[i]) == 0) {
-            specs.delimitedSuffix = 0x01;
-        }
-        else if (strcmp("--ethereum", argv[i]) == 0) {
-            specs.rate = 1088;
-            specs.capacity = 512;
-            specs.hashbitlen = 256;
-            specs.delimitedSuffix = 0x01;
-            base64 = 0;
-        }
-        else if ((strcmp("--kangarootwelve", argv[i]) == 0) || (strcmp("--k12", argv[i]) == 0)) {
-            specs.algorithm = algorithm_K12;
-            specs.hashbitlen = 264;
-            base64 = 1;
-        }
-        else if (strcmp("--ph128", argv[i]) == 0) {
-            specs.algorithm = algorithm_ParallelHash;
-            specs.capacity = 256;
-            specs.hashbitlen = 264;
-            specs.blockByteLen = 8192;
-            base64 = 1;
-        }
-        else if (strcmp("--ph256", argv[i]) == 0) {
-            specs.algorithm = algorithm_ParallelHash;
-            specs.capacity = 512;
-            specs.hashbitlen = 528;
-            specs.blockByteLen = 8192;
-            base64 = 1;
-        }
-        else if (strcmp("-B", argv[i]) == 0) {
-            int blockByteLen;
-            if ((i+1) >= argc) {
-                printf("Error: missing argument for -B\n");
-                return -1;
-            }
-            blockByteLen = 0;
-            if (sscanf(argv[i+1], "%d", &blockByteLen) && (blockByteLen > 0)) {
-                specs.blockByteLen = blockByteLen;
-                i++;
-            }
-            else {
-                printf("Error: argument for -B option must be a positive power of 2\n");
-                return -1;
-            }
-        }
-        else if (strcmp("--string", argv[i]) == 0) {
-            if ((i+1) >= argc) {
-                printf("Error: missing argument for --string\n");
-                return -1;
-            }
-            i++;
-            processString(argv[i], &specs, base64);
-        }
-        else if (strcmp("--help", argv[i]) == 0 || strcmp("-h", argv[i]) == 0) {
-            printHelp();
-            return 0;
-        }
-        else {
-            if (strlen(argv[i]) > 2) {
-                if ((argv[i][0] == '-') && (argv[i][1] == '-')) {
-                    printf("Unrecognized command '%s'\n", argv[i]);
-                    return -1;
-                }
-            }
-            was_filename = 1;
-            r = processFile(argv[i], &specs, base64);
-            if (r)
-                return r;
-        }
-    }
-    if (was_filename == 0) {
-        r = processFile("-", &specs, base64);
-        if (r)
-            return r;
-    }
-    return 0;
-}
-
-int main(int argc, char* argv[])
-{
-    return process(argc, argv);
-}