Introduce SHA1 implementations in the cryptohash infrastructure

With this commit, SHA1 goes through the implementation provided by
OpenSSL via EVP when building the backend with it, and uses as fallback
implementation KAME which was located in pgcrypto and already shaped for
an integration with a set of init, update and final routines.
Structures and routines have been renamed to make things consistent with
the fallback implementations of MD5 and SHA2.

uuid-ossp has used for ages a shortcut with pgcrypto to fetch a copy of
SHA1 if needed.  This was built depending on the build options within
./configure, so this cleans up some code and removes the build
dependency between pgcrypto and uuid-ossp.

Note that this will help with the refactoring of HMAC, as pgcrypto
offers the option to use MD5, SHA1 or SHA2, so only the second option
was missing to make that possible.

Author: Michael Paquier
Reviewed-by: Heikki Linnakangas
Discussion: https://postgr.es/m/X9HXKTgrvJvYO7Oh@paquier.xyz

10 files changed, 491 insertions, 5 deletions

diff --git a/src/Makefile.global.in b/src/Makefile.global.in
index 7ca1e9aac59..9a1688c97cb 100644
--- a/src/Makefile.global.in
+++ b/src/Makefile.global.in
@@ -289,7 +289,6 @@ LIBS = @LIBS@
 LDAP_LIBS_FE = @LDAP_LIBS_FE@
 LDAP_LIBS_BE = @LDAP_LIBS_BE@
 UUID_LIBS = @UUID_LIBS@
-UUID_EXTRA_OBJS = @UUID_EXTRA_OBJS@
 LLVM_LIBS=@LLVM_LIBS@
 LD = @LD@
 with_gnu_ld = @with_gnu_ld@
diff --git a/src/common/Makefile b/src/common/Makefile
index 93eb27a2aa4..1a1d0d3406c 100644
--- a/src/common/Makefile
+++ b/src/common/Makefile
@@ -88,6 +88,7 @@ else
 OBJS_COMMON += \
 	cryptohash.o \
 	md5.o \
+	sha1.o \
 	sha2.o
 endif
 
diff --git a/src/common/cryptohash.c b/src/common/cryptohash.c
index efedadd6263..5b2c050d799 100644
--- a/src/common/cryptohash.c
+++ b/src/common/cryptohash.c
@@ -25,6 +25,7 @@
 
 #include "common/cryptohash.h"
 #include "md5_int.h"
