drivers/staging/rt3090/common/crypt_md5.c

   1 /*
   2  *************************************************************************
   3  * Ralink Tech Inc.
   4  * 5F., No.36, Taiyuan St., Jhubei City,
   5  * Hsinchu County 302,
   6  * Taiwan, R.O.C.
   7  *
   8  * (c) Copyright 2002-2007, Ralink Technology, Inc.
   9  *
  10  * This program is free software; you can redistribute it and/or modify  *
  11  * it under the terms of the GNU General Public License as published by  *
  12  * the Free Software Foundation; either version 2 of the License, or     *
  13  * (at your option) any later version.                                   *
  14  *                                                                       *
  15  * This program is distributed in the hope that it will be useful,       *
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  18  * GNU General Public License for more details.                          *
  19  *                                                                       *
  20  * You should have received a copy of the GNU General Public License     *
  21  * along with this program; if not, write to the                         *
  22  * Free Software Foundation, Inc.,                                       *
  23  * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  24  *                                                                       *
  25  *************************************************************************/
  26
  27 #include "../crypt_md5.h"
  28
  29
  30 #ifdef MD5_SUPPORT
  31 /*
  32  * F, G, H and I are basic MD5 functions.
  33  */
  34 #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
  35 #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
  36 #define H(x, y, z) ((x) ^ (y) ^ (z))
  37 #define I(x, y, z) ((y) ^ ((x) | (~z)))
  38
  39 #define ROTL(x,n,w) ((x << n) | (x >> (w - n)))
  40 #define ROTL32(x,n) ROTL(x,n,32) /* 32 bits word */
  41
  42 #define ROUND1(a, b, c, d, x, s, ac) {          \
  43     (a) += F((b),(c),(d)) + (x) + (UINT32)(ac); \
  44     (a)  = ROTL32((a),(s));                     \
  45     (a) += (b);                                 \
  46 }
  47 #define ROUND2(a, b, c, d, x, s, ac) {          \
  48     (a) += G((b),(c),(d)) + (x) + (UINT32)(ac); \
  49     (a)  = ROTL32((a),(s));                     \
  50     (a) += (b);                                 \
  51 }
  52 #define ROUND3(a, b, c, d, x, s, ac) {          \
  53     (a) += H((b),(c),(d)) + (x) + (UINT32)(ac); \
  54     (a)  = ROTL32((a),(s));                     \
  55     (a) += (b);                                 \
  56 }
  57 #define ROUND4(a, b, c, d, x, s, ac) {          \
  58     (a) += I((b),(c),(d)) + (x) + (UINT32)(ac); \
  59     (a)  = ROTL32((a),(s));                     \
  60     (a) += (b);                                 \
  61 }
  62 static const UINT32 MD5_DefaultHashValue[4] = {
  63     0x67452301UL, 0xefcdab89UL, 0x98badcfeUL, 0x10325476UL
  64 };
  65 #endif /* MD5_SUPPORT */
  66
  67
  68 #ifdef MD5_SUPPORT
  69 /*
  70 ========================================================================
  71 Routine Description:
  72     Initial Md5_CTX_STRUC
  73
  74 Arguments:
  75     pMD5_CTX        Pointer to Md5_CTX_STRUC
  76
  77 Return Value:
  78     None
  79
  80 Note:
  81     None
  82 ========================================================================
  83 */
  84 VOID MD5_Init (
  85     IN  MD5_CTX_STRUC *pMD5_CTX)
  86 {
  87     NdisMoveMemory(pMD5_CTX->HashValue, MD5_DefaultHashValue,
  88         sizeof(MD5_DefaultHashValue));
  89     NdisZeroMemory(pMD5_CTX->Block, MD5_BLOCK_SIZE);
  90     pMD5_CTX->BlockLen   = 0;
  91     pMD5_CTX->MessageLen = 0;
  92 } /* End of MD5_Init */
  93
  94
  95 /*
  96 ========================================================================
  97 Routine Description:
  98     MD5 computation for one block (512 bits)
  99
 100 Arguments:
 101     pMD5_CTX        Pointer to Md5_CTX_STRUC
 102
 103 Return Value:
 104     None
 105
 106 Note:
 107     T[i] := floor(abs(sin(i + 1)) * (2 pow 32)), i is number of round
 108 ========================================================================
 109 */
 110 VOID MD5_Hash (
 111     IN  MD5_CTX_STRUC *pMD5_CTX)
 112 {
 113     UINT32 X_i;
 114     UINT32 X[16];
 115     UINT32 a,b,c,d;
 116
 117     /* Prepare the message schedule, {X_i} */
 118     NdisMoveMemory(X, pMD5_CTX->Block, MD5_BLOCK_SIZE);
 119     for (X_i = 0; X_i < 16; X_i++)
 120         X[X_i] = cpu2le32(X[X_i]); /* Endian Swap */
 121         /* End of for */
 122
 123     /* MD5 hash computation */
 124     /* Initialize the working variables */
 125     a = pMD5_CTX->HashValue[0];
 126     b = pMD5_CTX->HashValue[1];
 127     c = pMD5_CTX->HashValue[2];
 128     d = pMD5_CTX->HashValue[3];
 129
 130     /*
 131      *  Round 1
 132      *  Let [abcd k s i] denote the operation
 133      *  a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s)
 134      */
 135     ROUND1(a, b, c, d, X[ 0],  7, 0xd76aa478); /* 1 */
 136     ROUND1(d, a, b, c, X[ 1], 12, 0xe8c7b756); /* 2 */
 137     ROUND1(c, d, a, b, X[ 2], 17, 0x242070db); /* 3 */
 138     ROUND1(b, c, d, a, X[ 3], 22, 0xc1bdceee); /* 4 */
 139     ROUND1(a, b, c, d, X[ 4],  7, 0xf57c0faf); /* 5 */
 140     ROUND1(d, a, b, c, X[ 5], 12, 0x4787c62a); /* 6 */
 141     ROUND1(c, d, a, b, X[ 6], 17, 0xa8304613); /* 7 */
 142     ROUND1(b, c, d, a, X[ 7], 22, 0xfd469501); /* 8 */
 143     ROUND1(a, b, c, d, X[ 8],  7, 0x698098d8); /* 9 */
 144     ROUND1(d, a, b, c, X[ 9], 12, 0x8b44f7af); /* 10 */
 145     ROUND1(c, d, a, b, X[10], 17, 0xffff5bb1); /* 11 */
 146     ROUND1(b, c, d, a, X[11], 22, 0x895cd7be); /* 12 */
 147     ROUND1(a, b, c, d, X[12],  7, 0x6b901122); /* 13 */
 148     ROUND1(d, a, b, c, X[13], 12, 0xfd987193); /* 14 */
 149     ROUND1(c, d, a, b, X[14], 17, 0xa679438e); /* 15 */
 150     ROUND1(b, c, d, a, X[15], 22, 0x49b40821); /* 16 */
 151
 152     /*
 153      *  Round 2
 154      *  Let [abcd k s i] denote the operation
 155      *  a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s)
 156      */
 157     ROUND2(a, b, c, d, X[ 1],  5, 0xf61e2562); /* 17 */
 158     ROUND2(d, a, b, c, X[ 6],  9, 0xc040b340); /* 18 */
 159     ROUND2(c, d, a, b, X[11], 14, 0x265e5a51); /* 19 */
 160     ROUND2(b, c, d, a, X[ 0], 20, 0xe9b6c7aa); /* 20 */
 161     ROUND2(a, b, c, d, X[ 5],  5, 0xd62f105d); /* 21 */
 162     ROUND2(d, a, b, c, X[10],  9,  0x2441453); /* 22 */
 163     ROUND2(c, d, a, b, X[15], 14, 0xd8a1e681); /* 23 */
 164     ROUND2(b, c, d, a, X[ 4], 20, 0xe7d3fbc8); /* 24 */
 165     ROUND2(a, b, c, d, X[ 9],  5, 0x21e1cde6); /* 25 */
 166     ROUND2(d, a, b, c, X[14],  9, 0xc33707d6); /* 26 */
 167     ROUND2(c, d, a, b, X[ 3], 14, 0xf4d50d87); /* 27 */
 168     ROUND2(b, c, d, a, X[ 8], 20, 0x455a14ed); /* 28 */
 169     ROUND2(a, b, c, d, X[13],  5, 0xa9e3e905); /* 29 */
 170     ROUND2(d, a, b, c, X[ 2],  9, 0xfcefa3f8); /* 30 */
 171     ROUND2(c, d, a, b, X[ 7], 14, 0x676f02d9); /* 31 */
 172     ROUND2(b, c, d, a, X[12], 20, 0x8d2a4c8a); /* 32 */
 173
 174     /*
 175      *  Round 3
 176      *  Let [abcd k s t] denote the operation
 177      *  a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s)
 178      */
 179     ROUND3(a, b, c, d, X[ 5],  4, 0xfffa3942); /* 33 */
 180     ROUND3(d, a, b, c, X[ 8], 11, 0x8771f681); /* 34 */
 181     ROUND3(c, d, a, b, X[11], 16, 0x6d9d6122); /* 35 */
 182     ROUND3(b, c, d, a, X[14], 23, 0xfde5380c); /* 36 */
 183     ROUND3(a, b, c, d, X[ 1],  4, 0xa4beea44); /* 37 */
 184     ROUND3(d, a, b, c, X[ 4], 11, 0x4bdecfa9); /* 38 */
 185     ROUND3(c, d, a, b, X[ 7], 16, 0xf6bb4b60); /* 39 */
 186     ROUND3(b, c, d, a, X[10], 23, 0xbebfbc70); /* 40 */
 187     ROUND3(a, b, c, d, X[13],  4, 0x289b7ec6); /* 41 */
 188     ROUND3(d, a, b, c, X[ 0], 11, 0xeaa127fa); /* 42 */
 189     ROUND3(c, d, a, b, X[ 3], 16, 0xd4ef3085); /* 43 */
 190     ROUND3(b, c, d, a, X[ 6], 23,  0x4881d05); /* 44 */
 191     ROUND3(a, b, c, d, X[ 9],  4, 0xd9d4d039); /* 45 */
 192     ROUND3(d, a, b, c, X[12], 11, 0xe6db99e5); /* 46 */
 193     ROUND3(c, d, a, b, X[15], 16, 0x1fa27cf8); /* 47 */
 194     ROUND3(b, c, d, a, X[ 2], 23, 0xc4ac5665); /* 48 */
 195
 196     /*
 197      *  Round 4
 198      *  Let [abcd k s t] denote the operation
 199      *  a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s)
 200      */
 201     ROUND4(a, b, c, d, X[ 0],  6, 0xf4292244); /* 49 */
 202     ROUND4(d, a, b, c, X[ 7], 10, 0x432aff97); /* 50 */
 203     ROUND4(c, d, a, b, X[14], 15, 0xab9423a7); /* 51 */
 204     ROUND4(b, c, d, a, X[ 5], 21, 0xfc93a039); /* 52 */
 205     ROUND4(a, b, c, d, X[12],  6, 0x655b59c3); /* 53 */
 206     ROUND4(d, a, b, c, X[ 3], 10, 0x8f0ccc92); /* 54 */
 207     ROUND4(c, d, a, b, X[10], 15, 0xffeff47d); /* 55 */
 208     ROUND4(b, c, d, a, X[ 1], 21, 0x85845dd1); /* 56 */
 209     ROUND4(a, b, c, d, X[ 8],  6, 0x6fa87e4f); /* 57 */
 210     ROUND4(d, a, b, c, X[15], 10, 0xfe2ce6e0); /* 58 */
 211     ROUND4(c, d, a, b, X[ 6], 15, 0xa3014314); /* 59 */
 212     ROUND4(b, c, d, a, X[13], 21, 0x4e0811a1); /* 60 */
 213     ROUND4(a, b, c, d, X[ 4],  6, 0xf7537e82); /* 61 */
 214     ROUND4(d, a, b, c, X[11], 10, 0xbd3af235); /* 62 */
 215     ROUND4(c, d, a, b, X[ 2], 15, 0x2ad7d2bb); /* 63 */
 216     ROUND4(b, c, d, a, X[ 9], 21, 0xeb86d391); /* 64 */
 217
 218     /* Compute the i^th intermediate hash value H^(i) */
 219     pMD5_CTX->HashValue[0] += a;
 220     pMD5_CTX->HashValue[1] += b;
 221     pMD5_CTX->HashValue[2] += c;
 222     pMD5_CTX->HashValue[3] += d;
 223
 224     NdisZeroMemory(pMD5_CTX->Block, MD5_BLOCK_SIZE);
 225     pMD5_CTX->BlockLen = 0;
 226 } /* End of MD5_Hash */
 227
 228
 229 /*
 230 ========================================================================
 231 Routine Description:
 232     The message is appended to block. If block size > 64 bytes, the MD5_Hash
 233 will be called.
 234
 235 Arguments:
 236     pMD5_CTX        Pointer to MD5_CTX_STRUC
 237     message         Message context
 238     messageLen      The length of message in bytes
 239
 240 Return Value:
 241     None
 242
 243 Note:
 244     None
 245 ========================================================================
 246 */
 247 VOID MD5_Append (
 248     IN  MD5_CTX_STRUC *pMD5_CTX,
 249     IN  const UINT8 Message[],
 250     IN  UINT MessageLen)
 251 {
 252     UINT appendLen = 0;
 253     UINT diffLen = 0;
 254
 255     while (appendLen != MessageLen) {
 256         diffLen = MessageLen - appendLen;
 257         if ((pMD5_CTX->BlockLen + diffLen) < MD5_BLOCK_SIZE) {
 258             NdisMoveMemory(pMD5_CTX->Block + pMD5_CTX->BlockLen,
 259                 Message + appendLen, diffLen);
 260             pMD5_CTX->BlockLen += diffLen;
 261             appendLen += diffLen;
 262         }
 263         else
 264         {
 265             NdisMoveMemory(pMD5_CTX->Block + pMD5_CTX->BlockLen,
 266                 Message + appendLen, MD5_BLOCK_SIZE - pMD5_CTX->BlockLen);
 267             appendLen += (MD5_BLOCK_SIZE - pMD5_CTX->BlockLen);
 268             pMD5_CTX->BlockLen = MD5_BLOCK_SIZE;
 269             MD5_Hash(pMD5_CTX);
 270         } /* End of if */
 271     } /* End of while */
 272     pMD5_CTX->MessageLen += MessageLen;
 273 } /* End of MD5_Append */
 274
 275
 276 /*
 277 ========================================================================
 278 Routine Description:
 279     1. Append bit 1 to end of the message
 280     2. Append the length of message in rightmost 64 bits
 281     3. Transform the Hash Value to digest message
 282
 283 Arguments:
 284     pMD5_CTX        Pointer to MD5_CTX_STRUC
 285
 286 Return Value:
 287     digestMessage   Digest message
 288
 289 Note:
 290     None
 291 ========================================================================
 292 */
 293 VOID MD5_End (
 294     IN  MD5_CTX_STRUC *pMD5_CTX,
 295     OUT UINT8 DigestMessage[])
 296 {
 297     UINT index;
 298     UINT64 message_length_bits;
 299
 300     /* append 1 bits to end of the message */
 301     NdisFillMemory(pMD5_CTX->Block + pMD5_CTX->BlockLen, 1, 0x80);
 302
 303     /* 55 = 64 - 8 - 1: append 1 bit(1 byte) and message length (8 bytes) */
 304     if (pMD5_CTX->BlockLen > 55)
 305         MD5_Hash(pMD5_CTX);
 306         /* End of if */
 307
 308     /* Append the length of message in rightmost 64 bits */
 309     message_length_bits = pMD5_CTX->MessageLen*8;
 310     message_length_bits = cpu2le64(message_length_bits);
 311     NdisMoveMemory(&pMD5_CTX->Block[56], &message_length_bits, 8);
 312     MD5_Hash(pMD5_CTX);
 313
 314     /* Return message digest, transform the UINT32 hash value to bytes */
 315     for (index = 0; index < 4;index++)
 316         pMD5_CTX->HashValue[index] = cpu2le32(pMD5_CTX->HashValue[index]);
 317         /* End of for */
 318     NdisMoveMemory(DigestMessage, pMD5_CTX->HashValue, MD5_DIGEST_SIZE);
 319 } /* End of MD5_End */
 320
 321
 322 /*
 323 ========================================================================
 324 Routine Description:
 325     MD5 algorithm
 326
 327 Arguments:
 328     message         Message context
 329     messageLen      The length of message in bytes
 330
 331 Return Value:
 332     digestMessage   Digest message
 333
 334 Note:
 335     None
 336 ========================================================================
 337 */
 338 VOID RT_MD5 (
 339     IN  const UINT8 Message[],
 340     IN  UINT MessageLen,
 341     OUT UINT8 DigestMessage[])
 342 {
 343     MD5_CTX_STRUC md5_ctx;
 344
 345     NdisZeroMemory(&md5_ctx, sizeof(MD5_CTX_STRUC));
 346     MD5_Init(&md5_ctx);
 347     MD5_Append(&md5_ctx, Message, MessageLen);
 348     MD5_End(&md5_ctx, DigestMessage);
 349 } /* End of RT_MD5 */
 350
 351 #endif /* MD5_SUPPORT */
 352
 353 /* End of crypt_md5.c */