Annotation of embedaddon/bird/lib/sha1.c, revision 1.1

1.1     ! misho       1: /*
        !             2:  *     BIRD Library -- SHA-1 Hash Function (FIPS 180-1, RFC 3174)
        !             3:  *
        !             4:  *     (c) 2015 CZ.NIC z.s.p.o.
        !             5:  *
        !             6:  *     Based on the code from libucw-6.4
        !             7:  *     (c) 2008--2009 Martin Mares <mj@ucw.cz>
        !             8:  *
        !             9:  *     Based on the code from libgcrypt-1.2.3, which is
        !            10:  *     (c) 1998, 2001, 2002, 2003 Free Software Foundation, Inc.
        !            11:  *
        !            12:  *     Can be freely distributed and used under the terms of the GNU GPL.
        !            13:  */
        !            14: 
        !            15: #include "lib/sha1.h"
        !            16: #include "lib/unaligned.h"
        !            17: 
        !            18: 
        !            19: void
        !            20: sha1_init(struct hash_context *CTX)
        !            21: {
        !            22:   struct sha1_context *ctx = (void *) CTX;
        !            23: 
        !            24:   ctx->h0 = 0x67452301;
        !            25:   ctx->h1 = 0xefcdab89;
        !            26:   ctx->h2 = 0x98badcfe;
        !            27:   ctx->h3 = 0x10325476;
        !            28:   ctx->h4 = 0xc3d2e1f0;
        !            29: 
        !            30:   ctx->nblocks = 0;
        !            31:   ctx->count = 0;
        !            32: }
        !            33: 
        !            34: /*
        !            35:  * Transform the message X which consists of 16 32-bit-words
        !            36:  */
        !            37: static void
        !            38: sha1_transform(struct sha1_context *ctx, const byte *data)
        !            39: {
        !            40:   u32 a,b,c,d,e,tm;
        !            41:   u32 x[16];
        !            42: 
        !            43:   /* Get values from the chaining vars. */
        !            44:   a = ctx->h0;
        !            45:   b = ctx->h1;
        !            46:   c = ctx->h2;
        !            47:   d = ctx->h3;
        !            48:   e = ctx->h4;
        !            49: 
        !            50: #ifdef CPU_BIG_ENDIAN
        !            51:   memcpy(x, data, 64);
        !            52: #else
        !            53:   int i;
        !            54:   for (i = 0; i < 16; i++)
        !            55:     x[i] = get_u32(data+4*i);
        !            56: #endif
        !            57: 
        !            58: #define K1             0x5A827999L
        !            59: #define K2             0x6ED9EBA1L
        !            60: #define K3             0x8F1BBCDCL
        !            61: #define K4             0xCA62C1D6L
        !            62: #define F1(x,y,z)      ( z ^ ( x & ( y ^ z ) ) )
        !            63: #define F2(x,y,z)      ( x ^ y ^ z )
        !            64: #define F3(x,y,z)      ( ( x & y ) | ( z & ( x | y ) ) )
        !            65: #define F4(x,y,z)      ( x ^ y ^ z )
        !            66: 
        !            67: #define M(i) (tm = x[i&0x0f] ^ x[(i-14)&0x0f] ^ x[(i-8)&0x0f] ^ x[(i-3)&0x0f], (x[i&0x0f] = ROL(tm, 1)))
        !            68: 
        !            69: /* Bitwise rotation of an unsigned int to the left **/
        !            70: #define        ROL(x, bits) (((x) << (bits)) | ((uint)(x) >> (sizeof(uint)*8 - (bits))))
        !            71: 
        !            72:   #define R(a, b, c, d, e, f, k, m)            \
        !            73:     do                                                 \
        !            74:     {                                          \
        !            75:       e += ROL(a, 5) + f(b, c, d) + k + m;     \
        !            76:       b = ROL(b, 30);                          \
        !            77:     } while(0)
        !            78: 
        !            79:   R( a, b, c, d, e, F1, K1, x[ 0] );
        !            80:   R( e, a, b, c, d, F1, K1, x[ 1] );
        !            81:   R( d, e, a, b, c, F1, K1, x[ 2] );
        !            82:   R( c, d, e, a, b, F1, K1, x[ 3] );
        !            83:   R( b, c, d, e, a, F1, K1, x[ 4] );
        !            84:   R( a, b, c, d, e, F1, K1, x[ 5] );
        !            85:   R( e, a, b, c, d, F1, K1, x[ 6] );
        !            86:   R( d, e, a, b, c, F1, K1, x[ 7] );
        !            87:   R( c, d, e, a, b, F1, K1, x[ 8] );
        !            88:   R( b, c, d, e, a, F1, K1, x[ 9] );
        !            89:   R( a, b, c, d, e, F1, K1, x[10] );
        !            90:   R( e, a, b, c, d, F1, K1, x[11] );
        !            91:   R( d, e, a, b, c, F1, K1, x[12] );
        !            92:   R( c, d, e, a, b, F1, K1, x[13] );
        !            93:   R( b, c, d, e, a, F1, K1, x[14] );
        !            94:   R( a, b, c, d, e, F1, K1, x[15] );
        !            95:   R( e, a, b, c, d, F1, K1, M(16) );
        !            96:   R( d, e, a, b, c, F1, K1, M(17) );
        !            97:   R( c, d, e, a, b, F1, K1, M(18) );
        !            98:   R( b, c, d, e, a, F1, K1, M(19) );
        !            99:   R( a, b, c, d, e, F2, K2, M(20) );
        !           100:   R( e, a, b, c, d, F2, K2, M(21) );
        !           101:   R( d, e, a, b, c, F2, K2, M(22) );
        !           102:   R( c, d, e, a, b, F2, K2, M(23) );
        !           103:   R( b, c, d, e, a, F2, K2, M(24) );
        !           104:   R( a, b, c, d, e, F2, K2, M(25) );
        !           105:   R( e, a, b, c, d, F2, K2, M(26) );
        !           106:   R( d, e, a, b, c, F2, K2, M(27) );
        !           107:   R( c, d, e, a, b, F2, K2, M(28) );
        !           108:   R( b, c, d, e, a, F2, K2, M(29) );
        !           109:   R( a, b, c, d, e, F2, K2, M(30) );
        !           110:   R( e, a, b, c, d, F2, K2, M(31) );
        !           111:   R( d, e, a, b, c, F2, K2, M(32) );
        !           112:   R( c, d, e, a, b, F2, K2, M(33) );
        !           113:   R( b, c, d, e, a, F2, K2, M(34) );
        !           114:   R( a, b, c, d, e, F2, K2, M(35) );
        !           115:   R( e, a, b, c, d, F2, K2, M(36) );
        !           116:   R( d, e, a, b, c, F2, K2, M(37) );
        !           117:   R( c, d, e, a, b, F2, K2, M(38) );
        !           118:   R( b, c, d, e, a, F2, K2, M(39) );
        !           119:   R( a, b, c, d, e, F3, K3, M(40) );
        !           120:   R( e, a, b, c, d, F3, K3, M(41) );
        !           121:   R( d, e, a, b, c, F3, K3, M(42) );
        !           122:   R( c, d, e, a, b, F3, K3, M(43) );
        !           123:   R( b, c, d, e, a, F3, K3, M(44) );
        !           124:   R( a, b, c, d, e, F3, K3, M(45) );
        !           125:   R( e, a, b, c, d, F3, K3, M(46) );
        !           126:   R( d, e, a, b, c, F3, K3, M(47) );
        !           127:   R( c, d, e, a, b, F3, K3, M(48) );
        !           128:   R( b, c, d, e, a, F3, K3, M(49) );
        !           129:   R( a, b, c, d, e, F3, K3, M(50) );
        !           130:   R( e, a, b, c, d, F3, K3, M(51) );
        !           131:   R( d, e, a, b, c, F3, K3, M(52) );
        !           132:   R( c, d, e, a, b, F3, K3, M(53) );
        !           133:   R( b, c, d, e, a, F3, K3, M(54) );
        !           134:   R( a, b, c, d, e, F3, K3, M(55) );
        !           135:   R( e, a, b, c, d, F3, K3, M(56) );
        !           136:   R( d, e, a, b, c, F3, K3, M(57) );
        !           137:   R( c, d, e, a, b, F3, K3, M(58) );
        !           138:   R( b, c, d, e, a, F3, K3, M(59) );
        !           139:   R( a, b, c, d, e, F4, K4, M(60) );
        !           140:   R( e, a, b, c, d, F4, K4, M(61) );
        !           141:   R( d, e, a, b, c, F4, K4, M(62) );
        !           142:   R( c, d, e, a, b, F4, K4, M(63) );
        !           143:   R( b, c, d, e, a, F4, K4, M(64) );
        !           144:   R( a, b, c, d, e, F4, K4, M(65) );
        !           145:   R( e, a, b, c, d, F4, K4, M(66) );
        !           146:   R( d, e, a, b, c, F4, K4, M(67) );
        !           147:   R( c, d, e, a, b, F4, K4, M(68) );
        !           148:   R( b, c, d, e, a, F4, K4, M(69) );
        !           149:   R( a, b, c, d, e, F4, K4, M(70) );
        !           150:   R( e, a, b, c, d, F4, K4, M(71) );
        !           151:   R( d, e, a, b, c, F4, K4, M(72) );
        !           152:   R( c, d, e, a, b, F4, K4, M(73) );
        !           153:   R( b, c, d, e, a, F4, K4, M(74) );
        !           154:   R( a, b, c, d, e, F4, K4, M(75) );
        !           155:   R( e, a, b, c, d, F4, K4, M(76) );
        !           156:   R( d, e, a, b, c, F4, K4, M(77) );
        !           157:   R( c, d, e, a, b, F4, K4, M(78) );
        !           158:   R( b, c, d, e, a, F4, K4, M(79) );
        !           159: 
        !           160:   /* Update chaining vars. */
        !           161:   ctx->h0 += a;
        !           162:   ctx->h1 += b;
        !           163:   ctx->h2 += c;
        !           164:   ctx->h3 += d;
        !           165:   ctx->h4 += e;
        !           166: }
        !           167: 
        !           168: /*
        !           169:  * Update the message digest with the contents of BUF with length LEN.
        !           170:  */
        !           171: void
        !           172: sha1_update(struct hash_context *CTX, const byte *buf, uint len)
        !           173: {
        !           174:   struct sha1_context *ctx = (void *) CTX;
        !           175: 
        !           176:   if (ctx->count)
        !           177:   {
        !           178:     /* Fill rest of internal buffer */
        !           179:     for (; len && ctx->count < SHA1_BLOCK_SIZE; len--)
        !           180:       ctx->buf[ctx->count++] = *buf++;
        !           181: 
        !           182:     if (ctx->count < SHA1_BLOCK_SIZE)
        !           183:       return;
        !           184: 
        !           185:     /* Process data from internal buffer */
        !           186:     sha1_transform(ctx, ctx->buf);
        !           187:     ctx->nblocks++;
        !           188:     ctx->count = 0;
        !           189:   }
        !           190: 
        !           191:   if (!len)
        !           192:     return;
        !           193: 
        !           194:   /* Process data from input buffer */
        !           195:   while (len >= SHA1_BLOCK_SIZE)
        !           196:   {
        !           197:     sha1_transform(ctx, buf);
        !           198:     ctx->nblocks++;
        !           199:     buf += SHA1_BLOCK_SIZE;
        !           200:     len -= SHA1_BLOCK_SIZE;
        !           201:   }
        !           202: 
        !           203:   /* Copy remaining data to internal buffer */
        !           204:   memcpy(ctx->buf, buf, len);
        !           205:   ctx->count = len;
        !           206: }
        !           207: 
        !           208: /*
        !           209:  * The routine final terminates the computation and returns the digest. The
        !           210:  * handle is prepared for a new cycle, but adding bytes to the handle will the
        !           211:  * destroy the returned buffer.
        !           212:  *
        !           213:  * Returns: 20 bytes representing the digest.
        !           214:  */
        !           215: byte *
        !           216: sha1_final(struct hash_context *CTX)
        !           217: {
        !           218:   struct sha1_context *ctx = (void *) CTX;
        !           219:   u32 t, msb, lsb;
        !           220: 
        !           221:   sha1_update(CTX, NULL, 0);   /* flush */
        !           222: 
        !           223:   t = ctx->nblocks;
        !           224:   /* multiply by 64 to make a byte count */
        !           225:   lsb = t << 6;
        !           226:   msb = t >> 26;
        !           227:   /* add the count */
        !           228:   t = lsb;
        !           229:   if ((lsb += ctx->count) < t)
        !           230:     msb++;
        !           231:   /* multiply by 8 to make a bit count */
        !           232:   t = lsb;
        !           233:   lsb <<= 3;
        !           234:   msb <<= 3;
        !           235:   msb |= t >> 29;
        !           236: 
        !           237:   if (ctx->count < 56)
        !           238:   {
        !           239:     /* enough room */
        !           240:     ctx->buf[ctx->count++] = 0x80; /* pad */
        !           241:     while (ctx->count < 56)
        !           242:       ctx->buf[ctx->count++] = 0;  /* pad */
        !           243:   }
        !           244:   else
        !           245:   {
        !           246:     /* need one extra block */
        !           247:     ctx->buf[ctx->count++] = 0x80; /* pad character */
        !           248:     while (ctx->count < 64)
        !           249:       ctx->buf[ctx->count++] = 0;
        !           250:     sha1_update(CTX, NULL, 0); /* flush */
        !           251:     memset(ctx->buf, 0, 56); /* fill next block with zeroes */
        !           252:   }
        !           253: 
        !           254:   /* append the 64 bit count */
        !           255:   ctx->buf[56] = msb >> 24;
        !           256:   ctx->buf[57] = msb >> 16;
        !           257:   ctx->buf[58] = msb >>  8;
        !           258:   ctx->buf[59] = msb;
        !           259:   ctx->buf[60] = lsb >> 24;
        !           260:   ctx->buf[61] = lsb >> 16;
        !           261:   ctx->buf[62] = lsb >>  8;
        !           262:   ctx->buf[63] = lsb;
        !           263:   sha1_transform(ctx, ctx->buf);
        !           264: 
        !           265:   byte *p = ctx->buf;
        !           266: #define X(a) do { put_u32(p, ctx->h##a); p += 4; } while(0)
        !           267:   X(0);
        !           268:   X(1);
        !           269:   X(2);
        !           270:   X(3);
        !           271:   X(4);
        !           272: #undef X
        !           273: 
        !           274:   return ctx->buf;
        !           275: }

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