+#include "sha1_int.h"
 #include "sha2_int.h"
 
 /*
@@ -47,6 +48,7 @@ struct pg_cryptohash_ctx
 	union
 	{
 		pg_md5_ctx	md5;
+		pg_sha1_ctx sha1;
 		pg_sha224_ctx sha224;
 		pg_sha256_ctx sha256;
 		pg_sha384_ctx sha384;
@@ -97,6 +99,9 @@ pg_cryptohash_init(pg_cryptohash_ctx *ctx)
 		case PG_MD5:
 			pg_md5_init(&ctx->data.md5);
 			break;
+		case PG_SHA1:
+			pg_sha1_init(&ctx->data.sha1);
+			break;
 		case PG_SHA224:
 			pg_sha224_init(&ctx->data.sha224);
 			break;
@@ -132,6 +137,9 @@ pg_cryptohash_update(pg_cryptohash_ctx *ctx, const uint8 *data, size_t len)
 		case PG_MD5:
 			pg_md5_update(&ctx->data.md5, data, len);
 			break;
+		case PG_SHA1:
+			pg_sha1_update(&ctx->data.sha1, data, len);
+			break;
 		case PG_SHA224:
 			pg_sha224_update(&ctx->data.sha224, data, len);
 			break;
@@ -167,6 +175,9 @@ pg_cryptohash_final(pg_cryptohash_ctx *ctx, uint8 *dest)
 		case PG_MD5:
 			pg_md5_final(&ctx->data.md5, dest);
 			break;
+		case PG_SHA1:
+			pg_sha1_final(&ctx->data.sha1, dest);
+			break;
 		case PG_SHA224:
 			pg_sha224_final(&ctx->data.sha224, dest);
 			break;
diff --git a/src/common/cryptohash_openssl.c b/src/common/cryptohash_openssl.c
index 551ec392b60..006e867403e 100644
--- a/src/common/cryptohash_openssl.c
+++ b/src/common/cryptohash_openssl.c
@@ -131,6 +131,9 @@ pg_cryptohash_init(pg_cryptohash_ctx *ctx)
 		case PG_MD5:
 			status = EVP_DigestInit_ex(ctx->evpctx, EVP_md5(), NULL);
 			break;
+		case PG_SHA1:
+			status = EVP_DigestInit_ex(ctx->evpctx, EVP_sha1(), NULL);
+			break;
 		case PG_SHA224:
 			status = EVP_DigestInit_ex(ctx->evpctx, EVP_sha224(), NULL);
 			break;
diff --git a/src/common/sha1.c b/src/common/sha1.c
new file mode 100644
index 00000000000..f8ed4d68086
--- /dev/null
+++ b/src/common/sha1.c
@@ -0,0 +1,369 @@
+/*-------------------------------------------------------------------------
+ *
+ *	sha1.c
+ *	  Implements the SHA1 Secure Hash Algorithm
+ *
+ * Fallback implementation of SHA1, as specified in RFC 3174.
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/common/sha1.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+/*	   $KAME: sha1.c,v 1.3 2000/02/22 14:01:18 itojun Exp $    */
+
+/*
+ * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *	  notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *	  notice, this list of conditions and the following disclaimer in the
+ *	  documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the project nor the names of its contributors
+ *	  may be used to endorse or promote products derived from this software
+ *	  without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+/*
+ * FIPS pub 180-1: Secure Hash Algorithm (SHA-1)
+ * based on: http://www.itl.nist.gov/fipspubs/fip180-1.htm
+ * implemented by Jun-ichiro itojun Itoh <itojun@itojun.org>
+ */
+
+#ifndef FRONTEND
+#include "postgres.h"
+#else
+#include "postgres_fe.h"
+#endif
+
+#include <sys/param.h>
+
+#include "sha1_int.h"
+
+/* constant table */
+static uint32 _K[] = {0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6};
+
+#define K(t)	_K[(t) / 20]
+
+#define F0(b, c, d) (((b) & (c)) | ((~(b)) & (d)))
+#define F1(b, c, d) (((b) ^ (c)) ^ (d))
+#define F2(b, c, d) (((b) & (c)) | ((b) & (d)) | ((c) & (d)))
+#define F3(b, c, d) (((b) ^ (c)) ^ (d))
+
+#define S(n, x)		(((x) << (n)) | ((x) >> (32 - (n))))
+
+#define H(n)	(ctx->h.b32[(n)])
+#define COUNT	(ctx->count)
+#define BCOUNT	(ctx->c.b64[0] / 8)
+#define W(n)	(ctx->m.b32[(n)])
+
+#define PUTPAD(x) \
+do { \
+	ctx->m.b8[(COUNT % 64)] = (x);		\
+	COUNT++;				\
+	COUNT %= 64;				\
+	if (COUNT % 64 == 0)			\
+		sha1_step(ctx);		\
+} while (0)
+
+static void
+sha1_step(pg_sha1_ctx *ctx)
+{
+	uint32		a,
+				b,
+				c,
+				d,
+				e;
+	size_t		t,
+				s;
+	uint32		tmp;
+
+#ifndef WORDS_BIGENDIAN
+	pg_sha1_ctx tctx;
+
+	memmove(&tctx.m.b8[0], &ctx->m.b8[0], 64);
+	ctx->m.b8[0] = tctx.m.b8[3];
+	ctx->m.b8[1] = tctx.m.b8[2];
+	ctx->m.b8[2] = tctx.m.b8[1];
+	ctx->m.b8[3] = tctx.m.b8[0];
+	ctx->m.b8[4] = tctx.m.b8[7];
+	ctx->m.b8[5] = tctx.m.b8[6];
+	ctx->m.b8[6] = tctx.m.b8[5];
+	ctx->m.b8[7] = tctx.m.b8[4];
+	ctx->m.b8[8] = tctx.m.b8[11];
+	ctx->m.b8[9] = tctx.m.b8[10];
+	ctx->m.b8[10] = tctx.m.b8[9];
+	ctx->m.b8[11] = tctx.m.b8[8];
+	ctx->m.b8[12] = tctx.m.b8[15];
+	ctx->m.b8[13] = tctx.m.b8[14];
+	ctx->m.b8[14] = tctx.m.b8[13];
+	ctx->m.b8[15] = tctx.m.b8[12];
+	ctx->m.b8[16] = tctx.m.b8[19];
+	ctx->m.b8[17] = tctx.m.b8[18];
+	ctx->m.b8[18] = tctx.m.b8[17];
+	ctx->m.b8[19] = tctx.m.b8[16];
+	ctx->m.b8[20] = tctx.m.b8[23];
+	ctx->m.b8[21] = tctx.m.b8[22];
+	ctx->m.b8[22] = tctx.m.b8[21];
+	ctx->m.b8[23] = tctx.m.b8[20];
+	ctx->m.b8[24] = tctx.m.b8[27];
+	ctx->m.b8[25] = tctx.m.b8[26];
+	ctx->m.b8[26] = tctx.m.b8[25];
+	ctx->m.b8[27] = tctx.m.b8[24];
+	ctx->m.b8[28] = tctx.m.b8[31];
+	ctx->m.b8[29] = tctx.m.b8[30];
+	ctx->m.b8[30] = tctx.m.b8[29];
+	ctx->m.b8[31] = tctx.m.b8[28];
+	ctx->m.b8[32] = tctx.m.b8[35];
+	ctx->m.b8[33] = tctx.m.b8[34];
+	ctx->m.b8[34] = tctx.m.b8[33];
+	ctx->m.b8[35] = tctx.m.b8[32];
+	ctx->m.b8[36] = tctx.m.b8[39];
+	ctx->m.b8[37] = tctx.m.b8[38];
+	ctx->m.b8[38] = tctx.m.b8[37];
+	ctx->m.b8[39] = tctx.m.b8[36];
+	ctx->m.b8[40] = tctx.m.b8[43];
+	ctx->m.b8[41] = tctx.m.b8[42];
+	ctx->m.b8[42] = tctx.m.b8[41];
+	ctx->m.b8[43] = tctx.m.b8[40];
+	ctx->m.b8[44] = tctx.m.b8[47];
+	ctx->m.b8[45] = tctx.m.b8[46];
+	ctx->m.b8[46] = tctx.m.b8[45];
+	ctx->m.b8[47] = tctx.m.b8[44];
+	ctx->m.b8[48] = tctx.m.b8[51];
+	ctx->m.b8[49] = tctx.m.b8[50];
+	ctx->m.b8[50] = tctx.m.b8[49];
+	ctx->m.b8[51] = tctx.m.b8[48];
+	ctx->m.b8[52] = tctx.m.b8[55];
+	ctx->m.b8[53] = tctx.m.b8[54];
+	ctx->m.b8[54] = tctx.m.b8[53];
+	ctx->m.b8[55] = tctx.m.b8[52];
+	ctx->m.b8[56] = tctx.m.b8[59];
+	ctx->m.b8[57] = tctx.m.b8[58];
+	ctx->m.b8[58] = tctx.m.b8[57];
+	ctx->m.b8[59] = tctx.m.b8[56];
+	ctx->m.b8[60] = tctx.m.b8[63];
+	ctx->m.b8[61] = tctx.m.b8[62];
+	ctx->m.b8[62] = tctx.m.b8[61];
+	ctx->m.b8[63] = tctx.m.b8[60];
+#endif
+
+	a = H(0);
+	b = H(1);
+	c = H(2);
+	d = H(3);
+	e = H(4);
+
+	for (t = 0; t < 20; t++)
+	{
+		s = t & 0x0f;
+		if (t >= 16)
+			W(s) = S(1, W((s + 13) & 0x0f) ^ W((s + 8) & 0x0f) ^ W((s + 2) & 0x0f) ^ W(s));
+		tmp = S(5, a) + F0(b, c, d) + e + W(s) + K(t);
+		e = d;
+		d = c;
+		c = S(30, b);
+		b = a;
+		a = tmp;
+	}
+	for (t = 20; t < 40; t++)
+	{
+		s = t & 0x0f;
+		W(s) = S(1, W((s + 13) & 0x0f) ^ W((s + 8) & 0x0f) ^ W((s + 2) & 0x0f) ^ W(s));
+		tmp = S(5, a) + F1(b, c, d) + e + W(s) + K(t);
+		e = d;
+		d = c;
+		c = S(30, b);
+		b = a;
+		a = tmp;
+	}
+	for (t = 40; t < 60; t++)
+	{
+		s = t & 0x0f;
+		W(s) = S(1, W((s + 13) & 0x0f) ^ W((s + 8) & 0x0f) ^ W((s + 2) & 0x0f) ^ W(s));
+		tmp = S(5, a) + F2(b, c, d) + e + W(s) + K(t);
+		e = d;
+		d = c;
+		c = S(30, b);
+		b = a;
+		a = tmp;
+	}
+	for (t = 60; t < 80; t++)
+	{
+		s = t & 0x0f;
+		W(s) = S(1, W((s + 13) & 0x0f) ^ W((s + 8) & 0x0f) ^ W((s + 2) & 0x0f) ^ W(s));
+		tmp = S(5, a) + F3(b, c, d) + e + W(s) + K(t);
+		e = d;
+		d = c;
+		c = S(30, b);
+		b = a;
+		a = tmp;
+	}
+
+	H(0) = H(0) + a;
+	H(1) = H(1) + b;
+	H(2) = H(2) + c;
+	H(3) = H(3) + d;
+	H(4) = H(4) + e;
+
+	memset(&ctx->m.b8[0], 0, 64);
+}
+
+static void
+sha1_pad(pg_sha1_ctx *ctx)
+{
+	size_t		padlen;			/* pad length in bytes */
+	size_t		padstart;
+
+	PUTPAD(0x80);
+
+	padstart = COUNT % 64;
+	padlen = 64 - padstart;
+	if (padlen < 8)
+	{
+		memset(&ctx->m.b8[padstart], 0, padlen);
+		COUNT += padlen;
+		COUNT %= 64;
+		sha1_step(ctx);
+		padstart = COUNT % 64;	/* should be 0 */
+		padlen = 64 - padstart; /* should be 64 */
+	}
+	memset(&ctx->m.b8[padstart], 0, padlen - 8);
+	COUNT += (padlen - 8);
+	COUNT %= 64;
+#ifdef WORDS_BIGENDIAN
+	PUTPAD(ctx->c.b8[0]);
+	PUTPAD(ctx->c.b8[1]);
+	PUTPAD(ctx->c.b8[2]);
+	PUTPAD(ctx->c.b8[3]);
+	PUTPAD(ctx->c.b8[4]);
+	PUTPAD(ctx->c.b8[5]);
+	PUTPAD(ctx->c.b8[6]);
+	PUTPAD(ctx->c.b8[7]);
+#else
+	PUTPAD(ctx->c.b8[7]);
+	PUTPAD(ctx->c.b8[6]);
+	PUTPAD(ctx->c.b8[5]);
+	PUTPAD(ctx->c.b8[4]);
+	PUTPAD(ctx->c.b8[3]);
+	PUTPAD(ctx->c.b8[2]);
+	PUTPAD(ctx->c.b8[1]);
+	PUTPAD(ctx->c.b8[0]);
+#endif
+}
+
+static void
+sha1_result(uint8 *digest0, pg_sha1_ctx *ctx)
+{
+	uint8	   *digest;
+
+	digest = (uint8 *) digest0;
+
+#ifdef WORDS_BIGENDIAN
+	memmove(digest, &ctx->h.b8[0], 20);
+#else
+	digest[0] = ctx->h.b8[3];
+	digest[1] = ctx->h.b8[2];
+	digest[2] = ctx->h.b8[1];
+	digest[3] = ctx->h.b8[0];
+	digest[4] = ctx->h.b8[7];
+	digest[5] = ctx->h.b8[6];
+	digest[6] = ctx->h.b8[5];
+	digest[7] = ctx->h.b8[4];
+	digest[8] = ctx->h.b8[11];
+	digest[9] = ctx->h.b8[10];
+	digest[10] = ctx->h.b8[9];
+	digest[11] = ctx->h.b8[8];
+	digest[12] = ctx->h.b8[15];
+	digest[13] = ctx->h.b8[14];
+	digest[14] = ctx->h.b8[13];
+	digest[15] = ctx->h.b8[12];
+	digest[16] = ctx->h.b8[19];
+	digest[17] = ctx->h.b8[18];
+	digest[18] = ctx->h.b8[17];
+	digest[19] = ctx->h.b8[16];
+#endif
+}
+
+/* External routines for this SHA1 implementation */
+
+/*
+ * pg_sha1_init
+ *
+ * Initialize a SHA1 context.
+ */
+void
+pg_sha1_init(pg_sha1_ctx *ctx)
+{
+	memset(ctx, 0, sizeof(pg_sha1_ctx));
+	H(0) = 0x67452301;
+	H(1) = 0xefcdab89;
+	H(2) = 0x98badcfe;
+	H(3) = 0x10325476;
+	H(4) = 0xc3d2e1f0;
+}
+
+/*
+ * pg_sha1_update
+ *
+ * Update a SHA1 context.
+ */
+void
+pg_sha1_update(pg_sha1_ctx *ctx, const uint8 *data, size_t len)
+{
+	const uint8 *input;
+	size_t		gaplen;
+	size_t		gapstart;
+	size_t		off;
+	size_t		copysiz;
+
+	input = (const uint8 *) data;
+	off = 0;
+
+	while (off < len)
+	{
+		gapstart = COUNT % 64;
+		gaplen = 64 - gapstart;
+
+		copysiz = (gaplen < len - off) ? gaplen : len - off;
+		memmove(&ctx->m.b8[gapstart], &input[off], copysiz);
+		COUNT += copysiz;
+		COUNT %= 64;
+		ctx->c.b64[0] += copysiz * 8;
+		if (COUNT % 64 == 0)
+			sha1_step(ctx);
+		off += copysiz;
+	}
+}
+
+/*
+ * pg_sha1_final
+ *
+ * Finalize a SHA1 context.
+ */
+void
+pg_sha1_final(pg_sha1_ctx *ctx, uint8 *dest)
+{
+	sha1_pad(ctx);
+	sha1_result(dest, ctx);
+}
diff --git a/src/common/sha1_int.h b/src/common/sha1_int.h
new file mode 100644
index 00000000000..7f458a61274
--- /dev/null
+++ b/src/common/sha1_int.h
@@ -0,0 +1,81 @@
+/*-------------------------------------------------------------------------
+ *
+ * sha1_int.h
+ *	  Internal headers for fallback implementation of SHA1
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *		  src/common/sha1_int.h
+ *
+ *-------------------------------------------------------------------------
+ */
+
+/*	   $KAME: sha1.h,v 1.4 2000/02/22 14:01:18 itojun Exp $    */
+
+/*
+ * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *	  notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *	  notice, this list of conditions and the following disclaimer in the
+ *	  documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the project nor the names of its contributors
+ *	  may be used to endorse or promote products derived from this software
+ *	  without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+/*
+ * FIPS pub 180-1: Secure Hash Algorithm (SHA-1)
+ * based on: http://www.itl.nist.gov/fipspubs/fip180-1.htm
+ * implemented by Jun-ichiro itojun Itoh <itojun@itojun.org>
+ */
+
+#ifndef PG_SHA1_INT_H
+#define PG_SHA1_INT_H
+
+#include "common/sha1.h"
+
+typedef struct
+{
+	union
+	{
+		uint8		b8[20];
+		uint32		b32[5];
+	}			h;
+	union
+	{
+		uint8		b8[8];
+		uint64		b64[1];
+	}			c;
+	union
+	{
+		uint8		b8[64];
+		uint32		b32[16];
+	}			m;
+	uint8		count;
+} pg_sha1_ctx;
+
+/* Interface routines for SHA1 */
+extern void pg_sha1_init(pg_sha1_ctx *ctx);
+extern void pg_sha1_update(pg_sha1_ctx *ctx, const uint8 *data, size_t len);
+extern void pg_sha1_final(pg_sha1_ctx *ctx, uint8 *dest);
+
+#endif							/* PG_SHA1_INT_H */
diff --git a/src/include/common/cryptohash.h b/src/include/common/cryptohash.h
index 3ecaf621135..32d7784ca5b 100644
--- a/src/include/common/cryptohash.h
+++ b/src/include/common/cryptohash.h
@@ -19,6 +19,7 @@
 typedef enum
 {
 	PG_MD5 = 0,
+	PG_SHA1,
 	PG_SHA224,
 	PG_SHA256,
 	PG_SHA384,
diff --git a/src/include/common/sha1.h b/src/include/common/sha1.h
new file mode 100644
index 00000000000..a61bc47deda
--- /dev/null
+++ b/src/include/common/sha1.h
@@ -0,0 +1,19 @@
+/*-------------------------------------------------------------------------
+ *
+ * sha1.h
+ *	  Constants related to SHA1.
+ *
+ * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * src/include/common/sha1.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef PG_SHA1_H
+#define PG_SHA1_H
+
+/* Size of result generated by SHA1 computation */
+#define SHA1_DIGEST_LENGTH 20
+
+#endif							/* PG_SHA1_H */
diff --git a/src/tools/msvc/Mkvcbuild.pm b/src/tools/msvc/Mkvcbuild.pm
index 5634b2d40c0..7213e65e08b 100644
--- a/src/tools/msvc/Mkvcbuild.pm
+++ b/src/tools/msvc/Mkvcbuild.pm
@@ -136,6 +136,7 @@ sub mkvcbuild
 	{
 		push(@pgcommonallfiles, 'cryptohash.c');
 		push(@pgcommonallfiles, 'md5.c');
+		push(@pgcommonallfiles, 'sha1.c');
 		push(@pgcommonallfiles, 'sha2.c');
 	}
 
@@ -465,10 +466,10 @@ sub mkvcbuild
 	else
 	{
 		$pgcrypto->AddFiles(
-			'contrib/pgcrypto',   'sha1.c',
-			'internal.c',         'internal-sha2.c',
-			'blf.c',              'rijndael.c',
-			'pgp-mpi-internal.c', 'imath.c');
+			'contrib/pgcrypto', 'internal.c',
+			'internal-sha2.c',  'blf.c',
+			'rijndael.c',       'pgp-mpi-internal.c',
+			'imath.c');
 	}
 	$pgcrypto->AddReference($postgres);
 	$pgcrypto->AddLibrary('ws2_32.lib');
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
index 943142ced8c..721b230bf29 100644
--- a/src/tools/pgindent/typedefs.list
+++ b/src/tools/pgindent/typedefs.list
@@ -3214,6 +3214,7 @@ pg_md5_ctx
 pg_on_exit_callback
 pg_re_flags
 pg_saslprep_rc
+pg_sha1_ctx
 pg_sha224_ctx
 pg_sha256_ctx
 pg_sha384_ctx