Logo Search packages:      
Sourcecode: ksh version File versions  Download package

sum-md5.c

/***********************************************************************
*                                                                      *
*               This software is part of the ast package               *
*          Copyright (c) 1996-2009 AT&T Intellectual Property          *
*                      and is licensed under the                       *
*                  Common Public License, Version 1.0                  *
*                    by AT&T Intellectual Property                     *
*                                                                      *
*                A copy of the License is available at                 *
*            http://www.opensource.org/licenses/cpl1.0.txt             *
*         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
*                                                                      *
*              Information and Software Systems Research               *
*                            AT&T Research                             *
*                           Florham Park NJ                            *
*                                                                      *
*                 Glenn Fowler <gsf@research.att.com>                  *
*                                                                      *
***********************************************************************/
#pragma prototyped

/*
 * md5
 */

/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
   rights reserved.

   License to copy and use this software is granted provided that it
   is identified as the "RSA Data Security, Inc. MD5 Message-Digest
   Method" in all material mentioning or referencing this software
   or this function.

   License is also granted to make and use derivative works provided
   that such works are identified as "derived from the RSA Data
   Security, Inc. MD5 Message-Digest Method" in all material
   mentioning or referencing the derived work.

   RSA Data Security, Inc. makes no representations concerning either
   the merchantability of this software or the suitability of this
   software for any particular purpose. It is provided "as is"
   without express or implied warranty of any kind.

   These notices must be retained in any copies of any part of this
   documentation and/or software.
 */

#define md5_description \
      "The RSA Data Security, Inc. MD5 Message-Digest Method, 1991-2, \
      used with permission. The block count is not printed."
#define md5_options     "[+(version)?md5 (RSA Data Security, Inc. MD5 Message-Digest, 1991-2) 1996-02-29]"
#define md5_match "md5|MD5"
#define md5_scale 0

typedef uint32_t UINT4;

typedef struct Md5_s
{
      _SUM_PUBLIC_
      _SUM_PRIVATE_
      UINT4       state[4];   /* state (ABCD)               */
      UINT4       count[2];   /* # bits handled mod 2^64 (lsb)*/
      unsigned char     buffer[64]; /* input buffer               */
      unsigned char     digest[16]; /* final digest               */
      unsigned char     digest_sum[16]; /* sum of all digests           */
} Md5_t;

static const unsigned char    md5_pad[] =
{
      0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

/*
 * encode input into output
 * len must be a multiple of 4
 */

static void
md5_encode(register unsigned char* output, register UINT4* input, unsigned int len)
{
      register unsigned int   i;
      register unsigned int   j;

      for (i = j = 0; j < len; i++, j += 4)
      {
            output[j] = (unsigned char)(input[i] & 0xff);
            output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
            output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
            output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
      }
}

/*
 * decode input into output
 * len must be a multiple of 4
 */

static void
md5_decode(register UINT4* output, register unsigned char* input, unsigned int len)
{
      unsigned int      i;
      unsigned int      j;

      for (i = j = 0; j < len; i++, j += 4)
            output[i] = ((UINT4)input[j]) |
                      (((UINT4)input[j+1]) << 8) |
                      (((UINT4)input[j+2]) << 16) |
                      (((UINT4)input[j+3]) << 24);
}

static int
md5_init(Sum_t* p)
{
      register Md5_t*   context = (Md5_t*)p;

      context->count[0] = context->count[1] = 0;
      context->state[0] = 0x67452301;
      context->state[1] = 0xefcdab89;
      context->state[2] = 0x98badcfe;
      context->state[3] = 0x10325476;
      return 0;
}

static Sum_t*
md5_open(const Method_t* method, const char* name)
{
      Md5_t*      p;

      if (p = newof(0, Md5_t, 1, 0))
      {
            p->method = (Method_t*)method;
            p->name = name;
            md5_init((Sum_t*)p);
      }
      return (Sum_t*)p;
}

/*
 * basic MD5 step -- transforms buf based on in
 */

#define S11 7
#define S12 12
#define S13 17
#define S14 22
#define S21 5
#define S22 9
#define S23 14
#define S24 20
#define S31 4
#define S32 11
#define S33 16
#define S34 23
#define S41 6
#define S42 10
#define S43 15
#define S44 21

/* F, G, H and I are basic MD5 functions */
#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define I(x, y, z) ((y) ^ ((x) | (~z)))

/* ROTATE_LEFT rotates x left n bits */
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))

