sha1.c

   1 /*
   2  SHA-1 in C
   3
   4  By Steve Reid <steve@edmweb.com>, with small changes to make it
   5  fit into mutt by Thomas Roessler <roessler@does-not-exist.org>.
   6
   7  100% Public Domain.
   8
   9  Test Vectors (from FIPS PUB 180-1)
  10  "abc"
  11  A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
  12  "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
  13  84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
  14  A million repetitions of "a"
  15  34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
  16 */
  17
  18 #define SHA1HANDSOFF
  19
  20 #if HAVE_CONFIG_H
  21 # include "config.h"
  22 #endif
  23
  24 #include <string.h>
  25
  26 #include "sha1.h"
  27
  28 #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
  29
  30 /* blk0() and blk() perform the initial expand. */
  31 /* I got the idea of expanding during the round function from SSLeay */
  32 #ifdef WORDS_BIGENDIAN
  33 #  define blk0(i) block->l[i]
  34 #else
  35 #  define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
  36                     |(rol(block->l[i],8)&0x00FF00FF))
  37 #endif
  38
  39 #define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
  40     ^block->l[(i+2)&15]^block->l[i&15],1))
  41
  42 /* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
  43 #define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
  44 #define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
  45 #define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
  46 #define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
  47 #define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
  48
  49
  50 /* Hash a single 512-bit block. This is the core of the algorithm. */
  51
  52 void SHA1Transform (uint32_t state[5], const unsigned char buffer[64])
  53 {
  54   uint32_t a, b, c, d, e;
  55   typedef union {
  56     unsigned char c[64];
  57     uint32_t l[16];
  58   } CHAR64LONG16;
  59
  60 #ifdef SHA1HANDSOFF
  61   CHAR64LONG16 block[1];        /* use array to appear as a pointer */
  62
  63   memcpy (block, buffer, 64);
  64 #else
  65   /* The following had better never be used because it causes the
  66    * pointer-to-const buffer to be cast into a pointer to non-const.
  67    * And the result is written through.  I threw a "const" in, hoping
  68    * this will cause a diagnostic.
  69    */
  70   CHAR64LONG16 *block = (const CHAR64LONG16 *) buffer;
  71 #endif
  72   /* Copy context->state[] to working vars */
  73   a = state[0];
  74   b = state[1];
  75   c = state[2];
  76   d = state[3];
  77   e = state[4];
  78   /* 4 rounds of 20 operations each. Loop unrolled. */
  79   R0 (a, b, c, d, e, 0);
  80   R0 (e, a, b, c, d, 1);
  81   R0 (d, e, a, b, c, 2);
  82   R0 (c, d, e, a, b, 3);
  83   R0 (b, c, d, e, a, 4);
  84   R0 (a, b, c, d, e, 5);
  85   R0 (e, a, b, c, d, 6);
  86   R0 (d, e, a, b, c, 7);
  87   R0 (c, d, e, a, b, 8);
  88   R0 (b, c, d, e, a, 9);
  89   R0 (a, b, c, d, e, 10);
  90   R0 (e, a, b, c, d, 11);
  91   R0 (d, e, a, b, c, 12);
  92   R0 (c, d, e, a, b, 13);
  93   R0 (b, c, d, e, a, 14);
  94   R0 (a, b, c, d, e, 15);
  95   R1 (e, a, b, c, d, 16);
  96   R1 (d, e, a, b, c, 17);
  97   R1 (c, d, e, a, b, 18);
  98   R1 (b, c, d, e, a, 19);
  99   R2 (a, b, c, d, e, 20);
 100   R2 (e, a, b, c, d, 21);
 101   R2 (d, e, a, b, c, 22);
 102   R2 (c, d, e, a, b, 23);
 103   R2 (b, c, d, e, a, 24);
 104   R2 (a, b, c, d, e, 25);
 105   R2 (e, a, b, c, d, 26);
 106   R2 (d, e, a, b, c, 27);
 107   R2 (c, d, e, a, b, 28);
 108   R2 (b, c, d, e, a, 29);
 109   R2 (a, b, c, d, e, 30);
 110   R2 (e, a, b, c, d, 31);
 111   R2 (d, e, a, b, c, 32);
 112   R2 (c, d, e, a, b, 33);
 113   R2 (b, c, d, e, a, 34);
 114   R2 (a, b, c, d, e, 35);
 115   R2 (e, a, b, c, d, 36);
 116   R2 (d, e, a, b, c, 37);
 117   R2 (c, d, e, a, b, 38);
 118   R2 (b, c, d, e, a, 39);
 119   R3 (a, b, c, d, e, 40);
 120   R3 (e, a, b, c, d, 41);
 121   R3 (d, e, a, b, c, 42);
 122   R3 (c, d, e, a, b, 43);
 123   R3 (b, c, d, e, a, 44);
 124   R3 (a, b, c, d, e, 45);
 125   R3 (e, a, b, c, d, 46);
 126   R3 (d, e, a, b, c, 47);
 127   R3 (c, d, e, a, b, 48);
 128   R3 (b, c, d, e, a, 49);
 129   R3 (a, b, c, d, e, 50);
 130   R3 (e, a, b, c, d, 51);
 131   R3 (d, e, a, b, c, 52);
 132   R3 (c, d, e, a, b, 53);
 133   R3 (b, c, d, e, a, 54);
 134   R3 (a, b, c, d, e, 55);
 135   R3 (e, a, b, c, d, 56);
 136   R3 (d, e, a, b, c, 57);
 137   R3 (c, d, e, a, b, 58);
 138   R3 (b, c, d, e, a, 59);
 139   R4 (a, b, c, d, e, 60);
 140   R4 (e, a, b, c, d, 61);
 141   R4 (d, e, a, b, c, 62);
 142   R4 (c, d, e, a, b, 63);
 143   R4 (b, c, d, e, a, 64);
 144   R4 (a, b, c, d, e, 65);
 145   R4 (e, a, b, c, d, 66);
 146   R4 (d, e, a, b, c, 67);
 147   R4 (c, d, e, a, b, 68);
 148   R4 (b, c, d, e, a, 69);
 149   R4 (a, b, c, d, e, 70);
 150   R4 (e, a, b, c, d, 71);
 151   R4 (d, e, a, b, c, 72);
 152   R4 (c, d, e, a, b, 73);
 153   R4 (b, c, d, e, a, 74);
 154   R4 (a, b, c, d, e, 75);
 155   R4 (e, a, b, c, d, 76);
 156   R4 (d, e, a, b, c, 77);
 157   R4 (c, d, e, a, b, 78);
 158   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 #ifdef SHA1HANDSOFF
 168   memset (block, '\0', sizeof (block));
 169 #endif
 170 }
 171
 172
 173 /* SHA1Init - Initialize new context */
 174
 175 void SHA1Init (SHA1_CTX * context)
 176 {
 177   /* SHA1 initialization constants */
 178   context->state[0] = 0x67452301;
 179   context->state[1] = 0xEFCDAB89;
 180   context->state[2] = 0x98BADCFE;
 181   context->state[3] = 0x10325476;
 182   context->state[4] = 0xC3D2E1F0;
 183   context->count[0] = context->count[1] = 0;
 184 }
 185
 186
 187 /* Run your data through this. */
 188
 189 void SHA1Update (SHA1_CTX * context, const unsigned char *data, uint32_t len)
 190 {
 191   uint32_t i;
 192   uint32_t j;
 193
 194   j = context->count[0];
 195   if ((context->count[0] += len << 3) < j)
 196     context->count[1]++;
 197   context->count[1] += (len >> 29);
 198   j = (j >> 3) & 63;
 199   if ((j + len) > 63) {
 200     memcpy (&context->buffer[j], data, (i = 64 - j));
 201     SHA1Transform (context->state, context->buffer);
 202     for (; i + 63 < len; i += 64) {
 203       SHA1Transform (context->state, &data[i]);
 204     }
 205     j = 0;
 206   }
 207   else
 208     i = 0;
 209   memcpy (&context->buffer[j], &data[i], len - i);
 210 }
 211
 212
 213 /* Add padding and return the message digest. */
 214
 215 void SHA1Final (unsigned char digest[20], SHA1_CTX * context)
 216 {
 217   unsigned i;
 218   unsigned char finalcount[8];
 219   unsigned char c;
 220
 221   for (i = 0; i < 8; i++) {
 222     finalcount[i] = (unsigned char) ((context->count[(i >= 4 ? 0 : 1)]
 223                                       >> ((3 - (i & 3)) * 8)) & 255);   /* Endian independent */
 224   }
 225   c = 0200;
 226   SHA1Update (context, &c, 1);
 227   while ((context->count[0] & 504) != 448) {
 228     c = 0000;
 229     SHA1Update (context, &c, 1);
 230   }
 231   SHA1Update (context, finalcount, 8);  /* Should cause a SHA1Transform() */
 232   for (i = 0; i < 20; i++) {
 233     digest[i] = (unsigned char)
 234       ((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
 235   }
 236   /* Wipe variables */
 237   memset (context, '\0', sizeof (*context));
 238   memset (&finalcount, '\0', sizeof (finalcount));
 239 }