git.vger.kernel.org archive mirror
 help / color / mirror / Atom feed
From: Michael Clark <michaeljclark@mac.com>
To: git@vger.kernel.org
Cc: Michael Clark <michaeljclark@mac.com>
Subject: [PATCH 2/6] Add an implementation of the SHA-512 hash algorithm
Date: Sun, 22 Dec 2019 19:48:05 +1300	[thread overview]
Message-ID: <20191222064809.35667-3-michaeljclark@mac.com> (raw)
In-Reply-To: <20191222064809.35667-1-michaeljclark@mac.com>

- Add SHA-512 hash algorithm implementation derived from the
  SHA-256 implementation translated to 64-bit and 80 rounds.
- Add configuration machinery to select builtin impl or gcrypt.
- Add sha512-224, sha512-256 and sha512 commands to test-tool.
- Add sha512 hash tests to t/t0015-hash.sh
---
 Makefile               |  14 +++
 hash.h                 |  46 ++++++-
 sha/sha512/gcrypt.h    |  43 +++++++
 sha/sha512/sha512.c    | 206 +++++++++++++++++++++++++++++++
 sha/sha512/sha512.h    |  31 +++++
 sha1-file.c            | 268 +++++++++++++++++++++++++++++++++++++++++
 t/helper/test-sha512.c |  17 +++
 t/helper/test-tool.c   |   3 +
 t/helper/test-tool.h   |   3 +
 t/t0015-hash.sh        |  80 ++++++++++++
 10 files changed, 707 insertions(+), 4 deletions(-)
 create mode 100644 sha/sha512/gcrypt.h
 create mode 100644 sha/sha512/sha512.c
 create mode 100644 sha/sha512/sha512.h
 create mode 100644 t/helper/test-sha512.c

diff --git a/Makefile b/Makefile
index bac1b30b2f1f..2cd505b21ebb 100644
--- a/Makefile
+++ b/Makefile
@@ -183,6 +183,8 @@ all::
 #
 # Define BLK_SHA256 to use the built-in SHA-256 routines.
 #
+# Define BLK_SHA512 to use the built-in SHA-512 routines.
+#
 # Define GCRYPT_SHA256 to use the SHA-256 routines in libgcrypt.
 #
 # Define OPENSSL_SHA256 to use the SHA-256 routines in OpenSSL.
@@ -739,6 +741,7 @@ TEST_BUILTINS_OBJS += test-serve-v2.o
 TEST_BUILTINS_OBJS += test-sha1.o
 TEST_BUILTINS_OBJS += test-sha1-array.o
 TEST_BUILTINS_OBJS += test-sha256.o
+TEST_BUILTINS_OBJS += test-sha512.o
 TEST_BUILTINS_OBJS += test-sigchain.o
 TEST_BUILTINS_OBJS += test-strcmp-offset.o
 TEST_BUILTINS_OBJS += test-string-list.o
@@ -1712,6 +1715,14 @@ else
 endif
 endif
 
+ifdef GCRYPT_SHA512
+	BASIC_CFLAGS += -DSHA512_GCRYPT
+	EXTLIBS += -lgcrypt
+else
+	LIB_OBJS += sha/sha512/sha512.o
+	BASIC_CFLAGS += -DSHA512_BLK
+endif
+
 ifdef SHA1_MAX_BLOCK_SIZE
 	LIB_OBJS += compat/sha1-chunked.o
 	BASIC_CFLAGS += -DSHA1_MAX_BLOCK_SIZE="$(SHA1_MAX_BLOCK_SIZE)"
@@ -2784,6 +2795,9 @@ EXCEPT_HDRS := $(GEN_HDRS) compat/% xdiff/%
 ifndef GCRYPT_SHA256
 	EXCEPT_HDRS += sha/sha256/gcrypt.h
 endif
+ifndef GCRYPT_SHA512
+	EXCEPT_HDRS += sha/sha512/gcrypt.h
+endif
 CHK_HDRS = $(filter-out $(EXCEPT_HDRS),$(LIB_H))
 HCO = $(patsubst %.h,%.hco,$(CHK_HDRS))
 HCC = $(HCO:hco=hcc)
diff --git a/hash.h b/hash.h
index f1b941218dc8..ea96fccce0c8 100644
--- a/hash.h
+++ b/hash.h
@@ -23,6 +23,12 @@
 #include "sha/sha256/sha256.h"
 #endif
 
+#if defined(SHA512_GCRYPT)
+#include "sha/sha512/gcrypt.h"
+#else
+#include "sha/sha512/sha512.h"
+#endif
+
 #ifndef platform_SHA_CTX
 /*
  * platform's underlying implementation of SHA-1; could be OpenSSL,
@@ -54,6 +60,13 @@
 #define git_SHA256_Update	platform_SHA256_Update
 #define git_SHA256_Final	platform_SHA256_Final
 
+#define git_SHA512_CTX		platform_SHA512_CTX
+#define git_SHA512_Init		platform_SHA512_Init
+#define git_SHA512_224_Init	platform_SHA512_224_Init
+#define git_SHA512_256_Init	platform_SHA512_256_Init
+#define git_SHA512_Update	platform_SHA512_Update
+#define git_SHA512_Final	platform_SHA512_Final
+
 #ifdef SHA1_MAX_BLOCK_SIZE
 #include "compat/sha1-chunked.h"
 #undef git_SHA1_Update
@@ -74,13 +87,20 @@
 #define GIT_HASH_SHA1 1
 /* SHA-256  */
 #define GIT_HASH_SHA256 2
+/* SHA-512  */
+#define GIT_HASH_SHA512 3
+/* SHA-512-224  */
+#define GIT_HASH_SHA512_224 4
+/* SHA-512-256  */
+#define GIT_HASH_SHA512_256 5
 /* Number of algorithms supported (including unknown). */
