1 /*
2 * Copyright 2014-2022 The GmSSL Project. All Rights Reserved.
3 *
4 * Licensed under the Apache License, Version 2.0 (the License); you may
5 * not use this file except in compliance with the License.
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 */
9
10
11
12 #include <string.h>
13 #include <gmssl/md5.h>
14 #include <gmssl/endian.h>
15
16
17 #define F(B, C, D) (((B) & (C)) | ((~(B)) & (D)))
18 #define G(B, C, D) (((B) & (D)) | ((C) & (~(D))))
19 #define H(B, C, D) ((B) ^ (C) ^ (D))
20 #define I(B, C, D) ((C) ^ ((B) | (~(D))))
21
22 static const uint32_t K[] = {
23 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
24 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
25 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
26 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
27 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
28 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
29 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
30 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
31 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
32 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
33 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05,
34 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
35 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
36 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
37 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
38 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391,
39 };
40
41 static const int S[] = {
42 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22,
43 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20,
44 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23,
45 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21,
46 };
47
md5_compress_blocks(uint32_t state[4],const unsigned char * data,size_t blocks)48 static void md5_compress_blocks(uint32_t state[4],
49 const unsigned char *data, size_t blocks)
50 {
51 uint32_t A;
52 uint32_t B;
53 uint32_t C;
54 uint32_t D;
55 uint32_t T;
56 uint32_t W[16];
57 int g, i;
58
59 while (blocks--) {
60
61 A = state[0];
62 B = state[1];
63 C = state[2];
64 D = state[3];
65
66 for (i = 0; i < 16; i++) {
67 W[i] = GETU32_LE(data);
68 data += sizeof(uint32_t);
69 }
70
71 for (i = 0; i < 16; i++) {
72 T = ROL32(A + F(B, C, D) + W[i] + K[i], S[i]) + B;
73 A = D;
74 D = C;
75 C = B;
76 B = T;
77 }
78 for (; i < 32; i++) {
79 g = (5 * i + 1) % 16;
80 T = ROL32(A + G(B, C, D) + W[g] + K[i], S[i]) + B;
81 A = D;
82 D = C;
83 C = B;
84 B = T;
85 }
86 for (; i < 48; i++) {
87 g = (3 * i + 5) % 16;
88 T = ROL32(A + H(B, C, D) + W[g] + K[i], S[i]) + B;
89 A = D;
90 D = C;
91 C = B;
92 B = T;
93 }
94 for (; i < 64; i++) {
95 g = (7 * i) % 16;
96 T = ROL32(A + I(B, C, D) + W[g] + K[i], S[i]) + B;
97 A = D;
98 D = C;
99 C = B;
100 B = T;
101 }
102
103 state[0] += A;
104 state[1] += B;
105 state[2] += C;
106 state[3] += D;
107 }
108 }
109
md5_init(MD5_CTX * ctx)110 void md5_init(MD5_CTX *ctx)
111 {
112 memset(ctx, 0, sizeof(*ctx));
113 ctx->state[0] = 0x67452301;
114 ctx->state[1] = 0xefcdab89;
115 ctx->state[2] = 0x98badcfe;
116 ctx->state[3] = 0x10325476;
117 }
118
md5_update(MD5_CTX * ctx,const unsigned char * data,size_t datalen)119 void md5_update(MD5_CTX *ctx, const unsigned char *data, size_t datalen)
120 {
121 size_t blocks;
122
123 ctx->num &= 0x3f;
124 if (ctx->num) {
125 size_t left = MD5_BLOCK_SIZE - ctx->num;
126 if (datalen < left) {
127 memcpy(ctx->block + ctx->num, data, datalen);
128 ctx->num += datalen;
129 return;
130 } else {
131 memcpy(ctx->block + ctx->num, data, left);
132 md5_compress_blocks(ctx->state, ctx->block, 1);
133 ctx->nblocks++;
134 data += left;
135 datalen -= left;
136 }
137 }
138
139 blocks = datalen / MD5_BLOCK_SIZE;
140 md5_compress_blocks(ctx->state, data, blocks);
141 ctx->nblocks += blocks;
142 data += MD5_BLOCK_SIZE * blocks;
143 datalen -= MD5_BLOCK_SIZE * blocks;
144
145 ctx->num = datalen;
146 if (datalen) {
147 memcpy(ctx->block, data, datalen);
148 }
149 }
150
md5_finish(MD5_CTX * ctx,unsigned char * dgst)151 void md5_finish(MD5_CTX *ctx, unsigned char *dgst)
152 {
153 int i;
154
155 ctx->num &= 0x3f;
156 ctx->block[ctx->num] = 0x80;
157
158 if (ctx->num <= MD5_BLOCK_SIZE - 9) {
159 memset(ctx->block + ctx->num + 1, 0, MD5_BLOCK_SIZE - ctx->num - 9);
160 } else {
161 memset(ctx->block + ctx->num + 1, 0, MD5_BLOCK_SIZE - ctx->num - 1);
162 md5_compress_blocks(ctx->state, ctx->block, 1);
163 memset(ctx->block, 0, MD5_BLOCK_SIZE - 8);
164 }
165 PUTU64_LE(ctx->block + 56, (ctx->nblocks << 9) + (ctx->num << 3));
166 md5_compress_blocks(ctx->state, ctx->block, 1);
167 for (i = 0; i < 4; i++) {
168 PUTU32_LE(dgst, ctx->state[i]);
169 dgst += sizeof(uint32_t);
170 }
171 memset(ctx, 0, sizeof(*ctx));
172 }
173
md5_digest(const unsigned char * data,size_t datalen,unsigned char dgst[MD5_DIGEST_SIZE])174 void md5_digest(const unsigned char *data, size_t datalen,
175 unsigned char dgst[MD5_DIGEST_SIZE])
176 {
177 MD5_CTX ctx;
178 md5_init(&ctx);
179 md5_update(&ctx, data, datalen);
180 md5_finish(&ctx, dgst);
181 }
182