pd.if.org Git - uuid/blob - sha1.c

   1 /*
   2  * Adapted from libtomcrypt by Tom St Denis
   3  *
   4  * by Nathan Wagner and released into the public domain
   5  */
   6
   7 #define ENDIAN_NEUTRAL 1
   8 #define LTC_SMALL_CODE 1
   9
  10 #include "tomcrypt_macros.h"
  11 #include "hash.h"
  12
  13 #define F0(x,y,z)  (z ^ (x & (y ^ z)))
  14 #define F1(x,y,z)  (x ^ y ^ z)
  15 #define F2(x,y,z)  ((x & y) | (z & (x | y)))
  16 #define F3(x,y,z)  (x ^ y ^ z)
  17
  18 static int  sha1_compress(hash_state *md, unsigned char *buf)
  19 {
  20     ulong32 a,b,c,d,e,W[80],i;
  21 #ifdef LTC_SMALL_CODE
  22     ulong32 t;
  23 #endif
  24
  25     /* copy the state into 512-bits into W[0..15] */
  26     for (i = 0; i < 16; i++) {
  27         LOAD32H(W[i], buf + (4*i));
  28     }
  29
  30     /* copy state */
  31     a = md->sha1.state[0];
  32     b = md->sha1.state[1];
  33     c = md->sha1.state[2];
  34     d = md->sha1.state[3];
  35     e = md->sha1.state[4];
  36
  37     /* expand it */
  38     for (i = 16; i < 80; i++) {
  39         W[i] = ROL(W[i-3] ^ W[i-8] ^ W[i-14] ^ W[i-16], 1);
  40     }
  41
  42     /* compress */
  43     /* round one */
  44     #define FF0(a,b,c,d,e,i) e = (ROL(a, 5) + F0(b,c,d) + e + W[i] + 0x5a827999UL); b = ROL(b, 30);
  45     #define FF1(a,b,c,d,e,i) e = (ROL(a, 5) + F1(b,c,d) + e + W[i] + 0x6ed9eba1UL); b = ROL(b, 30);
  46     #define FF2(a,b,c,d,e,i) e = (ROL(a, 5) + F2(b,c,d) + e + W[i] + 0x8f1bbcdcUL); b = ROL(b, 30);
  47     #define FF3(a,b,c,d,e,i) e = (ROL(a, 5) + F3(b,c,d) + e + W[i] + 0xca62c1d6UL); b = ROL(b, 30);
  48
  49 #ifdef LTC_SMALL_CODE
  50
  51     for (i = 0; i < 20; ) {
  52        FF0(a,b,c,d,e,i++); t = e; e = d; d = c; c = b; b = a; a = t;
  53     }
  54
  55     for (; i < 40; ) {
  56        FF1(a,b,c,d,e,i++); t = e; e = d; d = c; c = b; b = a; a = t;
  57     }
  58
  59     for (; i < 60; ) {
  60        FF2(a,b,c,d,e,i++); t = e; e = d; d = c; c = b; b = a; a = t;
  61     }
  62
  63     for (; i < 80; ) {
  64        FF3(a,b,c,d,e,i++); t = e; e = d; d = c; c = b; b = a; a = t;
  65     }
  66
  67 #else
  68
  69     for (i = 0; i < 20; ) {
  70        FF0(a,b,c,d,e,i++);
  71        FF0(e,a,b,c,d,i++);
  72        FF0(d,e,a,b,c,i++);
  73        FF0(c,d,e,a,b,i++);
  74        FF0(b,c,d,e,a,i++);
  75     }
  76
  77     /* round two */
  78     for (; i < 40; )  {
  79        FF1(a,b,c,d,e,i++);
  80        FF1(e,a,b,c,d,i++);
  81        FF1(d,e,a,b,c,i++);
  82        FF1(c,d,e,a,b,i++);
  83        FF1(b,c,d,e,a,i++);
  84     }
  85
  86     /* round three */
  87     for (; i < 60; )  {
  88        FF2(a,b,c,d,e,i++);
  89        FF2(e,a,b,c,d,i++);
  90        FF2(d,e,a,b,c,i++);
  91        FF2(c,d,e,a,b,i++);
  92        FF2(b,c,d,e,a,i++);
  93     }
  94
  95     /* round four */
  96     for (; i < 80; )  {
  97        FF3(a,b,c,d,e,i++);
  98        FF3(e,a,b,c,d,i++);
  99        FF3(d,e,a,b,c,i++);
 100        FF3(c,d,e,a,b,i++);
 101        FF3(b,c,d,e,a,i++);
 102     }
 103 #endif
 104
 105     #undef FF0
 106     #undef FF1
 107     #undef FF2
 108     #undef FF3
 109
 110     /* store */
 111     md->sha1.state[0] = md->sha1.state[0] + a;
 112     md->sha1.state[1] = md->sha1.state[1] + b;
 113     md->sha1.state[2] = md->sha1.state[2] + c;
 114     md->sha1.state[3] = md->sha1.state[3] + d;
 115     md->sha1.state[4] = md->sha1.state[4] + e;
 116
 117     return CRYPT_OK;
 118 }
 119
 120 int sha1_init(hash_state * md)
 121 {
 122    LTC_ARGCHK(md != NULL);
 123    md->sha1.state[0] = 0x67452301UL;
 124    md->sha1.state[1] = 0xefcdab89UL;
 125    md->sha1.state[2] = 0x98badcfeUL;
 126    md->sha1.state[3] = 0x10325476UL;
 127    md->sha1.state[4] = 0xc3d2e1f0UL;
 128    md->sha1.curlen = 0;
 129    md->sha1.length = 0;
 130    return CRYPT_OK;
 131 }
 132
 133 HASH_PROCESS(sha1_process, sha1_compress, sha1, 64)
 134
 135 int sha1_done(hash_state * md, unsigned char *out) {
 136     int i;
 137
 138     LTC_ARGCHK(md  != NULL);
 139     LTC_ARGCHK(out != NULL);
 140
 141     if (md->sha1.curlen >= sizeof(md->sha1.buf)) {
 142        return CRYPT_INVALID_ARG;
 143     }
 144
 145     /* increase the length of the message */
 146     md->sha1.length += md->sha1.curlen * 8;
 147
 148     /* append the '1' bit */
 149     md->sha1.buf[md->sha1.curlen++] = (unsigned char)0x80;
 150
 151     /* if the length is currently above 56 bytes we append zeros
 152      * then compress.  Then we can fall back to padding zeros and length
 153      * encoding like normal.
 154      */
 155     if (md->sha1.curlen > 56) {
 156         while (md->sha1.curlen < 64) {
 157             md->sha1.buf[md->sha1.curlen++] = (unsigned char)0;
 158         }
 159         sha1_compress(md, md->sha1.buf);
 160         md->sha1.curlen = 0;
 161     }
 162
 163     /* pad upto 56 bytes of zeroes */
 164     while (md->sha1.curlen < 56) {
 165         md->sha1.buf[md->sha1.curlen++] = (unsigned char)0;
 166     }
 167
 168     /* store length */
 169     STORE64H(md->sha1.length, md->sha1.buf+56);
 170     sha1_compress(md, md->sha1.buf);
 171
 172     /* copy output */
 173     for (i = 0; i < 5; i++) {
 174         STORE32H(md->sha1.state[i], out+(4*i));
 175     }
 176 #ifdef LTC_CLEAN_STACK
 177     zeromem(md, sizeof(hash_state));
 178 #endif
 179     return CRYPT_OK;
 180 }
 181
 182 int  sha1_test(void) {
 183  #if 0
 184     return CRYPT_NOP;
 185  #else
 186   static const struct {
 187       char *msg;
 188       unsigned char hash[20];
 189   } tests[] = {
 190     { "abc",
 191       { 0xa9, 0x99, 0x3e, 0x36, 0x47, 0x06, 0x81, 0x6a,
 192         0xba, 0x3e, 0x25, 0x71, 0x78, 0x50, 0xc2, 0x6c,
 193         0x9c, 0xd0, 0xd8, 0x9d }
 194     },
 195     { "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
 196       { 0x84, 0x98, 0x3E, 0x44, 0x1C, 0x3B, 0xD2, 0x6E,
 197         0xBA, 0xAE, 0x4A, 0xA1, 0xF9, 0x51, 0x29, 0xE5,
 198         0xE5, 0x46, 0x70, 0xF1 }
 199     }
 200   };
 201
 202   int i;
 203   unsigned char tmp[20];
 204   hash_state md;
 205
 206   for (i = 0; i < (int)(sizeof(tests) / sizeof(tests[0]));  i++) {
 207       sha1_init(&md);
 208       sha1_process(&md, (unsigned char*)tests[i].msg, (unsigned long)strlen(tests[i].msg));
 209       sha1_done(&md, tmp);
 210       if (XMEMCMP(tmp, tests[i].hash, 20) != 0) {
 211          return CRYPT_FAIL_TESTVECTOR;
 212       }
 213   }
 214   return CRYPT_OK;
 215   #endif
 216 }