2
0

md4.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509
  1. /***************************************************************************
  2. * _ _ ____ _
  3. * Project ___| | | | _ \| |
  4. * / __| | | | |_) | |
  5. * | (__| |_| | _ <| |___
  6. * \___|\___/|_| \_\_____|
  7. *
  8. * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
  9. *
  10. * This software is licensed as described in the file COPYING, which
  11. * you should have received as part of this distribution. The terms
  12. * are also available at https://curl.se/docs/copyright.html.
  13. *
  14. * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15. * copies of the Software, and permit persons to whom the Software is
  16. * furnished to do so, under the terms of the COPYING file.
  17. *
  18. * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19. * KIND, either express or implied.
  20. *
  21. * SPDX-License-Identifier: curl
  22. *
  23. ***************************************************************************/
  24. #include "curl_setup.h"
  25. #if defined(USE_CURL_NTLM_CORE)
  26. #include <string.h>
  27. #include "curl_md4.h"
  28. #include "warnless.h"
  29. #ifdef USE_OPENSSL
  30. #include <openssl/opensslconf.h>
  31. #if defined(OPENSSL_VERSION_MAJOR) && (OPENSSL_VERSION_MAJOR >= 3) && \
  32. !defined(USE_AMISSL)
  33. /* OpenSSL 3.0.0 marks the MD4 functions as deprecated */
  34. #define OPENSSL_NO_MD4
  35. #endif
  36. #endif /* USE_OPENSSL */
  37. #ifdef USE_WOLFSSL
  38. #include <wolfssl/options.h>
  39. #ifdef NO_MD4
  40. #define WOLFSSL_NO_MD4
  41. #endif
  42. #endif
  43. #ifdef USE_MBEDTLS
  44. #include <mbedtls/version.h>
  45. #if MBEDTLS_VERSION_NUMBER >= 0x03000000
  46. #include <mbedtls/mbedtls_config.h>
  47. #else
  48. #include <mbedtls/config.h>
  49. #endif
  50. #if(MBEDTLS_VERSION_NUMBER >= 0x02070000)
  51. #define HAS_MBEDTLS_RESULT_CODE_BASED_FUNCTIONS
  52. #endif
  53. #endif /* USE_MBEDTLS */
  54. #if defined(USE_GNUTLS)
  55. #include <nettle/md4.h>
  56. /* When OpenSSL or wolfSSL is available, we use their MD4 functions. */
  57. #elif defined(USE_WOLFSSL) && !defined(WOLFSSL_NO_MD4)
  58. #include <wolfssl/openssl/md4.h>
  59. #elif defined(USE_OPENSSL) && !defined(OPENSSL_NO_MD4)
  60. #include <openssl/md4.h>
  61. #elif (defined(__MAC_OS_X_VERSION_MAX_ALLOWED) && \
  62. (__MAC_OS_X_VERSION_MAX_ALLOWED >= 1040) && \
  63. defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && \
  64. (__MAC_OS_X_VERSION_MIN_REQUIRED < 101500)) || \
  65. (defined(__IPHONE_OS_VERSION_MAX_ALLOWED) && \
  66. (__IPHONE_OS_VERSION_MAX_ALLOWED >= 20000) && \
  67. defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && \
  68. (__IPHONE_OS_VERSION_MIN_REQUIRED < 130000))
  69. #define AN_APPLE_OS
  70. #include <CommonCrypto/CommonDigest.h>
  71. #elif defined(USE_WIN32_CRYPTO)
  72. #include <wincrypt.h>
  73. #elif(defined(USE_MBEDTLS) && defined(MBEDTLS_MD4_C))
  74. #include <mbedtls/md4.h>
  75. #endif
  76. /* The last 3 #include files should be in this order */
  77. #include "curl_printf.h"
  78. #include "curl_memory.h"
  79. #include "memdebug.h"
  80. #if defined(USE_GNUTLS)
  81. typedef struct md4_ctx MD4_CTX;
  82. static void MD4_Init(MD4_CTX *ctx)
  83. {
  84. md4_init(ctx);
  85. }
  86. static void MD4_Update(MD4_CTX *ctx, const void *data, unsigned long size)
  87. {
  88. md4_update(ctx, size, data);
  89. }
  90. static void MD4_Final(unsigned char *result, MD4_CTX *ctx)
  91. {
  92. md4_digest(ctx, MD4_DIGEST_SIZE, result);
  93. }
  94. #elif defined(USE_WOLFSSL) && !defined(WOLFSSL_NO_MD4)
  95. #elif defined(USE_OPENSSL) && !defined(OPENSSL_NO_MD4)
  96. #elif defined(AN_APPLE_OS)
  97. typedef CC_MD4_CTX MD4_CTX;
  98. static void MD4_Init(MD4_CTX *ctx)
  99. {
  100. (void)CC_MD4_Init(ctx);
  101. }
  102. static void MD4_Update(MD4_CTX *ctx, const void *data, unsigned long size)
  103. {
  104. (void)CC_MD4_Update(ctx, data, (CC_LONG)size);
  105. }
  106. static void MD4_Final(unsigned char *result, MD4_CTX *ctx)
  107. {
  108. (void)CC_MD4_Final(result, ctx);
  109. }
  110. #elif defined(USE_WIN32_CRYPTO)
  111. struct md4_ctx {
  112. HCRYPTPROV hCryptProv;
  113. HCRYPTHASH hHash;
  114. };
  115. typedef struct md4_ctx MD4_CTX;
  116. static void MD4_Init(MD4_CTX *ctx)
  117. {
  118. ctx->hCryptProv = 0;
  119. ctx->hHash = 0;
  120. if(CryptAcquireContext(&ctx->hCryptProv, NULL, NULL, PROV_RSA_FULL,
  121. CRYPT_VERIFYCONTEXT | CRYPT_SILENT)) {
  122. CryptCreateHash(ctx->hCryptProv, CALG_MD4, 0, 0, &ctx->hHash);
  123. }
  124. }
  125. static void MD4_Update(MD4_CTX *ctx, const void *data, unsigned long size)
  126. {
  127. CryptHashData(ctx->hHash, (BYTE *)data, (unsigned int) size, 0);
  128. }
  129. static void MD4_Final(unsigned char *result, MD4_CTX *ctx)
  130. {
  131. unsigned long length = 0;
  132. CryptGetHashParam(ctx->hHash, HP_HASHVAL, NULL, &length, 0);
  133. if(length == MD4_DIGEST_LENGTH)
  134. CryptGetHashParam(ctx->hHash, HP_HASHVAL, result, &length, 0);
  135. if(ctx->hHash)
  136. CryptDestroyHash(ctx->hHash);
  137. if(ctx->hCryptProv)
  138. CryptReleaseContext(ctx->hCryptProv, 0);
  139. }
  140. #elif(defined(USE_MBEDTLS) && defined(MBEDTLS_MD4_C))
  141. struct md4_ctx {
  142. void *data;
  143. unsigned long size;
  144. };
  145. typedef struct md4_ctx MD4_CTX;
  146. static void MD4_Init(MD4_CTX *ctx)
  147. {
  148. ctx->data = NULL;
  149. ctx->size = 0;
  150. }
  151. static void MD4_Update(MD4_CTX *ctx, const void *data, unsigned long size)
  152. {
  153. if(!ctx->data) {
  154. ctx->data = malloc(size);
  155. if(ctx->data) {
  156. memcpy(ctx->data, data, size);
  157. ctx->size = size;
  158. }
  159. }
  160. }
  161. static void MD4_Final(unsigned char *result, MD4_CTX *ctx)
  162. {
  163. if(ctx->data) {
  164. #if !defined(HAS_MBEDTLS_RESULT_CODE_BASED_FUNCTIONS)
  165. mbedtls_md4(ctx->data, ctx->size, result);
  166. #else
  167. (void) mbedtls_md4_ret(ctx->data, ctx->size, result);
  168. #endif
  169. Curl_safefree(ctx->data);
  170. ctx->size = 0;
  171. }
  172. }
  173. #else
  174. /* When no other crypto library is available, or the crypto library doesn't
  175. * support MD4, we use this code segment this implementation of it
  176. *
  177. * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc.
  178. * MD4 Message-Digest Algorithm (RFC 1320).
  179. *
  180. * Homepage:
  181. https://openwall.info/wiki/people/solar/software/public-domain-source-code/md4
  182. *
  183. * Author:
  184. * Alexander Peslyak, better known as Solar Designer <solar at openwall.com>
  185. *
  186. * This software was written by Alexander Peslyak in 2001. No copyright is
  187. * claimed, and the software is hereby placed in the public domain. In case
  188. * this attempt to disclaim copyright and place the software in the public
  189. * domain is deemed null and void, then the software is Copyright (c) 2001
  190. * Alexander Peslyak and it is hereby released to the general public under the
  191. * following terms:
  192. *
  193. * Redistribution and use in source and binary forms, with or without
  194. * modification, are permitted.
  195. *
  196. * There's ABSOLUTELY NO WARRANTY, express or implied.
  197. *
  198. * (This is a heavily cut-down "BSD license".)
  199. *
  200. * This differs from Colin Plumb's older public domain implementation in that
  201. * no exactly 32-bit integer data type is required (any 32-bit or wider
  202. * unsigned integer data type will do), there's no compile-time endianness
  203. * configuration, and the function prototypes match OpenSSL's. No code from
  204. * Colin Plumb's implementation has been reused; this comment merely compares
  205. * the properties of the two independent implementations.
  206. *
  207. * The primary goals of this implementation are portability and ease of use.
  208. * It is meant to be fast, but not as fast as possible. Some known
  209. * optimizations are not included to reduce source code size and avoid
  210. * compile-time configuration.
  211. */
  212. /* Any 32-bit or wider unsigned integer data type will do */
  213. typedef unsigned int MD4_u32plus;
  214. struct md4_ctx {
  215. MD4_u32plus lo, hi;
  216. MD4_u32plus a, b, c, d;
  217. unsigned char buffer[64];
  218. MD4_u32plus block[16];
  219. };
  220. typedef struct md4_ctx MD4_CTX;
  221. static void MD4_Init(MD4_CTX *ctx);
  222. static void MD4_Update(MD4_CTX *ctx, const void *data, unsigned long size);
  223. static void MD4_Final(unsigned char *result, MD4_CTX *ctx);
  224. /*
  225. * The basic MD4 functions.
  226. *
  227. * F and G are optimized compared to their RFC 1320 definitions, with the
  228. * optimization for F borrowed from Colin Plumb's MD5 implementation.
  229. */
  230. #define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
  231. #define G(x, y, z) (((x) & ((y) | (z))) | ((y) & (z)))
  232. #define H(x, y, z) ((x) ^ (y) ^ (z))
  233. /*
  234. * The MD4 transformation for all three rounds.
  235. */
  236. #define STEP(f, a, b, c, d, x, s) \
  237. (a) += f((b), (c), (d)) + (x); \
  238. (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s))));
  239. /*
  240. * SET reads 4 input bytes in little-endian byte order and stores them
  241. * in a properly aligned word in host byte order.
  242. *
  243. * The check for little-endian architectures that tolerate unaligned
  244. * memory accesses is just an optimization. Nothing will break if it
  245. * doesn't work.
  246. */
  247. #if defined(__i386__) || defined(__x86_64__) || defined(__vax__)
  248. #define SET(n) \
  249. (*(MD4_u32plus *)(void *)&ptr[(n) * 4])
  250. #define GET(n) \
  251. SET(n)
  252. #else
  253. #define SET(n) \
  254. (ctx->block[(n)] = \
  255. (MD4_u32plus)ptr[(n) * 4] | \
  256. ((MD4_u32plus)ptr[(n) * 4 + 1] << 8) | \
  257. ((MD4_u32plus)ptr[(n) * 4 + 2] << 16) | \
  258. ((MD4_u32plus)ptr[(n) * 4 + 3] << 24))
  259. #define GET(n) \
  260. (ctx->block[(n)])
  261. #endif
  262. /*
  263. * This processes one or more 64-byte data blocks, but does NOT update
  264. * the bit counters. There are no alignment requirements.
  265. */
  266. static const void *body(MD4_CTX *ctx, const void *data, unsigned long size)
  267. {
  268. const unsigned char *ptr;
  269. MD4_u32plus a, b, c, d;
  270. ptr = (const unsigned char *)data;
  271. a = ctx->a;
  272. b = ctx->b;
  273. c = ctx->c;
  274. d = ctx->d;
  275. do {
  276. MD4_u32plus saved_a, saved_b, saved_c, saved_d;
  277. saved_a = a;
  278. saved_b = b;
  279. saved_c = c;
  280. saved_d = d;
  281. /* Round 1 */
  282. STEP(F, a, b, c, d, SET(0), 3)
  283. STEP(F, d, a, b, c, SET(1), 7)
  284. STEP(F, c, d, a, b, SET(2), 11)
  285. STEP(F, b, c, d, a, SET(3), 19)
  286. STEP(F, a, b, c, d, SET(4), 3)
  287. STEP(F, d, a, b, c, SET(5), 7)
  288. STEP(F, c, d, a, b, SET(6), 11)
  289. STEP(F, b, c, d, a, SET(7), 19)
  290. STEP(F, a, b, c, d, SET(8), 3)
  291. STEP(F, d, a, b, c, SET(9), 7)
  292. STEP(F, c, d, a, b, SET(10), 11)
  293. STEP(F, b, c, d, a, SET(11), 19)
  294. STEP(F, a, b, c, d, SET(12), 3)
  295. STEP(F, d, a, b, c, SET(13), 7)
  296. STEP(F, c, d, a, b, SET(14), 11)
  297. STEP(F, b, c, d, a, SET(15), 19)
  298. /* Round 2 */
  299. STEP(G, a, b, c, d, GET(0) + 0x5a827999, 3)
  300. STEP(G, d, a, b, c, GET(4) + 0x5a827999, 5)
  301. STEP(G, c, d, a, b, GET(8) + 0x5a827999, 9)
  302. STEP(G, b, c, d, a, GET(12) + 0x5a827999, 13)
  303. STEP(G, a, b, c, d, GET(1) + 0x5a827999, 3)
  304. STEP(G, d, a, b, c, GET(5) + 0x5a827999, 5)
  305. STEP(G, c, d, a, b, GET(9) + 0x5a827999, 9)
  306. STEP(G, b, c, d, a, GET(13) + 0x5a827999, 13)
  307. STEP(G, a, b, c, d, GET(2) + 0x5a827999, 3)
  308. STEP(G, d, a, b, c, GET(6) + 0x5a827999, 5)
  309. STEP(G, c, d, a, b, GET(10) + 0x5a827999, 9)
  310. STEP(G, b, c, d, a, GET(14) + 0x5a827999, 13)
  311. STEP(G, a, b, c, d, GET(3) + 0x5a827999, 3)
  312. STEP(G, d, a, b, c, GET(7) + 0x5a827999, 5)
  313. STEP(G, c, d, a, b, GET(11) + 0x5a827999, 9)
  314. STEP(G, b, c, d, a, GET(15) + 0x5a827999, 13)
  315. /* Round 3 */
  316. STEP(H, a, b, c, d, GET(0) + 0x6ed9eba1, 3)
  317. STEP(H, d, a, b, c, GET(8) + 0x6ed9eba1, 9)
  318. STEP(H, c, d, a, b, GET(4) + 0x6ed9eba1, 11)
  319. STEP(H, b, c, d, a, GET(12) + 0x6ed9eba1, 15)
  320. STEP(H, a, b, c, d, GET(2) + 0x6ed9eba1, 3)
  321. STEP(H, d, a, b, c, GET(10) + 0x6ed9eba1, 9)
  322. STEP(H, c, d, a, b, GET(6) + 0x6ed9eba1, 11)
  323. STEP(H, b, c, d, a, GET(14) + 0x6ed9eba1, 15)
  324. STEP(H, a, b, c, d, GET(1) + 0x6ed9eba1, 3)
  325. STEP(H, d, a, b, c, GET(9) + 0x6ed9eba1, 9)
  326. STEP(H, c, d, a, b, GET(5) + 0x6ed9eba1, 11)
  327. STEP(H, b, c, d, a, GET(13) + 0x6ed9eba1, 15)
  328. STEP(H, a, b, c, d, GET(3) + 0x6ed9eba1, 3)
  329. STEP(H, d, a, b, c, GET(11) + 0x6ed9eba1, 9)
  330. STEP(H, c, d, a, b, GET(7) + 0x6ed9eba1, 11)
  331. STEP(H, b, c, d, a, GET(15) + 0x6ed9eba1, 15)
  332. a += saved_a;
  333. b += saved_b;
  334. c += saved_c;
  335. d += saved_d;
  336. ptr += 64;
  337. } while(size -= 64);
  338. ctx->a = a;
  339. ctx->b = b;
  340. ctx->c = c;
  341. ctx->d = d;
  342. return ptr;
  343. }
  344. static void MD4_Init(MD4_CTX *ctx)
  345. {
  346. ctx->a = 0x67452301;
  347. ctx->b = 0xefcdab89;
  348. ctx->c = 0x98badcfe;
  349. ctx->d = 0x10325476;
  350. ctx->lo = 0;
  351. ctx->hi = 0;
  352. }
  353. static void MD4_Update(MD4_CTX *ctx, const void *data, unsigned long size)
  354. {
  355. MD4_u32plus saved_lo;
  356. unsigned long used;
  357. saved_lo = ctx->lo;
  358. ctx->lo = (saved_lo + size) & 0x1fffffff;
  359. if(ctx->lo < saved_lo)
  360. ctx->hi++;
  361. ctx->hi += (MD4_u32plus)size >> 29;
  362. used = saved_lo & 0x3f;
  363. if(used) {
  364. unsigned long available = 64 - used;
  365. if(size < available) {
  366. memcpy(&ctx->buffer[used], data, size);
  367. return;
  368. }
  369. memcpy(&ctx->buffer[used], data, available);
  370. data = (const unsigned char *)data + available;
  371. size -= available;
  372. body(ctx, ctx->buffer, 64);
  373. }
  374. if(size >= 64) {
  375. data = body(ctx, data, size & ~(unsigned long)0x3f);
  376. size &= 0x3f;
  377. }
  378. memcpy(ctx->buffer, data, size);
  379. }
  380. static void MD4_Final(unsigned char *result, MD4_CTX *ctx)
  381. {
  382. unsigned long used, available;
  383. used = ctx->lo & 0x3f;
  384. ctx->buffer[used++] = 0x80;
  385. available = 64 - used;
  386. if(available < 8) {
  387. memset(&ctx->buffer[used], 0, available);
  388. body(ctx, ctx->buffer, 64);
  389. used = 0;
  390. available = 64;
  391. }
  392. memset(&ctx->buffer[used], 0, available - 8);
  393. ctx->lo <<= 3;
  394. ctx->buffer[56] = curlx_ultouc((ctx->lo)&0xff);
  395. ctx->buffer[57] = curlx_ultouc((ctx->lo >> 8)&0xff);
  396. ctx->buffer[58] = curlx_ultouc((ctx->lo >> 16)&0xff);
  397. ctx->buffer[59] = curlx_ultouc((ctx->lo >> 24)&0xff);
  398. ctx->buffer[60] = curlx_ultouc((ctx->hi)&0xff);
  399. ctx->buffer[61] = curlx_ultouc((ctx->hi >> 8)&0xff);
  400. ctx->buffer[62] = curlx_ultouc((ctx->hi >> 16)&0xff);
  401. ctx->buffer[63] = curlx_ultouc(ctx->hi >> 24);
  402. body(ctx, ctx->buffer, 64);
  403. result[0] = curlx_ultouc((ctx->a)&0xff);
  404. result[1] = curlx_ultouc((ctx->a >> 8)&0xff);
  405. result[2] = curlx_ultouc((ctx->a >> 16)&0xff);
  406. result[3] = curlx_ultouc(ctx->a >> 24);
  407. result[4] = curlx_ultouc((ctx->b)&0xff);
  408. result[5] = curlx_ultouc((ctx->b >> 8)&0xff);
  409. result[6] = curlx_ultouc((ctx->b >> 16)&0xff);
  410. result[7] = curlx_ultouc(ctx->b >> 24);
  411. result[8] = curlx_ultouc((ctx->c)&0xff);
  412. result[9] = curlx_ultouc((ctx->c >> 8)&0xff);
  413. result[10] = curlx_ultouc((ctx->c >> 16)&0xff);
  414. result[11] = curlx_ultouc(ctx->c >> 24);
  415. result[12] = curlx_ultouc((ctx->d)&0xff);
  416. result[13] = curlx_ultouc((ctx->d >> 8)&0xff);
  417. result[14] = curlx_ultouc((ctx->d >> 16)&0xff);
  418. result[15] = curlx_ultouc(ctx->d >> 24);
  419. memset(ctx, 0, sizeof(*ctx));
  420. }
  421. #endif /* CRYPTO LIBS */
  422. void Curl_md4it(unsigned char *output, const unsigned char *input,
  423. const size_t len)
  424. {
  425. MD4_CTX ctx;
  426. MD4_Init(&ctx);
  427. MD4_Update(&ctx, input, curlx_uztoui(len));
  428. MD4_Final(output, &ctx);
  429. }
  430. #endif /* USE_CURL_NTLM_CORE */