Changeset 34afea7 for lib


Ignore:
Timestamp:
2015-01-31T23:58:57Z (10 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)

Location:
lib
Files:
5 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 }

  • lib/md5.h

    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 
    241#ifndef _MD5_H
    252#define _MD5_H
    263
    27 #include <sys/types.h>
     4#include <glib.h>
    285#include <gmodule.h>
    29 #if(__sun)
    30 #include <inttypes.h>
    31 #else
    32 #include <stdint.h>
    33 #endif
    346
    35 typedef uint8_t md5_byte_t;
    36 typedef struct MD5Context {
    37         uint32_t buf[4];
    38         uint32_t bits[2];
    39         unsigned char in[64];
    40 } md5_state_t;
     7typedef guint8 md5_byte_t;
     8typedef GChecksum *md5_state_t;
    419
    42 G_MODULE_EXPORT void md5_init(struct MD5Context *context);
    43 G_MODULE_EXPORT void md5_append(struct MD5Context *context, const md5_byte_t *buf, unsigned int len);
    44 G_MODULE_EXPORT void md5_finish(struct MD5Context *context, md5_byte_t digest[16]);
    45 G_MODULE_EXPORT void md5_finish_ascii(struct MD5Context *context, char *ascii);
     10
     11#define MD5_HASH_SIZE 16
     12
     13void md5_init(md5_state_t *);
     14void md5_append(md5_state_t *, const guint8 *, unsigned int);
     15void md5_finish(md5_state_t *, guint8 digest[MD5_HASH_SIZE]);
     16void md5_digest_keep(md5_state_t *, guint8 digest[MD5_HASH_SIZE]);
     17void md5_free(md5_state_t *);
    4618
    4719#endif

  • lib/oauth.c

    re41cc40 r34afea7  
    3838                         const char *params, struct oauth_info *oi )
    3939{
    40         uint8_t hash[sha1_hash_size];
     40        uint8_t hash[SHA1_HASH_SIZE];
    4141        GString *payload = g_string_new( "" );
    4242        char *key;
    … …  
    6666        /* base64_encode + HTTP escape it (both consumers
    6767           need it that away) and we're done. */
    68         s = base64_encode( hash, sha1_hash_size );
     68        s = base64_encode( hash, SHA1_HASH_SIZE );
    6969        s = g_realloc( s, strlen( s ) * 3 + 1 );
    7070        http_encode( s );

  • lib/sha1.c

    re41cc40 r34afea7  
    1 /*
    2  * SHA1 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  *  sha1.c
    9  *
    10  *  Description:
    11  *      This file implements the Secure Hashing Algorithm 1 as
    12  *      defined in FIPS PUB 180-1 published April 17, 1995.
    13  *
    14  *      The SHA-1, produces a 160-bit message digest for a given
    15  *      data stream.  It should take about 2**n steps to find a
    16  *      message with the same digest as a given message and
    17  *      2**(n/2) to find any two messages with the same digest,
    18  *      when n is the digest size in bits.  Therefore, this
    19  *      algorithm can serve as a means of providing a
    20  *      "fingerprint" for a message.
    21  *
    22  *  Portability Issues:
    23  *      SHA-1 is defined in terms of 32-bit "words".  This code
    24  *      uses <stdint.h> (included via "sha1.h" to define 32 and 8
    25  *      bit unsigned integer types.  If your C compiler does not
    26  *      support 32 bit unsigned integers, this code is not
    27  *      appropriate.
    28  *
    29  *  Caveats:
    30  *      SHA-1 is designed to work with messages less than 2^64 bits
    31  *      long.  Although SHA-1 allows a message digest to be generated
    32  *      for messages of any number of bits less than 2^64, this
    33  *      implementation only works with messages with a length that is
    34  *      a multiple of the size of an 8-bit character.
    35  *
    36  */
    37 
     1#include "sha1.h"
    382#include <string.h>
    393#include <stdio.h>
    40 #include "sha1.h"
    414
    42 /*
    43  *  Define the SHA1 circular left shift macro
    44  */
    45 #define SHA1CircularShift(bits,word) \
    46        (((word) << (bits)) | ((word) >> (32-(bits))))
    475
    48 /* Local Function Prototyptes */
    49 static void sha1_pad(sha1_state_t *);
    50 static void sha1_process_block(sha1_state_t *);
    51 
    52 /*
    53  *  sha1_init
    54  *
    55  *  Description:
    56  *      This function will initialize the sha1_state_t in preparation
    57  *      for computing a new SHA1 message digest.
    58  *
    59  *  Parameters:
    60  *      context: [in/out]
    61  *          The context to reset.
    62  *
    63  *  Returns:
    64  *      sha Error Code.
    65  *
    66  */
    67 int sha1_init(sha1_state_t * context)
     6void sha1_init(sha1_state_t *ctx)
    687{
    69         context->Length_Low = 0;
    70         context->Length_High = 0;
    71         context->Message_Block_Index = 0;
    72 
    73         context->Intermediate_Hash[0] = 0x67452301;
    74         context->Intermediate_Hash[1] = 0xEFCDAB89;
    75         context->Intermediate_Hash[2] = 0x98BADCFE;
    76         context->Intermediate_Hash[3] = 0x10325476;
    77         context->Intermediate_Hash[4] = 0xC3D2E1F0;
    78 
    79         context->Computed = 0;
    80         context->Corrupted = 0;
    81        
    82         return shaSuccess;
     8        *ctx = g_checksum_new(G_CHECKSUM_SHA1);
    839}
    8410
    85 /*
    86  *  sha1_finish
    87  *
    88  *  Description:
    89  *      This function will return the 160-bit message digest into the
    90  *      Message_Digest array  provided by the caller.
    91  *      NOTE: The first octet of hash is stored in the 0th element,
    92  *            the last octet of hash in the 19th element.
    93  *
    94  *  Parameters:
    95  *      context: [in/out]
    96  *          The context to use to calculate the SHA-1 hash.
    97  *      Message_Digest: [out]
    98  *          Where the digest is returned.
    99  *
    100  *  Returns:
    101  *      sha Error Code.
    102  *
    103  */
    104 int sha1_finish(sha1_state_t * context, uint8_t Message_Digest[sha1_hash_size])
     11void sha1_append(sha1_state_t *ctx, const guint8 * message_array, guint len)
    10512{
    106         int i;
    107 
    108         if (!context || !Message_Digest) {
    109                 return shaNull;
    110         }
    111 
    112         if (context->Corrupted) {
    113                 return context->Corrupted;
    114         }
    115 
    116         if (!context->Computed) {
    117                 sha1_pad(context);
    118                 for (i = 0; i < 64; ++i) {
    119                         /* message may be sensitive, clear it out */
    120                         context->Message_Block[i] = 0;
    121                 }
    122                 context->Length_Low = 0;        /* and clear length */
    123                 context->Length_High = 0;
    124                 context->Computed = 1;
    125 
    126         }
    127 
    128         for (i = 0; i < sha1_hash_size; ++i) {
    129                 Message_Digest[i] = context->Intermediate_Hash[i >> 2]
    130                     >> 8 * (3 - (i & 0x03));
    131         }
    132 
    133         return shaSuccess;
     13        g_checksum_update(*ctx, message_array, len);
    13414}
    13515
    136 /*
    137  *  sha1_append
    138  *
    139  *  Description:
    140  *      This function accepts an array of octets as the next portion
    141  *      of the message.
    142  *
    143  *  Parameters:
    144  *      context: [in/out]
    145  *          The SHA context to update
    146  *      message_array: [in]
    147  *          An array of characters representing the next portion of
    148  *          the message.
    149  *      length: [in]
    150  *          The length of the message in message_array
    151  *
    152  *  Returns:
    153  *      sha Error Code.
    154  *
    155  */
    156 int
    157 sha1_append(sha1_state_t * context,
    158           const uint8_t * message_array, unsigned length)
     16void sha1_finish(sha1_state_t *ctx, guint8 digest[SHA1_HASH_SIZE])
    15917{
    160         if (!length) {
    161                 return shaSuccess;
    162         }
    163 
    164         if (!context || !message_array) {
    165                 return shaNull;
    166         }
    167 
    168         if (context->Computed) {
    169                 context->Corrupted = shaStateError;
    170 
    171                 return shaStateError;
    172         }
    173 
    174         if (context->Corrupted) {
    175                 return context->Corrupted;
    176         }
    177         while (length-- && !context->Corrupted) {
    178                 context->Message_Block[context->Message_Block_Index++] =
    179                     (*message_array & 0xFF);
    180 
    181                 context->Length_Low += 8;
    182                 if (context->Length_Low == 0) {
    183                         context->Length_High++;
    184                         if (context->Length_High == 0) {
    185                                 /* Message is too long */
    186                                 context->Corrupted = 1;
    187                         }
    188                 }
    189 
    190                 if (context->Message_Block_Index == 64) {
    191                         sha1_process_block(context);
    192                 }
    193 
    194                 message_array++;
    195         }
    196 
    197         return shaSuccess;
    198 }
    199 
    200 /*
    201  *  sha1_process_block
    202  *
    203  *  Description:
    204  *      This function will process the next 512 bits of the message
    205  *      stored in the Message_Block array.
    206  *
    207  *  Parameters:
    208  *      None.
    209  *
    210  *  Returns:
    211  *      Nothing.
    212  *
    213  *  Comments:
    214  *      Many of the variable names in this code, especially the
    215  *      single character names, were used because those were the
    216  *      names used in the publication.
    217  *
    218  *
    219  */
    220 static void sha1_process_block(sha1_state_t * context)
    221 {
    222         const uint32_t K[] = {  /* Constants defined in SHA-1   */
    223                 0x5A827999,
    224                 0x6ED9EBA1,
    225                 0x8F1BBCDC,
    226                 0xCA62C1D6
    227         };
    228         int t;                  /* Loop counter                */
    229         uint32_t temp;          /* Temporary word value        */
    230         uint32_t W[80];         /* Word sequence               */
    231         uint32_t A, B, C, D, E; /* Word buffers                */
    232 
    233         /*
    234          *  Initialize the first 16 words in the array W
    235          */
    236         for (t = 0; t < 16; t++) {
    237                 W[t] = context->Message_Block[t * 4] << 24;
    238                 W[t] |= context->Message_Block[t * 4 + 1] << 16;
    239                 W[t] |= context->Message_Block[t * 4 + 2] << 8;
    240                 W[t] |= context->Message_Block[t * 4 + 3];
    241         }
    242 
    243         for (t = 16; t < 80; t++) {
    244                 W[t] =
    245                     SHA1CircularShift(1,
    246                                       W[t - 3] ^ W[t - 8] ^ W[t -
    247                                                               14] ^ W[t -
    248                                                                       16]);
    249         }
    250 
    251         A = context->Intermediate_Hash[0];
    252         B = context->Intermediate_Hash[1];
    253         C = context->Intermediate_Hash[2];
    254         D = context->Intermediate_Hash[3];
    255         E = context->Intermediate_Hash[4];
    256 
    257         for (t = 0; t < 20; t++) {
    258                 temp = SHA1CircularShift(5, A) +
    259                     ((B & C) | ((~B) & D)) + E + W[t] + K[0];
    260                 E = D;
    261                 D = C;
    262                 C = SHA1CircularShift(30, B);
    263 
    264                 B = A;
    265                 A = temp;
    266         }
    267 
    268         for (t = 20; t < 40; t++) {
    269                 temp =
    270                     SHA1CircularShift(5,
    271                                       A) + (B ^ C ^ D) + E + W[t] + K[1];
    272                 E = D;
    273                 D = C;
    274                 C = SHA1CircularShift(30, B);
    275                 B = A;
    276                 A = temp;
    277         }
    278 
    279         for (t = 40; t < 60; t++) {
    280                 temp = SHA1CircularShift(5, A) +
    281                     ((B & C) | (B & D) | (C & D)) + E + W[t] + K[2];
    282                 E = D;
    283                 D = C;
    284                 C = SHA1CircularShift(30, B);
    285                 B = A;
    286                 A = temp;
    287         }
    288 
    289         for (t = 60; t < 80; t++) {
    290                 temp =
    291                     SHA1CircularShift(5,
    292                                       A) + (B ^ C ^ D) + E + W[t] + K[3];
    293                 E = D;
    294                 D = C;
    295                 C = SHA1CircularShift(30, B);
    296                 B = A;
    297                 A = temp;
    298         }
    299 
    300         context->Intermediate_Hash[0] += A;
    301         context->Intermediate_Hash[1] += B;
    302         context->Intermediate_Hash[2] += C;
    303         context->Intermediate_Hash[3] += D;
    304         context->Intermediate_Hash[4] += E;
    305 
    306         context->Message_Block_Index = 0;
    307 }
    308 
    309 /*
    310  *  sha1_pad
    311  *
    312  *  Description:
    313  *      According to the standard, the message must be padded to an even
    314  *      512 bits.  The first padding bit must be a '1'.  The last 64
    315  *      bits represent the length of the original message.  All bits in
    316  *      between should be 0.  This function will pad the message
    317  *      according to those rules by filling the Message_Block array
    318  *      accordingly.  It will also call the ProcessMessageBlock function
    319  *      provided appropriately.  When it returns, it can be assumed that
    320  *      the message digest has been computed.
    321  *
    322  *  Parameters:
    323  *      context: [in/out]
    324  *          The context to pad
    325  *      ProcessMessageBlock: [in]
    326  *          The appropriate SHA*ProcessMessageBlock function
    327  *  Returns:
    328  *      Nothing.
    329  *
    330  */
    331 
    332 static void sha1_pad(sha1_state_t * context)
    333 {
    334         /*
    335          *  Check to see if the current message block is too small to hold
    336          *  the initial padding bits and length.  If so, we will pad the
    337          *  block, process it, and then continue padding into a second
    338          *  block.
    339          */
    340         if (context->Message_Block_Index > 55) {
    341                 context->Message_Block[context->Message_Block_Index++] =
    342                     0x80;
    343                 while (context->Message_Block_Index < 64) {
    344                         context->Message_Block[context->
    345                                                Message_Block_Index++] = 0;
    346                 }
    347 
    348                 sha1_process_block(context);
    349 
    350                 while (context->Message_Block_Index < 56) {
    351                         context->Message_Block[context->
    352                                                Message_Block_Index++] = 0;
    353                 }
    354         } else {
    355                 context->Message_Block[context->Message_Block_Index++] =
    356                     0x80;
    357                 while (context->Message_Block_Index < 56) {
    358 
    359                         context->Message_Block[context->
    360                                                Message_Block_Index++] = 0;
    361                 }
    362         }
    363 
    364         /*
    365          *  Store the message length as the last 8 octets
    366          */
    367         context->Message_Block[56] = context->Length_High >> 24;
    368         context->Message_Block[57] = context->Length_High >> 16;
    369         context->Message_Block[58] = context->Length_High >> 8;
    370         context->Message_Block[59] = context->Length_High;
    371         context->Message_Block[60] = context->Length_Low >> 24;
    372         context->Message_Block[61] = context->Length_Low >> 16;
    373         context->Message_Block[62] = context->Length_Low >> 8;
    374         context->Message_Block[63] = context->Length_Low;
    375 
    376         sha1_process_block(context);
     18        gsize digest_len = SHA1_HASH_SIZE;
     19        g_checksum_get_digest(*ctx, digest, &digest_len);
     20        g_checksum_free(*ctx);
    37721}
    37822
    … …  
    38024
    38125/* BitlBee addition: */
    382 void sha1_hmac(const char *key_, size_t key_len, const char *payload, size_t payload_len, uint8_t Message_Digest[sha1_hash_size])
     26void sha1_hmac(const char *key_, size_t key_len, const char *payload, size_t payload_len, guint8 digest[SHA1_HASH_SIZE])
    38327{
    38428        sha1_state_t sha1;
    385         uint8_t hash[sha1_hash_size];
    386         uint8_t key[HMAC_BLOCK_SIZE+1];
     29        guint8 hash[SHA1_HASH_SIZE];
     30        guint8 key[HMAC_BLOCK_SIZE+1];
    38731        int i;
    38832       
    … …  
    39842        {
    39943                sha1_init( &sha1 );
    400                 sha1_append( &sha1, (uint8_t*) key_, key_len );
     44                sha1_append( &sha1, (guint8*) key_, key_len );
    40145                sha1_finish( &sha1, key );
    40246        }
    … …  
    41155                key[i] ^= 0x36;
    41256        sha1_append( &sha1, key, HMAC_BLOCK_SIZE );
    413         sha1_append( &sha1, (const uint8_t*) payload, payload_len );
     57        sha1_append( &sha1, (const guint8*) payload, payload_len );
    41458        sha1_finish( &sha1, hash );
    41559       
    … …  
    41963                key[i] ^= 0x36 ^ 0x5c;
    42064        sha1_append( &sha1, key, HMAC_BLOCK_SIZE );
    421         sha1_append( &sha1, hash, sha1_hash_size );
    422         sha1_finish( &sha1, Message_Digest );
     65        sha1_append( &sha1, hash, SHA1_HASH_SIZE );
     66        sha1_finish( &sha1, digest );
    42367}
    42468
    … …  
    43175char *sha1_random_uuid( sha1_state_t * context )
    43276{
    433         uint8_t dig[sha1_hash_size];
     77        guint8 dig[SHA1_HASH_SIZE];
    43478        char *ret = g_new0( char, 40 ); /* 36 chars + \0 */
    43579        int i, p;

  • lib/sha1.h

    re41cc40 r34afea7  
    1 /*
    2  * SHA1 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  *  sha1.h
    9  *
    10  *  Description:
    11  *      This is the header file for code which implements the Secure
    12  *      Hashing Algorithm 1 as defined in FIPS PUB 180-1 published
    13  *      April 17, 1995.
    14  *
    15  *      Many of the variable names in this code, especially the
    16  *      single character names, were used because those were the names
    17  *      used in the publication.
    18  *
    19  *      Please read the file sha1.c for more information.
    20  *
    21  */
    221
    232#ifndef _SHA1_H_
    243#define _SHA1_H_
    254
    26 #if(__sun)
    27 #include <inttypes.h>
    28 #else
    29 #include <stdint.h>
    30 #endif
     5#include <glib.h>
    316#include <gmodule.h>
    327
    33 #ifndef _SHA_enum_
    34 #define _SHA_enum_
    35 enum {
    36         shaSuccess = 0,
    37         shaNull,                /* Null pointer parameter */
    38         shaInputTooLong,        /* input data too long */
    39         shaStateError           /* called Input after Result */
    40 };
    41 #endif
    42 #define sha1_hash_size 20
     8#define SHA1_HASH_SIZE 20
    439
    44 /*
    45  *  This structure will hold context information for the SHA-1
    46  *  hashing operation
    47  */
    48 typedef struct SHA1Context {
    49         uint32_t Intermediate_Hash[sha1_hash_size/4];   /* Message Digest   */
     10typedef GChecksum *sha1_state_t;
    5011
    51         uint32_t Length_Low;            /* Message length in bits           */
    52         uint32_t Length_High;           /* Message length in bits           */
    53 
    54         /* Index into message block array   */
    55         int_least16_t Message_Block_Index;
    56         uint8_t Message_Block[64];      /* 512-bit message blocks           */
    57 
    58         int Computed;                   /* Is the digest computed?          */
    59         int Corrupted;                  /* Is the message digest corrupted? */
    60 } sha1_state_t;
    61 
    62 /*
    63  *  Function Prototypes
    64  */
    65 
    66 G_MODULE_EXPORT int sha1_init(sha1_state_t *);
    67 G_MODULE_EXPORT int sha1_append(sha1_state_t *, const uint8_t *, unsigned int);
    68 G_MODULE_EXPORT int sha1_finish(sha1_state_t *, uint8_t Message_Digest[sha1_hash_size]);
    69 G_MODULE_EXPORT void sha1_hmac(const char *key_, size_t key_len, const char *payload, size_t payload_len, uint8_t Message_Digest[sha1_hash_size]);
    70 G_MODULE_EXPORT char *sha1_random_uuid( sha1_state_t * context );
     12void sha1_init(sha1_state_t *);
     13void sha1_append(sha1_state_t *, const guint8 *, unsigned int);
     14void sha1_finish(sha1_state_t *, guint8 digest[SHA1_HASH_SIZE]);
     15void sha1_hmac(const char *, size_t, const char *, size_t, guint8 digest[SHA1_HASH_SIZE]);
     16char *sha1_random_uuid(sha1_state_t *);
    7117
    7218#endif
Note: See TracChangeset for help on using the changeset viewer.