Got Mirror

Blob

Date:: Thu Feb 23 18:51:38 2023 UTC
Message:: add some helper functions to compute hashes This adds a set of functions to abstract over SHA1Init, SHA1Update, SHA1Final, their respective SHA256 variants and how to compare digests. Replace all the SHA1*() usage with the new APIs. It's a preparatory step for sha256 handling. ok stsp@
Actions:: History | Blame | Raw File
1 /*
2  * Copyright (c) 2019 Stefan Sperling <stsp@openbsd.org>
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16 
17 #include <sys/queue.h>
18 
19 #include <errno.h>
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <string.h>
23 #include <sha1.h>
24 #include <sha2.h>
25 #include <zlib.h>
26 #include <time.h>
27 
28 #include "got_error.h"
29 #include "got_object.h"
30 #include "got_path.h"
31 
32 #include "got_lib_deflate.h"
33 #include "got_lib_hash.h"
34 #include "got_lib_poll.h"
35 
36 #ifndef MIN
37 #define	MIN(_a,_b) ((_a) < (_b) ? (_a) : (_b))
38 #endif
39 
40 const struct got_error *
41 got_deflate_init(struct got_deflate_buf *zb, uint8_t *outbuf, size_t bufsize)
42 {
43 	const struct got_error *err = NULL;
44 	int zerr;
45 
46 	memset(zb, 0, sizeof(*zb));
47 
48 	zb->z.zalloc = Z_NULL;
49 	zb->z.zfree = Z_NULL;
50 	zerr = deflateInit(&zb->z, Z_DEFAULT_COMPRESSION);
51 	if (zerr != Z_OK) {
52 		if  (zerr == Z_ERRNO)
53 			return got_error_from_errno("deflateInit");
54 		if  (zerr == Z_MEM_ERROR) {
55 			errno = ENOMEM;
56 			return got_error_from_errno("deflateInit");
57 		}
58 		return got_error(GOT_ERR_COMPRESSION);
59 	}
60 
61 	zb->inlen = zb->outlen = bufsize;
62 
63 	zb->inbuf = calloc(1, zb->inlen);
64 	if (zb->inbuf == NULL) {
65 		err = got_error_from_errno("calloc");
66 		goto done;
67 	}
68 
69 	zb->flags = 0;
70 	if (outbuf == NULL) {
71 		zb->outbuf = calloc(1, zb->outlen);
72 		if (zb->outbuf == NULL) {
73 			err = got_error_from_errno("calloc");
74 			goto done;
75 		}
76 		zb->flags |= GOT_DEFLATE_F_OWN_OUTBUF;
77 	} else
78 		zb->outbuf = outbuf;
79 done:
80 	if (err)
81 		got_deflate_end(zb);
82 	return err;
83 }
84 
85 static void
86 csum_output(struct got_deflate_checksum *csum, const uint8_t *buf, size_t len)
87 {
88 	if (csum->output_crc)
89 		*csum->output_crc = crc32(*csum->output_crc, buf, len);
90 
91 	if (csum->output_sha1)
92 		SHA1Update(csum->output_sha1, buf, len);
93 
94 	if (csum->output_ctx)
95 		got_hash_update(csum->output_ctx, buf, len);
96 }
97 
98 const struct got_error *
99 got_deflate_read(struct got_deflate_buf *zb, FILE *f, off_t len,
100     size_t *outlenp, off_t *consumed)
101 {
102 	size_t last_total_out = zb->z.total_out;
103 	z_stream *z = &zb->z;
104 	int ret = Z_ERRNO;
105 
106 	z->next_out = zb->outbuf;
107 	z->avail_out = zb->outlen;
108 
109 	*outlenp = 0;
110 	*consumed = 0;
111 	do {
112 		size_t last_total_in = z->total_in;
113 		if (z->avail_in == 0) {
114 			size_t n = 0;
115 			if (*consumed < len) {
116 				n = fread(zb->inbuf, 1,
117 				    MIN(zb->inlen, len - *consumed), f);
118 			}
119 			if (n == 0) {
120 				if (ferror(f))
121 					return got_ferror(f, GOT_ERR_IO);
122 				/* EOF */
123 				ret = deflate(z, Z_FINISH);
124 				break;
125 			}
126 			z->next_in = zb->inbuf;
127 			z->avail_in = n;
128 		}
129 		ret = deflate(z, Z_NO_FLUSH);
130 		*consumed += z->total_in - last_total_in;
131 	} while (ret == Z_OK && z->avail_out > 0);
132 
133 	if (ret == Z_OK) {
134 		zb->flags |= GOT_DEFLATE_F_HAVE_MORE;
135 	} else {
136 		if (ret != Z_STREAM_END)
137 			return got_error(GOT_ERR_COMPRESSION);
138 		zb->flags &= ~GOT_DEFLATE_F_HAVE_MORE;
139 	}
140 
141 	*outlenp = z->total_out - last_total_out;
142 	return NULL;
143 }
144 
145 static const struct got_error *
146 deflate_read_mmap(struct got_deflate_buf *zb, uint8_t *map, size_t offset,
147     size_t len, size_t *outlenp, size_t *consumed, int flush_on_eof)
148 {
149 	z_stream *z = &zb->z;
150 	size_t last_total_out = z->total_out;
151 	int ret = Z_ERRNO;
152 
153 	z->next_out = zb->outbuf;
154 	z->avail_out = zb->outlen;
155 
156 	*outlenp = 0;
157 	*consumed = 0;
158 	do {
159 		size_t last_total_in = z->total_in;
160 		if (z->avail_in == 0) {
161 			z->next_in = map + offset + *consumed;
162 			if (len - *consumed > UINT_MAX)
163 				z->avail_in = UINT_MAX;
164 			else
165 				z->avail_in = len - *consumed;
166 			if (z->avail_in == 0) {
167 				/* EOF */
168 				if (flush_on_eof)
169 					ret = deflate(z, Z_FINISH);
170 				break;
171 			}
172 		}
173 		ret = deflate(z, Z_NO_FLUSH);
174 		*consumed += z->total_in - last_total_in;
175 	} while (ret == Z_OK && z->avail_out > 0);
176 
177 	if (ret == Z_OK) {
178 		zb->flags |= GOT_DEFLATE_F_HAVE_MORE;
179 	} else {
180 		if (ret != Z_STREAM_END)
181 			return got_error(GOT_ERR_COMPRESSION);
182 		zb->flags &= ~GOT_DEFLATE_F_HAVE_MORE;
183 	}
184 
185 	*outlenp = z->total_out - last_total_out;
186 	return NULL;
187 }
188 
189 const struct got_error *
190 got_deflate_read_mmap(struct got_deflate_buf *zb, uint8_t *map, size_t offset,
191     size_t len, size_t *outlenp, size_t *consumed)
192 {
193 	return deflate_read_mmap(zb, map, offset, len, outlenp, consumed, 1);
194 }
195 
196 const struct got_error *
197 got_deflate_flush(struct got_deflate_buf *zb, FILE *outfile,
198     struct got_deflate_checksum *csum, off_t *outlenp)
199 {
200 	int ret;
201 	size_t n;
202 	z_stream *z = &zb->z;
203 
204 	if (z->avail_in != 0)
205 		return got_error_msg(GOT_ERR_COMPRESSION,
206 		    "cannot flush zb with pending input data");
207 
208 	do {
209 		size_t avail, last_total_out = zb->z.total_out;
210 
211 		z->next_out = zb->outbuf;
212 		z->avail_out = zb->outlen;
213 
214 		ret = deflate(z, Z_FINISH);
215 		if (ret != Z_STREAM_END && ret != Z_OK)
216 			return got_error(GOT_ERR_COMPRESSION);
217 
218 		avail = z->total_out - last_total_out;
219 		if (avail > 0) {
220 			n = fwrite(zb->outbuf, avail, 1, outfile);
221 			if (n != 1)
222 				return got_ferror(outfile, GOT_ERR_IO);
223 			if (csum)
224 				csum_output(csum, zb->outbuf, avail);
225 			if (outlenp)
226 				*outlenp += avail;
227 		}
228 	} while (ret != Z_STREAM_END);
229 
230 	zb->flags &= ~GOT_DEFLATE_F_HAVE_MORE;
231 	return NULL;
232 }
233 
234 void
235 got_deflate_end(struct got_deflate_buf *zb)
236 {
237 	free(zb->inbuf);
238 	if (zb->flags & GOT_DEFLATE_F_OWN_OUTBUF)
239 		free(zb->outbuf);
240 	deflateEnd(&zb->z);
241 }
242 
243 const struct got_error *
244 got_deflate_to_fd(off_t *outlen, FILE *infile, off_t len, int outfd,
245     struct got_deflate_checksum *csum)
246 {
247 	const struct got_error *err;
248 	size_t avail;
249 	off_t consumed;
250 	struct got_deflate_buf zb;
251 
252 	err = got_deflate_init(&zb, NULL, GOT_DEFLATE_BUFSIZE);
253 	if (err)
254 		goto done;
255 
256 	*outlen = 0;
257 
258 	do {
259 		err = got_deflate_read(&zb, infile, len, &avail, &consumed);
260 		if (err)
261 			goto done;
262 		len -= consumed;
263 		if (avail > 0) {
264 			err = got_poll_write_full(outfd, zb.outbuf, avail);
265 			if (err)
266 				goto done;
267 			if (csum)
268 				csum_output(csum, zb.outbuf, avail);
269 			*outlen += avail;
270 		}
271 	} while (zb.flags & GOT_DEFLATE_F_HAVE_MORE);
272 
273 done:
274 	got_deflate_end(&zb);
275 	return err;
276 }
277 
278 const struct got_error *
279 got_deflate_to_fd_mmap(off_t *outlen, uint8_t *map, size_t offset,
280     size_t len, int outfd, struct got_deflate_checksum *csum)
281 {
282 	const struct got_error *err;
283 	size_t avail, consumed;
284 	struct got_deflate_buf zb;
285 
286 	err = got_deflate_init(&zb, NULL, GOT_DEFLATE_BUFSIZE);
287 	if (err)
288 		goto done;
289 
290 	*outlen = 0;
291 	do {
292 		err = got_deflate_read_mmap(&zb, map, offset, len, &avail,
293 		    &consumed);
294 		if (err)
295 			goto done;
296 		offset += consumed;
297 		len -= consumed;
298 		if (avail > 0) {
299 			err = got_poll_write_full(outfd, zb.outbuf, avail);
300 			if (err)
301 				goto done;
302 			if (csum)
303 				csum_output(csum, zb.outbuf, avail);
304 			*outlen += avail;
305 		}
306 	} while (zb.flags & GOT_DEFLATE_F_HAVE_MORE);
307 
308 done:
309 	got_deflate_end(&zb);
310 	return err;
311 }
312 
313 const struct got_error *
314 got_deflate_to_file(off_t *outlen, FILE *infile, off_t len,
315     FILE *outfile, struct got_deflate_checksum *csum)
316 {
317 	const struct got_error *err;
318 	size_t avail;
319 	off_t consumed;
320 	struct got_deflate_buf zb;
321 
322 	err = got_deflate_init(&zb, NULL, GOT_DEFLATE_BUFSIZE);
323 	if (err)
324 		goto done;
325 
326 	*outlen = 0;
327 
328 	do {
329 		err = got_deflate_read(&zb, infile, len, &avail, &consumed);
330 		if (err)
331 			goto done;
332 		len -= consumed;
333 		if (avail > 0) {
334 			size_t n;
335 			n = fwrite(zb.outbuf, avail, 1, outfile);
336 			if (n != 1) {
337 				err = got_ferror(outfile, GOT_ERR_IO);
338 				goto done;
339 			}
340 			if (csum)
341 				csum_output(csum, zb.outbuf, avail);
342 			*outlen += avail;
343 		}
344 	} while (zb.flags & GOT_DEFLATE_F_HAVE_MORE);
345 
346 done:
347 	got_deflate_end(&zb);
348 	return err;
349 }
350 
351 const struct got_error *
352 got_deflate_to_file_mmap(off_t *outlen, uint8_t *map, size_t offset,
353     size_t len, FILE *outfile, struct got_deflate_checksum *csum)
354 {
355 	const struct got_error *err;
356 	size_t avail, consumed;
357 	struct got_deflate_buf zb;
358 
359 	err = got_deflate_init(&zb, NULL, GOT_DEFLATE_BUFSIZE);
360 	if (err)
361 		goto done;
362 
363 	*outlen = 0;
364 	do {
365 		err = got_deflate_read_mmap(&zb, map, offset, len, &avail,
366 		    &consumed);
367 		if (err)
368 			goto done;
369 		offset += consumed;
370 		len -= consumed;
371 		if (avail > 0) {
372 			size_t n;
373 			n = fwrite(zb.outbuf, avail, 1, outfile);
374 			if (n != 1) {
375 				err = got_ferror(outfile, GOT_ERR_IO);
376 				goto done;
377 			}
378 			if (csum)
379 				csum_output(csum, zb.outbuf, avail);
380 			*outlen += avail;
381 		}
382 	} while (zb.flags & GOT_DEFLATE_F_HAVE_MORE);
383 
384 done:
385 	got_deflate_end(&zb);
386 	return err;
387 }
388 
389 const struct got_error *
390 got_deflate_append_to_file_mmap(struct got_deflate_buf *zb, off_t *outlen,
391     uint8_t *map, size_t offset, size_t len, FILE *outfile,
392     struct got_deflate_checksum *csum)
393 {
394 	const struct got_error *err;
395 	size_t avail, consumed;
396 
397 	do {
398 		err = deflate_read_mmap(zb, map, offset, len, &avail,
399 		    &consumed, 0);
400 		if (err)
401 			break;
402 		offset += consumed;
403 		len -= consumed;
404 		if (avail > 0) {
405 			size_t n;
406 			n = fwrite(zb->outbuf, avail, 1, outfile);
407 			if (n != 1) {
408 				err = got_ferror(outfile, GOT_ERR_IO);
409 				break;
410 			}
411 			if (csum)
412 				csum_output(csum, zb->outbuf, avail);
413 			if (outlen)
414 				*outlen += avail;
415 		}
416 	} while ((zb->flags & GOT_DEFLATE_F_HAVE_MORE) && len > 0);
417 
418 	return err;
419 }
420 
421 const struct got_error *
422 got_deflate_to_mem_mmap(uint8_t **outbuf, size_t *outlen,
423     size_t *consumed_total, struct got_deflate_checksum *csum, uint8_t *map,
424     size_t offset, size_t len)
425 {
426 	const struct got_error *err;
427 	size_t avail, consumed;
428 	struct got_deflate_buf zb;
429 	void *newbuf;
430 	size_t nbuf = 1;
431 
432 	if (outbuf) {
433 		*outbuf = malloc(GOT_DEFLATE_BUFSIZE);
434 		if (*outbuf == NULL)
435 			return got_error_from_errno("malloc");
436 		err = got_deflate_init(&zb, *outbuf, GOT_DEFLATE_BUFSIZE);
437 		if (err) {
438 			free(*outbuf);
439 			*outbuf = NULL;
440 			return err;
441 		}
442 	} else {
443 		err = got_deflate_init(&zb, NULL, GOT_DEFLATE_BUFSIZE);
444 		if (err)
445 			return err;
446 	}
447 
448 	*outlen = 0;
449 	if (consumed_total)
450 		*consumed_total = 0;
451 	do {
452 		err = got_deflate_read_mmap(&zb, map, offset, len, &avail,
453 		    &consumed);
454 		if (err)
455 			goto done;
456 		offset += consumed;
457 		if (consumed_total)
458 			*consumed_total += consumed;
459 		len -= consumed;
460 		if (avail > 0 && csum)
461 			csum_output(csum, zb.outbuf, avail);
462 		*outlen += avail;
463 		if ((zb.flags & GOT_DEFLATE_F_HAVE_MORE) && outbuf != NULL) {
464 			newbuf = reallocarray(*outbuf, ++nbuf,
465 			    GOT_DEFLATE_BUFSIZE);
466 			if (newbuf == NULL) {
467 				err = got_error_from_errno("reallocarray");
468 				free(*outbuf);
469 				*outbuf = NULL;
470 				*outlen = 0;
471 				goto done;
472 			}
473 			*outbuf = newbuf;
474 			zb.outbuf = newbuf + *outlen;
475 			zb.outlen = (nbuf * GOT_DEFLATE_BUFSIZE) - *outlen;
476 		}
477 	} while (zb.flags & GOT_DEFLATE_F_HAVE_MORE);
478 done:
479 	got_deflate_end(&zb);
480 	return err;
481 }