Implement MD5_{Update,Transform,Final}() directly in md5.c.

Copy the update, transform and final functions from md32_common.h, manually expanding the macros for MD5. This will allow for further clean up to occur. No change in generated assembly.
author: jsing <> 2023-08-10 13:54:21 +0000
committer: jsing <> 2023-08-10 13:54:21 +0000
commit: 45bab25145ddfb098cb68f6a2e32aa04a34f6590 (patch)
tree: 6b7f34768799de703c69e5b69895bac81a0a2b6d
parent: acca1f680e2133c5b3d31a35abe934eeff3197d8 (diff)
download: openbsd-45bab25145ddfb098cb68f6a2e32aa04a34f6590.tar.gz
openbsd-45bab25145ddfb098cb68f6a2e32aa04a34f6590.tar.bz2
openbsd-45bab25145ddfb098cb68f6a2e32aa04a34f6590.zip
1 files changed, 103 insertions, 1 deletions
diff --git a/src/lib/libcrypto/md5/md5.c b/src/lib/libcrypto/md5/md5.c
index 7f6535506c..5169627c02 100644
--- a/src/lib/libcrypto/md5/md5.c
+++ b/src/lib/libcrypto/md5/md5.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: md5.c,v 1.8 2023/08/10 13:41:18 jsing Exp $ */
+/* $OpenBSD: md5.c,v 1.9 2023/08/10 13:54:21 jsing Exp $ */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
 * All rights reserved.
 *
@@ -96,7 +96,109 @@ __END_HIDDEN_DECLS
        } while (0)
 #define HASH_BLOCK_DATA_ORDER   md5_block_data_order
+#define HASH_NO_UPDATE
+#define HASH_NO_TRANSFORM
+#define HASH_NO_FINAL
 #include "md32_common.h"
+int
+MD5_Update(MD5_CTX *c, const void *data_, size_t len)
+{
+        const unsigned char *data = data_;
+        unsigned char *p;
+        MD5_LONG l;
+        size_t n;
+        if (len == 0)
+                return 1;
+        l = (c->Nl + (((MD5_LONG)len) << 3))&0xffffffffUL;
+        /* 95-05-24 eay Fixed a bug with the overflow handling, thanks to
+         * Wei Dai <weidai@eskimo.com> for pointing it out. */
+        if (l < c->Nl) /* overflow */
+                c->Nh++;
+        c->Nh+=(MD5_LONG)(len>>29);     /* might cause compiler warning on 16-bit */
+        c->Nl = l;
+        n = c->num;
+        if (n != 0) {
+                p = (unsigned char *)c->data;
+                if (len >= MD5_CBLOCK || len + n >= MD5_CBLOCK) {
+                        memcpy(p + n, data, MD5_CBLOCK - n);
+                        md5_block_data_order(c, p, 1);
+                        n = MD5_CBLOCK - n;
+                        data += n;
+                        len -= n;
+                        c->num = 0;
+                        memset(p, 0, MD5_CBLOCK);       /* keep it zeroed */
+                } else {
+                        memcpy(p + n, data, len);
+                        c->num += (unsigned int)len;
+                        return 1;
+                }
+        }
+        n = len/MD5_CBLOCK;
+        if (n > 0) {
+                md5_block_data_order (c, data, n);
+                n    *= MD5_CBLOCK;
+                data += n;
+                len -= n;
+        }
+        if (len != 0) {
+                p = (unsigned char *)c->data;
+                c->num = (unsigned int)len;
+                memcpy (p, data, len);
+        }
+        return 1;
+}
+void
+MD5_Transform(MD5_CTX *c, const unsigned char *data)
+{
+        md5_block_data_order(c, data, 1);
+}
+int
+MD5_Final(unsigned char *md, MD5_CTX *c)
+{
+        unsigned char *p = (unsigned char *)c->data;
+        size_t n = c->num;
+        p[n] = 0x80; /* there is always room for one */
+        n++;
+        if (n > (MD5_CBLOCK - 8)) {
+                memset(p + n, 0, MD5_CBLOCK - n);
+                n = 0;
+                md5_block_data_order(c, p, 1);
+        }
+        memset(p + n, 0, MD5_CBLOCK - 8 - n);
+        p += MD5_CBLOCK - 8;
+#if   defined(DATA_ORDER_IS_BIG_ENDIAN)
+        HOST_l2c(c->Nh, p);
+        HOST_l2c(c->Nl, p);
+#elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)
+        HOST_l2c(c->Nl, p);
+        HOST_l2c(c->Nh, p);
+#endif
+        p -= MD5_CBLOCK;
+        md5_block_data_order(c, p, 1);
+        c->num = 0;
+        memset(p, 0, MD5_CBLOCK);
+#ifndef HASH_MAKE_STRING
+#error "HASH_MAKE_STRING must be defined!"
+#else
+        HASH_MAKE_STRING(c, md);
+#endif
+        return 1;
+}
 LCRYPTO_ALIAS(MD5_Update);
 LCRYPTO_ALIAS(MD5_Transform);
 LCRYPTO_ALIAS(MD5_Final);
