third-party-mirror / GRTEv5 / refs/heads/master / . / google3 / third_party / grte / v5_src / glibc-2.27 / crypt / md5-block.c

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

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

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

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

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

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

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

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

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

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

void | |

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

{ | |

md5_uint32 correct_words[16]; | |

const md5_uint32 *words = buffer; | |

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

const md5_uint32 *endp = words + nwords; | |

md5_uint32 A = ctx->A; | |

md5_uint32 B = ctx->B; | |

md5_uint32 C = ctx->C; | |

md5_uint32 D = ctx->D; | |

md5_uint32 lolen = len; | |

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

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

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

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

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

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

the loop. */ | |

while (words < endp) | |

{ | |

md5_uint32 *cwp = correct_words; | |

md5_uint32 A_save = A; | |

md5_uint32 B_save = B; | |

md5_uint32 C_save = C; | |

md5_uint32 D_save = D; | |

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

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

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

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

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

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

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

do \ | |

{ \ | |

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

++words; \ | |

CYCLIC (a, s); \ | |

a += b; \ | |

} \ | |

while (0) | |

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

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

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

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

They are defined in RFC 1321 as | |

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

*/ | |

/* Round 1. */ | |

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

argument specifying the function to use. */ | |

#undef OP | |

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

do \ | |

{ \ | |

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

CYCLIC (a, s); \ | |

a += b; \ | |

} \ | |

while (0) | |

/* Round 2. */ | |

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/* Round 3. */ | |

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/* Round 4. */ | |

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

A += A_save; | |

B += B_save; | |

C += C_save; | |

D += D_save; | |

} | |

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

ctx->A = A; | |

ctx->B = B; | |

ctx->C = C; | |

ctx->D = D; | |

} |