- added ipsec.conf template and man page back
[strongswan.git] / src / libstrongswan / crypto / hashers / sha1_hasher.c
1 /**
2 * @file sha1_hasher.c
3 *
4 * @brief Implementation of hasher_sha_t.
5 *
6 */
7
8 /*
9 * Copyright (C) 2005 Jan Hutter, Martin Willi
10 * Hochschule fuer Technik Rapperswil
11 *
12 * Ported from Steve Reid's <steve@edmweb.com> implementation
13 * "SHA1 in C" found in strongSwan.
14 *
15 * This program is free software; you can redistribute it and/or modify it
16 * under the terms of the GNU General Public License as published by the
17 * Free Software Foundation; either version 2 of the License, or (at your
18 * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
19 *
20 * This program is distributed in the hope that it will be useful, but
21 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
22 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
23 * for more details.
24 */
25
26 #include <string.h>
27
28 #include "sha1_hasher.h"
29
30 #include <definitions.h>
31
32 #define BLOCK_SIZE_SHA1 20
33
34 /*
35 * ugly macro stuff
36 */
37 #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
38
39 #if BYTE_ORDER == LITTLE_ENDIAN
40 #define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) |(rol(block->l[i],8)&0x00FF00FF))
41 #elif BYTE_ORDER == BIG_ENDIAN
42 #define blk0(i) block->l[i]
43 #else
44 #error "Endianness not defined!"
45 #endif
46 #define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] ^block->l[(i+2)&15]^block->l[i&15],1))
47
48 /* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
49 #define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
50 #define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
51 #define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
52 #define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
53 #define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
54
55
56 typedef struct private_sha1_hasher_t private_sha1_hasher_t;
57
58 /**
59 * Private data structure with hasing context.
60 */
61 struct private_sha1_hasher_t {
62 /**
63 * Public interface for this hasher.
64 */
65 sha1_hasher_t public;
66
67 /*
68 * State of the hasher.
69 */
70 u_int32_t state[5];
71 u_int32_t count[2];
72 u_int8_t buffer[64];
73 };
74
75 /*
76 * Hash a single 512-bit block. This is the core of the algorithm. *
77 */
78 static void SHA1Transform(u_int32_t state[5], const unsigned char buffer[64])
79 {
80 u_int32_t a, b, c, d, e;
81 typedef union {
82 u_int8_t c[64];
83 u_int32_t l[16];
84 } CHAR64LONG16;
85 CHAR64LONG16 block[1]; /* use array to appear as a pointer */
86 memcpy(block, buffer, 64);
87
88 /* Copy context->state[] to working vars */
89 a = state[0];
90 b = state[1];
91 c = state[2];
92 d = state[3];
93 e = state[4];
94 /* 4 rounds of 20 operations each. Loop unrolled. */
95 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);
96 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);
97 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);
98 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);
99 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);
100 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);
101 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);
102 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);
103 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);
104 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);
105 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);
106 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);
107 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);
108 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);
109 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);
110 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);
111 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);
112 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);
113 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);
114 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);
115 /* Add the working vars back into context.state[] */
116 state[0] += a;
117 state[1] += b;
118 state[2] += c;
119 state[3] += d;
120 state[4] += e;
121 /* Wipe variables */
122 a = b = c = d = e = 0;
123 memset(block, '\0', sizeof(block));
124 }
125
126 /*
127 * Run your data through this.
128 */
129 static void SHA1Update(private_sha1_hasher_t* this, u_int8_t *data, u_int32_t len)
130 {
131 u_int32_t i;
132 u_int32_t j;
133
134 j = this->count[0];
135 if ((this->count[0] += len << 3) < j)
136 {
137 this->count[1]++;
138 }
139 this->count[1] += (len>>29);
140 j = (j >> 3) & 63;
141 if ((j + len) > 63)
142 {
143 memcpy(&this->buffer[j], data, (i = 64-j));
144 SHA1Transform(this->state, this->buffer);
145 for ( ; i + 63 < len; i += 64)
146 {
147 SHA1Transform(this->state, &data[i]);
148 }
149 j = 0;
150 }
151 else
152 {
153 i = 0;
154 }
155 memcpy(&this->buffer[j], &data[i], len - i);
156 }
157
158
159 /*
160 * Add padding and return the message digest.
161 */
162 static void SHA1Final(private_sha1_hasher_t *this, u_int8_t *digest)
163 {
164 u_int32_t i;
165 u_int8_t finalcount[8];
166 u_int8_t c;
167
168 for (i = 0; i < 8; i++)
169 {
170 finalcount[i] = (u_int8_t)((this->count[(i >= 4 ? 0 : 1)]
171 >> ((3-(i & 3)) * 8) ) & 255); /* Endian independent */
172 }
173 c = 0200;
174 SHA1Update(this, &c, 1);
175 while ((this->count[0] & 504) != 448)
176 {
177 c = 0000;
178 SHA1Update(this, &c, 1);
179 }
180 SHA1Update(this, finalcount, 8); /* Should cause a SHA1Transform() */
181 for (i = 0; i < 20; i++)
182 {
183 digest[i] = (u_int8_t)((this->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
184 }
185 }
186
187
188 /**
189 * Implementation of hasher_t.get_hash.
190 */
191 static void get_hash(private_sha1_hasher_t *this, chunk_t chunk, u_int8_t *buffer)
192 {
193 SHA1Update(this, chunk.ptr, chunk.len);
194 if (buffer != NULL)
195 {
196 SHA1Final(this, buffer);
197 this->public.hasher_interface.reset(&(this->public.hasher_interface));
198 }
199 }
200
201
202 /**
203 * Implementation of hasher_t.allocate_hash.
204 */
205 static void allocate_hash(private_sha1_hasher_t *this, chunk_t chunk, chunk_t *hash)
206 {
207 chunk_t allocated_hash;
208
209 SHA1Update(this, chunk.ptr, chunk.len);
210 if (hash != NULL)
211 {
212 allocated_hash.ptr = malloc(BLOCK_SIZE_SHA1);
213 allocated_hash.len = BLOCK_SIZE_SHA1;
214
215 SHA1Final(this, allocated_hash.ptr);
216 this->public.hasher_interface.reset(&(this->public.hasher_interface));
217
218 *hash = allocated_hash;
219 }
220 }
221
222 /**
223 * Implementation of hasher_t.get_hash_size.
224 */
225 static size_t get_hash_size(private_sha1_hasher_t *this)
226 {
227 return BLOCK_SIZE_SHA1;
228 }
229
230 /**
231 * Implementation of hasher_t.reset.
232 */
233 static void reset(private_sha1_hasher_t *this)
234 {
235 this->state[0] = 0x67452301;
236 this->state[1] = 0xEFCDAB89;
237 this->state[2] = 0x98BADCFE;
238 this->state[3] = 0x10325476;
239 this->state[4] = 0xC3D2E1F0;
240 this->count[0] = 0;
241 this->count[1] = 0;
242 }
243 /**
244 * Implementation of hasher_t.destroy.
245 */
246 static void destroy(private_sha1_hasher_t *this)
247 {
248 free(this);
249 }
250
251
252 /*
253 * Described in header.
254 */
255 sha1_hasher_t *sha1_hasher_create(void)
256 {
257 private_sha1_hasher_t *this = malloc_thing(private_sha1_hasher_t);
258
259 this->public.hasher_interface.get_hash = (void (*) (hasher_t*, chunk_t, u_int8_t*))get_hash;
260 this->public.hasher_interface.allocate_hash = (void (*) (hasher_t*, chunk_t, chunk_t*))allocate_hash;
261 this->public.hasher_interface.get_hash_size = (size_t (*) (hasher_t*))get_hash_size;
262 this->public.hasher_interface.reset = (void (*) (hasher_t*))reset;
263 this->public.hasher_interface.destroy = (void (*) (hasher_t*))destroy;
264
265 /* initialize */
266 this->public.hasher_interface.reset(&(this->public.hasher_interface));
267
268 return &(this->public);
269 }