"Fossies" - the Fresh Open Source Software Archive

Member "motion-Release-4.3.0/src/md5.c" (14 Jan 2020, 10509 Bytes) of package /linux/misc/motion-Release-4.3.0.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "md5.c" see the Fossies "Dox" file reference documentation.

    1 /*
    2  * MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm
    3  * taken from RFC 1321
    4  */
    5 
    6 /*
    7  Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
    8 rights reserved.
    9 
   10 License to copy and use this software is granted provided that it
   11 is identified as the "RSA Data Security, Inc. MD5 Message-Digest
   12 Algorithm" in all material mentioning or referencing this software
   13 or this function.
   14 
   15 License is also granted to make and use derivative works provided
   16 that such works are identified as "derived from the RSA Data
   17 Security, Inc. MD5 Message-Digest Algorithm" in all material
   18 mentioning or referencing the derived work.
   19 
   20 RSA Data Security, Inc. makes no representations concerning either
   21 the merchantability of this software or the suitability of this
   22 software for any particular purpose. It is provided "as is"
   23 without express or implied warranty of any kind.
   24 
   25 These notices must be retained in any copies of any part of this
   26 documentation and/or software.
   27 */
   28 
   29 #include "md5.h"
   30 
   31 /*
   32  * Constants for MD5Transform routine.
   33  */
   34 
   35 #define S11 7
   36 #define S12 12
   37 #define S13 17
   38 #define S14 22
   39 #define S21 5
   40 #define S22 9
   41 #define S23 14
   42 #define S24 20
   43 #define S31 4
   44 #define S32 11
   45 #define S33 16
   46 #define S34 23
   47 #define S41 6
   48 #define S42 10
   49 #define S43 15
   50 #define S44 21
   51 
   52 static void MD5Transform(UINT4 [4], unsigned char [64]);
   53 static void Encode(unsigned char *, UINT4 *, unsigned int);
   54 static void Decode(UINT4 *, unsigned char *, unsigned int);
   55 static void MD5_memcpy(POINTER, POINTER, unsigned int);
   56 static void MD5_memset(POINTER, int, unsigned int);
   57 
   58 static unsigned char PADDING[64] = {
   59   0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   60   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
   61   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
   62 };
   63 
   64 /*
   65  * F, G, H and I are basic MD5 functions.
   66  */
   67 #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
   68 #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
   69 #define H(x, y, z) ((x) ^ (y) ^ (z))
   70 #define I(x, y, z) ((y) ^ ((x) | (~z)))
   71 
   72 /*
   73  * ROTATE_LEFT rotates x left n bits.
   74  */
   75 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
   76 
   77 /*
   78  * FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
   79  * Rotation is separate from addition to prevent recomputation.
   80  */
   81 #define FF(a, b, c, d, x, s, ac) { \
   82  (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \
   83  (a) = ROTATE_LEFT ((a), (s)); \
   84  (a) += (b); \
   85   }
   86 #define GG(a, b, c, d, x, s, ac) { \
   87  (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \
   88  (a) = ROTATE_LEFT ((a), (s)); \
   89  (a) += (b); \
   90   }
   91 #define HH(a, b, c, d, x, s, ac) { \
   92  (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \
   93  (a) = ROTATE_LEFT ((a), (s)); \
   94  (a) += (b); \
   95   }
   96 #define II(a, b, c, d, x, s, ac) { \
   97  (a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \
   98  (a) = ROTATE_LEFT ((a), (s)); \
   99  (a) += (b); \
  100   }
  101 
  102 /*
  103  * MD5 initialization. Begins an MD5 operation, writing a new context.
  104  */
  105 void MD5Init(MD5_CTX *context)
  106 {
  107   context->count[0] = context->count[1] = 0;
  108   /* Load magic initialization constants. */
  109   context->state[0] = 0x67452301;
  110   context->state[1] = 0xefcdab89;
  111   context->state[2] = 0x98badcfe;
  112   context->state[3] = 0x10325476;
  113 }
  114 
  115 /*
  116  * MD5 block update operation. Continues an MD5 message-digest
  117  * operation, processing another message block, and updating the
  118  * context.
  119  */
  120 void MD5Update (
  121     MD5_CTX *context,                                        /* context */
  122     unsigned char *input,                                /* input block */
  123     unsigned int inputLen)                     /* length of input block */
  124 {
  125   unsigned int i, index, partLen;
  126 
  127   /* Compute number of bytes mod 64 */
  128   index = (unsigned int)((context->count[0] >> 3) & 0x3F);
  129 
  130   /* Update number of bits */
  131   if ((context->count[0] += ((UINT4)inputLen << 3))
  132    < ((UINT4)inputLen << 3))
  133  context->count[1]++;
  134   context->count[1] += ((UINT4)inputLen >> 29);
  135 
  136   partLen = 64 - index;
  137 
  138   /* Transform as many times as possible. */
  139   if (inputLen >= partLen) {
  140  MD5_memcpy
  141    ((POINTER)&context->buffer[index], (POINTER)input, partLen);
  142  MD5Transform (context->state, context->buffer);
  143 
  144  for (i = partLen; i + 63 < inputLen; i += 64)
  145    MD5Transform (context->state, &input[i]);
  146 
  147  index = 0;
  148   }
  149   else
  150  i = 0;
  151 
  152   /* Buffer remaining input */
  153   MD5_memcpy
  154  ((POINTER)&context->buffer[index], (POINTER)&input[i],
  155   inputLen-i);
  156 }
  157 
  158 /*
  159  * MD5 finalization. Ends an MD5 message-digest operation, writing the
  160  * the message digest and zeroizing the context.
  161  */
  162 void MD5Final (
  163     unsigned char digest[16],                         /* message digest */
  164     MD5_CTX *context)                                       /* context */
  165 {
  166   unsigned char bits[8];
  167   unsigned int index, padLen;
  168 
  169   /* Save number of bits */
  170   Encode (bits, context->count, 8);
  171 
  172   /* Pad out to 56 mod 64. */
  173   index = (unsigned int)((context->count[0] >> 3) & 0x3f);
  174   padLen = (index < 56) ? (56 - index) : (120 - index);
  175   MD5Update (context, PADDING, padLen);
  176 
  177   /* Append length (before padding) */
  178   MD5Update (context, bits, 8);
  179 
  180   /* Store state in digest */
  181   Encode (digest, context->state, 16);
  182 
  183   /* Zeroize sensitive information. */
  184   MD5_memset ((POINTER)context, 0, sizeof (*context));
  185 }
  186 
  187 /*
  188  * MD5 basic transformation. Transforms state based on block.
  189  */
  190 static void MD5Transform (state, block)
  191 UINT4 state[4];
  192 unsigned char block[64];
  193 {
  194   UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
  195 
  196   Decode (x, block, 64);
  197 
  198   /* Round 1 */
  199   FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
  200   FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
  201   FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
  202   FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
  203   FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
  204   FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
  205   FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
  206   FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
  207   FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
  208   FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
  209   FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
  210   FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
  211   FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
  212   FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
  213   FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
  214   FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
  215 
  216  /* Round 2 */
  217   GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
  218   GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
  219   GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
  220   GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
  221   GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
  222   GG (d, a, b, c, x[10], S22,  0x2441453); /* 22 */
  223   GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
  224   GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
  225   GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
  226   GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
  227   GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
  228   GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
  229   GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
  230   GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
  231   GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
  232   GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
  233 
  234   /* Round 3 */
  235   HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
  236   HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
  237   HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
  238   HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
  239   HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
  240   HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
  241   HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
  242   HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
  243   HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
  244   HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
  245   HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
  246   HH (b, c, d, a, x[ 6], S34,  0x4881d05); /* 44 */
  247   HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
  248   HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
  249   HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
  250   HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
  251 
  252   /* Round 4 */
  253   II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
  254   II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
  255   II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
  256   II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
  257   II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
  258   II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
  259   II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
  260   II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
  261   II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
  262   II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
  263   II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
  264   II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
  265   II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
  266   II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
  267   II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
  268   II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
  269 
  270   state[0] += a;
  271   state[1] += b;
  272   state[2] += c;
  273   state[3] += d;
  274 
  275   /* Zeroize sensitive information. */
  276   MD5_memset ((POINTER)x, 0, sizeof (x));
  277 }
  278 
  279 /*
  280  * Encodes input (UINT4) into output (unsigned char). Assumes len is
  281  * a multiple of 4.
  282  */
  283 static void Encode (output, input, len)
  284 unsigned char *output;
  285 UINT4 *input;
  286 unsigned int len;
  287 {
  288   unsigned int i, j;
  289 
  290   for (i = 0, j = 0; j < len; i++, j += 4) {
  291  output[j] = (unsigned char)(input[i] & 0xff);
  292  output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
  293  output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
  294  output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
  295   }
  296 }
  297 
  298 /*
  299  * Decodes input (unsigned char) into output (UINT4). Assumes len is
  300  * a multiple of 4.
  301  */
  302 static void Decode (output, input, len)
  303 UINT4 *output;
  304 unsigned char *input;
  305 unsigned int len;
  306 {
  307   unsigned int i, j;
  308 
  309   for (i = 0, j = 0; j < len; i++, j += 4)
  310  output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) |
  311    (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
  312 }
  313 
  314 /* Note: Replace "for loop" with standard memcpy if possible. */
  315 
  316 static void MD5_memcpy (output, input, len)
  317 POINTER output;
  318 POINTER input;
  319 unsigned int len;
  320 {
  321   unsigned int i;
  322 
  323   for (i = 0; i < len; i++)
  324  output[i] = input[i];
  325 }
  326 
  327 /* Note: Replace "for loop" with standard memset if possible. */
  328 static void MD5_memset (output, value, len)
  329 POINTER output;
  330 int value;
  331 unsigned int len;
  332 {
  333   unsigned int i;
  334 
  335   for (i = 0; i < len; i++)
  336  ((char *)output)[i] = (char)value;
  337 }
  338 
  339 void MD5(unsigned char *message,unsigned long message_length,unsigned char *md)
  340 {
  341   MD5_CTX state;
  342 
  343   MD5Init(&state);
  344   MD5Update(&state,message,message_length);
  345   MD5Final(md,&state);
  346 
  347   return;
  348 }