From aa8c37ff0b85ff3bebe3c978f3d6ed4b8752fa78 Mon Sep 17 00:00:00 2001 From: Balazs Komuves Date: Sat, 14 Oct 2023 19:34:04 +0200 Subject: [PATCH] add SHA256 benchmark (Unix, self-contained C, and Merkle root over linear chunks in multithreaded C) --- hash/cpu/bench/SHA256/C/bench_linear | Bin 0 -> 18212 bytes hash/cpu/bench/SHA256/C/bench_linear.c | 72 ++ hash/cpu/bench/SHA256/C/bench_merkle | Bin 0 -> 22860 bytes hash/cpu/bench/SHA256/C/bench_merkle.c | 187 +++++ hash/cpu/bench/SHA256/C/build.sh | 4 + hash/cpu/bench/SHA256/C/setup.sh | 2 + hash/cpu/bench/SHA256/C/sha2.c | 1064 ++++++++++++++++++++++++ hash/cpu/bench/SHA256/C/sha2.h | 197 +++++ hash/cpu/bench/SHA256/Unix/setup.sh | 2 + 9 files changed, 1528 insertions(+) create mode 100755 hash/cpu/bench/SHA256/C/bench_linear create mode 100644 hash/cpu/bench/SHA256/C/bench_linear.c create mode 100755 hash/cpu/bench/SHA256/C/bench_merkle create mode 100644 hash/cpu/bench/SHA256/C/bench_merkle.c create mode 100755 hash/cpu/bench/SHA256/C/build.sh create mode 100755 hash/cpu/bench/SHA256/C/setup.sh create mode 100755 hash/cpu/bench/SHA256/C/sha2.c create mode 100755 hash/cpu/bench/SHA256/C/sha2.h create mode 100755 hash/cpu/bench/SHA256/Unix/setup.sh diff --git a/hash/cpu/bench/SHA256/C/bench_linear b/hash/cpu/bench/SHA256/C/bench_linear new file mode 100755 index 0000000000000000000000000000000000000000..6881fd9d124986033311e4120608ecf9f123f533 GIT binary patch literal 18212 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 literal 0 HcmV?d00001 diff --git a/hash/cpu/bench/SHA256/C/bench_linear.c b/hash/cpu/bench/SHA256/C/bench_linear.c new file mode 100644 index 0000000..0eaddc7 --- /dev/null +++ b/hash/cpu/bench/SHA256/C/bench_linear.c @@ -0,0 +1,72 @@ +// linear hashing of fake data + +#include +#include +#include "sha2.h" + +/* + +void SHA256_Init(SHA256_CTX *); +void SHA256_Update(SHA256_CTX*, const uint8_t*, size_t); +void SHA256_Final(uint8_t[SHA256_DIGEST_LENGTH], SHA256_CTX*); + +*/ + +//------------------------------------------------------------------------------ + +void print_hash(uint8_t *hash) { + for(int i=0;i:\n"); + exit(-1); + break; + + } +} \ No newline at end of file diff --git a/hash/cpu/bench/SHA256/C/bench_merkle b/hash/cpu/bench/SHA256/C/bench_merkle new file mode 100755 index 0000000000000000000000000000000000000000..1165b5bb05ac9a2f1f81f96e2ed45ebfc4d6cbb7 GIT binary patch literal 22860 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 OTL27RfGmEU0{;c7ffvXC literal 0 HcmV?d00001 diff --git a/hash/cpu/bench/SHA256/C/bench_merkle.c b/hash/cpu/bench/SHA256/C/bench_merkle.c new file mode 100644 index 0000000..28b4c56 --- /dev/null +++ b/hash/cpu/bench/SHA256/C/bench_merkle.c @@ -0,0 +1,187 @@ +// linear hashing 2048 byte chunks then building a Merkle tree on the top of them +// using `nThreads` parallel threads + +#include +#include +#include +#include +#include + +#include "sha2.h" + +/* + +void SHA256_Init(SHA256_CTX *); +void SHA256_Update(SHA256_CTX*, const uint8_t*, size_t); +void SHA256_Final(uint8_t[SHA256_DIGEST_LENGTH], SHA256_CTX*); + +*/ + +//------------------------------------------------------------------------------ + +void print_hash(uint8_t *hash) { + for(int i=0;i0) { log++; a=a>>1; } + return log; +} + +//------------------------------------------------------------------------------ + +#define CHUNK_SIZE 2048 +#define CHUNKS_PER_MEGABYTE ((1024*1024)/(CHUNK_SIZE)) + +void hash_chunk(int idx, uint8_t *chunk_data, uint8_t *tgt) { + SHA256_CTX ctx; + SHA256_Init(&ctx); + SHA256_Update(&ctx, chunk_data, CHUNK_SIZE ); + SHA256_Final( tgt, &ctx ); +} + +//------------------------------------------------------------------------------ + +void sha256_compression( const uint8_t *src, uint8_t *tgt ) { + SHA256_CTX ctx; + SHA256_Init(&ctx); + SHA256_Update(&ctx, src, 2*SHA256_DIGEST_LENGTH ); + SHA256_Final( tgt, &ctx ); +} + +void calc_merkle_root( int logN, uint8_t *data, uint8_t *tgt ) { + + int N = (1<nChunks ); + + // cretae fake data + unsigned char buffer[CHUNK_SIZE]; + for(int i=0;inChunks; i++) { + hash_chunk(i, buffer, leaves + i*SHA256_DIGEST_LENGTH ); + } + + // calculate the merkle root of the subtree + int logNChunks = integerLog2(thread_data->nChunks); + calc_merkle_root( logNChunks , leaves, thread_data->tgt ); + + free(leaves); + pthread_exit(NULL); +} + +// ----------------------------------------------------------------------------- + +// we assume nThreads is a power of two +// and that the number of chunks per thread is also a power of two +void merkle_root_multithread(int megabytes, int nThreads) { + + int logNThreads = integerLog2(nThreads); + printf("nThreads = %d; logNThreads = %d\n",nThreads,logNThreads); + assert( nThreads == (1<:\n"); + printf("$ ./bench_merkle :\n"); + exit(-1); + break; + } + + printf("calculating SHA2 chunked Merkle root for %d Mb of data on %d threads...\n",megabytes,nThreads); + merkle_root_multithread(megabytes, nThreads); + + printf("\n"); +} diff --git a/hash/cpu/bench/SHA256/C/build.sh b/hash/cpu/bench/SHA256/C/build.sh new file mode 100755 index 0000000..bb1c9b5 --- /dev/null +++ b/hash/cpu/bench/SHA256/C/build.sh @@ -0,0 +1,4 @@ +#!/bin/bash + +gcc -O3 sha2.c bench_linear.c -o bench_linear +gcc -O3 sha2.c bench_merkle.c -o bench_merkle diff --git a/hash/cpu/bench/SHA256/C/setup.sh b/hash/cpu/bench/SHA256/C/setup.sh new file mode 100755 index 0000000..934e19e --- /dev/null +++ b/hash/cpu/bench/SHA256/C/setup.sh @@ -0,0 +1,2 @@ +#!/bin/bash +echo "setup" \ No newline at end of file diff --git a/hash/cpu/bench/SHA256/C/sha2.c b/hash/cpu/bench/SHA256/C/sha2.c new file mode 100755 index 0000000..fb42ade --- /dev/null +++ b/hash/cpu/bench/SHA256/C/sha2.c @@ -0,0 +1,1064 @@ +/* + * FILE: sha2.c + * AUTHOR: Aaron D. Gifford - http://www.aarongifford.com/ + * + * Copyright (c) 2000-2001, Aaron D. Gifford + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the copyright holder nor the names of contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + */ + +#include /* memcpy()/memset() or bcopy()/bzero() */ +#include /* assert() */ +#include "sha2.h" + +/* + * ASSERT NOTE: + * Some sanity checking code is included using assert(). On my FreeBSD + * system, this additional code can be removed by compiling with NDEBUG + * defined. Check your own systems manpage on assert() to see how to + * compile WITHOUT the sanity checking code on your system. + * + * UNROLLED TRANSFORM LOOP NOTE: + * You can define SHA2_UNROLL_TRANSFORM to use the unrolled transform + * loop version for the hash transform rounds (defined using macros + * later in this file). Either define on the command line, for example: + * + * cc -DSHA2_UNROLL_TRANSFORM -o sha2 sha2.c sha2prog.c + * + * or define below: + * + * #define SHA2_UNROLL_TRANSFORM + * + */ + + +/*** SHA-256/384/512 Machine Architecture Definitions *****************/ +/* + * BYTE_ORDER NOTE: + * + * Please make sure that your system defines BYTE_ORDER. If your + * architecture is little-endian, make sure it also defines + * LITTLE_ENDIAN and that the two (BYTE_ORDER and LITTLE_ENDIAN) are + * equivilent. + * + * If your system does not define the above, then you can do so by + * hand like this: + * + * #define LITTLE_ENDIAN 1234 + * #define BIG_ENDIAN 4321 + * + * And for little-endian machines, add: + * + * #define BYTE_ORDER LITTLE_ENDIAN + * + * Or for big-endian machines: + * + * #define BYTE_ORDER BIG_ENDIAN + * + * The FreeBSD machine this was written on defines BYTE_ORDER + * appropriately by including (which in turn includes + * where the appropriate definitions are actually + * made). + */ +#if !defined(BYTE_ORDER) || (BYTE_ORDER != LITTLE_ENDIAN && BYTE_ORDER != BIG_ENDIAN) +#error Define BYTE_ORDER to be equal to either LITTLE_ENDIAN or BIG_ENDIAN +#endif + +/* + * Define the followingsha2_* types to types of the correct length on + * the native archtecture. Most BSD systems and Linux define u_intXX_t + * types. Machines with very recent ANSI C headers, can use the + * uintXX_t definintions from inttypes.h by defining SHA2_USE_INTTYPES_H + * during compile or in the sha.h header file. + * + * Machines that support neither u_intXX_t nor inttypes.h's uintXX_t + * will need to define these three typedefs below (and the appropriate + * ones in sha.h too) by hand according to their system architecture. + * + * Thank you, Jun-ichiro itojun Hagino, for suggesting using u_intXX_t + * types and pointing out recent ANSI C support for uintXX_t in inttypes.h. + */ +#ifdef SHA2_USE_INTTYPES_H + +typedef uint8_t sha2_byte; /* Exactly 1 byte */ +typedef uint32_t sha2_word32; /* Exactly 4 bytes */ +typedef uint64_t sha2_word64; /* Exactly 8 bytes */ + +#else /* SHA2_USE_INTTYPES_H */ + +typedef u_int8_t sha2_byte; /* Exactly 1 byte */ +typedef u_int32_t sha2_word32; /* Exactly 4 bytes */ +typedef u_int64_t sha2_word64; /* Exactly 8 bytes */ + +#endif /* SHA2_USE_INTTYPES_H */ + + +/*** SHA-256/384/512 Various Length Definitions ***********************/ +/* NOTE: Most of these are in sha2.h */ +#define SHA256_SHORT_BLOCK_LENGTH (SHA256_BLOCK_LENGTH - 8) +#define SHA384_SHORT_BLOCK_LENGTH (SHA384_BLOCK_LENGTH - 16) +#define SHA512_SHORT_BLOCK_LENGTH (SHA512_BLOCK_LENGTH - 16) + + +/*** ENDIAN REVERSAL MACROS *******************************************/ +#if BYTE_ORDER == LITTLE_ENDIAN +#define REVERSE32(w,x) { \ + sha2_word32 tmp = (w); \ + tmp = (tmp >> 16) | (tmp << 16); \ + (x) = ((tmp & 0xff00ff00UL) >> 8) | ((tmp & 0x00ff00ffUL) << 8); \ +} +#define REVERSE64(w,x) { \ + sha2_word64 tmp = (w); \ + tmp = (tmp >> 32) | (tmp << 32); \ + tmp = ((tmp & 0xff00ff00ff00ff00ULL) >> 8) | \ + ((tmp & 0x00ff00ff00ff00ffULL) << 8); \ + (x) = ((tmp & 0xffff0000ffff0000ULL) >> 16) | \ + ((tmp & 0x0000ffff0000ffffULL) << 16); \ +} +#endif /* BYTE_ORDER == LITTLE_ENDIAN */ + +/* + * Macro for incrementally adding the unsigned 64-bit integer n to the + * unsigned 128-bit integer (represented using a two-element array of + * 64-bit words): + */ +#define ADDINC128(w,n) { \ + (w)[0] += (sha2_word64)(n); \ + if ((w)[0] < (n)) { \ + (w)[1]++; \ + } \ +} + +/* + * Macros for copying blocks of memory and for zeroing out ranges + * of memory. Using these macros makes it easy to switch from + * using memset()/memcpy() and using bzero()/bcopy(). + * + * Please define either SHA2_USE_MEMSET_MEMCPY or define + * SHA2_USE_BZERO_BCOPY depending on which function set you + * choose to use: + */ +#if !defined(SHA2_USE_MEMSET_MEMCPY) && !defined(SHA2_USE_BZERO_BCOPY) +/* Default to memset()/memcpy() if no option is specified */ +#define SHA2_USE_MEMSET_MEMCPY 1 +#endif +#if defined(SHA2_USE_MEMSET_MEMCPY) && defined(SHA2_USE_BZERO_BCOPY) +/* Abort with an error if BOTH options are defined */ +#error Define either SHA2_USE_MEMSET_MEMCPY or SHA2_USE_BZERO_BCOPY, not both! +#endif + +#ifdef SHA2_USE_MEMSET_MEMCPY +#define MEMSET_BZERO(p,l) memset((p), 0, (l)) +#define MEMCPY_BCOPY(d,s,l) memcpy((d), (s), (l)) +#endif +#ifdef SHA2_USE_BZERO_BCOPY +#define MEMSET_BZERO(p,l) bzero((p), (l)) +#define MEMCPY_BCOPY(d,s,l) bcopy((s), (d), (l)) +#endif + + +/*** THE SIX LOGICAL FUNCTIONS ****************************************/ +/* + * Bit shifting and rotation (used by the six SHA-XYZ logical functions: + * + * NOTE: The naming of R and S appears backwards here (R is a SHIFT and + * S is a ROTATION) because the SHA-256/384/512 description document + * (see http://csrc.nist.gov/cryptval/shs/sha256-384-512.pdf) uses this + * same "backwards" definition. + */ +/* Shift-right (used in SHA-256, SHA-384, and SHA-512): */ +#define R(b,x) ((x) >> (b)) +/* 32-bit Rotate-right (used in SHA-256): */ +#define S32(b,x) (((x) >> (b)) | ((x) << (32 - (b)))) +/* 64-bit Rotate-right (used in SHA-384 and SHA-512): */ +#define S64(b,x) (((x) >> (b)) | ((x) << (64 - (b)))) + +/* Two of six logical functions used in SHA-256, SHA-384, and SHA-512: */ +#define Ch(x,y,z) (((x) & (y)) ^ ((~(x)) & (z))) +#define Maj(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z))) + +/* Four of six logical functions used in SHA-256: */ +#define Sigma0_256(x) (S32(2, (x)) ^ S32(13, (x)) ^ S32(22, (x))) +#define Sigma1_256(x) (S32(6, (x)) ^ S32(11, (x)) ^ S32(25, (x))) +#define sigma0_256(x) (S32(7, (x)) ^ S32(18, (x)) ^ R(3 , (x))) +#define sigma1_256(x) (S32(17, (x)) ^ S32(19, (x)) ^ R(10, (x))) + +/* Four of six logical functions used in SHA-384 and SHA-512: */ +#define Sigma0_512(x) (S64(28, (x)) ^ S64(34, (x)) ^ S64(39, (x))) +#define Sigma1_512(x) (S64(14, (x)) ^ S64(18, (x)) ^ S64(41, (x))) +#define sigma0_512(x) (S64( 1, (x)) ^ S64( 8, (x)) ^ R( 7, (x))) +#define sigma1_512(x) (S64(19, (x)) ^ S64(61, (x)) ^ R( 6, (x))) + +/*** INTERNAL FUNCTION PROTOTYPES *************************************/ +/* NOTE: These should not be accessed directly from outside this + * library -- they are intended for private internal visibility/use + * only. + */ +void SHA512_Last(SHA512_CTX*); +void SHA256_Transform(SHA256_CTX*, const sha2_word32*); +void SHA512_Transform(SHA512_CTX*, const sha2_word64*); + + +/*** SHA-XYZ INITIAL HASH VALUES AND CONSTANTS ************************/ +/* Hash constant words K for SHA-256: */ +const static sha2_word32 K256[64] = { + 0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL, + 0x3956c25bUL, 0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL, + 0xd807aa98UL, 0x12835b01UL, 0x243185beUL, 0x550c7dc3UL, + 0x72be5d74UL, 0x80deb1feUL, 0x9bdc06a7UL, 0xc19bf174UL, + 0xe49b69c1UL, 0xefbe4786UL, 0x0fc19dc6UL, 0x240ca1ccUL, + 0x2de92c6fUL, 0x4a7484aaUL, 0x5cb0a9dcUL, 0x76f988daUL, + 0x983e5152UL, 0xa831c66dUL, 0xb00327c8UL, 0xbf597fc7UL, + 0xc6e00bf3UL, 0xd5a79147UL, 0x06ca6351UL, 0x14292967UL, + 0x27b70a85UL, 0x2e1b2138UL, 0x4d2c6dfcUL, 0x53380d13UL, + 0x650a7354UL, 0x766a0abbUL, 0x81c2c92eUL, 0x92722c85UL, + 0xa2bfe8a1UL, 0xa81a664bUL, 0xc24b8b70UL, 0xc76c51a3UL, + 0xd192e819UL, 0xd6990624UL, 0xf40e3585UL, 0x106aa070UL, + 0x19a4c116UL, 0x1e376c08UL, 0x2748774cUL, 0x34b0bcb5UL, + 0x391c0cb3UL, 0x4ed8aa4aUL, 0x5b9cca4fUL, 0x682e6ff3UL, + 0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL, + 0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL +}; + +/* Initial hash value H for SHA-256: */ +const static sha2_word32 sha256_initial_hash_value[8] = { + 0x6a09e667UL, + 0xbb67ae85UL, + 0x3c6ef372UL, + 0xa54ff53aUL, + 0x510e527fUL, + 0x9b05688cUL, + 0x1f83d9abUL, + 0x5be0cd19UL +}; + +/* Hash constant words K for SHA-384 and SHA-512: */ +const static sha2_word64 K512[80] = { + 0x428a2f98d728ae22ULL, 0x7137449123ef65cdULL, + 0xb5c0fbcfec4d3b2fULL, 0xe9b5dba58189dbbcULL, + 0x3956c25bf348b538ULL, 0x59f111f1b605d019ULL, + 0x923f82a4af194f9bULL, 0xab1c5ed5da6d8118ULL, + 0xd807aa98a3030242ULL, 0x12835b0145706fbeULL, + 0x243185be4ee4b28cULL, 0x550c7dc3d5ffb4e2ULL, + 0x72be5d74f27b896fULL, 0x80deb1fe3b1696b1ULL, + 0x9bdc06a725c71235ULL, 0xc19bf174cf692694ULL, + 0xe49b69c19ef14ad2ULL, 0xefbe4786384f25e3ULL, + 0x0fc19dc68b8cd5b5ULL, 0x240ca1cc77ac9c65ULL, + 0x2de92c6f592b0275ULL, 0x4a7484aa6ea6e483ULL, + 0x5cb0a9dcbd41fbd4ULL, 0x76f988da831153b5ULL, + 0x983e5152ee66dfabULL, 0xa831c66d2db43210ULL, + 0xb00327c898fb213fULL, 0xbf597fc7beef0ee4ULL, + 0xc6e00bf33da88fc2ULL, 0xd5a79147930aa725ULL, + 0x06ca6351e003826fULL, 0x142929670a0e6e70ULL, + 0x27b70a8546d22ffcULL, 0x2e1b21385c26c926ULL, + 0x4d2c6dfc5ac42aedULL, 0x53380d139d95b3dfULL, + 0x650a73548baf63deULL, 0x766a0abb3c77b2a8ULL, + 0x81c2c92e47edaee6ULL, 0x92722c851482353bULL, + 0xa2bfe8a14cf10364ULL, 0xa81a664bbc423001ULL, + 0xc24b8b70d0f89791ULL, 0xc76c51a30654be30ULL, + 0xd192e819d6ef5218ULL, 0xd69906245565a910ULL, + 0xf40e35855771202aULL, 0x106aa07032bbd1b8ULL, + 0x19a4c116b8d2d0c8ULL, 0x1e376c085141ab53ULL, + 0x2748774cdf8eeb99ULL, 0x34b0bcb5e19b48a8ULL, + 0x391c0cb3c5c95a63ULL, 0x4ed8aa4ae3418acbULL, + 0x5b9cca4f7763e373ULL, 0x682e6ff3d6b2b8a3ULL, + 0x748f82ee5defb2fcULL, 0x78a5636f43172f60ULL, + 0x84c87814a1f0ab72ULL, 0x8cc702081a6439ecULL, + 0x90befffa23631e28ULL, 0xa4506cebde82bde9ULL, + 0xbef9a3f7b2c67915ULL, 0xc67178f2e372532bULL, + 0xca273eceea26619cULL, 0xd186b8c721c0c207ULL, + 0xeada7dd6cde0eb1eULL, 0xf57d4f7fee6ed178ULL, + 0x06f067aa72176fbaULL, 0x0a637dc5a2c898a6ULL, + 0x113f9804bef90daeULL, 0x1b710b35131c471bULL, + 0x28db77f523047d84ULL, 0x32caab7b40c72493ULL, + 0x3c9ebe0a15c9bebcULL, 0x431d67c49c100d4cULL, + 0x4cc5d4becb3e42b6ULL, 0x597f299cfc657e2aULL, + 0x5fcb6fab3ad6faecULL, 0x6c44198c4a475817ULL +}; + +/* Initial hash value H for SHA-384 */ +const static sha2_word64 sha384_initial_hash_value[8] = { + 0xcbbb9d5dc1059ed8ULL, + 0x629a292a367cd507ULL, + 0x9159015a3070dd17ULL, + 0x152fecd8f70e5939ULL, + 0x67332667ffc00b31ULL, + 0x8eb44a8768581511ULL, + 0xdb0c2e0d64f98fa7ULL, + 0x47b5481dbefa4fa4ULL +}; + +/* Initial hash value H for SHA-512 */ +const static sha2_word64 sha512_initial_hash_value[8] = { + 0x6a09e667f3bcc908ULL, + 0xbb67ae8584caa73bULL, + 0x3c6ef372fe94f82bULL, + 0xa54ff53a5f1d36f1ULL, + 0x510e527fade682d1ULL, + 0x9b05688c2b3e6c1fULL, + 0x1f83d9abfb41bd6bULL, + 0x5be0cd19137e2179ULL +}; + +/* + * Constant used by SHA256/384/512_End() functions for converting the + * digest to a readable hexadecimal character string: + */ +static const char *sha2_hex_digits = "0123456789abcdef"; + + +/*** SHA-256: *********************************************************/ +void SHA256_Init(SHA256_CTX* context) { + if (context == (SHA256_CTX*)0) { + return; + } + MEMCPY_BCOPY(context->state, sha256_initial_hash_value, SHA256_DIGEST_LENGTH); + MEMSET_BZERO(context->buffer, SHA256_BLOCK_LENGTH); + context->bitcount = 0; +} + +#ifdef SHA2_UNROLL_TRANSFORM + +/* Unrolled SHA-256 round macros: */ + +#if BYTE_ORDER == LITTLE_ENDIAN + +#define ROUND256_0_TO_15(a,b,c,d,e,f,g,h) \ + REVERSE32(*data++, W256[j]); \ + T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + \ + K256[j] + W256[j]; \ + (d) += T1; \ + (h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \ + j++ + + +#else /* BYTE_ORDER == LITTLE_ENDIAN */ + +#define ROUND256_0_TO_15(a,b,c,d,e,f,g,h) \ + T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + \ + K256[j] + (W256[j] = *data++); \ + (d) += T1; \ + (h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \ + j++ + +#endif /* BYTE_ORDER == LITTLE_ENDIAN */ + +#define ROUND256(a,b,c,d,e,f,g,h) \ + s0 = W256[(j+1)&0x0f]; \ + s0 = sigma0_256(s0); \ + s1 = W256[(j+14)&0x0f]; \ + s1 = sigma1_256(s1); \ + T1 = (h) + Sigma1_256(e) + Ch((e), (f), (g)) + K256[j] + \ + (W256[j&0x0f] += s1 + W256[(j+9)&0x0f] + s0); \ + (d) += T1; \ + (h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \ + j++ + +void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) { + sha2_word32 a, b, c, d, e, f, g, h, s0, s1; + sha2_word32 T1, *W256; + int j; + + W256 = (sha2_word32*)context->buffer; + + /* Initialize registers with the prev. intermediate value */ + a = context->state[0]; + b = context->state[1]; + c = context->state[2]; + d = context->state[3]; + e = context->state[4]; + f = context->state[5]; + g = context->state[6]; + h = context->state[7]; + + j = 0; + do { + /* Rounds 0 to 15 (unrolled): */ + ROUND256_0_TO_15(a,b,c,d,e,f,g,h); + ROUND256_0_TO_15(h,a,b,c,d,e,f,g); + ROUND256_0_TO_15(g,h,a,b,c,d,e,f); + ROUND256_0_TO_15(f,g,h,a,b,c,d,e); + ROUND256_0_TO_15(e,f,g,h,a,b,c,d); + ROUND256_0_TO_15(d,e,f,g,h,a,b,c); + ROUND256_0_TO_15(c,d,e,f,g,h,a,b); + ROUND256_0_TO_15(b,c,d,e,f,g,h,a); + } while (j < 16); + + /* Now for the remaining rounds to 64: */ + do { + ROUND256(a,b,c,d,e,f,g,h); + ROUND256(h,a,b,c,d,e,f,g); + ROUND256(g,h,a,b,c,d,e,f); + ROUND256(f,g,h,a,b,c,d,e); + ROUND256(e,f,g,h,a,b,c,d); + ROUND256(d,e,f,g,h,a,b,c); + ROUND256(c,d,e,f,g,h,a,b); + ROUND256(b,c,d,e,f,g,h,a); + } while (j < 64); + + /* Compute the current intermediate hash value */ + context->state[0] += a; + context->state[1] += b; + context->state[2] += c; + context->state[3] += d; + context->state[4] += e; + context->state[5] += f; + context->state[6] += g; + context->state[7] += h; + + /* Clean up */ + a = b = c = d = e = f = g = h = T1 = 0; +} + +#else /* SHA2_UNROLL_TRANSFORM */ + +void SHA256_Transform(SHA256_CTX* context, const sha2_word32* data) { + sha2_word32 a, b, c, d, e, f, g, h, s0, s1; + sha2_word32 T1, T2, *W256; + int j; + + W256 = (sha2_word32*)context->buffer; + + /* Initialize registers with the prev. intermediate value */ + a = context->state[0]; + b = context->state[1]; + c = context->state[2]; + d = context->state[3]; + e = context->state[4]; + f = context->state[5]; + g = context->state[6]; + h = context->state[7]; + + j = 0; + do { +#if BYTE_ORDER == LITTLE_ENDIAN + /* Copy data while converting to host byte order */ + REVERSE32(*data++,W256[j]); + /* Apply the SHA-256 compression function to update a..h */ + T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + W256[j]; +#else /* BYTE_ORDER == LITTLE_ENDIAN */ + /* Apply the SHA-256 compression function to update a..h with copy */ + T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + (W256[j] = *data++); +#endif /* BYTE_ORDER == LITTLE_ENDIAN */ + T2 = Sigma0_256(a) + Maj(a, b, c); + h = g; + g = f; + f = e; + e = d + T1; + d = c; + c = b; + b = a; + a = T1 + T2; + + j++; + } while (j < 16); + + do { + /* Part of the message block expansion: */ + s0 = W256[(j+1)&0x0f]; + s0 = sigma0_256(s0); + s1 = W256[(j+14)&0x0f]; + s1 = sigma1_256(s1); + + /* Apply the SHA-256 compression function to update a..h */ + T1 = h + Sigma1_256(e) + Ch(e, f, g) + K256[j] + + (W256[j&0x0f] += s1 + W256[(j+9)&0x0f] + s0); + T2 = Sigma0_256(a) + Maj(a, b, c); + h = g; + g = f; + f = e; + e = d + T1; + d = c; + c = b; + b = a; + a = T1 + T2; + + j++; + } while (j < 64); + + /* Compute the current intermediate hash value */ + context->state[0] += a; + context->state[1] += b; + context->state[2] += c; + context->state[3] += d; + context->state[4] += e; + context->state[5] += f; + context->state[6] += g; + context->state[7] += h; + + /* Clean up */ + a = b = c = d = e = f = g = h = T1 = T2 = 0; +} + +#endif /* SHA2_UNROLL_TRANSFORM */ + +void SHA256_Update(SHA256_CTX* context, const sha2_byte *data, size_t len) { + unsigned int freespace, usedspace; + + if (len == 0) { + /* Calling with no data is valid - we do nothing */ + return; + } + + /* Sanity check: */ + assert(context != (SHA256_CTX*)0 && data != (sha2_byte*)0); + + usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH; + if (usedspace > 0) { + /* Calculate how much free space is available in the buffer */ + freespace = SHA256_BLOCK_LENGTH - usedspace; + + if (len >= freespace) { + /* Fill the buffer completely and process it */ + MEMCPY_BCOPY(&context->buffer[usedspace], data, freespace); + context->bitcount += freespace << 3; + len -= freespace; + data += freespace; + SHA256_Transform(context, (sha2_word32*)context->buffer); + } else { + /* The buffer is not yet full */ + MEMCPY_BCOPY(&context->buffer[usedspace], data, len); + context->bitcount += len << 3; + /* Clean up: */ + usedspace = freespace = 0; + return; + } + } + while (len >= SHA256_BLOCK_LENGTH) { + /* Process as many complete blocks as we can */ + SHA256_Transform(context, (sha2_word32*)data); + context->bitcount += SHA256_BLOCK_LENGTH << 3; + len -= SHA256_BLOCK_LENGTH; + data += SHA256_BLOCK_LENGTH; + } + if (len > 0) { + /* There's left-overs, so save 'em */ + MEMCPY_BCOPY(context->buffer, data, len); + context->bitcount += len << 3; + } + /* Clean up: */ + usedspace = freespace = 0; +} + +void SHA256_Final(sha2_byte digest[], SHA256_CTX* context) { + sha2_word32 *d = (sha2_word32*)digest; + unsigned int usedspace; + + /* Sanity check: */ + assert(context != (SHA256_CTX*)0); + + /* If no digest buffer is passed, we don't bother doing this: */ + if (digest != (sha2_byte*)0) { + usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH; +#if BYTE_ORDER == LITTLE_ENDIAN + /* Convert FROM host byte order */ + REVERSE64(context->bitcount,context->bitcount); +#endif + if (usedspace > 0) { + /* Begin padding with a 1 bit: */ + context->buffer[usedspace++] = 0x80; + + if (usedspace <= SHA256_SHORT_BLOCK_LENGTH) { + /* Set-up for the last transform: */ + MEMSET_BZERO(&context->buffer[usedspace], SHA256_SHORT_BLOCK_LENGTH - usedspace); + } else { + if (usedspace < SHA256_BLOCK_LENGTH) { + MEMSET_BZERO(&context->buffer[usedspace], SHA256_BLOCK_LENGTH - usedspace); + } + /* Do second-to-last transform: */ + SHA256_Transform(context, (sha2_word32*)context->buffer); + + /* And set-up for the last transform: */ + MEMSET_BZERO(context->buffer, SHA256_SHORT_BLOCK_LENGTH); + } + } else { + /* Set-up for the last transform: */ + MEMSET_BZERO(context->buffer, SHA256_SHORT_BLOCK_LENGTH); + + /* Begin padding with a 1 bit: */ + *context->buffer = 0x80; + } + /* Set the bit count: */ + *(sha2_word64*)&context->buffer[SHA256_SHORT_BLOCK_LENGTH] = context->bitcount; + + /* Final transform: */ + SHA256_Transform(context, (sha2_word32*)context->buffer); + +#if BYTE_ORDER == LITTLE_ENDIAN + { + /* Convert TO host byte order */ + int j; + for (j = 0; j < 8; j++) { + REVERSE32(context->state[j],context->state[j]); + *d++ = context->state[j]; + } + } +#else + MEMCPY_BCOPY(d, context->state, SHA256_DIGEST_LENGTH); +#endif + } + + /* Clean up state data: */ + MEMSET_BZERO(context, sizeof(SHA256_CTX)); + usedspace = 0; +} + +char *SHA256_End(SHA256_CTX* context, char buffer[]) { + sha2_byte digest[SHA256_DIGEST_LENGTH], *d = digest; + int i; + + /* Sanity check: */ + assert(context != (SHA256_CTX*)0); + + if (buffer != (char*)0) { + SHA256_Final(digest, context); + + for (i = 0; i < SHA256_DIGEST_LENGTH; i++) { + *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4]; + *buffer++ = sha2_hex_digits[*d & 0x0f]; + d++; + } + *buffer = (char)0; + } else { + MEMSET_BZERO(context, sizeof(SHA256_CTX)); + } + MEMSET_BZERO(digest, SHA256_DIGEST_LENGTH); + return buffer; +} + +char* SHA256_Data(const sha2_byte* data, size_t len, char digest[SHA256_DIGEST_STRING_LENGTH]) { + SHA256_CTX context; + + SHA256_Init(&context); + SHA256_Update(&context, data, len); + return SHA256_End(&context, digest); +} + + +/*** SHA-512: *********************************************************/ +void SHA512_Init(SHA512_CTX* context) { + if (context == (SHA512_CTX*)0) { + return; + } + MEMCPY_BCOPY(context->state, sha512_initial_hash_value, SHA512_DIGEST_LENGTH); + MEMSET_BZERO(context->buffer, SHA512_BLOCK_LENGTH); + context->bitcount[0] = context->bitcount[1] = 0; +} + +#ifdef SHA2_UNROLL_TRANSFORM + +/* Unrolled SHA-512 round macros: */ +#if BYTE_ORDER == LITTLE_ENDIAN + +#define ROUND512_0_TO_15(a,b,c,d,e,f,g,h) \ + REVERSE64(*data++, W512[j]); \ + T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + \ + K512[j] + W512[j]; \ + (d) += T1, \ + (h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)), \ + j++ + + +#else /* BYTE_ORDER == LITTLE_ENDIAN */ + +#define ROUND512_0_TO_15(a,b,c,d,e,f,g,h) \ + T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + \ + K512[j] + (W512[j] = *data++); \ + (d) += T1; \ + (h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \ + j++ + +#endif /* BYTE_ORDER == LITTLE_ENDIAN */ + +#define ROUND512(a,b,c,d,e,f,g,h) \ + s0 = W512[(j+1)&0x0f]; \ + s0 = sigma0_512(s0); \ + s1 = W512[(j+14)&0x0f]; \ + s1 = sigma1_512(s1); \ + T1 = (h) + Sigma1_512(e) + Ch((e), (f), (g)) + K512[j] + \ + (W512[j&0x0f] += s1 + W512[(j+9)&0x0f] + s0); \ + (d) += T1; \ + (h) = T1 + Sigma0_512(a) + Maj((a), (b), (c)); \ + j++ + +void SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) { + sha2_word64 a, b, c, d, e, f, g, h, s0, s1; + sha2_word64 T1, *W512 = (sha2_word64*)context->buffer; + int j; + + /* Initialize registers with the prev. intermediate value */ + a = context->state[0]; + b = context->state[1]; + c = context->state[2]; + d = context->state[3]; + e = context->state[4]; + f = context->state[5]; + g = context->state[6]; + h = context->state[7]; + + j = 0; + do { + ROUND512_0_TO_15(a,b,c,d,e,f,g,h); + ROUND512_0_TO_15(h,a,b,c,d,e,f,g); + ROUND512_0_TO_15(g,h,a,b,c,d,e,f); + ROUND512_0_TO_15(f,g,h,a,b,c,d,e); + ROUND512_0_TO_15(e,f,g,h,a,b,c,d); + ROUND512_0_TO_15(d,e,f,g,h,a,b,c); + ROUND512_0_TO_15(c,d,e,f,g,h,a,b); + ROUND512_0_TO_15(b,c,d,e,f,g,h,a); + } while (j < 16); + + /* Now for the remaining rounds up to 79: */ + do { + ROUND512(a,b,c,d,e,f,g,h); + ROUND512(h,a,b,c,d,e,f,g); + ROUND512(g,h,a,b,c,d,e,f); + ROUND512(f,g,h,a,b,c,d,e); + ROUND512(e,f,g,h,a,b,c,d); + ROUND512(d,e,f,g,h,a,b,c); + ROUND512(c,d,e,f,g,h,a,b); + ROUND512(b,c,d,e,f,g,h,a); + } while (j < 80); + + /* Compute the current intermediate hash value */ + context->state[0] += a; + context->state[1] += b; + context->state[2] += c; + context->state[3] += d; + context->state[4] += e; + context->state[5] += f; + context->state[6] += g; + context->state[7] += h; + + /* Clean up */ + a = b = c = d = e = f = g = h = T1 = 0; +} + +#else /* SHA2_UNROLL_TRANSFORM */ + +void SHA512_Transform(SHA512_CTX* context, const sha2_word64* data) { + sha2_word64 a, b, c, d, e, f, g, h, s0, s1; + sha2_word64 T1, T2, *W512 = (sha2_word64*)context->buffer; + int j; + + /* Initialize registers with the prev. intermediate value */ + a = context->state[0]; + b = context->state[1]; + c = context->state[2]; + d = context->state[3]; + e = context->state[4]; + f = context->state[5]; + g = context->state[6]; + h = context->state[7]; + + j = 0; + do { +#if BYTE_ORDER == LITTLE_ENDIAN + /* Convert TO host byte order */ + REVERSE64(*data++, W512[j]); + /* Apply the SHA-512 compression function to update a..h */ + T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] + W512[j]; +#else /* BYTE_ORDER == LITTLE_ENDIAN */ + /* Apply the SHA-512 compression function to update a..h with copy */ + T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] + (W512[j] = *data++); +#endif /* BYTE_ORDER == LITTLE_ENDIAN */ + T2 = Sigma0_512(a) + Maj(a, b, c); + h = g; + g = f; + f = e; + e = d + T1; + d = c; + c = b; + b = a; + a = T1 + T2; + + j++; + } while (j < 16); + + do { + /* Part of the message block expansion: */ + s0 = W512[(j+1)&0x0f]; + s0 = sigma0_512(s0); + s1 = W512[(j+14)&0x0f]; + s1 = sigma1_512(s1); + + /* Apply the SHA-512 compression function to update a..h */ + T1 = h + Sigma1_512(e) + Ch(e, f, g) + K512[j] + + (W512[j&0x0f] += s1 + W512[(j+9)&0x0f] + s0); + T2 = Sigma0_512(a) + Maj(a, b, c); + h = g; + g = f; + f = e; + e = d + T1; + d = c; + c = b; + b = a; + a = T1 + T2; + + j++; + } while (j < 80); + + /* Compute the current intermediate hash value */ + context->state[0] += a; + context->state[1] += b; + context->state[2] += c; + context->state[3] += d; + context->state[4] += e; + context->state[5] += f; + context->state[6] += g; + context->state[7] += h; + + /* Clean up */ + a = b = c = d = e = f = g = h = T1 = T2 = 0; +} + +#endif /* SHA2_UNROLL_TRANSFORM */ + +void SHA512_Update(SHA512_CTX* context, const sha2_byte *data, size_t len) { + unsigned int freespace, usedspace; + + if (len == 0) { + /* Calling with no data is valid - we do nothing */ + return; + } + + /* Sanity check: */ + assert(context != (SHA512_CTX*)0 && data != (sha2_byte*)0); + + usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH; + if (usedspace > 0) { + /* Calculate how much free space is available in the buffer */ + freespace = SHA512_BLOCK_LENGTH - usedspace; + + if (len >= freespace) { + /* Fill the buffer completely and process it */ + MEMCPY_BCOPY(&context->buffer[usedspace], data, freespace); + ADDINC128(context->bitcount, freespace << 3); + len -= freespace; + data += freespace; + SHA512_Transform(context, (sha2_word64*)context->buffer); + } else { + /* The buffer is not yet full */ + MEMCPY_BCOPY(&context->buffer[usedspace], data, len); + ADDINC128(context->bitcount, len << 3); + /* Clean up: */ + usedspace = freespace = 0; + return; + } + } + while (len >= SHA512_BLOCK_LENGTH) { + /* Process as many complete blocks as we can */ + SHA512_Transform(context, (sha2_word64*)data); + ADDINC128(context->bitcount, SHA512_BLOCK_LENGTH << 3); + len -= SHA512_BLOCK_LENGTH; + data += SHA512_BLOCK_LENGTH; + } + if (len > 0) { + /* There's left-overs, so save 'em */ + MEMCPY_BCOPY(context->buffer, data, len); + ADDINC128(context->bitcount, len << 3); + } + /* Clean up: */ + usedspace = freespace = 0; +} + +void SHA512_Last(SHA512_CTX* context) { + unsigned int usedspace; + + usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH; +#if BYTE_ORDER == LITTLE_ENDIAN + /* Convert FROM host byte order */ + REVERSE64(context->bitcount[0],context->bitcount[0]); + REVERSE64(context->bitcount[1],context->bitcount[1]); +#endif + if (usedspace > 0) { + /* Begin padding with a 1 bit: */ + context->buffer[usedspace++] = 0x80; + + if (usedspace <= SHA512_SHORT_BLOCK_LENGTH) { + /* Set-up for the last transform: */ + MEMSET_BZERO(&context->buffer[usedspace], SHA512_SHORT_BLOCK_LENGTH - usedspace); + } else { + if (usedspace < SHA512_BLOCK_LENGTH) { + MEMSET_BZERO(&context->buffer[usedspace], SHA512_BLOCK_LENGTH - usedspace); + } + /* Do second-to-last transform: */ + SHA512_Transform(context, (sha2_word64*)context->buffer); + + /* And set-up for the last transform: */ + MEMSET_BZERO(context->buffer, SHA512_BLOCK_LENGTH - 2); + } + } else { + /* Prepare for final transform: */ + MEMSET_BZERO(context->buffer, SHA512_SHORT_BLOCK_LENGTH); + + /* Begin padding with a 1 bit: */ + *context->buffer = 0x80; + } + /* Store the length of input data (in bits): */ + *(sha2_word64*)&context->buffer[SHA512_SHORT_BLOCK_LENGTH] = context->bitcount[1]; + *(sha2_word64*)&context->buffer[SHA512_SHORT_BLOCK_LENGTH+8] = context->bitcount[0]; + + /* Final transform: */ + SHA512_Transform(context, (sha2_word64*)context->buffer); +} + +void SHA512_Final(sha2_byte digest[], SHA512_CTX* context) { + sha2_word64 *d = (sha2_word64*)digest; + + /* Sanity check: */ + assert(context != (SHA512_CTX*)0); + + /* If no digest buffer is passed, we don't bother doing this: */ + if (digest != (sha2_byte*)0) { + SHA512_Last(context); + + /* Save the hash data for output: */ +#if BYTE_ORDER == LITTLE_ENDIAN + { + /* Convert TO host byte order */ + int j; + for (j = 0; j < 8; j++) { + REVERSE64(context->state[j],context->state[j]); + *d++ = context->state[j]; + } + } +#else + MEMCPY_BCOPY(d, context->state, SHA512_DIGEST_LENGTH); +#endif + } + + /* Zero out state data */ + MEMSET_BZERO(context, sizeof(SHA512_CTX)); +} + +char *SHA512_End(SHA512_CTX* context, char buffer[]) { + sha2_byte digest[SHA512_DIGEST_LENGTH], *d = digest; + int i; + + /* Sanity check: */ + assert(context != (SHA512_CTX*)0); + + if (buffer != (char*)0) { + SHA512_Final(digest, context); + + for (i = 0; i < SHA512_DIGEST_LENGTH; i++) { + *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4]; + *buffer++ = sha2_hex_digits[*d & 0x0f]; + d++; + } + *buffer = (char)0; + } else { + MEMSET_BZERO(context, sizeof(SHA512_CTX)); + } + MEMSET_BZERO(digest, SHA512_DIGEST_LENGTH); + return buffer; +} + +char* SHA512_Data(const sha2_byte* data, size_t len, char digest[SHA512_DIGEST_STRING_LENGTH]) { + SHA512_CTX context; + + SHA512_Init(&context); + SHA512_Update(&context, data, len); + return SHA512_End(&context, digest); +} + + +/*** SHA-384: *********************************************************/ +void SHA384_Init(SHA384_CTX* context) { + if (context == (SHA384_CTX*)0) { + return; + } + MEMCPY_BCOPY(context->state, sha384_initial_hash_value, SHA512_DIGEST_LENGTH); + MEMSET_BZERO(context->buffer, SHA384_BLOCK_LENGTH); + context->bitcount[0] = context->bitcount[1] = 0; +} + +void SHA384_Update(SHA384_CTX* context, const sha2_byte* data, size_t len) { + SHA512_Update((SHA512_CTX*)context, data, len); +} + +void SHA384_Final(sha2_byte digest[], SHA384_CTX* context) { + sha2_word64 *d = (sha2_word64*)digest; + + /* Sanity check: */ + assert(context != (SHA384_CTX*)0); + + /* If no digest buffer is passed, we don't bother doing this: */ + if (digest != (sha2_byte*)0) { + SHA512_Last((SHA512_CTX*)context); + + /* Save the hash data for output: */ +#if BYTE_ORDER == LITTLE_ENDIAN + { + /* Convert TO host byte order */ + int j; + for (j = 0; j < 6; j++) { + REVERSE64(context->state[j],context->state[j]); + *d++ = context->state[j]; + } + } +#else + MEMCPY_BCOPY(d, context->state, SHA384_DIGEST_LENGTH); +#endif + } + + /* Zero out state data */ + MEMSET_BZERO(context, sizeof(SHA384_CTX)); +} + +char *SHA384_End(SHA384_CTX* context, char buffer[]) { + sha2_byte digest[SHA384_DIGEST_LENGTH], *d = digest; + int i; + + /* Sanity check: */ + assert(context != (SHA384_CTX*)0); + + if (buffer != (char*)0) { + SHA384_Final(digest, context); + + for (i = 0; i < SHA384_DIGEST_LENGTH; i++) { + *buffer++ = sha2_hex_digits[(*d & 0xf0) >> 4]; + *buffer++ = sha2_hex_digits[*d & 0x0f]; + d++; + } + *buffer = (char)0; + } else { + MEMSET_BZERO(context, sizeof(SHA384_CTX)); + } + MEMSET_BZERO(digest, SHA384_DIGEST_LENGTH); + return buffer; +} + +char* SHA384_Data(const sha2_byte* data, size_t len, char digest[SHA384_DIGEST_STRING_LENGTH]) { + SHA384_CTX context; + + SHA384_Init(&context); + SHA384_Update(&context, data, len); + return SHA384_End(&context, digest); +} + diff --git a/hash/cpu/bench/SHA256/C/sha2.h b/hash/cpu/bench/SHA256/C/sha2.h new file mode 100755 index 0000000..bf759ad --- /dev/null +++ b/hash/cpu/bench/SHA256/C/sha2.h @@ -0,0 +1,197 @@ +/* + * FILE: sha2.h + * AUTHOR: Aaron D. Gifford - http://www.aarongifford.com/ + * + * Copyright (c) 2000-2001, Aaron D. Gifford + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of the copyright holder nor the names of contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTOR(S) ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTOR(S) BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: sha2.h,v 1.1 2001/11/08 00:02:01 adg Exp adg $ + */ + +#ifndef __SHA2_H__ +#define __SHA2_H__ + +#ifdef __cplusplus +extern "C" { +#endif + + +/* + * Import u_intXX_t size_t type definitions from system headers. You + * may need to change this, or define these things yourself in this + * file. + */ +#include + +#ifdef SHA2_USE_INTTYPES_H + +#include + +#endif /* SHA2_USE_INTTYPES_H */ + + +/*** SHA-256/384/512 Various Length Definitions ***********************/ +#define SHA256_BLOCK_LENGTH 64 +#define SHA256_DIGEST_LENGTH 32 +#define SHA256_DIGEST_STRING_LENGTH (SHA256_DIGEST_LENGTH * 2 + 1) +#define SHA384_BLOCK_LENGTH 128 +#define SHA384_DIGEST_LENGTH 48 +#define SHA384_DIGEST_STRING_LENGTH (SHA384_DIGEST_LENGTH * 2 + 1) +#define SHA512_BLOCK_LENGTH 128 +#define SHA512_DIGEST_LENGTH 64 +#define SHA512_DIGEST_STRING_LENGTH (SHA512_DIGEST_LENGTH * 2 + 1) + + +/*** SHA-256/384/512 Context Structures *******************************/ +/* NOTE: If your architecture does not define either u_intXX_t types or + * uintXX_t (from inttypes.h), you may need to define things by hand + * for your system: + */ +#if 0 +typedef unsigned char u_int8_t; /* 1-byte (8-bits) */ +typedef unsigned int u_int32_t; /* 4-bytes (32-bits) */ +typedef unsigned long long u_int64_t; /* 8-bytes (64-bits) */ +#endif +/* + * Most BSD systems already define u_intXX_t types, as does Linux. + * Some systems, however, like Compaq's Tru64 Unix instead can use + * uintXX_t types defined by very recent ANSI C standards and included + * in the file: + * + * #include + * + * If you choose to use then please define: + * + * #define SHA2_USE_INTTYPES_H + * + * Or on the command line during compile: + * + * cc -DSHA2_USE_INTTYPES_H ... + */ +#ifdef SHA2_USE_INTTYPES_H + +typedef struct _SHA256_CTX { + uint32_t state[8]; + uint64_t bitcount; + uint8_t buffer[SHA256_BLOCK_LENGTH]; +} SHA256_CTX; +typedef struct _SHA512_CTX { + uint64_t state[8]; + uint64_t bitcount[2]; + uint8_t buffer[SHA512_BLOCK_LENGTH]; +} SHA512_CTX; + +#else /* SHA2_USE_INTTYPES_H */ + +typedef struct _SHA256_CTX { + u_int32_t state[8]; + u_int64_t bitcount; + u_int8_t buffer[SHA256_BLOCK_LENGTH]; +} SHA256_CTX; +typedef struct _SHA512_CTX { + u_int64_t state[8]; + u_int64_t bitcount[2]; + u_int8_t buffer[SHA512_BLOCK_LENGTH]; +} SHA512_CTX; + +#endif /* SHA2_USE_INTTYPES_H */ + +typedef SHA512_CTX SHA384_CTX; + + +/*** SHA-256/384/512 Function Prototypes ******************************/ +#ifndef NOPROTO +#ifdef SHA2_USE_INTTYPES_H + +void SHA256_Init(SHA256_CTX *); +void SHA256_Update(SHA256_CTX*, const uint8_t*, size_t); +void SHA256_Final(uint8_t[SHA256_DIGEST_LENGTH], SHA256_CTX*); +char* SHA256_End(SHA256_CTX*, char[SHA256_DIGEST_STRING_LENGTH]); +char* SHA256_Data(const uint8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]); + +void SHA384_Init(SHA384_CTX*); +void SHA384_Update(SHA384_CTX*, const uint8_t*, size_t); +void SHA384_Final(uint8_t[SHA384_DIGEST_LENGTH], SHA384_CTX*); +char* SHA384_End(SHA384_CTX*, char[SHA384_DIGEST_STRING_LENGTH]); +char* SHA384_Data(const uint8_t*, size_t, char[SHA384_DIGEST_STRING_LENGTH]); + +void SHA512_Init(SHA512_CTX*); +void SHA512_Update(SHA512_CTX*, const uint8_t*, size_t); +void SHA512_Final(uint8_t[SHA512_DIGEST_LENGTH], SHA512_CTX*); +char* SHA512_End(SHA512_CTX*, char[SHA512_DIGEST_STRING_LENGTH]); +char* SHA512_Data(const uint8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]); + +#else /* SHA2_USE_INTTYPES_H */ + +void SHA256_Init(SHA256_CTX *); +void SHA256_Update(SHA256_CTX*, const u_int8_t*, size_t); +void SHA256_Final(u_int8_t[SHA256_DIGEST_LENGTH], SHA256_CTX*); +char* SHA256_End(SHA256_CTX*, char[SHA256_DIGEST_STRING_LENGTH]); +char* SHA256_Data(const u_int8_t*, size_t, char[SHA256_DIGEST_STRING_LENGTH]); + +void SHA384_Init(SHA384_CTX*); +void SHA384_Update(SHA384_CTX*, const u_int8_t*, size_t); +void SHA384_Final(u_int8_t[SHA384_DIGEST_LENGTH], SHA384_CTX*); +char* SHA384_End(SHA384_CTX*, char[SHA384_DIGEST_STRING_LENGTH]); +char* SHA384_Data(const u_int8_t*, size_t, char[SHA384_DIGEST_STRING_LENGTH]); + +void SHA512_Init(SHA512_CTX*); +void SHA512_Update(SHA512_CTX*, const u_int8_t*, size_t); +void SHA512_Final(u_int8_t[SHA512_DIGEST_LENGTH], SHA512_CTX*); +char* SHA512_End(SHA512_CTX*, char[SHA512_DIGEST_STRING_LENGTH]); +char* SHA512_Data(const u_int8_t*, size_t, char[SHA512_DIGEST_STRING_LENGTH]); + +#endif /* SHA2_USE_INTTYPES_H */ + +#else /* NOPROTO */ + +void SHA256_Init(); +void SHA256_Update(); +void SHA256_Final(); +char* SHA256_End(); +char* SHA256_Data(); + +void SHA384_Init(); +void SHA384_Update(); +void SHA384_Final(); +char* SHA384_End(); +char* SHA384_Data(); + +void SHA512_Init(); +void SHA512_Update(); +void SHA512_Final(); +char* SHA512_End(); +char* SHA512_Data(); + +#endif /* NOPROTO */ + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* __SHA2_H__ */ + diff --git a/hash/cpu/bench/SHA256/Unix/setup.sh b/hash/cpu/bench/SHA256/Unix/setup.sh new file mode 100755 index 0000000..934e19e --- /dev/null +++ b/hash/cpu/bench/SHA256/Unix/setup.sh @@ -0,0 +1,2 @@ +#!/bin/bash +echo "setup" \ No newline at end of file