Mercurial > hgrepos > Python2 > PyMuPDF

comparison mupdf-source/thirdparty/jbig2dec/sha1.c @ 2:b50eed0cc0ef upstream

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
ADD: MuPDF v1.26.7: the MuPDF source as downloaded by a default build of PyMuPDF 1.26.4. The directory name has changed: no version number in the expanded directory now.
author Franz Glasner <fzglas.hg@dom66.de>
date Mon, 15 Sep 2025 11:43:07 +0200
parents
children
comparison
equal deleted inserted replaced
1:1d09e1dec1d9 2:b50eed0cc0ef
1 /*
2 SHA-1 in C
3 By Steve Reid <sreid@sea-to-sky.net>
4 100% Public Domain
5
6 -----------------
7 Modified 7/98
8 By James H. Brown <jbrown@burgoyne.com>
9 Still 100% Public Domain
10
11 Corrected a problem which generated improper hash values on 16 bit machines
12 Routine SHA1Update changed from
13 void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned int
14 len)
15 to
16 void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned
17 long len)
18
19 The 'len' parameter was declared an int which works fine on 32 bit machines.
20 However, on 16 bit machines an int is too small for the shifts being done
21 against
22 it. This caused the hash function to generate incorrect values if len was
23 greater than 8191 (8K - 1) due to the 'len << 3' on line 3 of SHA1Update().
24
25 Since the file IO in main() reads 16K at a time, any file 8K or larger would
26 be guaranteed to generate the wrong hash (e.g. Test Vector #3, a million
27 "a"s).
28
29 I also changed the declaration of variables i & j in SHA1Update to
30 unsigned long from unsigned int for the same reason.
31
32 These changes should make no difference to any 32 bit implementations since
33 an
34 int and a long are the same size in those environments.
35
36 --
37 I also corrected a few compiler warnings generated by Borland C.
38 1. Added #include <process.h> for exit() prototype
39 2. Removed unused variable 'j' in SHA1Final
40 3. Changed exit(0) to return(0) at end of main.
41
42 ALL changes I made can be located by searching for comments containing 'JHB'
43 -----------------
44 Modified 8/98
45 By Steve Reid <sreid@sea-to-sky.net>
46 Still 100% public domain
47
48 1- Removed #include <process.h> and used return() instead of exit()
49 2- Fixed overwriting of finalcount in SHA1Final() (discovered by Chris Hall)
50 3- Changed email address from steve@edmweb.com to sreid@sea-to-sky.net
51
52 -----------------
53 Modified 4/01
54 By Saul Kravitz <Saul.Kravitz@celera.com>
55 Still 100% PD
56 Modified to run on Compaq Alpha hardware.
57
58 -----------------
59 Modified 07/2002
60 By Ralph Giles <giles@ghostscript.com>
61 Still 100% public domain
62 modified for use with stdint types, autoconf
63 code cleanup, removed attribution comments
64 switched SHA1Final() argument order for consistency
65 use SHA1_ prefix for public api
66 move public api to sha1.h
67 */
68
69 /*
70 Test Vectors (from FIPS PUB 180-1)
71 "abc"
72 A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
73 "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
74 84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
75 A million repetitions of "a"
76 34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
77 */
78
79 /* #define SHA1HANDSOFF */
80
81 #ifdef HAVE_CONFIG_H
82 #include "config.h"
83 #endif
84
85 #include <stdio.h>
86 #include <string.h>
87
88 #include "os_types.h"
89 #include "sha1.h"
90
91 void SHA1_Transform(uint32_t state[5], const uint8_t buffer[64]);
92
93 #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
94
95 /* blk0() and blk() perform the initial expand. */
96 /* I got the idea of expanding during the round function from SSLeay */
97 /* FIXME: can we do this in an endian-proof way? */
98 #ifdef WORDS_BIGENDIAN
99 #define blk0(i) block->l[i]
100 #else
101 #define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
102 |(rol(block->l[i],8)&0x00FF00FF))
103 #endif
104 #define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
105 ^block->l[(i+2)&15]^block->l[i&15],1))
106
107 /* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
108 #define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
109 #define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
110 #define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
111 #define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
112 #define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
113
114 #ifdef VERBOSE /* SAK */
115 void
116 SHAPrintContext(SHA1_CTX *context, char *msg)
117 {
118 printf("%s (%d,%d) %x %x %x %x %x\n",
119 msg, context->count[0], context->count[1], context->state[0], context->state[1], context->state[2], context->state[3], context->state[4]);
120 }
121 #endif /* VERBOSE */
122
123 /* Hash a single 512-bit block. This is the core of the algorithm. */
124 void
125 SHA1_Transform(uint32_t state[5], const uint8_t buffer[64])
126 {
127 uint32_t a, b, c, d, e;
128 typedef union {
129 uint8_t c[64];
130 uint32_t l[16];
131 } CHAR64LONG16;
132 CHAR64LONG16 *block;
133
134 #ifdef SHA1HANDSOFF
135 static uint8_t workspace[64];
136
137 block = (CHAR64LONG16 *) workspace;
138 memcpy(block, buffer, 64);
139 #else
140 block = (CHAR64LONG16 *) buffer;
141 #endif
142
143 /* Copy context->state[] to working vars */
144 a = state[0];
145 b = state[1];
146 c = state[2];
147 d = state[3];
148 e = state[4];
149
150 /* 4 rounds of 20 operations each. Loop unrolled. */
151 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);
152 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);
153 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);
154 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);
155 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);
156 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);
157 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);
158 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);
159 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);
160 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);
161 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);
162 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);
163 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);
164 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);
165 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);
166 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);
167 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);
168 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);
169 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);
170 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);
171
172 /* Add the working vars back into context.state[] */
173 state[0] += a;
174 state[1] += b;
175 state[2] += c;
176 state[3] += d;
177 state[4] += e;
178
179 /* Wipe variables */
180 a = b = c = d = e = 0;
181 }
182
183 /* SHA1Init - Initialize new context */
184 void
185 SHA1_Init(SHA1_CTX *context)
186 {
187 /* SHA1 initialization constants */
188 context->state[0] = 0x67452301;
189 context->state[1] = 0xEFCDAB89;
190 context->state[2] = 0x98BADCFE;
191 context->state[3] = 0x10325476;
192 context->state[4] = 0xC3D2E1F0;
193 context->count[0] = context->count[1] = 0;
194 }
195
196 /* Run your data through this. */
197 void
198 SHA1_Update(SHA1_CTX *context, const uint8_t *data, const size_t len)
199 {
200 size_t i, j;
201
202 #ifdef VERBOSE
203 SHAPrintContext(context, "before");
204 #endif
205
206 j = (context->count[0] >> 3) & 63;
207 if ((context->count[0] += len << 3) < (len << 3))
208 context->count[1]++;
209 context->count[1] += (len >> 29);
210 if ((j + len) > 63) {
211 memcpy(&context->buffer[j], data, (i = 64 - j));
212 SHA1_Transform(context->state, context->buffer);
213 for (; i + 63 < len; i += 64) {
214 SHA1_Transform(context->state, data + i);
215 }
216 j = 0;
217 } else
218 i = 0;
219 memcpy(&context->buffer[j], &data[i], len - i);
220
221 #ifdef VERBOSE
222 SHAPrintContext(context, "after ");
223 #endif
224 }
225
226 /* Add padding and return the message digest. */
227 void
228 SHA1_Final(SHA1_CTX *context, uint8_t digest[SHA1_DIGEST_SIZE])
229 {
230 uint32_t i;
231 uint8_t finalcount[8];
232
233 for (i = 0; i < 8; i++) {
234 finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)]
235 >> ((3 - (i & 3)) * 8)) & 255); /* Endian independent */
236 }
237 SHA1_Update(context, (uint8_t *) "\200", 1);
238 while ((context->count[0] & 504) != 448) {
239 SHA1_Update(context, (uint8_t *) "\0", 1);
240 }
241 SHA1_Update(context, finalcount, 8); /* Should cause a SHA1_Transform() */
242 for (i = 0; i < SHA1_DIGEST_SIZE; i++) {
243 digest[i] = (uint8_t)
244 ((context->state[i >> 2] >> ((3 - (i & 3)) * 8)) & 255);
245 }
246
247 /* Wipe variables */
248 i = 0;
249 memset(context->buffer, 0, 64);
250 memset(context->state, 0, 20);
251 memset(context->count, 0, 8);
252 memset(finalcount, 0, 8); /* SWR */
253
254 #ifdef SHA1HANDSOFF /* make SHA1Transform overwrite its own static vars */
255 SHA1_Transform(context->state, context->buffer);
256 #endif
257 }
258
259 /*************************************************************/
260
261 #if 0
262 int
263 main(int argc, char **argv)
264 {
265 int i, j;
266 SHA1_CTX context;
267 unsigned char digest[SHA1_DIGEST_SIZE], buffer[16384];
268 FILE *file;
269
270 if (argc > 2) {
271 puts("Public domain SHA-1 implementation - by Steve Reid <sreid@sea-to-sky.net>");
272 puts("Modified for 16 bit environments 7/98 - by James H. Brown <jbrown@burgoyne.com>"); /* JHB */
273 puts("Produces the SHA-1 hash of a file, or stdin if no file is specified.");
274 return (0);
275 }
276 if (argc < 2) {
277 file = stdin;
278 } else {
279 if (!(file = fopen(argv[1], "rb"))) {
280 fputs("Unable to open file.", stderr);
281 return (-1);
282 }
283 }
284 SHA1_Init(&context);
285 while (!feof(file)) { /* note: what if ferror(file) */
286 i = fread(buffer, 1, 16384, file);
287 SHA1_Update(&context, buffer, i);
288 }
289 SHA1_Final(&context, digest);
290 fclose(file);
291 for (i = 0; i < SHA1_DIGEST_SIZE / 4; i++) {
292 for (j = 0; j < 4; j++) {
293 printf("%02X", digest[i * 4 + j]);
294 }
295 putchar(' ');
296 }
297 putchar('\n');
298 return (0); /* JHB */
299 }
300 #endif
301
302 /* self test */
303
304 #ifdef TEST
305
306 static char *test_data[] = {
307 "abc",
308 "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
309 "A million repetitions of 'a'"
310 };
311 static char *test_results[] = {
312 "A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D",
313 "84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1",
314 "34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F"
315 };
316
317 void
318 digest_to_hex(const uint8_t digest[SHA1_DIGEST_SIZE], char *output)
319 {
320 int i, j;
321 char *c = output;
322
323 for (i = 0; i < SHA1_DIGEST_SIZE / 4; i++) {
324 for (j = 0; j < 4; j++) {
325 sprintf(c, "%02X", digest[i * 4 + j]);
326 c += 2;
327 }
328 sprintf(c, " ");
329 c += 1;
330 }
331 *(c - 1) = '\0';
332 }
333
334 int
335 main(int argc, char **argv)
336 {
337 int k;
338 SHA1_CTX context;
339 uint8_t digest[20];
340 char output[80];
341
342 fprintf(stdout, "verifying SHA-1 implementation... ");
343
344 for (k = 0; k < 2; k++) {
345 SHA1_Init(&context);
346 SHA1_Update(&context, (uint8_t *) test_data[k], strlen(test_data[k]));
347 SHA1_Final(&context, digest);
348 digest_to_hex(digest, output);
349
350 if (strcmp(output, test_results[k])) {
351 fprintf(stdout, "FAIL\n");
352 fprintf(stderr, "* hash of \"%s\" incorrect:\n", test_data[k]);
353 fprintf(stderr, "\t%s returned\n", output);
354 fprintf(stderr, "\t%s is correct\n", test_results[k]);
355 return (1);
356 }
357 }
358 /* million 'a' vector we feed separately */
359 SHA1_Init(&context);
360 for (k = 0; k < 1000000; k++)
361 SHA1_Update(&context, (uint8_t *) "a", 1);
362 SHA1_Final(&context, digest);
363 digest_to_hex(digest, output);
364 if (strcmp(output, test_results[2])) {
365 fprintf(stdout, "FAIL\n");
366 fprintf(stderr, "* hash of \"%s\" incorrect:\n", test_data[2]);
367 fprintf(stderr, "\t%s returned\n", output);
368 fprintf(stderr, "\t%s is correct\n", test_results[2]);
369 return (1);
370 }
371
372 /* success */
373 fprintf(stdout, "ok\n");
374 return (0);
375 }
376 #endif /* TEST */