1 /* gchecksum.h - data hashing functions
3 * Copyright (C) 2007 Emmanuele Bassi <ebassi@gnome.org>
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Library General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Library General Public License for more details.
15 * You should have received a copy of the GNU Library General Public
16 * License along with this library; if not, write to the
17 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 * Boston, MA 02111-1307, USA.
25 #include "gchecksum.h"
28 #include "gstrfuncs.h"
29 #include "gtestutils.h"
36 * @title: Data Checksums
37 * @short_description: Computes the checksum for data
39 * GLib provides a generic API for computing checksums (or "digests")
40 * for a sequence of arbitrary bytes, using various hashing algorithms
41 * like MD5, SHA-1 and SHA-256. Checksums are commonly used in various
42 * environments and specifications.
44 * GLib supports incremental checksums using the GChecksum data
45 * structure, by calling g_checksum_update() as long as there's data
46 * available and then using g_checksum_get_string() or
47 * g_checksum_get_digest() to compute the checksum and return it either
48 * as a string in hexadecimal form, or as a raw sequence of bytes. To
49 * compute the checksum for binary blobs and NUL-terminated strings in
50 * one go, use the convenience functions g_compute_checksum_for_data()
51 * and g_compute_checksum_for_string(), respectively.
53 * Support for checksums has been added in GLib 2.16
56 #define IS_VALID_TYPE(type) ((type) >= G_CHECKSUM_MD5 && (type) <= G_CHECKSUM_SHA256)
58 /* The fact that these are lower case characters is part of the ABI */
59 static const gchar hex_digits[] = "0123456789abcdef";
61 #define MD5_DATASIZE 64
62 #define MD5_DIGEST_LEN 16
69 guchar data[MD5_DATASIZE];
71 guchar digest[MD5_DIGEST_LEN];
74 #define SHA1_DATASIZE 64
75 #define SHA1_DIGEST_LEN 20
82 /* we pack 64 unsigned chars into 16 32-bit unsigned integers */
85 guchar digest[SHA1_DIGEST_LEN];
88 #define SHA256_DATASIZE 64
89 #define SHA256_DIGEST_LEN 32
96 guint8 data[SHA256_DATASIZE];
98 guchar digest[SHA256_DIGEST_LEN];
114 /* we need different byte swapping functions because MD5 expects buffers
115 * to be little-endian, while SHA1 and SHA256 expect them in big-endian
119 #if G_BYTE_ORDER == G_LITTLE_ENDIAN
120 #define md5_byte_reverse(buffer,length)
122 /* assume that the passed buffer is integer aligned */
124 md5_byte_reverse (guchar *buffer,
131 bit = (guint32) ((unsigned) buffer[3] << 8 | buffer[2]) << 16 |
132 ((unsigned) buffer[1] << 8 | buffer[0]);
133 * (guint32 *) buffer = bit;
138 #endif /* G_BYTE_ORDER == G_LITTLE_ENDIAN */
140 #if G_BYTE_ORDER == G_BIG_ENDIAN
141 #define sha_byte_reverse(buffer,length)
144 sha_byte_reverse (guint32 *buffer,
147 length /= sizeof (guint32);
150 *buffer = GUINT32_SWAP_LE_BE (*buffer);
154 #endif /* G_BYTE_ORDER == G_BIG_ENDIAN */
157 digest_to_string (guint8 *digest,
160 gint len = digest_len * 2;
164 retval = g_new (gchar, len + 1);
166 for (i = 0; i < digest_len; i++)
168 guint8 byte = digest[i];
170 retval[2 * i] = hex_digits[byte >> 4];
171 retval[2 * i + 1] = hex_digits[byte & 0xf];
183 /* This MD5 digest computation is based on the equivalent code
184 * written by Colin Plumb. It came with this notice:
186 * This code implements the MD5 message-digest algorithm.
187 * The algorithm is due to Ron Rivest. This code was
188 * written by Colin Plumb in 1993, no copyright is claimed.
189 * This code is in the public domain; do with it what you wish.
191 * Equivalent code is available from RSA Data Security, Inc.
192 * This code has been tested against that, and is equivalent,
193 * except that you don't need to include two pages of legalese
198 md5_sum_init (Md5sum *md5)
200 /* arbitrary constants */
201 md5->buf[0] = 0x67452301;
202 md5->buf[1] = 0xefcdab89;
203 md5->buf[2] = 0x98badcfe;
204 md5->buf[3] = 0x10325476;
206 md5->bits[0] = md5->bits[1] = 0;
210 * The core of the MD5 algorithm, this alters an existing MD5 hash to
211 * reflect the addition of 16 longwords of new data. md5_sum_update()
212 * blocks the data and converts bytes into longwords for this routine.
215 md5_transform (guint32 buf[4],
216 guint32 const in[16])
218 register guint32 a, b, c, d;
220 /* The four core functions - F1 is optimized somewhat */
221 #define F1(x, y, z) (z ^ (x & (y ^ z)))
222 #define F2(x, y, z) F1 (z, x, y)
223 #define F3(x, y, z) (x ^ y ^ z)
224 #define F4(x, y, z) (y ^ (x | ~z))
226 /* This is the central step in the MD5 algorithm. */
227 #define md5_step(f, w, x, y, z, data, s) \
228 ( w += f (x, y, z) + data, w = w << s | w >> (32 - s), w += x )
235 md5_step (F1, a, b, c, d, in[0] + 0xd76aa478, 7);
236 md5_step (F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
237 md5_step (F1, c, d, a, b, in[2] + 0x242070db, 17);
238 md5_step (F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
239 md5_step (F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
240 md5_step (F1, d, a, b, c, in[5] + 0x4787c62a, 12);
241 md5_step (F1, c, d, a, b, in[6] + 0xa8304613, 17);
242 md5_step (F1, b, c, d, a, in[7] + 0xfd469501, 22);
243 md5_step (F1, a, b, c, d, in[8] + 0x698098d8, 7);
244 md5_step (F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
245 md5_step (F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
246 md5_step (F1, b, c, d, a, in[11] + 0x895cd7be, 22);
247 md5_step (F1, a, b, c, d, in[12] + 0x6b901122, 7);
248 md5_step (F1, d, a, b, c, in[13] + 0xfd987193, 12);
249 md5_step (F1, c, d, a, b, in[14] + 0xa679438e, 17);
250 md5_step (F1, b, c, d, a, in[15] + 0x49b40821, 22);
252 md5_step (F2, a, b, c, d, in[1] + 0xf61e2562, 5);
253 md5_step (F2, d, a, b, c, in[6] + 0xc040b340, 9);
254 md5_step (F2, c, d, a, b, in[11] + 0x265e5a51, 14);
255 md5_step (F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
256 md5_step (F2, a, b, c, d, in[5] + 0xd62f105d, 5);
257 md5_step (F2, d, a, b, c, in[10] + 0x02441453, 9);
258 md5_step (F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
259 md5_step (F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
260 md5_step (F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
261 md5_step (F2, d, a, b, c, in[14] + 0xc33707d6, 9);
262 md5_step (F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
263 md5_step (F2, b, c, d, a, in[8] + 0x455a14ed, 20);
264 md5_step (F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
265 md5_step (F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
266 md5_step (F2, c, d, a, b, in[7] + 0x676f02d9, 14);
267 md5_step (F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
269 md5_step (F3, a, b, c, d, in[5] + 0xfffa3942, 4);
270 md5_step (F3, d, a, b, c, in[8] + 0x8771f681, 11);
271 md5_step (F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
272 md5_step (F3, b, c, d, a, in[14] + 0xfde5380c, 23);
273 md5_step (F3, a, b, c, d, in[1] + 0xa4beea44, 4);
274 md5_step (F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
275 md5_step (F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
276 md5_step (F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
277 md5_step (F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
278 md5_step (F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
279 md5_step (F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
280 md5_step (F3, b, c, d, a, in[6] + 0x04881d05, 23);
281 md5_step (F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
282 md5_step (F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
283 md5_step (F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
284 md5_step (F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
286 md5_step (F4, a, b, c, d, in[0] + 0xf4292244, 6);
287 md5_step (F4, d, a, b, c, in[7] + 0x432aff97, 10);
288 md5_step (F4, c, d, a, b, in[14] + 0xab9423a7, 15);
289 md5_step (F4, b, c, d, a, in[5] + 0xfc93a039, 21);
290 md5_step (F4, a, b, c, d, in[12] + 0x655b59c3, 6);
291 md5_step (F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
292 md5_step (F4, c, d, a, b, in[10] + 0xffeff47d, 15);
293 md5_step (F4, b, c, d, a, in[1] + 0x85845dd1, 21);
294 md5_step (F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
295 md5_step (F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
296 md5_step (F4, c, d, a, b, in[6] + 0xa3014314, 15);
297 md5_step (F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
298 md5_step (F4, a, b, c, d, in[4] + 0xf7537e82, 6);
299 md5_step (F4, d, a, b, c, in[11] + 0xbd3af235, 10);
300 md5_step (F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
301 md5_step (F4, b, c, d, a, in[9] + 0xeb86d391, 21);
316 md5_sum_update (Md5sum *md5,
323 md5->bits[0] = bit + ((guint32) length << 3);
325 /* carry from low to high */
326 if (md5->bits[0] < bit)
329 md5->bits[1] += length >> 29;
331 /* bytes already in Md5sum->data */
332 bit = (bit >> 3) & 0x3f;
334 /* handle any leading odd-sized chunks */
337 guchar *p = (guchar *) md5->data + bit;
339 bit = MD5_DATASIZE - bit;
342 memcpy (p, data, length);
346 memcpy (p, data, bit);
348 md5_byte_reverse (md5->data, 16);
349 md5_transform (md5->buf, (guint32 *) md5->data);
355 /* process data in 64-byte chunks */
356 while (length >= MD5_DATASIZE)
358 memcpy (md5->data, data, MD5_DATASIZE);
360 md5_byte_reverse (md5->data, 16);
361 md5_transform (md5->buf, (guint32 *) md5->data);
363 data += MD5_DATASIZE;
364 length -= MD5_DATASIZE;
367 /* handle any remaining bytes of data */
368 memcpy (md5->data, data, length);
371 /* closes a checksum */
373 md5_sum_close (Md5sum *md5)
378 /* Compute number of bytes mod 64 */
379 count = (md5->bits[0] >> 3) & 0x3F;
381 /* Set the first char of padding to 0x80.
382 * This is safe since there is always at least one byte free
384 p = md5->data + count;
387 /* Bytes of padding needed to make 64 bytes */
388 count = MD5_DATASIZE - 1 - count;
390 /* Pad out to 56 mod 64 */
393 /* Two lots of padding: Pad the first block to 64 bytes */
394 memset (p, 0, count);
396 md5_byte_reverse (md5->data, 16);
397 md5_transform (md5->buf, (guint32 *) md5->data);
399 /* Now fill the next block with 56 bytes */
400 memset (md5->data, 0, MD5_DATASIZE - 8);
404 /* Pad block to 56 bytes */
405 memset (p, 0, count - 8);
408 md5_byte_reverse (md5->data, 14);
410 /* Append length in bits and transform */
411 ((guint32 *) md5->data)[14] = md5->bits[0];
412 ((guint32 *) md5->data)[15] = md5->bits[1];
414 md5_transform (md5->buf, (guint32 *) md5->data);
415 md5_byte_reverse ((guchar *) md5->buf, 4);
417 memcpy (md5->digest, md5->buf, 16);
419 /* Reset buffers in case they contain sensitive data */
420 memset (md5->buf, 0, sizeof (md5->buf));
421 memset (md5->data, 0, sizeof (md5->data));
425 md5_sum_to_string (Md5sum *md5)
427 return digest_to_string (md5->digest, MD5_DIGEST_LEN);
431 md5_sum_digest (Md5sum *md5,
436 for (i = 0; i < MD5_DIGEST_LEN; i++)
437 digest[i] = md5->digest[i];
444 /* The following implementation comes from D-Bus dbus-sha.c. I've changed
445 * it to use GLib types and to work more like the MD5 implementation above.
446 * I left the comments to have an history of this code.
447 * -- Emmanuele Bassi, ebassi@gnome.org
450 /* The following comments have the history of where this code
451 * comes from. I actually copied it from GNet in GNOME CVS.
456 * sha.h : Implementation of the Secure Hash Algorithm
458 * Part of the Python Cryptography Toolkit, version 1.0.0
460 * Copyright (C) 1995, A.M. Kuchling
462 * Distribute and use freely; there are no restrictions on further
463 * dissemination and usage except those imposed by the laws of your
464 * country of residence.
468 /* SHA: NIST's Secure Hash Algorithm */
470 /* Based on SHA code originally posted to sci.crypt by Peter Gutmann
471 in message <30ajo5$oe8@ccu2.auckland.ac.nz>.
472 Modified to test for endianness on creation of SHA objects by AMK.
473 Also, the original specification of SHA was found to have a weakness
474 by NSA/NIST. This code implements the fixed version of SHA.
477 /* Here's the first paragraph of Peter Gutmann's posting:
479 The following is my SHA (FIPS 180) code updated to allow use of the "fixed"
480 SHA, thanks to Jim Gillogly and an anonymous contributor for the information on
481 what's changed in the new version. The fix is a simple change which involves
482 adding a single rotate in the initial expansion function. It is unknown
483 whether this is an optimal solution to the problem which was discovered in the
484 SHA or whether it's simply a bandaid which fixes the problem with a minimum of
485 effort (for example the reengineering of a great many Capstone chips).
489 sha1_sum_init (Sha1sum *sha1)
491 /* initialize constants */
492 sha1->buf[0] = 0x67452301L;
493 sha1->buf[1] = 0xEFCDAB89L;
494 sha1->buf[2] = 0x98BADCFEL;
495 sha1->buf[3] = 0x10325476L;
496 sha1->buf[4] = 0xC3D2E1F0L;
498 /* initialize bits */
499 sha1->bits[0] = sha1->bits[1] = 0;
502 /* The SHA f()-functions. */
504 #define f1(x,y,z) (z ^ (x & (y ^ z))) /* Rounds 0-19 */
505 #define f2(x,y,z) (x ^ y ^ z) /* Rounds 20-39 */
506 #define f3(x,y,z) (( x & y) | (z & (x | y))) /* Rounds 40-59 */
507 #define f4(x,y,z) (x ^ y ^ z) /* Rounds 60-79 */
509 /* The SHA Mysterious Constants */
510 #define K1 0x5A827999L /* Rounds 0-19 */
511 #define K2 0x6ED9EBA1L /* Rounds 20-39 */
512 #define K3 0x8F1BBCDCL /* Rounds 40-59 */
513 #define K4 0xCA62C1D6L /* Rounds 60-79 */
515 /* 32-bit rotate left - kludged with shifts */
516 #define ROTL(n,X) (((X) << n ) | ((X) >> (32 - n)))
518 /* The initial expanding function. The hash function is defined over an
519 80-word expanded input array W, where the first 16 are copies of the input
520 data, and the remaining 64 are defined by
522 W[ i ] = W[ i - 16 ] ^ W[ i - 14 ] ^ W[ i - 8 ] ^ W[ i - 3 ]
524 This implementation generates these values on the fly in a circular
525 buffer - thanks to Colin Plumb, colin@nyx10.cs.du.edu for this
528 The updated SHA changes the expanding function by adding a rotate of 1
529 bit. Thanks to Jim Gillogly, jim@rand.org, and an anonymous contributor
530 for this information */
532 #define expand(W,i) (W[ i & 15 ] = ROTL (1, (W[ i & 15] ^ \
538 /* The prototype SHA sub-round. The fundamental sub-round is:
540 a' = e + ROTL( 5, a ) + f( b, c, d ) + k + data;
546 but this is implemented by unrolling the loop 5 times and renaming the
547 variables ( e, a, b, c, d ) = ( a', b', c', d', e' ) each iteration.
548 This code is then replicated 20 times for each of the 4 functions, using
549 the next 20 values from the W[] array each time */
551 #define subRound(a, b, c, d, e, f, k, data) \
552 (e += ROTL (5, a) + f(b, c, d) + k + data, b = ROTL (30, b))
555 sha1_transform (guint32 buf[5],
558 guint32 A, B, C, D, E;
566 /* Heavy mangling, in 4 sub-rounds of 20 interations each. */
567 subRound (A, B, C, D, E, f1, K1, in[0]);
568 subRound (E, A, B, C, D, f1, K1, in[1]);
569 subRound (D, E, A, B, C, f1, K1, in[2]);
570 subRound (C, D, E, A, B, f1, K1, in[3]);
571 subRound (B, C, D, E, A, f1, K1, in[4]);
572 subRound (A, B, C, D, E, f1, K1, in[5]);
573 subRound (E, A, B, C, D, f1, K1, in[6]);
574 subRound (D, E, A, B, C, f1, K1, in[7]);
575 subRound (C, D, E, A, B, f1, K1, in[8]);
576 subRound (B, C, D, E, A, f1, K1, in[9]);
577 subRound (A, B, C, D, E, f1, K1, in[10]);
578 subRound (E, A, B, C, D, f1, K1, in[11]);
579 subRound (D, E, A, B, C, f1, K1, in[12]);
580 subRound (C, D, E, A, B, f1, K1, in[13]);
581 subRound (B, C, D, E, A, f1, K1, in[14]);
582 subRound (A, B, C, D, E, f1, K1, in[15]);
583 subRound (E, A, B, C, D, f1, K1, expand (in, 16));
584 subRound (D, E, A, B, C, f1, K1, expand (in, 17));
585 subRound (C, D, E, A, B, f1, K1, expand (in, 18));
586 subRound (B, C, D, E, A, f1, K1, expand (in, 19));
588 subRound (A, B, C, D, E, f2, K2, expand (in, 20));
589 subRound (E, A, B, C, D, f2, K2, expand (in, 21));
590 subRound (D, E, A, B, C, f2, K2, expand (in, 22));
591 subRound (C, D, E, A, B, f2, K2, expand (in, 23));
592 subRound (B, C, D, E, A, f2, K2, expand (in, 24));
593 subRound (A, B, C, D, E, f2, K2, expand (in, 25));
594 subRound (E, A, B, C, D, f2, K2, expand (in, 26));
595 subRound (D, E, A, B, C, f2, K2, expand (in, 27));
596 subRound (C, D, E, A, B, f2, K2, expand (in, 28));
597 subRound (B, C, D, E, A, f2, K2, expand (in, 29));
598 subRound (A, B, C, D, E, f2, K2, expand (in, 30));
599 subRound (E, A, B, C, D, f2, K2, expand (in, 31));
600 subRound (D, E, A, B, C, f2, K2, expand (in, 32));
601 subRound (C, D, E, A, B, f2, K2, expand (in, 33));
602 subRound (B, C, D, E, A, f2, K2, expand (in, 34));
603 subRound (A, B, C, D, E, f2, K2, expand (in, 35));
604 subRound (E, A, B, C, D, f2, K2, expand (in, 36));
605 subRound (D, E, A, B, C, f2, K2, expand (in, 37));
606 subRound (C, D, E, A, B, f2, K2, expand (in, 38));
607 subRound (B, C, D, E, A, f2, K2, expand (in, 39));
609 subRound (A, B, C, D, E, f3, K3, expand (in, 40));
610 subRound (E, A, B, C, D, f3, K3, expand (in, 41));
611 subRound (D, E, A, B, C, f3, K3, expand (in, 42));
612 subRound (C, D, E, A, B, f3, K3, expand (in, 43));
613 subRound (B, C, D, E, A, f3, K3, expand (in, 44));
614 subRound (A, B, C, D, E, f3, K3, expand (in, 45));
615 subRound (E, A, B, C, D, f3, K3, expand (in, 46));
616 subRound (D, E, A, B, C, f3, K3, expand (in, 47));
617 subRound (C, D, E, A, B, f3, K3, expand (in, 48));
618 subRound (B, C, D, E, A, f3, K3, expand (in, 49));
619 subRound (A, B, C, D, E, f3, K3, expand (in, 50));
620 subRound (E, A, B, C, D, f3, K3, expand (in, 51));
621 subRound (D, E, A, B, C, f3, K3, expand (in, 52));
622 subRound (C, D, E, A, B, f3, K3, expand (in, 53));
623 subRound (B, C, D, E, A, f3, K3, expand (in, 54));
624 subRound (A, B, C, D, E, f3, K3, expand (in, 55));
625 subRound (E, A, B, C, D, f3, K3, expand (in, 56));
626 subRound (D, E, A, B, C, f3, K3, expand (in, 57));
627 subRound (C, D, E, A, B, f3, K3, expand (in, 58));
628 subRound (B, C, D, E, A, f3, K3, expand (in, 59));
630 subRound (A, B, C, D, E, f4, K4, expand (in, 60));
631 subRound (E, A, B, C, D, f4, K4, expand (in, 61));
632 subRound (D, E, A, B, C, f4, K4, expand (in, 62));
633 subRound (C, D, E, A, B, f4, K4, expand (in, 63));
634 subRound (B, C, D, E, A, f4, K4, expand (in, 64));
635 subRound (A, B, C, D, E, f4, K4, expand (in, 65));
636 subRound (E, A, B, C, D, f4, K4, expand (in, 66));
637 subRound (D, E, A, B, C, f4, K4, expand (in, 67));
638 subRound (C, D, E, A, B, f4, K4, expand (in, 68));
639 subRound (B, C, D, E, A, f4, K4, expand (in, 69));
640 subRound (A, B, C, D, E, f4, K4, expand (in, 70));
641 subRound (E, A, B, C, D, f4, K4, expand (in, 71));
642 subRound (D, E, A, B, C, f4, K4, expand (in, 72));
643 subRound (C, D, E, A, B, f4, K4, expand (in, 73));
644 subRound (B, C, D, E, A, f4, K4, expand (in, 74));
645 subRound (A, B, C, D, E, f4, K4, expand (in, 75));
646 subRound (E, A, B, C, D, f4, K4, expand (in, 76));
647 subRound (D, E, A, B, C, f4, K4, expand (in, 77));
648 subRound (C, D, E, A, B, f4, K4, expand (in, 78));
649 subRound (B, C, D, E, A, f4, K4, expand (in, 79));
651 /* Build message digest */
672 sha1_sum_update (Sha1sum *sha1,
673 const guchar *buffer,
679 /* Update bitcount */
681 if ((sha1->bits[0] = tmp + ((guint32) count << 3) ) < tmp)
682 sha1->bits[1] += 1; /* Carry from low to high */
683 sha1->bits[1] += count >> 29;
685 /* Get count of bytes already in data */
686 dataCount = (guint) (tmp >> 3) & 0x3F;
688 /* Handle any leading odd-sized chunks */
691 guchar *p = (guchar *) sha1->data + dataCount;
693 dataCount = SHA1_DATASIZE - dataCount;
694 if (count < dataCount)
696 memcpy (p, buffer, count);
700 memcpy (p, buffer, dataCount);
702 sha_byte_reverse (sha1->data, SHA1_DATASIZE);
703 sha1_transform (sha1->buf, sha1->data);
709 /* Process data in SHA1_DATASIZE chunks */
710 while (count >= SHA1_DATASIZE)
712 memcpy (sha1->data, buffer, SHA1_DATASIZE);
714 sha_byte_reverse (sha1->data, SHA1_DATASIZE);
715 sha1_transform (sha1->buf, sha1->data);
717 buffer += SHA1_DATASIZE;
718 count -= SHA1_DATASIZE;
721 /* Handle any remaining bytes of data. */
722 memcpy (sha1->data, buffer, count);
725 /* Final wrapup - pad to SHA_DATASIZE-byte boundary with the bit pattern
726 1 0* (64-bit count of bits processed, MSB-first) */
728 sha1_sum_close (Sha1sum *sha1)
733 /* Compute number of bytes mod 64 */
734 count = (gint) ((sha1->bits[0] >> 3) & 0x3f);
736 /* Set the first char of padding to 0x80. This is safe since there is
737 always at least one byte free */
738 data_p = (guchar *) sha1->data + count;
741 /* Bytes of padding needed to make 64 bytes */
742 count = SHA1_DATASIZE - 1 - count;
744 /* Pad out to 56 mod 64 */
747 /* Two lots of padding: Pad the first block to 64 bytes */
748 memset (data_p, 0, count);
750 sha_byte_reverse (sha1->data, SHA1_DATASIZE);
751 sha1_transform (sha1->buf, sha1->data);
753 /* Now fill the next block with 56 bytes */
754 memset (sha1->data, 0, SHA1_DATASIZE - 8);
758 /* Pad block to 56 bytes */
759 memset (data_p, 0, count - 8);
762 /* Append length in bits and transform */
763 sha1->data[14] = sha1->bits[1];
764 sha1->data[15] = sha1->bits[0];
766 sha_byte_reverse (sha1->data, SHA1_DATASIZE - 8);
767 sha1_transform (sha1->buf, sha1->data);
768 sha_byte_reverse (sha1->buf, SHA1_DIGEST_LEN);
770 memcpy (sha1->digest, sha1->buf, SHA1_DIGEST_LEN);
772 /* Reset buffers in case they contain sensitive data */
773 memset (sha1->buf, 0, sizeof (sha1->buf));
774 memset (sha1->data, 0, sizeof (sha1->data));
778 sha1_sum_to_string (Sha1sum *sha1)
780 return digest_to_string (sha1->digest, SHA1_DIGEST_LEN);
784 sha1_sum_digest (Sha1sum *sha1,
789 for (i = 0; i < SHA1_DIGEST_LEN; i++)
790 digest[i] = sha1->digest[i];
797 /* adapted from the SHA256 implementation in gsk/src/hash/gskhash.c.
799 * Copyright (C) 2006 Dave Benson
800 * Released under the terms of the GNU Lesser General Public License
804 sha256_sum_init (Sha256sum *sha256)
806 sha256->buf[0] = 0x6a09e667;
807 sha256->buf[1] = 0xbb67ae85;
808 sha256->buf[2] = 0x3c6ef372;
809 sha256->buf[3] = 0xa54ff53a;
810 sha256->buf[4] = 0x510e527f;
811 sha256->buf[5] = 0x9b05688c;
812 sha256->buf[6] = 0x1f83d9ab;
813 sha256->buf[7] = 0x5be0cd19;
815 sha256->bits[0] = sha256->bits[1] = 0;
818 #define GET_UINT32(n,b,i) G_STMT_START{ \
819 (n) = ((guint32) (b)[(i) ] << 24) \
820 | ((guint32) (b)[(i) + 1] << 16) \
821 | ((guint32) (b)[(i) + 2] << 8) \
822 | ((guint32) (b)[(i) + 3] ); } G_STMT_END
824 #define PUT_UINT32(n,b,i) G_STMT_START{ \
825 (b)[(i) ] = (guint8) ((n) >> 24); \
826 (b)[(i) + 1] = (guint8) ((n) >> 16); \
827 (b)[(i) + 2] = (guint8) ((n) >> 8); \
828 (b)[(i) + 3] = (guint8) ((n) ); } G_STMT_END
831 sha256_transform (guint32 buf[8],
832 guint8 const data[64])
834 guint32 temp1, temp2, W[64];
835 guint32 A, B, C, D, E, F, G, H;
837 GET_UINT32 (W[0], data, 0);
838 GET_UINT32 (W[1], data, 4);
839 GET_UINT32 (W[2], data, 8);
840 GET_UINT32 (W[3], data, 12);
841 GET_UINT32 (W[4], data, 16);
842 GET_UINT32 (W[5], data, 20);
843 GET_UINT32 (W[6], data, 24);
844 GET_UINT32 (W[7], data, 28);
845 GET_UINT32 (W[8], data, 32);
846 GET_UINT32 (W[9], data, 36);
847 GET_UINT32 (W[10], data, 40);
848 GET_UINT32 (W[11], data, 44);
849 GET_UINT32 (W[12], data, 48);
850 GET_UINT32 (W[13], data, 52);
851 GET_UINT32 (W[14], data, 56);
852 GET_UINT32 (W[15], data, 60);
854 #define SHR(x,n) ((x & 0xFFFFFFFF) >> n)
855 #define ROTR(x,n) (SHR (x,n) | (x << (32 - n)))
857 #define S0(x) (ROTR (x, 7) ^ ROTR (x,18) ^ SHR (x, 3))
858 #define S1(x) (ROTR (x,17) ^ ROTR (x,19) ^ SHR (x,10))
859 #define S2(x) (ROTR (x, 2) ^ ROTR (x,13) ^ ROTR (x,22))
860 #define S3(x) (ROTR (x, 6) ^ ROTR (x,11) ^ ROTR (x,25))
862 #define F0(x,y,z) ((x & y) | (z & (x | y)))
863 #define F1(x,y,z) (z ^ (x & (y ^ z)))
865 #define R(t) (W[t] = S1(W[t - 2]) + W[t - 7] + \
866 S0(W[t - 15]) + W[t - 16])
868 #define P(a,b,c,d,e,f,g,h,x,K) G_STMT_START { \
869 temp1 = h + S3(e) + F1(e,f,g) + K + x; \
870 temp2 = S2(a) + F0(a,b,c); \
871 d += temp1; h = temp1 + temp2; } G_STMT_END
882 P (A, B, C, D, E, F, G, H, W[ 0], 0x428A2F98);
883 P (H, A, B, C, D, E, F, G, W[ 1], 0x71374491);
884 P (G, H, A, B, C, D, E, F, W[ 2], 0xB5C0FBCF);
885 P (F, G, H, A, B, C, D, E, W[ 3], 0xE9B5DBA5);
886 P (E, F, G, H, A, B, C, D, W[ 4], 0x3956C25B);
887 P (D, E, F, G, H, A, B, C, W[ 5], 0x59F111F1);
888 P (C, D, E, F, G, H, A, B, W[ 6], 0x923F82A4);
889 P (B, C, D, E, F, G, H, A, W[ 7], 0xAB1C5ED5);
890 P (A, B, C, D, E, F, G, H, W[ 8], 0xD807AA98);
891 P (H, A, B, C, D, E, F, G, W[ 9], 0x12835B01);
892 P (G, H, A, B, C, D, E, F, W[10], 0x243185BE);
893 P (F, G, H, A, B, C, D, E, W[11], 0x550C7DC3);
894 P (E, F, G, H, A, B, C, D, W[12], 0x72BE5D74);
895 P (D, E, F, G, H, A, B, C, W[13], 0x80DEB1FE);
896 P (C, D, E, F, G, H, A, B, W[14], 0x9BDC06A7);
897 P (B, C, D, E, F, G, H, A, W[15], 0xC19BF174);
898 P (A, B, C, D, E, F, G, H, R(16), 0xE49B69C1);
899 P (H, A, B, C, D, E, F, G, R(17), 0xEFBE4786);
900 P (G, H, A, B, C, D, E, F, R(18), 0x0FC19DC6);
901 P (F, G, H, A, B, C, D, E, R(19), 0x240CA1CC);
902 P (E, F, G, H, A, B, C, D, R(20), 0x2DE92C6F);
903 P (D, E, F, G, H, A, B, C, R(21), 0x4A7484AA);
904 P (C, D, E, F, G, H, A, B, R(22), 0x5CB0A9DC);
905 P (B, C, D, E, F, G, H, A, R(23), 0x76F988DA);
906 P (A, B, C, D, E, F, G, H, R(24), 0x983E5152);
907 P (H, A, B, C, D, E, F, G, R(25), 0xA831C66D);
908 P (G, H, A, B, C, D, E, F, R(26), 0xB00327C8);
909 P (F, G, H, A, B, C, D, E, R(27), 0xBF597FC7);
910 P (E, F, G, H, A, B, C, D, R(28), 0xC6E00BF3);
911 P (D, E, F, G, H, A, B, C, R(29), 0xD5A79147);
912 P (C, D, E, F, G, H, A, B, R(30), 0x06CA6351);
913 P (B, C, D, E, F, G, H, A, R(31), 0x14292967);
914 P (A, B, C, D, E, F, G, H, R(32), 0x27B70A85);
915 P (H, A, B, C, D, E, F, G, R(33), 0x2E1B2138);
916 P (G, H, A, B, C, D, E, F, R(34), 0x4D2C6DFC);
917 P (F, G, H, A, B, C, D, E, R(35), 0x53380D13);
918 P (E, F, G, H, A, B, C, D, R(36), 0x650A7354);
919 P (D, E, F, G, H, A, B, C, R(37), 0x766A0ABB);
920 P (C, D, E, F, G, H, A, B, R(38), 0x81C2C92E);
921 P (B, C, D, E, F, G, H, A, R(39), 0x92722C85);
922 P (A, B, C, D, E, F, G, H, R(40), 0xA2BFE8A1);
923 P (H, A, B, C, D, E, F, G, R(41), 0xA81A664B);
924 P (G, H, A, B, C, D, E, F, R(42), 0xC24B8B70);
925 P (F, G, H, A, B, C, D, E, R(43), 0xC76C51A3);
926 P (E, F, G, H, A, B, C, D, R(44), 0xD192E819);
927 P (D, E, F, G, H, A, B, C, R(45), 0xD6990624);
928 P (C, D, E, F, G, H, A, B, R(46), 0xF40E3585);
929 P (B, C, D, E, F, G, H, A, R(47), 0x106AA070);
930 P (A, B, C, D, E, F, G, H, R(48), 0x19A4C116);
931 P (H, A, B, C, D, E, F, G, R(49), 0x1E376C08);
932 P (G, H, A, B, C, D, E, F, R(50), 0x2748774C);
933 P (F, G, H, A, B, C, D, E, R(51), 0x34B0BCB5);
934 P (E, F, G, H, A, B, C, D, R(52), 0x391C0CB3);
935 P (D, E, F, G, H, A, B, C, R(53), 0x4ED8AA4A);
936 P (C, D, E, F, G, H, A, B, R(54), 0x5B9CCA4F);
937 P (B, C, D, E, F, G, H, A, R(55), 0x682E6FF3);
938 P (A, B, C, D, E, F, G, H, R(56), 0x748F82EE);
939 P (H, A, B, C, D, E, F, G, R(57), 0x78A5636F);
940 P (G, H, A, B, C, D, E, F, R(58), 0x84C87814);
941 P (F, G, H, A, B, C, D, E, R(59), 0x8CC70208);
942 P (E, F, G, H, A, B, C, D, R(60), 0x90BEFFFA);
943 P (D, E, F, G, H, A, B, C, R(61), 0xA4506CEB);
944 P (C, D, E, F, G, H, A, B, R(62), 0xBEF9A3F7);
945 P (B, C, D, E, F, G, H, A, R(63), 0xC67178F2);
969 sha256_sum_update (Sha256sum *sha256,
970 const guchar *buffer,
974 const guint8 *input = buffer;
979 left = sha256->bits[0] & 0x3F;
982 sha256->bits[0] += length;
983 sha256->bits[0] &= 0xFFFFFFFF;
985 if (sha256->bits[0] < length)
988 if (left > 0 && length >= fill)
990 memcpy ((sha256->data + left), input, fill);
992 sha256_transform (sha256->buf, sha256->data);
999 while (length >= SHA256_DATASIZE)
1001 sha256_transform (sha256->buf, input);
1008 memcpy (sha256->data + left, input, length);
1011 static guint8 sha256_padding[64] =
1013 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1014 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1015 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1016 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
1020 sha256_sum_close (Sha256sum *sha256)
1026 high = (sha256->bits[0] >> 29)
1027 | (sha256->bits[1] << 3);
1028 low = (sha256->bits[0] << 3);
1030 PUT_UINT32 (high, msglen, 0);
1031 PUT_UINT32 (low, msglen, 4);
1033 last = sha256->bits[0] & 0x3F;
1034 padn = (last < 56) ? (56 - last) : (120 - last);
1036 sha256_sum_update (sha256, sha256_padding, padn);
1037 sha256_sum_update (sha256, msglen, 8);
1039 PUT_UINT32 (sha256->buf[0], sha256->digest, 0);
1040 PUT_UINT32 (sha256->buf[1], sha256->digest, 4);
1041 PUT_UINT32 (sha256->buf[2], sha256->digest, 8);
1042 PUT_UINT32 (sha256->buf[3], sha256->digest, 12);
1043 PUT_UINT32 (sha256->buf[4], sha256->digest, 16);
1044 PUT_UINT32 (sha256->buf[5], sha256->digest, 20);
1045 PUT_UINT32 (sha256->buf[6], sha256->digest, 24);
1046 PUT_UINT32 (sha256->buf[7], sha256->digest, 28);
1053 sha256_sum_to_string (Sha256sum *sha256)
1055 return digest_to_string (sha256->digest, SHA256_DIGEST_LEN);
1059 sha256_sum_digest (Sha256sum *sha256,
1064 for (i = 0; i < SHA256_DIGEST_LEN; i++)
1065 digest[i] = sha256->digest[i];
1074 * g_checksum_type_get_length:
1075 * @checksum_type: a #GChecksumType
1077 * Gets the length in bytes of digests of type @checksum_type
1079 * Return value: the checksum length, or -1 if @checksum_type is
1085 g_checksum_type_get_length (GChecksumType checksum_type)
1089 switch (checksum_type)
1091 case G_CHECKSUM_MD5:
1092 len = MD5_DIGEST_LEN;
1094 case G_CHECKSUM_SHA1:
1095 len = SHA1_DIGEST_LEN;
1097 case G_CHECKSUM_SHA256:
1098 len = SHA256_DIGEST_LEN;
1110 * @checksum_type: the desired type of checksum
1112 * Creates a new #GChecksum, using the checksum algorithm @checksum_type.
1113 * If the @checksum_type is not known, %NULL is returned.
1114 * A #GChecksum can be used to compute the checksum, or digest, of an
1115 * arbitrary binary blob, using different hashing algorithms.
1117 * A #GChecksum works by feeding a binary blob through g_checksum_update()
1118 * until there is data to be checked; the digest can then be extracted
1119 * using g_checksum_get_string(), which will return the checksum as a
1120 * hexadecimal string; or g_checksum_get_digest(), which will return a
1121 * vector of raw bytes. Once either g_checksum_get_string() or
1122 * g_checksum_get_digest() have been called on a #GChecksum, the checksum
1123 * will be closed and it won't be possible to call g_checksum_update()
1126 * Return value: the newly created #GChecksum, or %NULL.
1127 * Use g_checksum_free() to free the memory allocated by it.
1132 g_checksum_new (GChecksumType checksum_type)
1134 GChecksum *checksum;
1136 if (! IS_VALID_TYPE (checksum_type))
1139 checksum = g_slice_new0 (GChecksum);
1140 checksum->type = checksum_type;
1142 g_checksum_reset (checksum);
1149 * @checksum: the #GChecksum to reset
1151 * Resets the state of the @checksum back to its initial state.
1156 g_checksum_reset (GChecksum *checksum)
1158 g_return_if_fail (checksum != NULL);
1160 g_free (checksum->digest_str);
1161 checksum->digest_str = NULL;
1163 switch (checksum->type)
1165 case G_CHECKSUM_MD5:
1166 md5_sum_init (&(checksum->sum.md5));
1168 case G_CHECKSUM_SHA1:
1169 sha1_sum_init (&(checksum->sum.sha1));
1171 case G_CHECKSUM_SHA256:
1172 sha256_sum_init (&(checksum->sum.sha256));
1175 g_assert_not_reached ();
1182 * @checksum: the #GChecksum to copy
1184 * Copies a #GChecksum. If @checksum has been closed, by calling
1185 * g_checksum_get_string() or g_checksum_get_digest(), the copied
1186 * checksum will be closed as well.
1188 * Return value: the copy of the passed #GChecksum. Use g_checksum_free()
1189 * when finished using it.
1194 g_checksum_copy (const GChecksum *checksum)
1198 g_return_val_if_fail (checksum != NULL, NULL);
1200 copy = g_slice_new (GChecksum);
1203 copy->digest_str = g_strdup (checksum->digest_str);
1210 * @checksum: a #GChecksum
1212 * Frees the memory allocated for @checksum.
1217 g_checksum_free (GChecksum *checksum)
1219 if (G_LIKELY (checksum))
1221 g_free (checksum->digest_str);
1223 g_slice_free (GChecksum, checksum);
1228 * g_checksum_update:
1229 * @checksum: a #GChecksum
1230 * @data: buffer used to compute the checksum
1231 * @length: size of the buffer, or -1 if it is a null-terminated string.
1233 * Feeds @data into an existing #GChecksum. The checksum must still be
1234 * open, that is g_checksum_get_string() or g_checksum_get_digest() must
1235 * not have been called on @checksum.
1240 g_checksum_update (GChecksum *checksum,
1244 g_return_if_fail (checksum != NULL);
1245 g_return_if_fail (length == 0 || data != NULL);
1248 length = strlen ((const gchar *) data);
1250 if (checksum->digest_str)
1252 g_warning ("The checksum `%s' has been closed and cannot be updated "
1254 checksum->digest_str);
1258 switch (checksum->type)
1260 case G_CHECKSUM_MD5:
1261 md5_sum_update (&(checksum->sum.md5), data, length);
1263 case G_CHECKSUM_SHA1:
1264 sha1_sum_update (&(checksum->sum.sha1), data, length);
1266 case G_CHECKSUM_SHA256:
1267 sha256_sum_update (&(checksum->sum.sha256), data, length);
1270 g_assert_not_reached ();
1276 * g_checksum_get_string:
1277 * @checksum: a #GChecksum
1279 * Gets the digest as an hexadecimal string.
1281 * Once this function has been called the #GChecksum can no longer be
1282 * updated with g_checksum_update().
1284 * The hexadecimal characters will be lower case.
1286 * Return value: the hexadecimal representation of the checksum. The
1287 * returned string is owned by the checksum and should not be modified
1292 G_CONST_RETURN gchar *
1293 g_checksum_get_string (GChecksum *checksum)
1297 g_return_val_if_fail (checksum != NULL, NULL);
1299 if (checksum->digest_str)
1300 return checksum->digest_str;
1302 switch (checksum->type)
1304 case G_CHECKSUM_MD5:
1305 md5_sum_close (&(checksum->sum.md5));
1306 str = md5_sum_to_string (&(checksum->sum.md5));
1308 case G_CHECKSUM_SHA1:
1309 sha1_sum_close (&(checksum->sum.sha1));
1310 str = sha1_sum_to_string (&(checksum->sum.sha1));
1312 case G_CHECKSUM_SHA256:
1313 sha256_sum_close (&(checksum->sum.sha256));
1314 str = sha256_sum_to_string (&(checksum->sum.sha256));
1317 g_assert_not_reached ();
1321 checksum->digest_str = str;
1323 return checksum->digest_str;
1327 * g_checksum_get_digest:
1328 * @checksum: a #GChecksum
1329 * @buffer: output buffer
1330 * @digest_len: an inout parameter. The caller initializes it to the size of @buffer.
1331 * After the call it contains the length of the digest.
1333 * Gets the digest from @checksum as a raw binary vector and places it
1334 * into @buffer. The size of the digest depends on the type of checksum.
1336 * Once this function has been called, the #GChecksum is closed and can
1337 * no longer be updated with g_checksum_update().
1342 g_checksum_get_digest (GChecksum *checksum,
1346 gboolean checksum_open = FALSE;
1350 g_return_if_fail (checksum != NULL);
1352 len = g_checksum_type_get_length (checksum->type);
1353 g_return_if_fail (*digest_len >= len);
1355 checksum_open = !!(checksum->digest_str == NULL);
1357 switch (checksum->type)
1359 case G_CHECKSUM_MD5:
1362 md5_sum_close (&(checksum->sum.md5));
1363 str = md5_sum_to_string (&(checksum->sum.md5));
1365 md5_sum_digest (&(checksum->sum.md5), buffer);
1367 case G_CHECKSUM_SHA1:
1370 sha1_sum_close (&(checksum->sum.sha1));
1371 str = sha1_sum_to_string (&(checksum->sum.sha1));
1373 sha1_sum_digest (&(checksum->sum.sha1), buffer);
1375 case G_CHECKSUM_SHA256:
1378 sha256_sum_close (&(checksum->sum.sha256));
1379 str = sha256_sum_to_string (&(checksum->sum.sha256));
1381 sha256_sum_digest (&(checksum->sum.sha256), buffer);
1384 g_assert_not_reached ();
1389 checksum->digest_str = str;
1395 * g_compute_checksum_for_data:
1396 * @checksum_type: a #GChecksumType
1397 * @data: binary blob to compute the digest of
1398 * @length: length of @data
1400 * Computes the checksum for a binary @data of @length. This is a
1401 * convenience wrapper for g_checksum_new(), g_checksum_get_string()
1402 * and g_checksum_free().
1404 * The hexadecimal string returned will be in lower case.
1406 * Return value: the digest of the binary data as a string in hexadecimal.
1407 * The returned string should be freed with g_free() when done using it.
1412 g_compute_checksum_for_data (GChecksumType checksum_type,
1416 GChecksum *checksum;
1419 g_return_val_if_fail (IS_VALID_TYPE (checksum_type), NULL);
1420 g_return_val_if_fail (length == 0 || data != NULL, NULL);
1422 checksum = g_checksum_new (checksum_type);
1426 g_checksum_update (checksum, data, length);
1427 retval = g_strdup (g_checksum_get_string (checksum));
1428 g_checksum_free (checksum);
1434 * g_compute_checksum_for_string:
1435 * @checksum_type: a #GChecksumType
1436 * @str: the string to compute the checksum of
1437 * @length: the length of the string, or -1 if the string is null-terminated.
1439 * Computes the checksum of a string.
1441 * The hexadecimal string returned will be in lower case.
1443 * Return value: the checksum as a hexadecimal string. The returned string
1444 * should be freed with g_free() when done using it.
1449 g_compute_checksum_for_string (GChecksumType checksum_type,
1453 g_return_val_if_fail (IS_VALID_TYPE (checksum_type), NULL);
1454 g_return_val_if_fail (length == 0 || str != NULL, NULL);
1457 length = strlen (str);
1459 return g_compute_checksum_for_data (checksum_type, (const guchar *) str, length);