Separate module for both SHA-256 and SHA-512.
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 \
* <tr><td> <usual/crypto/hmac.h> </td><td> HMAC with digest </td></tr>
* <tr><td> <usual/crypto/md5.h> </td><td> MD5 hash </td></tr>
* <tr><td> <usual/crypto/sha1.h> </td><td> SHA1 hash </td></tr>
+ * <tr><td> <usual/crypto/sha256.h> </td><td> SHA256/224 hashes </td></tr>
+ * <tr><td> <usual/crypto/sha512.h> </td><td> SHA512/384 hashes </td></tr>
* <tr><th colspan=2> Memory Allocation </th></tr>
* <tr><td> <usual/cxalloc.h> </td><td> Context Allocator framework </td></tr>
* <tr><td> <usual/cxextra.h> </td><td> Extra allocators </td></tr>
#include <usual/crypto/hmac.h>
#include <usual/crypto/md5.h>
#include <usual/crypto/sha1.h>
+#include <usual/crypto/sha256.h>
+#include <usual/crypto/sha512.h>
#include <usual/crypto/digest.h>
#include <usual/cxalloc.h>
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
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
};
/** 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
--- /dev/null
+/*
+ * 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 <usual/crypto/sha256.h>
+#include <usual/crypto/digest.h>
+
+#include <usual/endian.h>
+#include <usual/bits.h>
+
+/* 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;
+}
+
--- /dev/null
+/*
+ * 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 <usual/base.h>
+
+#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
--- /dev/null
+/*
+ * 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 <usual/crypto/sha512.h>
+#include <usual/crypto/digest.h>
+
+#include <usual/endian.h>
+#include <usual/bits.h>
+
+/* 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;
+}
+
--- /dev/null
+/*
+ * 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 <usual/base.h>
+
+#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
projects / libusual.git / commitdiff