syslinux/com32/libutil/sha1hash.c

   1 /*
   2 SHA-1 in C
   3 By Steve Reid <sreid@sea-to-sky.net>
   4 100% Public Domain
   5
   6 -----------------
   7 Modified 7/98
   8 By James H. Brown <jbrown@burgoyne.com>
   9 Still 100% Public Domain
  10
  11 Corrected a problem which generated improper hash values on 16 bit machines
  12 Routine SHA1Update changed from
  13         void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned int
  14 len)
  15 to
  16         void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned
  17 long len)
  18
  19 The 'len' parameter was declared an int which works fine on 32 bit machines.
  20 However, on 16 bit machines an int is too small for the shifts being done
  21 against
  22 it.  This caused the hash function to generate incorrect values if len was
  23 greater than 8191 (8K - 1) due to the 'len << 3' on line 3 of SHA1Update().
  24
  25 Since the file IO in main() reads 16K at a time, any file 8K or larger would
  26 be guaranteed to generate the wrong hash (e.g. Test Vector #3, a million
  27 "a"s).
  28
  29 I also changed the declaration of variables i & j in SHA1Update to
  30 unsigned long from unsigned int for the same reason.
  31
  32 These changes should make no difference to any 32 bit implementations since
  33 an
  34 int and a long are the same size in those environments.
  35
  36 --
  37 I also corrected a few compiler warnings generated by Borland C.
  38 1. Added #include <process.h> for exit() prototype
  39 2. Removed unused variable 'j' in SHA1Final
  40 3. Changed exit(0) to return(0) at end of main.
  41
  42 ALL changes I made can be located by searching for comments containing 'JHB'
  43 -----------------
  44 Modified 8/98
  45 By Steve Reid <sreid@sea-to-sky.net>
  46 Still 100% public domain
  47
  48 1- Removed #include <process.h> and used return() instead of exit()
  49 2- Fixed overwriting of finalcount in SHA1Final() (discovered by Chris Hall)
  50 3- Changed email address from steve@edmweb.com to sreid@sea-to-sky.net
  51
  52 -----------------
  53 Modified 4/01
  54 By Saul Kravitz <Saul.Kravitz@celera.com>
  55 Still 100% PD
  56 Modified to run on Compaq Alpha hardware.
  57
  58 -----------------
  59 Modified 2/03
  60 By H. Peter Anvin <hpa@zytor.com>
  61 Still 100% PD
  62 Modified to run on any hardware with <inttypes.h> and <netinet/in.h>
  63 Changed the driver program
  64
  65 */
  66
  67 /*
  68 Test Vectors (from FIPS PUB 180-1)
  69 "abc"
  70   A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
  71 "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
  72   84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
  73 A million repetitions of "a"
  74   34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
  75 */
  76
  77 /* #define SHA1HANDSOFF  */
  78
  79 #include <stdio.h>
  80 #include <string.h>
  81 #include <inttypes.h>
  82 #include <netinet/in.h>         /* For htonl/ntohl/htons/ntohs */
  83
  84 #include "sha1.h"
  85
  86 #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
  87
  88 /* blk0() and blk() perform the initial expand. */
  89 /* I got the idea of expanding during the round function from SSLeay */
  90 #define blk0(i) (block->l[i] = ntohl(block->l[i]))
  91 #define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
  92     ^block->l[(i+2)&15]^block->l[i&15],1))
  93
  94 /* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
  95 #define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
  96 #define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
  97 #define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
  98 #define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
  99 #define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
 100
 101
 102 #ifdef VERBOSE  /* SAK */
 103 void SHAPrintContext(SHA1_CTX *context, char *msg){
 104   printf("%s (%d,%d) %x %x %x %x %x\n",
 105          msg,
 106          context->count[0], context->count[1],
 107          context->state[0],
 108          context->state[1],
 109          context->state[2],
 110          context->state[3],
 111          context->state[4]);
 112 }
 113 #endif
 114
 115 /* Hash a single 512-bit block. This is the core of the algorithm. */
 116
 117 void SHA1Transform(uint32_t state[5], const unsigned char buffer[64])
 118 {
 119 uint32_t a, b, c, d, e;
 120 typedef union {
 121     unsigned char c[64];
 122     uint32_t l[16];
 123 } CHAR64LONG16;
 124 CHAR64LONG16* block;
 125 #ifdef SHA1HANDSOFF
 126 static unsigned char workspace[64];
 127     block = (CHAR64LONG16*)workspace;
 128     memcpy(block, buffer, 64);
 129 #else
 130     block = (CHAR64LONG16*)buffer;
 131 #endif
 132     /* Copy context->state[] to working vars */
 133     a = state[0];
 134     b = state[1];
 135     c = state[2];
 136     d = state[3];
 137     e = state[4];
 138     /* 4 rounds of 20 operations each. Loop unrolled. */
 139     R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
 140     R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
 141     R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
 142     R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
 143     R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
 144     R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
 145     R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
 146     R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
 147     R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
 148     R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
 149     R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
 150     R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
 151     R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
 152     R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
 153     R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
 154     R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
 155     R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
 156     R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
 157     R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
 158     R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
 159     /* Add the working vars back into context.state[] */
 160     state[0] += a;
 161     state[1] += b;
 162     state[2] += c;
 163     state[3] += d;
 164     state[4] += e;
 165     /* Wipe variables */
 166     a = b = c = d = e = 0;
 167 }
 168
 169
 170 /* SHA1Init - Initialize new context */
 171
 172 void SHA1Init(SHA1_CTX* context)
 173 {
 174     /* SHA1 initialization constants */
 175     context->state[0] = 0x67452301;
 176     context->state[1] = 0xEFCDAB89;
 177     context->state[2] = 0x98BADCFE;
 178     context->state[3] = 0x10325476;
 179     context->state[4] = 0xC3D2E1F0;
 180     context->count[0] = context->count[1] = 0;
 181 }
 182
 183
 184 /* Run your data through this. */
 185
 186 void SHA1Update(SHA1_CTX* context, const unsigned char* data, uint32_t len)     /*
 187 JHB */
 188 {
 189 uint32_t i, j;  /* JHB */
 190
 191 #ifdef VERBOSE
 192     SHAPrintContext(context, "before");
 193 #endif
 194     j = (context->count[0] >> 3) & 63;
 195     if ((context->count[0] += len << 3) < (len << 3)) context->count[1]++;
 196     context->count[1] += (len >> 29);
 197     if ((j + len) > 63) {
 198         memcpy(&context->buffer[j], data, (i = 64-j));
 199         SHA1Transform(context->state, context->buffer);
 200         for ( ; i + 63 < len; i += 64) {
 201             SHA1Transform(context->state, &data[i]);
 202         }
 203         j = 0;
 204     }
 205     else i = 0;
 206     memcpy(&context->buffer[j], &data[i], len - i);
 207 #ifdef VERBOSE
 208     SHAPrintContext(context, "after ");
 209 #endif
 210 }
 211
 212
 213 /* Add padding and return the message digest. */
 214
 215 void SHA1Final(unsigned char digest[20], SHA1_CTX* context)
 216 {
 217 uint32_t i;     /* JHB */
 218 unsigned char finalcount[8];
 219
 220     for (i = 0; i < 8; i++) {
 221         finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)]
 222          >> ((3-(i & 3)) * 8) ) & 255);  /* Endian independent */
 223     }
 224     SHA1Update(context, (unsigned char *)"\200", 1);
 225     while ((context->count[0] & 504) != 448) {
 226         SHA1Update(context, (unsigned char *)"\0", 1);
 227     }
 228     SHA1Update(context, finalcount, 8);  /* Should cause a SHA1Transform()
 229 */
 230     for (i = 0; i < 20; i++) {
 231         digest[i] = (unsigned char)
 232          ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
 233     }
 234     /* Wipe variables */
 235     i = 0;      /* JHB */
 236     memset(context->buffer, 0, 64);
 237     memset(context->state, 0, 20);
 238     memset(context->count, 0, 8);
 239     memset(finalcount, 0, 8);   /* SWR */
 240 #ifdef SHA1HANDSOFF  /* make SHA1Transform overwrite it's own static vars */
 241     SHA1Transform(context->state, context->buffer);
 242 #endif
 243 }
 244
 245 /*************************************************************/
 246
 247 /* This is not quite the MIME base64 algorithm: it uses _ instead of /,
 248    and instead of padding the output with = characters we just make the
 249    output shorter. */
 250 char *mybase64(uint8_t digest[20])
 251 {
 252   static const char charz[] =
 253     "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+_";
 254   uint8_t input[21];
 255   static char output[28];
 256   int i, j;
 257   uint8_t *p;
 258   char *q;
 259   uint32_t bv;
 260
 261   memcpy(input, digest, 20);
 262   input[20] = 0;                /* Pad to multiple of 3 bytes */
 263
 264   p = input;  q = output;
 265   for ( i = 0 ; i < 7 ; i++ ) {
 266     bv = (p[0] << 16) | (p[1] << 8) | p[2];
 267     p += 3;
 268     for ( j = 0 ; j < 4 ; j++ ) {
 269       *q++ = charz[(bv >> 18) & 0x3f];
 270       bv <<= 6;
 271     }
 272   }
 273   *--q = '\0';                  /* The last character is not significant */
 274   return output;
 275 }
 276
 277 #ifdef FOR_TESTING_ONLY
 278
 279 int main(int argc, char** argv)
 280 {
 281   int i;
 282   SHA1_CTX context;
 283   uint8_t digest[20], buffer[16384];
 284   FILE* file;
 285
 286   if (argc < 2) {
 287     file = stdin;
 288   }
 289   else {
 290     if (!(file = fopen(argv[1], "rb"))) {
 291       fputs("Unable to open file.", stderr);
 292       return(-1);
 293     }
 294   }
 295   SHA1Init(&context);
 296   while (!feof(file)) {  /* note: what if ferror(file) */
 297     i = fread(buffer, 1, 16384, file);
 298     SHA1Update(&context, buffer, i);
 299   }
 300   SHA1Final(digest, &context);
 301   fclose(file);
 302
 303   puts(mybase64(digest));
 304
 305   return 0;
 306 }
 307
 308 #endif