summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/lib/libcrypto/md4/md4.c205
1 files changed, 102 insertions, 103 deletions
diff --git a/src/lib/libcrypto/md4/md4.c b/src/lib/libcrypto/md4/md4.c
index 94de291260..717268b72a 100644
--- a/src/lib/libcrypto/md4/md4.c
+++ b/src/lib/libcrypto/md4/md4.c
@@ -1,4 +1,4 @@
1/* $OpenBSD: md4.c,v 1.10 2024/03/26 06:54:20 jsing Exp $ */ 1/* $OpenBSD: md4.c,v 1.11 2024/03/26 06:58:58 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 *
@@ -92,108 +92,6 @@ __END_HIDDEN_DECLS
92 92
93#include "md32_common.h" 93#include "md32_common.h"
94 94
95int
96MD4_Update(MD4_CTX *c, const void *data_, size_t len)
97{
98 const unsigned char *data = data_;
99 unsigned char *p;
100 MD4_LONG l;
101 size_t n;
102
103 if (len == 0)
104 return 1;
105
106 l = (c->Nl + (((MD4_LONG)len) << 3))&0xffffffffUL;
107 /* 95-05-24 eay Fixed a bug with the overflow handling, thanks to
108 * Wei Dai <weidai@eskimo.com> for pointing it out. */
109 if (l < c->Nl) /* overflow */
110 c->Nh++;
111 c->Nh+=(MD4_LONG)(len>>29); /* might cause compiler warning on 16-bit */
112 c->Nl = l;
113
114 n = c->num;
115 if (n != 0) {
116 p = (unsigned char *)c->data;
117
118 if (len >= MD4_CBLOCK || len + n >= MD4_CBLOCK) {
119 memcpy (p + n, data, MD4_CBLOCK - n);
120 md4_block_data_order (c, p, 1);
121 n = MD4_CBLOCK - n;
122 data += n;
123 len -= n;
124 c->num = 0;
125 memset(p, 0, MD4_CBLOCK); /* keep it zeroed */
126 } else {
127 memcpy(p + n, data, len);
128 c->num += (unsigned int)len;
129 return 1;
130 }
131 }
132
133 n = len / MD4_CBLOCK;
134 if (n > 0) {
135 md4_block_data_order(c, data, n);
136 n *= MD4_CBLOCK;
137 data += n;
138 len -= n;
139 }
140
141 if (len != 0) {
142 p = (unsigned char *)c->data;
143 c->num = (unsigned int)len;
144 memcpy(p, data, len);
145 }
146 return 1;
147}
148
149void
150MD4_Transform(MD4_CTX *c, const unsigned char *data)
151{
152 md4_block_data_order(c, data, 1);
153}
154
155int
156MD4_Final(unsigned char *md, MD4_CTX *c)
157{
158 unsigned char *p = (unsigned char *)c->data;
159 size_t n = c->num;
160
161 p[n] = 0x80; /* there is always room for one */
162 n++;
163
164 if (n > (MD4_CBLOCK - 8)) {
165 memset(p + n, 0, MD4_CBLOCK - n);
166 n = 0;
167 md4_block_data_order(c, p, 1);
168 }
169 memset(p + n, 0, MD4_CBLOCK - 8 - n);
170
171 p += MD4_CBLOCK - 8;
172#if defined(DATA_ORDER_IS_BIG_ENDIAN)
173 HOST_l2c(c->Nh, p);
174 HOST_l2c(c->Nl, p);
175#elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)
176 HOST_l2c(c->Nl, p);
177 HOST_l2c(c->Nh, p);
178#endif
179 p -= MD4_CBLOCK;
180 md4_block_data_order(c, p, 1);
181 c->num = 0;
182 memset(p, 0, MD4_CBLOCK);
183
184#ifndef HASH_MAKE_STRING
185#error "HASH_MAKE_STRING must be defined!"
186#else
187 HASH_MAKE_STRING(c, md);
188#endif
189
190 return 1;
191}
192
193LCRYPTO_ALIAS(MD4_Update);
194LCRYPTO_ALIAS(MD4_Final);
195LCRYPTO_ALIAS(MD4_Transform);
196
197/* 95/*
198#define F(x,y,z) (((x) & (y)) | ((~(x)) & (z))) 96#define F(x,y,z) (((x) & (y)) | ((~(x)) & (z)))
199#define G(x,y,z) (((x) & (y)) | ((x) & ((z))) | ((y) & ((z)))) 97#define G(x,y,z) (((x) & (y)) | ((x) & ((z))) | ((y) & ((z))))
@@ -349,6 +247,107 @@ MD4_Init(MD4_CTX *c)
349} 247}
350LCRYPTO_ALIAS(MD4_Init); 248LCRYPTO_ALIAS(MD4_Init);
351 249
250int
251MD4_Update(MD4_CTX *c, const void *data_, size_t len)
252{
253 const unsigned char *data = data_;
254 unsigned char *p;
255 MD4_LONG l;
256 size_t n;
257
258 if (len == 0)
259 return 1;
260
261 l = (c->Nl + (((MD4_LONG)len) << 3))&0xffffffffUL;
262 /* 95-05-24 eay Fixed a bug with the overflow handling, thanks to
263 * Wei Dai <weidai@eskimo.com> for pointing it out. */
264 if (l < c->Nl) /* overflow */
265 c->Nh++;
266 c->Nh+=(MD4_LONG)(len>>29); /* might cause compiler warning on 16-bit */
267 c->Nl = l;
268
269 n = c->num;
270 if (n != 0) {
271 p = (unsigned char *)c->data;
272
273 if (len >= MD4_CBLOCK || len + n >= MD4_CBLOCK) {
274 memcpy (p + n, data, MD4_CBLOCK - n);
275 md4_block_data_order (c, p, 1);
276 n = MD4_CBLOCK - n;
277 data += n;
278 len -= n;
279 c->num = 0;
280 memset(p, 0, MD4_CBLOCK); /* keep it zeroed */
281 } else {
282 memcpy(p + n, data, len);
283 c->num += (unsigned int)len;
284 return 1;
285 }
286 }
287
288 n = len / MD4_CBLOCK;
289 if (n > 0) {
290 md4_block_data_order(c, data, n);
291 n *= MD4_CBLOCK;
292 data += n;
293 len -= n;
294 }
295
296 if (len != 0) {
297 p = (unsigned char *)c->data;
298 c->num = (unsigned int)len;
299 memcpy(p, data, len);
300 }
301 return 1;
302}
303LCRYPTO_ALIAS(MD4_Update);
304
305void
306MD4_Transform(MD4_CTX *c, const unsigned char *data)
307{
308 md4_block_data_order(c, data, 1);
309}
310LCRYPTO_ALIAS(MD4_Transform);
311
312int
313MD4_Final(unsigned char *md, MD4_CTX *c)
314{
315 unsigned char *p = (unsigned char *)c->data;
316 size_t n = c->num;
317
318 p[n] = 0x80; /* there is always room for one */
319 n++;
320
321 if (n > (MD4_CBLOCK - 8)) {
322 memset(p + n, 0, MD4_CBLOCK - n);
323 n = 0;
324 md4_block_data_order(c, p, 1);
325 }
326 memset(p + n, 0, MD4_CBLOCK - 8 - n);
327
328 p += MD4_CBLOCK - 8;
329#if defined(DATA_ORDER_IS_BIG_ENDIAN)
330 HOST_l2c(c->Nh, p);
331 HOST_l2c(c->Nl, p);
332#elif defined(DATA_ORDER_IS_LITTLE_ENDIAN)
333 HOST_l2c(c->Nl, p);
334 HOST_l2c(c->Nh, p);
335#endif
336 p -= MD4_CBLOCK;
337 md4_block_data_order(c, p, 1);
338 c->num = 0;
339 memset(p, 0, MD4_CBLOCK);
340
341#ifndef HASH_MAKE_STRING
342#error "HASH_MAKE_STRING must be defined!"
343#else
344 HASH_MAKE_STRING(c, md);
345#endif
346
347 return 1;
348}
349LCRYPTO_ALIAS(MD4_Final);
350
352unsigned char * 351unsigned char *
353MD4(const unsigned char *d, size_t n, unsigned char *md) 352MD4(const unsigned char *d, size_t n, unsigned char *md)
354{ 353{
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-03-21 18:05:05 +0000