Return to sha1.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / crypto / axtls

Annotation of qemu/roms/ipxe/src/crypto/axtls/sha1.c, revision 1.1

1.1     ! root        1: /*
        !             2:  *  Copyright(C) 2006 Cameron Rich
        !             3:  *
        !             4:  *  This library is free software; you can redistribute it and/or modify
        !             5:  *  it under the terms of the GNU Lesser General Public License as published by
        !             6:  *  the Free Software Foundation; either version 2.1 of the License, or
        !             7:  *  (at your option) any later version.
        !             8:  *
        !             9:  *  This library is distributed in the hope that it will be useful,
        !            10:  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
        !            11:  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        !            12:  *  GNU Lesser General Public License for more details.
        !            13:  *
        !            14:  *  You should have received a copy of the GNU Lesser General Public License
        !            15:  *  along with this library; if not, write to the Free Software
        !            16:  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
        !            17:  */
        !            18: 
        !            19: /**
        !            20:  * SHA1 implementation - as defined in FIPS PUB 180-1 published April 17, 1995.
        !            21:  * This code was originally taken from RFC3174
        !            22:  */
        !            23: 
        !            24: #include <string.h>
        !            25: #include "crypto.h"
        !            26: 
        !            27: /*
        !            28:  *  Define the SHA1 circular left shift macro
        !            29:  */
        !            30: #define SHA1CircularShift(bits,word) \
        !            31:                 (((word) << (bits)) | ((word) >> (32-(bits))))
        !            32: 
        !            33: /* ----- static functions ----- */
        !            34: static void SHA1PadMessage(SHA1_CTX *ctx);
        !            35: static void SHA1ProcessMessageBlock(SHA1_CTX *ctx);
        !            36: 
        !            37: /**
        !            38:  * Initialize the SHA1 context 
        !            39:  */
        !            40: void SHA1Init(SHA1_CTX *ctx)
        !            41: {
        !            42:     ctx->Length_Low             = 0;
        !            43:     ctx->Length_High            = 0;
        !            44:     ctx->Message_Block_Index    = 0;
        !            45:     ctx->Intermediate_Hash[0]   = 0x67452301;
        !            46:     ctx->Intermediate_Hash[1]   = 0xEFCDAB89;
        !            47:     ctx->Intermediate_Hash[2]   = 0x98BADCFE;
        !            48:     ctx->Intermediate_Hash[3]   = 0x10325476;
        !            49:     ctx->Intermediate_Hash[4]   = 0xC3D2E1F0;
        !            50: }
        !            51: 
        !            52: /**
        !            53:  * Accepts an array of octets as the next portion of the message.
        !            54:  */
        !            55: void SHA1Update(SHA1_CTX *ctx, const uint8_t *msg, int len)
        !            56: {
        !            57:     while (len--)
        !            58:     {
        !            59:         ctx->Message_Block[ctx->Message_Block_Index++] = (*msg & 0xFF);
        !            60: 
        !            61:         ctx->Length_Low += 8;
        !            62:         if (ctx->Length_Low == 0)
        !            63:         {
        !            64:             ctx->Length_High++;
        !            65:         }
        !            66: 
        !            67:         if (ctx->Message_Block_Index == 64)
        !            68:         {
        !            69:             SHA1ProcessMessageBlock(ctx);
        !            70:         }
        !            71: 
        !            72:         msg++;
        !            73:     }
        !            74: }
        !            75: 
        !            76: /**
        !            77:  * Return the 160-bit message digest into the user's array
        !            78:  */
        !            79: void SHA1Final(SHA1_CTX *ctx, uint8_t *digest)
        !            80: {
        !            81:     int i;
        !            82: 
        !            83:     SHA1PadMessage(ctx);
        !            84:     memset(ctx->Message_Block, 0, 64);
        !            85:     ctx->Length_Low = 0;    /* and clear length */
        !            86:     ctx->Length_High = 0;
        !            87: 
        !            88:     for  (i = 0; i < SHA1_SIZE; i++)
        !            89:     {
        !            90:         digest[i] = ctx->Intermediate_Hash[i>>2] >> 8 * ( 3 - ( i & 0x03 ) );
        !            91:     }
        !            92: }
        !            93: 
        !            94: /**
        !            95:  * Process the next 512 bits of the message stored in the array.
        !            96:  */
        !            97: static void SHA1ProcessMessageBlock(SHA1_CTX *ctx)
        !            98: {
        !            99:     const uint32_t K[] =    {       /* Constants defined in SHA-1   */
        !           100:                             0x5A827999,
        !           101:                             0x6ED9EBA1,
        !           102:                             0x8F1BBCDC,
        !           103:                             0xCA62C1D6
        !           104:                             };
        !           105:     int        t;                 /* Loop counter                */
        !           106:     uint32_t      temp;              /* Temporary word value        */
        !           107:     uint32_t      W[80];             /* Word sequence               */
        !           108:     uint32_t      A, B, C, D, E;     /* Word buffers                */
        !           109: 
        !           110:     /*
        !           111:      *  Initialize the first 16 words in the array W
        !           112:      */
        !           113:     for  (t = 0; t < 16; t++)
        !           114:     {
        !           115:         W[t] = ctx->Message_Block[t * 4] << 24;
        !           116:         W[t] |= ctx->Message_Block[t * 4 + 1] << 16;
        !           117:         W[t] |= ctx->Message_Block[t * 4 + 2] << 8;
        !           118:         W[t] |= ctx->Message_Block[t * 4 + 3];
        !           119:     }
        !           120: 
        !           121:     for (t = 16; t < 80; t++)
        !           122:     {
        !           123:        W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]);
        !           124:     }
        !           125: 
        !           126:     A = ctx->Intermediate_Hash[0];
        !           127:     B = ctx->Intermediate_Hash[1];
        !           128:     C = ctx->Intermediate_Hash[2];
        !           129:     D = ctx->Intermediate_Hash[3];
        !           130:     E = ctx->Intermediate_Hash[4];
        !           131: 
        !           132:     for (t = 0; t < 20; t++)
        !           133:     {
        !           134:         temp =  SHA1CircularShift(5,A) +
        !           135:                 ((B & C) | ((~B) & D)) + E + W[t] + K[0];
        !           136:         E = D;
        !           137:         D = C;
        !           138:         C = SHA1CircularShift(30,B);
        !           139: 
        !           140:         B = A;
        !           141:         A = temp;
        !           142:     }
        !           143: 
        !           144:     for (t = 20; t < 40; t++)
        !           145:     {
        !           146:         temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1];
        !           147:         E = D;
        !           148:         D = C;
        !           149:         C = SHA1CircularShift(30,B);
        !           150:         B = A;
        !           151:         A = temp;
        !           152:     }
        !           153: 
        !           154:     for (t = 40; t < 60; t++)
        !           155:     {
        !           156:         temp = SHA1CircularShift(5,A) +
        !           157:                ((B & C) | (B & D) | (C & D)) + E + W[t] + K[2];
        !           158:         E = D;
        !           159:         D = C;
        !           160:         C = SHA1CircularShift(30,B);
        !           161:         B = A;
        !           162:         A = temp;
        !           163:     }
        !           164: 
        !           165:     for (t = 60; t < 80; t++)
        !           166:     {
        !           167:         temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[3];
        !           168:         E = D;
        !           169:         D = C;
        !           170:         C = SHA1CircularShift(30,B);
        !           171:         B = A;
        !           172:         A = temp;
        !           173:     }
        !           174: 
        !           175:     ctx->Intermediate_Hash[0] += A;
        !           176:     ctx->Intermediate_Hash[1] += B;
        !           177:     ctx->Intermediate_Hash[2] += C;
        !           178:     ctx->Intermediate_Hash[3] += D;
        !           179:     ctx->Intermediate_Hash[4] += E;
        !           180:     ctx->Message_Block_Index = 0;
        !           181: }
        !           182: 
        !           183: /*
        !           184:  * According to the standard, the message must be padded to an even
        !           185:  * 512 bits.  The first padding bit must be a '1'.  The last 64
        !           186:  * bits represent the length of the original message.  All bits in
        !           187:  * between should be 0.  This function will pad the message
        !           188:  * according to those rules by filling the Message_Block array
        !           189:  * accordingly.  It will also call the ProcessMessageBlock function
        !           190:  * provided appropriately.  When it returns, it can be assumed that
        !           191:  * the message digest has been computed.
        !           192:  *
        !           193:  * @param ctx [in, out] The SHA1 context
        !           194:  */
        !           195: static void SHA1PadMessage(SHA1_CTX *ctx)
        !           196: {
        !           197:     /*
        !           198:      *  Check to see if the current message block is too small to hold
        !           199:      *  the initial padding bits and length.  If so, we will pad the
        !           200:      *  block, process it, and then continue padding into a second
        !           201:      *  block.
        !           202:      */
        !           203:     if (ctx->Message_Block_Index > 55)
        !           204:     {
        !           205:         ctx->Message_Block[ctx->Message_Block_Index++] = 0x80;
        !           206:         while(ctx->Message_Block_Index < 64)
        !           207:         {
        !           208:             ctx->Message_Block[ctx->Message_Block_Index++] = 0;
        !           209:         }
        !           210: 
        !           211:         SHA1ProcessMessageBlock(ctx);
        !           212: 
        !           213:         while (ctx->Message_Block_Index < 56)
        !           214:         {
        !           215:             ctx->Message_Block[ctx->Message_Block_Index++] = 0;
        !           216:         }
        !           217:     }
        !           218:     else
        !           219:     {
        !           220:         ctx->Message_Block[ctx->Message_Block_Index++] = 0x80;
        !           221:         while(ctx->Message_Block_Index < 56)
        !           222:         {
        !           223: 
        !           224:             ctx->Message_Block[ctx->Message_Block_Index++] = 0;
        !           225:         }
        !           226:     }
        !           227: 
        !           228:     /*
        !           229:      *  Store the message length as the last 8 octets
        !           230:      */
        !           231:     ctx->Message_Block[56] = ctx->Length_High >> 24;
        !           232:     ctx->Message_Block[57] = ctx->Length_High >> 16;
        !           233:     ctx->Message_Block[58] = ctx->Length_High >> 8;
        !           234:     ctx->Message_Block[59] = ctx->Length_High;
        !           235:     ctx->Message_Block[60] = ctx->Length_Low >> 24;
        !           236:     ctx->Message_Block[61] = ctx->Length_Low >> 16;
        !           237:     ctx->Message_Block[62] = ctx->Length_Low >> 8;
        !           238:     ctx->Message_Block[63] = ctx->Length_Low;
        !           239:     SHA1ProcessMessageBlock(ctx);
        !           240: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.