00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015 #include "includes.h"
00016
00017 #include "common.h"
00018 #include "sha1.h"
00019 #include "sha1_i.h"
00020 #include "md5.h"
00021 #include "crypto.h"
00022
00023 typedef struct SHA1Context SHA1_CTX;
00024
00025 void SHA1Transform(u32 state[5], const unsigned char buffer[64]);
00026
00027
00036 int sha1_vector(size_t num_elem, const u8 *addr[], const size_t *len, u8 *mac)
00037 {
00038 SHA1_CTX ctx;
00039 size_t i;
00040
00041 SHA1Init(&ctx);
00042 for (i = 0; i < num_elem; i++)
00043 SHA1Update(&ctx, addr[i], len[i]);
00044 SHA1Final(mac, &ctx);
00045 return 0;
00046 }
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129 #define SHA1HANDSOFF
00130
00131 #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
00132
00133
00134
00135 #ifndef WORDS_BIGENDIAN
00136 #define blk0(i) (block->l[i] = (rol(block->l[i], 24) & 0xFF00FF00) | \
00137 (rol(block->l[i], 8) & 0x00FF00FF))
00138 #else
00139 #define blk0(i) block->l[i]
00140 #endif
00141 #define blk(i) (block->l[i & 15] = rol(block->l[(i + 13) & 15] ^ \
00142 block->l[(i + 8) & 15] ^ block->l[(i + 2) & 15] ^ block->l[i & 15], 1))
00143
00144
00145 #define R0(v,w,x,y,z,i) \
00146 z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + rol(v, 5); \
00147 w = rol(w, 30);
00148 #define R1(v,w,x,y,z,i) \
00149 z += ((w & (x ^ y)) ^ y) + blk(i) + 0x5A827999 + rol(v, 5); \
00150 w = rol(w, 30);
00151 #define R2(v,w,x,y,z,i) \
00152 z += (w ^ x ^ y) + blk(i) + 0x6ED9EBA1 + rol(v, 5); w = rol(w, 30);
00153 #define R3(v,w,x,y,z,i) \
00154 z += (((w | x) & y) | (w & x)) + blk(i) + 0x8F1BBCDC + rol(v, 5); \
00155 w = rol(w, 30);
00156 #define R4(v,w,x,y,z,i) \
00157 z += (w ^ x ^ y) + blk(i) + 0xCA62C1D6 + rol(v, 5); \
00158 w=rol(w, 30);
00159
00160
00161 #ifdef VERBOSE
00162 void SHAPrintContext(SHA1_CTX *context, char *msg)
00163 {
00164 printf("%s (%d,%d) %x %x %x %x %x\n",
00165 msg,
00166 context->count[0], context->count[1],
00167 context->state[0],
00168 context->state[1],
00169 context->state[2],
00170 context->state[3],
00171 context->state[4]);
00172 }
00173 #endif
00174
00175
00176
00177 void SHA1Transform(u32 state[5], const unsigned char buffer[64])
00178 {
00179 u32 a, b, c, d, e;
00180 typedef union {
00181 unsigned char c[64];
00182 u32 l[16];
00183 } CHAR64LONG16;
00184 CHAR64LONG16* block;
00185 #ifdef SHA1HANDSOFF
00186 CHAR64LONG16 workspace;
00187 block = &workspace;
00188 os_memcpy(block, buffer, 64);
00189 #else
00190 block = (CHAR64LONG16 *) buffer;
00191 #endif
00192
00193 a = state[0];
00194 b = state[1];
00195 c = state[2];
00196 d = state[3];
00197 e = state[4];
00198
00199 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);
00200 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);
00201 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);
00202 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);
00203 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);
00204 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);
00205 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);
00206 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);
00207 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);
00208 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);
00209 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);
00210 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);
00211 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);
00212 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);
00213 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);
00214 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);
00215 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);
00216 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);
00217 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);
00218 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);
00219
00220 state[0] += a;
00221 state[1] += b;
00222 state[2] += c;
00223 state[3] += d;
00224 state[4] += e;
00225
00226 a = b = c = d = e = 0;
00227 #ifdef SHA1HANDSOFF
00228 os_memset(block, 0, 64);
00229 #endif
00230 }
00231
00232
00233
00234
00235 void SHA1Init(SHA1_CTX* context)
00236 {
00237
00238 context->state[0] = 0x67452301;
00239 context->state[1] = 0xEFCDAB89;
00240 context->state[2] = 0x98BADCFE;
00241 context->state[3] = 0x10325476;
00242 context->state[4] = 0xC3D2E1F0;
00243 context->count[0] = context->count[1] = 0;
00244 }
00245
00246
00247
00248
00249 void SHA1Update(SHA1_CTX* context, const void *_data, u32 len)
00250 {
00251 u32 i, j;
00252 const unsigned char *data = _data;
00253
00254 #ifdef VERBOSE
00255 SHAPrintContext(context, "before");
00256 #endif
00257 j = (context->count[0] >> 3) & 63;
00258 if ((context->count[0] += len << 3) < (len << 3))
00259 context->count[1]++;
00260 context->count[1] += (len >> 29);
00261 if ((j + len) > 63) {
00262 os_memcpy(&context->buffer[j], data, (i = 64-j));
00263 SHA1Transform(context->state, context->buffer);
00264 for ( ; i + 63 < len; i += 64) {
00265 SHA1Transform(context->state, &data[i]);
00266 }
00267 j = 0;
00268 }
00269 else i = 0;
00270 os_memcpy(&context->buffer[j], &data[i], len - i);
00271 #ifdef VERBOSE
00272 SHAPrintContext(context, "after ");
00273 #endif
00274 }
00275
00276
00277
00278
00279 void SHA1Final(unsigned char digest[20], SHA1_CTX* context)
00280 {
00281 u32 i;
00282 unsigned char finalcount[8];
00283
00284 for (i = 0; i < 8; i++) {
00285 finalcount[i] = (unsigned char)
00286 ((context->count[(i >= 4 ? 0 : 1)] >>
00287 ((3-(i & 3)) * 8) ) & 255);
00288 }
00289 SHA1Update(context, (unsigned char *) "\200", 1);
00290 while ((context->count[0] & 504) != 448) {
00291 SHA1Update(context, (unsigned char *) "\0", 1);
00292 }
00293 SHA1Update(context, finalcount, 8);
00294
00295 for (i = 0; i < 20; i++) {
00296 digest[i] = (unsigned char)
00297 ((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) &
00298 255);
00299 }
00300
00301 i = 0;
00302 os_memset(context->buffer, 0, 64);
00303 os_memset(context->state, 0, 20);
00304 os_memset(context->count, 0, 8);
00305 os_memset(finalcount, 0, 8);
00306 }
00307
00308