/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4 */
/* Rotation is separate from addition to prevent recomputation */
#define FF(a, b, c, d, x, s, ac) { \
    (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
    (a) = ROTATE_LEFT ((a), (s)); \
    (a) += (b); \
  }
#define GG(a, b, c, d, x, s, ac) { \
    (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
    (a) = ROTATE_LEFT ((a), (s)); \
    (a) += (b); \
  }
#define HH(a, b, c, d, x, s, ac) { \
    (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
    (a) = ROTATE_LEFT ((a), (s)); \
    (a) += (b); \
  }
#define II(a, b, c, d, x, s, ac) { \
    (a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
    (a) = ROTATE_LEFT ((a), (s)); \
    (a) += (b); \
  }

static void
md5_transform(UINT4 state[4], unsigned char block[64])
{
      UINT4 a = state[0];
      UINT4 b = state[1];
      UINT4 c = state[2];
      UINT4 d = state[3];
      UINT4 x[16];

      md5_decode(x, block, 64);

      /* round 1 */
      FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
      FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
      FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
      FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
      FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
      FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
      FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
      FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
      FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
      FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
      FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
      FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
      FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
      FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
      FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
      FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */

      /* round 2 */
      GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
      GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
      GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
      GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
      GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
      GG (d, a, b, c, x[10], S22, 0x02441453); /* 22 */
      GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
      GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
      GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
      GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
      GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
      GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
      GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
      GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
      GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
      GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */

      /* round 3 */
      HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
      HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
      HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
      HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
      HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
      HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
      HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
      HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
      HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
      HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
      HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
      HH (b, c, d, a, x[ 6], S34, 0x04881d05); /* 44 */
      HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
      HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
      HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
      HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */

      /* round 4 */
      II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
      II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
      II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
      II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
      II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
      II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
      II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
      II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
      II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
      II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
      II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
      II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
      II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
      II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
      II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
      II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */

      state[0] += a;
      state[1] += b;
      state[2] += c;
      state[3] += d;
}

static int
md5_block(Sum_t* p, const void* s, size_t inputLen)
{
      register Md5_t*   context = (Md5_t*)p;
      unsigned char*    input = (unsigned char*)s;
      unsigned int      i;
      unsigned int      index;
      unsigned int      partLen;

      /* compute number of bytes mod 64 */
      index = (unsigned int)((context->count[0] >> 3) & 0x3f);

      /* update number of bits */
      if ((context->count[0] += ((UINT4)inputLen << 3)) < ((UINT4)inputLen << 3))
            context->count[1]++;
      context->count[1] += ((UINT4)inputLen >> 29);
      partLen = 64 - index;

      /* transform as many times as possible */
      if (inputLen >= partLen)
      {
            memcpy(&context->buffer[index], input, partLen);
            md5_transform(context->state, context->buffer);
            for (i = partLen; i + 63 < inputLen; i += 64)
                  md5_transform(context->state, &input[i]);
            index = 0;
      }
      else
            i = 0;

      /* buffer remaining input */
      memcpy(&context->buffer[index], &input[i], inputLen - i);

      return 0;
}

static int
md5_done(Sum_t* p)
{
      register Md5_t*   context = (Md5_t*)p;
      unsigned char     bits[8];
      unsigned int      index;
      unsigned int      padLen;

      /* save number of bits */
      md5_encode(bits, context->count, sizeof(bits));

      /* pad out to 56 mod 64 */
      index = (unsigned int)((context->count[0] >> 3) & 0x3f);
      padLen = (index < 56) ? (56 - index) : (120 - index);
      md5_block(p, md5_pad, padLen);

      /* append length (before padding) */
      md5_block(p, bits, sizeof(bits));

      /* store state in digest */
      md5_encode(context->digest, context->state, sizeof(context->digest));

      /* accumulate the digests */
      for (index = 0; index < elementsof(context->digest); index++)
            context->digest_sum[index] ^= context->digest[index];

      return 0;
}

static int
md5_print(Sum_t* p, Sfio_t* sp, register int flags, size_t scale)
{
      register Md5_t*         x = (Md5_t*)p;
      register unsigned char* d;
      register int            n;

      d = (flags & SUM_TOTAL) ? x->digest_sum : x->digest;
      for (n = 0; n < elementsof(x->digest); n++)
            sfprintf(sp, "%02x", d[n]);
      return 0;
}

static int
md5_data(Sum_t* p, Sumdata_t* data)
{
      register Md5_t*         x = (Md5_t*)p;

      data->size = elementsof(x->digest);
      data->num = 0;
      data->buf = x->digest;
      return 0;
}

Generated by  Doxygen 1.6.0   Back to index