-#define GIT_HASH_NALGOS (GIT_HASH_SHA256 + 1)
+#define GIT_HASH_NALGOS (GIT_HASH_SHA512_256 + 1)
 
 /* A suitably aligned type for stack allocations of hash contexts. */
 union git_hash_ctx {
 	git_SHA_CTX sha1;
 	git_SHA256_CTX sha256;
+	git_SHA512_CTX sha512;
 };
 typedef union git_hash_ctx git_hash_ctx;
 
@@ -151,11 +171,29 @@ static inline int hash_algo_by_ptr(const struct git_hash_algo *p)
 /* The block size of SHA-256. */
 #define GIT_SHA256_BLKSZ 64
 
+/* The length in bytes and in hex digits of an object name (SHA-512 value). */
+#define GIT_SHA512_RAWSZ 64
+#define GIT_SHA512_HEXSZ (2 * GIT_SHA512_RAWSZ)
+/* The block size of SHA-512. */
+#define GIT_SHA512_BLKSZ 128
+
+/* The length in bytes and in hex digits of an object name (SHA-512-224 value). */
+#define GIT_SHA512_224_RAWSZ 28
+#define GIT_SHA512_224_HEXSZ (2 * GIT_SHA512_224_RAWSZ)
+/* The block size of SHA-512-224. */
+#define GIT_SHA512_224_BLKSZ 128
+
+/* The length in bytes and in hex digits of an object name (SHA-512-256 value). */
+#define GIT_SHA512_256_RAWSZ 32
+#define GIT_SHA512_256_HEXSZ (2 * GIT_SHA512_256_RAWSZ)
+/* The block size of SHA-512-256. */
+#define GIT_SHA512_256_BLKSZ 128
+
 /* The length in byte and in hex digits of the largest possible hash value. */
-#define GIT_MAX_RAWSZ GIT_SHA256_RAWSZ
-#define GIT_MAX_HEXSZ GIT_SHA256_HEXSZ
+#define GIT_MAX_RAWSZ GIT_SHA512_RAWSZ
+#define GIT_MAX_HEXSZ GIT_SHA512_HEXSZ
 /* The largest possible block size for any supported hash. */
