kris
/
boringssl
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2230 Commits
12 Branches
38 MiB
 
 
 
 
 
 
Tree: acb2451807
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'acb2451807'
${ noResults }
boringssl/crypto/md5/md5.c

276 lines
9.1 KiB
Raw Blame History 

  1. /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)

  2.  * All rights reserved.

  3.  *

  4.  * This package is an SSL implementation written

  5.  * by Eric Young (eay@cryptsoft.com).

  6.  * The implementation was written so as to conform with Netscapes SSL.

  7.  *

  8.  * This library is free for commercial and non-commercial use as long as

  9.  * the following conditions are aheared to.  The following conditions

  10.  * apply to all code found in this distribution, be it the RC4, RSA,

  11.  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation

  12.  * included with this distribution is covered by the same copyright terms

  13.  * except that the holder is Tim Hudson (tjh@cryptsoft.com).

  14.  *

  15.  * Copyright remains Eric Young's, and as such any Copyright notices in

  16.  * the code are not to be removed.

  17.  * If this package is used in a product, Eric Young should be given attribution

  18.  * as the author of the parts of the library used.

  19.  * This can be in the form of a textual message at program startup or

  20.  * in documentation (online or textual) provided with the package.

  21.  *

  22.  * Redistribution and use in source and binary forms, with or without

  23.  * modification, are permitted provided that the following conditions

  24.  * are met:

  25.  * 1. Redistributions of source code must retain the copyright

  26.  *    notice, this list of conditions and the following disclaimer.

  27.  * 2. Redistributions in binary form must reproduce the above copyright

  28.  *    notice, this list of conditions and the following disclaimer in the

  29.  *    documentation and/or other materials provided with the distribution.

  30.  * 3. All advertising materials mentioning features or use of this software

  31.  *    must display the following acknowledgement:

  32.  *    "This product includes cryptographic software written by

  33.  *     Eric Young (eay@cryptsoft.com)"

  34.  *    The word 'cryptographic' can be left out if the rouines from the library

  35.  *    being used are not cryptographic related :-).

  36.  * 4. If you include any Windows specific code (or a derivative thereof) from

  37.  *    the apps directory (application code) you must include an acknowledgement:

  38.  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"

  39.  *

  40.  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND

  41.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

  42.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

  43.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE

  44.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

  45.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

  46.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

  47.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

  48.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

  49.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

  50.  * SUCH DAMAGE.

  51.  *

  52.  * The licence and distribution terms for any publically available version or

  53.  * derivative of this code cannot be changed.  i.e. this code cannot simply be

  54.  * copied and put under another distribution licence

  55.  * [including the GNU Public Licence.] */

  56. 

  57. #include <openssl/md5.h>

  58. 

  59. #include <string.h>

  60. 

  61. #include <openssl/mem.h>

  62. 

  63. 

  64. uint8_t *MD5(const uint8_t *data, size_t len, uint8_t *out) {

  65.   MD5_CTX ctx;

  66.   static uint8_t digest[MD5_DIGEST_LENGTH];

  67. 

  68.   /* TODO(fork): remove this static buffer. */

  69.   if (out == NULL) {

  70.     out = digest;

  71.   }

  72. 

  73.   MD5_Init(&ctx);

  74.   MD5_Update(&ctx, data, len);

  75.   MD5_Final(out, &ctx);

  76. 

  77.   return out;

  78. }

  79. 

  80. int MD5_Init(MD5_CTX *md5) {

  81.   memset(md5, 0, sizeof(MD5_CTX));

  82.   md5->h[0] = 0x67452301UL;

  83.   md5->h[1] = 0xefcdab89UL;

  84.   md5->h[2] = 0x98badcfeUL;

  85.   md5->h[3] = 0x10325476UL;

  86.   return 1;

  87. }

  88. 

  89. #if !defined(OPENSSL_NO_ASM) && \

  90.     (defined(OPENSSL_X86_64) || defined(OPENSSL_X86))

  91. #define MD5_ASM

  92. #define md5_block_data_order md5_block_asm_data_order

  93. #endif

  94. 

  95. 

  96. void md5_block_data_order(uint32_t *state, const uint8_t *data, size_t num);

  97. 

  98. #define DATA_ORDER_IS_LITTLE_ENDIAN

  99. 

  100. #define HASH_CTX MD5_CTX

  101. #define HASH_CBLOCK 64

  102. #define HASH_UPDATE MD5_Update

  103. #define HASH_TRANSFORM MD5_Transform

  104. #define HASH_FINAL MD5_Final

  105. #define HASH_MAKE_STRING(c, s) \

  106.   do {                         \

  107.     uint32_t ll;               \

  108.     ll = (c)->h[0];            \

  109.     HOST_l2c(ll, (s));         \

  110.     ll = (c)->h[1];            \

  111.     HOST_l2c(ll, (s));         \

  112.     ll = (c)->h[2];            \

  113.     HOST_l2c(ll, (s));         \

  114.     ll = (c)->h[3];            \

  115.     HOST_l2c(ll, (s));         \

  116.   } while (0)

  117. #define HASH_BLOCK_DATA_ORDER md5_block_data_order

  118. 

  119. #include "../digest/md32_common.h"

  120. 

  121. /* As pointed out by Wei Dai <weidai@eskimo.com>, the above can be

  122.  * simplified to the code below.  Wei attributes these optimizations

  123.  * to Peter Gutmann's SHS code, and he attributes it to Rich Schroeppel.

  124.  */

  125. #define	F(b,c,d)	((((c) ^ (d)) & (b)) ^ (d))

  126. #define	G(b,c,d)	((((b) ^ (c)) & (d)) ^ (c))

  127. #define	H(b,c,d)	((b) ^ (c) ^ (d))

  128. #define	I(b,c,d)	(((~(d)) | (b)) ^ (c))

  129. 

  130. #define ROTATE(a, n) (((a) << (n)) | ((a) >> (32 - (n))))

  131. 

  132. #define R0(a,b,c,d,k,s,t) { \

  133. 	a+=((k)+(t)+F((b),(c),(d))); \

  134. 	a=ROTATE(a,s); \

  135. 	a+=b; };\

  136. 

  137. #define R1(a,b,c,d,k,s,t) { \

  138. 	a+=((k)+(t)+G((b),(c),(d))); \

  139. 	a=ROTATE(a,s); \

  140. 	a+=b; };

  141. 

  142. #define R2(a,b,c,d,k,s,t) { \

  143. 	a+=((k)+(t)+H((b),(c),(d))); \

  144. 	a=ROTATE(a,s); \

  145. 	a+=b; };

  146. 

  147. #define R3(a,b,c,d,k,s,t) { \

  148. 	a+=((k)+(t)+I((b),(c),(d))); \

  149. 	a=ROTATE(a,s); \

  150. 	a+=b; };

  151. 

  152. #ifndef md5_block_data_order

  153. #ifdef X

  154. #undef X

  155. #endif

  156. void md5_block_data_order(uint32_t *state, const uint8_t *data, size_t num) {

  157.   uint32_t A, B, C, D, l;

  158.   uint32_t XX0, XX1, XX2, XX3, XX4, XX5, XX6, XX7, XX8, XX9, XX10, XX11, XX12,

  159.       XX13, XX14, XX15;

  160. #define X(i) XX##i

  161. 

  162.   A = state[0];

  163.   B = state[1];

  164.   C = state[2];

  165.   D = state[3];

  166. 

  167.   for (; num--;) {

  168.     HOST_c2l(data, l);

  169.     X(0) = l;

  170.     HOST_c2l(data, l);

  171.     X(1) = l;

  172.     /* Round 0 */

  173.     R0(A, B, C, D, X(0), 7, 0xd76aa478L);

  174.     HOST_c2l(data, l);

  175.     X(2) = l;

  176.     R0(D, A, B, C, X(1), 12, 0xe8c7b756L);

  177.     HOST_c2l(data, l);

  178.     X(3) = l;

  179.     R0(C, D, A, B, X(2), 17, 0x242070dbL);

  180.     HOST_c2l(data, l);

  181.     X(4) = l;

  182.     R0(B, C, D, A, X(3), 22, 0xc1bdceeeL);

  183.     HOST_c2l(data, l);

  184.     X(5) = l;

  185.     R0(A, B, C, D, X(4), 7, 0xf57c0fafL);

  186.     HOST_c2l(data, l);

  187.     X(6) = l;

  188.     R0(D, A, B, C, X(5), 12, 0x4787c62aL);

  189.     HOST_c2l(data, l);

  190.     X(7) = l;

  191.     R0(C, D, A, B, X(6), 17, 0xa8304613L);

  192.     HOST_c2l(data, l);

  193.     X(8) = l;

  194.     R0(B, C, D, A, X(7), 22, 0xfd469501L);

  195.     HOST_c2l(data, l);

  196.     X(9) = l;

  197.     R0(A, B, C, D, X(8), 7, 0x698098d8L);

  198.     HOST_c2l(data, l);

  199.     X(10) = l;

  200.     R0(D, A, B, C, X(9), 12, 0x8b44f7afL);

  201.     HOST_c2l(data, l);

  202.     X(11) = l;

  203.     R0(C, D, A, B, X(10), 17, 0xffff5bb1L);

  204.     HOST_c2l(data, l);

  205.     X(12) = l;

  206.     R0(B, C, D, A, X(11), 22, 0x895cd7beL);

  207.     HOST_c2l(data, l);

  208.     X(13) = l;

  209.     R0(A, B, C, D, X(12), 7, 0x6b901122L);

  210.     HOST_c2l(data, l);

  211.     X(14) = l;

  212.     R0(D, A, B, C, X(13), 12, 0xfd987193L);

  213.     HOST_c2l(data, l);

  214.     X(15) = l;

  215.     R0(C, D, A, B, X(14), 17, 0xa679438eL);

  216.     R0(B, C, D, A, X(15), 22, 0x49b40821L);

  217.     /* Round 1 */

  218.     R1(A, B, C, D, X(1), 5, 0xf61e2562L);

  219.     R1(D, A, B, C, X(6), 9, 0xc040b340L);

  220.     R1(C, D, A, B, X(11), 14, 0x265e5a51L);

  221.     R1(B, C, D, A, X(0), 20, 0xe9b6c7aaL);

  222.     R1(A, B, C, D, X(5), 5, 0xd62f105dL);

  223.     R1(D, A, B, C, X(10), 9, 0x02441453L);

  224.     R1(C, D, A, B, X(15), 14, 0xd8a1e681L);

  225.     R1(B, C, D, A, X(4), 20, 0xe7d3fbc8L);

  226.     R1(A, B, C, D, X(9), 5, 0x21e1cde6L);

  227.     R1(D, A, B, C, X(14), 9, 0xc33707d6L);

  228.     R1(C, D, A, B, X(3), 14, 0xf4d50d87L);

  229.     R1(B, C, D, A, X(8), 20, 0x455a14edL);

  230.     R1(A, B, C, D, X(13), 5, 0xa9e3e905L);

  231.     R1(D, A, B, C, X(2), 9, 0xfcefa3f8L);

  232.     R1(C, D, A, B, X(7), 14, 0x676f02d9L);

  233.     R1(B, C, D, A, X(12), 20, 0x8d2a4c8aL);

  234.     /* Round 2 */

  235.     R2(A, B, C, D, X(5), 4, 0xfffa3942L);

  236.     R2(D, A, B, C, X(8), 11, 0x8771f681L);

  237.     R2(C, D, A, B, X(11), 16, 0x6d9d6122L);

  238.     R2(B, C, D, A, X(14), 23, 0xfde5380cL);

  239.     R2(A, B, C, D, X(1), 4, 0xa4beea44L);

  240.     R2(D, A, B, C, X(4), 11, 0x4bdecfa9L);

  241.     R2(C, D, A, B, X(7), 16, 0xf6bb4b60L);

  242.     R2(B, C, D, A, X(10), 23, 0xbebfbc70L);

  243.     R2(A, B, C, D, X(13), 4, 0x289b7ec6L);

  244.     R2(D, A, B, C, X(0), 11, 0xeaa127faL);

  245.     R2(C, D, A, B, X(3), 16, 0xd4ef3085L);

  246.     R2(B, C, D, A, X(6), 23, 0x04881d05L);

  247.     R2(A, B, C, D, X(9), 4, 0xd9d4d039L);

  248.     R2(D, A, B, C, X(12), 11, 0xe6db99e5L);

  249.     R2(C, D, A, B, X(15), 16, 0x1fa27cf8L);

  250.     R2(B, C, D, A, X(2), 23, 0xc4ac5665L);

  251.     /* Round 3 */

  252.     R3(A, B, C, D, X(0), 6, 0xf4292244L);

  253.     R3(D, A, B, C, X(7), 10, 0x432aff97L);

  254.     R3(C, D, A, B, X(14), 15, 0xab9423a7L);

  255.     R3(B, C, D, A, X(5), 21, 0xfc93a039L);

  256.     R3(A, B, C, D, X(12), 6, 0x655b59c3L);

  257.     R3(D, A, B, C, X(3), 10, 0x8f0ccc92L);

  258.     R3(C, D, A, B, X(10), 15, 0xffeff47dL);

  259.     R3(B, C, D, A, X(1), 21, 0x85845dd1L);

  260.     R3(A, B, C, D, X(8), 6, 0x6fa87e4fL);

  261.     R3(D, A, B, C, X(15), 10, 0xfe2ce6e0L);

  262.     R3(C, D, A, B, X(6), 15, 0xa3014314L);

  263.     R3(B, C, D, A, X(13), 21, 0x4e0811a1L);

  264.     R3(A, B, C, D, X(4), 6, 0xf7537e82L);

  265.     R3(D, A, B, C, X(11), 10, 0xbd3af235L);

  266.     R3(C, D, A, B, X(2), 15, 0x2ad7d2bbL);

  267.     R3(B, C, D, A, X(9), 21, 0xeb86d391L);

  268. 

  269.     A = state[0] += A;

  270.     B = state[1] += B;

  271.     C = state[2] += C;

  272.     D = state[3] += D;

  273.   }

  274. }

  275. #endif