From patchwork Sun Dec 22 06:48:04 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Michael Clark X-Patchwork-Id: 11307299 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 6FC7F159A for ; Sun, 22 Dec 2019 06:48:40 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 4E1D920733 for ; Sun, 22 Dec 2019 06:48:40 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=mac.com header.i=@mac.com header.b="Knq9y2iP" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1725848AbfLVGs1 (ORCPT ); Sun, 22 Dec 2019 01:48:27 -0500 Received: from mr85p00im-hyfv06011401.me.com ([17.58.23.191]:36233 "EHLO mr85p00im-hyfv06011401.me.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725775AbfLVGs1 (ORCPT ); Sun, 22 Dec 2019 01:48:27 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=mac.com; s=1a1hai; t=1576997305; bh=rjph3GTyTVgKRyONS6vEc+/nKX1tpkB+qAXLfvJPT7E=; h=From:To:Subject:Date:Message-Id; b=Knq9y2iPqfjyHQ8Xw6dFdxerPPIOJUXbPL4QkMo9KwsWOKU4mouqF4LNsEAKJdoeE SwiA8rNPwEjXmTZKvZIEWf5gilctmcd5MU6kHekUJaMozIdCaar1jwtzhUGoAKyzcq lqSi9I5ztPxc374jWz9ERuPFA0dqT8aVJQ2/U3xkAg2rmsJ9pIQAPhGgzfHM+9Wdda X2boG9niisSqEYkwCusIerqb/HZ/VXDd7gqKNxJBGR4xksN9Pj2M7J5dl6JBM9MVDV VJHAqkIeNqxBCRllqVsTrEUL8Y36ef7+s9ata9c8pcNp+WG2gbeZ7z/Oib7qiOM1WX CsYcy1xuJqbCg== Received: from localhost.localdomain (125-237-36-9-fibre.sparkbb.co.nz [125.237.36.9]) by mr85p00im-hyfv06011401.me.com (Postfix) with ESMTPSA id ED92FD20971; Sun, 22 Dec 2019 06:48:24 +0000 (UTC) From: Michael Clark To: git@vger.kernel.org Cc: Michael Clark Subject: [PATCH 1/6] Move all SHA algorithm variants into sha/ directory Date: Sun, 22 Dec 2019 19:48:04 +1300 Message-Id: <20191222064809.35667-2-michaeljclark@mac.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20191222064809.35667-1-michaeljclark@mac.com> References: <20191222064809.35667-1-michaeljclark@mac.com> MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:,, definitions=2019-12-22_01:,, signatures=0 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 suspectscore=1 malwarescore=0 phishscore=0 bulkscore=0 spamscore=0 clxscore=1015 mlxscore=0 mlxlogscore=965 adultscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.0.1-1908290000 definitions=main-1912220061 Sender: git-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org This is a tidy up before we add additional hash agorithms. This patch does not change code. It only contains renames. After this patch, all hash algorithm implementations are in sha/. --- Makefile | 16 ++++++++-------- hash.h | 6 +++--- {block-sha1 => sha/sha1}/sha1.c | 2 +- {block-sha1 => sha/sha1}/sha1.h | 0 {sha1dc => sha/sha1dc}/.gitattributes | 0 {sha1dc => sha/sha1dc}/LICENSE.txt | 0 {sha1dc => sha/sha1dc}/sha1.c | 0 {sha1dc => sha/sha1dc}/sha1.h | 0 {sha1dc => sha/sha1dc}/ubc_check.c | 0 {sha1dc => sha/sha1dc}/ubc_check.h | 0 sha1dc_git.c => sha/sha1dc_git.c | 0 sha1dc_git.h => sha/sha1dc_git.h | 2 +- {ppc => sha/sha1ppc}/sha1.c | 0 {ppc => sha/sha1ppc}/sha1.h | 0 {ppc => sha/sha1ppc}/sha1ppc.S | 0 {sha256 => sha/sha256}/gcrypt.h | 0 {sha256/block => sha/sha256}/sha256.c | 0 {sha256/block => sha/sha256}/sha256.h | 0 18 files changed, 13 insertions(+), 13 deletions(-) rename {block-sha1 => sha/sha1}/sha1.c (99%) rename {block-sha1 => sha/sha1}/sha1.h (100%) rename {sha1dc => sha/sha1dc}/.gitattributes (100%) rename {sha1dc => sha/sha1dc}/LICENSE.txt (100%) rename {sha1dc => sha/sha1dc}/sha1.c (100%) rename {sha1dc => sha/sha1dc}/sha1.h (100%) rename {sha1dc => sha/sha1dc}/ubc_check.c (100%) rename {sha1dc => sha/sha1dc}/ubc_check.h (100%) rename sha1dc_git.c => sha/sha1dc_git.c (100%) rename sha1dc_git.h => sha/sha1dc_git.h (95%) rename {ppc => sha/sha1ppc}/sha1.c (100%) rename {ppc => sha/sha1ppc}/sha1.h (100%) rename {ppc => sha/sha1ppc}/sha1ppc.S (100%) rename {sha256 => sha/sha256}/gcrypt.h (100%) rename {sha256/block => sha/sha256}/sha256.c (100%) rename {sha256/block => sha/sha256}/sha256.h (100%) diff --git a/Makefile b/Makefile index 42a061d3fb75..bac1b30b2f1f 100644 --- a/Makefile +++ b/Makefile @@ -1158,7 +1158,7 @@ THIRD_PARTY_SOURCES += compat/obstack.% THIRD_PARTY_SOURCES += compat/poll/% THIRD_PARTY_SOURCES += compat/regex/% THIRD_PARTY_SOURCES += sha1collisiondetection/% -THIRD_PARTY_SOURCES += sha1dc/% +THIRD_PARTY_SOURCES += sha/sha1dc/% GITLIBS = common-main.o $(LIB_FILE) $(XDIFF_LIB) EXTLIBS = @@ -1657,11 +1657,11 @@ ifdef OPENSSL_SHA1 BASIC_CFLAGS += -DSHA1_OPENSSL else ifdef BLK_SHA1 - LIB_OBJS += block-sha1/sha1.o + LIB_OBJS += sha/sha1/sha1.o BASIC_CFLAGS += -DSHA1_BLK else ifdef PPC_SHA1 - LIB_OBJS += ppc/sha1.o ppc/sha1ppc.o + LIB_OBJS += sha/sha1ppc/sha1.o sha/sha1ppc/sha1ppc.o BASIC_CFLAGS += -DSHA1_PPC else ifdef APPLE_COMMON_CRYPTO @@ -1670,7 +1670,7 @@ ifdef APPLE_COMMON_CRYPTO else DC_SHA1 := YesPlease BASIC_CFLAGS += -DSHA1_DC - LIB_OBJS += sha1dc_git.o + LIB_OBJS += sha/sha1dc_git.o ifdef DC_SHA1_EXTERNAL ifdef DC_SHA1_SUBMODULE ifneq ($(DC_SHA1_SUBMODULE),auto) @@ -1685,8 +1685,8 @@ ifdef DC_SHA1_SUBMODULE LIB_OBJS += sha1collisiondetection/lib/ubc_check.o BASIC_CFLAGS += -DDC_SHA1_SUBMODULE else - LIB_OBJS += sha1dc/sha1.o - LIB_OBJS += sha1dc/ubc_check.o + LIB_OBJS += sha/sha1dc/sha1.o + LIB_OBJS += sha/sha1dc/ubc_check.o endif BASIC_CFLAGS += \ -DSHA1DC_NO_STANDARD_INCLUDES \ @@ -1707,7 +1707,7 @@ ifdef GCRYPT_SHA256 BASIC_CFLAGS += -DSHA256_GCRYPT EXTLIBS += -lgcrypt else - LIB_OBJS += sha256/block/sha256.o + LIB_OBJS += sha/sha256/sha256.o BASIC_CFLAGS += -DSHA256_BLK endif endif @@ -2782,7 +2782,7 @@ sparse: $(SP_OBJ) GEN_HDRS := command-list.h unicode-width.h EXCEPT_HDRS := $(GEN_HDRS) compat/% xdiff/% ifndef GCRYPT_SHA256 - EXCEPT_HDRS += sha256/gcrypt.h + EXCEPT_HDRS += sha/sha256/gcrypt.h endif CHK_HDRS = $(filter-out $(EXCEPT_HDRS),$(LIB_H)) HCO = $(patsubst %.h,%.hco,$(CHK_HDRS)) diff --git a/hash.h b/hash.h index 52a4f1a3f430..f1b941218dc8 100644 --- a/hash.h +++ b/hash.h @@ -10,9 +10,9 @@ #elif defined(SHA1_OPENSSL) #include #elif defined(SHA1_DC) -#include "sha1dc_git.h" +#include "sha/sha1dc_git.h" #else /* SHA1_BLK */ -#include "block-sha1/sha1.h" +#include "sha/sha1/sha1.h" #endif #if defined(SHA256_GCRYPT) @@ -20,7 +20,7 @@ #elif defined(SHA256_OPENSSL) #include #else -#include "sha256/block/sha256.h" +#include "sha/sha256/sha256.h" #endif #ifndef platform_SHA_CTX diff --git a/block-sha1/sha1.c b/sha/sha1/sha1.c similarity index 99% rename from block-sha1/sha1.c rename to sha/sha1/sha1.c index 22b125cf8c12..ad9f7e50a395 100644 --- a/block-sha1/sha1.c +++ b/sha/sha1/sha1.c @@ -7,7 +7,7 @@ */ /* this is only to get definitions for memcpy(), ntohl() and htonl() */ -#include "../git-compat-util.h" +#include "git-compat-util.h" #include "sha1.h" diff --git a/block-sha1/sha1.h b/sha/sha1/sha1.h similarity index 100% rename from block-sha1/sha1.h rename to sha/sha1/sha1.h diff --git a/sha1dc/.gitattributes b/sha/sha1dc/.gitattributes similarity index 100% rename from sha1dc/.gitattributes rename to sha/sha1dc/.gitattributes diff --git a/sha1dc/LICENSE.txt b/sha/sha1dc/LICENSE.txt similarity index 100% rename from sha1dc/LICENSE.txt rename to sha/sha1dc/LICENSE.txt diff --git a/sha1dc/sha1.c b/sha/sha1dc/sha1.c similarity index 100% rename from sha1dc/sha1.c rename to sha/sha1dc/sha1.c diff --git a/sha1dc/sha1.h b/sha/sha1dc/sha1.h similarity index 100% rename from sha1dc/sha1.h rename to sha/sha1dc/sha1.h diff --git a/sha1dc/ubc_check.c b/sha/sha1dc/ubc_check.c similarity index 100% rename from sha1dc/ubc_check.c rename to sha/sha1dc/ubc_check.c diff --git a/sha1dc/ubc_check.h b/sha/sha1dc/ubc_check.h similarity index 100% rename from sha1dc/ubc_check.h rename to sha/sha1dc/ubc_check.h diff --git a/sha1dc_git.c b/sha/sha1dc_git.c similarity index 100% rename from sha1dc_git.c rename to sha/sha1dc_git.c diff --git a/sha1dc_git.h b/sha/sha1dc_git.h similarity index 95% rename from sha1dc_git.h rename to sha/sha1dc_git.h index 41e1c3fd3f78..100a7cc9d641 100644 --- a/sha1dc_git.h +++ b/sha/sha1dc_git.h @@ -5,7 +5,7 @@ #elif defined(DC_SHA1_SUBMODULE) #include "sha1collisiondetection/lib/sha1.h" #else -#include "sha1dc/sha1.h" +#include "sha/sha1dc/sha1.h" #endif #ifdef DC_SHA1_EXTERNAL diff --git a/ppc/sha1.c b/sha/sha1ppc/sha1.c similarity index 100% rename from ppc/sha1.c rename to sha/sha1ppc/sha1.c diff --git a/ppc/sha1.h b/sha/sha1ppc/sha1.h similarity index 100% rename from ppc/sha1.h rename to sha/sha1ppc/sha1.h diff --git a/ppc/sha1ppc.S b/sha/sha1ppc/sha1ppc.S similarity index 100% rename from ppc/sha1ppc.S rename to sha/sha1ppc/sha1ppc.S diff --git a/sha256/gcrypt.h b/sha/sha256/gcrypt.h similarity index 100% rename from sha256/gcrypt.h rename to sha/sha256/gcrypt.h diff --git a/sha256/block/sha256.c b/sha/sha256/sha256.c similarity index 100% rename from sha256/block/sha256.c rename to sha/sha256/sha256.c diff --git a/sha256/block/sha256.h b/sha/sha256/sha256.h similarity index 100% rename from sha256/block/sha256.h rename to sha/sha256/sha256.h From patchwork Sun Dec 22 06:48:05 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Michael Clark X-Patchwork-Id: 11307301 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id B871C921 for ; Sun, 22 Dec 2019 06:48:40 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 7903F206CB for ; Sun, 22 Dec 2019 06:48:40 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=mac.com header.i=@mac.com header.b="LywrJpab" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1725899AbfLVGs3 (ORCPT ); Sun, 22 Dec 2019 01:48:29 -0500 Received: from mr85p00im-hyfv06011401.me.com ([17.58.23.191]:36375 "EHLO mr85p00im-hyfv06011401.me.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725775AbfLVGs3 (ORCPT ); Sun, 22 Dec 2019 01:48:29 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=mac.com; s=1a1hai; t=1576997307; bh=vmff1nqE5B6xE/CCBZeL2/eFT5LpliQQWYvPYqqHjJg=; h=From:To:Subject:Date:Message-Id; b=LywrJpabCrZTRd3BcSEMWkGyH0DDXDTryLoCNDqOwNhlIj2mCPrYOaZpI1FVvR0VM G4CqiWBxq8TiJeUsgljwyP+XW27ocfVYEFxdA2vH/ByjRCC7CNdJBS7efp/TNGRNcR Yfv/dS2lLa/n2FgnSn7F991YWCQBrTWCA6aoGftepBVdG7qQEz7ZEO1ytUX1agoxjW ot5vERetNIZM5tbY3WGO0OKgP35X7EGOpyMwFBlNLbJzav/1/dMoPYnjVyfwB0JYdo XOsWbi1Gsy9L+VLqAp2/5fhknC+MO0mQwhteJPTXfEnksBGY7iUSWFWMq8wO9aUaFc ngLWCMSw9O+TA== Received: from localhost.localdomain (125-237-36-9-fibre.sparkbb.co.nz [125.237.36.9]) by mr85p00im-hyfv06011401.me.com (Postfix) with ESMTPSA id 468BED209F7; Sun, 22 Dec 2019 06:48:26 +0000 (UTC) From: Michael Clark To: git@vger.kernel.org Cc: Michael Clark Subject: [PATCH 2/6] Add an implementation of the SHA-512 hash algorithm Date: Sun, 22 Dec 2019 19:48:05 +1300 Message-Id: <20191222064809.35667-3-michaeljclark@mac.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20191222064809.35667-1-michaeljclark@mac.com> References: <20191222064809.35667-1-michaeljclark@mac.com> MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:,, definitions=2019-12-22_01:,, signatures=0 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 suspectscore=1 malwarescore=0 phishscore=0 bulkscore=0 spamscore=0 clxscore=1015 mlxscore=0 mlxlogscore=999 adultscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.0.1-1908290000 definitions=main-1912220061 Sender: git-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org - 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 + +#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 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 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 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 From patchwork Sun Dec 22 06:48:06 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Michael Clark X-Patchwork-Id: 11307303 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id E3D5018B6 for ; Sun, 22 Dec 2019 06:48:40 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id C1E81206CB for ; Sun, 22 Dec 2019 06:48:40 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=mac.com header.i=@mac.com header.b="fWqhSeel" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1725958AbfLVGsb (ORCPT ); Sun, 22 Dec 2019 01:48:31 -0500 Received: from mr85p00im-hyfv06011401.me.com ([17.58.23.191]:36522 "EHLO mr85p00im-hyfv06011401.me.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725852AbfLVGsb (ORCPT ); Sun, 22 Dec 2019 01:48:31 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=mac.com; s=1a1hai; t=1576997309; bh=DDYVF/GUnAvYCYVNzldkAbNHNFmEqlRgF5KB1J0ayv8=; h=From:To:Subject:Date:Message-Id:Content-Type; b=fWqhSeelkWApoE+tBffySklQXMawcz5667Y+hRFkmiGyCPWYWuNTtRoC+th9Fe3R+ /Ci/buFgqz1lsK6d9IES6gSjjXgUzbwl2DUGgkuP8zbTCVEFgidBnAy6tFuCBJPN+L 6xXxgkPTs3bth0ZuIC06hDmbSYd1xHWtq2uGz6oNb1I+/Wtdg/FfcNpzEL23dzZVWx gAZRs+2NQA250tgZPyzIhAYsZSnRc2aubD48Ad86f8PSR7WE+e1ru/jJBj+nmhn8P4 W3fMS7Ebajyy5Ni00VcRYgL0Gi8Q7GS8+c52xb1U96JI56gsOtmP9FKX3EQ5Y+yGyO AXty403VZYG0g== Received: from localhost.localdomain (125-237-36-9-fibre.sparkbb.co.nz [125.237.36.9]) by mr85p00im-hyfv06011401.me.com (Postfix) with ESMTPSA id 24859D20971; Sun, 22 Dec 2019 06:48:27 +0000 (UTC) From: Michael Clark To: git@vger.kernel.org Cc: Michael Clark Subject: [PATCH 3/6] Add an implementation of the SHA-3 hash algorithm Date: Sun, 22 Dec 2019 19:48:06 +1300 Message-Id: <20191222064809.35667-4-michaeljclark@mac.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20191222064809.35667-1-michaeljclark@mac.com> References: <20191222064809.35667-1-michaeljclark@mac.com> MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:,, definitions=2019-12-22_01:,, signatures=0 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 suspectscore=1 malwarescore=0 phishscore=0 bulkscore=0 spamscore=0 clxscore=1015 mlxscore=0 mlxlogscore=999 adultscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.0.1-1908290000 definitions=main-1912220061 Sender: git-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org - Add SHA3-224, SHA3-256, SHA3-384 and SHA3-512 hash algorithms derived from the Keccak SHA-3 submission to NIST (Round 3), 2011 by Guido Bertoni, Joan Daemen, Michaël Peeters and Gilles Van Assche - Add configuration machinery to select builtin impl or gcrypt. - Add sha3-224, sha3-256, sha3-384 and sha3-512 commands to test-tool. - Add sha3 hash tests to t/t0015-hash.sh --- Makefile | 9 ++ hash.h | 49 +++++++- sha/sha3/gcrypt.h | 53 +++++++++ sha/sha3/sha3.c | 271 +++++++++++++++++++++++++++++++++++++++++++ sha/sha3/sha3.h | 34 ++++++ t/helper/test-sha3.c | 22 ++++ t/helper/test-tool.c | 4 + t/helper/test-tool.h | 4 + t/t0015-hash.sh | 108 +++++++++++++++++ 9 files changed, 553 insertions(+), 1 deletion(-) create mode 100644 sha/sha3/gcrypt.h create mode 100644 sha/sha3/sha3.c create mode 100644 sha/sha3/sha3.h create mode 100644 t/helper/test-sha3.c diff --git a/Makefile b/Makefile index 2cd505b21ebb..6bf9900291cb 100644 --- a/Makefile +++ b/Makefile @@ -742,6 +742,7 @@ 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-sha3.o TEST_BUILTINS_OBJS += test-sigchain.o TEST_BUILTINS_OBJS += test-strcmp-offset.o TEST_BUILTINS_OBJS += test-string-list.o @@ -1723,6 +1724,14 @@ else BASIC_CFLAGS += -DSHA512_BLK endif +ifdef GCRYPT_SHA3 + BASIC_CFLAGS += -DSHA3_GCRYPT + EXTLIBS += -lgcrypt +else + LIB_OBJS += sha/sha3/sha3.o + BASIC_CFLAGS += -DSHA3_BLK +endif + ifdef SHA1_MAX_BLOCK_SIZE LIB_OBJS += compat/sha1-chunked.o BASIC_CFLAGS += -DSHA1_MAX_BLOCK_SIZE="$(SHA1_MAX_BLOCK_SIZE)" diff --git a/hash.h b/hash.h index ea96fccce0c8..4826de3c80d4 100644 --- a/hash.h +++ b/hash.h @@ -29,6 +29,12 @@ #include "sha/sha512/sha512.h" #endif +#if defined(SHA3_GCRYPT) +#include "sha/sha3/gcrypt.h" +#else +#include "sha/sha3/sha3.h" +#endif + #ifndef platform_SHA_CTX /* * platform's underlying implementation of SHA-1; could be OpenSSL, @@ -67,6 +73,14 @@ #define git_SHA512_Update platform_SHA512_Update #define git_SHA512_Final platform_SHA512_Final +#define git_SHA3_CTX platform_SHA3_CTX +#define git_SHA3_224_Init platform_SHA3_224_Init +#define git_SHA3_256_Init platform_SHA3_256_Init +#define git_SHA3_384_Init platform_SHA3_384_Init +#define git_SHA3_512_Init platform_SHA3_512_Init +#define git_SHA3_Update platform_SHA3_Update +#define git_SHA3_Final platform_SHA3_Final + #ifdef SHA1_MAX_BLOCK_SIZE #include "compat/sha1-chunked.h" #undef git_SHA1_Update @@ -93,14 +107,23 @@ #define GIT_HASH_SHA512_224 4 /* SHA-512-256 */ #define GIT_HASH_SHA512_256 5 +/* SHA-3-224 */ +#define GIT_HASH_SHA3_224 6 +/* SHA-3-256 */ +#define GIT_HASH_SHA3_256 7 +/* SHA-3-384 */ +#define GIT_HASH_SHA3_384 8 +/* SHA-3-512 */ +#define GIT_HASH_SHA3_512 9 /* Number of algorithms supported (including unknown). */ -#define GIT_HASH_NALGOS (GIT_HASH_SHA512_256 + 1) +#define GIT_HASH_NALGOS (GIT_HASH_SHA3_512 + 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; + git_SHA3_CTX sha3; }; typedef union git_hash_ctx git_hash_ctx; @@ -189,6 +212,30 @@ static inline int hash_algo_by_ptr(const struct git_hash_algo *p) /* The block size of SHA-512-256. */ #define GIT_SHA512_256_BLKSZ 128 +/* The length in bytes and in hex digits of an object name (SHA-3-224 value). */ +#define GIT_SHA3_224_RAWSZ 28 +#define GIT_SHA3_224_HEXSZ (2 * GIT_SHA3_224_RAWSZ) +/* The block size of SHA-3-224. */ +#define GIT_SHA3_224_BLKSZ 128 + +/* The length in bytes and in hex digits of an object name (SHA-3-256 value). */ +#define GIT_SHA3_256_RAWSZ 32 +#define GIT_SHA3_256_HEXSZ (2 * GIT_SHA3_256_RAWSZ) +/* The block size of SHA-3-256. */ +#define GIT_SHA3_256_BLKSZ 128 + +/* The length in bytes and in hex digits of an object name (SHA-3-384 value). */ +#define GIT_SHA3_384_RAWSZ 48 +#define GIT_SHA3_384_HEXSZ (2 * GIT_SHA3_384_RAWSZ) +/* The block size of SHA-3-384. */ +#define GIT_SHA3_384_BLKSZ 128 + +/* The length in bytes and in hex digits of an object name (SHA-3-512 value). */ +#define GIT_SHA3_512_RAWSZ 64 +#define GIT_SHA3_512_HEXSZ (2 * GIT_SHA3_512_RAWSZ) +/* The block size of SHA-3-512. */ +#define GIT_SHA3_512_BLKSZ 128 + /* The length in byte and in hex digits of the largest possible hash value. */ #define GIT_MAX_RAWSZ GIT_SHA512_RAWSZ #define GIT_MAX_HEXSZ GIT_SHA512_HEXSZ diff --git a/sha/sha3/gcrypt.h b/sha/sha3/gcrypt.h new file mode 100644 index 000000000000..47a1482d65bc --- /dev/null +++ b/sha/sha3/gcrypt.h @@ -0,0 +1,53 @@ +#ifndef SHA3_GCRYPT_H +#define SHA3_GCRYPT_H + +#include + +#define SHA3_224_DIGEST_SIZE 28 +#define SHA3_256_DIGEST_SIZE 32 +#define SHA3_384_DIGEST_SIZE 48 +#define SHA3_512_DIGEST_SIZE 64 + +typedef gcry_md_hd_t gcrypt_SHA3_CTX; + +inline void gcrypt_SHA3_224_Init(gcrypt_SHA3_CTX *ctx) +{ + gcry_md_open(ctx, GCRY_MD_SHA3_224, 0); +} + +inline void gcrypt_SHA3_256_Init(gcrypt_SHA3_CTX *ctx) +{ + gcry_md_open(ctx, GCRY_MD_SHA3_256, 0); +} + +inline void gcrypt_SHA3_384_Init(gcrypt_SHA3_CTX *ctx) +{ + gcry_md_open(ctx, GCRY_MD_SHA3_384, 0); +} + +inline void gcrypt_SHA3_512_Init(gcrypt_SHA3_CTX *ctx) +{ + gcry_md_open(ctx, GCRY_MD_SHA3_512, 0); +} + +inline void gcrypt_SHA3_Update(gcrypt_SHA3_CTX *ctx, const void *data, size_t len) +{ + gcry_md_write(*ctx, data, len); +} + +inline void gcrypt_SHA3_Final(unsigned char *digest, gcrypt_SHA3_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_SHA3_CTX gcrypt_SHA3_CTX +#define platform_SHA3_224_Init gcrypt_SHA3_224_Init +#define platform_SHA3_256_Init gcrypt_SHA3_256_Init +#define platform_SHA3_384_Init gcrypt_SHA3_384_Init +#define platform_SHA3_512_Init gcrypt_SHA3_512_Init +#define platform_SHA3_Update gcrypt_SHA3_Update +#define platform_SHA3_Final gcrypt_SHA3_Final + +#endif diff --git a/sha/sha3/sha3.c b/sha/sha3/sha3.c new file mode 100644 index 000000000000..572cbf88f163 --- /dev/null +++ b/sha/sha3/sha3.c @@ -0,0 +1,271 @@ +/* + * sha3.c + * + * an implementation of Secure Hash Algorithm 3 (Keccak) based on: + * The Keccak SHA-3 submission. Submission to NIST (Round 3), 2011 + * by Guido Bertoni, Joan Daemen, Michaël Peeters and Gilles Van Assche + * + * portions derived from RHash/sha3.c + * + * Copyright (c) 2013, Aleksey Kravchenko + * Copyright (c) 2019, Michael Clark + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted. + * + * 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 "git-compat-util.h" +#include "sha3.h" + +/* + * macro to expand Keccak 7-term GF(2) round constant: + * + * (ax^63 + bx^31 + cx^15 + dx^7 + ex^3 + fx + g) + * + * K(c) -> forall (b in 0...6) |= c[b] << (1 << b) ; + */ +#define T(c,b) 0b##c##ull>>b<<63>>(64-(1 << b)) +#define K(c) T(c,0)|T(c,1)|T(c,2)|T(c,3)|T(c,4)|T(c,5)|T(c,6) + +/* + * expand SHA3 (Keccak) constants for 24 rounds + */ +static uint64_t keccak_round_constants[24] = { + K(0000001), K(0011010), K(1011110), K(1110000), + K(0011111), K(0100001), K(1111001), K(1010101), + K(0001110), K(0001100), K(0110101), K(0100110), + K(0111111), K(1001111), K(1011101), K(1010011), + K(1010010), K(1001000), K(0010110), K(1100110), + K(1111001), K(1011000), K(0100001), K(1110100), +}; + +static inline uint64_t rol(uint64_t x, int d) +{ + return (x << d) | (x >> (64-d)); +} + +/* Keccak theta() transformation */ +static void keccak_theta(uint64_t A[25]) +{ + uint64_t C[5] = { + A[0] ^ A[5] ^ A[10] ^ A[15] ^ A[20], + A[1] ^ A[6] ^ A[11] ^ A[16] ^ A[21], + A[2] ^ A[7] ^ A[12] ^ A[17] ^ A[22], + A[3] ^ A[8] ^ A[13] ^ A[18] ^ A[23], + A[4] ^ A[9] ^ A[14] ^ A[19] ^ A[24] + }; + + uint64_t D[5] = { + rol(C[1], 1) ^ C[4], + rol(C[2], 1) ^ C[0], + rol(C[3], 1) ^ C[1], + rol(C[4], 1) ^ C[2], + rol(C[0], 1) ^ C[3] + }; + + for (size_t i = 0; i < 25; i += 5) { + A[i + 0] ^= D[0]; + A[i + 1] ^= D[1]; + A[i + 2] ^= D[2]; + A[i + 3] ^= D[3]; + A[i + 4] ^= D[4]; + } +} + +/* Keccak pi() transformation */ +static void keccak_pi(uint64_t A[25]) +{ + uint64_t A1; + A1 = A[1]; + A[ 1] = A[ 6]; + A[ 6] = A[ 9]; + A[ 9] = A[22]; + A[22] = A[14]; + A[14] = A[20]; + A[20] = A[ 2]; + A[ 2] = A[12]; + A[12] = A[13]; + A[13] = A[19]; + A[19] = A[23]; + A[23] = A[15]; + A[15] = A[ 4]; + A[ 4] = A[24]; + A[24] = A[21]; + A[21] = A[ 8]; + A[ 8] = A[16]; + A[16] = A[ 5]; + A[ 5] = A[ 3]; + A[ 3] = A[18]; + A[18] = A[17]; + A[17] = A[11]; + A[11] = A[ 7]; + A[ 7] = A[10]; + A[10] = A1; + /* note: A[ 0] is left as is */ +} + +static inline void ChiStep(uint64_t A[25], size_t i) +{ + uint64_t C[5]; + C[0] = A[0 + i] ^ ~A[1 + i] & A[2 + i]; + C[1] = A[1 + i] ^ ~A[2 + i] & A[3 + i]; + C[2] = A[2 + i] ^ ~A[3 + i] & A[4 + i]; + C[3] = A[3 + i] ^ ~A[4 + i] & A[0 + i]; + C[4] = A[4 + i] ^ ~A[0 + i] & A[1 + i]; + A[0 + i] = C[0]; + A[1 + i] = C[1]; + A[2 + i] = C[2]; + A[3 + i] = C[3]; + A[4 + i] = C[4]; +} + +/* Keccak chi() transformation */ +static void keccak_chi(uint64_t A[25]) +{ + ChiStep(A,0); + ChiStep(A,5); + ChiStep(A,10); + ChiStep(A,15); + ChiStep(A,20); +} + +static void keccak_rho(uint64_t A[25]) +{ + /* apply Keccak rho() transformation */ + A[ 1] = rol(A[ 1], 1); + A[ 2] = rol(A[ 2], 62); + A[ 3] = rol(A[ 3], 28); + A[ 4] = rol(A[ 4], 27); + A[ 5] = rol(A[ 5], 36); + A[ 6] = rol(A[ 6], 44); + A[ 7] = rol(A[ 7], 6); + A[ 8] = rol(A[ 8], 55); + A[ 9] = rol(A[ 9], 20); + A[10] = rol(A[10], 3); + A[11] = rol(A[11], 10); + A[12] = rol(A[12], 43); + A[13] = rol(A[13], 25); + A[14] = rol(A[14], 39); + A[15] = rol(A[15], 41); + A[16] = rol(A[16], 45); + A[17] = rol(A[17], 15); + A[18] = rol(A[18], 21); + A[19] = rol(A[19], 8); + A[20] = rol(A[20], 18); + A[21] = rol(A[21], 2); + A[22] = rol(A[22], 61); + A[23] = rol(A[23], 56); + A[24] = rol(A[24], 14); +} + +static void keccak_iota(uint64_t A[25], size_t round) +{ + /* apply iota(state, round) */ + A[0] ^= keccak_round_constants[round]; +} + +static void keccak_permutation(uint64_t A[25]) +{ + for (size_t round = 0; round < 24; round++) + { + keccak_theta(A); + keccak_rho(A); + keccak_pi(A); + keccak_chi(A); + keccak_iota(A, round); + } +} + +static void blk_SHA3_Transform(blk_SHA3_CTX* ctx, const unsigned char *buf) +{ + size_t block_size = ctx->block_size; + for (size_t i = 0; i < block_size/8; i++) + { + ctx->state[i] ^= le64toh(((uint64_t*)buf)[i]); + } + keccak_permutation(ctx->state); +} + +static void blk_SHA3_Init(blk_SHA3_CTX* ctx, unsigned bits) +{ + /* NB: The Keccak capacity parameter = bits * 2 */ + unsigned rate = 1600 - bits * 2; + + memset(ctx, 0, sizeof(blk_SHA3_CTX)); + ctx->block_size = rate / 8; + assert(rate <= 1600 && (rate % 64) == 0); +} + +void blk_SHA3_224_Init(blk_SHA3_CTX* ctx) { blk_SHA3_Init(ctx, 224); } +void blk_SHA3_256_Init(blk_SHA3_CTX* ctx) { blk_SHA3_Init(ctx, 256); } +void blk_SHA3_384_Init(blk_SHA3_CTX* ctx) { blk_SHA3_Init(ctx, 384); } +void blk_SHA3_512_Init(blk_SHA3_CTX* ctx) { blk_SHA3_Init(ctx, 512); } + +void blk_SHA3_Update(blk_SHA3_CTX* ctx, const void *data, size_t len) +{ + unsigned int block_size = ctx->block_size; + unsigned int len_buf = ctx->size % block_size; + + ctx->size += len; + + /* Read the data into buf and process blocks as they get full */ + if (len_buf) { + unsigned int left = block_size - len_buf; + if (len < left) + left = len; + memcpy(len_buf + ctx->buf, data, left); + len_buf = (len_buf + left) % block_size; + len -= left; + data = ((const char *)data + left); + if (len_buf) + return; + blk_SHA3_Transform(ctx, ctx->buf); + } + while (len >= block_size) { + blk_SHA3_Transform(ctx, data); + data = ((const char *)data + block_size); + len -= block_size; + } + if (len) + memcpy(ctx->buf, data, len); +} + +static inline void put_le64(void *ptr, uint64_t value) +{ + unsigned char *p = ptr; + p[0] = value >> 0; + p[1] = value >> 8; + p[2] = value >> 16; + p[3] = value >> 24; + p[4] = value >> 32; + p[5] = value >> 40; + p[6] = value >> 48; + p[7] = value >> 56; +} + +void blk_SHA3_Final(unsigned char* digest, blk_SHA3_CTX* ctx) +{ + unsigned int digest_length = 100 - ctx->block_size / 2; + unsigned int block_size = ctx->block_size; + unsigned int len = ctx->size % block_size, i; + + /* Pad with 0x06, then zeroes, then 0x80 */ + memset((char*)ctx->buf + len, 0, block_size - len); + ((char*)ctx->buf)[len] |= 0x06; + ((char*)ctx->buf)[block_size - 1] |= 0x80; + + /* process final block */ + blk_SHA3_Transform(ctx, ctx->buf); + + /* copy output */ + for (i = 0; i < (digest_length+7)/8; i++, digest += sizeof(uint64_t)) + put_le64(digest, ctx->state[i]); +} diff --git a/sha/sha3/sha3.h b/sha/sha3/sha3.h new file mode 100644 index 000000000000..eb974d69d2b8 --- /dev/null +++ b/sha/sha3/sha3.h @@ -0,0 +1,34 @@ +#ifndef SHA3_BLOCK_H +#define SHA3_BLOCK_H + +#define blk_SHA3_224_hash_size 28 +#define blk_SHA3_256_hash_size 32 +#define blk_SHA3_384_hash_size 48 +#define blk_SHA3_512_hash_size 64 +#define blk_SHA3_max_permutation_size 200 + +typedef struct blk_SHA3_CTX +{ + uint64_t state[blk_SHA3_max_permutation_size]; + uint64_t size; + uint64_t block_size; + uint8_t buf[blk_SHA3_max_permutation_size]; +} blk_SHA3_CTX; + +void blk_SHA3_224_Init(blk_SHA3_CTX* ctx); +void blk_SHA3_256_Init(blk_SHA3_CTX* ctx); +void blk_SHA3_384_Init(blk_SHA3_CTX* ctx); +void blk_SHA3_512_Init(blk_SHA3_CTX* ctx); +void blk_SHA3_Update(blk_SHA3_CTX* ctx, const void *data, size_t len); +void blk_SHA3_Final(unsigned char* digest, blk_SHA3_CTX* ctx); + +#define platform_SHA3_CTX blk_SHA3_CTX +#define platform_SHA3_Init blk_SHA3_Init +#define platform_SHA3_224_Init blk_SHA3_224_Init +#define platform_SHA3_256_Init blk_SHA3_256_Init +#define platform_SHA3_384_Init blk_SHA3_384_Init +#define platform_SHA3_512_Init blk_SHA3_512_Init +#define platform_SHA3_Update blk_SHA3_Update +#define platform_SHA3_Final blk_SHA3_Final + +#endif \ No newline at end of file diff --git a/t/helper/test-sha3.c b/t/helper/test-sha3.c new file mode 100644 index 000000000000..323936d1bc2e --- /dev/null +++ b/t/helper/test-sha3.c @@ -0,0 +1,22 @@ +#include "test-tool.h" +#include "cache.h" + +int cmd__sha3_224(int ac, const char **av) +{ + return cmd_hash_impl(ac, av, GIT_HASH_SHA3_224); +} + +int cmd__sha3_256(int ac, const char **av) +{ + return cmd_hash_impl(ac, av, GIT_HASH_SHA3_256); +} + +int cmd__sha3_384(int ac, const char **av) +{ + return cmd_hash_impl(ac, av, GIT_HASH_SHA3_384); +} + +int cmd__sha3_512(int ac, const char **av) +{ + return cmd_hash_impl(ac, av, GIT_HASH_SHA3_512); +} diff --git a/t/helper/test-tool.c b/t/helper/test-tool.c index 47deff9c6ef4..7acae78e9b87 100644 --- a/t/helper/test-tool.c +++ b/t/helper/test-tool.c @@ -60,6 +60,10 @@ static struct test_cmd cmds[] = { { "sha512", cmd__sha512 }, { "sha512-224", cmd__sha512_224 }, { "sha512-256", cmd__sha512_256 }, + { "sha3-224", cmd__sha3_224 }, + { "sha3-256", cmd__sha3_256 }, + { "sha3-384", cmd__sha3_384 }, + { "sha3-512", cmd__sha3_512 }, { "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 927540dff7dd..8aa5cee7710b 100644 --- a/t/helper/test-tool.h +++ b/t/helper/test-tool.h @@ -50,6 +50,10 @@ 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__sha3_224(int argc, const char **argv); +int cmd__sha3_256(int argc, const char **argv); +int cmd__sha3_384(int argc, const char **argv); +int cmd__sha3_512(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 4735befe1c72..c68a9ef2145c 100755 --- a/t/t0015-hash.sh +++ b/t/t0015-hash.sh @@ -132,4 +132,112 @@ test_expect_success 'test basic SHA-512 hash values' ' ' +test_expect_success 'test basic SHA3-224 hash values' ' + test-tool sha3-224 actual && + grep 6b4e03423667dbb73b6e15454f0eb1abd4597f9a1b078e3f5b5a6bc7 actual && + printf "a" | test-tool sha3-224 >actual && + grep 9e86ff69557ca95f405f081269685b38e3a819b309ee942f482b6a8b actual && + printf "abc" | test-tool sha3-224 >actual && + grep e642824c3f8cf24ad09234ee7d3c766fc9a3a5168d0c94ad73b46fdf actual && + printf "message digest" | test-tool sha3-224 >actual && + grep 18768bb4c48eb7fc88e5ddb17efcf2964abd7798a39d86a4b4a1e4c8 actual && + printf "abcdefghijklmnopqrstuvwxyz" | test-tool sha3-224 >actual && + grep 5cdeca81e123f87cad96b9cba999f16f6d41549608d4e0f4681b8239 actual && + # Try to exercise the chunking code by turning autoflush on. + perl -e "$| = 1; print q{aaaaaaaaaa} for 1..100000;" | \ + test-tool sha3-224 >actual && + grep d69335b93325192e516a912e6d19a15cb51c6ed5c15243e7a7fd653c actual && + perl -e "$| = 1; print q{abcdefghijklmnopqrstuvwxyz} for 1..100000;" | \ + test-tool sha3-224 >actual && + grep 165efebf793f03c7610d6d5e79462c5f9b7fbcb903f4448038eb35a2 actual && + printf "blob 0\0" | test-tool sha3-224 >actual && + grep f1e72935ac5c52d5c09b408842e207c42e5434424007364fdb468063 actual && + printf "blob 3\0abc" | test-tool sha3-224 >actual && + grep f83c608c9d424b858f66ec80a67ab42409bdc1aae8d7867e6b595e2a actual && + printf "tree 0\0" | test-tool sha3-224 >actual && + grep 1e04f23de0b2b7d1b85e6768fa997a99bd0119dec8158ae0ad07e183 actual + +' + +test_expect_success 'test basic SHA3-256 hash values' ' + test-tool sha3-256 actual && + grep a7ffc6f8bf1ed76651c14756a061d662f580ff4de43b49fa82d80a4b80f8434a actual && + printf "a" | test-tool sha3-256 >actual && + grep 80084bf2fba02475726feb2cab2d8215eab14bc6bdd8bfb2c8151257032ecd8b actual && + printf "abc" | test-tool sha3-256 >actual && + grep 3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532 actual && + printf "message digest" | test-tool sha3-256 >actual && + grep edcdb2069366e75243860c18c3a11465eca34bce6143d30c8665cefcfd32bffd actual && + printf "abcdefghijklmnopqrstuvwxyz" | test-tool sha3-256 >actual && + grep 7cab2dc765e21b241dbc1c255ce620b29f527c6d5e7f5f843e56288f0d707521 actual && + # Try to exercise the chunking code by turning autoflush on. + perl -e "$| = 1; print q{aaaaaaaaaa} for 1..100000;" | \ + test-tool sha3-256 >actual && + grep 5c8875ae474a3634ba4fd55ec85bffd661f32aca75c6d699d0cdcb6c115891c1 actual && + perl -e "$| = 1; print q{abcdefghijklmnopqrstuvwxyz} for 1..100000;" | \ + test-tool sha3-256 >actual && + grep 529a361bd6ebbb28deea5a78db2fd714c5b415499d608e37123c4ca130770e6d actual && + printf "blob 0\0" | test-tool sha3-256 >actual && + grep 5aadde7d8ca5b9b352c250ce9b799f5d818893fe89dc52b49f438c8a9ba0a545 actual && + printf "blob 3\0abc" | test-tool sha3-256 >actual && + grep 1a6437dda2a94af5c38246520fd1461886dc46b97ced88b04d43537c603cde6d actual && + printf "tree 0\0" | test-tool sha3-256 >actual && + grep 30211ed485c912e5bc285bd0bd8959ddbfb5875cafb0ae28e0abfa1077b2b214 actual + +' + +test_expect_success 'test basic SHA3-384 hash values' ' + test-tool sha3-384 actual && + grep 0c63a75b845e4f7d01107d852e4c2485c51a50aaaa94fc61995e71bbee983a2ac3713831264adb47fb6bd1e058d5f004 actual && + printf "a" | test-tool sha3-384 >actual && + grep 1815f774f320491b48569efec794d249eeb59aae46d22bf77dafe25c5edc28d7ea44f93ee1234aa88f61c91912a4ccd9 actual && + printf "abc" | test-tool sha3-384 >actual && + grep ec01498288516fc926459f58e2c6ad8df9b473cb0fc08c2596da7cf0e49be4b298d88cea927ac7f539f1edf228376d25 actual && + printf "message digest" | test-tool sha3-384 >actual && + grep d9519709f44af73e2c8e291109a979de3d61dc02bf69def7fbffdfffe662751513f19ad57e17d4b93ba1e484fc1980d5 actual && + printf "abcdefghijklmnopqrstuvwxyz" | test-tool sha3-384 >actual && + grep fed399d2217aaf4c717ad0c5102c15589e1c990cc2b9a5029056a7f7485888d6ab65db2370077a5cadb53fc9280d278f actual && + # Try to exercise the chunking code by turning autoflush on. + perl -e "$| = 1; print q{aaaaaaaaaa} for 1..100000;" | \ + test-tool sha3-384 >actual && + grep eee9e24d78c1855337983451df97c8ad9eedf256c6334f8e948d252d5e0e76847aa0774ddb90a842190d2c558b4b8340 actual && + perl -e "$| = 1; print q{abcdefghijklmnopqrstuvwxyz} for 1..100000;" | \ + test-tool sha3-384 >actual && + grep 62c16d1d4366dd40a4c6995168c1e7b35e8e8103403274151a34c5838845a0f3d1a192dadbb0964af7d6941c50f0eb97 actual && + printf "blob 0\0" | test-tool sha3-384 >actual && + grep a53e088abe908d8c9458a8ba955690c417f768031ecf156a1662441faeda502e838f2660164b61a78b15ac75e0f8ded4 actual && + printf "blob 3\0abc" | test-tool sha3-384 >actual && + grep ba0eda34a4b47f9ec8ed996a260efadeb576e4f682b7d0d7d84b4781a210771da519e48f2542431882499fbd21d16935 actual && + printf "tree 0\0" | test-tool sha3-384 >actual && + grep 92e99ae9281a89dc332c9ce8f2831db50ecc54784d51c3ebd5c1151e8fd603fb408abbbb9dcf5713ed21566789ce8059 actual + +' + +test_expect_success 'test basic SHA3-512 hash values' ' + test-tool sha3-512 actual && + grep a69f73cca23a9ac5c8b567dc185a756e97c982164fe25859e0d1dcc1475c80a615b2123af1f5f94c11e3e9402c3ac558f500199d95b6d3e301758586281dcd26 actual && + printf "a" | test-tool sha3-512 >actual && + grep 697f2d856172cb8309d6b8b97dac4de344b549d4dee61edfb4962d8698b7fa803f4f93ff24393586e28b5b957ac3d1d369420ce53332712f997bd336d09ab02a actual && + printf "abc" | test-tool sha3-512 >actual && + grep b751850b1a57168a5693cd924b6b096e08f621827444f70d884f5d0240d2712e10e116e9192af3c91a7ec57647e3934057340b4cf408d5a56592f8274eec53f0 actual && + printf "message digest" | test-tool sha3-512 >actual && + grep 3444e155881fa15511f57726c7d7cfe80302a7433067b29d59a71415ca9dd141ac892d310bc4d78128c98fda839d18d7f0556f2fe7acb3c0cda4bff3a25f5f59 actual && + printf "abcdefghijklmnopqrstuvwxyz" | test-tool sha3-512 >actual && + grep af328d17fa28753a3c9f5cb72e376b90440b96f0289e5703b729324a975ab384eda565fc92aaded143669900d761861687acdc0a5ffa358bd0571aaad80aca68 actual && + # Try to exercise the chunking code by turning autoflush on. + perl -e "$| = 1; print q{aaaaaaaaaa} for 1..100000;" | \ + test-tool sha3-512 >actual && + grep 3c3a876da14034ab60627c077bb98f7e120a2a5370212dffb3385a18d4f38859ed311d0a9d5141ce9cc5c66ee689b266a8aa18ace8282a0e0db596c90b0a7b87 actual && + perl -e "$| = 1; print q{abcdefghijklmnopqrstuvwxyz} for 1..100000;" | \ + test-tool sha3-512 >actual && + grep 06b2e52cc7595712651351cdc6726acdebba682844c7983f66089158433975e4d2caf6c0efc4c7018cd2da73df53047f19a79935941025db4aaf1bd876c49ad6 actual && + printf "blob 0\0" | test-tool sha3-512 >actual && + grep 4353a50d0d3d8edd231763fb0102116286aa6d760a772133e32c124a998a19467d789064dd763e57b547ff3a31882da3d2031378cfe0fa5774c12eea51055a51 actual && + printf "blob 3\0abc" | test-tool sha3-512 >actual && + grep 89de02c66a3beca3411b5a72699fe8389d574b7d59ca17d42cba7a83cd03423388b1c4248cd8a3cce73a0768948fe1a800c155c24378334f6ae2bb8c5bf48284 actual && + printf "tree 0\0" | test-tool sha3-512 >actual && + grep 8f86cb67ce0a8bc865b300733c27dade0ea8fe66299b4bc6368ec84f53134c367c66f0e3376261ab5a86d722ad0d98391a3c1c472d6791da464a7836006de12c actual + +' + test_done From patchwork Sun Dec 22 06:48:07 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Michael Clark X-Patchwork-Id: 11307305 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 1A5FC17EF for ; Sun, 22 Dec 2019 06:48:41 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id ECF93206CB for ; Sun, 22 Dec 2019 06:48:40 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=mac.com header.i=@mac.com header.b="q3eVOZ1Q" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1725977AbfLVGsc (ORCPT ); Sun, 22 Dec 2019 01:48:32 -0500 Received: from mr85p00im-hyfv06011401.me.com ([17.58.23.191]:36542 "EHLO mr85p00im-hyfv06011401.me.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725903AbfLVGsc (ORCPT ); Sun, 22 Dec 2019 01:48:32 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=mac.com; s=1a1hai; t=1576997310; bh=CG5yi1nF4CXVhQYsmDi+ZIzymJKktrw8iDwp1sHa1e4=; h=From:To:Subject:Date:Message-Id; b=q3eVOZ1QtAP8LU0z7U76Jn5a+XH74N4hGR3OLIwaB9TkghuSgVpg5iCRKt49rRkl7 j+IelwMWFqMSxG+tzpNdGSDjzJ1/cqlNMCrXp+U2cs+FFcBhgFJv+NuTmvNZrKwbfY 1SYTFENyuHWunKcI2RpHOfidHUjILRG6Z4bTuA8tV6VEmk6PJc6hEi4ACCZbeA1OIZ 2H2wdW7t6iT5QluVRxXW74LXoat+QyzXE/UOadC3AYLRaWvvr/EIsD1araK8oDtySa IKCj+sk2L8gGB9Qk6EqAC81LRNMEW605ecgj+saLAKa8PABvpqxUz2xVDAqWJatqSX pmVe4JngNIl3w== Received: from localhost.localdomain (125-237-36-9-fibre.sparkbb.co.nz [125.237.36.9]) by mr85p00im-hyfv06011401.me.com (Postfix) with ESMTPSA id D3637D20A2D; Sun, 22 Dec 2019 06:48:29 +0000 (UTC) From: Michael Clark To: git@vger.kernel.org Cc: Michael Clark Subject: [PATCH 4/6] Add an implementation of the SHA224 truncated hash algorithm Date: Sun, 22 Dec 2019 19:48:07 +1300 Message-Id: <20191222064809.35667-5-michaeljclark@mac.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20191222064809.35667-1-michaeljclark@mac.com> References: <20191222064809.35667-1-michaeljclark@mac.com> MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:,, definitions=2019-12-22_01:,, signatures=0 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 suspectscore=1 malwarescore=0 phishscore=0 bulkscore=0 spamscore=0 clxscore=1015 mlxscore=0 mlxlogscore=999 adultscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.0.1-1908290000 definitions=main-1912220061 Sender: git-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org - Update existing SHA256 implementation adding initialization vector for SHA224 and add algorithm to list of hash algos. - Add sha224 commands to test-tool. - Add sha224 hash tests to t/t0015-hash.sh --- hash.h | 34 +++++++++++++++++++++++++++------- sha/sha256/gcrypt.h | 15 ++++++++++++++- sha/sha256/sha256.c | 18 +++++++++++++++++- sha/sha256/sha256.h | 9 +++++++++ sha1-file.c | 41 +++++++++++++++++++++++++++++++++++++++++ t/helper/test-sha256.c | 5 +++++ t/helper/test-tool.c | 1 + t/helper/test-tool.h | 1 + t/t0015-hash.sh | 26 ++++++++++++++++++++++++++ 9 files changed, 141 insertions(+), 9 deletions(-) diff --git a/hash.h b/hash.h index 4826de3c80d4..16924203d035 100644 --- a/hash.h +++ b/hash.h @@ -54,6 +54,18 @@ #define git_SHA1_Update platform_SHA1_Update #define git_SHA1_Final platform_SHA1_Final +#ifndef platform_SHA224_CTX +#define platform_SHA224_CTX SHA224_CTX +#define platform_SHA224_Init SHA224_Init +#define platform_SHA224_Update SHA224_Update +#define platform_SHA224_Final SHA224_Final +#endif + +#define git_SHA224_CTX platform_SHA224_CTX +#define git_SHA224_Init platform_SHA224_Init +#define git_SHA224_Update platform_SHA224_Update +#define git_SHA224_Final platform_SHA224_Final + #ifndef platform_SHA256_CTX #define platform_SHA256_CTX SHA256_CTX #define platform_SHA256_Init SHA256_Init @@ -101,20 +113,22 @@ #define GIT_HASH_SHA1 1 /* SHA-256 */ #define GIT_HASH_SHA256 2 +/* SHA-224 */ +#define GIT_HASH_SHA224 3 /* SHA-512 */ -#define GIT_HASH_SHA512 3 +#define GIT_HASH_SHA512 4 /* SHA-512-224 */ -#define GIT_HASH_SHA512_224 4 +#define GIT_HASH_SHA512_224 5 /* SHA-512-256 */ -#define GIT_HASH_SHA512_256 5 +#define GIT_HASH_SHA512_256 6 /* SHA-3-224 */ -#define GIT_HASH_SHA3_224 6 +#define GIT_HASH_SHA3_224 7 /* SHA-3-256 */ -#define GIT_HASH_SHA3_256 7 +#define GIT_HASH_SHA3_256 8 /* SHA-3-384 */ -#define GIT_HASH_SHA3_384 8 +#define GIT_HASH_SHA3_384 9 /* SHA-3-512 */ -#define GIT_HASH_SHA3_512 9 +#define GIT_HASH_SHA3_512 10 /* Number of algorithms supported (including unknown). */ #define GIT_HASH_NALGOS (GIT_HASH_SHA3_512 + 1) @@ -188,6 +202,12 @@ static inline int hash_algo_by_ptr(const struct git_hash_algo *p) /* The block size of SHA-1. */ #define GIT_SHA1_BLKSZ 64 +/* The length in bytes and in hex digits of an object name (SHA-224 value). */ +#define GIT_SHA224_RAWSZ 28 +#define GIT_SHA224_HEXSZ (2 * GIT_SHA224_RAWSZ) +/* The block size of SHA-224. */ +#define GIT_SHA224_BLKSZ 64 + /* The length in bytes and in hex digits of an object name (SHA-256 value). */ #define GIT_SHA256_RAWSZ 32 #define GIT_SHA256_HEXSZ (2 * GIT_SHA256_RAWSZ) diff --git a/sha/sha256/gcrypt.h b/sha/sha256/gcrypt.h index 09bd8bb20062..3de8614eb1d8 100644 --- a/sha/sha256/gcrypt.h +++ b/sha/sha256/gcrypt.h @@ -3,10 +3,16 @@ #include +#define SHA224_DIGEST_SIZE 28 #define SHA256_DIGEST_SIZE 32 typedef gcry_md_hd_t gcrypt_SHA256_CTX; +inline void gcrypt_SHA224_Init(gcrypt_SHA256_CTX *ctx) +{ + gcry_md_open(ctx, GCRY_MD_SHA224, 0); +} + inline void gcrypt_SHA256_Init(gcrypt_SHA256_CTX *ctx) { gcry_md_open(ctx, GCRY_MD_SHA256, 0); @@ -19,7 +25,9 @@ inline void gcrypt_SHA256_Update(gcrypt_SHA256_CTX *ctx, const void *data, size_ inline void gcrypt_SHA256_Final(unsigned char *digest, gcrypt_SHA256_CTX *ctx) { - memcpy(digest, gcry_md_read(*ctx, GCRY_MD_SHA256), SHA256_DIGEST_SIZE); + 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_SHA256_CTX gcrypt_SHA256_CTX @@ -27,4 +35,9 @@ inline void gcrypt_SHA256_Final(unsigned char *digest, gcrypt_SHA256_CTX *ctx) #define platform_SHA256_Update gcrypt_SHA256_Update #define platform_SHA256_Final gcrypt_SHA256_Final +#define platform_SHA224_CTX gcrypt_SHA256_CTX +#define platform_SHA224_Init gcrypt_SHA224_Init +#define platform_SHA224_Update gcrypt_SHA256_Update +#define platform_SHA224_Final gcrypt_SHA256_Final + #endif diff --git a/sha/sha256/sha256.c b/sha/sha256/sha256.c index 37850b4e52e0..a774d7562d6e 100644 --- a/sha/sha256/sha256.c +++ b/sha/sha256/sha256.c @@ -6,8 +6,24 @@ #define BLKSIZE blk_SHA256_BLKSIZE +void blk_SHA224_Init(blk_SHA256_CTX *ctx) +{ + ctx->digestlen = blk_SHA224_HASHSIZE; + ctx->offset = 0; + ctx->size = 0; + ctx->state[0] = 0xc1059ed8ul; + ctx->state[1] = 0x367cd507ul; + ctx->state[2] = 0x3070dd17ul; + ctx->state[3] = 0xf70e5939ul; + ctx->state[4] = 0xffc00b31ul; + ctx->state[5] = 0x68581511ul; + ctx->state[6] = 0x64f98fa7ul; + ctx->state[7] = 0xbefa4fa4ul; +} + void blk_SHA256_Init(blk_SHA256_CTX *ctx) { + ctx->digestlen = blk_SHA256_HASHSIZE; ctx->offset = 0; ctx->size = 0; ctx->state[0] = 0x6a09e667ul; @@ -191,6 +207,6 @@ void blk_SHA256_Final(unsigned char *digest, blk_SHA256_CTX *ctx) blk_SHA256_Update(ctx, padlen, 8); /* copy output */ - for (i = 0; i < 8; i++, digest += sizeof(uint32_t)) + for (i = 0; i < (ctx->digestlen >> 2); i++, digest += sizeof(uint32_t)) put_be32(digest, ctx->state[i]); } diff --git a/sha/sha256/sha256.h b/sha/sha256/sha256.h index 5099d6421d37..e513eafa8199 100644 --- a/sha/sha256/sha256.h +++ b/sha/sha256/sha256.h @@ -2,16 +2,20 @@ #define SHA256_BLOCK_SHA256_H #define blk_SHA256_BLKSIZE 64 +#define blk_SHA224_HASHSIZE 28 +#define blk_SHA256_HASHSIZE 32 struct blk_SHA256_CTX { uint32_t state[8]; uint64_t size; uint32_t offset; + uint32_t digestlen; uint8_t buf[blk_SHA256_BLKSIZE]; }; typedef struct blk_SHA256_CTX blk_SHA256_CTX; +void blk_SHA224_Init(blk_SHA256_CTX *ctx); void blk_SHA256_Init(blk_SHA256_CTX *ctx); void blk_SHA256_Update(blk_SHA256_CTX *ctx, const void *data, size_t len); void blk_SHA256_Final(unsigned char *digest, blk_SHA256_CTX *ctx); @@ -21,4 +25,9 @@ void blk_SHA256_Final(unsigned char *digest, blk_SHA256_CTX *ctx); #define platform_SHA256_Update blk_SHA256_Update #define platform_SHA256_Final blk_SHA256_Final +#define platform_SHA224_CTX blk_SHA256_CTX +#define platform_SHA224_Init blk_SHA224_Init +#define platform_SHA224_Update blk_SHA256_Update +#define platform_SHA224_Final blk_SHA256_Final + #endif diff --git a/sha1-file.c b/sha1-file.c index 1f5b835a9f24..b73847bea5d2 100644 --- a/sha1-file.c +++ b/sha1-file.c @@ -40,6 +40,10 @@ #define EMPTY_TREE_SHA1_BIN_LITERAL \ "\x4b\x82\x5d\xc6\x42\xcb\x6e\xb9\xa0\x60" \ "\xe5\x4b\xf8\xd6\x92\x88\xfb\xee\x49\x04" +#define EMPTY_TREE_SHA224_BIN_LITERAL \ + "\xc8\x24\x29\x25\x0d\x41\x1b\x49\x91\xa3" \ + "\xde\x9b\x42\xf5\x00\x90\x8a\x4a\x24\x2a" \ + "\x8d\x3b\x34\x85\xe5\xe3\xbf\x71" #define EMPTY_TREE_SHA256_BIN_LITERAL \ "\x6e\xf1\x9b\x41\x22\x5c\x53\x69\xf1\xc1" \ "\x04\xd4\x5d\x8d\x85\xef\xa9\xb0\x57\xb5" \ @@ -89,6 +93,10 @@ #define EMPTY_BLOB_SHA1_BIN_LITERAL \ "\xe6\x9d\xe2\x9b\xb2\xd1\xd6\x43\x4b\x8b" \ "\x29\xae\x77\x5a\xd8\xc2\xe4\x8c\x53\x91" +#define EMPTY_BLOB_SHA224_BIN_LITERAL \ + "\xfc\xdd\x1b\x16\x6d\xde\x80\x33\x06\xa4" \ + "\x48\x52\xe0\xb7\xdc\xdf\x73\xba\xd0\xde" \ + "\xc5\x6f\x00\x1f\xeb\x39\xea\x89" #define EMPTY_BLOB_SHA256_BIN_LITERAL \ "\x47\x3a\x0f\x4c\x3b\xe8\xa9\x36\x81\xa2" \ "\x67\xe3\xb1\xe9\xa7\xdc\xda\x11\x85\x43" \ @@ -142,6 +150,12 @@ static const struct object_id empty_tree_oid = { static const struct object_id empty_blob_oid = { EMPTY_BLOB_SHA1_BIN_LITERAL }; +static const struct object_id empty_tree_oid_sha224 = { + EMPTY_TREE_SHA224_BIN_LITERAL +}; +static const struct object_id empty_blob_oid_sha224 = { + EMPTY_BLOB_SHA224_BIN_LITERAL +}; static const struct object_id empty_tree_oid_sha256 = { EMPTY_TREE_SHA256_BIN_LITERAL }; @@ -206,6 +220,20 @@ static void git_hash_sha1_final(unsigned char *hash, git_hash_ctx *ctx) git_SHA1_Final(hash, &ctx->sha1); } +static void git_hash_sha224_init(git_hash_ctx *ctx) +{ + git_SHA224_Init(&ctx->sha256); +} + +static void git_hash_sha224_update(git_hash_ctx *ctx, const void *data, size_t len) +{ + git_SHA224_Update(&ctx->sha256, data, len); +} + +static void git_hash_sha224_final(unsigned char *hash, git_hash_ctx *ctx) +{ + git_SHA224_Final(hash, &ctx->sha256); +} static void git_hash_sha256_init(git_hash_ctx *ctx) { @@ -331,6 +359,19 @@ const struct git_hash_algo hash_algos[GIT_HASH_NALGOS] = { &empty_tree_oid_sha256, &empty_blob_oid_sha256, }, + { + "sha224", + /* "s224", big-endian */ + 0x73323234, + GIT_SHA224_RAWSZ, + GIT_SHA224_HEXSZ, + GIT_SHA224_BLKSZ, + git_hash_sha224_init, + git_hash_sha224_update, + git_hash_sha224_final, + &empty_tree_oid_sha224, + &empty_blob_oid_sha224, + }, { "sha512", /* "s512", big-endian */ diff --git a/t/helper/test-sha256.c b/t/helper/test-sha256.c index 0ac6a99d5f2a..f79aca916128 100644 --- a/t/helper/test-sha256.c +++ b/t/helper/test-sha256.c @@ -1,6 +1,11 @@ #include "test-tool.h" #include "cache.h" +int cmd__sha224(int ac, const char **av) +{ + return cmd_hash_impl(ac, av, GIT_HASH_SHA224); +} + int cmd__sha256(int ac, const char **av) { return cmd_hash_impl(ac, av, GIT_HASH_SHA256); diff --git a/t/helper/test-tool.c b/t/helper/test-tool.c index 7acae78e9b87..762c4cb01d19 100644 --- a/t/helper/test-tool.c +++ b/t/helper/test-tool.c @@ -56,6 +56,7 @@ static struct test_cmd cmds[] = { { "serve-v2", cmd__serve_v2 }, { "sha1", cmd__sha1 }, { "sha1-array", cmd__sha1_array }, + { "sha224", cmd__sha224 }, { "sha256", cmd__sha256 }, { "sha512", cmd__sha512 }, { "sha512-224", cmd__sha512_224 }, diff --git a/t/helper/test-tool.h b/t/helper/test-tool.h index 8aa5cee7710b..e4f63baef948 100644 --- a/t/helper/test-tool.h +++ b/t/helper/test-tool.h @@ -46,6 +46,7 @@ int cmd__scrap_cache_tree(int argc, const char **argv); 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__sha224(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); diff --git a/t/t0015-hash.sh b/t/t0015-hash.sh index c68a9ef2145c..225145d52653 100755 --- a/t/t0015-hash.sh +++ b/t/t0015-hash.sh @@ -52,6 +52,32 @@ test_expect_success 'test basic SHA-256 hash values' ' grep 6ef19b41225c5369f1c104d45d8d85efa9b057b53b14b4b9b939dd74decc5321 actual ' +test_expect_success 'test basic SHA-224 hash values' ' + test-tool sha224 actual && + grep d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42f actual && + printf "a" | test-tool sha224 >actual && + grep abd37534c7d9a2efb9465de931cd7055ffdb8879563ae98078d6d6d5 actual && + printf "abc" | test-tool sha224 >actual && + grep 23097d223405d8228642a477bda255b32aadbce4bda0b3f7e36c9da7 actual && + printf "message digest" | test-tool sha224 >actual && + grep 2cb21c83ae2f004de7e81c3c7019cbcb65b71ab656b22d6d0c39b8eb actual && + printf "abcdefghijklmnopqrstuvwxyz" | test-tool sha224 >actual && + grep 45a5f72c39c5cff2522eb3429799e49e5f44b356ef926bcf390dccc2 actual && + # Try to exercise the chunking code by turning autoflush on. + perl -e "$| = 1; print q{aaaaaaaaaa} for 1..100000;" | \ + test-tool sha224 >actual && + grep 20794655980c91d8bbb4c1ea97618a4bf03f42581948b2ee4ee7ad67 actual && + perl -e "$| = 1; print q{abcdefghijklmnopqrstuvwxyz} for 1..100000;" | \ + test-tool sha224 >actual && + grep 22c732697633e465ba836e11c7829ee185a72b53fbf35fde511bfbcd actual && + printf "blob 0\0" | test-tool sha224 >actual && + grep fcdd1b166dde803306a44852e0b7dcdf73bad0dec56f001feb39ea89 actual && + printf "blob 3\0abc" | test-tool sha224 >actual && + grep 22d78642a42d232e5b21911de160bed5b033badbecb8fc8b693e6ffe actual && + printf "tree 0\0" | test-tool sha224 >actual && + grep c82429250d411b4991a3de9b42f500908a4a242a8d3b3485e5e3bf71 actual +' + test_expect_success 'test basic SHA-512/224 hash values' ' test-tool sha512-224 actual && grep 6ed0dd02806fa89e25de060c19d3ac86cabb87d6a0ddd05c333b84f4 actual && From patchwork Sun Dec 22 06:48:08 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Michael Clark X-Patchwork-Id: 11307307 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 459B2138D for ; Sun, 22 Dec 2019 06:48:41 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 23984206CB for ; Sun, 22 Dec 2019 06:48:41 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=mac.com header.i=@mac.com header.b="C+GS7CUp" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726010AbfLVGsd (ORCPT ); Sun, 22 Dec 2019 01:48:33 -0500 Received: from mr85p00im-hyfv06011401.me.com ([17.58.23.191]:36629 "EHLO mr85p00im-hyfv06011401.me.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725852AbfLVGsd (ORCPT ); Sun, 22 Dec 2019 01:48:33 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=mac.com; s=1a1hai; t=1576997311; bh=YCZIOHzWWKAFzgYyaPks0miGiP8uqmAWhTCD4auSchE=; h=From:To:Subject:Date:Message-Id; b=C+GS7CUpmcGHHSmYK/ZeUY9ViJiDnFQ9QKrWcXIe+mFD3wm0XLVeXwqXpASz8Rf3v lqNXl8VKJX44baLAcIWhML3sprWJZGsZgYLkM4Q9+IPkTDKN3ctfbyVNOuP8TLbWe4 bwMgLB2ihfVm8JtNxBeoQbsPNWvjdhs16NJmG+IbVO85w3CjxWAe5yZDGTa/KbS/0z bluISWjksIUsfmK2Sg1PZVrlEJagBFBKsxS31yzyWu/4iFs5qU37+G45omh9Oa7ZmT z3K5iCoFXa8q/dl1TM9JzWJbb16v7DN3QOwCwCcuLyVwslwIYYz13inpJNtLZE8K7d URwni+V5HaXvw== Received: from localhost.localdomain (125-237-36-9-fibre.sparkbb.co.nz [125.237.36.9]) by mr85p00im-hyfv06011401.me.com (Postfix) with ESMTPSA id 39CD9D20A38; Sun, 22 Dec 2019 06:48:31 +0000 (UTC) From: Michael Clark To: git@vger.kernel.org Cc: Michael Clark Subject: [PATCH 5/6] Add OpenSSL EVP interface for SHA-3 and SHA-512 algorithms Date: Sun, 22 Dec 2019 19:48:08 +1300 Message-Id: <20191222064809.35667-6-michaeljclark@mac.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20191222064809.35667-1-michaeljclark@mac.com> References: <20191222064809.35667-1-michaeljclark@mac.com> MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:,, definitions=2019-12-22_01:,, signatures=0 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 suspectscore=3 malwarescore=0 phishscore=0 bulkscore=0 spamscore=0 clxscore=1015 mlxscore=0 mlxlogscore=539 adultscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.0.1-1908290000 definitions=main-1912220061 Sender: git-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org - Add OpenSSL EVP context wrapper and interface. - Add configuration machinery to select SHA-3 and SHA-512 impls from OpenSSL using the EVP interface. - Use `make OPENSSL_EVP=1` to build using the OpenSSL EVP impls for all SHA-3 and SHA-512 algos. --- Makefile | 9 +++- hash.h | 6 +++ sha/sha_evp/sha_evp.c | 99 +++++++++++++++++++++++++++++++++++++++++++ sha/sha_evp/sha_evp.h | 51 ++++++++++++++++++++++ 4 files changed, 164 insertions(+), 1 deletion(-) create mode 100644 sha/sha_evp/sha_evp.c create mode 100644 sha/sha_evp/sha_evp.h diff --git a/Makefile b/Makefile index 6bf9900291cb..e065630e24fa 100644 --- a/Makefile +++ b/Makefile @@ -189,6 +189,8 @@ all:: # # Define OPENSSL_SHA256 to use the SHA-256 routines in OpenSSL. # +# Define OPENSSL_EVP to use the SHA-3 and SHA-512 routines in OpenSSL. +# # Define NEEDS_CRYPTO_WITH_SSL if you need -lcrypto when using -lssl (Darwin). # # Define NEEDS_SSL_WITH_CRYPTO if you need -lssl when using -lcrypto (Darwin). @@ -1716,6 +1718,11 @@ else endif endif +ifdef OPENSSL_EVP + EXTLIBS += $(LIB_4_CRYPTO) + BASIC_CFLAGS += -DSHA_EVP_OPENSSL + LIB_OBJS += sha/sha_evp/sha_evp.o +else ifdef GCRYPT_SHA512 BASIC_CFLAGS += -DSHA512_GCRYPT EXTLIBS += -lgcrypt @@ -1723,7 +1730,6 @@ else LIB_OBJS += sha/sha512/sha512.o BASIC_CFLAGS += -DSHA512_BLK endif - ifdef GCRYPT_SHA3 BASIC_CFLAGS += -DSHA3_GCRYPT EXTLIBS += -lgcrypt @@ -1731,6 +1737,7 @@ else LIB_OBJS += sha/sha3/sha3.o BASIC_CFLAGS += -DSHA3_BLK endif +endif ifdef SHA1_MAX_BLOCK_SIZE LIB_OBJS += compat/sha1-chunked.o diff --git a/hash.h b/hash.h index 16924203d035..38e691fe8961 100644 --- a/hash.h +++ b/hash.h @@ -25,12 +25,18 @@ #if defined(SHA512_GCRYPT) #include "sha/sha512/gcrypt.h" +#elif defined(SHA_EVP_OPENSSL) +#include +#include "sha/sha_evp/sha_evp.h" #else #include "sha/sha512/sha512.h" #endif #if defined(SHA3_GCRYPT) #include "sha/sha3/gcrypt.h" +#elif defined(SHA_EVP_OPENSSL) +#include +#include "sha/sha_evp/sha_evp.h" #else #include "sha/sha3/sha3.h" #endif diff --git a/sha/sha_evp/sha_evp.c b/sha/sha_evp/sha_evp.c new file mode 100644 index 000000000000..6871f9744a71 --- /dev/null +++ b/sha/sha_evp/sha_evp.c @@ -0,0 +1,99 @@ +#include "git-compat-util.h" +#include "sha_evp.h" + +void evp_SHA2_224_Init(SHA_EVP_CTX *ctx) +{ + ctx->digest_ctx = NULL; + ctx->digest_md = EVP_sha224(); +} + +void evp_SHA2_256_Init(SHA_EVP_CTX *ctx) +{ + ctx->digest_ctx = NULL; + ctx->digest_md = EVP_sha256(); +} + +void evp_SHA2_512_Init(SHA_EVP_CTX *ctx) +{ + ctx->digest_ctx = NULL; + ctx->digest_md = EVP_sha512(); +} + +void evp_SHA2_512_224_Init(SHA_EVP_CTX *ctx) +{ + ctx->digest_ctx = NULL; + ctx->digest_md = EVP_sha512_224(); +} + +void evp_SHA2_512_256_Init(SHA_EVP_CTX *ctx) +{ + ctx->digest_ctx = NULL; + ctx->digest_md = EVP_sha512_256(); +} + +void evp_SHA3_224_Init(SHA_EVP_CTX *ctx) +{ + ctx->digest_ctx = NULL; + ctx->digest_md = EVP_sha3_224(); +} + +void evp_SHA3_256_Init(SHA_EVP_CTX *ctx) +{ + ctx->digest_ctx = NULL; + ctx->digest_md = EVP_sha3_256(); +} + +void evp_SHA3_384_Init(SHA_EVP_CTX *ctx) +{ + ctx->digest_ctx = NULL; + ctx->digest_md = EVP_sha3_384(); +} + +void evp_SHA3_512_Init(SHA_EVP_CTX *ctx) +{ + ctx->digest_ctx = NULL; + ctx->digest_md = EVP_sha3_512(); +} + +static void evp_SHA_Lazy_Init(SHA_EVP_CTX *ctx) +{ + /* + * The OpenSSL EVP digest API requires a dynamically sized context to be + * allocated and destroyed, however, the digest API we are emulating uses + * static structures and thus has no allocation or deallocation API. + * + * Due to this, we must call EVP_MD_CTX_destroy in Final to free up + * dynamically allocated memory. Context creation is thus done lazily in + * either Update or Final to handle cases where the context is reused + * after Final has been called. + */ + if (ctx->digest_ctx) return; + if ((ctx->digest_ctx = EVP_MD_CTX_create()) == NULL) + abort(); + if (EVP_DigestInit_ex(ctx->digest_ctx, ctx->digest_md, NULL) != 1) + abort(); +} + +void evp_SHA_Update(SHA_EVP_CTX *ctx, const void *data, size_t len) +{ + /* handle late Init as well as being called again after Final */ + evp_SHA_Lazy_Init(ctx); + + if (EVP_DigestUpdate(ctx->digest_ctx, data, len) != 1) + abort(); +} + +void evp_SHA_Final(unsigned char *result, SHA_EVP_CTX *ctx) +{ + unsigned int len; + + /* handle case where Final is called without Update (empty hash) */ + evp_SHA_Lazy_Init(ctx); + + if (EVP_DigestFinal_ex(ctx->digest_ctx, result, &len) != 1) + abort(); + assert(EVP_MD_size(ctx->digest_md) == len); + + EVP_MD_CTX_destroy(ctx->digest_ctx); + ctx->digest_ctx = NULL; +} diff --git a/sha/sha_evp/sha_evp.h b/sha/sha_evp/sha_evp.h new file mode 100644 index 000000000000..8757f77f4c13 --- /dev/null +++ b/sha/sha_evp/sha_evp.h @@ -0,0 +1,51 @@ +#ifndef SHAEVP_BLOCK_H +#define SHAEVP_BLOCK_H + +#include + +#define evp_SHA2_256_hash_size 32 +#define evp_SHA2_512_224_hash_size 28 +#define evp_SHA2_512_256_hash_size 32 +#define evp_SHA2_512_hash_size 64 +#define evp_SHA3_224_hash_size 28 +#define evp_SHA3_256_hash_size 32 +#define evp_SHA3_384_hash_size 48 +#define evp_SHA3_512_hash_size 64 + +struct SHA_EVP_CTX { + EVP_MD_CTX *digest_ctx; + const EVP_MD* digest_md; +}; + +typedef struct SHA_EVP_CTX SHA_EVP_CTX; + +void evp_SHA2_224_Init(SHA_EVP_CTX *ctx); +void evp_SHA2_256_Init(SHA_EVP_CTX *ctx); +void evp_SHA2_512_Init(SHA_EVP_CTX *ctx); +void evp_SHA2_512_224_Init(SHA_EVP_CTX *ctx); +void evp_SHA2_512_256_Init(SHA_EVP_CTX *ctx); +void evp_SHA3_224_Init(SHA_EVP_CTX *ctx); +void evp_SHA3_256_Init(SHA_EVP_CTX *ctx); +void evp_SHA3_384_Init(SHA_EVP_CTX *ctx); +void evp_SHA3_512_Init(SHA_EVP_CTX *ctx); + +void evp_SHA_Update(SHA_EVP_CTX *ctx, const void *data, size_t len); +void evp_SHA_Final(unsigned char *result, SHA_EVP_CTX *ctx); + +#define platform_SHA512_CTX SHA_EVP_CTX +#define platform_SHA512_Init evp_SHA2_512_Init +#define platform_SHA512_224_Init evp_SHA2_512_224_Init +#define platform_SHA512_256_Init evp_SHA2_512_256_Init +#define platform_SHA512_Update evp_SHA_Update +#define platform_SHA512_Final evp_SHA_Final + +#define platform_SHA3_CTX SHA_EVP_CTX +#define platform_SHA3_Init evp_SHA3_256_Init +#define platform_SHA3_224_Init evp_SHA3_224_Init +#define platform_SHA3_256_Init evp_SHA3_256_Init +#define platform_SHA3_384_Init evp_SHA3_384_Init +#define platform_SHA3_512_Init evp_SHA3_512_Init +#define platform_SHA3_Update evp_SHA_Update +#define platform_SHA3_Final evp_SHA_Final + +#endif \ No newline at end of file From patchwork Sun Dec 22 06:48:09 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Michael Clark X-Patchwork-Id: 11307309 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id 70EC8159A for ; Sun, 22 Dec 2019 06:48:41 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 4F3BC206CB for ; Sun, 22 Dec 2019 06:48:41 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=mac.com header.i=@mac.com header.b="AZhRvlFT" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726057AbfLVGse (ORCPT ); Sun, 22 Dec 2019 01:48:34 -0500 Received: from mr85p00im-hyfv06011401.me.com ([17.58.23.191]:36705 "EHLO mr85p00im-hyfv06011401.me.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726048AbfLVGsd (ORCPT ); Sun, 22 Dec 2019 01:48:33 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=mac.com; s=1a1hai; t=1576997313; bh=m3uuJCGAWgXpdu/O0+TwgNvGXWrZgpeRF6Bmzh+UGCs=; h=From:To:Subject:Date:Message-Id; b=AZhRvlFTKYVLWafXlHdi2L7vmYRmWnXv65c4AwNCUfdKWc5cJRbDJ5O9zLtK8AGsz 2Jkd9KzYJYM1oICVig266K/X3niW+9iVBTMb5oIca9R4S4qsXXCXkbJ+6qHIanqN2x dlicJQtndjTJtgYt1DwN5aPwouP0KFkEdG0Z29SIWClaqBAEdbrsxjr/fqwN9r+Lyc X66mQ7PTQYOZ39TmUe6eWHiFu6g14+jTiZXuKM2r+DtrVDnOXao1C4DmHQDs2E7VDR d8kG30LRofp2OiBQuwFW4MP/HLQZZO5vP8AkCcVxauOP2cfM+s+btn8iK4wBZ2cmw9 O9K7gP+5APS+w== Received: from localhost.localdomain (125-237-36-9-fibre.sparkbb.co.nz [125.237.36.9]) by mr85p00im-hyfv06011401.me.com (Postfix) with ESMTPSA id 8CEDED20971; Sun, 22 Dec 2019 06:48:32 +0000 (UTC) From: Michael Clark To: git@vger.kernel.org Cc: Michael Clark Subject: [PATCH 6/6] Add sha/README.md with table of SHA algorithm details Date: Sun, 22 Dec 2019 19:48:09 +1300 Message-Id: <20191222064809.35667-7-michaeljclark@mac.com> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20191222064809.35667-1-michaeljclark@mac.com> References: <20191222064809.35667-1-michaeljclark@mac.com> MIME-Version: 1.0 X-Proofpoint-Virus-Version: vendor=fsecure engine=2.50.10434:,, definitions=2019-12-22_01:,, signatures=0 X-Proofpoint-Spam-Details: rule=notspam policy=default score=0 suspectscore=0 malwarescore=0 phishscore=0 bulkscore=0 spamscore=0 clxscore=1015 mlxscore=0 mlxlogscore=999 adultscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.0.1-1908290000 definitions=main-1912220061 Sender: git-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: git@vger.kernel.org - Add table showing algorith name, mnemonic, type-code, wdith, and library implementation (builtin, gcrypt, OpenSSL, EVP). --- sha/README.md | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) create mode 100644 sha/README.md diff --git a/sha/README.md b/sha/README.md new file mode 100644 index 000000000000..0e24049e4cc7 --- /dev/null +++ b/sha/README.md @@ -0,0 +1,23 @@ +# SHA algorithms + +### Algorithms + +Table showing details of the SHA algorithms: + +| algorithm | mnemonic | type-code | width | extension | builtin | gcrypt | OpenSSL| EVP | +|:---------------|:---------|:-------------|------:|----------:|:-------------|:-------|:-------|:-------| +| `sha1` | `sha1` | `0x73686131` | 160 | yes | `sha/sha1` | yes | yes | - | +| `sha256` | `s256` | `0x73323536` | 256 | yes | `sha/sha256` | yes | yes | - | +| `sha224` | `s224` | `0x73323234` | 224 | no | `sha/sha256` | yes | yes | - | +| `sha512` | `s512` | `0x73353132` | 512 | yes | `sha/sha512` | yes | yes | yes | +| `sha512/224` | `s226` | `0x73323236` | 224 | no | `sha/sha512` | yes | yes | yes | +| `sha512/256` | `s228` | `0x73323238` | 256 | no | `sha/sha512` | yes | yes | yes | +| `sha3-224` | `s388` | `0x73333838` | 224 | no | `sha/sha3` | yes | - | yes | +| `sha3-256` | `s398` | `0x73333938` | 256 | no | `sha/sha3` | yes | - | yes | +| `sha3-384` | `s3a8` | `0x73336138` | 384 | no | `sha/sha3` | yes | - | yes | +| `sha3-512` | `s3b8` | `0x73336238` | 512 | no | `sha/sha3` | yes | - | yes | + +#### Notes + +- The _'extension'_ column refers to whether the algorithm is vulnerable to the + [length extension attack](https://en.wikipedia.org/wiki/Length_extension_attack). \ No newline at end of file