flight/libraries/sha1.c

   1 /*      $NetBSD: sha1.c,v 1.6 2009/11/06 20:31:18 joerg Exp $   */
   2 /*      $OpenBSD: sha1.c,v 1.9 1997/07/23 21:12:32 kstailey Exp $       */
   3
   4 /*
   5  * SHA-1 in C
   6  * By Steve Reid <steve@edmweb.com>
   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 /* Copies data before messing with it. */
  19
  20 #include <sys/cdefs.h>
  21
  22 #if defined(_KERNEL) || defined(_STANDALONE)
  23 __KERNEL_RCSID(0, "$NetBSD: sha1.c,v 1.6 2009/11/06 20:31:18 joerg Exp $");
  24
  25 #include <lib/libkern/libkern.h>
  26
  27 #else
  28
  29 #if defined(LIBC_SCCS) && !defined(lint)
  30 __RCSID("$NetBSD: sha1.c,v 1.6 2009/11/06 20:31:18 joerg Exp $");
  31 #endif /* LIBC_SCCS and not lint */
  32
  33 // #include "namespace.h"
  34 #include <assert.h>
  35 #include <string.h>
  36
  37 #endif
  38
  39 #include <stdint.h>
  40 #include <sha1.h>
  41
  42
  43 #if HAVE_NBTOOL_CONFIG_H
  44 #include "nbtool_config.h"
  45 #endif
  46
  47 #if !HAVE_SHA1_H
  48
  49 #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
  50
  51 /*
  52  * blk0() and blk() perform the initial expand.
  53  * I got the idea of expanding during the round function from SSLeay
  54  */
  55 #if BYTE_ORDER == LITTLE_ENDIAN
  56 # define blk0(i) \
  57     (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) \
  58                    | (rol(block->l[i], 8) & 0x00FF00FF))
  59 #else
  60 # define blk0(i)             block->l[i]
  61 #endif
  62 #define blk(i) \
  63     (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ block->l[(i + 8) & 15] \
  64                             ^ block->l[(i + 2) & 15] ^ block->l[i & 15], 1))
  65
  66 /*
  67  * (R0+R1), R2, R3, R4 are the different operations (rounds) used in SHA1
  68  */
  69 #define R0(v, w, x, y, z, i) z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); w = rol(w, 30);
  70 #define R1(v, w, x, y, z, i) z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); w = rol(w, 30);
  71 #define R2(v, w, x, y, z, i) z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); w = rol(w, 30);
  72 #define R3(v, w, x, y, z, i) z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); w = rol(w, 30);
  73 #define R4(v, w, x, y, z, i) z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); w = rol(w, 30);
  74
  75
  76 #if !defined(_KERNEL) && !defined(_STANDALONE)
  77 #if defined(__weak_alias)
  78 __weak_alias(SHA1Transform, _SHA1Transform)
  79 __weak_alias(SHA1Init, _SHA1Init)
  80 __weak_alias(SHA1Update, _SHA1Update)
  81 __weak_alias(SHA1Final, _SHA1Final)
  82 #endif
  83 #endif
  84
  85 typedef union {
  86     uint8_t  c[64];
  87     uint32_t l[16];
  88 } CHAR64LONG16;
  89
  90 /* old sparc64 gcc could not compile this */
  91 #undef SPARC64_GCC_WORKAROUND
  92 #if defined(__sparc64__) && defined(__GNUC__) && __GNUC__ < 3
  93 #define SPARC64_GCC_WORKAROUND
  94 #endif
  95
  96 #ifdef SPARC64_GCC_WORKAROUND
  97 void do_R01(uint32_t *a, uint32_t *b, uint32_t *c, uint32_t *d, uint32_t *e, CHAR64LONG16 *);
  98 void do_R2(uint32_t *a, uint32_t *b, uint32_t *c, uint32_t *d, uint32_t *e, CHAR64LONG16 *);
  99 void do_R3(uint32_t *a, uint32_t *b, uint32_t *c, uint32_t *d, uint32_t *e, CHAR64LONG16 *);
 100 void do_R4(uint32_t *a, uint32_t *b, uint32_t *c, uint32_t *d, uint32_t *e, CHAR64LONG16 *);
 101
 102 #define nR0(v, w, x, y, z, i) R0(*v, *w, *x, *y, *z, i)
 103 #define nR1(v, w, x, y, z, i) R1(*v, *w, *x, *y, *z, i)
 104 #define nR2(v, w, x, y, z, i) R2(*v, *w, *x, *y, *z, i)
 105 #define nR3(v, w, x, y, z, i) R3(*v, *w, *x, *y, *z, i)
 106 #define nR4(v, w, x, y, z, i) R4(*v, *w, *x, *y, *z, i)
 107
 108 void do_R01(uint32_t *a, uint32_t *b, uint32_t *c, uint32_t *d, uint32_t *e, CHAR64LONG16 *block)
 109 {
 110     nR0(a, b, c, d, e, 0); nR0(e, a, b, c, d, 1); nR0(d, e, a, b, c, 2); nR0(c, d, e, a, b, 3);
 111     nR0(b, c, d, e, a, 4); nR0(a, b, c, d, e, 5); nR0(e, a, b, c, d, 6); nR0(d, e, a, b, c, 7);
 112     nR0(c, d, e, a, b, 8); nR0(b, c, d, e, a, 9); nR0(a, b, c, d, e, 10); nR0(e, a, b, c, d, 11);
 113     nR0(d, e, a, b, c, 12); nR0(c, d, e, a, b, 13); nR0(b, c, d, e, a, 14); nR0(a, b, c, d, e, 15);
 114     nR1(e, a, b, c, d, 16); nR1(d, e, a, b, c, 17); nR1(c, d, e, a, b, 18); nR1(b, c, d, e, a, 19);
 115 }
 116
 117 void do_R2(uint32_t *a, uint32_t *b, uint32_t *c, uint32_t *d, uint32_t *e, CHAR64LONG16 *block)
 118 {
 119     nR2(a, b, c, d, e, 20); nR2(e, a, b, c, d, 21); nR2(d, e, a, b, c, 22); nR2(c, d, e, a, b, 23);
 120     nR2(b, c, d, e, a, 24); nR2(a, b, c, d, e, 25); nR2(e, a, b, c, d, 26); nR2(d, e, a, b, c, 27);
 121     nR2(c, d, e, a, b, 28); nR2(b, c, d, e, a, 29); nR2(a, b, c, d, e, 30); nR2(e, a, b, c, d, 31);
 122     nR2(d, e, a, b, c, 32); nR2(c, d, e, a, b, 33); nR2(b, c, d, e, a, 34); nR2(a, b, c, d, e, 35);
 123     nR2(e, a, b, c, d, 36); nR2(d, e, a, b, c, 37); nR2(c, d, e, a, b, 38); nR2(b, c, d, e, a, 39);
 124 }
 125
 126 void do_R3(uint32_t *a, uint32_t *b, uint32_t *c, uint32_t *d, uint32_t *e, CHAR64LONG16 *block)
 127 {
 128     nR3(a, b, c, d, e, 40); nR3(e, a, b, c, d, 41); nR3(d, e, a, b, c, 42); nR3(c, d, e, a, b, 43);
 129     nR3(b, c, d, e, a, 44); nR3(a, b, c, d, e, 45); nR3(e, a, b, c, d, 46); nR3(d, e, a, b, c, 47);
 130     nR3(c, d, e, a, b, 48); nR3(b, c, d, e, a, 49); nR3(a, b, c, d, e, 50); nR3(e, a, b, c, d, 51);
 131     nR3(d, e, a, b, c, 52); nR3(c, d, e, a, b, 53); nR3(b, c, d, e, a, 54); nR3(a, b, c, d, e, 55);
 132     nR3(e, a, b, c, d, 56); nR3(d, e, a, b, c, 57); nR3(c, d, e, a, b, 58); nR3(b, c, d, e, a, 59);
 133 }
 134
 135 void do_R4(uint32_t *a, uint32_t *b, uint32_t *c, uint32_t *d, uint32_t *e, CHAR64LONG16 *block)
 136 {
 137     nR4(a, b, c, d, e, 60); nR4(e, a, b, c, d, 61); nR4(d, e, a, b, c, 62); nR4(c, d, e, a, b, 63);
 138     nR4(b, c, d, e, a, 64); nR4(a, b, c, d, e, 65); nR4(e, a, b, c, d, 66); nR4(d, e, a, b, c, 67);
 139     nR4(c, d, e, a, b, 68); nR4(b, c, d, e, a, 69); nR4(a, b, c, d, e, 70); nR4(e, a, b, c, d, 71);
 140     nR4(d, e, a, b, c, 72); nR4(c, d, e, a, b, 73); nR4(b, c, d, e, a, 74); nR4(a, b, c, d, e, 75);
 141     nR4(e, a, b, c, d, 76); nR4(d, e, a, b, c, 77); nR4(c, d, e, a, b, 78); nR4(b, c, d, e, a, 79);
 142 }
 143 #endif /* ifdef SPARC64_GCC_WORKAROUND */
 144
 145 /*
 146  * Hash a single 512-bit block. This is the core of the algorithm.
 147  */
 148 void SHA1Transform(uint32_t state[5], const uint8_t buffer[64])
 149 {
 150     uint32_t a, b, c, d, e;
 151     CHAR64LONG16 *block;
 152
 153 #ifdef SHA1HANDSOFF
 154     CHAR64LONG16 workspace;
 155 #endif
 156
 157 #ifdef SHA1HANDSOFF
 158     block = &workspace;
 159     (void)memcpy(block, buffer, 64);
 160 #else
 161     block = (CHAR64LONG16 *)(void *)buffer;
 162 #endif
 163
 164     /* Copy context->state[] to working vars */
 165     a = state[0];
 166     b = state[1];
 167     c = state[2];
 168     d = state[3];
 169     e = state[4];
 170
 171 #ifdef SPARC64_GCC_WORKAROUND
 172     do_R01(&a, &b, &c, &d, &e, block);
 173     do_R2(&a, &b, &c, &d, &e, block);
 174     do_R3(&a, &b, &c, &d, &e, block);
 175     do_R4(&a, &b, &c, &d, &e, block);
 176 #else
 177     /* 4 rounds of 20 operations each. Loop unrolled. */
 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 #endif /* ifdef SPARC64_GCC_WORKAROUND */
 199
 200     /* Add the working vars back into context.state[] */
 201     state[0] += a;
 202     state[1] += b;
 203     state[2] += c;
 204     state[3] += d;
 205     state[4] += e;
 206
 207     /* Wipe variables */
 208     a = b = c = d = e = 0;
 209 }
 210
 211
 212 /*
 213  * SHA1Init - Initialize new context
 214  */
 215 void SHA1Init(SHA1_CTX *context)
 216 {
 217     /* SHA1 initialization constants */
 218     context->state[0] = 0x67452301;
 219     context->state[1] = 0xEFCDAB89;
 220     context->state[2] = 0x98BADCFE;
 221     context->state[3] = 0x10325476;
 222     context->state[4] = 0xC3D2E1F0;
 223     context->count[0] = context->count[1] = 0;
 224 }
 225
 226
 227 /*
 228  * Run your data through this.
 229  */
 230 void SHA1Update(SHA1_CTX *context, const uint8_t *data, unsigned int len)
 231 {
 232     unsigned int i, j;
 233
 234     j = context->count[0];
 235     if ((context->count[0] += len << 3) < j) {
 236         context->count[1] += (len >> 29) + 1;
 237     }
 238     j = (j >> 3) & 63;
 239     if ((j + len) > 63) {
 240         (void)memcpy(&context->buffer[j], data, (i = 64 - j));
 241         SHA1Transform(context->state, context->buffer);
 242         for (; i + 63 < len; i += 64) {
 243             SHA1Transform(context->state, &data[i]);
 244         }
 245         j = 0;
 246     } else {
 247         i = 0;
 248     }
 249     (void)memcpy(&context->buffer[j], &data[i], len - i);
 250 }
 251
 252
 253 /*
 254  * Add padding and return the message digest.
 255  */
 256 void SHA1Final(uint8_t digest[20], SHA1_CTX *context)
 257 {
 258     unsigned int i;
 259     uint8_t finalcount[8];
 260
 261     for (i = 0; i < 8; i++) {
 262         finalcount[i] = (uint8_t)((context->count[(i >= 4 ? 0 : 1)]
 263                                    >> ((3 - (i & 3)) * 8)) & 255); /* Endian independent */
 264     }
 265     SHA1Update(context, (const uint8_t *)"\200", 1);
 266     while ((context->count[0] & 504) != 448) {
 267         SHA1Update(context, (const uint8_t *)"\0", 1);
 268     }
 269     SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */
 270
 271     if (digest) {
 272         for (i = 0; i < 20; i++) {
 273             digest[i] = (uint8_t)
 274                         ((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
 275         }
 276     }
 277 }
 278
 279 #endif /* HAVE_SHA1_H */