Changeset df6d1da


Ignore:
Timestamp:
2007-11-23T22:25:04Z (17 years ago)
Author:
Wilmer van der Gaast <wilmer@…>
Branches:
master
Children:
77bfd07
Parents:
56f260a
Message:

Replaced GPL-incompatible MD5 hashing code.

Files:
4 edited

Legend:

Unmodified
Added
Removed

  • crypting.c

    r56f260a rdf6d1da  
    2929   the programs will be built. */
    3030
    31 #include "md5.h"
    32 #include "crypting.h"
    3331#include <string.h>
    3432#include <stdio.h>
    3533#include <stdlib.h>
     34#include <glib.h>
     35#include "md5.h"
     36#include "crypting.h"
    3637
    3738/*\

  • debian/copyright

    r56f260a rdf6d1da  
    2828  if not, write to the Free Software Foundation, Inc., 59 Temple Place,
    2929  Suite 330, Boston, MA  02111-1307  USA
    30 ============================================================================
    31 
    32 
    33 
    34 The MD5 generator used for authentication in some modules is written by
    35 Aladdin Enterprises:
    36 
    37 ============================================================================
    38   Copyright (C) 1999 Aladdin Enterprises.  All rights reserved.
    39 
    40   This software is provided 'as-is', without any express or implied
    41   warranty.  In no event will the authors be held liable for any damages
    42   arising from the use of this software.
    43 
    44   Permission is granted to anyone to use this software for any purpose,
    45   including commercial applications, and to alter it and redistribute it
    46   freely, subject to the following restrictions:
    47 
    48   1. The origin of this software must not be misrepresented; you must not
    49      claim that you wrote the original software. If you use this software
    50      in a product, an acknowledgment in the product documentation would be
    51      appreciated but is not required.
    52   2. Altered source versions must be plainly marked as such, and must not be
    53      misrepresented as being the original software.
    54   3. This notice may not be removed or altered from any source distribution.
    5530============================================================================
    5631

  • lib/md5.c

    r56f260a rdf6d1da  
    11/*
    2   Copyright (C) 1999 Aladdin Enterprises.  All rights reserved.
    3 
    4   This software is provided 'as-is', without any express or implied
    5   warranty.  In no event will the authors be held liable for any damages
    6   arising from the use of this software.
    7 
    8   Permission is granted to anyone to use this software for any purpose,
    9   including commercial applications, and to alter it and redistribute it
    10   freely, subject to the following restrictions:
    11 
    12   1. The origin of this software must not be misrepresented; you must not
    13      claim that you wrote the original software. If you use this software
    14      in a product, an acknowledgment in the product documentation would be
    15      appreciated but is not required.
    16   2. Altered source versions must be plainly marked as such, and must not be
    17      misrepresented as being the original software.
    18   3. This notice may not be removed or altered from any source distribution.
    19 
    20   L. Peter Deutsch
    21   ghost@aladdin.com
    22 
    23  */
    24 /*
    25   Independent implementation of MD5 (RFC 1321).
    26 
    27   This code implements the MD5 Algorithm defined in RFC 1321.
    28   It is derived directly from the text of the RFC and not from the
    29   reference implementation.
    30 
    31   The original and principal author of md5.c is L. Peter Deutsch
    32   <ghost@aladdin.com>.  Other authors are noted in the change history
    33   that follows (in reverse chronological order):
    34 
    35   1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
    36   1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5).
    37   1999-05-03 lpd Original version.
    38  */
    39 
     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() */
    4026#include "md5.h"
    41 #include <string.h>
    42 
    43 #ifdef TEST
    44 /*
    45  * Compile with -DTEST to create a self-contained executable test program.
    46  * The test program should print out the same values as given in section
    47  * A.5 of RFC 1321, reproduced below.
    48  */
    49 #include <string.h>
    50 main()
    51 {
    52     static const char *const test[7] = {
    53         "", /*d41d8cd98f00b204e9800998ecf8427e*/
    54         "945399884.61923487334tuvga", /*0cc175b9c0f1b6a831c399e269772661*/
    55         "abc", /*900150983cd24fb0d6963f7d28e17f72*/
    56         "message digest", /*f96b697d7cb7938d525a2f31aaf161d0*/
    57         "abcdefghijklmnopqrstuvwxyz", /*c3fcd3d76192e4007dfb496cca67e13b*/
    58         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
    59                                 /*d174ab98d277d9f5a5611c2c9f419d9f*/
    60         "12345678901234567890123456789012345678901234567890123456789012345678901234567890" /*57edf4a22be3c955ac49da2e2107b67a*/
    61     };
    62     int i;
    63 
    64     for (i = 0; i < 7; ++i) {
    65         md5_state_t state;
    66         md5_byte_t digest[16];
    67         int di;
    68 
    69         md5_init(&state);
    70         md5_append(&state, (const md5_byte_t *)test[i], strlen(test[i]));
    71         md5_finish(&state, digest);
    72         printf("MD5 (\"%s\") = ", test[i]);
    73         for (di = 0; di < 16; ++di)
    74             printf("%02x", digest[di]);
    75         printf("\n");
    76     }
    77     return 0;
    78 }
    79 #endif /* TEST */
    80 
    81 
    82 /*
    83  * For reference, here is the program that computed the T values.
    84  */
    85 #if 0
    86 #include <math.h>
    87 main()
    88 {
    89     int i;
    90     for (i = 1; i <= 64; ++i) {
    91         unsigned long v = (unsigned long)(4294967296.0 * fabs(sin((double)i)));
    92         printf("#define T%d 0x%08lx\n", i, v);
    93     }
    94     return 0;
    95 }
    96 #endif
    97 /*
    98  * End of T computation program.
    99  */
    100 #define T1 0xd76aa478
    101 #define T2 0xe8c7b756
    102 #define T3 0x242070db
    103 #define T4 0xc1bdceee
    104 #define T5 0xf57c0faf
    105 #define T6 0x4787c62a
    106 #define T7 0xa8304613
    107 #define T8 0xfd469501
    108 #define T9 0x698098d8
    109 #define T10 0x8b44f7af
    110 #define T11 0xffff5bb1
    111 #define T12 0x895cd7be
    112 #define T13 0x6b901122
    113 #define T14 0xfd987193
    114 #define T15 0xa679438e
    115 #define T16 0x49b40821
    116 #define T17 0xf61e2562
    117 #define T18 0xc040b340
    118 #define T19 0x265e5a51
    119 #define T20 0xe9b6c7aa
    120 #define T21 0xd62f105d
    121 #define T22 0x02441453
    122 #define T23 0xd8a1e681
    123 #define T24 0xe7d3fbc8
    124 #define T25 0x21e1cde6
    125 #define T26 0xc33707d6
    126 #define T27 0xf4d50d87
    127 #define T28 0x455a14ed
    128 #define T29 0xa9e3e905
    129 #define T30 0xfcefa3f8
    130 #define T31 0x676f02d9
    131 #define T32 0x8d2a4c8a
    132 #define T33 0xfffa3942
    133 #define T34 0x8771f681
    134 #define T35 0x6d9d6122
    135 #define T36 0xfde5380c
    136 #define T37 0xa4beea44
    137 #define T38 0x4bdecfa9
    138 #define T39 0xf6bb4b60
    139 #define T40 0xbebfbc70
    140 #define T41 0x289b7ec6
    141 #define T42 0xeaa127fa
    142 #define T43 0xd4ef3085
    143 #define T44 0x04881d05
    144 #define T45 0xd9d4d039
    145 #define T46 0xe6db99e5
    146 #define T47 0x1fa27cf8
    147 #define T48 0xc4ac5665
    148 #define T49 0xf4292244
    149 #define T50 0x432aff97
    150 #define T51 0xab9423a7
    151 #define T52 0xfc93a039
    152 #define T53 0x655b59c3
    153 #define T54 0x8f0ccc92
    154 #define T55 0xffeff47d
    155 #define T56 0x85845dd1
    156 #define T57 0x6fa87e4f
    157 #define T58 0xfe2ce6e0
    158 #define T59 0xa3014314
    159 #define T60 0x4e0811a1
    160 #define T61 0xf7537e82
    161 #define T62 0xbd3af235
    162 #define T63 0x2ad7d2bb
    163 #define T64 0xeb86d391
    164 
    165 static void
    166 md5_process(md5_state_t *pms, const md5_byte_t *data /*[64]*/)
    167 {
    168     md5_word_t
    169         a = pms->abcd[0], b = pms->abcd[1],
    170         c = pms->abcd[2], d = pms->abcd[3];
    171     md5_word_t t;
    172 
    173 #ifndef ARCH_IS_BIG_ENDIAN
    174 # define ARCH_IS_BIG_ENDIAN 1   /* slower, default implementation */
    175 #endif
    176 #if ARCH_IS_BIG_ENDIAN
    177 
    178     /*
    179      * On big-endian machines, we must arrange the bytes in the right
    180      * order.  (This also works on machines of unknown byte order.)
    181      */
    182     md5_word_t X[16];
    183     const md5_byte_t *xp = data;
    184     int i;
    185 
    186     for (i = 0; i < 16; ++i, xp += 4)
    187         X[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24);
    188 
    189 #else  /* !ARCH_IS_BIG_ENDIAN */
    190 
    191     /*
    192      * On little-endian machines, we can process properly aligned data
    193      * without copying it.
    194      */
    195     md5_word_t xbuf[16];
    196     const md5_word_t *X;
    197 
    198     if (!((data - (const md5_byte_t *)0) & 3)) {
    199         /* data are properly aligned */
    200         X = (const md5_word_t *)data;
    201     } else {
    202         /* not aligned */
    203         memcpy(xbuf, data, 64);
    204         X = xbuf;
    205     }
    206 #endif
    207 
    208 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
    209 
    210     /* Round 1. */
    211     /* Let [abcd k s i] denote the operation
    212        a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
    213 #define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
    214 #define SET(a, b, c, d, k, s, Ti)\
    215   t = a + F(b,c,d) + X[k] + Ti;\
    216   a = ROTATE_LEFT(t, s) + b
    217     /* Do the following 16 operations. */
    218     SET(a, b, c, d,  0,  7,  T1);
    219     SET(d, a, b, c,  1, 12,  T2);
    220     SET(c, d, a, b,  2, 17,  T3);
    221     SET(b, c, d, a,  3, 22,  T4);
    222     SET(a, b, c, d,  4,  7,  T5);
    223     SET(d, a, b, c,  5, 12,  T6);
    224     SET(c, d, a, b,  6, 17,  T7);
    225     SET(b, c, d, a,  7, 22,  T8);
    226     SET(a, b, c, d,  8,  7,  T9);
    227     SET(d, a, b, c,  9, 12, T10);
    228     SET(c, d, a, b, 10, 17, T11);
    229     SET(b, c, d, a, 11, 22, T12);
    230     SET(a, b, c, d, 12,  7, T13);
    231     SET(d, a, b, c, 13, 12, T14);
    232     SET(c, d, a, b, 14, 17, T15);
    233     SET(b, c, d, a, 15, 22, T16);
    234 #undef SET
    235 
    236      /* Round 2. */
    237      /* Let [abcd k s i] denote the operation
    238           a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
    239 #define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
    240 #define SET(a, b, c, d, k, s, Ti)\
    241   t = a + G(b,c,d) + X[k] + Ti;\
    242   a = ROTATE_LEFT(t, s) + b
    243      /* Do the following 16 operations. */
    244     SET(a, b, c, d,  1,  5, T17);
    245     SET(d, a, b, c,  6,  9, T18);
    246     SET(c, d, a, b, 11, 14, T19);
    247     SET(b, c, d, a,  0, 20, T20);
    248     SET(a, b, c, d,  5,  5, T21);
    249     SET(d, a, b, c, 10,  9, T22);
    250     SET(c, d, a, b, 15, 14, T23);
    251     SET(b, c, d, a,  4, 20, T24);
    252     SET(a, b, c, d,  9,  5, T25);
    253     SET(d, a, b, c, 14,  9, T26);
    254     SET(c, d, a, b,  3, 14, T27);
    255     SET(b, c, d, a,  8, 20, T28);
    256     SET(a, b, c, d, 13,  5, T29);
    257     SET(d, a, b, c,  2,  9, T30);
    258     SET(c, d, a, b,  7, 14, T31);
    259     SET(b, c, d, a, 12, 20, T32);
    260 #undef SET
    261 
    262      /* Round 3. */
    263      /* Let [abcd k s t] denote the operation
    264           a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
    265 #define H(x, y, z) ((x) ^ (y) ^ (z))
    266 #define SET(a, b, c, d, k, s, Ti)\
    267   t = a + H(b,c,d) + X[k] + Ti;\
    268   a = ROTATE_LEFT(t, s) + b
    269      /* Do the following 16 operations. */
    270     SET(a, b, c, d,  5,  4, T33);
    271     SET(d, a, b, c,  8, 11, T34);
    272     SET(c, d, a, b, 11, 16, T35);
    273     SET(b, c, d, a, 14, 23, T36);
    274     SET(a, b, c, d,  1,  4, T37);
    275     SET(d, a, b, c,  4, 11, T38);
    276     SET(c, d, a, b,  7, 16, T39);
    277     SET(b, c, d, a, 10, 23, T40);
    278     SET(a, b, c, d, 13,  4, T41);
    279     SET(d, a, b, c,  0, 11, T42);
    280     SET(c, d, a, b,  3, 16, T43);
    281     SET(b, c, d, a,  6, 23, T44);
    282     SET(a, b, c, d,  9,  4, T45);
    283     SET(d, a, b, c, 12, 11, T46);
    284     SET(c, d, a, b, 15, 16, T47);
    285     SET(b, c, d, a,  2, 23, T48);
    286 #undef SET
    287 
    288      /* Round 4. */
    289      /* Let [abcd k s t] denote the operation
    290           a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
    291 #define I(x, y, z) ((y) ^ ((x) | ~(z)))
    292 #define SET(a, b, c, d, k, s, Ti)\
    293   t = a + I(b,c,d) + X[k] + Ti;\
    294   a = ROTATE_LEFT(t, s) + b
    295      /* Do the following 16 operations. */
    296     SET(a, b, c, d,  0,  6, T49);
    297     SET(d, a, b, c,  7, 10, T50);
    298     SET(c, d, a, b, 14, 15, T51);
    299     SET(b, c, d, a,  5, 21, T52);
    300     SET(a, b, c, d, 12,  6, T53);
    301     SET(d, a, b, c,  3, 10, T54);
    302     SET(c, d, a, b, 10, 15, T55);
    303     SET(b, c, d, a,  1, 21, T56);
    304     SET(a, b, c, d,  8,  6, T57);
    305     SET(d, a, b, c, 15, 10, T58);
    306     SET(c, d, a, b,  6, 15, T59);
    307     SET(b, c, d, a, 13, 21, T60);
    308     SET(a, b, c, d,  4,  6, T61);
    309     SET(d, a, b, c, 11, 10, T62);
    310     SET(c, d, a, b,  2, 15, T63);
    311     SET(b, c, d, a,  9, 21, T64);
    312 #undef SET
    313 
    314      /* Then perform the following additions. (That is increment each
    315         of the four registers by the value it had before this block
    316         was started.) */
    317     pms->abcd[0] += a;
    318     pms->abcd[1] += b;
    319     pms->abcd[2] += c;
    320     pms->abcd[3] += d;
    321 }
    322 
    323 void
    324 md5_init(md5_state_t *pms)
    325 {
    326     pms->count[0] = pms->count[1] = 0;
    327     pms->abcd[0] = 0x67452301;
    328     pms->abcd[1] = 0xefcdab89;
    329     pms->abcd[2] = 0x98badcfe;
    330     pms->abcd[3] = 0x10325476;
    331 }
    332 
    333 void
    334 md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes)
    335 {
    336     const md5_byte_t *p = data;
    337     int left = nbytes;
    338     int offset = (pms->count[0] >> 3) & 63;
    339     md5_word_t nbits = (md5_word_t)(nbytes << 3);
    340 
    341     if (nbytes <= 0)
    342         return;
    343 
    344     /* Update the message length. */
    345     pms->count[1] += nbytes >> 29;
    346     pms->count[0] += nbits;
    347     if (pms->count[0] < nbits)
    348         pms->count[1]++;
    349 
    350     /* Process an initial partial block. */
    351     if (offset) {
    352         int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
    353 
    354         memcpy(pms->buf + offset, p, copy);
    355         if (offset + copy < 64)
    356             return;
    357         p += copy;
    358         left -= copy;
    359         md5_process(pms, pms->buf);
    360     }
    361 
    362     /* Process full blocks. */
    363     for (; left >= 64; p += 64, left -= 64)
    364         md5_process(pms, p);
    365 
    366     /* Process a final partial block. */
    367     if (left)
    368         memcpy(pms->buf, p, left);
    369 }
    370 
    371 void
    372 md5_finish(md5_state_t *pms, md5_byte_t digest[16])
    373 {
    374     static const md5_byte_t pad[64] = {
    375         0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    376         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    377         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    378         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
    379     };
    380     md5_byte_t data[8];
    381     int i;
    382 
    383     /* Save the length before padding. */
    384     for (i = 0; i < 8; ++i)
    385         data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3));
    386     /* Pad to 56 bytes mod 64. */
    387     md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
    388     /* Append the length. */
    389     md5_append(pms, data, 8);
    390     for (i = 0; i < 16; ++i)
    391         digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3));
    392 }
     27
     28static void md5_transform(u_int32_t buf[4], u_int32_t const in[16]);
     29
     30/*
     31 * Wrapper function for all-in-one MD5
     32 *
     33 * Bernardo Reino, aka Lepton.
     34 * 20021120
     35 */
     36
     37void md5_init(struct MD5Context *ctx)
     38{
     39        ctx->buf[0] = 0x67452301;
     40        ctx->buf[1] = 0xefcdab89;
     41        ctx->buf[2] = 0x98badcfe;
     42        ctx->buf[3] = 0x10325476;
     43
     44        ctx->bits[0] = 0;
     45        ctx->bits[1] = 0;
     46}
     47
     48/*
     49 * Update context to reflect the concatenation of another buffer full
     50 * of bytes.
     51 */
     52void md5_append(struct MD5Context *ctx, const md5_byte_t *buf,
     53                unsigned int len)
     54{
     55        u_int32_t t;
     56
     57        /* Update bitcount */
     58
     59        t = ctx->bits[0];
     60        if ((ctx->bits[0] = t + ((u_int32_t) len << 3)) < t)
     61                ctx->bits[1]++; /* Carry from low to high */
     62        ctx->bits[1] += len >> 29;
     63
     64        t = (t >> 3) & 0x3f;    /* Bytes already in shsInfo->data */
     65
     66        /* Handle any leading odd-sized chunks */
     67
     68        if (t) {
     69                unsigned char *p = (unsigned char *) ctx->in + t;
     70
     71                t = 64 - t;
     72                if (len < t) {
     73                        memcpy(p, buf, len);
     74                        return;
     75                }
     76                memcpy(p, buf, t);
     77                md5_transform(ctx->buf, (u_int32_t *) ctx->in);
     78                buf += t;
     79                len -= t;
     80        }
     81        /* Process data in 64-byte chunks */
     82
     83        while (len >= 64) {
     84                memcpy(ctx->in, buf, 64);
     85                md5_transform(ctx->buf, (u_int32_t *) ctx->in);
     86                buf += 64;
     87                len -= 64;
     88        }
     89
     90        /* Handle any remaining bytes of data. */
     91
     92        memcpy(ctx->in, buf, len);
     93}
     94
     95/*
     96 * Final wrapup - pad to 64-byte boundary with the bit pattern
     97 * 1 0* (64-bit count of bits processed, MSB-first)
     98 */
     99void md5_finish(struct MD5Context *ctx, md5_byte_t digest[16])
     100{
     101        unsigned count;
     102        unsigned char *p;
     103
     104        /* Compute number of bytes mod 64 */
     105        count = (ctx->bits[0] >> 3) & 0x3F;
     106
     107        /* Set the first char of padding to 0x80.  This is safe since there is
     108           always at least one byte free */
     109        p = ctx->in + count;
     110        *p++ = 0x80;
     111
     112        /* Bytes of padding needed to make 64 bytes */
     113        count = 64 - 1 - count;
     114
     115        /* Pad out to 56 mod 64 */
     116        if (count < 8) {
     117                /* Two lots of padding:  Pad the first block to 64 bytes */
     118                memset(p, 0, count);
     119                md5_transform(ctx->buf, (u_int32_t *) ctx->in);
     120
     121                /* Now fill the next block with 56 bytes */
     122                memset(ctx->in, 0, 56);
     123        } else {
     124                /* Pad block to 56 bytes */
     125                memset(p, 0, count - 8);
     126        }
     127
     128        /* Append length in bits and transform */
     129        ((u_int32_t *) ctx->in)[14] = ctx->bits[0];
     130        ((u_int32_t *) ctx->in)[15] = ctx->bits[1];
     131
     132        md5_transform(ctx->buf, (u_int32_t *) ctx->in);
     133        memcpy(digest, ctx->buf, 16);
     134        memset(ctx, 0, sizeof(ctx));    /* In case it's sensitive */
     135}
     136
     137/* The four core functions - F1 is optimized somewhat */
     138
     139/* #define F1(x, y, z) (x & y | ~x & z) */
     140#define F1(x, y, z) (z ^ (x & (y ^ z)))
     141#define F2(x, y, z) F1(z, x, y)
     142#define F3(x, y, z) (x ^ y ^ z)
     143#define F4(x, y, z) (y ^ (x | ~z))
     144
     145/* This is the central step in the MD5 algorithm. */
     146#define MD5STEP(f, w, x, y, z, data, s) \
     147        ( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
     148
     149/*
     150 * The core of the MD5 algorithm, this alters an existing MD5 hash to
     151 * reflect the addition of 16 longwords of new data.  MD5Update blocks
     152 * the data and converts bytes into longwords for this routine.
     153 */
     154static void md5_transform(u_int32_t buf[4], u_int32_t const in[16])
     155{
     156        register u_int32_t a, b, c, d;
     157
     158        a = buf[0];
     159        b = buf[1];
     160        c = buf[2];
     161        d = buf[3];
     162
     163        MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
     164        MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
     165        MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
     166        MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
     167        MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
     168        MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
     169        MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
     170        MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
     171        MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
     172        MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
     173        MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
     174        MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
     175        MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
     176        MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
     177        MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
     178        MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
     179
     180        MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
     181        MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
     182        MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
     183        MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
     184        MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
     185        MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
     186        MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
     187        MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
     188        MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
     189        MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
     190        MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
     191        MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
     192        MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
     193        MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
     194        MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
     195        MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
     196
     197        MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
     198        MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
     199        MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
     200        MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
     201        MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
     202        MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
     203        MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
     204        MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
     205        MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
     206        MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
     207        MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
     208        MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
     209        MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
     210        MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
     211        MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
     212        MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
     213
     214        MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
     215        MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
     216        MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
     217        MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
     218        MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
     219        MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
     220        MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
     221        MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
     222        MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
     223        MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
     224        MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
     225        MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
     226        MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
     227        MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
     228        MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
     229        MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
     230
     231        buf[0] += a;
     232        buf[1] += b;
     233        buf[2] += c;
     234        buf[3] += d;
     235}

  • lib/md5.h

    r56f260a rdf6d1da  
    11/*
    2   Copyright (C) 1999 Aladdin Enterprises.  All rights reserved.
    3  
    4   This software is provided 'as-is', without any express or implied
    5   warranty.  In no event will the authors be held liable for any damages
    6   arising from the use of this software.
    7 
    8   Permission is granted to anyone to use this software for any purpose,
    9   including commercial applications, and to alter it and redistribute it
    10   freely, subject to the following restrictions:
    11 
    12   1. The origin of this software must not be misrepresented; you must not
    13      claim that you wrote the original software. If you use this software
    14      in a product, an acknowledgment in the product documentation would be
    15      appreciated but is not required.
    16   2. Altered source versions must be plainly marked as such, and must not be
    17      misrepresented as being the original software.
    18   3. This notice may not be removed or altered from any source distribution.
    19 
    20   L. Peter Deutsch
    21   ghost@aladdin.com
    22 
    23  */
    24 /*
    25   Independent implementation of MD5 (RFC 1321).
    26 
    27   This code implements the MD5 Algorithm defined in RFC 1321.
    28   It is derived directly from the text of the RFC and not from the
    29   reference implementation.
    30 
    31   The original and principal author of md5.h is L. Peter Deutsch
    32   <ghost@aladdin.com>.  Other authors are noted in the change history
    33   that follows (in reverse chronological order):
    34 
    35   2004-03-09 Jelmer Vernooij add G_MODULE_EXPORT for Bitlbee
    36   1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
    37   1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5);
    38         added conditionalization for C++ compilation from Martin
    39         Purschke <purschke@bnl.gov>.
    40   1999-05-03 lpd Original version.
     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.
    415 */
    426
    43 #ifndef md5_INCLUDED
    44 #  define md5_INCLUDED
     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 */
    4523
    46 #include <glib.h>
     24#ifndef _MD5_H
     25#define _MD5_H
     26
     27#include <sys/types.h>
    4728#include <gmodule.h>
    4829
    49 /*
    50  * This code has some adaptations for the Ghostscript environment, but it
    51  * will compile and run correctly in any environment with 8-bit chars and
    52  * 32-bit ints.  Specifically, it assumes that if the following are
    53  * defined, they have the same meaning as in Ghostscript: P1, P2, P3,
    54  * ARCH_IS_BIG_ENDIAN.
    55  */
    56 
    57 typedef unsigned char md5_byte_t; /* 8-bit byte */
    58 typedef unsigned int md5_word_t; /* 32-bit word */
    59 
    60 /* Define the state of the MD5 Algorithm. */
    61 typedef struct md5_state_s {
    62     md5_word_t count[2];        /* message length in bits, lsw first */
    63     md5_word_t abcd[4];         /* digest buffer */
    64     md5_byte_t buf[64];         /* accumulate block */
     30typedef u_int8_t md5_byte_t;
     31typedef struct MD5Context {
     32        u_int32_t buf[4];
     33        u_int32_t bits[2];
     34        unsigned char in[64];
    6535} md5_state_t;
    6636
    67 #ifdef __cplusplus
    68 extern "C"
    69 {
     37G_MODULE_EXPORT void md5_init(struct MD5Context *context);
     38G_MODULE_EXPORT void md5_append(struct MD5Context *context, const md5_byte_t *buf, unsigned int len);
     39G_MODULE_EXPORT void md5_finish(struct MD5Context *context, md5_byte_t digest[16]);
     40
    7041#endif
    71 
    72 /* Initialize the algorithm. */
    73 G_MODULE_EXPORT void md5_init(md5_state_t *pms);
    74 
    75 /* Append a string to the message. */
    76 G_MODULE_EXPORT void md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes);
    77 
    78 /* Finish the message and return the digest. */
    79 G_MODULE_EXPORT void md5_finish(md5_state_t *pms, md5_byte_t digest[16]);
    80 
    81 #ifdef __cplusplus
    82 }  /* end extern "C" */
    83 #endif
    84 
    85 #endif /* md5_INCLUDED */
Note: See TracChangeset for help on using the changeset viewer.