Mercurial > hg > xmms-sid

comparison src/xs_md5.c @ 359:b1a858b8cb1a

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Re-indentation all (non-generated) code.
author Matti Hamalainen <ccr@tnsp.org>
date Mon, 07 Nov 2005 09:50:04 +0000
parents 70ab1c28d4b2
children a3fdd2d6c056
comparison
equal deleted inserted replaced
358:4f247b19c9ea 359:b1a858b8cb1a
117 #define T64 0xeb86d391 117 #define T64 0xeb86d391
118 118
119 119
120 static void xs_md5_process(t_xs_md5state * pms, const guint8 * data) 120 static void xs_md5_process(t_xs_md5state * pms, const guint8 * data)
121 { 121 {
122 guint32 a = pms->abcd[0], b = pms->abcd[1], c = pms->abcd[2], d = pms->abcd[3]; 122 guint32 a = pms->abcd[0], b = pms->abcd[1], c = pms->abcd[2], d = pms->abcd[3];
123 guint32 t; 123 guint32 t;
124 guint32 X[16]; 124 guint32 X[16];
125 const guint8 *xp = data; 125 const guint8 *xp = data;
126 gint i; 126 gint i;
127 127
128 for (i = 0; i < 16; ++i, xp += 4) 128 for (i = 0; i < 16; ++i, xp += 4)
129 X[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24); 129 X[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24);
130 130
131 131
132 /* 132 /*
133 * Round 1. Let [abcd k s i] denote the operation 133 * Round 1. Let [abcd k s i] denote the operation
134 * a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). 134 * a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s).
135 */ 135 */
136 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n)))) 136 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
137 #define F(x, y, z) (((x) & (y)) | (~(x) & (z))) 137 #define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
138 #define SET(a, b, c, d, k, s, Ti)\ 138 #define SET(a, b, c, d, k, s, Ti)\
139 t = a + F(b,c,d) + X[k] + Ti;\ 139 t = a + F(b,c,d) + X[k] + Ti;\
140 a = ROTATE_LEFT(t, s) + b 140 a = ROTATE_LEFT(t, s) + b
141 141
142 /* Do the following 16 operations. */ 142 /* Do the following 16 operations. */
143 SET(a, b, c, d, 0, 7, T1); 143 SET(a, b, c, d, 0, 7, T1);
144 SET(d, a, b, c, 1, 12, T2); 144 SET(d, a, b, c, 1, 12, T2);
145 SET(c, d, a, b, 2, 17, T3); 145 SET(c, d, a, b, 2, 17, T3);
146 SET(b, c, d, a, 3, 22, T4); 146 SET(b, c, d, a, 3, 22, T4);
147 SET(a, b, c, d, 4, 7, T5); 147 SET(a, b, c, d, 4, 7, T5);
148 SET(d, a, b, c, 5, 12, T6); 148 SET(d, a, b, c, 5, 12, T6);
149 SET(c, d, a, b, 6, 17, T7); 149 SET(c, d, a, b, 6, 17, T7);
150 SET(b, c, d, a, 7, 22, T8); 150 SET(b, c, d, a, 7, 22, T8);
151 SET(a, b, c, d, 8, 7, T9); 151 SET(a, b, c, d, 8, 7, T9);
152 SET(d, a, b, c, 9, 12, T10); 152 SET(d, a, b, c, 9, 12, T10);
153 SET(c, d, a, b, 10, 17, T11); 153 SET(c, d, a, b, 10, 17, T11);
154 SET(b, c, d, a, 11, 22, T12); 154 SET(b, c, d, a, 11, 22, T12);
155 SET(a, b, c, d, 12, 7, T13); 155 SET(a, b, c, d, 12, 7, T13);
156 SET(d, a, b, c, 13, 12, T14); 156 SET(d, a, b, c, 13, 12, T14);
157 SET(c, d, a, b, 14, 17, T15); 157 SET(c, d, a, b, 14, 17, T15);
158 SET(b, c, d, a, 15, 22, T16); 158 SET(b, c, d, a, 15, 22, T16);
159 159
160 #undef SET 160 #undef SET
161 161
162 /* 162 /*
163 * Round 2. Let [abcd k s i] denote the operation 163 * Round 2. Let [abcd k s i] denote the operation
164 * a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). 164 * a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s).
165 */ 165 */
166 #define G(x, y, z) (((x) & (z)) | ((y) & ~(z))) 166 #define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
167 #define SET(a, b, c, d, k, s, Ti)\ 167 #define SET(a, b, c, d, k, s, Ti)\
168 t = a + G(b,c,d) + X[k] + Ti;\ 168 t = a + G(b,c,d) + X[k] + Ti;\
169 a = ROTATE_LEFT(t, s) + b 169 a = ROTATE_LEFT(t, s) + b
170 170
171 /* Do the following 16 operations. */ 171 /* Do the following 16 operations. */
172 SET(a, b, c, d, 1, 5, T17); 172 SET(a, b, c, d, 1, 5, T17);
173 SET(d, a, b, c, 6, 9, T18); 173 SET(d, a, b, c, 6, 9, T18);
174 SET(c, d, a, b, 11, 14, T19); 174 SET(c, d, a, b, 11, 14, T19);
175 SET(b, c, d, a, 0, 20, T20); 175 SET(b, c, d, a, 0, 20, T20);
176 SET(a, b, c, d, 5, 5, T21); 176 SET(a, b, c, d, 5, 5, T21);
177 SET(d, a, b, c, 10, 9, T22); 177 SET(d, a, b, c, 10, 9, T22);
178 SET(c, d, a, b, 15, 14, T23); 178 SET(c, d, a, b, 15, 14, T23);
179 SET(b, c, d, a, 4, 20, T24); 179 SET(b, c, d, a, 4, 20, T24);
180 SET(a, b, c, d, 9, 5, T25); 180 SET(a, b, c, d, 9, 5, T25);
181 SET(d, a, b, c, 14, 9, T26); 181 SET(d, a, b, c, 14, 9, T26);
182 SET(c, d, a, b, 3, 14, T27); 182 SET(c, d, a, b, 3, 14, T27);
183 SET(b, c, d, a, 8, 20, T28); 183 SET(b, c, d, a, 8, 20, T28);
184 SET(a, b, c, d, 13, 5, T29); 184 SET(a, b, c, d, 13, 5, T29);
185 SET(d, a, b, c, 2, 9, T30); 185 SET(d, a, b, c, 2, 9, T30);
186 SET(c, d, a, b, 7, 14, T31); 186 SET(c, d, a, b, 7, 14, T31);
187 SET(b, c, d, a, 12, 20, T32); 187 SET(b, c, d, a, 12, 20, T32);
188 188
189 #undef SET 189 #undef SET
190 190
191 /* 191 /*
192 * Round 3. Let [abcd k s t] denote the operation 192 * Round 3. Let [abcd k s t] denote the operation
193 * a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). 193 * a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s).
194 */ 194 */
195 #define H(x, y, z) ((x) ^ (y) ^ (z)) 195 #define H(x, y, z) ((x) ^ (y) ^ (z))
196 #define SET(a, b, c, d, k, s, Ti)\ 196 #define SET(a, b, c, d, k, s, Ti)\
197 t = a + H(b,c,d) + X[k] + Ti;\ 197 t = a + H(b,c,d) + X[k] + Ti;\
198 a = ROTATE_LEFT(t, s) + b 198 a = ROTATE_LEFT(t, s) + b
199 199
200 /* Do the following 16 operations. */ 200 /* Do the following 16 operations. */
201 SET(a, b, c, d, 5, 4, T33); 201 SET(a, b, c, d, 5, 4, T33);
202 SET(d, a, b, c, 8, 11, T34); 202 SET(d, a, b, c, 8, 11, T34);
203 SET(c, d, a, b, 11, 16, T35); 203 SET(c, d, a, b, 11, 16, T35);
204 SET(b, c, d, a, 14, 23, T36); 204 SET(b, c, d, a, 14, 23, T36);
205 SET(a, b, c, d, 1, 4, T37); 205 SET(a, b, c, d, 1, 4, T37);
206 SET(d, a, b, c, 4, 11, T38); 206 SET(d, a, b, c, 4, 11, T38);
207 SET(c, d, a, b, 7, 16, T39); 207 SET(c, d, a, b, 7, 16, T39);
208 SET(b, c, d, a, 10, 23, T40); 208 SET(b, c, d, a, 10, 23, T40);
209 SET(a, b, c, d, 13, 4, T41); 209 SET(a, b, c, d, 13, 4, T41);
210 SET(d, a, b, c, 0, 11, T42); 210 SET(d, a, b, c, 0, 11, T42);
211 SET(c, d, a, b, 3, 16, T43); 211 SET(c, d, a, b, 3, 16, T43);
212 SET(b, c, d, a, 6, 23, T44); 212 SET(b, c, d, a, 6, 23, T44);
213 SET(a, b, c, d, 9, 4, T45); 213 SET(a, b, c, d, 9, 4, T45);
214 SET(d, a, b, c, 12, 11, T46); 214 SET(d, a, b, c, 12, 11, T46);
215 SET(c, d, a, b, 15, 16, T47); 215 SET(c, d, a, b, 15, 16, T47);
216 SET(b, c, d, a, 2, 23, T48); 216 SET(b, c, d, a, 2, 23, T48);
217 217
218 #undef SET 218 #undef SET
219 219
220 /* 220 /*
221 * Round 4. Let [abcd k s t] denote the operation 221 * Round 4. Let [abcd k s t] denote the operation
222 * a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). 222 * a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s).
223 */ 223 */
224 #define I(x, y, z) ((y) ^ ((x) | ~(z))) 224 #define I(x, y, z) ((y) ^ ((x) | ~(z)))
225 #define SET(a, b, c, d, k, s, Ti)\ 225 #define SET(a, b, c, d, k, s, Ti)\
226 t = a + I(b,c,d) + X[k] + Ti;\ 226 t = a + I(b,c,d) + X[k] + Ti;\
227 a = ROTATE_LEFT(t, s) + b 227 a = ROTATE_LEFT(t, s) + b
228 228
229 /* Do the following 16 operations. */ 229 /* Do the following 16 operations. */
230 SET(a, b, c, d, 0, 6, T49); 230 SET(a, b, c, d, 0, 6, T49);
231 SET(d, a, b, c, 7, 10, T50); 231 SET(d, a, b, c, 7, 10, T50);
232 SET(c, d, a, b, 14, 15, T51); 232 SET(c, d, a, b, 14, 15, T51);
233 SET(b, c, d, a, 5, 21, T52); 233 SET(b, c, d, a, 5, 21, T52);
234 SET(a, b, c, d, 12, 6, T53); 234 SET(a, b, c, d, 12, 6, T53);
235 SET(d, a, b, c, 3, 10, T54); 235 SET(d, a, b, c, 3, 10, T54);
236 SET(c, d, a, b, 10, 15, T55); 236 SET(c, d, a, b, 10, 15, T55);
237 SET(b, c, d, a, 1, 21, T56); 237 SET(b, c, d, a, 1, 21, T56);
238 SET(a, b, c, d, 8, 6, T57); 238 SET(a, b, c, d, 8, 6, T57);
239 SET(d, a, b, c, 15, 10, T58); 239 SET(d, a, b, c, 15, 10, T58);
240 SET(c, d, a, b, 6, 15, T59); 240 SET(c, d, a, b, 6, 15, T59);
241 SET(b, c, d, a, 13, 21, T60); 241 SET(b, c, d, a, 13, 21, T60);
242 SET(a, b, c, d, 4, 6, T61); 242 SET(a, b, c, d, 4, 6, T61);
243 SET(d, a, b, c, 11, 10, T62); 243 SET(d, a, b, c, 11, 10, T62);
244 SET(c, d, a, b, 2, 15, T63); 244 SET(c, d, a, b, 2, 15, T63);
245 SET(b, c, d, a, 9, 21, T64); 245 SET(b, c, d, a, 9, 21, T64);
246 246
247 #undef SET 247 #undef SET
248 248
249 /* 249 /*
250 * Then perform the following additions. (That is increment each 250 * Then perform the following additions. (That is increment each
251 * of the four registers by the value it had before this block was started.) 251 * of the four registers by the value it had before this block was started.)
252 */ 252 */
253 pms->abcd[0] += a; 253 pms->abcd[0] += a;
254 pms->abcd[1] += b; 254 pms->abcd[1] += b;
255 pms->abcd[2] += c; 255 pms->abcd[2] += c;
256 pms->abcd[3] += d; 256 pms->abcd[3] += d;
257 } 257 }
258 258
259 259
260 void xs_md5_init(t_xs_md5state * pms) 260 void xs_md5_init(t_xs_md5state * pms)
261 { 261 {
262 pms->count[0] = pms->count[1] = 0; 262 pms->count[0] = pms->count[1] = 0;
263 pms->abcd[0] = 0x67452301; 263 pms->abcd[0] = 0x67452301;
264 pms->abcd[1] = 0xefcdab89; 264 pms->abcd[1] = 0xefcdab89;
265 pms->abcd[2] = 0x98badcfe; 265 pms->abcd[2] = 0x98badcfe;
266 pms->abcd[3] = 0x10325476; 266 pms->abcd[3] = 0x10325476;
267 } 267 }
268 268
269 269
270 void xs_md5_append(t_xs_md5state * pms, const guint8 * data, int nbytes) 270 void xs_md5_append(t_xs_md5state * pms, const guint8 * data, int nbytes)
271 { 271 {
272 const guint8 *p = data; 272 const guint8 *p = data;
273 gint left = nbytes; 273 gint left = nbytes;
274 gint offset = (pms->count[0] >> 3) & 63; 274 gint offset = (pms->count[0] >> 3) & 63;
275 guint32 nbits = (guint32) (nbytes << 3); 275 guint32 nbits = (guint32) (nbytes << 3);
276 276
277 if (nbytes <= 0) 277 if (nbytes <= 0)
278 return;
279
280 /* Update the message length. */
281 pms->count[1] += nbytes >> 29;
282 pms->count[0] += nbits;
283 if (pms->count[0] < nbits)
284 pms->count[1]++;
285
286 /* Process an initial partial block. */
287 if (offset)
288 {
289 int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
290
291 memcpy(pms->buf + offset, p, copy);
292
293 if (offset + copy < 64)
294 return; 278 return;
295 279
296 p += copy; 280 /* Update the message length. */
297 left -= copy; 281 pms->count[1] += nbytes >> 29;
298 xs_md5_process(pms, pms->buf); 282 pms->count[0] += nbits;
283 if (pms->count[0] < nbits)
284 pms->count[1]++;
285
286 /* Process an initial partial block. */
287 if (offset) {
288 int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
289
290 memcpy(pms->buf + offset, p, copy);
291
292 if (offset + copy < 64)
293 return;
294
295 p += copy;
296 left -= copy;
297 xs_md5_process(pms, pms->buf);
299 } 298 }
300 299
301 /* Process full blocks. */ 300 /* Process full blocks. */
302 for (; left >= 64; p += 64, left -= 64) 301 for (; left >= 64; p += 64, left -= 64)
303 xs_md5_process(pms, p); 302 xs_md5_process(pms, p);
304 303
305 /* Process a final partial block. */ 304 /* Process a final partial block. */
306 if (left) 305 if (left)
307 memcpy(pms->buf, p, left); 306 memcpy(pms->buf, p, left);
308 } 307 }
309 308
310 309
311 void xs_md5_finish(t_xs_md5state * pms, t_xs_md5hash digest) 310 void xs_md5_finish(t_xs_md5state * pms, t_xs_md5hash digest)
312 { 311 {
313 static const guint8 pad[64] = { 312 static const guint8 pad[64] = {
314 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 313 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
315 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 314 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
316 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 315 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
317 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 316 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
318 }; 317 };
319 318
320 guint8 data[8]; 319 guint8 data[8];
321 gint i; 320 gint i;
322 321
323 /* Save the length before padding. */ 322 /* Save the length before padding. */
324 for (i = 0; i < 8; ++i) 323 for (i = 0; i < 8; ++i)
325 data[i] = (guint8) (pms->count[i >> 2] >> ((i & 3) << 3)); 324 data[i] = (guint8) (pms->count[i >> 2] >> ((i & 3) << 3));
326 325
327 /* Pad to 56 bytes mod 64. */ 326 /* Pad to 56 bytes mod 64. */
328 xs_md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1); 327 xs_md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
329 328
330 /* Append the length. */ 329 /* Append the length. */
331 xs_md5_append(pms, data, 8); 330 xs_md5_append(pms, data, 8);
332 for (i = 0; i < XS_MD5HASH_LENGTH; ++i) 331 for (i = 0; i < XS_MD5HASH_LENGTH; ++i)
333 digest[i] = (guint8) (pms->abcd[i >> 2] >> ((i & 3) << 3)); 332 digest[i] = (guint8) (pms->abcd[i >> 2] >> ((i & 3) << 3));
334 } 333 }
335