op public repos

Blob

Date:: Sun Oct 23 00:37:19 2022 UTC
Message:: introduce gotd(8), a Git repository server reachable via ssh(1) This is an initial barebones implementation which provides the absolute minimum of functionality required to serve got(1) and git(1) clients. Basic fetch/send functionality has been tested and seems to work here, but this server is not yet expected to be stable. More testing is welcome. See the man pages for setup instructions. The current design uses one reader and one writer process per repository, which will have to be extended to N readers and N writers in the future. At startup, each process will chroot(2) into its assigned repository. This works because gotd(8) can only be started as root, and will then fork+exec, chroot, and privdrop. At present the parent process runs with the following pledge(2) promises: "stdio rpath wpath cpath proc getpw sendfd recvfd fattr flock unix unveil" The parent is the only process able to modify the repository in a way that becomes visible to Git clients. The parent uses unveil(2) to restrict its view of the filesystem to /tmp and the repositories listed in the configuration file gotd.conf(5). Per-repository chroot(2) processes use "stdio rpath sendfd recvfd". The writer defers to the parent for modifying references in the repository to point at newly uploaded commits. The reader is fine without such help, because Git repositories can be read without having to create any lock-files. gotd(8) requires a dedicated user ID, which should own repositories on the filesystem, and a separate secondary group, which should not have filesystem-level repository access, and must be allowed access to the gotd(8) socket. To obtain Git repository access, users must be members of this secondary group, and must have their login shell set to gotsh(1). gotsh(1) connects to the gotd(8) socket and speaks Git-protocol towards the client on the other end of the SSH connection. gotsh(1) is not an interactive command shell. At present, authenticated clients are granted read/write access to all repositories and all references (except for the "refs/got/" and the "refs/remotes/" namespaces, which are already being protected from modification). While complicated access control mechanism are not a design goal, making it possible to safely offer anonymous Git repository access over ssh(1) is on the road map.
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 <zlib.h>
25 #include <time.h>
26 
27 #include "got_error.h"
28 #include "got_object.h"
29 #include "got_path.h"
30 
31 #include "got_lib_deflate.h"
32 #include "got_lib_poll.h"
33 
34 #ifndef MIN
35 #define	MIN(_a,_b) ((_a) < (_b) ? (_a) : (_b))
36 #endif
37 
38 const struct got_error *
39 got_deflate_init(struct got_deflate_buf *zb, uint8_t *outbuf, size_t bufsize)
40 {
41 	const struct got_error *err = NULL;
42 	int zerr;
43 
44 	memset(&zb->z, 0, sizeof(zb->z));
45 
46 	zb->z.zalloc = Z_NULL;
47 	zb->z.zfree = Z_NULL;
48 	zerr = deflateInit(&zb->z, Z_DEFAULT_COMPRESSION);
49 	if (zerr != Z_OK) {
50 		if  (zerr == Z_ERRNO)
51 			return got_error_from_errno("deflateInit");
52 		if  (zerr == Z_MEM_ERROR) {
53 			errno = ENOMEM;
54 			return got_error_from_errno("deflateInit");
55 		}
56 		return got_error(GOT_ERR_COMPRESSION);
57 	}
58 
59 	zb->inlen = zb->outlen = bufsize;
60 
61 	zb->inbuf = calloc(1, zb->inlen);
62 	if (zb->inbuf == NULL) {
63 		err = got_error_from_errno("calloc");
64 		goto done;
65 	}
66 
67 	zb->flags = 0;
68 	if (outbuf == NULL) {
69 		zb->outbuf = calloc(1, zb->outlen);
70 		if (zb->outbuf == NULL) {
71 			err = got_error_from_errno("calloc");
72 			goto done;
73 		}
74 		zb->flags |= GOT_DEFLATE_F_OWN_OUTBUF;
75 	} else
76 		zb->outbuf = outbuf;
77 done:
78 	if (err)
79 		got_deflate_end(zb);
80 	return err;
81 }
82 
83 static void
84 csum_output(struct got_deflate_checksum *csum, const uint8_t *buf, size_t len)
85 {
86 	if (csum->output_crc)
87 		*csum->output_crc = crc32(*csum->output_crc, buf, len);
88 
89 	if (csum->output_sha1)
90 		SHA1Update(csum->output_sha1, buf, len);
91 }
92 
93 const struct got_error *
94 got_deflate_read(struct got_deflate_buf *zb, FILE *f, off_t len,
95     size_t *outlenp, off_t *consumed)
96 {
97 	size_t last_total_out = zb->z.total_out;
98 	z_stream *z = &zb->z;
99 	int ret = Z_ERRNO;
100 
101 	z->next_out = zb->outbuf;
102 	z->avail_out = zb->outlen;
103 
104 	*outlenp = 0;
105 	*consumed = 0;
106 	do {
107 		size_t last_total_in = z->total_in;
108 		if (z->avail_in == 0) {
109 			size_t n = 0;
110 			if (*consumed < len) {
111 				n = fread(zb->inbuf, 1,
112 				    MIN(zb->inlen, len - *consumed), f);
113 			}
114 			if (n == 0) {
115 				if (ferror(f))
116 					return got_ferror(f, GOT_ERR_IO);
117 				/* EOF */
118 				ret = deflate(z, Z_FINISH);
119 				break;
120 			}
121 			z->next_in = zb->inbuf;
122 			z->avail_in = n;
123 		}
124 		ret = deflate(z, Z_NO_FLUSH);
125 		*consumed += z->total_in - last_total_in;
126 	} while (ret == Z_OK && z->avail_out > 0);
127 
128 	if (ret == Z_OK) {
129 		zb->flags |= GOT_DEFLATE_F_HAVE_MORE;
130 	} else {
131 		if (ret != Z_STREAM_END)
132 			return got_error(GOT_ERR_COMPRESSION);
133 		zb->flags &= ~GOT_DEFLATE_F_HAVE_MORE;
134 	}
135 
136 	*outlenp = z->total_out - last_total_out;
137 	return NULL;
138 }
139 
140 static const struct got_error *
141 deflate_read_mmap(struct got_deflate_buf *zb, uint8_t *map, size_t offset,
142     size_t len, size_t *outlenp, size_t *consumed, int flush_on_eof)
143 {
144 	z_stream *z = &zb->z;
145 	size_t last_total_out = z->total_out;
146 	int ret = Z_ERRNO;
147 
148 	z->next_out = zb->outbuf;
149 	z->avail_out = zb->outlen;
150 
151 	*outlenp = 0;
152 	*consumed = 0;
153 	do {
154 		size_t last_total_in = z->total_in;
155 		if (z->avail_in == 0) {
156 			z->next_in = map + offset + *consumed;
157 			if (len - *consumed > UINT_MAX)
158 				z->avail_in = UINT_MAX;
159 			else
160 				z->avail_in = len - *consumed;
161 			if (z->avail_in == 0) {
162 				/* EOF */
163 				if (flush_on_eof)
164 					ret = deflate(z, Z_FINISH);
165 				break;
166 			}
167 		}
168 		ret = deflate(z, Z_NO_FLUSH);
169 		*consumed += z->total_in - last_total_in;
170 	} while (ret == Z_OK && z->avail_out > 0);
171 
172 	if (ret == Z_OK) {
173 		zb->flags |= GOT_DEFLATE_F_HAVE_MORE;
174 	} else {
175 		if (ret != Z_STREAM_END)
176 			return got_error(GOT_ERR_COMPRESSION);
177 		zb->flags &= ~GOT_DEFLATE_F_HAVE_MORE;
178 	}
179 
180 	*outlenp = z->total_out - last_total_out;
181 	return NULL;
182 }
183 
184 const struct got_error *
185 got_deflate_read_mmap(struct got_deflate_buf *zb, uint8_t *map, size_t offset,
186     size_t len, size_t *outlenp, size_t *consumed)
187 {
188 	return deflate_read_mmap(zb, map, offset, len, outlenp, consumed, 1);
189 }
190 
191 const struct got_error *
192 got_deflate_flush(struct got_deflate_buf *zb, FILE *outfile,
193     struct got_deflate_checksum *csum, off_t *outlenp)
194 {
195 	int ret;
196 	size_t n;
197 	z_stream *z = &zb->z;
198 
199 	if (z->avail_in != 0)
200 		return got_error_msg(GOT_ERR_COMPRESSION,
201 		    "cannot flush zb with pending input data");
202 
203 	do {
204 		size_t avail, last_total_out = zb->z.total_out;
205 
206 		z->next_out = zb->outbuf;
207 		z->avail_out = zb->outlen;
208 
209 		ret = deflate(z, Z_FINISH);
210 		if (ret != Z_STREAM_END && ret != Z_OK)
211 			return got_error(GOT_ERR_COMPRESSION);
212 
213 		avail = z->total_out - last_total_out;
214 		if (avail > 0) {
215 			n = fwrite(zb->outbuf, avail, 1, outfile);
216 			if (n != 1)
217 				return got_ferror(outfile, GOT_ERR_IO);
218 			if (csum)
219 				csum_output(csum, zb->outbuf, avail);
220 			if (outlenp)
221 				*outlenp += avail;
222 		}
223 	} while (ret != Z_STREAM_END);
224 
225 	zb->flags &= ~GOT_DEFLATE_F_HAVE_MORE;
226 	return NULL;
227 }
228 
229 void
230 got_deflate_end(struct got_deflate_buf *zb)
231 {
232 	free(zb->inbuf);
233 	if (zb->flags & GOT_DEFLATE_F_OWN_OUTBUF)
234 		free(zb->outbuf);
235 	deflateEnd(&zb->z);
236 }
237 
238 const struct got_error *
239 got_deflate_to_fd(off_t *outlen, FILE *infile, off_t len, int outfd,
240     struct got_deflate_checksum *csum)
241 {
242 	const struct got_error *err;
243 	size_t avail;
244 	off_t consumed;
245 	struct got_deflate_buf zb;
246 
247 	err = got_deflate_init(&zb, NULL, GOT_DEFLATE_BUFSIZE);
248 	if (err)
249 		goto done;
250 
251 	*outlen = 0;
252 
253 	do {
254 		err = got_deflate_read(&zb, infile, len, &avail, &consumed);
255 		if (err)
256 			goto done;
257 		len -= consumed;
258 		if (avail > 0) {
259 			err = got_poll_write_full(outfd, zb.outbuf, avail);
260 			if (err)
261 				goto done;
262 			if (csum)
263 				csum_output(csum, zb.outbuf, avail);
264 			*outlen += avail;
265 		}
266 	} while (zb.flags & GOT_DEFLATE_F_HAVE_MORE);
267 
268 done:
269 	got_deflate_end(&zb);
270 	return err;
271 }
272 
273 const struct got_error *
274 got_deflate_to_fd_mmap(off_t *outlen, uint8_t *map, size_t offset,
275     size_t len, int outfd, struct got_deflate_checksum *csum)
276 {
277 	const struct got_error *err;
278 	size_t avail, consumed;
279 	struct got_deflate_buf zb;
280 
281 	err = got_deflate_init(&zb, NULL, GOT_DEFLATE_BUFSIZE);
282 	if (err)
283 		goto done;
284 
285 	*outlen = 0;
286 	do {
287 		err = got_deflate_read_mmap(&zb, map, offset, len, &avail,
288 		    &consumed);
289 		if (err)
290 			goto done;
291 		offset += consumed;
292 		len -= consumed;
293 		if (avail > 0) {
294 			err = got_poll_write_full(outfd, zb.outbuf, avail);
295 			if (err)
296 				goto done;
297 			if (csum)
298 				csum_output(csum, zb.outbuf, avail);
299 			*outlen += avail;
300 		}
301 	} while (zb.flags & GOT_DEFLATE_F_HAVE_MORE);
302 
303 done:
304 	got_deflate_end(&zb);
305 	return err;
306 }
307 
308 const struct got_error *
309 got_deflate_to_file(off_t *outlen, FILE *infile, off_t len,
310     FILE *outfile, struct got_deflate_checksum *csum)
311 {
312 	const struct got_error *err;
313 	size_t avail;
314 	off_t consumed;
315 	struct got_deflate_buf zb;
316 
317 	err = got_deflate_init(&zb, NULL, GOT_DEFLATE_BUFSIZE);
318 	if (err)
319 		goto done;
320 
321 	*outlen = 0;
322 
323 	do {
324 		err = got_deflate_read(&zb, infile, len, &avail, &consumed);
325 		if (err)
326 			goto done;
327 		len -= consumed;
328 		if (avail > 0) {
329 			size_t n;
330 			n = fwrite(zb.outbuf, avail, 1, outfile);
331 			if (n != 1) {
332 				err = got_ferror(outfile, GOT_ERR_IO);
333 				goto done;
334 			}
335 			if (csum)
336 				csum_output(csum, zb.outbuf, avail);
337 			*outlen += avail;
338 		}
339 	} while (zb.flags & GOT_DEFLATE_F_HAVE_MORE);
340 
341 done:
342 	got_deflate_end(&zb);
343 	return err;
344 }
345 
346 const struct got_error *
347 got_deflate_to_file_mmap(off_t *outlen, uint8_t *map, size_t offset,
348     size_t len, FILE *outfile, struct got_deflate_checksum *csum)
349 {
350 	const struct got_error *err;
351 	size_t avail, consumed;
352 	struct got_deflate_buf zb;
353 
354 	err = got_deflate_init(&zb, NULL, GOT_DEFLATE_BUFSIZE);
355 	if (err)
356 		goto done;
357 
358 	*outlen = 0;
359 	do {
360 		err = got_deflate_read_mmap(&zb, map, offset, len, &avail,
361 		    &consumed);
362 		if (err)
363 			goto done;
364 		offset += consumed;
365 		len -= consumed;
366 		if (avail > 0) {
367 			size_t n;
368 			n = fwrite(zb.outbuf, avail, 1, outfile);
369 			if (n != 1) {
370 				err = got_ferror(outfile, GOT_ERR_IO);
371 				goto done;
372 			}
373 			if (csum)
374 				csum_output(csum, zb.outbuf, avail);
375 			*outlen += avail;
376 		}
377 	} while (zb.flags & GOT_DEFLATE_F_HAVE_MORE);
378 
379 done:
380 	got_deflate_end(&zb);
381 	return err;
382 }
383 
384 const struct got_error *
385 got_deflate_append_to_file_mmap(struct got_deflate_buf *zb, off_t *outlen,
386     uint8_t *map, size_t offset, size_t len, FILE *outfile,
387     struct got_deflate_checksum *csum)
388 {
389 	const struct got_error *err;
390 	size_t avail, consumed;
391 
392 	do {
393 		err = deflate_read_mmap(zb, map, offset, len, &avail,
394 		    &consumed, 0);
395 		if (err)
396 			break;
397 		offset += consumed;
398 		len -= consumed;
399 		if (avail > 0) {
400 			size_t n;
401 			n = fwrite(zb->outbuf, avail, 1, outfile);
402 			if (n != 1) {
403 				err = got_ferror(outfile, GOT_ERR_IO);
404 				break;
405 			}
406 			if (csum)
407 				csum_output(csum, zb->outbuf, avail);
408 			if (outlen)
409 				*outlen += avail;
410 		}
411 	} while ((zb->flags & GOT_DEFLATE_F_HAVE_MORE) && len > 0);
412 
413 	return err;
414 }
415 
416 const struct got_error *
417 got_deflate_to_mem_mmap(uint8_t **outbuf, size_t *outlen,
418     size_t *consumed_total, struct got_deflate_checksum *csum, uint8_t *map,
419     size_t offset, size_t len)
420 {
421 	const struct got_error *err;
422 	size_t avail, consumed;
423 	struct got_deflate_buf zb;
424 	void *newbuf;
425 	size_t nbuf = 1;
426 
427 	if (outbuf) {
428 		*outbuf = malloc(GOT_DEFLATE_BUFSIZE);
429 		if (*outbuf == NULL)
430 			return got_error_from_errno("malloc");
431 		err = got_deflate_init(&zb, *outbuf, GOT_DEFLATE_BUFSIZE);
432 		if (err) {
433 			free(*outbuf);
434 			*outbuf = NULL;
435 			return err;
436 		}
437 	} else {
438 		err = got_deflate_init(&zb, NULL, GOT_DEFLATE_BUFSIZE);
439 		if (err)
440 			return err;
441 	}
442 
443 	*outlen = 0;
444 	if (consumed_total)
445 		*consumed_total = 0;
446 	do {
447 		err = got_deflate_read_mmap(&zb, map, offset, len, &avail,
448 		    &consumed);
449 		if (err)
450 			goto done;
451 		offset += consumed;
452 		if (consumed_total)
453 			*consumed_total += consumed;
454 		len -= consumed;
455 		if (avail > 0 && csum)
456 			csum_output(csum, zb.outbuf, avail);
457 		*outlen += avail;
458 		if ((zb.flags & GOT_DEFLATE_F_HAVE_MORE) && outbuf != NULL) {
459 			newbuf = reallocarray(*outbuf, ++nbuf,
460 			    GOT_DEFLATE_BUFSIZE);
461 			if (newbuf == NULL) {
462 				err = got_error_from_errno("reallocarray");
463 				free(*outbuf);
464 				*outbuf = NULL;
465 				*outlen = 0;
466 				goto done;
467 			}
468 			*outbuf = newbuf;
469 			zb.outbuf = newbuf + *outlen;
470 			zb.outlen = (nbuf * GOT_DEFLATE_BUFSIZE) - *outlen;
471 		}
472 	} while (zb.flags & GOT_DEFLATE_F_HAVE_MORE);
473 done:
474 	got_deflate_end(&zb);
475 	return err;
476 }