author	jsing <>	2023-08-10 13:54:21 +0000
committer	jsing <>	2023-08-10 13:54:21 +0000
commit	45bab25145ddfb098cb68f6a2e32aa04a34f6590 (patch)
tree	6b7f34768799de703c69e5b69895bac81a0a2b6d
parent	acca1f680e2133c5b3d31a35abe934eeff3197d8 (diff)
download	openbsd-45bab25145ddfb098cb68f6a2e32aa04a34f6590.tar.gz openbsd-45bab25145ddfb098cb68f6a2e32aa04a34f6590.tar.bz2 openbsd-45bab25145ddfb098cb68f6a2e32aa04a34f6590.zip

diff --git a/src/lib/libcrypto/md5/md5.c b/src/lib/libcrypto/md5/md5.c index 7f6535506c..5169627c02 100644 --- a/src/lib/libcrypto/md5/md5.c +++ b/src/lib/libcrypto/md5/md5.c
@@ -1,4 +1,4 @@
1	/* $OpenBSD: md5.c,v 1.8 2023/08/10 13:41:18 jsing Exp $ */	1	/* $OpenBSD: md5.c,v 1.9 2023/08/10 13:54:21 jsing Exp $ */
2	/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)	2	/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
@@ -96,7 +96,109 @@ __END_HIDDEN_DECLS
96	} while (0)	96	} while (0)
97	#define HASH_BLOCK_DATA_ORDER md5_block_data_order	97	#define HASH_BLOCK_DATA_ORDER md5_block_data_order
98		98
		99	#define HASH_NO_UPDATE
		100	#define HASH_NO_TRANSFORM
		101	#define HASH_NO_FINAL
		102
99	#include "md32_common.h"	103	#include "md32_common.h"
		104
		105	int
		106	MD5_Update(MD5_CTX c, const void data_, size_t len)
		107	{
		108	const unsigned char *data = data_;
		109	unsigned char *p;
		110	MD5_LONG l;
		111	size_t n;
		112
		113	if (len == 0)
		114	return 1;
		115
		116	l = (c->Nl + (((MD5_LONG)len) << 3))&0xffffffffUL;
		117	/* 95-05-24 eay Fixed a bug with the overflow handling, thanks to
		118	* Wei Dai <weidai@eskimo.com> for pointing it out. */
		119	if (l < c->Nl) /* overflow */
		120	c->Nh++;
		121	c->Nh+=(MD5_LONG)(len>>29); /* might cause compiler warning on 16-bit */
		122	c->Nl = l;
		123
		124	n = c->num;
		125	if (n != 0) {
		126	p = (unsigned char *)c->data;
		127
		128	if (len >= MD5_CBLOCK \|\| len + n >= MD5_CBLOCK) {
		129	memcpy(p + n, data, MD5_CBLOCK - n);
		130	md5_block_data_order(c, p, 1);
		131	n = MD5_CBLOCK - n;
		132	data += n;
		133	len -= n;
		134	c->num = 0;
		135	memset(p, 0, MD5_CBLOCK); /* keep it zeroed */
		136	} else {
		137	memcpy(p + n, data, len);
		138	c->num += (unsigned int)len;
		139	return 1;
		140	}
		141	}
		142
		143	n = len/MD5_CBLOCK;
		144	if (n > 0) {
		145	md5_block_data_order (c, data, n);
		146	n *= MD5_CBLOCK;
		147	data += n;
		148	len -= n;
		149	}
		150
		151	if (len != 0) {
		152	p = (unsigned char *)c->data;
		153	c->num = (unsigned int)len;
		154	memcpy (p, data, len);
		155	}
		156	return 1;
		157	}
		158
		159	void
		160	MD5_Transform(MD5_CTX c, const unsigned char data)
		161	{
		162	md5_block_data_order(c, data, 1);
		163	}
		164
		165	int
		166	MD5_Final(unsigned char md, MD5_CTX c)
		167	{
		168	unsigned char p = (unsigned char )c->data;
		169	size_t n = c->num;
		170
		171	p[n] = 0x80; /* there is always room for one */
		172	n++;
		173
		174	if (n > (MD5_CBLOCK - 8)) {
		175	memset(p + n, 0, MD5_CBLOCK - n);
		176	n = 0;
		177	md5_block_data_order(c, p, 1);
		178	}
		179	memset(p + n, 0, MD5_CBLOCK - 8 - n);
		180
		181	p += MD5_CBLOCK - 8;
		182	#if defined(DATA_ORDER_IS_BIG_ENDIAN)
		183	HOST_l2c(c->Nh, p);
		184	HOST_l2c(c->Nl, p);
		185	#elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)
		186	HOST_l2c(c->Nl, p);
		187	HOST_l2c(c->Nh, p);
		188	#endif
		189	p -= MD5_CBLOCK;
		190	md5_block_data_order(c, p, 1);
		191	c->num = 0;
		192	memset(p, 0, MD5_CBLOCK);
		193
		194	#ifndef HASH_MAKE_STRING
		195	#error "HASH_MAKE_STRING must be defined!"
		196	#else
		197	HASH_MAKE_STRING(c, md);
		198	#endif
		199
		200	return 1;
		201	}
100	LCRYPTO_ALIAS(MD5_Update);	202	LCRYPTO_ALIAS(MD5_Update);
101	LCRYPTO_ALIAS(MD5_Transform);	203	LCRYPTO_ALIAS(MD5_Transform);
102	LCRYPTO_ALIAS(MD5_Final);	204	LCRYPTO_ALIAS(MD5_Final);