Branch data Line data Source code
1 : : /* Functions to compute SHA1 message digest of files or memory blocks.
2 : : according to the definition of SHA1 in FIPS 180-1 from April 1997.
3 : : Copyright (C) 2008-2011 Red Hat, Inc.
4 : : This file is part of elfutils.
5 : : Written by Ulrich Drepper <drepper@redhat.com>, 2008.
6 : :
7 : : This file is free software; you can redistribute it and/or modify
8 : : it under the terms of either
9 : :
10 : : * the GNU Lesser General Public License as published by the Free
11 : : Software Foundation; either version 3 of the License, or (at
12 : : your option) any later version
13 : :
14 : : or
15 : :
16 : : * the GNU General Public License as published by the Free
17 : : Software Foundation; either version 2 of the License, or (at
18 : : your option) any later version
19 : :
20 : : or both in parallel, as here.
21 : :
22 : : elfutils is distributed in the hope that it will be useful, but
23 : : WITHOUT ANY WARRANTY; without even the implied warranty of
24 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
25 : : General Public License for more details.
26 : :
27 : : You should have received copies of the GNU General Public License and
28 : : the GNU Lesser General Public License along with this program. If
29 : : not, see <http://www.gnu.org/licenses/>. */
30 : :
31 : : #ifdef HAVE_CONFIG_H
32 : : # include <config.h>
33 : : #endif
34 : :
35 : : #include <stdlib.h>
36 : : #include <string.h>
37 : : #include <sys/types.h>
38 : :
39 : : #include "sha1.h"
40 : : #include "system.h"
41 : :
42 : : #define SWAP(n) BE32 (n)
43 : :
44 : : /* This array contains the bytes used to pad the buffer to the next
45 : : 64-byte boundary. */
46 : : static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ... */ };
47 : :
48 : :
49 : : /* Initialize structure containing state of computation. */
50 : : void
51 : 4 : sha1_init_ctx (ctx)
52 : : struct sha1_ctx *ctx;
53 : : {
54 : 4 : ctx->A = 0x67452301;
55 : 4 : ctx->B = 0xefcdab89;
56 : 4 : ctx->C = 0x98badcfe;
57 : 4 : ctx->D = 0x10325476;
58 : 4 : ctx->E = 0xc3d2e1f0;
59 : :
60 : 4 : ctx->total[0] = ctx->total[1] = 0;
61 : 4 : ctx->buflen = 0;
62 : 4 : }
63 : :
64 : : /* Put result from CTX in first 20 bytes following RESBUF. The result
65 : : must be in little endian byte order.
66 : :
67 : : IMPORTANT: On some systems it is required that RESBUF is correctly
68 : : aligned for a 32 bits value. */
69 : : void *
70 : 4 : sha1_read_ctx (ctx, resbuf)
71 : : const struct sha1_ctx *ctx;
72 : : void *resbuf;
73 : : {
74 [ - + ]: 4 : ((sha1_uint32 *) resbuf)[0] = SWAP (ctx->A);
75 [ - + ]: 4 : ((sha1_uint32 *) resbuf)[1] = SWAP (ctx->B);
76 [ - + ]: 4 : ((sha1_uint32 *) resbuf)[2] = SWAP (ctx->C);
77 [ - + ]: 4 : ((sha1_uint32 *) resbuf)[3] = SWAP (ctx->D);
78 [ - + ]: 4 : ((sha1_uint32 *) resbuf)[4] = SWAP (ctx->E);
79 : :
80 : 4 : return resbuf;
81 : : }
82 : :
83 : : static void
84 : : be64_copy (char *dest, uint64_t x)
85 : : {
86 [ + + ]: 36 : for (size_t i = 8; i-- > 0; x >>= 8)
87 : 32 : dest[i] = (uint8_t) x;
88 : : }
89 : :
90 : : /* Process the remaining bytes in the internal buffer and the usual
91 : : prolog according to the standard and write the result to RESBUF.
92 : :
93 : : IMPORTANT: On some systems it is required that RESBUF is correctly
94 : : aligned for a 32 bits value. */
95 : : void *
96 : 4 : sha1_finish_ctx (ctx, resbuf)
97 : : struct sha1_ctx *ctx;
98 : : void *resbuf;
99 : : {
100 : : /* Take yet unprocessed bytes into account. */
101 : 4 : sha1_uint32 bytes = ctx->buflen;
102 : : size_t pad;
103 : :
104 : : /* Now count remaining bytes. */
105 : 4 : ctx->total[0] += bytes;
106 [ - + ]: 4 : if (ctx->total[0] < bytes)
107 : 0 : ++ctx->total[1];
108 : :
109 [ + + ]: 4 : pad = bytes >= 56 ? 64 + 56 - bytes : 56 - bytes;
110 : 4 : memcpy (&ctx->buffer[bytes], fillbuf, pad);
111 : :
112 : : /* Put the 64-bit file length in *bits* at the end of the buffer. */
113 : 8 : const uint64_t bit_length = ((ctx->total[0] << 3)
114 : 8 : + ((uint64_t) ((ctx->total[1] << 3) |
115 : 8 : (ctx->total[0] >> 29)) << 32));
116 : 4 : be64_copy (&ctx->buffer[bytes + pad], bit_length);
117 : :
118 : : /* Process last bytes. */
119 : 4 : sha1_process_block (ctx->buffer, bytes + pad + 8, ctx);
120 : :
121 : 4 : return sha1_read_ctx (ctx, resbuf);
122 : : }
123 : :
124 : :
125 : : void
126 : 1003 : sha1_process_bytes (buffer, len, ctx)
127 : : const void *buffer;
128 : : size_t len;
129 : : struct sha1_ctx *ctx;
130 : : {
131 : : /* When we already have some bits in our internal buffer concatenate
132 : : both inputs first. */
133 [ + + ]: 1003 : if (ctx->buflen != 0)
134 : : {
135 : 875 : size_t left_over = ctx->buflen;
136 : 875 : size_t add = 128 - left_over > len ? len : 128 - left_over;
137 : :
138 : 875 : memcpy (&ctx->buffer[left_over], buffer, add);
139 : 875 : ctx->buflen += add;
140 : :
141 [ + - ]: 875 : if (ctx->buflen > 64)
142 : : {
143 : 875 : sha1_process_block (ctx->buffer, ctx->buflen & ~63, ctx);
144 : :
145 : 875 : ctx->buflen &= 63;
146 : : /* The regions in the following copy operation cannot overlap. */
147 : 875 : memcpy (ctx->buffer, &ctx->buffer[(left_over + add) & ~63],
148 : : ctx->buflen);
149 : : }
150 : :
151 : 875 : buffer = (const char *) buffer + add;
152 : 875 : len -= add;
153 : : }
154 : :
155 : : /* Process available complete blocks. */
156 [ + + ]: 1003 : if (len >= 64)
157 : : {
158 : : #if !_STRING_ARCH_unaligned
159 : : /* To check alignment gcc has an appropriate operator. Other
160 : : compilers don't. */
161 : : # if __GNUC__ >= 2
162 : : # define UNALIGNED_P(p) (((sha1_uintptr) p) % __alignof__ (sha1_uint32) != 0)
163 : : # else
164 : : # define UNALIGNED_P(p) (((sha1_uintptr) p) % sizeof (sha1_uint32) != 0)
165 : : # endif
166 : : if (UNALIGNED_P (buffer))
167 : : while (len > 64)
168 : : {
169 : : sha1_process_block (memcpy (ctx->buffer, buffer, 64), 64, ctx);
170 : : buffer = (const char *) buffer + 64;
171 : : len -= 64;
172 : : }
173 : : else
174 : : #endif
175 : : {
176 : 1000 : sha1_process_block (buffer, len & ~63, ctx);
177 : 1000 : buffer = (const char *) buffer + (len & ~63);
178 : 1000 : len &= 63;
179 : : }
180 : : }
181 : :
182 : : /* Move remaining bytes in internal buffer. */
183 [ + + ]: 1003 : if (len > 0)
184 : : {
185 : 878 : size_t left_over = ctx->buflen;
186 : :
187 : 878 : memcpy (&ctx->buffer[left_over], buffer, len);
188 : 878 : left_over += len;
189 [ - + ]: 878 : if (left_over >= 64)
190 : : {
191 : 0 : sha1_process_block (ctx->buffer, 64, ctx);
192 : 0 : left_over -= 64;
193 : 0 : memcpy (ctx->buffer, &ctx->buffer[64], left_over);
194 : : }
195 : 878 : ctx->buflen = left_over;
196 : : }
197 : 1003 : }
198 : :
199 : :
200 : : /* These are the four functions used in the four steps of the SHA1 algorithm
201 : : and defined in the FIPS 180-1. */
202 : : /* #define FF(b, c, d) ((b & c) | (~b & d)) */
203 : : #define FF(b, c, d) (d ^ (b & (c ^ d)))
204 : : #define FG(b, c, d) (b ^ c ^ d)
205 : : /* define FH(b, c, d) ((b & c) | (b & d) | (c & d)) */
206 : : #define FH(b, c, d) (((b | c) & d) | (b & c))
207 : :
208 : : /* It is unfortunate that C does not provide an operator for cyclic
209 : : rotation. Hope the C compiler is smart enough. */
210 : : #define CYCLIC(w, s) (((w) << s) | ((w) >> (32 - s)))
211 : :
212 : : /* Magic constants. */
213 : : #define K0 0x5a827999
214 : : #define K1 0x6ed9eba1
215 : : #define K2 0x8f1bbcdc
216 : : #define K3 0xca62c1d6
217 : :
218 : :
219 : : /* Process LEN bytes of BUFFER, accumulating context into CTX.
220 : : It is assumed that LEN % 64 == 0. */
221 : :
222 : : void
223 : 1879 : sha1_process_block (buffer, len, ctx)
224 : : const void *buffer;
225 : : size_t len;
226 : : struct sha1_ctx *ctx;
227 : : {
228 : : sha1_uint32 computed_words[16];
229 : : #define W(i) computed_words[(i) % 16]
230 : 1879 : const sha1_uint32 *words = buffer;
231 : 1879 : size_t nwords = len / sizeof (sha1_uint32);
232 : 1879 : const sha1_uint32 *endp = words + nwords;
233 : 1879 : sha1_uint32 A = ctx->A;
234 : 1879 : sha1_uint32 B = ctx->B;
235 : 1879 : sha1_uint32 C = ctx->C;
236 : 1879 : sha1_uint32 D = ctx->D;
237 : 1879 : sha1_uint32 E = ctx->E;
238 : :
239 : : /* First increment the byte count. FIPS 180-1 specifies the possible
240 : : length of the file up to 2^64 bits. Here we only compute the
241 : : number of bytes. Do a double word increment. */
242 : 1879 : ctx->total[0] += len;
243 [ - + ]: 1879 : if (ctx->total[0] < len)
244 : 1879 : ++ctx->total[1];
245 : :
246 : : /* Process all bytes in the buffer with 64 bytes in each round of
247 : : the loop. */
248 [ + + ]: 17509 : while (words < endp)
249 : : {
250 : 15630 : sha1_uint32 A_save = A;
251 : 15630 : sha1_uint32 B_save = B;
252 : 15630 : sha1_uint32 C_save = C;
253 : 15630 : sha1_uint32 D_save = D;
254 : 15630 : sha1_uint32 E_save = E;
255 : :
256 : : /* First round: using the given function, the context and a constant
257 : : the next context is computed. Because the algorithms processing
258 : : unit is a 32-bit word and it is determined to work on words in
259 : : little endian byte order we perhaps have to change the byte order
260 : : before the computation. */
261 : :
262 : : #define OP(i, a, b, c, d, e) \
263 : : do \
264 : : { \
265 : : W (i) = SWAP (*words); \
266 : : e = CYCLIC (a, 5) + FF (b, c, d) + e + W (i) + K0; \
267 : : ++words; \
268 : : b = CYCLIC (b, 30); \
269 : : } \
270 : : while (0)
271 : :
272 : : /* Steps 0 to 15. */
273 [ - + ]: 15630 : OP (0, A, B, C, D, E);
274 [ - + ]: 15630 : OP (1, E, A, B, C, D);
275 [ - + ]: 15630 : OP (2, D, E, A, B, C);
276 [ - + ]: 15630 : OP (3, C, D, E, A, B);
277 [ - + ]: 15630 : OP (4, B, C, D, E, A);
278 [ - + ]: 15630 : OP (5, A, B, C, D, E);
279 [ - + ]: 15630 : OP (6, E, A, B, C, D);
280 [ - + ]: 15630 : OP (7, D, E, A, B, C);
281 [ - + ]: 15630 : OP (8, C, D, E, A, B);
282 [ - + ]: 15630 : OP (9, B, C, D, E, A);
283 [ - + ]: 15630 : OP (10, A, B, C, D, E);
284 [ - + ]: 15630 : OP (11, E, A, B, C, D);
285 [ - + ]: 15630 : OP (12, D, E, A, B, C);
286 [ - + ]: 15630 : OP (13, C, D, E, A, B);
287 [ - + ]: 15630 : OP (14, B, C, D, E, A);
288 [ - + ]: 15630 : OP (15, A, B, C, D, E);
289 : :
290 : : /* For the remaining 64 steps we have a more complicated
291 : : computation of the input data-derived values. Redefine the
292 : : macro to take an additional second argument specifying the
293 : : function to use and a new last parameter for the magic
294 : : constant. */
295 : : #undef OP
296 : : #define OP(i, f, a, b, c, d, e, K) \
297 : : do \
298 : : { \
299 : : W (i) = CYCLIC (W (i - 3) ^ W (i - 8) ^ W (i - 14) ^ W (i - 16), 1);\
300 : : e = CYCLIC (a, 5) + f (b, c, d) + e + W (i) + K; \
301 : : b = CYCLIC (b, 30); \
302 : : } \
303 : : while (0)
304 : :
305 : : /* Steps 16 to 19. */
306 : 15630 : OP (16, FF, E, A, B, C, D, K0);
307 : 15630 : OP (17, FF, D, E, A, B, C, K0);
308 : 15630 : OP (18, FF, C, D, E, A, B, K0);
309 : 15630 : OP (19, FF, B, C, D, E, A, K0);
310 : :
311 : : /* Steps 20 to 39. */
312 : 15630 : OP (20, FG, A, B, C, D, E, K1);
313 : 15630 : OP (21, FG, E, A, B, C, D, K1);
314 : 15630 : OP (22, FG, D, E, A, B, C, K1);
315 : 15630 : OP (23, FG, C, D, E, A, B, K1);
316 : 15630 : OP (24, FG, B, C, D, E, A, K1);
317 : 15630 : OP (25, FG, A, B, C, D, E, K1);
318 : 15630 : OP (26, FG, E, A, B, C, D, K1);
319 : 15630 : OP (27, FG, D, E, A, B, C, K1);
320 : 15630 : OP (28, FG, C, D, E, A, B, K1);
321 : 15630 : OP (29, FG, B, C, D, E, A, K1);
322 : 15630 : OP (30, FG, A, B, C, D, E, K1);
323 : 15630 : OP (31, FG, E, A, B, C, D, K1);
324 : 15630 : OP (32, FG, D, E, A, B, C, K1);
325 : 15630 : OP (33, FG, C, D, E, A, B, K1);
326 : 15630 : OP (34, FG, B, C, D, E, A, K1);
327 : 15630 : OP (35, FG, A, B, C, D, E, K1);
328 : 15630 : OP (36, FG, E, A, B, C, D, K1);
329 : 15630 : OP (37, FG, D, E, A, B, C, K1);
330 : 15630 : OP (38, FG, C, D, E, A, B, K1);
331 : 15630 : OP (39, FG, B, C, D, E, A, K1);
332 : :
333 : : /* Steps 40 to 59. */
334 : 15630 : OP (40, FH, A, B, C, D, E, K2);
335 : 15630 : OP (41, FH, E, A, B, C, D, K2);
336 : 15630 : OP (42, FH, D, E, A, B, C, K2);
337 : 15630 : OP (43, FH, C, D, E, A, B, K2);
338 : 15630 : OP (44, FH, B, C, D, E, A, K2);
339 : 15630 : OP (45, FH, A, B, C, D, E, K2);
340 : 15630 : OP (46, FH, E, A, B, C, D, K2);
341 : 15630 : OP (47, FH, D, E, A, B, C, K2);
342 : 15630 : OP (48, FH, C, D, E, A, B, K2);
343 : 15630 : OP (49, FH, B, C, D, E, A, K2);
344 : 15630 : OP (50, FH, A, B, C, D, E, K2);
345 : 15630 : OP (51, FH, E, A, B, C, D, K2);
346 : 15630 : OP (52, FH, D, E, A, B, C, K2);
347 : 15630 : OP (53, FH, C, D, E, A, B, K2);
348 : 15630 : OP (54, FH, B, C, D, E, A, K2);
349 : 15630 : OP (55, FH, A, B, C, D, E, K2);
350 : 15630 : OP (56, FH, E, A, B, C, D, K2);
351 : 15630 : OP (57, FH, D, E, A, B, C, K2);
352 : 15630 : OP (58, FH, C, D, E, A, B, K2);
353 : 15630 : OP (59, FH, B, C, D, E, A, K2);
354 : :
355 : : /* Steps 60 to 79. */
356 : 15630 : OP (60, FG, A, B, C, D, E, K3);
357 : 15630 : OP (61, FG, E, A, B, C, D, K3);
358 : 15630 : OP (62, FG, D, E, A, B, C, K3);
359 : 15630 : OP (63, FG, C, D, E, A, B, K3);
360 : 15630 : OP (64, FG, B, C, D, E, A, K3);
361 : 15630 : OP (65, FG, A, B, C, D, E, K3);
362 : 15630 : OP (66, FG, E, A, B, C, D, K3);
363 : 15630 : OP (67, FG, D, E, A, B, C, K3);
364 : 15630 : OP (68, FG, C, D, E, A, B, K3);
365 : 15630 : OP (69, FG, B, C, D, E, A, K3);
366 : 15630 : OP (70, FG, A, B, C, D, E, K3);
367 : 15630 : OP (71, FG, E, A, B, C, D, K3);
368 : 15630 : OP (72, FG, D, E, A, B, C, K3);
369 : 15630 : OP (73, FG, C, D, E, A, B, K3);
370 : 15630 : OP (74, FG, B, C, D, E, A, K3);
371 : 15630 : OP (75, FG, A, B, C, D, E, K3);
372 : 15630 : OP (76, FG, E, A, B, C, D, K3);
373 : 15630 : OP (77, FG, D, E, A, B, C, K3);
374 : 15630 : OP (78, FG, C, D, E, A, B, K3);
375 : 15630 : OP (79, FG, B, C, D, E, A, K3);
376 : :
377 : : /* Add the starting values of the context. */
378 : 15630 : A += A_save;
379 : 15630 : B += B_save;
380 : 15630 : C += C_save;
381 : 15630 : D += D_save;
382 : 15630 : E += E_save;
383 : : }
384 : :
385 : : /* Put checksum in context given as argument. */
386 : 1879 : ctx->A = A;
387 : 1879 : ctx->B = B;
388 : 1879 : ctx->C = C;
389 : 1879 : ctx->D = D;
390 : 1879 : ctx->E = E;
391 : 1879 : }
|
