1 | /* These are the four functions used in the four steps of the MD5 algorithm |
---|---|

2 | and defined in the RFC 1321. The first function is a little bit optimized |

3 | (as found in Colin Plumbs public domain implementation). */ |

4 | /* #define FF(b, c, d) ((b & c) | (~b & d)) */ |

5 | #define FF(b, c, d) (d ^ (b & (c ^ d))) |

6 | #define FG(b, c, d) FF (d, b, c) |

7 | #define FH(b, c, d) (b ^ c ^ d) |

8 | #define FI(b, c, d) (c ^ (b | ~d)) |

9 | |

10 | /* Process LEN bytes of BUFFER, accumulating context into CTX. |

11 | It is assumed that LEN % 64 == 0. */ |

12 | |

13 | void |

14 | __md5_process_block (const void *buffer, size_t len, struct md5_ctx *ctx) |

15 | { |

16 | md5_uint32 correct_words[16]; |

17 | const md5_uint32 *words = buffer; |

18 | size_t nwords = len / sizeof (md5_uint32); |

19 | const md5_uint32 *endp = words + nwords; |

20 | md5_uint32 A = ctx->A; |

21 | md5_uint32 B = ctx->B; |

22 | md5_uint32 C = ctx->C; |

23 | md5_uint32 D = ctx->D; |

24 | md5_uint32 lolen = len; |

25 | |

26 | /* First increment the byte count. RFC 1321 specifies the possible |

27 | length of the file up to 2^64 bits. Here we only compute the |

28 | number of bytes. Do a double word increment. */ |

29 | ctx->total[0] += lolen; |

30 | ctx->total[1] += (len >> 31 >> 1) + (ctx->total[0] < lolen); |

31 | |

32 | /* Process all bytes in the buffer with 64 bytes in each round of |

33 | the loop. */ |

34 | while (words < endp) |

35 | { |

36 | md5_uint32 *cwp = correct_words; |

37 | md5_uint32 A_save = A; |

38 | md5_uint32 B_save = B; |

39 | md5_uint32 C_save = C; |

40 | md5_uint32 D_save = D; |

41 | |

42 | /* First round: using the given function, the context and a constant |

43 | the next context is computed. Because the algorithms processing |

44 | unit is a 32-bit word and it is determined to work on words in |

45 | little endian byte order we perhaps have to change the byte order |

46 | before the computation. To reduce the work for the next steps |

47 | we store the swapped words in the array CORRECT_WORDS. */ |

48 | |

49 | #define OP(a, b, c, d, s, T) \ |

50 | do \ |

51 | { \ |

52 | a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T; \ |

53 | ++words; \ |

54 | CYCLIC (a, s); \ |

55 | a += b; \ |

56 | } \ |

57 | while (0) |

58 | |

59 | /* It is unfortunate that C does not provide an operator for |

60 | cyclic rotation. Hope the C compiler is smart enough. */ |

61 | #define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s))) |

62 | |

63 | /* Before we start, one word to the strange constants. |

64 | They are defined in RFC 1321 as |

65 | |

66 | T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64 |

67 | */ |

68 | |

69 | /* Round 1. */ |

70 | OP (A, B, C, D, 7, 0xd76aa478); |

71 | OP (D, A, B, C, 12, 0xe8c7b756); |

72 | OP (C, D, A, B, 17, 0x242070db); |

73 | OP (B, C, D, A, 22, 0xc1bdceee); |

74 | OP (A, B, C, D, 7, 0xf57c0faf); |

75 | OP (D, A, B, C, 12, 0x4787c62a); |

76 | OP (C, D, A, B, 17, 0xa8304613); |

77 | OP (B, C, D, A, 22, 0xfd469501); |

78 | OP (A, B, C, D, 7, 0x698098d8); |

79 | OP (D, A, B, C, 12, 0x8b44f7af); |

80 | OP (C, D, A, B, 17, 0xffff5bb1); |

81 | OP (B, C, D, A, 22, 0x895cd7be); |

82 | OP (A, B, C, D, 7, 0x6b901122); |

83 | OP (D, A, B, C, 12, 0xfd987193); |

84 | OP (C, D, A, B, 17, 0xa679438e); |

85 | OP (B, C, D, A, 22, 0x49b40821); |

86 | |

87 | /* For the second to fourth round we have the possibly swapped words |

88 | in CORRECT_WORDS. Redefine the macro to take an additional first |

89 | argument specifying the function to use. */ |

90 | #undef OP |

91 | #define OP(f, a, b, c, d, k, s, T) \ |

92 | do \ |

93 | { \ |

94 | a += f (b, c, d) + correct_words[k] + T; \ |

95 | CYCLIC (a, s); \ |

96 | a += b; \ |

97 | } \ |

98 | while (0) |

99 | |

100 | /* Round 2. */ |

101 | OP (FG, A, B, C, D, 1, 5, 0xf61e2562); |

102 | OP (FG, D, A, B, C, 6, 9, 0xc040b340); |

103 | OP (FG, C, D, A, B, 11, 14, 0x265e5a51); |

104 | OP (FG, B, C, D, A, 0, 20, 0xe9b6c7aa); |

105 | OP (FG, A, B, C, D, 5, 5, 0xd62f105d); |

106 | OP (FG, D, A, B, C, 10, 9, 0x02441453); |

107 | OP (FG, C, D, A, B, 15, 14, 0xd8a1e681); |

108 | OP (FG, B, C, D, A, 4, 20, 0xe7d3fbc8); |

109 | OP (FG, A, B, C, D, 9, 5, 0x21e1cde6); |

110 | OP (FG, D, A, B, C, 14, 9, 0xc33707d6); |

111 | OP (FG, C, D, A, B, 3, 14, 0xf4d50d87); |

112 | OP (FG, B, C, D, A, 8, 20, 0x455a14ed); |

113 | OP (FG, A, B, C, D, 13, 5, 0xa9e3e905); |

114 | OP (FG, D, A, B, C, 2, 9, 0xfcefa3f8); |

115 | OP (FG, C, D, A, B, 7, 14, 0x676f02d9); |

116 | OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a); |

117 | |

118 | /* Round 3. */ |

119 | OP (FH, A, B, C, D, 5, 4, 0xfffa3942); |

120 | OP (FH, D, A, B, C, 8, 11, 0x8771f681); |

121 | OP (FH, C, D, A, B, 11, 16, 0x6d9d6122); |

122 | OP (FH, B, C, D, A, 14, 23, 0xfde5380c); |

123 | OP (FH, A, B, C, D, 1, 4, 0xa4beea44); |

124 | OP (FH, D, A, B, C, 4, 11, 0x4bdecfa9); |

125 | OP (FH, C, D, A, B, 7, 16, 0xf6bb4b60); |

126 | OP (FH, B, C, D, A, 10, 23, 0xbebfbc70); |

127 | OP (FH, A, B, C, D, 13, 4, 0x289b7ec6); |

128 | OP (FH, D, A, B, C, 0, 11, 0xeaa127fa); |

129 | OP (FH, C, D, A, B, 3, 16, 0xd4ef3085); |

130 | OP (FH, B, C, D, A, 6, 23, 0x04881d05); |

131 | OP (FH, A, B, C, D, 9, 4, 0xd9d4d039); |

132 | OP (FH, D, A, B, C, 12, 11, 0xe6db99e5); |

133 | OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8); |

