Changeset 34afea7 for lib/md5.c


Ignore:
Timestamp:
2015-01-31T23:58:57Z (6 years ago)
Author:
dequis <dx@…>
Branches:
master
Children:
0ca1d79
Parents:
e41cc40
git-author:
dequis <dx@…> (18-01-15 06:39:20)
git-committer:
dequis <dx@…> (31-01-15 23:58:57)
Message:

Use glib's GChecksum for md5/sha1

This changes behavior slightly:

  • md5_init()/sha1_init() allocate a GChecksum
  • md5_finish()/sha1_finish() close and free() it
  • md5_digest_keep() was added (no sha1 equivalent needed)

And yes, glib has this concept of "closing" the GChecksum, which means
it can't be used anymore after g_checksum_get_digest().

jabber_cache_add() actually seems to need to do that to generate some
random-ish values, so i kept that working by adding a md5_digest_keep()
function that copies the GChecksum before it gets closed

GChecksum was introduced in glib 2.16, so the configure script version
was bumped. We were already depending on glib 2.16 accidentally
(some post-3.2.2 code uses GHashTableIter)

File:
1 edited

Legend:

Unmodified
Added
Removed
  • lib/md5.c

    re41cc40 r34afea7  
    1 /*
    2  * MD5 hashing code copied from Lepton's crack <http://usuarios.lycos.es/reinob/>
    3  *
    4  * Adapted to be API-compatible with the previous (GPL-incompatible) code.
    5  */
    6 
    7 /*
    8  * This code implements the MD5 message-digest algorithm.
    9  * The algorithm is due to Ron Rivest.  This code was
    10  * written by Colin Plumb in 1993, no copyright is claimed.
    11  * This code is in the public domain; do with it what you wish.
    12  *
    13  * Equivalent code is available from RSA Data Security, Inc.
    14  * This code has been tested against that, and is equivalent,
    15  * except that you don't need to include two pages of legalese
    16  * with every copy.
    17  *
    18  * To compute the message digest of a chunk of bytes, declare an
    19  * MD5Context structure, pass it to MD5Init, call MD5Update as
    20  * needed on buffers full of bytes, and then call MD5Final, which
    21  * will fill a supplied 16-byte array with the digest.
    22  */
    23 
    24 #include <sys/types.h>
    25 #include <string.h>             /* for memcpy() */
    26 #include <stdio.h>
    271#include "md5.h"
    282
    29 static void md5_transform(uint32_t buf[4], uint32_t const in[16]);
    30 
    31 /*
    32  * Wrapper function for all-in-one MD5
    33  *
    34  * Bernardo Reino, aka Lepton.
    35  * 20021120
    36  */
    37 
    38 /* Turns out MD5 was designed for little-endian machines. If we're running
    39    on a big-endian machines, we have to swap some bytes. Since detecting
    40    endianness at compile time reliably seems pretty hard, let's do it at
    41    run-time. It's not like we're going to checksum megabytes of data... */
    42 static uint32_t cvt32(uint32_t val)
     3/* Creates a new GChecksum in ctx */
     4void md5_init(md5_state_t *ctx)
    435{
    44         static int little_endian = -1;
    45        
    46         if (little_endian == -1)
    47         {
    48                 little_endian = 1;
    49                 little_endian = *((char*) &little_endian);
    50         }
    51        
    52         if (little_endian)
    53                 return val;
    54         else
    55                 return (val >> 24) |
    56                        ((val >> 8) & 0xff00) |
    57                        ((val << 8) & 0xff0000) |
    58                        (val << 24);
     6        *ctx = g_checksum_new(G_CHECKSUM_MD5);
    597}
    608
    61 void md5_init(struct MD5Context *ctx)
     9/* Wrapper for g_checksum_update */
     10void md5_append(md5_state_t *ctx, const guint8 *buf, unsigned int len)
    6211{
    63         ctx->buf[0] = 0x67452301;
    64         ctx->buf[1] = 0xefcdab89;
    65         ctx->buf[2] = 0x98badcfe;
    66         ctx->buf[3] = 0x10325476;
    67 
    68         ctx->bits[0] = 0;
    69         ctx->bits[1] = 0;
     12        g_checksum_update(*ctx, buf, len);
    7013}
    7114
    72 /*
    73  * Update context to reflect the concatenation of another buffer full
    74  * of bytes.
    75  */
    76 void md5_append(struct MD5Context *ctx, const md5_byte_t *buf,
    77                 unsigned int len)
     15/* Wrapper for g_checksum_get_digest
     16 * Also takes care of g_checksum_free(), since it can't be reused anyway
     17 * (the GChecksum is closed after get_digest) */
     18void md5_finish(md5_state_t *ctx, guint8 digest[MD5_HASH_SIZE])
    7819{
    79         uint32_t t;
    80 
    81         /* Update bitcount */
    82 
    83         t = ctx->bits[0];
    84         if ((ctx->bits[0] = t + ((uint32_t) len << 3)) < t)
    85                 ctx->bits[1]++; /* Carry from low to high */
    86         ctx->bits[1] += len >> 29;
    87 
    88         t = (t >> 3) & 0x3f;    /* Bytes already in shsInfo->data */
    89 
    90         /* Handle any leading odd-sized chunks */
    91 
    92         if (t) {
    93                 unsigned char *p = (unsigned char *) ctx->in + t;
    94 
    95                 t = 64 - t;
    96                 if (len < t) {
    97                         memcpy(p, buf, len);
    98                         return;
    99                 }
    100                 memcpy(p, buf, t);
    101                 md5_transform(ctx->buf, (uint32_t *) ctx->in);
    102                 buf += t;
    103                 len -= t;
    104         }
    105         /* Process data in 64-byte chunks */
    106 
    107         while (len >= 64) {
    108                 memcpy(ctx->in, buf, 64);
    109                 md5_transform(ctx->buf, (uint32_t *) ctx->in);
    110                 buf += 64;
    111                 len -= 64;
    112         }
    113 
    114         /* Handle any remaining bytes of data. */
    115 
    116         memcpy(ctx->in, buf, len);
     20        gsize digest_len = MD5_HASH_SIZE;
     21        g_checksum_get_digest(*ctx, digest, &digest_len);
     22        g_checksum_free(*ctx);
    11723}
    11824
    119 /*
    120  * Final wrapup - pad to 64-byte boundary with the bit pattern
    121  * 1 0* (64-bit count of bits processed, MSB-first)
    122  */
    123 void md5_finish(struct MD5Context *ctx, md5_byte_t digest[16])
     25/* Variant of md5_finish that copies the GChecksum
     26 * and finishes that one instead of the original */
     27void md5_digest_keep(md5_state_t *ctx, guint8 digest[MD5_HASH_SIZE])
    12428{
    125         unsigned count;
    126         unsigned char *p;
    127 
    128         /* Compute number of bytes mod 64 */
    129         count = (ctx->bits[0] >> 3) & 0x3F;
    130 
    131         /* Set the first char of padding to 0x80.  This is safe since there is
    132            always at least one byte free */
    133         p = ctx->in + count;
    134         *p++ = 0x80;
    135 
    136         /* Bytes of padding needed to make 64 bytes */
    137         count = 64 - 1 - count;
    138 
    139         /* Pad out to 56 mod 64 */
    140         if (count < 8) {
    141                 /* Two lots of padding:  Pad the first block to 64 bytes */
    142                 memset(p, 0, count);
    143                 md5_transform(ctx->buf, (uint32_t *) ctx->in);
    144 
    145                 /* Now fill the next block with 56 bytes */
    146                 memset(ctx->in, 0, 56);
    147         } else {
    148                 /* Pad block to 56 bytes */
    149                 memset(p, 0, count - 8);
    150         }
    151 
    152         /* Append length in bits and transform */
    153         ((uint32_t *) ctx->in)[14] = cvt32(ctx->bits[0]);
    154         ((uint32_t *) ctx->in)[15] = cvt32(ctx->bits[1]);
    155 
    156         md5_transform(ctx->buf, (uint32_t *) ctx->in);
    157         ctx->buf[0] = cvt32(ctx->buf[0]);
    158         ctx->buf[1] = cvt32(ctx->buf[1]);
    159         ctx->buf[2] = cvt32(ctx->buf[2]);
    160         ctx->buf[3] = cvt32(ctx->buf[3]);
    161         memcpy(digest, ctx->buf, 16);
    162         memset(ctx, 0, sizeof(*ctx));   /* In case it's sensitive */
     29        md5_state_t copy = g_checksum_copy(*ctx);
     30        md5_finish(&copy, digest);
    16331}
    16432
    165 void md5_finish_ascii(struct MD5Context *context, char *ascii)
     33void md5_free(md5_state_t *ctx)
    16634{
    167         md5_byte_t bin[16];
    168         int i;
    169        
    170         md5_finish(context, bin);
    171         for (i = 0; i < 16; i ++)
    172                 sprintf(ascii + i * 2, "%02x", bin[i]);
     35        g_checksum_free(*ctx);
    17336}
    174 
    175 /* The four core functions - F1 is optimized somewhat */
    176 
    177 /* #define F1(x, y, z) (x & y | ~x & z) */
    178 #define F1(x, y, z) (z ^ (x & (y ^ z)))
    179 #define F2(x, y, z) F1(z, x, y)
    180 #define F3(x, y, z) (x ^ y ^ z)
    181 #define F4(x, y, z) (y ^ (x | ~z))
    182 
    183 /* This is the central step in the MD5 algorithm. */
    184 #define MD5STEP(f, w, x, y, z, data, s) \
    185         ( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
    186 
    187 /*
    188  * The core of the MD5 algorithm, this alters an existing MD5 hash to
    189  * reflect the addition of 16 longwords of new data.  MD5Update blocks
    190  * the data and converts bytes into longwords for this routine.
    191  */
    192 static void md5_transform(uint32_t buf[4], uint32_t const in[16])
    193 {
    194         register uint32_t a, b, c, d;
    195 
    196         a = buf[0];
    197         b = buf[1];
    198         c = buf[2];
    199         d = buf[3];
    200 
    201         MD5STEP(F1, a, b, c, d, cvt32(in[0]) + 0xd76aa478, 7);
    202         MD5STEP(F1, d, a, b, c, cvt32(in[1]) + 0xe8c7b756, 12);
    203         MD5STEP(F1, c, d, a, b, cvt32(in[2]) + 0x242070db, 17);
    204         MD5STEP(F1, b, c, d, a, cvt32(in[3]) + 0xc1bdceee, 22);
    205         MD5STEP(F1, a, b, c, d, cvt32(in[4]) + 0xf57c0faf, 7);
    206         MD5STEP(F1, d, a, b, c, cvt32(in[5]) + 0x4787c62a, 12);
    207         MD5STEP(F1, c, d, a, b, cvt32(in[6]) + 0xa8304613, 17);
    208         MD5STEP(F1, b, c, d, a, cvt32(in[7]) + 0xfd469501, 22);
    209         MD5STEP(F1, a, b, c, d, cvt32(in[8]) + 0x698098d8, 7);
    210         MD5STEP(F1, d, a, b, c, cvt32(in[9]) + 0x8b44f7af, 12);
    211         MD5STEP(F1, c, d, a, b, cvt32(in[10]) + 0xffff5bb1, 17);
    212         MD5STEP(F1, b, c, d, a, cvt32(in[11]) + 0x895cd7be, 22);
    213         MD5STEP(F1, a, b, c, d, cvt32(in[12]) + 0x6b901122, 7);
    214         MD5STEP(F1, d, a, b, c, cvt32(in[13]) + 0xfd987193, 12);
    215         MD5STEP(F1, c, d, a, b, cvt32(in[14]) + 0xa679438e, 17);
    216         MD5STEP(F1, b, c, d, a, cvt32(in[15]) + 0x49b40821, 22);
    217 
    218         MD5STEP(F2, a, b, c, d, cvt32(in[1]) + 0xf61e2562, 5);
    219         MD5STEP(F2, d, a, b, c, cvt32(in[6]) + 0xc040b340, 9);
    220         MD5STEP(F2, c, d, a, b, cvt32(in[11]) + 0x265e5a51, 14);
    221         MD5STEP(F2, b, c, d, a, cvt32(in[0]) + 0xe9b6c7aa, 20);
    222         MD5STEP(F2, a, b, c, d, cvt32(in[5]) + 0xd62f105d, 5);
    223         MD5STEP(F2, d, a, b, c, cvt32(in[10]) + 0x02441453, 9);
    224         MD5STEP(F2, c, d, a, b, cvt32(in[15]) + 0xd8a1e681, 14);
    225         MD5STEP(F2, b, c, d, a, cvt32(in[4]) + 0xe7d3fbc8, 20);
    226         MD5STEP(F2, a, b, c, d, cvt32(in[9]) + 0x21e1cde6, 5);
    227         MD5STEP(F2, d, a, b, c, cvt32(in[14]) + 0xc33707d6, 9);
    228         MD5STEP(F2, c, d, a, b, cvt32(in[3]) + 0xf4d50d87, 14);
    229         MD5STEP(F2, b, c, d, a, cvt32(in[8]) + 0x455a14ed, 20);
    230         MD5STEP(F2, a, b, c, d, cvt32(in[13]) + 0xa9e3e905, 5);
    231         MD5STEP(F2, d, a, b, c, cvt32(in[2]) + 0xfcefa3f8, 9);
    232         MD5STEP(F2, c, d, a, b, cvt32(in[7]) + 0x676f02d9, 14);
    233         MD5STEP(F2, b, c, d, a, cvt32(in[12]) + 0x8d2a4c8a, 20);
    234 
    235         MD5STEP(F3, a, b, c, d, cvt32(in[5]) + 0xfffa3942, 4);
    236         MD5STEP(F3, d, a, b, c, cvt32(in[8]) + 0x8771f681, 11);
    237         MD5STEP(F3, c, d, a, b, cvt32(in[11]) + 0x6d9d6122, 16);
    238         MD5STEP(F3, b, c, d, a, cvt32(in[14]) + 0xfde5380c, 23);
    239         MD5STEP(F3, a, b, c, d, cvt32(in[1]) + 0xa4beea44, 4);
    240         MD5STEP(F3, d, a, b, c, cvt32(in[4]) + 0x4bdecfa9, 11);
    241         MD5STEP(F3, c, d, a, b, cvt32(in[7]) + 0xf6bb4b60, 16);
    242         MD5STEP(F3, b, c, d, a, cvt32(in[10]) + 0xbebfbc70, 23);
    243         MD5STEP(F3, a, b, c, d, cvt32(in[13]) + 0x289b7ec6, 4);
    244         MD5STEP(F3, d, a, b, c, cvt32(in[0]) + 0xeaa127fa, 11);
    245         MD5STEP(F3, c, d, a, b, cvt32(in[3]) + 0xd4ef3085, 16);
    246         MD5STEP(F3, b, c, d, a, cvt32(in[6]) + 0x04881d05, 23);
    247         MD5STEP(F3, a, b, c, d, cvt32(in[9]) + 0xd9d4d039, 4);
    248         MD5STEP(F3, d, a, b, c, cvt32(in[12]) + 0xe6db99e5, 11);
    249         MD5STEP(F3, c, d, a, b, cvt32(in[15]) + 0x1fa27cf8, 16);
    250         MD5STEP(F3, b, c, d, a, cvt32(in[2]) + 0xc4ac5665, 23);
    251 
    252         MD5STEP(F4, a, b, c, d, cvt32(in[0]) + 0xf4292244, 6);
    253         MD5STEP(F4, d, a, b, c, cvt32(in[7]) + 0x432aff97, 10);
    254         MD5STEP(F4, c, d, a, b, cvt32(in[14]) + 0xab9423a7, 15);
    255         MD5STEP(F4, b, c, d, a, cvt32(in[5]) + 0xfc93a039, 21);
    256         MD5STEP(F4, a, b, c, d, cvt32(in[12]) + 0x655b59c3, 6);
    257         MD5STEP(F4, d, a, b, c, cvt32(in[3]) + 0x8f0ccc92, 10);
    258         MD5STEP(F4, c, d, a, b, cvt32(in[10]) + 0xffeff47d, 15);
    259         MD5STEP(F4, b, c, d, a, cvt32(in[1]) + 0x85845dd1, 21);
    260         MD5STEP(F4, a, b, c, d, cvt32(in[8]) + 0x6fa87e4f, 6);
    261         MD5STEP(F4, d, a, b, c, cvt32(in[15]) + 0xfe2ce6e0, 10);
    262         MD5STEP(F4, c, d, a, b, cvt32(in[6]) + 0xa3014314, 15);
    263         MD5STEP(F4, b, c, d, a, cvt32(in[13]) + 0x4e0811a1, 21);
    264         MD5STEP(F4, a, b, c, d, cvt32(in[4]) + 0xf7537e82, 6);
    265         MD5STEP(F4, d, a, b, c, cvt32(in[11]) + 0xbd3af235, 10);
    266         MD5STEP(F4, c, d, a, b, cvt32(in[2]) + 0x2ad7d2bb, 15);
    267         MD5STEP(F4, b, c, d, a, cvt32(in[9]) + 0xeb86d391, 21);
    268 
    269         buf[0] += a;
    270         buf[1] += b;
    271         buf[2] += c;
    272         buf[3] += d;
    273 }
Note: See TracChangeset for help on using the changeset viewer.