From 50d9b6086ff6b56c6d100dcc57e71c7b13b596a5 Mon Sep 17 00:00:00 2001 From: Marko Kreen Date: Mon, 29 Oct 2012 18:13:46 +0200 Subject: [PATCH] crypto: SHA2 digests Separate module for both SHA-256 and SHA-512. --- Makefile | 2 + doc/mainpage.dox | 2 + test/test_crypto.c | 90 ++++++++++++++++ usual/crypto/digest.h | 12 +++ usual/crypto/sha256.c | 224 +++++++++++++++++++++++++++++++++++++++ usual/crypto/sha256.h | 47 ++++++++ usual/crypto/sha512.c | 241 ++++++++++++++++++++++++++++++++++++++++++ usual/crypto/sha512.h | 47 ++++++++ 8 files changed, 665 insertions(+) create mode 100644 usual/crypto/sha256.c create mode 100644 usual/crypto/sha256.h create mode 100644 usual/crypto/sha512.c create mode 100644 usual/crypto/sha512.h diff --git a/Makefile b/Makefile index 1076525..20f3385 100644 --- a/Makefile +++ b/Makefile @@ -22,6 +22,8 @@ libusual_la_SOURCES = usual/config.h.in \ usual/crypto/hmac.h usual/crypto/hmac.c \ usual/crypto/md5.h usual/crypto/md5.c \ usual/crypto/sha1.h usual/crypto/sha1.c \ + usual/crypto/sha256.h usual/crypto/sha256.c \ + usual/crypto/sha512.h usual/crypto/sha512.c \ usual/ctype.h \ usual/cxalloc.h usual/cxalloc.c \ usual/cxextra.h usual/cxextra.c \ diff --git a/doc/mainpage.dox b/doc/mainpage.dox index f12b3f4..a65f1ed 100644 --- a/doc/mainpage.dox +++ b/doc/mainpage.dox @@ -67,6 +67,8 @@ * HMAC with digest * MD5 hash * SHA1 hash + * SHA256/224 hashes + * SHA512/384 hashes * Memory Allocation * Context Allocator framework * Extra allocators diff --git a/test/test_crypto.c b/test/test_crypto.c index 789dbd6..dc3936a 100644 --- a/test/test_crypto.c +++ b/test/test_crypto.c @@ -9,6 +9,8 @@ #include #include #include +#include +#include #include #include @@ -98,6 +100,90 @@ static void test_sha1(void *ptr) end:; } +/* + * SHA224 + */ + +static const char *run_sha224(const char *str) +{ + return run_hash(str, digest_SHA224()); +} + +static void test_sha224(void *ptr) +{ + str_check(run_sha224(""), "d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f"); + str_check(run_sha224("a"), "abd37534c7d9a2efb9465de931cd7055ffdb8879563ae98078d6d6d5"); + str_check(run_sha224("abc"), "23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7"); + str_check(run_sha224("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"), "75388b16512776cc5dba5da1fd890150b0c6455cb4f58b1952522525"); + str_check(run_sha224("12345678901234567890123456789012345678901234567890123456789012345678901234567890"), "b50aecbe4e9bb0b57bc5f3ae760a8e01db24f203fb3cdcd13148046e"); +end:; +} + +/* + * SHA256 + */ + +static const char *run_sha256(const char *str) +{ + return run_hash(str, digest_SHA256()); +} + +static void test_sha256(void *ptr) +{ + str_check(run_sha256(""), "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"); + str_check(run_sha256("a"), "ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb"); + str_check(run_sha256("abc"), "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"); + str_check(run_sha256("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"), "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1"); + str_check(run_sha256("12345678901234567890123456789012345678901234567890123456789012345678901234567890"), "f371bc4a311f2b009eef952dd83ca80e2b60026c8e935592d0f9c308453c813e"); +end:; +} + +/* + * SHA384 + */ + +static const char *run_sha384(const char *str) +{ + return run_hash(str, digest_SHA384()); +} + +static void test_sha384(void *ptr) +{ + str_check(run_sha384(""), "38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b"); + str_check(run_sha384("a"), "54a59b9f22b0b80880d8427e548b7c23abd873486e1f035dce9cd697e85175033caa88e6d57bc35efae0b5afd3145f31"); + str_check(run_sha384("abc"), "cb00753f45a35e8bb5a03d699ac65007272c32ab0eded1631a8b605a43ff5bed8086072ba1e7cc2358baeca134c825a7"); + str_check(run_sha384("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"), + "3391fdddfc8dc7393707a65b1b4709397cf8b1d162af05abfe8f450de5f36bc6b0455a8520bc4e6f5fe95b1fe3c8452b"); + str_check(run_sha384("abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"), + "09330c33f71147e83d192fc782cd1b4753111b173b3b05d22fa08086e3b0f712fcc7c71a557e2db966c3e9fa91746039"); + str_check(run_sha384("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"), + "3d208973ab3508dbbd7e2c2862ba290ad3010e4978c198dc4d8fd014e582823a89e16f9b2a7bbc1ac938e2d199e8bea4"); +end:; +} + +/* + * SHA512 + */ + +static const char *run_sha512(const char *str) +{ + return run_hash(str, digest_SHA512()); +} + +static void test_sha512(void *ptr) +{ + str_check(run_sha512(""), "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e"); + str_check(run_sha512("a"), "1f40fc92da241694750979ee6cf582f2d5d7d28e18335de05abc54d0560e0f5302860c652bf08d560252aa5e74210546f369fbbbce8c12cfc7957b2652fe9a75"); + str_check(run_sha512("abc"), "ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f"); + str_check(run_sha512("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"), + "204a8fc6dda82f0a0ced7beb8e08a41657c16ef468b228a8279be331a703c33596fd15c13b1b07f9aa1d3bea57789ca031ad85c7a71dd70354ec631238ca3445"); + str_check(run_sha512("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"), + "930d0cefcb30ff1133b6898121f1cf3d27578afcafe8677c5257cf069911f75d8f5831b56ebfda67b278e66dff8b84fe2b2870f742a580d8edb41987232850c9"); + str_check(run_sha512("abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"), + "8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909"); +end:; +} + /* * HMAC @@ -157,6 +243,10 @@ end:; struct testcase_t crypto_tests[] = { { "md5", test_md5 }, { "sha1", test_sha1 }, + { "sha224", test_sha224 }, + { "sha256", test_sha256 }, + { "sha384", test_sha384 }, + { "sha512", test_sha512 }, { "hmac", test_hmac }, END_OF_TESTCASES }; diff --git a/usual/crypto/digest.h b/usual/crypto/digest.h index d13cf2b..3fc8c90 100644 --- a/usual/crypto/digest.h +++ b/usual/crypto/digest.h @@ -94,5 +94,17 @@ const struct DigestInfo *digest_MD5(void); /** SHA1 message digest */ const struct DigestInfo *digest_SHA1(void); +/** SHA224 message digest */ +const struct DigestInfo *digest_SHA224(void); + +/** SHA256 message digest */ +const struct DigestInfo *digest_SHA256(void); + +/** SHA384 message digest */ +const struct DigestInfo *digest_SHA384(void); + +/** SHA512 message digest */ +const struct DigestInfo *digest_SHA512(void); + #endif diff --git a/usual/crypto/sha256.c b/usual/crypto/sha256.c new file mode 100644 index 0000000..76b7689 --- /dev/null +++ b/usual/crypto/sha256.c @@ -0,0 +1,224 @@ +/* + * SHA2-256 implementation based on FIPS180-2. + * + * Copyright (c) 2009 Marko Kreen + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include +#include + +#include +#include + +/* repeat with increasing offset */ +#define R4(R, t) R(t+0); R(t+1); R(t+2); R(t+3) +#define R16(R, t) R4(R, t+0); R4(R, t+4); R4(R, t+8); R4(R, t+12) +#define R64(R, t) R16(R, t+0); R16(R, t+16); R16(R, t+32); R16(R, t+48); + +#define bufpos(ctx) ((ctx)->nbytes & (SHA256_BLOCK_SIZE - 1)) + +/* + * initial values + */ + +static const uint32_t H224[8] = { + 0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, + 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4, +}; + +static const uint32_t H256[8] = { + 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, + 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19, +}; + +/* + * constants for mixing + */ + +static const uint32_t K[64] = { + 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, + 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, + 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, + 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, + 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, + 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, + 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, + 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, + 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, + 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, + 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2, +}; + +/* + * mixing + */ + +#define CH(x,y,z) ((x & y) ^ ((~x) & z)) +#define MAJ(x,y,z) ((x & y) ^ (x & z) ^ (y & z)) + +#define E0(x) (ror32(x, 2) ^ ror32(x, 13) ^ ror32(x, 22)) +#define E1(x) (ror32(x, 6) ^ ror32(x, 11) ^ ror32(x, 25)) +#define O0(x) (ror32(x, 7) ^ ror32(x, 18) ^ (x >> 3)) +#define O1(x) (ror32(x, 17) ^ ror32(x, 19) ^ (x >> 10)) + +#define W(n) (ctx->buf.words[(n) & 15]) +#define setW(n,v) W(n) = (v) + +#define SHA256_ROUND(_t) do { \ + uint32_t tmp1, tmp2, t = (_t); \ + if (t >= 16) { \ + setW(t, O1(W(t - 2)) + W(t - 7) + O0(W(t - 15)) + W(t - 16)); \ + } else { \ + /* convert endianess on first go */ \ + setW(t, be32toh(W(t))); \ + } \ + tmp1 = h + E1(e) + CH(e,f,g) + K[k_pos++] + W(t); \ + tmp2 = E0(a) + MAJ(a,b,c); \ + h = g; g = f; f = e; e = d + tmp1; d = c; c = b; b = a; a = tmp1 + tmp2; \ +} while (0) + +/* + * actual core + */ + +static void sha256_core(struct sha256_ctx *ctx) +{ + uint32_t *state = ctx->state; + uint32_t a = state[0], b = state[1], c = state[2], d = state[3]; + uint32_t e = state[4], f = state[5], g = state[6], h = state[7]; + unsigned k_pos = 0; + + R16(SHA256_ROUND, 0); + while (k_pos < 64) { + R16(SHA256_ROUND, 16); + } + + state[0] += a; + state[1] += b; + state[2] += c; + state[3] += d; + state[4] += e; + state[5] += f; + state[6] += g; + state[7] += h; +} + +/* + * Public API for SHA256. + */ + +void sha256_reset(struct sha256_ctx *ctx) +{ + memset(ctx, 0, sizeof(*ctx)); + memcpy(ctx->state, H256, sizeof(H256)); +} + +void sha256_update(struct sha256_ctx *ctx, const void *data, unsigned int len) +{ + unsigned int n; + const uint8_t *src = data; + uint8_t *dst = ctx->buf.raw; + + while (len > 0) { + n = SHA256_BLOCK_SIZE - bufpos(ctx); + if (n > len) + n = len; + + memcpy(dst + bufpos(ctx), src, n); + src += n; + len -= n; + ctx->nbytes += n; + + if (bufpos(ctx) == 0) + sha256_core(ctx); + } +} + +void sha256_final(struct sha256_ctx *ctx, uint8_t *dst) +{ + static const uint8_t padding[SHA256_BLOCK_SIZE] = { 0x80 }; + uint64_t nbits = ctx->nbytes * 8; + int pad_len, pos = bufpos(ctx); + int i; + + /* add padding */ + pad_len = SHA256_BLOCK_SIZE - 8 - pos; + if (pad_len <= 0) + pad_len += SHA256_BLOCK_SIZE; + sha256_update(ctx, padding, pad_len); + + /* add length */ + ctx->buf.words[14] = htobe32(nbits >> 32); + ctx->buf.words[15] = htobe32(nbits); + + /* final result */ + sha256_core(ctx); + for (i = 0; i < SHA256_DIGEST_LENGTH / 4; i++) + be32enc(dst + i*4, ctx->state[i]); +} + +/* + * Public API for SHA224. + */ + +void sha224_reset(struct sha256_ctx *ctx) +{ + memset(ctx, 0, sizeof(*ctx)); + memcpy(ctx->state, H224, sizeof(H224)); +} + +void sha224_update(struct sha256_ctx *ctx, const void *data, unsigned int len) +{ + sha256_update(ctx, data, len); +} + +void sha224_final(struct sha256_ctx *ctx, uint8_t *dst) +{ + uint8_t buf[SHA256_DIGEST_LENGTH]; + sha256_final(ctx, buf); + memcpy(dst, buf, SHA224_DIGEST_LENGTH); + memset(buf, 0, sizeof(buf)); +} + +/* + * DigestInfo + */ + +const struct DigestInfo *digest_SHA224(void) +{ + static const struct DigestInfo info = { + (DigestInitFunc *)sha224_reset, + (DigestUpdateFunc *)sha224_update, + (DigestFinalFunc *)sha224_final, + sizeof(struct sha256_ctx), + SHA224_DIGEST_LENGTH, + SHA224_BLOCK_SIZE + }; + return &info; +} + +const struct DigestInfo *digest_SHA256(void) +{ + static const struct DigestInfo info = { + (DigestInitFunc *)sha256_reset, + (DigestUpdateFunc *)sha256_update, + (DigestFinalFunc *)sha256_final, + sizeof(struct sha256_ctx), + SHA256_DIGEST_LENGTH, + SHA256_BLOCK_SIZE + }; + return &info; +} + diff --git a/usual/crypto/sha256.h b/usual/crypto/sha256.h new file mode 100644 index 0000000..3c213a9 --- /dev/null +++ b/usual/crypto/sha256.h @@ -0,0 +1,47 @@ +/* + * SHA2-256 implementation based on FIPS180-2. + * + * Copyright (c) 2009 Marko Kreen + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _USUAL_CRYPTO_SHA256_H_ +#define _USUAL_CRYPTO_SHA256_H_ + +#include + +#define SHA224_BLOCK_SIZE (16*4) +#define SHA256_BLOCK_SIZE (16*4) + +#define SHA224_DIGEST_LENGTH (224/8) +#define SHA256_DIGEST_LENGTH (256/8) + +struct sha256_ctx { + union { + uint32_t words[16]; + uint8_t raw[16 * 4]; + } buf; + uint32_t state[8]; + uint64_t nbytes; +}; + +void sha256_reset(struct sha256_ctx *ctx); +void sha256_update(struct sha256_ctx *ctx, const void *data, unsigned int len); +void sha256_final(struct sha256_ctx *ctx, uint8_t *dst); + +void sha224_reset(struct sha256_ctx *ctx); +void sha224_update(struct sha256_ctx *ctx, const void *data, unsigned int len); +void sha224_final(struct sha256_ctx *ctx, uint8_t *dst); + +#endif diff --git a/usual/crypto/sha512.c b/usual/crypto/sha512.c new file mode 100644 index 0000000..f8d96b0 --- /dev/null +++ b/usual/crypto/sha512.c @@ -0,0 +1,241 @@ +/* + * SHA2-512 implementation based on FIPS180-2. + * + * Copyright (c) 2009 Marko Kreen + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include +#include + +#include +#include + +/* repeat with increasing offset */ +#define R4(R, t) R(t+0); R(t+1); R(t+2); R(t+3) +#define R16(R, t) R4(R, t+0); R4(R, t+4); R4(R, t+8); R4(R, t+12) +#define R64(R, t) R16(R, t+0); R16(R, t+16); R16(R, t+32); R16(R, t+48); + +#define bufpos(ctx) ((ctx)->nbytes & (SHA512_BLOCK_SIZE - 1)) + +/* + * initial values + */ + +static const uint64_t H384[8] = { + UINT64_C(0xcbbb9d5dc1059ed8), UINT64_C(0x629a292a367cd507), UINT64_C(0x9159015a3070dd17), + UINT64_C(0x152fecd8f70e5939), UINT64_C(0x67332667ffc00b31), UINT64_C(0x8eb44a8768581511), + UINT64_C(0xdb0c2e0d64f98fa7), UINT64_C(0x47b5481dbefa4fa4), +}; + +static const uint64_t H512[8] = { + UINT64_C(0x6a09e667f3bcc908), UINT64_C(0xbb67ae8584caa73b), UINT64_C(0x3c6ef372fe94f82b), + UINT64_C(0xa54ff53a5f1d36f1), UINT64_C(0x510e527fade682d1), UINT64_C(0x9b05688c2b3e6c1f), + UINT64_C(0x1f83d9abfb41bd6b), UINT64_C(0x5be0cd19137e2179), +}; + +/* + * constants for mixing + */ + +static const uint64_t K[80] = { + UINT64_C(0x428a2f98d728ae22), UINT64_C(0x7137449123ef65cd), UINT64_C(0xb5c0fbcfec4d3b2f), + UINT64_C(0xe9b5dba58189dbbc), UINT64_C(0x3956c25bf348b538), UINT64_C(0x59f111f1b605d019), + UINT64_C(0x923f82a4af194f9b), UINT64_C(0xab1c5ed5da6d8118), UINT64_C(0xd807aa98a3030242), + UINT64_C(0x12835b0145706fbe), UINT64_C(0x243185be4ee4b28c), UINT64_C(0x550c7dc3d5ffb4e2), + UINT64_C(0x72be5d74f27b896f), UINT64_C(0x80deb1fe3b1696b1), UINT64_C(0x9bdc06a725c71235), + UINT64_C(0xc19bf174cf692694), UINT64_C(0xe49b69c19ef14ad2), UINT64_C(0xefbe4786384f25e3), + UINT64_C(0x0fc19dc68b8cd5b5), UINT64_C(0x240ca1cc77ac9c65), UINT64_C(0x2de92c6f592b0275), + UINT64_C(0x4a7484aa6ea6e483), UINT64_C(0x5cb0a9dcbd41fbd4), UINT64_C(0x76f988da831153b5), + UINT64_C(0x983e5152ee66dfab), UINT64_C(0xa831c66d2db43210), UINT64_C(0xb00327c898fb213f), + UINT64_C(0xbf597fc7beef0ee4), UINT64_C(0xc6e00bf33da88fc2), UINT64_C(0xd5a79147930aa725), + UINT64_C(0x06ca6351e003826f), UINT64_C(0x142929670a0e6e70), UINT64_C(0x27b70a8546d22ffc), + UINT64_C(0x2e1b21385c26c926), UINT64_C(0x4d2c6dfc5ac42aed), UINT64_C(0x53380d139d95b3df), + UINT64_C(0x650a73548baf63de), UINT64_C(0x766a0abb3c77b2a8), UINT64_C(0x81c2c92e47edaee6), + UINT64_C(0x92722c851482353b), UINT64_C(0xa2bfe8a14cf10364), UINT64_C(0xa81a664bbc423001), + UINT64_C(0xc24b8b70d0f89791), UINT64_C(0xc76c51a30654be30), UINT64_C(0xd192e819d6ef5218), + UINT64_C(0xd69906245565a910), UINT64_C(0xf40e35855771202a), UINT64_C(0x106aa07032bbd1b8), + UINT64_C(0x19a4c116b8d2d0c8), UINT64_C(0x1e376c085141ab53), UINT64_C(0x2748774cdf8eeb99), + UINT64_C(0x34b0bcb5e19b48a8), UINT64_C(0x391c0cb3c5c95a63), UINT64_C(0x4ed8aa4ae3418acb), + UINT64_C(0x5b9cca4f7763e373), UINT64_C(0x682e6ff3d6b2b8a3), UINT64_C(0x748f82ee5defb2fc), + UINT64_C(0x78a5636f43172f60), UINT64_C(0x84c87814a1f0ab72), UINT64_C(0x8cc702081a6439ec), + UINT64_C(0x90befffa23631e28), UINT64_C(0xa4506cebde82bde9), UINT64_C(0xbef9a3f7b2c67915), + UINT64_C(0xc67178f2e372532b), UINT64_C(0xca273eceea26619c), UINT64_C(0xd186b8c721c0c207), + UINT64_C(0xeada7dd6cde0eb1e), UINT64_C(0xf57d4f7fee6ed178), UINT64_C(0x06f067aa72176fba), + UINT64_C(0x0a637dc5a2c898a6), UINT64_C(0x113f9804bef90dae), UINT64_C(0x1b710b35131c471b), + UINT64_C(0x28db77f523047d84), UINT64_C(0x32caab7b40c72493), UINT64_C(0x3c9ebe0a15c9bebc), + UINT64_C(0x431d67c49c100d4c), UINT64_C(0x4cc5d4becb3e42b6), UINT64_C(0x597f299cfc657e2a), + UINT64_C(0x5fcb6fab3ad6faec), UINT64_C(0x6c44198c4a475817), +}; + +/* + * mixing + */ + +#define CH(x,y,z) ((x & y) ^ ((~x) & z)) +#define MAJ(x,y,z) ((x & y) ^ (x & z) ^ (y & z)) + +#define E0(x) (ror64(x, 28) ^ ror64(x, 34) ^ ror64(x, 39)) +#define E1(x) (ror64(x, 14) ^ ror64(x, 18) ^ ror64(x, 41)) +#define O0(x) (ror64(x, 1) ^ ror64(x, 8) ^ (x >> 7)) +#define O1(x) (ror64(x, 19) ^ ror64(x, 61) ^ (x >> 6)) + +#define W(n) (ctx->buf.words[(n) & 15]) +#define setW(n,v) W(n) = (v) + +#define SHA512_ROUND(_t) do { \ + uint64_t tmp1, tmp2, t = (_t); \ + if (t >= 16) { \ + setW(t, O1(W(t - 2)) + W(t - 7) + O0(W(t - 15)) + W(t - 16)); \ + } else { \ + /* convert endianess on first go */ \ + setW(t, be64toh(W(t))); \ + } \ + tmp1 = h + E1(e) + CH(e,f,g) + K[k_pos++] + W(t); \ + tmp2 = E0(a) + MAJ(a,b,c); \ + h = g; g = f; f = e; e = d + tmp1; d = c; c = b; b = a; a = tmp1 + tmp2; \ +} while (0) + +/* + * actual core + */ + +static void sha512_core(struct sha512_ctx *ctx) +{ + uint64_t *state = ctx->state; + uint64_t a = state[0], b = state[1], c = state[2], d = state[3]; + uint64_t e = state[4], f = state[5], g = state[6], h = state[7]; + unsigned k_pos = 0; + + R16(SHA512_ROUND, 0); + while (k_pos < 80) { + R16(SHA512_ROUND, 16); + } + + state[0] += a; + state[1] += b; + state[2] += c; + state[3] += d; + state[4] += e; + state[5] += f; + state[6] += g; + state[7] += h; +} + +/* + * Public API for SHA512. + */ + +void sha512_reset(struct sha512_ctx *ctx) +{ + memset(ctx, 0, sizeof(*ctx)); + memcpy(ctx->state, H512, sizeof(H512)); +} + +void sha512_update(struct sha512_ctx *ctx, const void *data, unsigned int len) +{ + unsigned int n; + const uint8_t *src = data; + uint8_t *dst = ctx->buf.raw; + + while (len > 0) { + n = SHA512_BLOCK_SIZE - bufpos(ctx); + if (n > len) + n = len; + + memcpy(dst + bufpos(ctx), src, n); + src += n; + len -= n; + ctx->nbytes += n; + + if (bufpos(ctx) == 0) + sha512_core(ctx); + } +} + +void sha512_final(struct sha512_ctx *ctx, uint8_t *dst) +{ + static const uint8_t padding[SHA512_BLOCK_SIZE] = { 0x80 }; + uint64_t nbits = ctx->nbytes * 8; + int i, pad_len; + + /* add padding */ + pad_len = SHA512_BLOCK_SIZE - 16 - bufpos(ctx); + if (pad_len <= 0) + pad_len += SHA512_BLOCK_SIZE; + sha512_update(ctx, padding, pad_len); + + /* add length */ + ctx->buf.words[14] = 0; + ctx->buf.words[15] = htobe64(nbits); + + /* final result */ + sha512_core(ctx); + for (i = 0; i < SHA512_DIGEST_LENGTH / 8; i++) + be64enc(dst + i*8, ctx->state[i]); +} + +/* + * Public API for SHA384. + */ + +void sha384_reset(struct sha512_ctx *ctx) +{ + memset(ctx, 0, sizeof(*ctx)); + memcpy(ctx->state, H384, sizeof(H384)); +} + +void sha384_update(struct sha512_ctx *ctx, const void *data, unsigned int len) +{ + sha512_update(ctx, data, len); +} + +void sha384_final(struct sha512_ctx *ctx, uint8_t *dst) +{ + uint8_t buf[SHA512_DIGEST_LENGTH]; + sha512_final(ctx, buf); + memcpy(dst, buf, SHA384_DIGEST_LENGTH); + memset(buf, 0, sizeof(buf)); +} + +/* + * DigestInfo + */ + +const struct DigestInfo *digest_SHA384(void) +{ + static const struct DigestInfo info = { + (DigestInitFunc *)sha384_reset, + (DigestUpdateFunc *)sha384_update, + (DigestFinalFunc *)sha384_final, + sizeof(struct sha512_ctx), + SHA384_DIGEST_LENGTH, + SHA384_BLOCK_SIZE + }; + return &info; +} + +const struct DigestInfo *digest_SHA512(void) +{ + static const struct DigestInfo info = { + (DigestInitFunc *)sha512_reset, + (DigestUpdateFunc *)sha512_update, + (DigestFinalFunc *)sha512_final, + sizeof(struct sha512_ctx), + SHA512_DIGEST_LENGTH, + SHA512_BLOCK_SIZE + }; + return &info; +} + diff --git a/usual/crypto/sha512.h b/usual/crypto/sha512.h new file mode 100644 index 0000000..fff51a5 --- /dev/null +++ b/usual/crypto/sha512.h @@ -0,0 +1,47 @@ +/* + * SHA2-512 implementation based on FIPS180-2. + * + * Copyright (c) 2009 Marko Kreen + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#ifndef _USUAL_CRYPTO_SHA512_H_ +#define _USUAL_CRYPTO_SHA512_H_ + +#include + +#define SHA384_BLOCK_SIZE (16*8) +#define SHA512_BLOCK_SIZE (16*8) + +#define SHA384_DIGEST_LENGTH (384/8) +#define SHA512_DIGEST_LENGTH (512/8) + +struct sha512_ctx { + union { + uint64_t words[16]; + uint8_t raw[16 * 8]; + } buf; + uint64_t state[8]; + uint64_t nbytes; +}; + +void sha512_reset(struct sha512_ctx *ctx); +void sha512_update(struct sha512_ctx *ctx, const void *data, unsigned int len); +void sha512_final(struct sha512_ctx *ctx, uint8_t *dst); + +void sha384_reset(struct sha512_ctx *ctx); +void sha384_update(struct sha512_ctx *ctx, const void *data, unsigned int len); +void sha384_final(struct sha512_ctx *ctx, uint8_t *dst); + +#endif -- 2.39.5