134 | OP (FH, B, C, D, A, 2, 23, 0xc4ac5665); |

135 | |

136 | /* Round 4. */ |

137 | OP (FI, A, B, C, D, 0, 6, 0xf4292244); |

138 | OP (FI, D, A, B, C, 7, 10, 0x432aff97); |

139 | OP (FI, C, D, A, B, 14, 15, 0xab9423a7); |

140 | OP (FI, B, C, D, A, 5, 21, 0xfc93a039); |

141 | OP (FI, A, B, C, D, 12, 6, 0x655b59c3); |

142 | OP (FI, D, A, B, C, 3, 10, 0x8f0ccc92); |

143 | OP (FI, C, D, A, B, 10, 15, 0xffeff47d); |

144 | OP (FI, B, C, D, A, 1, 21, 0x85845dd1); |

145 | OP (FI, A, B, C, D, 8, 6, 0x6fa87e4f); |

146 | OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0); |

147 | OP (FI, C, D, A, B, 6, 15, 0xa3014314); |

148 | OP (FI, B, C, D, A, 13, 21, 0x4e0811a1); |

149 | OP (FI, A, B, C, D, 4, 6, 0xf7537e82); |

150 | OP (FI, D, A, B, C, 11, 10, 0xbd3af235); |

151 | OP (FI, C, D, A, B, 2, 15, 0x2ad7d2bb); |

152 | OP (FI, B, C, D, A, 9, 21, 0xeb86d391); |

153 | |

154 | /* Add the starting values of the context. */ |

155 | A += A_save; |

156 | B += B_save; |

157 | C += C_save; |

158 | D += D_save; |

159 | } |

160 | |

161 | /* Put checksum in context given as argument. */ |

162 | ctx->A = A; |

163 | ctx->B = B; |

164 | ctx->C = C; |

165 | ctx->D = D; |

166 | } |

167 |