1 /* ppp-md5.c - MD5 Digest implementation 2 * 3 * Copyright (c) 2022 Eivind Nss. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in 14 * the documentation and/or other materials provided with the 15 * distribution. 16 * 17 * 3. The name(s) of the authors of this software must not be used to 18 * endorse or promote products derived from this software without 19 * prior written permission. 20 * 21 * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO 22 * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 23 * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY 24 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 25 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN 26 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING 27 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 28 * 29 * Sections of this code holds different copyright information. 30 */ 31 32 #ifdef HAVE_CONFIG_H 33 #include "config.h" 34 #endif 35 36 #include <stdlib.h> 37 #include <string.h> 38 39 #include "crypto-priv.h" 40 41 #ifdef OPENSSL_HAVE_MD5 42 #include <openssl/evp.h> 43 44 #if OPENSSL_VERSION_NUMBER < 0x10100000L 45 #define EVP_MD_CTX_free EVP_MD_CTX_destroy 46 #define EVP_MD_CTX_new EVP_MD_CTX_create 47 #endif 48 49 static int md5_init(PPP_MD_CTX *ctx) 50 { 51 if (ctx) { 52 EVP_MD_CTX *mctx = EVP_MD_CTX_new(); 53 if (mctx) { 54 if (EVP_DigestInit((EVP_MD_CTX*) mctx, EVP_md5())) { 55 ctx->priv = mctx; 56 return 1; 57 } 58 EVP_MD_CTX_free(mctx); 59 } 60 } 61 return 0; 62 } 63 64 static int md5_update(PPP_MD_CTX *ctx, const void *data, size_t len) 65 { 66 if (EVP_DigestUpdate((EVP_MD_CTX*) ctx->priv, data, len)) { 67 return 1; 68 } 69 return 0; 70 } 71 72 static int md5_final(PPP_MD_CTX *ctx, unsigned char *out, unsigned int *len) 73 { 74 if (EVP_DigestFinal((EVP_MD_CTX*) ctx->priv, out, len)) { 75 return 1; 76 } 77 return 0; 78 } 79 80 static void md5_clean(PPP_MD_CTX *ctx) 81 { 82 if (ctx->priv) { 83 EVP_MD_CTX_free((EVP_MD_CTX*) ctx->priv); 84 ctx->priv = NULL; 85 } 86 } 87 88 #else // !OPENSSL_HAVE_MD5 89 90 /* 91 *********************************************************************** 92 ** md5.c -- the source code for MD5 routines ** 93 ** RSA Data Security, Inc. MD5 Message-Digest Algorithm ** 94 ** Created: 2/17/90 RLR ** 95 ** Revised: 1/91 SRD,AJ,BSK,JT Reference C ver., 7/10 constant corr. ** 96 *********************************************************************** 97 */ 98 99 /* 100 *********************************************************************** 101 ** Copyright (C) 1990, RSA Data Security, Inc. All rights reserved. ** 102 ** ** 103 ** License to copy and use this software is granted provided that ** 104 ** it is identified as the "RSA Data Security, Inc. MD5 Message- ** 105 ** Digest Algorithm" in all material mentioning or referencing this ** 106 ** software or this function. ** 107 ** ** 108 ** License is also granted to make and use derivative works ** 109 ** provided that such works are identified as "derived from the RSA ** 110 ** Data Security, Inc. MD5 Message-Digest Algorithm" in all ** 111 ** material mentioning or referencing the derived work. ** 112 ** ** 113 ** RSA Data Security, Inc. makes no representations concerning ** 114 ** either the merchantability of this software or the suitability ** 115 ** of this software for any particular purpose. It is provided "as ** 116 ** is" without express or implied warranty of any kind. ** 117 ** ** 118 ** These notices must be retained in any copies of any part of this ** 119 ** documentation and/or software. ** 120 *********************************************************************** 121 */ 122 123 124 /* typedef a 32-bit type */ 125 #ifdef _LP64 126 typedef unsigned int UINT4; 127 typedef int INT4; 128 #else 129 typedef unsigned long UINT4; 130 typedef long INT4; 131 #endif 132 #define _UINT4_T 133 134 /* Data structure for MD5 (Message-Digest) computation */ 135 typedef struct { 136 UINT4 i[2]; /* number of _bits_ handled mod 2^64 */ 137 UINT4 buf[4]; /* scratch buffer */ 138 unsigned char in[64]; /* input buffer */ 139 unsigned char digest[16]; /* actual digest after MD5Final call */ 140 } MD5_CTX; 141 142 143 /* 144 *********************************************************************** 145 ** Message-digest routines: ** 146 ** To form the message digest for a message M ** 147 ** (1) Initialize a context buffer mdContext using MD5_Init ** 148 ** (2) Call MD5_Update on mdContext and M ** 149 ** (3) Call MD5_Final on mdContext ** 150 ** The message digest is now in mdContext->digest[0...15] ** 151 *********************************************************************** 152 */ 153 154 /* forward declaration */ 155 static void Transform (UINT4 *buf, UINT4 *in); 156 157 static unsigned char PADDING[64] = { 158 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 159 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 160 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 161 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 162 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 163 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 164 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 165 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 166 }; 167 168 /* F, G, H and I are basic MD5 functions */ 169 #define F(x, y, z) (((x) & (y)) | ((~x) & (z))) 170 #define G(x, y, z) (((x) & (z)) | ((y) & (~z))) 171 #define H(x, y, z) ((x) ^ (y) ^ (z)) 172 #define I(x, y, z) ((y) ^ ((x) | (~z))) 173 174 /* ROTATE_LEFT rotates x left n bits */ 175 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n)))) 176 177 /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4 */ 178 /* Rotation is separate from addition to prevent recomputation */ 179 #define FF(a, b, c, d, x, s, ac) \ 180 {(a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \ 181 (a) = ROTATE_LEFT ((a), (s)); \ 182 (a) += (b); \ 183 } 184 #define GG(a, b, c, d, x, s, ac) \ 185 {(a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \ 186 (a) = ROTATE_LEFT ((a), (s)); \ 187 (a) += (b); \ 188 } 189 #define HH(a, b, c, d, x, s, ac) \ 190 {(a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \ 191 (a) = ROTATE_LEFT ((a), (s)); \ 192 (a) += (b); \ 193 } 194 #define II(a, b, c, d, x, s, ac) \ 195 {(a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \ 196 (a) = ROTATE_LEFT ((a), (s)); \ 197 (a) += (b); \ 198 } 199 200 #ifdef __STDC__ 201 #define UL(x) x##U 202 #else 203 #define UL(x) x 204 #endif 205 206 /* The routine MD5_Init initializes the message-digest context 207 mdContext. All fields are set to zero. 208 */ 209 static void MD5_Init (MD5_CTX *mdContext) 210 { 211 mdContext->i[0] = mdContext->i[1] = (UINT4)0; 212 213 /* Load magic initialization constants. 214 */ 215 mdContext->buf[0] = (UINT4)0x67452301; 216 mdContext->buf[1] = (UINT4)0xefcdab89; 217 mdContext->buf[2] = (UINT4)0x98badcfe; 218 mdContext->buf[3] = (UINT4)0x10325476; 219 } 220 221 /* The routine MD5Update updates the message-digest context to 222 account for the presence of each of the characters inBuf[0..inLen-1] 223 in the message whose digest is being computed. 224 */ 225 static void MD5_Update (MD5_CTX *mdContext, unsigned char *inBuf, unsigned int inLen) 226 { 227 UINT4 in[16]; 228 int mdi; 229 unsigned int i, ii; 230 231 /* compute number of bytes mod 64 */ 232 mdi = (int)((mdContext->i[0] >> 3) & 0x3F); 233 234 /* update number of bits */ 235 if ((mdContext->i[0] + ((UINT4)inLen << 3)) < mdContext->i[0]) 236 mdContext->i[1]++; 237 mdContext->i[0] += ((UINT4)inLen << 3); 238 mdContext->i[1] += ((UINT4)inLen >> 29); 239 240 while (inLen--) { 241 /* add new character to buffer, increment mdi */ 242 mdContext->in[mdi++] = *inBuf++; 243 244 /* transform if necessary */ 245 if (mdi == 0x40) { 246 for (i = 0, ii = 0; i < 16; i++, ii += 4) 247 in[i] = (((UINT4)mdContext->in[ii+3]) << 24) | 248 (((UINT4)mdContext->in[ii+2]) << 16) | 249 (((UINT4)mdContext->in[ii+1]) << 8) | 250 ((UINT4)mdContext->in[ii]); 251 Transform (mdContext->buf, in); 252 mdi = 0; 253 } 254 } 255 } 256 257 /* The routine MD5Final terminates the message-digest computation and 258 ends with the desired message digest in mdContext->digest[0...15]. 259 */ 260 static void MD5_Final (unsigned char hash[], MD5_CTX *mdContext) 261 { 262 UINT4 in[16]; 263 int mdi; 264 unsigned int i, ii; 265 unsigned int padLen; 266 267 /* save number of bits */ 268 in[14] = mdContext->i[0]; 269 in[15] = mdContext->i[1]; 270 271 /* compute number of bytes mod 64 */ 272 mdi = (int)((mdContext->i[0] >> 3) & 0x3F); 273 274 /* pad out to 56 mod 64 */ 275 padLen = (mdi < 56) ? (56 - mdi) : (120 - mdi); 276 MD5_Update (mdContext, PADDING, padLen); 277 278 /* append length in bits and transform */ 279 for (i = 0, ii = 0; i < 14; i++, ii += 4) 280 in[i] = (((UINT4)mdContext->in[ii+3]) << 24) | 281 (((UINT4)mdContext->in[ii+2]) << 16) | 282 (((UINT4)mdContext->in[ii+1]) << 8) | 283 ((UINT4)mdContext->in[ii]); 284 Transform (mdContext->buf, in); 285 286 /* store buffer in digest */ 287 for (i = 0, ii = 0; i < 4; i++, ii += 4) { 288 mdContext->digest[ii] = (unsigned char)(mdContext->buf[i] & 0xFF); 289 mdContext->digest[ii+1] = 290 (unsigned char)((mdContext->buf[i] >> 8) & 0xFF); 291 mdContext->digest[ii+2] = 292 (unsigned char)((mdContext->buf[i] >> 16) & 0xFF); 293 mdContext->digest[ii+3] = 294 (unsigned char)((mdContext->buf[i] >> 24) & 0xFF); 295 } 296 memcpy(hash, mdContext->digest, 16); 297 } 298 299 /* Basic MD5 step. Transforms buf based on in. 300 */ 301 static void Transform (UINT4 *buf, UINT4 *in) 302 { 303 UINT4 a = buf[0], b = buf[1], c = buf[2], d = buf[3]; 304 305 /* Round 1 */ 306 #define S11 7 307 #define S12 12 308 #define S13 17 309 #define S14 22 310 FF ( a, b, c, d, in[ 0], S11, UL(3614090360)); /* 1 */ 311 FF ( d, a, b, c, in[ 1], S12, UL(3905402710)); /* 2 */ 312 FF ( c, d, a, b, in[ 2], S13, UL( 606105819)); /* 3 */ 313 FF ( b, c, d, a, in[ 3], S14, UL(3250441966)); /* 4 */ 314 FF ( a, b, c, d, in[ 4], S11, UL(4118548399)); /* 5 */ 315 FF ( d, a, b, c, in[ 5], S12, UL(1200080426)); /* 6 */ 316 FF ( c, d, a, b, in[ 6], S13, UL(2821735955)); /* 7 */ 317 FF ( b, c, d, a, in[ 7], S14, UL(4249261313)); /* 8 */ 318 FF ( a, b, c, d, in[ 8], S11, UL(1770035416)); /* 9 */ 319 FF ( d, a, b, c, in[ 9], S12, UL(2336552879)); /* 10 */ 320 FF ( c, d, a, b, in[10], S13, UL(4294925233)); /* 11 */ 321 FF ( b, c, d, a, in[11], S14, UL(2304563134)); /* 12 */ 322 FF ( a, b, c, d, in[12], S11, UL(1804603682)); /* 13 */ 323 FF ( d, a, b, c, in[13], S12, UL(4254626195)); /* 14 */ 324 FF ( c, d, a, b, in[14], S13, UL(2792965006)); /* 15 */ 325 FF ( b, c, d, a, in[15], S14, UL(1236535329)); /* 16 */ 326 327 /* Round 2 */ 328 #define S21 5 329 #define S22 9 330 #define S23 14 331 #define S24 20 332 GG ( a, b, c, d, in[ 1], S21, UL(4129170786)); /* 17 */ 333 GG ( d, a, b, c, in[ 6], S22, UL(3225465664)); /* 18 */ 334 GG ( c, d, a, b, in[11], S23, UL( 643717713)); /* 19 */ 335 GG ( b, c, d, a, in[ 0], S24, UL(3921069994)); /* 20 */ 336 GG ( a, b, c, d, in[ 5], S21, UL(3593408605)); /* 21 */ 337 GG ( d, a, b, c, in[10], S22, UL( 38016083)); /* 22 */ 338 GG ( c, d, a, b, in[15], S23, UL(3634488961)); /* 23 */ 339 GG ( b, c, d, a, in[ 4], S24, UL(3889429448)); /* 24 */ 340 GG ( a, b, c, d, in[ 9], S21, UL( 568446438)); /* 25 */ 341 GG ( d, a, b, c, in[14], S22, UL(3275163606)); /* 26 */ 342 GG ( c, d, a, b, in[ 3], S23, UL(4107603335)); /* 27 */ 343 GG ( b, c, d, a, in[ 8], S24, UL(1163531501)); /* 28 */ 344 GG ( a, b, c, d, in[13], S21, UL(2850285829)); /* 29 */ 345 GG ( d, a, b, c, in[ 2], S22, UL(4243563512)); /* 30 */ 346 GG ( c, d, a, b, in[ 7], S23, UL(1735328473)); /* 31 */ 347 GG ( b, c, d, a, in[12], S24, UL(2368359562)); /* 32 */ 348 349 /* Round 3 */ 350 #define S31 4 351 #define S32 11 352 #define S33 16 353 #define S34 23 354 HH ( a, b, c, d, in[ 5], S31, UL(4294588738)); /* 33 */ 355 HH ( d, a, b, c, in[ 8], S32, UL(2272392833)); /* 34 */ 356 HH ( c, d, a, b, in[11], S33, UL(1839030562)); /* 35 */ 357 HH ( b, c, d, a, in[14], S34, UL(4259657740)); /* 36 */ 358 HH ( a, b, c, d, in[ 1], S31, UL(2763975236)); /* 37 */ 359 HH ( d, a, b, c, in[ 4], S32, UL(1272893353)); /* 38 */ 360 HH ( c, d, a, b, in[ 7], S33, UL(4139469664)); /* 39 */ 361 HH ( b, c, d, a, in[10], S34, UL(3200236656)); /* 40 */ 362 HH ( a, b, c, d, in[13], S31, UL( 681279174)); /* 41 */ 363 HH ( d, a, b, c, in[ 0], S32, UL(3936430074)); /* 42 */ 364 HH ( c, d, a, b, in[ 3], S33, UL(3572445317)); /* 43 */ 365 HH ( b, c, d, a, in[ 6], S34, UL( 76029189)); /* 44 */ 366 HH ( a, b, c, d, in[ 9], S31, UL(3654602809)); /* 45 */ 367 HH ( d, a, b, c, in[12], S32, UL(3873151461)); /* 46 */ 368 HH ( c, d, a, b, in[15], S33, UL( 530742520)); /* 47 */ 369 HH ( b, c, d, a, in[ 2], S34, UL(3299628645)); /* 48 */ 370 371 /* Round 4 */ 372 #define S41 6 373 #define S42 10 374 #define S43 15 375 #define S44 21 376 II ( a, b, c, d, in[ 0], S41, UL(4096336452)); /* 49 */ 377 II ( d, a, b, c, in[ 7], S42, UL(1126891415)); /* 50 */ 378 II ( c, d, a, b, in[14], S43, UL(2878612391)); /* 51 */ 379 II ( b, c, d, a, in[ 5], S44, UL(4237533241)); /* 52 */ 380 II ( a, b, c, d, in[12], S41, UL(1700485571)); /* 53 */ 381 II ( d, a, b, c, in[ 3], S42, UL(2399980690)); /* 54 */ 382 II ( c, d, a, b, in[10], S43, UL(4293915773)); /* 55 */ 383 II ( b, c, d, a, in[ 1], S44, UL(2240044497)); /* 56 */ 384 II ( a, b, c, d, in[ 8], S41, UL(1873313359)); /* 57 */ 385 II ( d, a, b, c, in[15], S42, UL(4264355552)); /* 58 */ 386 II ( c, d, a, b, in[ 6], S43, UL(2734768916)); /* 59 */ 387 II ( b, c, d, a, in[13], S44, UL(1309151649)); /* 60 */ 388 II ( a, b, c, d, in[ 4], S41, UL(4149444226)); /* 61 */ 389 II ( d, a, b, c, in[11], S42, UL(3174756917)); /* 62 */ 390 II ( c, d, a, b, in[ 2], S43, UL( 718787259)); /* 63 */ 391 II ( b, c, d, a, in[ 9], S44, UL(3951481745)); /* 64 */ 392 393 buf[0] += a; 394 buf[1] += b; 395 buf[2] += c; 396 buf[3] += d; 397 } 398 399 /* 400 *********************************************************************** 401 ** End of md5.c ** 402 ******************************** (cut) ******************************** 403 */ 404 405 static int md5_init(PPP_MD_CTX *ctx) 406 { 407 if (ctx) { 408 MD5_CTX *md5 = calloc(1, sizeof(MD5_CTX)); 409 if (md5 != NULL) { 410 MD5_Init(md5); 411 ctx->priv = md5; 412 return 1; 413 } 414 } 415 return 0; 416 } 417 418 static int md5_update(PPP_MD_CTX *ctx, const void *data, size_t len) 419 { 420 MD5_Update((MD5_CTX*) ctx->priv, (void*) data, len); 421 return 1; 422 } 423 424 static int md5_final(PPP_MD_CTX *ctx, unsigned char *out, unsigned int *len) 425 { 426 MD5_Final(out, (MD5_CTX*) ctx->priv); 427 return 1; 428 } 429 430 static void md5_clean(PPP_MD_CTX *ctx) 431 { 432 if (ctx->priv) { 433 free(ctx->priv); 434 ctx->priv = NULL; 435 } 436 } 437 438 #endif 439 440 static PPP_MD ppp_md5 = { 441 .init_fn = md5_init, 442 .update_fn = md5_update, 443 .final_fn = md5_final, 444 .clean_fn = md5_clean, 445 }; 446 447 const PPP_MD *PPP_md5(void) 448 { 449 return &ppp_md5; 450 } 451 452
Indexes created Thu Jun 25 00:25:11 UTC 2026