Annotation of embedaddon/quagga/lib/md5.c, revision 1.1

1.1     ! misho       1: /* $USAGI: md5.c,v 1.2 2000/11/02 11:59:24 yoshfuji Exp $ */
        !             2: /*     $KAME: md5.c,v 1.2 2000/05/27 07:07:48 jinmei Exp $     */
        !             3: /*     $Id: md5.c,v 1.6 2006/01/17 23:39:04 vincent Exp $ */
        !             4: 
        !             5: /*
        !             6:  * Copyright (C) 2004 6WIND
        !             7:  *                          <Vincent.Jardin@6WIND.com>
        !             8:  * All rights reserved.
        !             9:  *
        !            10:  * This MD5 code is Big endian and Little Endian compatible.
        !            11:  */
        !            12: 
        !            13: /*
        !            14:  * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
        !            15:  * All rights reserved.
        !            16:  *
        !            17:  * Redistribution and use in source and binary forms, with or without
        !            18:  * modification, are permitted provided that the following conditions
        !            19:  * are met:
        !            20:  * 1. Redistributions of source code must retain the above copyright
        !            21:  *    notice, this list of conditions and the following disclaimer.
        !            22:  * 2. Redistributions in binary form must reproduce the above copyright
        !            23:  *    notice, this list of conditions and the following disclaimer in the
        !            24:  *    documentation and/or other materials provided with the distribution.
        !            25:  * 3. Neither the name of the project nor the names of its contributors
        !            26:  *    may be used to endorse or promote products derived from this software
        !            27:  *    without specific prior written permission.
        !            28:  *
        !            29:  * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
        !            30:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
        !            31:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
        !            32:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
        !            33:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
        !            34:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
        !            35:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
        !            36:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
        !            37:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
        !            38:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
        !            39:  * SUCH DAMAGE.
        !            40:  */
        !            41: 
        !            42: #include <zebra.h>
        !            43: #include "md5.h"
        !            44: 
        !            45: #define SHIFT(X, s) (((X) << (s)) | ((X) >> (32 - (s))))
        !            46: 
        !            47: #define F(X, Y, Z) (((X) & (Y)) | ((~X) & (Z)))
        !            48: #define G(X, Y, Z) (((X) & (Z)) | ((Y) & (~Z)))
        !            49: #define H(X, Y, Z) ((X) ^ (Y) ^ (Z))
        !            50: #define I(X, Y, Z) ((Y) ^ ((X) | (~Z)))
        !            51: 
        !            52: #define ROUND1(a, b, c, d, k, s, i) { \
        !            53:        (a) = (a) + F((b), (c), (d)) + X[(k)] + T[(i)]; \
        !            54:        (a) = SHIFT((a), (s)); \
        !            55:        (a) = (b) + (a); \
        !            56: }
        !            57: 
        !            58: #define ROUND2(a, b, c, d, k, s, i) { \
        !            59:        (a) = (a) + G((b), (c), (d)) + X[(k)] + T[(i)]; \
        !            60:        (a) = SHIFT((a), (s)); \
        !            61:        (a) = (b) + (a); \
        !            62: }
        !            63: 
        !            64: #define ROUND3(a, b, c, d, k, s, i) { \
        !            65:        (a) = (a) + H((b), (c), (d)) + X[(k)] + T[(i)]; \
        !            66:        (a) = SHIFT((a), (s)); \
        !            67:        (a) = (b) + (a); \
        !            68: }
        !            69: 
        !            70: #define ROUND4(a, b, c, d, k, s, i) { \
        !            71:        (a) = (a) + I((b), (c), (d)) + X[(k)] + T[(i)]; \
        !            72:        (a) = SHIFT((a), (s)); \
        !            73:        (a) = (b) + (a); \
        !            74: }
        !            75: 
        !            76: #define Sa      7
        !            77: #define Sb     12
        !            78: #define Sc     17
        !            79: #define Sd     22
        !            80: 
        !            81: #define Se      5
        !            82: #define Sf      9
        !            83: #define Sg     14
        !            84: #define Sh     20
        !            85: 
        !            86: #define Si      4
        !            87: #define Sj     11
        !            88: #define Sk     16
        !            89: #define Sl     23
        !            90: 
        !            91: #define Sm      6
        !            92: #define Sn     10
        !            93: #define So     15
        !            94: #define Sp     21
        !            95: 
        !            96: #define MD5_A0 0x67452301
        !            97: #define MD5_B0 0xefcdab89
        !            98: #define MD5_C0 0x98badcfe
        !            99: #define MD5_D0 0x10325476
        !           100: 
        !           101: /* Integer part of 4294967296 times abs(sin(i)), where i is in radians. */
        !           102: static const uint32_t T[65] = {
        !           103:        0,
        !           104:        0xd76aa478,     0xe8c7b756,     0x242070db,     0xc1bdceee,
        !           105:        0xf57c0faf,     0x4787c62a,     0xa8304613,     0xfd469501,
        !           106:        0x698098d8,     0x8b44f7af,     0xffff5bb1,     0x895cd7be,
        !           107:        0x6b901122,     0xfd987193,     0xa679438e,     0x49b40821,
        !           108: 
        !           109:        0xf61e2562,     0xc040b340,     0x265e5a51,     0xe9b6c7aa,
        !           110:        0xd62f105d,     0x2441453,      0xd8a1e681,     0xe7d3fbc8,
        !           111:        0x21e1cde6,     0xc33707d6,     0xf4d50d87,     0x455a14ed,
        !           112:        0xa9e3e905,     0xfcefa3f8,     0x676f02d9,     0x8d2a4c8a,
        !           113: 
        !           114:        0xfffa3942,     0x8771f681,     0x6d9d6122,     0xfde5380c,
        !           115:        0xa4beea44,     0x4bdecfa9,     0xf6bb4b60,     0xbebfbc70,
        !           116:        0x289b7ec6,     0xeaa127fa,     0xd4ef3085,     0x4881d05,
        !           117:        0xd9d4d039,     0xe6db99e5,     0x1fa27cf8,     0xc4ac5665,
        !           118: 
        !           119:        0xf4292244,     0x432aff97,     0xab9423a7,     0xfc93a039,
        !           120:        0x655b59c3,     0x8f0ccc92,     0xffeff47d,     0x85845dd1,
        !           121:        0x6fa87e4f,     0xfe2ce6e0,     0xa3014314,     0x4e0811a1,
        !           122:        0xf7537e82,     0xbd3af235,     0x2ad7d2bb,     0xeb86d391,
        !           123: };
        !           124: 
        !           125: static const uint8_t md5_paddat[MD5_BUFLEN] = {
        !           126:        0x80,   0,      0,      0,      0,      0,      0,      0,
        !           127:        0,      0,      0,      0,      0,      0,      0,      0,
        !           128:        0,      0,      0,      0,      0,      0,      0,      0,
        !           129:        0,      0,      0,      0,      0,      0,      0,      0,
        !           130:        0,      0,      0,      0,      0,      0,      0,      0,
        !           131:        0,      0,      0,      0,      0,      0,      0,      0,
        !           132:        0,      0,      0,      0,      0,      0,      0,      0,
        !           133:        0,      0,      0,      0,      0,      0,      0,      0,      
        !           134: };
        !           135: 
        !           136: static void md5_calc (const uint8_t *, md5_ctxt *);
        !           137: 
        !           138: void md5_init(md5_ctxt *ctxt)
        !           139: {
        !           140:        ctxt->md5_n = 0;
        !           141:        ctxt->md5_i = 0;
        !           142:        ctxt->md5_sta = MD5_A0;
        !           143:        ctxt->md5_stb = MD5_B0;
        !           144:        ctxt->md5_stc = MD5_C0;
        !           145:        ctxt->md5_std = MD5_D0;
        !           146:        memset (ctxt->md5_buf, 0, sizeof(ctxt->md5_buf));
        !           147: }
        !           148: 
        !           149: void md5_loop(md5_ctxt *ctxt, const void *vinput, uint len)
        !           150: {
        !           151:        uint gap, i;
        !           152:        const uint8_t *input = vinput;
        !           153: 
        !           154:        ctxt->md5_n += len * 8; /* byte to bit */
        !           155:        gap = MD5_BUFLEN - ctxt->md5_i;
        !           156: 
        !           157:        if (len >= gap) {
        !           158:                memcpy (ctxt->md5_buf + ctxt->md5_i, input, gap);
        !           159:                md5_calc(ctxt->md5_buf, ctxt);
        !           160: 
        !           161:                for (i = gap; i + MD5_BUFLEN <= len; i += MD5_BUFLEN) {
        !           162:                        md5_calc((input + i), ctxt);
        !           163:                }
        !           164:                
        !           165:                ctxt->md5_i = len - i;
        !           166:                memcpy (ctxt->md5_buf, (input + i), ctxt->md5_i);
        !           167:        } else {
        !           168:                memcpy (ctxt->md5_buf + ctxt->md5_i, input, len);
        !           169:                ctxt->md5_i += len;
        !           170:        }
        !           171: }
        !           172: 
        !           173: void md5_pad(md5_ctxt *ctxt)
        !           174: {
        !           175:        uint gap;
        !           176: 
        !           177:        /* Don't count up padding. Keep md5_n. */       
        !           178:        gap = MD5_BUFLEN - ctxt->md5_i;
        !           179:        if (gap > 8) {
        !           180:                memcpy (ctxt->md5_buf + ctxt->md5_i, md5_paddat, 
        !           181:                        gap - sizeof(ctxt->md5_n));
        !           182:        } else {
        !           183:                /* including gap == 8 */
        !           184:                memcpy (ctxt->md5_buf + ctxt->md5_i, md5_paddat, gap);
        !           185:                md5_calc (ctxt->md5_buf, ctxt);
        !           186:                memcpy (ctxt->md5_buf, md5_paddat + gap,
        !           187:                        MD5_BUFLEN - sizeof(ctxt->md5_n));
        !           188:        }
        !           189: 
        !           190:        /* 8 byte word */       
        !           191:        if (BYTE_ORDER == LITTLE_ENDIAN)
        !           192:          memcpy (&ctxt->md5_buf[56], &ctxt->md5_n8[0], 8);
        !           193:        else
        !           194:          {
        !           195:            ctxt->md5_buf[56] = ctxt->md5_n8[7];
        !           196:            ctxt->md5_buf[57] = ctxt->md5_n8[6];
        !           197:            ctxt->md5_buf[58] = ctxt->md5_n8[5];
        !           198:            ctxt->md5_buf[59] = ctxt->md5_n8[4];
        !           199:            ctxt->md5_buf[60] = ctxt->md5_n8[3];
        !           200:            ctxt->md5_buf[61] = ctxt->md5_n8[2];
        !           201:            ctxt->md5_buf[62] = ctxt->md5_n8[1];
        !           202:            ctxt->md5_buf[63] = ctxt->md5_n8[0];
        !           203:          }
        !           204:        md5_calc(ctxt->md5_buf, ctxt);
        !           205: }
        !           206: 
        !           207: void md5_result(uint8_t *digest, md5_ctxt *ctxt)
        !           208: {
        !           209:        /* 4 byte words */
        !           210:        if (BYTE_ORDER == LITTLE_ENDIAN)
        !           211:          memcpy (digest, &ctxt->md5_st8[0], 16);
        !           212:        else if (BYTE_ORDER == BIG_ENDIAN)
        !           213:          {
        !           214:            digest[ 0] = ctxt->md5_st8[ 3]; digest[ 1] = ctxt->md5_st8[ 2];
        !           215:            digest[ 2] = ctxt->md5_st8[ 1]; digest[ 3] = ctxt->md5_st8[ 0];
        !           216:            digest[ 4] = ctxt->md5_st8[ 7]; digest[ 5] = ctxt->md5_st8[ 6];
        !           217:            digest[ 6] = ctxt->md5_st8[ 5]; digest[ 7] = ctxt->md5_st8[ 4];
        !           218:            digest[ 8] = ctxt->md5_st8[11]; digest[ 9] = ctxt->md5_st8[10];
        !           219:            digest[10] = ctxt->md5_st8[ 9]; digest[11] = ctxt->md5_st8[ 8];
        !           220:            digest[12] = ctxt->md5_st8[15]; digest[13] = ctxt->md5_st8[14];
        !           221:            digest[14] = ctxt->md5_st8[13]; digest[15] = ctxt->md5_st8[12];
        !           222:          }
        !           223: }
        !           224: 
        !           225: static void md5_calc(const uint8_t *b64, md5_ctxt * ctxt)
        !           226: {
        !           227:        uint32_t A = ctxt->md5_sta;
        !           228:        uint32_t B = ctxt->md5_stb;
        !           229:        uint32_t C = ctxt->md5_stc;
        !           230:        uint32_t D = ctxt->md5_std;
        !           231: #if (BYTE_ORDER == LITTLE_ENDIAN)
        !           232:        const uint32_t *X = (const uint32_t *)b64;
        !           233: #elif (BYTE_ORDER == BIG_ENDIAN)
        !           234:        uint32_t X[16];
        !           235: 
        !           236:        if (BYTE_ORDER == BIG_ENDIAN)
        !           237:          {
        !           238:            /* 4 byte words */
        !           239:            /* what a brute force but fast! */
        !           240:            uint8_t *y = (uint8_t *)X;
        !           241:            y[ 0] = b64[ 3]; y[ 1] = b64[ 2]; y[ 2] = b64[ 1]; y[ 3] = b64[ 0];
        !           242:            y[ 4] = b64[ 7]; y[ 5] = b64[ 6]; y[ 6] = b64[ 5]; y[ 7] = b64[ 4];
        !           243:            y[ 8] = b64[11]; y[ 9] = b64[10]; y[10] = b64[ 9]; y[11] = b64[ 8];
        !           244:            y[12] = b64[15]; y[13] = b64[14]; y[14] = b64[13]; y[15] = b64[12];
        !           245:            y[16] = b64[19]; y[17] = b64[18]; y[18] = b64[17]; y[19] = b64[16];
        !           246:            y[20] = b64[23]; y[21] = b64[22]; y[22] = b64[21]; y[23] = b64[20];
        !           247:            y[24] = b64[27]; y[25] = b64[26]; y[26] = b64[25]; y[27] = b64[24];
        !           248:            y[28] = b64[31]; y[29] = b64[30]; y[30] = b64[29]; y[31] = b64[28];
        !           249:            y[32] = b64[35]; y[33] = b64[34]; y[34] = b64[33]; y[35] = b64[32];
        !           250:            y[36] = b64[39]; y[37] = b64[38]; y[38] = b64[37]; y[39] = b64[36];
        !           251:            y[40] = b64[43]; y[41] = b64[42]; y[42] = b64[41]; y[43] = b64[40];
        !           252:            y[44] = b64[47]; y[45] = b64[46]; y[46] = b64[45]; y[47] = b64[44];
        !           253:            y[48] = b64[51]; y[49] = b64[50]; y[50] = b64[49]; y[51] = b64[48];
        !           254:            y[52] = b64[55]; y[53] = b64[54]; y[54] = b64[53]; y[55] = b64[52];
        !           255:            y[56] = b64[59]; y[57] = b64[58]; y[58] = b64[57]; y[59] = b64[56];
        !           256:            y[60] = b64[63]; y[61] = b64[62]; y[62] = b64[61]; y[63] = b64[60];
        !           257:          }
        !           258: #endif
        !           259: 
        !           260:        ROUND1(A, B, C, D,  0, Sa,  1); ROUND1(D, A, B, C,  1, Sb,  2);
        !           261:        ROUND1(C, D, A, B,  2, Sc,  3); ROUND1(B, C, D, A,  3, Sd,  4);
        !           262:        ROUND1(A, B, C, D,  4, Sa,  5); ROUND1(D, A, B, C,  5, Sb,  6);
        !           263:        ROUND1(C, D, A, B,  6, Sc,  7); ROUND1(B, C, D, A,  7, Sd,  8);
        !           264:        ROUND1(A, B, C, D,  8, Sa,  9); ROUND1(D, A, B, C,  9, Sb, 10);
        !           265:        ROUND1(C, D, A, B, 10, Sc, 11); ROUND1(B, C, D, A, 11, Sd, 12);
        !           266:        ROUND1(A, B, C, D, 12, Sa, 13); ROUND1(D, A, B, C, 13, Sb, 14);
        !           267:        ROUND1(C, D, A, B, 14, Sc, 15); ROUND1(B, C, D, A, 15, Sd, 16);
        !           268:        
        !           269:        ROUND2(A, B, C, D,  1, Se, 17); ROUND2(D, A, B, C,  6, Sf, 18);
        !           270:        ROUND2(C, D, A, B, 11, Sg, 19); ROUND2(B, C, D, A,  0, Sh, 20);
        !           271:        ROUND2(A, B, C, D,  5, Se, 21); ROUND2(D, A, B, C, 10, Sf, 22);
        !           272:        ROUND2(C, D, A, B, 15, Sg, 23); ROUND2(B, C, D, A,  4, Sh, 24);
        !           273:        ROUND2(A, B, C, D,  9, Se, 25); ROUND2(D, A, B, C, 14, Sf, 26);
        !           274:        ROUND2(C, D, A, B,  3, Sg, 27); ROUND2(B, C, D, A,  8, Sh, 28);
        !           275:        ROUND2(A, B, C, D, 13, Se, 29); ROUND2(D, A, B, C,  2, Sf, 30);
        !           276:        ROUND2(C, D, A, B,  7, Sg, 31); ROUND2(B, C, D, A, 12, Sh, 32);
        !           277: 
        !           278:        ROUND3(A, B, C, D,  5, Si, 33); ROUND3(D, A, B, C,  8, Sj, 34);
        !           279:        ROUND3(C, D, A, B, 11, Sk, 35); ROUND3(B, C, D, A, 14, Sl, 36);
        !           280:        ROUND3(A, B, C, D,  1, Si, 37); ROUND3(D, A, B, C,  4, Sj, 38);
        !           281:        ROUND3(C, D, A, B,  7, Sk, 39); ROUND3(B, C, D, A, 10, Sl, 40);
        !           282:        ROUND3(A, B, C, D, 13, Si, 41); ROUND3(D, A, B, C,  0, Sj, 42);
        !           283:        ROUND3(C, D, A, B,  3, Sk, 43); ROUND3(B, C, D, A,  6, Sl, 44);
        !           284:        ROUND3(A, B, C, D,  9, Si, 45); ROUND3(D, A, B, C, 12, Sj, 46);
        !           285:        ROUND3(C, D, A, B, 15, Sk, 47); ROUND3(B, C, D, A,  2, Sl, 48);
        !           286:        
        !           287:        ROUND4(A, B, C, D,  0, Sm, 49); ROUND4(D, A, B, C,  7, Sn, 50); 
        !           288:        ROUND4(C, D, A, B, 14, So, 51); ROUND4(B, C, D, A,  5, Sp, 52); 
        !           289:        ROUND4(A, B, C, D, 12, Sm, 53); ROUND4(D, A, B, C,  3, Sn, 54); 
        !           290:        ROUND4(C, D, A, B, 10, So, 55); ROUND4(B, C, D, A,  1, Sp, 56); 
        !           291:        ROUND4(A, B, C, D,  8, Sm, 57); ROUND4(D, A, B, C, 15, Sn, 58); 
        !           292:        ROUND4(C, D, A, B,  6, So, 59); ROUND4(B, C, D, A, 13, Sp, 60); 
        !           293:        ROUND4(A, B, C, D,  4, Sm, 61); ROUND4(D, A, B, C, 11, Sn, 62); 
        !           294:        ROUND4(C, D, A, B,  2, So, 63); ROUND4(B, C, D, A,  9, Sp, 64);
        !           295: 
        !           296:        ctxt->md5_sta += A;
        !           297:        ctxt->md5_stb += B;
        !           298:        ctxt->md5_stc += C;
        !           299:        ctxt->md5_std += D;
        !           300: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>