target/linux/generic-2.6/files/crypto/ocf/kirkwood/cesa/mvMD5.c

   1 /*******************************************************************************
   2 Copyright (C) Marvell International Ltd. and its affiliates
   3
   4 This software file (the "File") is owned and distributed by Marvell
   5 International Ltd. and/or its affiliates ("Marvell") under the following
   6 alternative licensing terms.  Once you have made an election to distribute the
   7 File under one of the following license alternatives, please (i) delete this
   8 introductory statement regarding license alternatives, (ii) delete the two
   9 license alternatives that you have not elected to use and (iii) preserve the
  10 Marvell copyright notice above.
  11
  12 ********************************************************************************
  13 Marvell Commercial License Option
  14
  15 If you received this File from Marvell and you have entered into a commercial
  16 license agreement (a "Commercial License") with Marvell, the File is licensed
  17 to you under the terms of the applicable Commercial License.
  18
  19 ********************************************************************************
  20 Marvell GPL License Option
  21
  22 If you received this File from Marvell, you may opt to use, redistribute and/or
  23 modify this File in accordance with the terms and conditions of the General
  24 Public License Version 2, June 1991 (the "GPL License"), a copy of which is
  25 available along with the File in the license.txt file or by writing to the Free
  26 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 or
  27 on the worldwide web at http://www.gnu.org/licenses/gpl.txt.
  28
  29 THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE IMPLIED
  30 WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY
  31 DISCLAIMED.  The GPL License provides additional details about this warranty
  32 disclaimer.
  33 ********************************************************************************
  34 Marvell BSD License Option
  35
  36 If you received this File from Marvell, you may opt to use, redistribute and/or
  37 modify this File under the following licensing terms.
  38 Redistribution and use in source and binary forms, with or without modification,
  39 are permitted provided that the following conditions are met:
  40
  41     *   Redistributions of source code must retain the above copyright notice,
  42             this list of conditions and the following disclaimer.
  43
  44     *   Redistributions in binary form must reproduce the above copyright
  45         notice, this list of conditions and the following disclaimer in the
  46         documentation and/or other materials provided with the distribution.
  47
  48     *   Neither the name of Marvell nor the names of its contributors may be
  49         used to endorse or promote products derived from this software without
  50         specific prior written permission.
  51
  52 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  53 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  54 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  55 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
  56 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  57 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  58 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  59 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  60 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  61 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  62
  63 *******************************************************************************/
  64
  65 #include "mvOs.h"
  66 #include "mvMD5.h"
  67
  68 static void mvMD5Transform(MV_U32 buf[4], MV_U32 const in[MV_MD5_MAC_LEN]);
  69
  70 #ifdef  MV_CPU_LE
  71 #define mvByteReverse(buf, len)   /* Nothing */
  72 #else
  73 static void mvByteReverse(unsigned char *buf, unsigned longs);
  74
  75 /*
  76  * Note: this code is harmless on little-endian machines.
  77  */
  78 static void mvByteReverse(unsigned char *buf, unsigned longs)
  79 {
  80     MV_U32 t;
  81
  82     do
  83     {
  84         t = (MV_U32) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
  85                       ((unsigned) buf[1] << 8 | buf[0]);
  86         *(MV_U32 *) buf = t;
  87         buf += 4;
  88     } while (--longs);
  89 }
  90 #endif
  91
  92 /*
  93  * Start MD5 accumulation.  Set bit count to 0 and buffer to mysterious
  94  * initialization constants.
  95  */
  96 void    mvMD5Init(MV_MD5_CONTEXT *ctx)
  97 {
  98     ctx->buf[0] = 0x67452301;
  99     ctx->buf[1] = 0xefcdab89;
 100     ctx->buf[2] = 0x98badcfe;
 101     ctx->buf[3] = 0x10325476;
 102
 103     ctx->bits[0] = 0;
 104     ctx->bits[1] = 0;
 105 }
 106
 107 /*
 108  * Update context to reflect the concatenation of another buffer full
 109  * of bytes.
 110  */
 111 void    mvMD5Update(MV_MD5_CONTEXT *ctx, unsigned char const *buf, unsigned len)
 112 {
 113     MV_U32 t;
 114
 115     /* Update bitcount */
 116
 117     t = ctx->bits[0];
 118     if ((ctx->bits[0] = t + ((MV_U32) len << 3)) < t)
 119         ctx->bits[1]++;         /* Carry from low to high */
 120     ctx->bits[1] += len >> 29;
 121
 122     t = (t >> 3) & 0x3f;        /* Bytes already in shsInfo->data */
 123
 124     /* Handle any leading odd-sized chunks */
 125
 126     if (t)
 127     {
 128         unsigned char *p = (unsigned char *) ctx->in + t;
 129
 130         t = 64 - t;
 131         if (len < t)
 132         {
 133             memcpy(p, buf, len);
 134             return;
 135         }
 136         memcpy(p, buf, t);
 137         mvByteReverse(ctx->in, MV_MD5_MAC_LEN);
 138         mvMD5Transform(ctx->buf, (MV_U32 *) ctx->in);
 139         buf += t;
 140         len -= t;
 141     }
 142     /* Process data in 64-byte chunks */
 143
 144     while (len >= 64)
 145     {
 146         memcpy(ctx->in, buf, 64);
 147         mvByteReverse(ctx->in, MV_MD5_MAC_LEN);
 148         mvMD5Transform(ctx->buf, (MV_U32 *) ctx->in);
 149         buf += 64;
 150         len -= 64;
 151     }
 152
 153     /* Handle any remaining bytes of data. */
 154
 155     memcpy(ctx->in, buf, len);
 156 }
 157
 158 /*
 159  * Final wrapup - pad to 64-byte boundary with the bit pattern
 160  * 1 0* (64-bit count of bits processed, MSB-first)
 161  */
 162 void    mvMD5Final(unsigned char digest[MV_MD5_MAC_LEN], MV_MD5_CONTEXT *ctx)
 163 {
 164     unsigned count;
 165     unsigned char *p;
 166
 167     /* Compute number of bytes mod 64 */
 168     count = (ctx->bits[0] >> 3) & 0x3F;
 169
 170     /* Set the first char of padding to 0x80.  This is safe since there is
 171        always at least one byte free */
 172     p = ctx->in + count;
 173     *p++ = 0x80;
 174
 175     /* Bytes of padding needed to make 64 bytes */
 176     count = 64 - 1 - count;
 177
 178     /* Pad out to 56 mod 64 */
 179     if (count < 8)
 180     {
 181         /* Two lots of padding:  Pad the first block to 64 bytes */
 182         memset(p, 0, count);
 183         mvByteReverse(ctx->in, MV_MD5_MAC_LEN);
 184         mvMD5Transform(ctx->buf, (MV_U32 *) ctx->in);
 185
 186         /* Now fill the next block with 56 bytes */
 187         memset(ctx->in, 0, 56);
 188     }
 189     else
 190     {
 191         /* Pad block to 56 bytes */
 192         memset(p, 0, count - 8);
 193     }
 194     mvByteReverse(ctx->in, 14);
 195
 196     /* Append length in bits and transform */
 197     ((MV_U32 *) ctx->in)[14] = ctx->bits[0];
 198     ((MV_U32 *) ctx->in)[15] = ctx->bits[1];
 199
 200     mvMD5Transform(ctx->buf, (MV_U32 *) ctx->in);
 201     mvByteReverse((unsigned char *) ctx->buf, 4);
 202     memcpy(digest, ctx->buf, MV_MD5_MAC_LEN);
 203     memset(ctx, 0, sizeof(ctx));        /* In case it's sensitive */
 204 }
 205
 206 /* The four core functions - F1 is optimized somewhat */
 207
 208 /* #define F1(x, y, z) (x & y | ~x & z) */
 209 #define F1(x, y, z) (z ^ (x & (y ^ z)))
 210 #define F2(x, y, z) F1(z, x, y)
 211 #define F3(x, y, z) (x ^ y ^ z)
 212 #define F4(x, y, z) (y ^ (x | ~z))
 213
 214 /* This is the central step in the MD5 algorithm. */
 215 #define MD5STEP(f, w, x, y, z, data, s) \
 216         ( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
 217
 218 /*
 219  * The core of the MD5 algorithm, this alters an existing MD5 hash to
 220  * reflect the addition of 16 longwords of new data.  MD5Update blocks
 221  * the data and converts bytes into longwords for this routine.
 222  */
 223 static void mvMD5Transform(MV_U32 buf[4], MV_U32 const in[MV_MD5_MAC_LEN])
 224 {
 225     register MV_U32 a, b, c, d;
 226
 227     a = buf[0];
 228     b = buf[1];
 229     c = buf[2];
 230     d = buf[3];
 231
 232     MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
 233     MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
 234     MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
 235     MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
 236     MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
 237     MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
 238     MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
 239     MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
 240     MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
 241     MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
 242     MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
 243     MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
 244     MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
 245     MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
 246     MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
 247     MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
 248
 249     MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
 250     MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
 251     MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
 252     MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
 253     MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
 254     MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
 255     MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
 256     MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
 257     MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
 258     MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
 259     MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
 260     MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
 261     MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
 262     MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
 263     MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
 264     MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
 265
 266     MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
 267     MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
 268     MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
 269     MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
 270     MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
 271     MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
 272     MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
 273     MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
 274     MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
 275     MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
 276     MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
 277     MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
 278     MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
 279     MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
 280     MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
 281     MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
 282
 283     MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
 284     MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
 285     MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
 286     MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
 287     MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
 288     MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
 289     MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
 290     MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
 291     MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
 292     MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
 293     MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
 294     MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
 295     MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
 296     MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
 297     MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
 298     MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
 299
 300     buf[0] += a;
 301     buf[1] += b;
 302     buf[2] += c;
 303     buf[3] += d;
 304 }
 305
 306 void    mvMD5(unsigned char const *buf, unsigned len, unsigned char* digest)
 307 {
 308     MV_MD5_CONTEXT  ctx;
 309
 310     mvMD5Init(&ctx);
 311     mvMD5Update(&ctx, buf, len);
 312     mvMD5Final(digest, &ctx);
 313 }
 314
 315
 316 void    mvHmacMd5(unsigned char const* text, int text_len,
 317                   unsigned char const* key, int key_len,
 318                   unsigned char* digest)
 319 {
 320     int             i;
 321     MV_MD5_CONTEXT  ctx;
 322     unsigned char   k_ipad[64+1]; /* inner padding - key XORd with ipad */
 323     unsigned char   k_opad[64+1]; /* outer padding - key XORd with opad */
 324
 325     /* start out by storing key in pads */
 326     memset(k_ipad, 0, 64);
 327     memcpy(k_ipad, key, key_len);
 328     memset(k_opad, 0, 64);
 329     memcpy(k_opad, key, key_len);
 330
 331     /* XOR key with ipad and opad values */
 332     for (i=0; i<64; i++)
 333     {
 334             k_ipad[i] ^= 0x36;
 335             k_opad[i] ^= 0x5c;
 336     }
 337
 338     /* perform inner MD5 */
 339     mvMD5Init(&ctx);                   /* init ctx for 1st pass */
 340     mvMD5Update(&ctx, k_ipad, 64);    /* start with inner pad */
 341     mvMD5Update(&ctx, text, text_len); /* then text of datagram */
 342     mvMD5Final(digest, &ctx);          /* finish up 1st pass */
 343
 344     /* perform outer MD5 */
 345     mvMD5Init(&ctx);                   /* init ctx for 2nd pass */
 346     mvMD5Update(&ctx, k_opad, 64);     /* start with outer pad */
 347     mvMD5Update(&ctx, digest, 16);     /* then results of 1st hash */
 348     mvMD5Final(digest, &ctx);          /* finish up 2nd pass */
 349 }