-#define GIT_MAX_BLKSZ GIT_SHA256_BLKSZ
+#define GIT_MAX_BLKSZ GIT_SHA512_BLKSZ
 
 struct object_id {
 	unsigned char hash[GIT_MAX_RAWSZ];
diff --git a/sha/sha512/gcrypt.h b/sha/sha512/gcrypt.h
new file mode 100644
index 000000000000..fdc0097d0777
--- /dev/null
+++ b/sha/sha512/gcrypt.h
@@ -0,0 +1,43 @@
+#ifndef SHA512_GCRYPT_H
+#define SHA512_GCRYPT_H
+
+#include <gcrypt.h>
+
+#define SHA512_DIGEST_SIZE 64
+
+typedef gcry_md_hd_t gcrypt_SHA512_CTX;
+
+inline void gcrypt_SHA512_Init(gcrypt_SHA512_CTX *ctx)
+{
+	gcry_md_open(ctx, GCRY_MD_SHA512, 0);
+}
+
+inline void gcrypt_SHA512_224_Init(gcrypt_SHA512_CTX *ctx)
+{
+	gcry_md_open(ctx, GCRY_MD_SHA512_224, 0);
+}
+
+inline void gcrypt_SHA512_256_Init(gcrypt_SHA512_CTX *ctx)
+{
+	gcry_md_open(ctx, GCRY_MD_SHA512_256, 0);
+}
+
+inline void gcrypt_SHA512_Update(gcrypt_SHA512_CTX *ctx, const void *data, size_t len)
+{
+	gcry_md_write(*ctx, data, len);
+}
+
+inline void gcrypt_SHA512_Final(unsigned char *digest, gcrypt_SHA512_CTX *ctx)
+{
+	int algo = gcry_md_get_algo(ctx);
+	unsigned int dlen = gcry_md_get_algo_dlen(algo);
+	memcpy(digest, gcry_md_read(*ctx, algo), dlen);
+}
+
+#define platform_SHA512_CTX gcrypt_SHA512_CTX
+#define platform_SHA512_Init gcrypt_SHA512_Init
+#define platform_SHA512_256_Init gcrypt_SHA512_256_Init
+#define platform_SHA512_Update gcrypt_SHA512_Update
+#define platform_SHA512_Final gcrypt_SHA512_Final
+
+#endif
diff --git a/sha/sha512/sha512.c b/sha/sha512/sha512.c
new file mode 100644
index 000000000000..8c1955627648
--- /dev/null
+++ b/sha/sha512/sha512.c
@@ -0,0 +1,206 @@
+#include "git-compat-util.h"
+#include "./sha512.h"
+
+static const uint64_t SHA_512_K[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
+};
+
+void blk_SHA512_224_Init(blk_SHA512_CTX *ctx)
+{
+	ctx->size = 0;
+	ctx->digestlen = blk_SHA512_224_HASHSIZE;
+	ctx->state[0] = 0x8c3d37c819544da2ull;
+	ctx->state[1] = 0x73e1996689dcd4d6ull;
+	ctx->state[2] = 0x1dfab7ae32ff9c82ull;
+	ctx->state[3] = 0x679dd514582f9fcfull;
+	ctx->state[4] = 0x0f6d2b697bd44da8ull;
+	ctx->state[5] = 0x77e36f7304c48942ull;
+	ctx->state[6] = 0x3f9d85a86a1d36c8ull;
+	ctx->state[7] = 0x1112e6ad91d692a1ull;
+}
+
+void blk_SHA512_256_Init(blk_SHA512_CTX *ctx)
+{
+	ctx->size = 0;
+	ctx->digestlen = blk_SHA512_256_HASHSIZE;
+	ctx->state[0] = 0x22312194fc2bf72cull;
+	ctx->state[1] = 0x9f555fa3c84c64c2ull;
+	ctx->state[2] = 0x2393b86b6f53b151ull;
+	ctx->state[3] = 0x963877195940eabdull;
+	ctx->state[4] = 0x96283ee2a88effe3ull;
+	ctx->state[5] = 0xbe5e1e2553863992ull;
+	ctx->state[6] = 0x2b0199fc2c85b8aaull;
+	ctx->state[7] = 0x0eb72ddc81c52ca2ull;
+}
+
+void blk_SHA512_Init(blk_SHA512_CTX *ctx)
+{
+	ctx->size = 0;
+	ctx->digestlen = blk_SHA512_HASHSIZE;
+	ctx->state[0] = 0x6a09e667f3bcc908ull;
+	ctx->state[1] = 0xbb67ae8584caa73bull;
+	ctx->state[2] = 0x3c6ef372fe94f82bull;
+	ctx->state[3] = 0xa54ff53a5f1d36f1ull;
+	ctx->state[4] = 0x510e527fade682d1ull;
+	ctx->state[5] = 0x9b05688c2b3e6c1full;
+	ctx->state[6] = 0x1f83d9abfb41bd6bull;
+	ctx->state[7] = 0x5be0cd19137e2179ull;
+}
+
+static inline uint64_t ror(uint64_t x, unsigned n)
+{
+	return (x >> n) | (x << (64 - n));
+}
+
+static inline uint64_t ch(uint64_t x, uint64_t y, uint64_t z)
+{
+	return z ^ (x & (y ^ z));
+}
+
+static inline uint64_t maj(uint64_t x, uint64_t y, uint64_t z)
+{
+	return ((x | y) & z) | (x & y);
+}
+
+static inline uint64_t sigma0(uint64_t x)
+{
+	return ror(x, 28) ^ ror(x, 34) ^ ror(x, 39);
+}
+
+static inline uint64_t sigma1(uint64_t x)
+{
+	return ror(x, 14) ^ ror(x, 18) ^ ror(x, 41);
+}
+
+static inline uint64_t gamma0(uint64_t x)
+{
+	return ror(x, 1) ^ ror(x, 8) ^ (x >> 7);
+}
+
+static inline uint64_t gamma1(uint64_t x)
+{
+	return ror(x, 19) ^ ror(x, 61) ^ (x >> 6);
+}
+
+static void blk_SHA512_Transform(blk_SHA512_CTX *ctx, const unsigned char *buf)
+{
+	uint64_t S[8], W[80], t0, t1;
+	int i;
+
+	/* copy state into S */
+	for (i = 0; i < 8; i++)
+		S[i] = ctx->state[i];
+
+	/* copy the state into 1024-bits into W[0..15] */
+	for (i=0; i<16; i++, buf += sizeof(uint64_t)) {
+		W[i] = get_be64(buf);
+	}
+
+	/* fill W[16..80] */
+	for (; i<80; i++) {
+		W[i] = gamma1(W[i - 2]) + W[i - 7] + gamma0(W[i - 15]) + W[i - 16];
+	}
+
+	/* compute SHA rounds */
+	for (i=0; i<80; i++) {
+		t0 = W[i] + S[7] + sigma1(S[4]) + ch(S[4], S[5], S[6]) + SHA_512_K[i];
+		t1 = maj(S[0], S[1], S[2]) + sigma0(S[0]);
+		S[7] = S[6];
+		S[6] = S[5];
+		S[5] = S[4];
+		S[4] = S[3] + t0;
+		S[3] = S[2];
+		S[2] = S[1];
+		S[1] = S[0];
+		S[0] = t0 + t1;
+	}
+
+	for (i = 0; i < 8; i++)
+		ctx->state[i] += S[i];
+}
+
+void blk_SHA512_Update(blk_SHA512_CTX *ctx, const void *data, size_t len)
+{
+	unsigned int len_buf = ctx->size & 127;
+
+	ctx->size += len;
+
+	/* Read the data into buf and process blocks as they get full */
+	if (len_buf) {
+		unsigned int left = 128 - len_buf;
+		if (len < left)
+			left = len;
+		memcpy(len_buf + ctx->buf, data, left);
+		len_buf = (len_buf + left) & 127;
+		len -= left;
+		data = ((const char *)data + left);
+		if (len_buf)
+			return;
+		blk_SHA512_Transform(ctx, ctx->buf);
+	}
+	while (len >= 128) {
+		blk_SHA512_Transform(ctx, data);
+		data = ((const char *)data + 128);
+		len -= 128;
+	}
+	if (len)
+		memcpy(ctx->buf, data, len);
+}
+
+void blk_SHA512_Final(uint8_t *digest, blk_SHA512_CTX *ctx)
+{
+	static const unsigned char pad[128] = { 0x80 };
+	unsigned int padlen[2];
+	int i;
+
+	/* Pad with a binary 1 (ie 0x80), then zeroes, then length */
+	padlen[0] = htonl((uint32_t)(ctx->size >> 29));
+	padlen[1] = htonl((uint32_t)(ctx->size << 3));
+
+	i = ctx->size & 127;
+	blk_SHA512_Update(ctx, pad, 1 + (127 & (119 - i)));
+	blk_SHA512_Update(ctx, padlen, 8);
+
+	/* copy output */
+	for (i = 0; i < 8; i++, digest += sizeof(uint64_t))
+		put_be64(digest, ctx->state[i]);
+}
diff --git a/sha/sha512/sha512.h b/sha/sha512/sha512.h
new file mode 100644
index 000000000000..bc063f0af868
--- /dev/null
+++ b/sha/sha512/sha512.h
@@ -0,0 +1,31 @@
+#ifndef SHA512_BLOCK_SHA512_H
+#define SHA512_BLOCK_SHA512_H
+
+#define blk_SHA512_BLKSIZE 128
+#define blk_SHA512_224_HASHSIZE 28
+#define blk_SHA512_256_HASHSIZE 32
+#define blk_SHA512_HASHSIZE 64
+
+struct blk_SHA512_CTX {
+	uint64_t state[8];
+	uint64_t size;
+	uint64_t digestlen;
+	uint8_t buf[blk_SHA512_BLKSIZE];
+};
+
+typedef struct blk_SHA512_CTX blk_SHA512_CTX;
+
+void blk_SHA512_Init(blk_SHA512_CTX *ctx);
+void blk_SHA512_224_Init(blk_SHA512_CTX *ctx);
+void blk_SHA512_256_Init(blk_SHA512_CTX *ctx);
+void blk_SHA512_Update(blk_SHA512_CTX *ctx, const void *data, size_t len);
+void blk_SHA512_Final(unsigned char *digest, blk_SHA512_CTX *ctx);
+
+#define platform_SHA512_CTX blk_SHA512_CTX
+#define platform_SHA512_Init blk_SHA512_Init
+#define platform_SHA512_224_Init blk_SHA512_224_Init
+#define platform_SHA512_256_Init blk_SHA512_256_Init
+#define platform_SHA512_Update blk_SHA512_Update
+#define platform_SHA512_Final blk_SHA512_Final
+
+#endif
diff --git a/sha1-file.c b/sha1-file.c
index 188de57634bb..1f5b835a9f24 100644
--- a/sha1-file.c
+++ b/sha1-file.c
@@ -45,6 +45,46 @@
 	"\x04\xd4\x5d\x8d\x85\xef\xa9\xb0\x57\xb5" \
 	"\x3b\x14\xb4\xb9\xb9\x39\xdd\x74\xde\xcc" \
 	"\x53\x21"
+#define EMPTY_TREE_SHA512_224_BIN_LITERAL \
+	"\xaa\xff\x3a\xb0\x67\xb1\x51\xd0\xbc\x31" \
+	"\x30\x27\x7d\x64\xa1\x1e\xb2\x57\xe0\xfe" \
+	"\xca\x74\xe0\xdc\xb7\xe3\x83\x03"
+#define EMPTY_TREE_SHA512_256_BIN_LITERAL \
+	"\x2c\xfe\x78\xf8\xea\x2f\xa9\xd2\x19\x37" \
+	"\x48\x68\xe7\xaa\x1f\xe4\x91\x62\x2b\xcb" \
+	"\x58\x15\xdc\xf3\xad\x12\xf3\x08\xbe\x79" \
+	"\x59\xdb"
+#define EMPTY_TREE_SHA512_BIN_LITERAL \
+	"\xd5\x1f\xd9\x2f\xdd\x8b\x29\xd0\x8f\x5c" \
+	"\xba\x26\x1a\xbb\x22\x15\x29\xe6\xff\xb1" \
+	"\x26\x4c\x51\x1b\xe2\x16\xd2\xf5\x30\x6e" \
+	"\xcd\xcc\x38\xe2\x39\x2d\xe4\xf6\x2c\x74" \
+	"\x56\x07\xa9\x76\x80\xfc\x7c\xcb\xbe\x73" \
+	"\x04\x4d\xfc\x03\xd8\x9e\xd9\x5b\xa5\x49" \
+	"\x67\x90\x91\x95"
+#define EMPTY_TREE_SHA3_224_BIN_LITERAL \
+	"\x1e\x04\xf2\x3d\xe0\xb2\xb7\xd1\xb8\x5e" \
+	"\x67\x68\xfa\x99\x7a\x99\xbd\x01\x19\xde" \
+	"\xc8\x15\x8a\xe0\xad\x07\xe1\x83"
+#define EMPTY_TREE_SHA3_256_BIN_LITERAL \
+	"\x30\x21\x1e\xd4\x85\xc9\x12\xe5\xbc\x28" \
+	"\x5b\xd0\xbd\x89\x59\xdd\xbf\xb5\x87\x5c" \
+	"\xaf\xb0\xae\x28\xe0\xab\xfa\x10\x77\xb2" \
+	"\xb2\x14"
+#define EMPTY_TREE_SHA3_384_BIN_LITERAL \
+	"\x92\xe9\x9a\xe9\x28\x1a\x89\xdc\x33\x2c" \
+	"\x9c\xe8\xf2\x83\x1d\xb5\x0e\xcc\x54\x78" \
+	"\x4d\x51\xc3\xeb\xd5\xc1\x15\x1e\x8f\xd6" \
+	"\x03\xfb\x40\x8a\xbb\xbb\x9d\xcf\x57\x13" \
+	"\xed\x21\x56\x67\x89\xce\x80\x59"
+#define EMPTY_TREE_SHA3_512_BIN_LITERAL \
+	"\x8f\x86\xcb\x67\xce\x0a\x8b\xc8\x65\xb3" \
+	"\x00\x73\x3c\x27\xda\xde\x0e\xa8\xfe\x66" \
+	"\x29\x9b\x4b\xc6\x36\x8e\xc8\x4f\x53\x13" \
+	"\x4c\x36\x7c\x66\xf0\xe3\x37\x62\x61\xab" \
+	"\x5a\x86\xd7\x22\xad\x0d\x98\x39\x1a\x3c" \
+	"\x1c\x47\x2d\x67\x91\xda\x46\x4a\x78\x36" \
+	"\x00\x6d\xe1\x2c"
 
 #define EMPTY_BLOB_SHA1_BIN_LITERAL \
 	"\xe6\x9d\xe2\x9b\xb2\xd1\xd6\x43\x4b\x8b" \
@@ -54,6 +94,46 @@
 	"\x67\xe3\xb1\xe9\xa7\xdc\xda\x11\x85\x43" \
 	"\x6f\xe1\x41\xf7\x74\x91\x20\xa3\x03\x72" \
 	"\x18\x13"
+#define EMPTY_BLOB_SHA512_224_BIN_LITERAL \
+	"\xa8\x6d\x3c\x63\x33\x98\x60\x44\x56\x07" \
+	"\xd6\xcf\xd3\x55\x12\x92\xa6\xfb\x04\x9f" \
+	"\x0f\xaa\x22\x2a\x7c\x10\x02\x7b"
+#define EMPTY_BLOB_SHA512_256_BIN_LITERAL \
+	"\x65\x76\x66\x8d\x3a\xcf\x02\x2c\x9c\x77" \
+	"\x92\x0c\x83\x49\xed\x6c\xcd\x8f\xc5\x96" \
+	"\x84\x5e\x87\xc3\x8b\x9e\x74\x90\x16\xc9" \
+	"\x84\xb3"
+#define EMPTY_BLOB_SHA512_BIN_LITERAL \
+	"\xba\x4d\x0b\xb3\xec\x89\x0f\xdc\x47\xa1" \
+	"\x0d\xf5\x3a\x59\x1a\x79\x85\x22\x37\xd5" \
+	"\xe6\x35\x45\x5d\xa9\x0a\x37\x42\xd7\x48" \
+	"\x27\x08\xb5\x7d\xe2\xff\xab\xc7\x58\x1f" \
+	"\x58\x1e\xe8\x07\x5f\xba\xb3\x47\x62\x70" \
+	"\x94\x2c\xdf\x87\xfa\x7d\xd6\x89\x5d\xaa" \
+	"\x65\x09\x89\x6c"
+#define EMPTY_BLOB_SHA3_224_BIN_LITERAL \
+	"\xf1\xe7\x29\x35\xac\x5c\x52\xd5\xc0\x9b" \
+	"\x40\x88\x42\xe2\x07\xc4\x2e\x54\x34\x42" \
+	"\x40\x07\x36\x4f\xdb\x46\x80\x63"
+#define EMPTY_BLOB_SHA3_256_BIN_LITERAL \
+	"\x5a\xad\xde\x7d\x8c\xa5\xb9\xb3\x52\xc2" \
+	"\x50\xce\x9b\x79\x9f\x5d\x81\x88\x93\xfe" \
+	"\x89\xdc\x52\xb4\x9f\x43\x8c\x8a\x9b\xa0" \
+	"\xa5\x45"
+#define EMPTY_BLOB_SHA3_384_BIN_LITERAL \
+	"\xa5\x3e\x08\x8a\xbe\x90\x8d\x8c\x94\x58" \
+	"\xa8\xba\x95\x56\x90\xc4\x17\xf7\x68\x03" \
+	"\x1e\xcf\x15\x6a\x16\x62\x44\x1f\xae\xda" \
+	"\x50\x2e\x83\x8f\x26\x60\x16\x4b\x61\xa7" \
+	"\x8b\x15\xac\x75\xe0\xf8\xde\xd4"
+#define EMPTY_BLOB_SHA3_512_BIN_LITERAL \
+	"\x43\x53\xa5\x0d\x0d\x3d\x8e\xdd\x23\x17" \
+	"\x63\xfb\x01\x02\x11\x62\x86\xaa\x6d\x76" \
+	"\x0a\x77\x21\x33\xe3\x2c\x12\x4a\x99\x8a" \
+	"\x19\x46\x7d\x78\x90\x64\xdd\x76\x3e\x57" \
+	"\xb5\x47\xff\x3a\x31\x88\x2d\xa3\xd2\x03" \
+	"\x13\x78\xcf\xe0\xfa\x57\x74\xc1\x2e\xea" \
+	"\x51\x05\x5a\x51"
 
 const struct object_id null_oid;
 static const struct object_id empty_tree_oid = {
@@ -68,6 +148,48 @@ static const struct object_id empty_tree_oid_sha256 = {
 static const struct object_id empty_blob_oid_sha256 = {
 	EMPTY_BLOB_SHA256_BIN_LITERAL
 };
+static const struct object_id empty_tree_oid_sha512 = {
+	EMPTY_TREE_SHA512_BIN_LITERAL
+};
+static const struct object_id empty_blob_oid_sha512 = {
+	EMPTY_BLOB_SHA512_BIN_LITERAL
+};
+static const struct object_id empty_tree_oid_sha512_224 = {
+	EMPTY_TREE_SHA512_224_BIN_LITERAL
+};
+static const struct object_id empty_blob_oid_sha512_224 = {
+	EMPTY_BLOB_SHA512_224_BIN_LITERAL
+};
+static const struct object_id empty_tree_oid_sha512_256 = {
+	EMPTY_TREE_SHA512_256_BIN_LITERAL
+};
+static const struct object_id empty_blob_oid_sha512_256 = {
+	EMPTY_BLOB_SHA512_256_BIN_LITERAL
+};
+static const struct object_id empty_tree_oid_sha3_224 = {
+	EMPTY_TREE_SHA3_224_BIN_LITERAL
+};
+static const struct object_id empty_blob_oid_sha3_224 = {
+	EMPTY_BLOB_SHA3_224_BIN_LITERAL
+};
+static const struct object_id empty_tree_oid_sha3_256 = {
+	EMPTY_TREE_SHA3_256_BIN_LITERAL
+};
+static const struct object_id empty_blob_oid_sha3_256 = {
+	EMPTY_BLOB_SHA3_256_BIN_LITERAL
+};
+static const struct object_id empty_tree_oid_sha3_384 = {
+	EMPTY_TREE_SHA3_384_BIN_LITERAL
+};
+static const struct object_id empty_blob_oid_sha3_384 = {
+	EMPTY_BLOB_SHA3_384_BIN_LITERAL
+};
+static const struct object_id empty_tree_oid_sha3_512 = {
+	EMPTY_TREE_SHA3_512_BIN_LITERAL
+};
+static const struct object_id empty_blob_oid_sha3_512 = {
+	EMPTY_BLOB_SHA3_512_BIN_LITERAL
+};
 
 static void git_hash_sha1_init(git_hash_ctx *ctx)
 {
@@ -100,6 +222,61 @@ static void git_hash_sha256_final(unsigned char *hash, git_hash_ctx *ctx)
 	git_SHA256_Final(hash, &ctx->sha256);
 }
 
+static void git_hash_sha512_init(git_hash_ctx *ctx)
+{
+	git_SHA512_Init(&ctx->sha512);
+}
+
+static void git_hash_sha512_224_init(git_hash_ctx *ctx)
+{
+	git_SHA512_224_Init(&ctx->sha512);
+}
+
+static void git_hash_sha512_256_init(git_hash_ctx *ctx)
+{
+	git_SHA512_256_Init(&ctx->sha512);
+}
+
+static void git_hash_sha512_update(git_hash_ctx *ctx, const void *data, size_t len)
+{
+	git_SHA512_Update(&ctx->sha512, data, len);
+}
+
+static void git_hash_sha512_final(unsigned char *hash, git_hash_ctx *ctx)
+{
+	git_SHA512_Final(hash, &ctx->sha512);
+}
+
+static void git_hash_sha3_224_init(git_hash_ctx *ctx)
+{
+	git_SHA3_224_Init(&ctx->sha3);
+}
+
+static void git_hash_sha3_256_init(git_hash_ctx *ctx)
+{
+	git_SHA3_256_Init(&ctx->sha3);
+}
+
+static void git_hash_sha3_384_init(git_hash_ctx *ctx)
+{
+	git_SHA3_384_Init(&ctx->sha3);
+}
+
+static void git_hash_sha3_512_init(git_hash_ctx *ctx)
+{
+	git_SHA3_512_Init(&ctx->sha3);
+}
+
+static void git_hash_sha3_update(git_hash_ctx *ctx, const void *data, size_t len)
+{
+	git_SHA3_Update(&ctx->sha3, data, len);
+}
+
+static void git_hash_sha3_final(unsigned char *hash, git_hash_ctx *ctx)
+{
+	git_SHA3_Final(hash, &ctx->sha3);
+}
+
 static void git_hash_unknown_init(git_hash_ctx *ctx)
 {
 	BUG("trying to init unknown hash");
@@ -153,6 +330,97 @@ const struct git_hash_algo hash_algos[GIT_HASH_NALGOS] = {
 		git_hash_sha256_final,
 		&empty_tree_oid_sha256,
 		&empty_blob_oid_sha256,
+	},
+	{
+		"sha512",
+		/* "s512", big-endian */
+		0x73353132,
+		GIT_SHA512_RAWSZ,
+		GIT_SHA512_HEXSZ,
+		GIT_SHA512_BLKSZ,
+		git_hash_sha512_init,
+		git_hash_sha512_update,
+		git_hash_sha512_final,
+		&empty_tree_oid_sha512,
+		&empty_blob_oid_sha512,
+	},
+	{
+		"sha512/224",
+		/* "s226", big-endian */
+		0x73323236,
+		GIT_SHA512_224_RAWSZ,
+		GIT_SHA512_224_HEXSZ,
+		GIT_SHA512_224_BLKSZ,
+		git_hash_sha512_224_init,
+		git_hash_sha512_update,
+		git_hash_sha512_final,
+		&empty_tree_oid_sha512_224,
+		&empty_blob_oid_sha512_224,
+	},
+	{
+		"sha512/256",
+		/* "s228", big-endian */
+		0x73323238,
+		GIT_SHA512_256_RAWSZ,
+		GIT_SHA512_256_HEXSZ,
+		GIT_SHA512_256_BLKSZ,
+		git_hash_sha512_256_init,
+		git_hash_sha512_update,
+		git_hash_sha512_final,
+		&empty_tree_oid_sha512_256,
+		&empty_blob_oid_sha512_256,
+	},
+	{
+		"sha3-224",
+		/* "s388", big-endian */
+		0x73333838,
+		GIT_SHA3_224_RAWSZ,
+		GIT_SHA3_224_HEXSZ,
+		GIT_SHA3_224_BLKSZ,
+		git_hash_sha3_224_init,
+		git_hash_sha3_update,
+		git_hash_sha3_final,
+		&empty_tree_oid_sha3_224,
+		&empty_blob_oid_sha3_224,
+	},
+	{
+		"sha3-256",
+		/* "s398", big-endian */
+		0x73333938,
+		GIT_SHA3_256_RAWSZ,
+		GIT_SHA3_256_HEXSZ,
+		GIT_SHA3_256_BLKSZ,
+		git_hash_sha3_256_init,
+		git_hash_sha3_update,
+		git_hash_sha3_final,
+		&empty_tree_oid_sha3_256,
+		&empty_blob_oid_sha3_256,
+	},
+	{
+		"sha3-384",
+		/* "s3a8", big-endian */
+		0x73336138,
+		GIT_SHA3_384_RAWSZ,
+		GIT_SHA3_384_HEXSZ,
+		GIT_SHA3_384_BLKSZ,
+		git_hash_sha3_384_init,
+		git_hash_sha3_update,
+		git_hash_sha3_final,
+		&empty_tree_oid_sha3_384,
+		&empty_blob_oid_sha3_384,
+	},
+	{
+		"sha3-512",
+		/* "s3b8", big-endian */
+		0x73336238,
+		GIT_SHA3_512_RAWSZ,
+		GIT_SHA3_512_HEXSZ,
+		GIT_SHA3_512_BLKSZ,
+		git_hash_sha3_512_init,
+		git_hash_sha3_update,
+		git_hash_sha3_final,
+		&empty_tree_oid_sha3_512,
+		&empty_blob_oid_sha3_512,
 	}
 };
 
diff --git a/t/helper/test-sha512.c b/t/helper/test-sha512.c
new file mode 100644
index 000000000000..c80941a2a595
--- /dev/null
+++ b/t/helper/test-sha512.c
@@ -0,0 +1,17 @@
+#include "test-tool.h"
+#include "cache.h"
+
+int cmd__sha512(int ac, const char **av)
+{
+	return cmd_hash_impl(ac, av, GIT_HASH_SHA512);
+}
+
+int cmd__sha512_224(int ac, const char **av)
+{
+	return cmd_hash_impl(ac, av, GIT_HASH_SHA512_224);
+}
+
+int cmd__sha512_256(int ac, const char **av)
+{
+	return cmd_hash_impl(ac, av, GIT_HASH_SHA512_256);
+}
diff --git a/t/helper/test-tool.c b/t/helper/test-tool.c
index f20989d4497b..47deff9c6ef4 100644
--- a/t/helper/test-tool.c
+++ b/t/helper/test-tool.c
@@ -57,6 +57,9 @@ static struct test_cmd cmds[] = {
 	{ "sha1", cmd__sha1 },
 	{ "sha1-array", cmd__sha1_array },
 	{ "sha256", cmd__sha256 },
+	{ "sha512", cmd__sha512 },
+	{ "sha512-224", cmd__sha512_224 },
+	{ "sha512-256", cmd__sha512_256 },
 	{ "sigchain", cmd__sigchain },
 	{ "strcmp-offset", cmd__strcmp_offset },
 	{ "string-list", cmd__string_list },
diff --git a/t/helper/test-tool.h b/t/helper/test-tool.h
index 8ed2af71d1b2..927540dff7dd 100644
--- a/t/helper/test-tool.h
+++ b/t/helper/test-tool.h
@@ -47,6 +47,9 @@ int cmd__serve_v2(int argc, const char **argv);
 int cmd__sha1(int argc, const char **argv);
 int cmd__sha1_array(int argc, const char **argv);
 int cmd__sha256(int argc, const char **argv);
+int cmd__sha512(int argc, const char **argv);
+int cmd__sha512_224(int argc, const char **argv);
+int cmd__sha512_256(int argc, const char **argv);
 int cmd__sigchain(int argc, const char **argv);
 int cmd__strcmp_offset(int argc, const char **argv);
 int cmd__string_list(int argc, const char **argv);
diff --git a/t/t0015-hash.sh b/t/t0015-hash.sh
index 291e9061f39d..4735befe1c72 100755
--- a/t/t0015-hash.sh
+++ b/t/t0015-hash.sh
@@ -52,4 +52,84 @@ test_expect_success 'test basic SHA-256 hash values' '
 	grep 6ef19b41225c5369f1c104d45d8d85efa9b057b53b14b4b9b939dd74decc5321 actual
 '
 
+test_expect_success 'test basic SHA-512/224 hash values' '
+	test-tool sha512-224 </dev/null >actual &&
+	grep 6ed0dd02806fa89e25de060c19d3ac86cabb87d6a0ddd05c333b84f4 actual &&
+	printf "a" | test-tool sha512-224 >actual &&
+	grep d5cdb9ccc769a5121d4175f2bfdd13d6310e0d3d361ea75d82108327 actual &&
+	printf "abc" | test-tool sha512-224 >actual &&
+	grep 4634270f707b6a54daae7530460842e20e37ed265ceee9a43e8924aa actual &&
+	printf "message digest" | test-tool sha512-224 >actual &&
+	grep ad1a4db188fe57064f4f24609d2a83cd0afb9b398eb2fcaeaae2c564 actual &&
+	printf "abcdefghijklmnopqrstuvwxyz" | test-tool sha512-224 >actual &&
+	grep ff83148aa07ec30655c1b40aff86141c0215fe2a54f767d3f38743d8 actual &&
+	# Try to exercise the chunking code by turning autoflush on.
+	perl -e "$| = 1; print q{aaaaaaaaaa} for 1..100000;" | \
+		test-tool sha512-224 >actual &&
+	grep 37ab331d76f0d36de422bd0edeb22a28accd487b7a8453ae965dd287 actual &&
+	perl -e "$| = 1; print q{abcdefghijklmnopqrstuvwxyz} for 1..100000;" | \
+		test-tool sha512-224 >actual &&
+	grep 6a312ce7c451ef28bf9ad33f5ce85ddf2d9f07097660160dbcb5c4c4 actual &&
+	printf "blob 0\0" | test-tool sha512-224 >actual &&
+	grep a86d3c63339860445607d6cfd3551292a6fb049f0faa222a7c10027b actual &&
+	printf "blob 3\0abc" | test-tool sha512-224 >actual &&
+	grep 9d6948b51bccf6b9814288d3e8cbca42f5e31b825ec613b23a45a546 actual &&
+	printf "tree 0\0" | test-tool sha512-224 >actual &&
+	grep aaff3ab067b151d0bc3130277d64a11eb257e0feca74e0dcb7e38303 actual
+'
+
+test_expect_success 'test basic SHA-512/256 hash values' '
+	test-tool sha512-256 </dev/null >actual &&
+	grep c672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967a actual &&
+	printf "a" | test-tool sha512-256 >actual &&
+	grep 455e518824bc0601f9fb858ff5c37d417d67c2f8e0df2babe4808858aea830f8 actual &&
+	printf "abc" | test-tool sha512-256 >actual &&
+	grep 53048e2681941ef99b2e29b76b4c7dabe4c2d0c634fc6d46e0e2f13107e7af23 actual &&
+	printf "message digest" | test-tool sha512-256 >actual &&
+	grep 0cf471fd17ed69d990daf3433c89b16d63dec1bb9cb42a6094604ee5d7b4e9fb actual &&
+	printf "abcdefghijklmnopqrstuvwxyz" | test-tool sha512-256 >actual &&
+	grep fc3189443f9c268f626aea08a756abe7b726b05f701cb08222312ccfd6710a26 actual &&
+	# Try to exercise the chunking code by turning autoflush on.
+	perl -e "$| = 1; print q{aaaaaaaaaa} for 1..100000;" | \
+		test-tool sha512-256 >actual &&
+	grep 9a59a052930187a97038cae692f30708aa6491923ef5194394dc68d56c74fb21 actual &&
+	perl -e "$| = 1; print q{abcdefghijklmnopqrstuvwxyz} for 1..100000;" | \
+		test-tool sha512-256 >actual &&
+	grep b8803f7dc283e57eeb6340a3ba9d9a2098125500008b5bfdfeeb6ddd0582d2b8 actual &&
+	printf "blob 0\0" | test-tool sha512-256 >actual &&
+	grep 6576668d3acf022c9c77920c8349ed6ccd8fc596845e87c38b9e749016c984b3 actual &&
+	printf "blob 3\0abc" | test-tool sha512-256 >actual &&
+	grep 815d5a4e692c971eea251f5e8d86b42953640027d8f1163d9f33adeb5e1f7a7a actual &&
+	printf "tree 0\0" | test-tool sha512-256 >actual &&
+	grep 2cfe78f8ea2fa9d219374868e7aa1fe491622bcb5815dcf3ad12f308be7959db actual
+
+'
+
+test_expect_success 'test basic SHA-512 hash values' '
+	test-tool sha512 </dev/null >actual &&
+	grep cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e actual &&
+	printf "a" | test-tool sha512 >actual &&
+	grep 1f40fc92da241694750979ee6cf582f2d5d7d28e18335de05abc54d0560e0f5302860c652bf08d560252aa5e74210546f369fbbbce8c12cfc7957b2652fe9a75 actual &&
+	printf "abc" | test-tool sha512 >actual &&
+	grep ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f actual &&
+	printf "message digest" | test-tool sha512 >actual &&
+	grep 107dbf389d9e9f71a3a95f6c055b9251bc5268c2be16d6c13492ea45b0199f3309e16455ab1e96118e8a905d5597b72038ddb372a89826046de66687bb420e7c actual &&
+	printf "abcdefghijklmnopqrstuvwxyz" | test-tool sha512 >actual &&
+	grep 4dbff86cc2ca1bae1e16468a05cb9881c97f1753bce3619034898faa1aabe429955a1bf8ec483d7421fe3c1646613a59ed5441fb0f321389f77f48a879c7b1f1 actual &&
+	# Try to exercise the chunking code by turning autoflush on.
+	perl -e "$| = 1; print q{aaaaaaaaaa} for 1..100000;" | \
+		test-tool sha512 >actual &&
+	grep e718483d0ce769644e2e42c7bc15b4638e1f98b13b2044285632a803afa973ebde0ff244877ea60a4cb0432ce577c31beb009c5c2c49aa2e4eadb217ad8cc09b actual &&
+	perl -e "$| = 1; print q{abcdefghijklmnopqrstuvwxyz} for 1..100000;" | \
+		test-tool sha512 >actual &&
+	grep daeddbe45570b154876086f66464a1a1ea6b623bd6bf53132a92f3326e0edb5cb8bf3eef58fe0b15c87526a226bd3242cad65f1f2025f1dbde0c30e41a9f8253 actual &&
+	printf "blob 0\0" | test-tool sha512 >actual &&
+	grep ba4d0bb3ec890fdc47a10df53a591a79852237d5e635455da90a3742d7482708b57de2ffabc7581f581ee8075fbab3476270942cdf87fa7dd6895daa6509896c actual &&
+	printf "blob 3\0abc" | test-tool sha512 >actual &&
+	grep 55abbe2a993e9d900dcd5e1315dbf5bc634af92500bf4242fd9c5bba38090ee043fc886018aab7fa7d855abf41162a1fcb49ef7bd56778fd6c0b9d1a7ba00a71 actual &&
+	printf "tree 0\0" | test-tool sha512 >actual &&
+	grep d51fd92fdd8b29d08f5cba261abb221529e6ffb1264c511be216d2f5306ecdcc38e2392de4f62c745607a97680fc7ccbbe73044dfc03d89ed95ba54967909195 actual
+
+'
+
 test_done
-- 
2.20.1


  parent reply	other threads:[~2019-12-22  6:48 UTC|newest]

Thread overview: 7+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2019-12-22  6:48 [PATCH 0/6] Additional SHA implementations Michael Clark
2019-12-22  6:48 ` [PATCH 1/6] Move all SHA algorithm variants into sha/ directory Michael Clark
2019-12-22  6:48 ` Michael Clark [this message]
2019-12-22  6:48 ` [PATCH 3/6] Add an implementation of the SHA-3 hash algorithm Michael Clark
2019-12-22  6:48 ` [PATCH 4/6] Add an implementation of the SHA224 truncated " Michael Clark
2019-12-22  6:48 ` [PATCH 5/6] Add OpenSSL EVP interface for SHA-3 and SHA-512 algorithms Michael Clark
2019-12-22  6:48 ` [PATCH 6/6] Add sha/README.md with table of SHA algorithm details Michael Clark

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20191222064809.35667-3-michaeljclark@mac.com \
    --to=michaeljclark@mac.com \
    --cc=git@vger.kernel.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).