src/third_party/libjingle/source/talk/base/sha1.cc

   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 07/2002
  60  * By Ralph Giles <giles@ghostscript.com>
  61  * Still 100% public domain
  62  * modified for use with stdint types, autoconf
  63  * code cleanup, removed attribution comments
  64  * switched SHA1Final() argument order for consistency
  65  * use SHA1_ prefix for public api
  66  * move public api to sha1.h
  67  *
  68  * -----------------
  69  * Modified 02/2012
  70  * By Justin Uberti <juberti@google.com>
  71  * Remove underscore from SHA1 prefix to avoid conflict with OpenSSL
  72  * Remove test code
  73  * Untabify
  74  *
  75  * -----------------
  76  * Modified 03/2012
  77  * By Ronghua Wu <ronghuawu@google.com>
  78  * Change the typedef of uint32(8)_t to uint32(8). We need this because in the
  79  * chromium android build, the stdio.h will include stdint.h which already
  80  * defined uint32(8)_t.
  81  *
  82  * -----------------
  83  * Modified 04/2012
  84  * By Frank Barchard <fbarchard@google.com>
  85  * Ported to C++, Google style, change len to size_t, enable SHA1HANDSOFF
  86  *
  87  * Test Vectors (from FIPS PUB 180-1)
  88  * "abc"
  89  *   A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
  90  * "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
  91  *   84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
  92  * A million repetitions of "a"
  93  *   34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
  94  */
  95
  96 // Enabling SHA1HANDSOFF preserves the caller's data buffer.
  97 // Disabling SHA1HANDSOFF the buffer will be modified (end swapped).
  98 #define SHA1HANDSOFF
  99
 100 #include "talk/base/sha1.h"
 101
 102 #include <stdio.h>
 103 #include <string.h>
 104
 105 void SHA1Transform(uint32 state[5], const uint8 buffer[64]);
 106
 107 #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
 108
 109 // blk0() and blk() perform the initial expand.
 110 // I got the idea of expanding during the round function from SSLeay
 111 // FIXME: can we do this in an endian-proof way?
 112 #ifdef ARCH_CPU_BIG_ENDIAN
 113 #define blk0(i) block->l[i]
 114 #else
 115 #define blk0(i) (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \
 116     (rol(block->l[i], 8) & 0x00FF00FF))
 117 #endif
 118 #define blk(i) (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ \
 119     block->l[(i + 8) & 15] ^ block->l[(i + 2) & 15] ^ block->l[i & 15], 1))
 120
 121 // (R0+R1), R2, R3, R4 are the different operations used in SHA1.
 122 #define R0(v, w, x, y, z, i) \
 123     z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \
 124     w = rol(w, 30);
 125 #define R1(v, w, x, y, z, i) \
 126     z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \
 127     w = rol(w, 30);
 128 #define R2(v, w, x, y, z, i) \
 129     z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5);\
 130     w = rol(w, 30);
 131 #define R3(v, w, x, y, z, i) \
 132     z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \
 133     w = rol(w, 30);
 134 #define R4(v, w, x, y, z, i) \
 135     z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \
 136     w = rol(w, 30);
 137
 138 #ifdef VERBOSE  // SAK
 139 void SHAPrintContext(SHA1_CTX *context, char *msg) {
 140   printf("%s (%d,%d) %x %x %x %x %x\n",
 141          msg,
 142          context->count[0], context->count[1],
 143          context->state[0],
 144          context->state[1],
 145          context->state[2],
 146          context->state[3],
 147          context->state[4]);
 148 }
 149 #endif /* VERBOSE */
 150
 151 // Hash a single 512-bit block. This is the core of the algorithm.
 152 void SHA1Transform(uint32 state[5], const uint8 buffer[64]) {
 153   union CHAR64LONG16 {
 154     uint8 c[64];
 155     uint32 l[16];
 156   };
 157 #ifdef SHA1HANDSOFF
 158   static uint8 workspace[64];
 159   memcpy(workspace, buffer, 64);
 160   CHAR64LONG16* block = reinterpret_cast<CHAR64LONG16*>(workspace);
 161 #else
 162   // Note(fbarchard): This option does modify the user's data buffer.
 163   CHAR64LONG16* block = const_cast<CHAR64LONG16*>(
 164       reinterpret_cast<const CHAR64LONG16*>(buffer));
 165 #endif
 166
 167   // Copy context->state[] to working vars.
 168   uint32 a = state[0];
 169   uint32 b = state[1];
 170   uint32 c = state[2];
 171   uint32 d = state[3];
 172   uint32 e = state[4];
 173
 174   // 4 rounds of 20 operations each. Loop unrolled.
 175   // Note(fbarchard): The following has lint warnings for multiple ; on
 176   // a line and no space after , but is left as-is to be similar to the
 177   // original code.
 178   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);
 179   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);
 180   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);
 181   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);
 182   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);
 183   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);
 184   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);
 185   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);
 186   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);
 187   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);
 188   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);
 189   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);
 190   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);
 191   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);
 192   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);
 193   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);
 194   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);
 195   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);
 196   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);
 197   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);
 198
 199   // Add the working vars back into context.state[].
 200   state[0] += a;
 201   state[1] += b;
 202   state[2] += c;
 203   state[3] += d;
 204   state[4] += e;
 205 }
 206
 207 // SHA1Init - Initialize new context.
 208 void SHA1Init(SHA1_CTX* context) {
 209   // SHA1 initialization constants.
 210   context->state[0] = 0x67452301;
 211   context->state[1] = 0xEFCDAB89;
 212   context->state[2] = 0x98BADCFE;
 213   context->state[3] = 0x10325476;
 214   context->state[4] = 0xC3D2E1F0;
 215   context->count[0] = context->count[1] = 0;
 216 }
 217
 218 // Run your data through this.
 219 void SHA1Update(SHA1_CTX* context, const uint8* data, size_t input_len) {
 220   size_t i = 0;
 221
 222 #ifdef VERBOSE
 223   SHAPrintContext(context, "before");
 224 #endif
 225
 226   // Compute number of bytes mod 64.
 227   size_t index = (context->count[0] >> 3) & 63;
 228
 229   // Update number of bits.
 230   // TODO: Use uint64 instead of 2 uint32 for count.
 231   // count[0] has low 29 bits for byte count + 3 pad 0's making 32 bits for
 232   // bit count.
 233   // Add bit count to low uint32
 234   context->count[0] += static_cast<uint32>(input_len << 3);
 235   if (context->count[0] < static_cast<uint32>(input_len << 3)) {
 236     ++context->count[1];  // if overlow (carry), add one to high word
 237   }
 238   context->count[1] += static_cast<uint32>(input_len >> 29);
 239   if ((index + input_len) > 63) {
 240     i = 64 - index;
 241     memcpy(&context->buffer[index], data, i);
 242     SHA1Transform(context->state, context->buffer);
 243     for (; i + 63 < input_len; i += 64) {
 244       SHA1Transform(context->state, data + i);
 245     }
 246     index = 0;
 247   }
 248   memcpy(&context->buffer[index], &data[i], input_len - i);
 249
 250 #ifdef VERBOSE
 251   SHAPrintContext(context, "after ");
 252 #endif
 253 }
 254
 255 // Add padding and return the message digest.
 256 void SHA1Final(SHA1_CTX* context, uint8 digest[SHA1_DIGEST_SIZE]) {
 257   uint8 finalcount[8];
 258   for (int i = 0; i < 8; ++i) {
 259     // Endian independent
 260     finalcount[i] = static_cast<uint8>(
 261         (context->count[(i >= 4 ? 0 : 1)] >> ((3 - (i & 3)) * 8) ) & 255);
 262   }
 263   SHA1Update(context, reinterpret_cast<const uint8*>("\200"), 1);
 264   while ((context->count[0] & 504) != 448) {
 265     SHA1Update(context, reinterpret_cast<const uint8*>("\0"), 1);
 266   }
 267   SHA1Update(context, finalcount, 8);  // Should cause a SHA1Transform().
 268   for (int i = 0; i < SHA1_DIGEST_SIZE; ++i) {
 269     digest[i] = static_cast<uint8>(
 270         (context->state[i >> 2] >> ((3 - (i & 3)) * 8) ) & 255);
 271   }
 272
 273   // Wipe variables.
 274   memset(context->buffer, 0, 64);
 275   memset(context->state, 0, 20);
 276   memset(context->count, 0, 8);
 277   memset(finalcount, 0, 8);   // SWR
 278
 279 #ifdef SHA1HANDSOFF  // Make SHA1Transform overwrite its own static vars.
 280   SHA1Transform(context->state, context->buffer);
 281 #endif
 282 }