(root)/mandos/release
» Revision
237.7.785
(compared to revision 237.7.242)
: plugins.d/mandos-client.c
To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to plugins.d/mandos-client.c
- browse files at revision 237.7.785
- compare with another revision
- download diff
- download tarball
- view history from revision 237.7.785
- Committer: Teddy Hogeborn
- Date: 2021-02-03 23:10:42 UTC
- mto: This revision was merged to the branch mainline in revision 406.
- Revision ID: teddy@recompile.se-20210203231042-2z3egrvpo1zt7nej
mandos-ctl: Fix bad test for command.Remove and related minor issues
The test for command.Remove removes all clients from the spy server,
and then loops over all clients, looking for the corresponding Remove
command as recorded by the spy server. But since since there aren't
any clients left after they were removed, no assertions are made, and
the test therefore does nothing. Fix this.
In tests for command.Approve and command.Deny, add checks that clients
were not somehow removed by the command (in which case, likewise, no
assertions are made).
Add related checks to TestPropertySetterCmd.runTest; i.e. test that a
sequence is not empty before looping over it and making assertions.
* mandos-ctl (TestBaseCommands.test_Remove): Save a copy of the
original "clients" dict, and loop over those instead. Add assertion
that all clients were indeed removed. Also fix the code which looks
for the Remove command, which now needs to actually work.
(TestBaseCommands.test_Approve, TestBaseCommands.test_Deny): Add
assertion that there are still clients before looping over them.
(TestPropertySetterCmd.runTest): Add assertion that the list of
values to get is not empty before looping over them. Also add check
that there are still clients before looping over clients.
The test for command.Remove removes all clients from the spy server,
and then loops over all clients, looking for the corresponding Remove
command as recorded by the spy server. But since since there aren't
any clients left after they were removed, no assertions are made, and
the test therefore does nothing. Fix this.
In tests for command.Approve and command.Deny, add checks that clients
were not somehow removed by the command (in which case, likewise, no
assertions are made).
Add related checks to TestPropertySetterCmd.runTest; i.e. test that a
sequence is not empty before looping over it and making assertions.
* mandos-ctl (TestBaseCommands.test_Remove): Save a copy of the
original "clients" dict, and loop over those instead. Add assertion
that all clients were indeed removed. Also fix the code which looks
for the Remove command, which now needs to actually work.
(TestBaseCommands.test_Approve, TestBaseCommands.test_Deny): Add
assertion that there are still clients before looping over them.
(TestPropertySetterCmd.runTest): Add assertion that the list of
values to get is not empty before looping over them. Also add check
that there are still clients before looping over clients.
- files added:
- bugs.xml
- debian/tests
- dracut-module
- plugin-helpers
- files removed:
- initramfs-tools-hook-conf
- files modified:
- .bzrignore
added
removed
plugins.d/mandos-client.c
9
9
* "browse_callback", and parts of "main".
10
10
*
11
11
* Everything else is
12
* Copyright © 2008-2014 Teddy Hogeborn
13
* Copyright © 2008-2014 Björn Påhlsson
14
*
15
* This program is free software: you can redistribute it and/or
16
* modify it under the terms of the GNU General Public License as
17
* published by the Free Software Foundation, either version 3 of the
18
* License, or (at your option) any later version.
19
*
20
* This program is distributed in the hope that it will be useful, but
12
* Copyright © 2008-2021 Teddy Hogeborn
13
* Copyright © 2008-2021 Björn Påhlsson
14
*
15
* This file is part of Mandos.
16
*
17
* Mandos is free software: you can redistribute it and/or modify it
18
* under the terms of the GNU General Public License as published by
19
* the Free Software Foundation, either version 3 of the License, or
20
* (at your option) any later version.
21
*
22
* Mandos is distributed in the hope that it will be useful, but
21
23
* WITHOUT ANY WARRANTY; without even the implied warranty of
22
24
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23
25
* General Public License for more details.
24
26
*
25
27
* You should have received a copy of the GNU General Public License
26
* along with this program. If not, see
27
* <http://www.gnu.org/licenses/>.
28
* along with Mandos. If not, see <http://www.gnu.org/licenses/>.
28
29
*
29
30
* Contact the authors at <mandos@recompile.se>.
30
31
*/
37
38
#define _FILE_OFFSET_BITS 64
38
39
#endif /* not _FILE_OFFSET_BITS */
39
40
40
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
41
42
#include <stdio.h> /* fprintf(), stderr, fwrite(),
43
stdout, ferror() */
44
#include <stdint.h> /* uint16_t, uint32_t, intptr_t */
45
#include <stddef.h> /* NULL, size_t, ssize_t */
46
#include <stdlib.h> /* free(), EXIT_SUCCESS, srand(),
47
strtof(), abort() */
41
#define _GNU_SOURCE /* program_invocation_short_name,
42
TEMP_FAILURE_RETRY(), O_CLOEXEC,
43
scandirat(), asprintf() */
48
44
#include <stdbool.h> /* bool, false, true */
49
#include <string.h> /* memset(), strcmp(), strlen(),
50
strerror(), asprintf(), strcpy() */
51
#include <sys/ioctl.h> /* ioctl */
52
#include <sys/types.h> /* socket(), inet_pton(), sockaddr,
53
sockaddr_in6, PF_INET6,
54
SOCK_STREAM, uid_t, gid_t, open(),
55
opendir(), DIR */
56
#include <sys/stat.h> /* open(), S_ISREG */
57
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
58
inet_pton(), connect(),
59
getnameinfo() */
60
#include <fcntl.h> /* open(), unlinkat() */
61
#include <dirent.h> /* opendir(), struct dirent, readdir()
62
*/
63
#include <inttypes.h> /* PRIu16, PRIdMAX, intmax_t,
45
#include <argp.h> /* argp_program_version,
46
argp_program_bug_address,
47
struct argp_option,
48
struct argp_state, argp_error(),
49
argp_state_help,
50
ARGP_HELP_STD_HELP,
51
ARGP_HELP_EXIT_ERR,
52
ARGP_HELP_EXIT_OK, ARGP_HELP_USAGE,
53
argp_err_exit_status,
54
ARGP_ERR_UNKNOWN, struct argp,
55
argp_parse(), ARGP_IN_ORDER,
56
ARGP_NO_HELP */
57
#include <stddef.h> /* NULL, size_t */
58
#include <sys/types.h> /* uid_t, gid_t, sig_atomic_t,
59
seteuid(), setuid(), pid_t,
60
setgid(), getuid(), getgid() */
61
#include <unistd.h> /* uid_t, gid_t, TEMP_FAILURE_RETRY(),
62
seteuid(), setuid(), close(),
63
ssize_t, read(), fork(), setgid(),
64
_exit(), dup2(), STDIN_FILENO,
65
STDERR_FILENO, STDOUT_FILENO,
66
fexecve(), write(), getuid(),
67
getgid(), fchown(), symlink(),
68
sleep(), unlinkat(), pause() */
69
#include <netinet/in.h> /* in_port_t, struct sockaddr_in6,
70
sa_family_t, struct sockaddr_in,
71
htons(), IN6_IS_ADDR_LINKLOCAL,
72
INET_ADDRSTRLEN, INET6_ADDRSTRLEN,
73
ntohl(), IPPROTO_IP */
74
#include <time.h> /* struct timespec, clock_gettime(),
75
CLOCK_MONOTONIC, time_t, struct tm,
76
gmtime_r(), clock_settime(),
77
CLOCK_REALTIME, nanosleep() */
78
#include <errno.h> /* errno,
79
program_invocation_short_name,
80
EINTR, EINVAL, ENETUNREACH,
81
EHOSTUNREACH, ECONNREFUSED, EPROTO,
82
EIO, ENOENT, ENXIO, error_t,
83
ENOMEM, EISDIR, ENOTEMPTY */
84
#include <stdio.h> /* fprintf(), stderr, perror(), FILE,
85
vfprintf(), off_t, SEEK_SET,
86
stdout, fwrite(), ferror(),
87
fflush(), asprintf() */
88
#include <stdarg.h> /* va_list, va_start(), vfprintf() */
89
#include <stdlib.h> /* realloc(), free(), malloc(),
90
getenv(), EXIT_FAILURE, setenv(),
91
EXIT_SUCCESS, strtof(), strtod(),
92
srand(), mkdtemp(), abort() */
93
#include <string.h> /* strdup(), strcmp(), strlen(),
94
strerror(), strncpy(), strspn(),
95
memcpy(), strrchr(), strchr(),
96
strsignal() */
97
#include <fcntl.h> /* open(), O_RDONLY, O_DIRECTORY,
98
O_PATH, O_CLOEXEC, openat(),
99
O_NOFOLLOW, AT_REMOVEDIR */
100
#include <iso646.h> /* or, and, not */
101
#include <sys/stat.h> /* struct stat, fstat(), fstatat(),
102
S_ISREG(), S_IXUSR, S_IXGRP,
103
S_IXOTH, lstat() */
104
#include <net/if.h> /* IF_NAMESIZE, if_indextoname(),
105
if_nametoindex(), SIOCGIFFLAGS,
106
IFF_LOOPBACK, IFF_POINTOPOINT,
107
IFF_BROADCAST, IFF_NOARP, IFF_UP,
108
IFF_RUNNING, SIOCSIFFLAGS */
109
#include <sysexits.h> /* EX_NOPERM, EX_OSERR,
110
EX_UNAVAILABLE, EX_USAGE */
111
#include <grp.h> /* setgroups() */
112
#include <sys/wait.h> /* waitpid(), WIFEXITED(),
113
WEXITSTATUS(), WIFSIGNALED(),
114
WTERMSIG() */
115
#include <signal.h> /* kill(), SIGTERM, struct sigaction,
116
SIG_DFL, sigemptyset(),
117
sigaddset(), SIGINT, SIGHUP,
118
SIG_IGN, raise() */
119
#include <sys/socket.h> /* struct sockaddr_storage, AF_INET6,
120
PF_INET6, AF_INET, PF_INET,
121
socket(), SOCK_STREAM,
122
SOCK_CLOEXEC, struct sockaddr,
123
connect(), SOCK_DGRAM */
124
#include <argz.h> /* argz_next(), argz_add_sep(),
125
argz_delete(), argz_stringify(),
126
argz_add(), argz_count() */
127
#include <inttypes.h> /* PRIuMAX, uintmax_t, uint32_t,
128
PRIdMAX, PRIu16, intmax_t,
64
129
strtoimax() */
65
#include <errno.h> /* perror(), errno,
66
program_invocation_short_name */
67
#include <time.h> /* nanosleep(), time(), sleep() */
68
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
69
SIOCSIFFLAGS, if_indextoname(),
70
if_nametoindex(), IF_NAMESIZE */
71
#include <netinet/in.h> /* IN6_IS_ADDR_LINKLOCAL,
72
INET_ADDRSTRLEN, INET6_ADDRSTRLEN
73
*/
74
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
75
getuid(), getgid(), seteuid(),
76
setgid(), pause(), _exit(),
77
unlinkat() */
78
#include <arpa/inet.h> /* inet_pton(), htons() */
79
#include <iso646.h> /* not, or, and */
80
#include <argp.h> /* struct argp_option, error_t, struct
81
argp_state, struct argp,
82
argp_parse(), ARGP_KEY_ARG,
83
ARGP_KEY_END, ARGP_ERR_UNKNOWN */
84
#include <signal.h> /* sigemptyset(), sigaddset(),
85
sigaction(), SIGTERM, sig_atomic_t,
86
raise() */
87
#include <sysexits.h> /* EX_OSERR, EX_USAGE, EX_UNAVAILABLE,
88
EX_NOHOST, EX_IOERR, EX_PROTOCOL */
89
#include <sys/wait.h> /* waitpid(), WIFEXITED(),
90
WEXITSTATUS(), WTERMSIG() */
91
#include <grp.h> /* setgroups() */
92
#include <argz.h> /* argz_add_sep(), argz_next(),
93
argz_delete(), argz_append(),
94
argz_stringify(), argz_add(),
95
argz_count() */
130
#include <arpa/inet.h> /* inet_pton() */
131
#include <stdint.h> /* uint32_t, intptr_t, uint16_t */
96
132
#include <netdb.h> /* getnameinfo(), NI_NUMERICHOST,
97
133
EAI_SYSTEM, gai_strerror() */
134
#include <sys/ioctl.h> /* ioctl() */
135
#include <dirent.h> /* struct dirent, scandirat(),
136
alphasort(), scandir() */
137
#include <limits.h> /* INT_MAX */
98
138
99
139
#ifdef __linux__
100
140
#include <sys/klog.h> /* klogctl() */
113
153
114
154
/* GnuTLS */
115
155
#include <gnutls/gnutls.h> /* All GnuTLS types, constants and
116
functions:
117
gnutls_*
118
init_gnutls_session(),
119
GNUTLS_* */
156
functions: gnutls_*, GNUTLS_* */
157
#if GNUTLS_VERSION_NUMBER < 0x030600
120
158
#include <gnutls/openpgp.h>
121
159
/* gnutls_certificate_set_openpgp_key_file(),
122
160
GNUTLS_OPENPGP_FMT_BASE64 */
161
#elif GNUTLS_VERSION_NUMBER >= 0x030606
162
#include <gnutls/x509.h> /* GNUTLS_PKCS_PLAIN,
163
GNUTLS_PKCS_NULL_PASSWORD */
164
#endif
123
165
124
166
/* GPGME */
125
167
#include <gpgme.h> /* All GPGME types, constants and
126
168
functions:
127
gpgme_*
128
GPGME_PROTOCOL_OpenPGP,
129
GPG_ERR_NO_* */
169
gpgme_*, GPG_ERR_NO_*,
170
GPGME_IMPORT_*
171
GPGME_PROTOCOL_OpenPGP */
130
172
131
173
#define BUFFER_SIZE 256
132
174
133
175
#define PATHDIR "/conf/conf.d/mandos"
134
176
#define SECKEY "seckey.txt"
135
177
#define PUBKEY "pubkey.txt"
178
#define TLS_PRIVKEY "tls-privkey.pem"
179
#define TLS_PUBKEY "tls-pubkey.pem"
136
180
#define HOOKDIR "/lib/mandos/network-hooks.d"
137
181
138
182
bool debug = false;
234
278
.af = af };
235
279
if(new_server->ip == NULL){
236
280
perror_plus("strdup");
281
free(new_server);
237
282
return false;
238
283
}
239
284
ret = clock_gettime(CLOCK_MONOTONIC, &(new_server->last_seen));
240
285
if(ret == -1){
241
286
perror_plus("clock_gettime");
287
#ifdef __GNUC__
288
#pragma GCC diagnostic push
289
#pragma GCC diagnostic ignored "-Wcast-qual"
290
#endif
291
free((char *)(new_server->ip));
292
#ifdef __GNUC__
293
#pragma GCC diagnostic pop
294
#endif
295
free(new_server);
242
296
return false;
243
297
}
244
298
/* Special case of first server */
256
310
return true;
257
311
}
258
312
313
/* Set effective uid to 0, return errno */
314
__attribute__((warn_unused_result))
315
int raise_privileges(void){
316
int old_errno = errno;
317
int ret = 0;
318
if(seteuid(0) == -1){
319
ret = errno;
320
}
321
errno = old_errno;
322
return ret;
323
}
324
325
/* Set effective and real user ID to 0. Return errno. */
326
__attribute__((warn_unused_result))
327
int raise_privileges_permanently(void){
328
int old_errno = errno;
329
int ret = raise_privileges();
330
if(ret != 0){
331
errno = old_errno;
332
return ret;
333
}
334
if(setuid(0) == -1){
335
ret = errno;
336
}
337
errno = old_errno;
338
return ret;
339
}
340
341
/* Set effective user ID to unprivileged saved user ID */
342
__attribute__((warn_unused_result))
343
int lower_privileges(void){
344
int old_errno = errno;
345
int ret = 0;
346
if(seteuid(uid) == -1){
347
ret = errno;
348
}
349
errno = old_errno;
350
return ret;
351
}
352
353
/* Lower privileges permanently */
354
__attribute__((warn_unused_result))
355
int lower_privileges_permanently(void){
356
int old_errno = errno;
357
int ret = 0;
358
if(setuid(uid) == -1){
359
ret = errno;
360
}
361
errno = old_errno;
362
return ret;
363
}
364
259
365
/*
260
366
* Initialize GPGME.
261
367
*/
281
387
return false;
282
388
}
283
389
390
/* Workaround for systems without a real-time clock; see also
391
Debian bug #894495: <https://bugs.debian.org/894495> */
392
do {
393
{
394
time_t currtime = time(NULL);
395
if(currtime != (time_t)-1){
396
struct tm tm;
397
if(gmtime_r(&currtime, &tm) == NULL) {
398
perror_plus("gmtime_r");
399
break;
400
}
401
if(tm.tm_year != 70 or tm.tm_mon != 0){
402
break;
403
}
404
if(debug){
405
fprintf_plus(stderr, "System clock is January 1970");
406
}
407
} else {
408
if(debug){
409
fprintf_plus(stderr, "System clock is invalid");
410
}
411
}
412
}
413
struct stat keystat;
414
ret = fstat(fd, &keystat);
415
if(ret != 0){
416
perror_plus("fstat");
417
break;
418
}
419
ret = raise_privileges();
420
if(ret != 0){
421
errno = ret;
422
perror_plus("Failed to raise privileges");
423
break;
424
}
425
if(debug){
426
fprintf_plus(stderr,
427
"Setting system clock to key file mtime");
428
}
429
if(clock_settime(CLOCK_REALTIME, &keystat.st_mtim) != 0){
430
perror_plus("clock_settime");
431
}
432
ret = lower_privileges();
433
if(ret != 0){
434
errno = ret;
435
perror_plus("Failed to lower privileges");
436
}
437
} while(false);
438
284
439
rc = gpgme_data_new_from_fd(&pgp_data, fd);
285
440
if(rc != GPG_ERR_NO_ERROR){
286
441
fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
294
449
gpgme_strsource(rc), gpgme_strerror(rc));
295
450
return false;
296
451
}
452
{
453
gpgme_import_result_t import_result
454
= gpgme_op_import_result(mc->ctx);
455
if((import_result->imported < 1
456
or import_result->not_imported > 0)
457
and import_result->unchanged == 0){
458
fprintf_plus(stderr, "bad gpgme_op_import_results:\n");
459
fprintf_plus(stderr,
460
"The total number of considered keys: %d\n",
461
import_result->considered);
462
fprintf_plus(stderr,
463
"The number of keys without user ID: %d\n",
464
import_result->no_user_id);
465
fprintf_plus(stderr,
466
"The total number of imported keys: %d\n",
467
import_result->imported);
468
fprintf_plus(stderr, "The number of imported RSA keys: %d\n",
469
import_result->imported_rsa);
470
fprintf_plus(stderr, "The number of unchanged keys: %d\n",
471
import_result->unchanged);
472
fprintf_plus(stderr, "The number of new user IDs: %d\n",
473
import_result->new_user_ids);
474
fprintf_plus(stderr, "The number of new sub keys: %d\n",
475
import_result->new_sub_keys);
476
fprintf_plus(stderr, "The number of new signatures: %d\n",
477
import_result->new_signatures);
478
fprintf_plus(stderr, "The number of new revocations: %d\n",
479
import_result->new_revocations);
480
fprintf_plus(stderr,
481
"The total number of secret keys read: %d\n",
482
import_result->secret_read);
483
fprintf_plus(stderr,
484
"The number of imported secret keys: %d\n",
485
import_result->secret_imported);
486
fprintf_plus(stderr,
487
"The number of unchanged secret keys: %d\n",
488
import_result->secret_unchanged);
489
fprintf_plus(stderr, "The number of keys not imported: %d\n",
490
import_result->not_imported);
491
for(gpgme_import_status_t import_status
492
= import_result->imports;
493
import_status != NULL;
494
import_status = import_status->next){
495
fprintf_plus(stderr, "Import status for key: %s\n",
496
import_status->fpr);
497
if(import_status->result != GPG_ERR_NO_ERROR){
498
fprintf_plus(stderr, "Import result: %s: %s\n",
499
gpgme_strsource(import_status->result),
500
gpgme_strerror(import_status->result));
501
}
502
fprintf_plus(stderr, "Key status:\n");
503
fprintf_plus(stderr,
504
import_status->status & GPGME_IMPORT_NEW
505
? "The key was new.\n"
506
: "The key was not new.\n");
507
fprintf_plus(stderr,
508
import_status->status & GPGME_IMPORT_UID
509
? "The key contained new user IDs.\n"
510
: "The key did not contain new user IDs.\n");
511
fprintf_plus(stderr,
512
import_status->status & GPGME_IMPORT_SIG
513
? "The key contained new signatures.\n"
514
: "The key did not contain new signatures.\n");
515
fprintf_plus(stderr,
516
import_status->status & GPGME_IMPORT_SUBKEY
517
? "The key contained new sub keys.\n"
518
: "The key did not contain new sub keys.\n");
519
fprintf_plus(stderr,
520
import_status->status & GPGME_IMPORT_SECRET
521
? "The key contained a secret key.\n"
522
: "The key did not contain a secret key.\n");
523
}
524
return false;
525
}
526
}
297
527
298
ret = (int)TEMP_FAILURE_RETRY(close(fd));
528
ret = close(fd);
299
529
if(ret == -1){
300
530
perror_plus("close");
301
531
}
340
570
/* Create new GPGME "context" */
341
571
rc = gpgme_new(&(mc->ctx));
342
572
if(rc != GPG_ERR_NO_ERROR){
343
fprintf_plus(stderr, "Mandos plugin mandos-client: "
344
"bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
345
gpgme_strerror(rc));
573
fprintf_plus(stderr, "bad gpgme_new: %s: %s\n",
574
gpgme_strsource(rc), gpgme_strerror(rc));
346
575
return false;
347
576
}
348
577
384
613
/* Create new empty GPGME data buffer for the plaintext */
385
614
rc = gpgme_data_new(&dh_plain);
386
615
if(rc != GPG_ERR_NO_ERROR){
387
fprintf_plus(stderr, "Mandos plugin mandos-client: "
388
"bad gpgme_data_new: %s: %s\n",
616
fprintf_plus(stderr, "bad gpgme_data_new: %s: %s\n",
389
617
gpgme_strsource(rc), gpgme_strerror(rc));
390
618
gpgme_data_release(dh_crypto);
391
619
return -1;
404
632
if(result == NULL){
405
633
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
406
634
} else {
407
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
408
result->unsupported_algorithm);
409
fprintf_plus(stderr, "Wrong key usage: %u\n",
410
result->wrong_key_usage);
635
if(result->unsupported_algorithm != NULL) {
636
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
637
result->unsupported_algorithm);
638
}
639
fprintf_plus(stderr, "Wrong key usage: %s\n",
640
result->wrong_key_usage ? "Yes" : "No");
411
641
if(result->file_name != NULL){
412
642
fprintf_plus(stderr, "File name: %s\n", result->file_name);
413
643
}
414
gpgme_recipient_t recipient;
415
recipient = result->recipients;
416
while(recipient != NULL){
644
645
for(gpgme_recipient_t r = result->recipients; r != NULL;
646
r = r->next){
417
647
fprintf_plus(stderr, "Public key algorithm: %s\n",
418
gpgme_pubkey_algo_name
419
(recipient->pubkey_algo));
420
fprintf_plus(stderr, "Key ID: %s\n", recipient->keyid);
648
gpgme_pubkey_algo_name(r->pubkey_algo));
649
fprintf_plus(stderr, "Key ID: %s\n", r->keyid);
421
650
fprintf_plus(stderr, "Secret key available: %s\n",
422
recipient->status == GPG_ERR_NO_SECKEY
423
? "No" : "Yes");
424
recipient = recipient->next;
651
r->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
425
652
}
426
653
}
427
654
}
483
710
return plaintext_length;
484
711
}
485
712
713
__attribute__((warn_unused_result, const))
714
static const char *safe_string(const char *str){
715
if(str == NULL)
716
return "(unknown)";
717
return str;
718
}
719
486
720
__attribute__((warn_unused_result))
487
721
static const char *safer_gnutls_strerror(int value){
488
722
const char *ret = gnutls_strerror(value);
489
if(ret == NULL)
490
ret = "(unknown)";
491
return ret;
723
return safe_string(ret);
492
724
}
493
725
494
726
/* GnuTLS log function callback */
498
730
fprintf_plus(stderr, "GnuTLS: %s", string);
499
731
}
500
732
501
__attribute__((nonnull, warn_unused_result))
733
__attribute__((nonnull(1, 2, 4), warn_unused_result))
502
734
static int init_gnutls_global(const char *pubkeyfilename,
503
735
const char *seckeyfilename,
736
const char *dhparamsfilename,
504
737
mandos_context *mc){
505
738
int ret;
506
739
508
741
fprintf_plus(stderr, "Initializing GnuTLS\n");
509
742
}
510
743
511
ret = gnutls_global_init();
512
if(ret != GNUTLS_E_SUCCESS){
513
fprintf_plus(stderr, "GnuTLS global_init: %s\n",
514
safer_gnutls_strerror(ret));
515
return -1;
516
}
517
518
744
if(debug){
519
745
/* "Use a log level over 10 to enable all debugging options."
520
746
* - GnuTLS manual
528
754
if(ret != GNUTLS_E_SUCCESS){
529
755
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
530
756
safer_gnutls_strerror(ret));
531
gnutls_global_deinit();
532
757
return -1;
533
758
}
534
759
535
760
if(debug){
536
fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
537
" secret key %s as GnuTLS credentials\n",
761
fprintf_plus(stderr, "Attempting to use public key %s and"
762
" private key %s as GnuTLS credentials\n",
538
763
pubkeyfilename,
539
764
seckeyfilename);
540
765
}
541
766
767
#if GNUTLS_VERSION_NUMBER >= 0x030606
768
ret = gnutls_certificate_set_rawpk_key_file
769
(mc->cred, pubkeyfilename, seckeyfilename,
770
GNUTLS_X509_FMT_PEM, /* format */
771
NULL, /* pass */
772
/* key_usage */
773
GNUTLS_KEY_DIGITAL_SIGNATURE | GNUTLS_KEY_KEY_ENCIPHERMENT,
774
NULL, /* names */
775
0, /* names_length */
776
/* privkey_flags */
777
GNUTLS_PKCS_PLAIN | GNUTLS_PKCS_NULL_PASSWORD,
778
0); /* pkcs11_flags */
779
#elif GNUTLS_VERSION_NUMBER < 0x030600
542
780
ret = gnutls_certificate_set_openpgp_key_file
543
781
(mc->cred, pubkeyfilename, seckeyfilename,
544
782
GNUTLS_OPENPGP_FMT_BASE64);
783
#else
784
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
785
#endif
545
786
if(ret != GNUTLS_E_SUCCESS){
546
787
fprintf_plus(stderr,
547
"Error[%d] while reading the OpenPGP key pair ('%s',"
788
"Error[%d] while reading the key pair ('%s',"
548
789
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
549
790
fprintf_plus(stderr, "The GnuTLS error is: %s\n",
550
791
safer_gnutls_strerror(ret));
559
800
safer_gnutls_strerror(ret));
560
801
goto globalfail;
561
802
}
562
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
563
if(ret != GNUTLS_E_SUCCESS){
564
fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
565
safer_gnutls_strerror(ret));
566
goto globalfail;
567
}
568
569
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
803
/* If a Diffie-Hellman parameters file was given, try to use it */
804
if(dhparamsfilename != NULL){
805
gnutls_datum_t params = { .data = NULL, .size = 0 };
806
do {
807
int dhpfile = open(dhparamsfilename, O_RDONLY);
808
if(dhpfile == -1){
809
perror_plus("open");
810
dhparamsfilename = NULL;
811
break;
812
}
813
size_t params_capacity = 0;
814
while(true){
815
params_capacity = incbuffer((char **)¶ms.data,
816
(size_t)params.size,
817
(size_t)params_capacity);
818
if(params_capacity == 0){
819
perror_plus("incbuffer");
820
free(params.data);
821
params.data = NULL;
822
dhparamsfilename = NULL;
823
break;
824
}
825
ssize_t bytes_read = read(dhpfile,
826
params.data + params.size,
827
BUFFER_SIZE);
828
/* EOF */
829
if(bytes_read == 0){
830
break;
831
}
832
/* check bytes_read for failure */
833
if(bytes_read < 0){
834
perror_plus("read");
835
free(params.data);
836
params.data = NULL;
837
dhparamsfilename = NULL;
838
break;
839
}
840
params.size += (unsigned int)bytes_read;
841
}
842
ret = close(dhpfile);
843
if(ret == -1){
844
perror_plus("close");
845
}
846
if(params.data == NULL){
847
dhparamsfilename = NULL;
848
}
849
if(dhparamsfilename == NULL){
850
break;
851
}
852
ret = gnutls_dh_params_import_pkcs3(mc->dh_params, ¶ms,
853
GNUTLS_X509_FMT_PEM);
854
if(ret != GNUTLS_E_SUCCESS){
855
fprintf_plus(stderr, "Failed to parse DH parameters in file"
856
" \"%s\": %s\n", dhparamsfilename,
857
safer_gnutls_strerror(ret));
858
dhparamsfilename = NULL;
859
}
860
free(params.data);
861
} while(false);
862
}
863
if(dhparamsfilename == NULL){
864
if(mc->dh_bits == 0){
865
#if GNUTLS_VERSION_NUMBER < 0x030600
866
/* Find out the optimal number of DH bits */
867
/* Try to read the private key file */
868
gnutls_datum_t buffer = { .data = NULL, .size = 0 };
869
do {
870
int secfile = open(seckeyfilename, O_RDONLY);
871
if(secfile == -1){
872
perror_plus("open");
873
break;
874
}
875
size_t buffer_capacity = 0;
876
while(true){
877
buffer_capacity = incbuffer((char **)&buffer.data,
878
(size_t)buffer.size,
879
(size_t)buffer_capacity);
880
if(buffer_capacity == 0){
881
perror_plus("incbuffer");
882
free(buffer.data);
883
buffer.data = NULL;
884
break;
885
}
886
ssize_t bytes_read = read(secfile,
887
buffer.data + buffer.size,
888
BUFFER_SIZE);
889
/* EOF */
890
if(bytes_read == 0){
891
break;
892
}
893
/* check bytes_read for failure */
894
if(bytes_read < 0){
895
perror_plus("read");
896
free(buffer.data);
897
buffer.data = NULL;
898
break;
899
}
900
buffer.size += (unsigned int)bytes_read;
901
}
902
close(secfile);
903
} while(false);
904
/* If successful, use buffer to parse private key */
905
gnutls_sec_param_t sec_param = GNUTLS_SEC_PARAM_ULTRA;
906
if(buffer.data != NULL){
907
{
908
gnutls_openpgp_privkey_t privkey = NULL;
909
ret = gnutls_openpgp_privkey_init(&privkey);
910
if(ret != GNUTLS_E_SUCCESS){
911
fprintf_plus(stderr, "Error initializing OpenPGP key"
912
" structure: %s",
913
safer_gnutls_strerror(ret));
914
free(buffer.data);
915
buffer.data = NULL;
916
} else {
917
ret = gnutls_openpgp_privkey_import
918
(privkey, &buffer, GNUTLS_OPENPGP_FMT_BASE64, "", 0);
919
if(ret != GNUTLS_E_SUCCESS){
920
fprintf_plus(stderr, "Error importing OpenPGP key : %s",
921
safer_gnutls_strerror(ret));
922
privkey = NULL;
923
}
924
free(buffer.data);
925
buffer.data = NULL;
926
if(privkey != NULL){
927
/* Use private key to suggest an appropriate
928
sec_param */
929
sec_param = gnutls_openpgp_privkey_sec_param(privkey);
930
gnutls_openpgp_privkey_deinit(privkey);
931
if(debug){
932
fprintf_plus(stderr, "This OpenPGP key implies using"
933
" a GnuTLS security parameter \"%s\".\n",
934
safe_string(gnutls_sec_param_get_name
935
(sec_param)));
936
}
937
}
938
}
939
}
940
if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
941
/* Err on the side of caution */
942
sec_param = GNUTLS_SEC_PARAM_ULTRA;
943
if(debug){
944
fprintf_plus(stderr, "Falling back to security parameter"
945
" \"%s\"\n",
946
safe_string(gnutls_sec_param_get_name
947
(sec_param)));
948
}
949
}
950
}
951
unsigned int uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
952
if(uret != 0){
953
mc->dh_bits = uret;
954
if(debug){
955
fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
956
" implies %u DH bits; using that.\n",
957
safe_string(gnutls_sec_param_get_name
958
(sec_param)),
959
mc->dh_bits);
960
}
961
} else {
962
fprintf_plus(stderr, "Failed to get implied number of DH"
963
" bits for security parameter \"%s\"): %s\n",
964
safe_string(gnutls_sec_param_get_name
965
(sec_param)),
966
safer_gnutls_strerror(ret));
967
goto globalfail;
968
}
969
#endif
970
} else { /* dh_bits != 0 */
971
if(debug){
972
fprintf_plus(stderr, "DH bits explicitly set to %u\n",
973
mc->dh_bits);
974
}
975
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
976
if(ret != GNUTLS_E_SUCCESS){
977
fprintf_plus(stderr, "Error in GnuTLS prime generation (%u"
978
" bits): %s\n", mc->dh_bits,
979
safer_gnutls_strerror(ret));
980
goto globalfail;
981
}
982
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
983
}
984
}
570
985
571
986
return 0;
572
987
573
988
globalfail:
574
989
575
990
gnutls_certificate_free_credentials(mc->cred);
576
gnutls_global_deinit();
577
991
gnutls_dh_params_deinit(mc->dh_params);
578
992
return -1;
579
993
}
584
998
int ret;
585
999
/* GnuTLS session creation */
586
1000
do {
587
ret = gnutls_init(session, GNUTLS_SERVER);
1001
ret = gnutls_init(session, (GNUTLS_SERVER
1002
#if GNUTLS_VERSION_NUMBER >= 0x030506
1003
| GNUTLS_NO_TICKETS
1004
#endif
1005
#if GNUTLS_VERSION_NUMBER >= 0x030606
1006
| GNUTLS_ENABLE_RAWPK
1007
#endif
1008
));
588
1009
if(quit_now){
589
1010
return -1;
590
1011
}
631
1052
/* ignore client certificate if any. */
632
1053
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
633
1054
634
gnutls_dh_set_prime_bits(*session, mc->dh_bits);
635
636
1055
return 0;
637
1056
}
638
1057
640
1059
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
641
1060
__attribute__((unused)) const char *txt){}
642
1061
1062
/* Helper function to add_local_route() and delete_local_route() */
1063
__attribute__((nonnull, warn_unused_result))
1064
static bool add_delete_local_route(const bool add,
1065
const char *address,
1066
AvahiIfIndex if_index){
1067
int ret;
1068
char helper[] = "mandos-client-iprouteadddel";
1069
char add_arg[] = "add";
1070
char delete_arg[] = "delete";
1071
char debug_flag[] = "--debug";
1072
char *pluginhelperdir = getenv("MANDOSPLUGINHELPERDIR");
1073
if(pluginhelperdir == NULL){
1074
if(debug){
1075
fprintf_plus(stderr, "MANDOSPLUGINHELPERDIR environment"
1076
" variable not set; cannot run helper\n");
1077
}
1078
return false;
1079
}
1080
1081
char interface[IF_NAMESIZE];
1082
if(if_indextoname((unsigned int)if_index, interface) == NULL){
1083
perror_plus("if_indextoname");
1084
return false;
1085
}
1086
1087
int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
1088
if(devnull == -1){
1089
perror_plus("open(\"/dev/null\", O_RDONLY)");
1090
return false;
1091
}
1092
pid_t pid = fork();
1093
if(pid == 0){
1094
/* Child */
1095
/* Raise privileges */
1096
errno = raise_privileges_permanently();
1097
if(errno != 0){
1098
perror_plus("Failed to raise privileges");
1099
/* _exit(EX_NOPERM); */
1100
} else {
1101
/* Set group */
1102
errno = 0;
1103
ret = setgid(0);
1104
if(ret == -1){
1105
perror_plus("setgid");
1106
close(devnull);
1107
_exit(EX_NOPERM);
1108
}
1109
/* Reset supplementary groups */
1110
errno = 0;
1111
ret = setgroups(0, NULL);
1112
if(ret == -1){
1113
perror_plus("setgroups");
1114
close(devnull);
1115
_exit(EX_NOPERM);
1116
}
1117
}
1118
ret = dup2(devnull, STDIN_FILENO);
1119
if(ret == -1){
1120
perror_plus("dup2(devnull, STDIN_FILENO)");
1121
close(devnull);
1122
_exit(EX_OSERR);
1123
}
1124
ret = close(devnull);
1125
if(ret == -1){
1126
perror_plus("close");
1127
}
1128
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
1129
if(ret == -1){
1130
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
1131
_exit(EX_OSERR);
1132
}
1133
int helperdir_fd = (int)TEMP_FAILURE_RETRY(open(pluginhelperdir,
1134
O_RDONLY
1135
| O_DIRECTORY
1136
| O_PATH
1137
| O_CLOEXEC));
1138
if(helperdir_fd == -1){
1139
perror_plus("open");
1140
_exit(EX_UNAVAILABLE);
1141
}
1142
int helper_fd = (int)TEMP_FAILURE_RETRY(openat(helperdir_fd,
1143
helper, O_RDONLY));
1144
if(helper_fd == -1){
1145
perror_plus("openat");
1146
close(helperdir_fd);
1147
_exit(EX_UNAVAILABLE);
1148
}
1149
close(helperdir_fd);
1150
#ifdef __GNUC__
1151
#pragma GCC diagnostic push
1152
#pragma GCC diagnostic ignored "-Wcast-qual"
1153
#endif
1154
if(fexecve(helper_fd, (char *const [])
1155
{ helper, add ? add_arg : delete_arg, (char *)address,
1156
interface, debug ? debug_flag : NULL, NULL },
1157
environ) == -1){
1158
#ifdef __GNUC__
1159
#pragma GCC diagnostic pop
1160
#endif
1161
perror_plus("fexecve");
1162
_exit(EXIT_FAILURE);
1163
}
1164
}
1165
if(pid == -1){
1166
perror_plus("fork");
1167
close(devnull);
1168
return false;
1169
}
1170
ret = close(devnull);
1171
if(ret == -1){
1172
perror_plus("close");
1173
}
1174
int status;
1175
pid_t pret = -1;
1176
errno = 0;
1177
do {
1178
pret = waitpid(pid, &status, 0);
1179
if(pret == -1 and errno == EINTR and quit_now){
1180
int errno_raising = 0;
1181
if((errno = raise_privileges()) != 0){
1182
errno_raising = errno;
1183
perror_plus("Failed to raise privileges in order to"
1184
" kill helper program");
1185
}
1186
if(kill(pid, SIGTERM) == -1){
1187
perror_plus("kill");
1188
}
1189
if((errno_raising == 0) and (errno = lower_privileges()) != 0){
1190
perror_plus("Failed to lower privileges after killing"
1191
" helper program");
1192
}
1193
return false;
1194
}
1195
} while(pret == -1 and errno == EINTR);
1196
if(pret == -1){
1197
perror_plus("waitpid");
1198
return false;
1199
}
1200
if(WIFEXITED(status)){
1201
if(WEXITSTATUS(status) != 0){
1202
fprintf_plus(stderr, "Error: iprouteadddel exited"
1203
" with status %d\n", WEXITSTATUS(status));
1204
return false;
1205
}
1206
return true;
1207
}
1208
if(WIFSIGNALED(status)){
1209
fprintf_plus(stderr, "Error: iprouteadddel died by"
1210
" signal %d\n", WTERMSIG(status));
1211
return false;
1212
}
1213
fprintf_plus(stderr, "Error: iprouteadddel crashed\n");
1214
return false;
1215
}
1216
1217
__attribute__((nonnull, warn_unused_result))
1218
static bool add_local_route(const char *address,
1219
AvahiIfIndex if_index){
1220
if(debug){
1221
fprintf_plus(stderr, "Adding route to %s\n", address);
1222
}
1223
return add_delete_local_route(true, address, if_index);
1224
}
1225
1226
__attribute__((nonnull, warn_unused_result))
1227
static bool delete_local_route(const char *address,
1228
AvahiIfIndex if_index){
1229
if(debug){
1230
fprintf_plus(stderr, "Removing route to %s\n", address);
1231
}
1232
return add_delete_local_route(false, address, if_index);
1233
}
1234
643
1235
/* Called when a Mandos server is found */
644
1236
__attribute__((nonnull, warn_unused_result))
645
1237
static int start_mandos_communication(const char *ip, in_port_t port,
656
1248
int retval = -1;
657
1249
gnutls_session_t session;
658
1250
int pf; /* Protocol family */
1251
bool route_added = false;
659
1252
660
1253
errno = 0;
661
1254
683
1276
bool match = false;
684
1277
{
685
1278
char *interface = NULL;
686
while((interface=argz_next(mc->interfaces, mc->interfaces_size,
687
interface))){
1279
while((interface = argz_next(mc->interfaces,
1280
mc->interfaces_size,
1281
interface))){
688
1282
if(if_nametoindex(interface) == (unsigned int)if_index){
689
1283
match = true;
690
1284
break;
719
1313
PRIuMAX "\n", ip, (uintmax_t)port);
720
1314
}
721
1315
722
tcp_sd = socket(pf, SOCK_STREAM, 0);
1316
tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
723
1317
if(tcp_sd < 0){
724
1318
int e = errno;
725
1319
perror_plus("socket");
732
1326
goto mandos_end;
733
1327
}
734
1328
735
memset(&to, 0, sizeof(to));
736
1329
if(af == AF_INET6){
737
((struct sockaddr_in6 *)&to)->sin6_family = (sa_family_t)af;
738
ret = inet_pton(af, ip, &((struct sockaddr_in6 *)&to)->sin6_addr);
1330
struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)&to;
1331
*to6 = (struct sockaddr_in6){ .sin6_family = (sa_family_t)af };
1332
ret = inet_pton(af, ip, &to6->sin6_addr);
739
1333
} else { /* IPv4 */
740
((struct sockaddr_in *)&to)->sin_family = (sa_family_t)af;
741
ret = inet_pton(af, ip, &((struct sockaddr_in *)&to)->sin_addr);
1334
struct sockaddr_in *to4 = (struct sockaddr_in *)&to;
1335
*to4 = (struct sockaddr_in){ .sin_family = (sa_family_t)af };
1336
ret = inet_pton(af, ip, &to4->sin_addr);
742
1337
}
743
1338
if(ret < 0 ){
744
1339
int e = errno;
814
1409
goto mandos_end;
815
1410
}
816
1411
817
if(af == AF_INET6){
818
ret = connect(tcp_sd, (struct sockaddr *)&to,
819
sizeof(struct sockaddr_in6));
820
} else {
821
ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
822
sizeof(struct sockaddr_in));
823
}
824
if(ret < 0){
825
if((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
826
int e = errno;
827
perror_plus("connect");
828
errno = e;
829
}
830
goto mandos_end;
831
}
832
833
if(quit_now){
834
errno = EINTR;
835
goto mandos_end;
1412
while(true){
1413
if(af == AF_INET6){
1414
ret = connect(tcp_sd, (struct sockaddr *)&to,
1415
sizeof(struct sockaddr_in6));
1416
} else {
1417
ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
1418
sizeof(struct sockaddr_in));
1419
}
1420
if(ret < 0){
1421
if(((errno == ENETUNREACH) or (errno == EHOSTUNREACH))
1422
and if_index != AVAHI_IF_UNSPEC
1423
and connect_to == NULL
1424
and not route_added and
1425
((af == AF_INET6 and not
1426
IN6_IS_ADDR_LINKLOCAL(&(((struct sockaddr_in6 *)
1427
&to)->sin6_addr)))
1428
or (af == AF_INET and
1429
/* Not a a IPv4LL address */
1430
(ntohl(((struct sockaddr_in *)&to)->sin_addr.s_addr)
1431
& 0xFFFF0000L) != 0xA9FE0000L))){
1432
/* Work around Avahi bug - Avahi does not announce link-local
1433
addresses if it has a global address, so local hosts with
1434
*only* a link-local address (e.g. Mandos clients) cannot
1435
connect to a Mandos server announced by Avahi on a server
1436
host with a global address. Work around this by retrying
1437
with an explicit route added with the server's address.
1438
1439
Avahi bug reference:
1440
https://lists.freedesktop.org/archives/avahi/2010-February/001833.html
1441
https://bugs.debian.org/587961
1442
*/
1443
if(debug){
1444
fprintf_plus(stderr, "Mandos server unreachable, trying"
1445
" direct route\n");
1446
}
1447
int e = errno;
1448
route_added = add_local_route(ip, if_index);
1449
if(route_added){
1450
continue;
1451
}
1452
errno = e;
1453
}
1454
if(errno != ECONNREFUSED or debug){
1455
int e = errno;
1456
perror_plus("connect");
1457
errno = e;
1458
}
1459
goto mandos_end;
1460
}
1461
1462
if(quit_now){
1463
errno = EINTR;
1464
goto mandos_end;
1465
}
1466
break;
836
1467
}
837
1468
838
1469
const char *out = mandos_protocol_version;
992
1623
&decrypted_buffer, mc);
993
1624
if(decrypted_buffer_size >= 0){
994
1625
1626
clearerr(stdout);
995
1627
written = 0;
996
1628
while(written < (size_t) decrypted_buffer_size){
997
1629
if(quit_now){
1013
1645
}
1014
1646
written += (size_t)ret;
1015
1647
}
1648
ret = fflush(stdout);
1649
if(ret != 0){
1650
int e = errno;
1651
if(debug){
1652
fprintf_plus(stderr, "Error writing encrypted data: %s\n",
1653
strerror(errno));
1654
}
1655
errno = e;
1656
goto mandos_end;
1657
}
1016
1658
retval = 0;
1017
1659
}
1018
1660
}
1021
1663
1022
1664
mandos_end:
1023
1665
{
1666
if(route_added){
1667
if(not delete_local_route(ip, if_index)){
1668
fprintf_plus(stderr, "Failed to delete local route to %s on"
1669
" interface %d", ip, if_index);
1670
}
1671
}
1024
1672
int e = errno;
1025
1673
free(decrypted_buffer);
1026
1674
free(buffer);
1027
1675
if(tcp_sd >= 0){
1028
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
1676
ret = close(tcp_sd);
1029
1677
}
1030
1678
if(ret == -1){
1031
1679
if(e == 0){
1043
1691
return retval;
1044
1692
}
1045
1693
1046
__attribute__((nonnull))
1047
1694
static void resolve_callback(AvahiSServiceResolver *r,
1048
1695
AvahiIfIndex interface,
1049
1696
AvahiProtocol proto,
1066
1713
timed out */
1067
1714
1068
1715
if(quit_now){
1716
avahi_s_service_resolver_free(r);
1069
1717
return;
1070
1718
}
1071
1719
1185
1833
__attribute__((nonnull, warn_unused_result))
1186
1834
bool get_flags(const char *ifname, struct ifreq *ifr){
1187
1835
int ret;
1188
error_t ret_errno;
1836
int old_errno;
1189
1837
1190
1838
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1191
1839
if(s < 0){
1192
ret_errno = errno;
1840
old_errno = errno;
1193
1841
perror_plus("socket");
1194
errno = ret_errno;
1842
errno = old_errno;
1195
1843
return false;
1196
1844
}
1197
strcpy(ifr->ifr_name, ifname);
1845
strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
1846
ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
1198
1847
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1199
1848
if(ret == -1){
1200
1849
if(debug){
1201
ret_errno = errno;
1850
old_errno = errno;
1202
1851
perror_plus("ioctl SIOCGIFFLAGS");
1203
errno = ret_errno;
1852
errno = old_errno;
1853
}
1854
if((close(s) == -1) and debug){
1855
old_errno = errno;
1856
perror_plus("close");
1857
errno = old_errno;
1204
1858
}
1205
1859
return false;
1206
1860
}
1861
if((close(s) == -1) and debug){
1862
old_errno = errno;
1863
perror_plus("close");
1864
errno = old_errno;
1865
}
1207
1866
return true;
1208
1867
}
1209
1868
1451
2110
}
1452
2111
}
1453
2112
1454
/* Set effective uid to 0, return errno */
1455
__attribute__((warn_unused_result))
1456
error_t raise_privileges(void){
1457
error_t old_errno = errno;
1458
error_t ret_errno = 0;
1459
if(seteuid(0) == -1){
1460
ret_errno = errno;
1461
perror_plus("seteuid");
1462
}
1463
errno = old_errno;
1464
return ret_errno;
1465
}
1466
1467
/* Set effective and real user ID to 0. Return errno. */
1468
__attribute__((warn_unused_result))
1469
error_t raise_privileges_permanently(void){
1470
error_t old_errno = errno;
1471
error_t ret_errno = raise_privileges();
1472
if(ret_errno != 0){
1473
errno = old_errno;
1474
return ret_errno;
1475
}
1476
if(setuid(0) == -1){
1477
ret_errno = errno;
1478
perror_plus("seteuid");
1479
}
1480
errno = old_errno;
1481
return ret_errno;
1482
}
1483
1484
/* Set effective user ID to unprivileged saved user ID */
1485
__attribute__((warn_unused_result))
1486
error_t lower_privileges(void){
1487
error_t old_errno = errno;
1488
error_t ret_errno = 0;
1489
if(seteuid(uid) == -1){
1490
ret_errno = errno;
1491
perror_plus("seteuid");
1492
}
1493
errno = old_errno;
1494
return ret_errno;
1495
}
1496
1497
/* Lower privileges permanently */
1498
__attribute__((warn_unused_result))
1499
error_t lower_privileges_permanently(void){
1500
error_t old_errno = errno;
1501
error_t ret_errno = 0;
1502
if(setuid(uid) == -1){
1503
ret_errno = errno;
1504
perror_plus("setuid");
1505
}
1506
errno = old_errno;
1507
return ret_errno;
1508
}
1509
1510
#ifndef O_CLOEXEC
1511
/*
1512
* Based on the example in the GNU LibC manual chapter 13.13 "File
1513
* Descriptor Flags".
1514
| [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
1515
*/
1516
__attribute__((warn_unused_result))
1517
static int set_cloexec_flag(int fd){
1518
int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
1519
/* If reading the flags failed, return error indication now. */
1520
if(ret < 0){
1521
return ret;
1522
}
1523
/* Store modified flag word in the descriptor. */
1524
return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
1525
ret | FD_CLOEXEC));
1526
}
1527
#endif /* not O_CLOEXEC */
1528
1529
2113
__attribute__((nonnull))
1530
2114
void run_network_hooks(const char *mode, const char *interface,
1531
2115
const float delay){
1532
struct dirent **direntries;
2116
struct dirent **direntries = NULL;
1533
2117
if(hookdir_fd == -1){
1534
hookdir_fd = open(hookdir, O_RDONLY |
1535
#ifdef O_CLOEXEC
1536
O_CLOEXEC
1537
#else /* not O_CLOEXEC */
1538
0
1539
#endif /* not O_CLOEXEC */
1540
);
2118
hookdir_fd = open(hookdir, O_RDONLY | O_DIRECTORY | O_PATH
2119
| O_CLOEXEC);
1541
2120
if(hookdir_fd == -1){
1542
2121
if(errno == ENOENT){
1543
2122
if(debug){
1549
2128
}
1550
2129
return;
1551
2130
}
1552
#ifndef O_CLOEXEC
1553
if(set_cloexec_flag(hookdir_fd) < 0){
1554
perror_plus("set_cloexec_flag");
1555
if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
1556
perror_plus("close");
1557
} else {
1558
hookdir_fd = -1;
1559
}
1560
return;
1561
}
1562
#endif /* not O_CLOEXEC */
1563
}
1564
#ifdef __GLIBC__
1565
#if __GLIBC_PREREQ(2, 15)
2131
}
2132
int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
2133
if(devnull == -1){
2134
perror_plus("open(\"/dev/null\", O_RDONLY)");
2135
return;
2136
}
1566
2137
int numhooks = scandirat(hookdir_fd, ".", &direntries,
1567
2138
runnable_hook, alphasort);
1568
#else /* not __GLIBC_PREREQ(2, 15) */
1569
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1570
alphasort);
1571
#endif /* not __GLIBC_PREREQ(2, 15) */
1572
#else /* not __GLIBC__ */
1573
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1574
alphasort);
1575
#endif /* not __GLIBC__ */
1576
2139
if(numhooks == -1){
1577
2140
perror_plus("scandir");
2141
close(devnull);
1578
2142
return;
1579
2143
}
1580
2144
struct dirent *direntry;
1581
2145
int ret;
1582
int devnull = open("/dev/null", O_RDONLY);
1583
2146
for(int i = 0; i < numhooks; i++){
1584
2147
direntry = direntries[i];
1585
2148
if(debug){
1590
2153
if(hook_pid == 0){
1591
2154
/* Child */
1592
2155
/* Raise privileges */
1593
if(raise_privileges_permanently() != 0){
2156
errno = raise_privileges_permanently();
2157
if(errno != 0){
1594
2158
perror_plus("Failed to raise privileges");
1595
2159
_exit(EX_NOPERM);
1596
2160
}
1608
2172
perror_plus("setgroups");
1609
2173
_exit(EX_NOPERM);
1610
2174
}
1611
ret = dup2(devnull, STDIN_FILENO);
1612
if(ret == -1){
1613
perror_plus("dup2(devnull, STDIN_FILENO)");
1614
_exit(EX_OSERR);
1615
}
1616
ret = close(devnull);
1617
if(ret == -1){
1618
perror_plus("close");
1619
_exit(EX_OSERR);
1620
}
1621
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
1622
if(ret == -1){
1623
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
1624
_exit(EX_OSERR);
1625
}
1626
2175
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1627
2176
if(ret == -1){
1628
2177
perror_plus("setenv");
1663
2212
_exit(EX_OSERR);
1664
2213
}
1665
2214
}
1666
if(fexecve(hookdir_fd, (char *const [])
1667
{ direntry->d_name, NULL }, environ) == -1){
2215
int hook_fd = (int)TEMP_FAILURE_RETRY(openat(hookdir_fd,
2216
direntry->d_name,
2217
O_RDONLY));
2218
if(hook_fd == -1){
2219
perror_plus("openat");
2220
_exit(EXIT_FAILURE);
2221
}
2222
if(close(hookdir_fd) == -1){
2223
perror_plus("close");
2224
_exit(EXIT_FAILURE);
2225
}
2226
ret = dup2(devnull, STDIN_FILENO);
2227
if(ret == -1){
2228
perror_plus("dup2(devnull, STDIN_FILENO)");
2229
_exit(EX_OSERR);
2230
}
2231
ret = close(devnull);
2232
if(ret == -1){
2233
perror_plus("close");
2234
_exit(EX_OSERR);
2235
}
2236
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
2237
if(ret == -1){
2238
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
2239
_exit(EX_OSERR);
2240
}
2241
if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
2242
environ) == -1){
1668
2243
perror_plus("fexecve");
1669
2244
_exit(EXIT_FAILURE);
1670
2245
}
1671
2246
} else {
2247
if(hook_pid == -1){
2248
perror_plus("fork");
2249
free(direntry);
2250
continue;
2251
}
1672
2252
int status;
1673
2253
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1674
2254
perror_plus("waitpid");
2255
free(direntry);
1675
2256
continue;
1676
2257
}
1677
2258
if(WIFEXITED(status)){
1679
2260
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1680
2261
" with status %d\n", direntry->d_name,
1681
2262
WEXITSTATUS(status));
2263
free(direntry);
1682
2264
continue;
1683
2265
}
1684
2266
} else if(WIFSIGNALED(status)){
1685
2267
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1686
2268
" signal %d\n", direntry->d_name,
1687
2269
WTERMSIG(status));
2270
free(direntry);
1688
2271
continue;
1689
2272
} else {
1690
2273
fprintf_plus(stderr, "Warning: network hook \"%s\""
1691
2274
" crashed\n", direntry->d_name);
2275
free(direntry);
1692
2276
continue;
1693
2277
}
1694
2278
}
1696
2280
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1697
2281
direntry->d_name);
1698
2282
}
2283
free(direntry);
1699
2284
}
1700
if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
2285
free(direntries);
2286
if(close(hookdir_fd) == -1){
1701
2287
perror_plus("close");
1702
2288
} else {
1703
2289
hookdir_fd = -1;
1706
2292
}
1707
2293
1708
2294
__attribute__((nonnull, warn_unused_result))
1709
error_t bring_up_interface(const char *const interface,
1710
const float delay){
1711
error_t old_errno = errno;
2295
int bring_up_interface(const char *const interface,
2296
const float delay){
2297
int old_errno = errno;
1712
2298
int ret;
1713
2299
struct ifreq network;
1714
2300
unsigned int if_index = if_nametoindex(interface);
1724
2310
}
1725
2311
1726
2312
if(not interface_is_up(interface)){
1727
error_t ret_errno = 0, ioctl_errno = 0;
2313
int ret_errno = 0;
2314
int ioctl_errno = 0;
1728
2315
if(not get_flags(interface, &network)){
1729
2316
ret_errno = errno;
1730
2317
fprintf_plus(stderr, "Failed to get flags for interface "
1743
2330
}
1744
2331
1745
2332
if(quit_now){
1746
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2333
ret = close(sd);
1747
2334
if(ret == -1){
1748
2335
perror_plus("close");
1749
2336
}
1759
2346
/* Raise privileges */
1760
2347
ret_errno = raise_privileges();
1761
2348
if(ret_errno != 0){
2349
errno = ret_errno;
1762
2350
perror_plus("Failed to raise privileges");
1763
2351
}
1764
2352
1798
2386
}
1799
2387
1800
2388
/* Close the socket */
1801
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2389
ret = close(sd);
1802
2390
if(ret == -1){
1803
2391
perror_plus("close");
1804
2392
}
1816
2404
1817
2405
/* Sleep checking until interface is running.
1818
2406
Check every 0.25s, up to total time of delay */
1819
for(int i=0; i < delay * 4; i++){
2407
for(int i = 0; i < delay * 4; i++){
1820
2408
if(interface_is_running(interface)){
1821
2409
break;
1822
2410
}
1832
2420
}
1833
2421
1834
2422
__attribute__((nonnull, warn_unused_result))
1835
error_t take_down_interface(const char *const interface){
1836
error_t old_errno = errno;
2423
int take_down_interface(const char *const interface){
2424
int old_errno = errno;
1837
2425
struct ifreq network;
1838
2426
unsigned int if_index = if_nametoindex(interface);
1839
2427
if(if_index == 0){
1842
2430
return ENXIO;
1843
2431
}
1844
2432
if(interface_is_up(interface)){
1845
error_t ret_errno = 0, ioctl_errno = 0;
2433
int ret_errno = 0;
2434
int ioctl_errno = 0;
1846
2435
if(not get_flags(interface, &network) and debug){
1847
2436
ret_errno = errno;
1848
2437
fprintf_plus(stderr, "Failed to get flags for interface "
1868
2457
/* Raise privileges */
1869
2458
ret_errno = raise_privileges();
1870
2459
if(ret_errno != 0){
2460
errno = ret_errno;
1871
2461
perror_plus("Failed to raise privileges");
1872
2462
}
1873
2463
1885
2475
}
1886
2476
1887
2477
/* Close the socket */
1888
int ret = (int)TEMP_FAILURE_RETRY(close(sd));
2478
int ret = close(sd);
1889
2479
if(ret == -1){
1890
2480
perror_plus("close");
1891
2481
}
1906
2496
}
1907
2497
1908
2498
int main(int argc, char *argv[]){
1909
mandos_context mc = { .server = NULL, .dh_bits = 1024,
1910
.priority = "SECURE256:!CTYPE-X.509:"
1911
"+CTYPE-OPENPGP", .current_server = NULL,
1912
.interfaces = NULL, .interfaces_size = 0 };
2499
mandos_context mc = { .server = NULL, .dh_bits = 0,
2500
#if GNUTLS_VERSION_NUMBER >= 0x030606
2501
.priority = "SECURE128:!CTYPE-X.509"
2502
":+CTYPE-RAWPK:!RSA:!VERS-ALL:+VERS-TLS1.3"
2503
":%PROFILE_ULTRA",
2504
#elif GNUTLS_VERSION_NUMBER < 0x030600
2505
.priority = "SECURE256:!CTYPE-X.509"
2506
":+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256",
2507
#else
2508
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
2509
#endif
2510
.current_server = NULL, .interfaces = NULL,
2511
.interfaces_size = 0 };
1913
2512
AvahiSServiceBrowser *sb = NULL;
1914
2513
error_t ret_errno;
1915
2514
int ret;
1924
2523
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1925
2524
const char *seckey = PATHDIR "/" SECKEY;
1926
2525
const char *pubkey = PATHDIR "/" PUBKEY;
2526
#if GNUTLS_VERSION_NUMBER >= 0x030606
2527
const char *tls_privkey = PATHDIR "/" TLS_PRIVKEY;
2528
const char *tls_pubkey = PATHDIR "/" TLS_PUBKEY;
2529
#endif
2530
const char *dh_params_file = NULL;
1927
2531
char *interfaces_hooks = NULL;
1928
2532
1929
2533
bool gnutls_initialized = false;
1976
2580
{ .name = "pubkey", .key = 'p',
1977
2581
.arg = "FILE",
1978
2582
.doc = "OpenPGP public key file base name",
1979
.group = 2 },
2583
.group = 1 },
2584
{ .name = "tls-privkey", .key = 't',
2585
.arg = "FILE",
2586
#if GNUTLS_VERSION_NUMBER >= 0x030606
2587
.doc = "TLS private key file base name",
2588
#else
2589
.doc = "Dummy; ignored (requires GnuTLS 3.6.6)",
2590
#endif
2591
.group = 1 },
2592
{ .name = "tls-pubkey", .key = 'T',
2593
.arg = "FILE",
2594
#if GNUTLS_VERSION_NUMBER >= 0x030606
2595
.doc = "TLS public key file base name",
2596
#else
2597
.doc = "Dummy; ignored (requires GnuTLS 3.6.6)",
2598
#endif
2599
.group = 1 },
1980
2600
{ .name = "dh-bits", .key = 129,
1981
2601
.arg = "BITS",
1982
2602
.doc = "Bit length of the prime number used in the"
1983
2603
" Diffie-Hellman key exchange",
1984
2604
.group = 2 },
2605
{ .name = "dh-params", .key = 134,
2606
.arg = "FILE",
2607
.doc = "PEM-encoded PKCS#3 file with pre-generated parameters"
2608
" for the Diffie-Hellman key exchange",
2609
.group = 2 },
1985
2610
{ .name = "priority", .key = 130,
1986
2611
.arg = "STRING",
1987
2612
.doc = "GnuTLS priority string for the TLS handshake",
2033
2658
case 'p': /* --pubkey */
2034
2659
pubkey = arg;
2035
2660
break;
2661
case 't': /* --tls-privkey */
2662
#if GNUTLS_VERSION_NUMBER >= 0x030606
2663
tls_privkey = arg;
2664
#endif
2665
break;
2666
case 'T': /* --tls-pubkey */
2667
#if GNUTLS_VERSION_NUMBER >= 0x030606
2668
tls_pubkey = arg;
2669
#endif
2670
break;
2036
2671
case 129: /* --dh-bits */
2037
2672
errno = 0;
2038
2673
tmpmax = strtoimax(arg, &tmp, 10);
2042
2677
}
2043
2678
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
2044
2679
break;
2680
case 134: /* --dh-params */
2681
dh_params_file = arg;
2682
break;
2045
2683
case 130: /* --priority */
2046
2684
mc.priority = arg;
2047
2685
break;
2070
2708
argp_state_help(state, state->out_stream,
2071
2709
(ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
2072
2710
& ~(unsigned int)ARGP_HELP_EXIT_OK);
2711
__builtin_unreachable();
2073
2712
case -3: /* --usage */
2074
2713
argp_state_help(state, state->out_stream,
2075
2714
ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
2715
__builtin_unreachable();
2076
2716
case 'V': /* --version */
2077
2717
fprintf_plus(state->out_stream, "%s\n", argp_program_version);
2078
2718
exit(argp_err_exit_status);
2087
2727
.args_doc = "",
2088
2728
.doc = "Mandos client -- Get and decrypt"
2089
2729
" passwords from a Mandos server" };
2090
ret = argp_parse(&argp, argc, argv,
2091
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2092
switch(ret){
2730
ret_errno = argp_parse(&argp, argc, argv,
2731
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2732
switch(ret_errno){
2093
2733
case 0:
2094
2734
break;
2095
2735
case ENOMEM:
2096
2736
default:
2097
errno = ret;
2737
errno = ret_errno;
2098
2738
perror_plus("argp_parse");
2099
2739
exitcode = EX_OSERR;
2100
2740
goto end;
2103
2743
goto end;
2104
2744
}
2105
2745
}
2106
2746
2107
2747
{
2108
/* Work around Debian bug #633582:
2109
<http://bugs.debian.org/633582> */
2110
2111
2748
/* Re-raise privileges */
2112
ret_errno = raise_privileges();
2113
if(ret_errno != 0){
2114
errno = ret_errno;
2749
ret = raise_privileges();
2750
if(ret != 0){
2751
errno = ret;
2115
2752
perror_plus("Failed to raise privileges");
2116
2753
} else {
2117
2754
struct stat st;
2118
2755
2756
/* Work around Debian bug #633582:
2757
<https://bugs.debian.org/633582> */
2758
2119
2759
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
2120
2760
int seckey_fd = open(seckey, O_RDONLY);
2121
2761
if(seckey_fd == -1){
2133
2773
}
2134
2774
}
2135
2775
}
2136
TEMP_FAILURE_RETRY(close(seckey_fd));
2776
close(seckey_fd);
2137
2777
}
2138
2778
}
2139
2779
2140
2780
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2141
2781
int pubkey_fd = open(pubkey, O_RDONLY);
2142
2782
if(pubkey_fd == -1){
2154
2794
}
2155
2795
}
2156
2796
}
2157
TEMP_FAILURE_RETRY(close(pubkey_fd));
2158
}
2159
}
2160
2797
close(pubkey_fd);
2798
}
2799
}
2800
2801
if(dh_params_file != NULL
2802
and strcmp(dh_params_file, PATHDIR "/dhparams.pem" ) == 0){
2803
int dhparams_fd = open(dh_params_file, O_RDONLY);
2804
if(dhparams_fd == -1){
2805
perror_plus("open");
2806
} else {
2807
ret = (int)TEMP_FAILURE_RETRY(fstat(dhparams_fd, &st));
2808
if(ret == -1){
2809
perror_plus("fstat");
2810
} else {
2811
if(S_ISREG(st.st_mode)
2812
and st.st_uid == 0 and st.st_gid == 0){
2813
ret = fchown(dhparams_fd, uid, gid);
2814
if(ret == -1){
2815
perror_plus("fchown");
2816
}
2817
}
2818
}
2819
close(dhparams_fd);
2820
}
2821
}
2822
2823
/* Work around Debian bug #981302
2824
<https://bugs.debian.org/981302> */
2825
if(lstat("/dev/fd", &st) != 0 and errno == ENOENT){
2826
ret = symlink("/proc/self/fd", "/dev/fd");
2827
if(ret == -1){
2828
perror_plus("Failed to create /dev/fd symlink");
2829
}
2830
}
2831
2161
2832
/* Lower privileges */
2162
ret_errno = lower_privileges();
2163
if(ret_errno != 0){
2164
errno = ret_errno;
2833
ret = lower_privileges();
2834
if(ret != 0){
2835
errno = ret;
2165
2836
perror_plus("Failed to lower privileges");
2166
2837
}
2167
2838
}
2280
2951
2281
2952
/* If no interfaces were specified, make a list */
2282
2953
if(mc.interfaces == NULL){
2283
struct dirent **direntries;
2954
struct dirent **direntries = NULL;
2284
2955
/* Look for any good interfaces */
2285
2956
ret = scandir(sys_class_net, &direntries, good_interface,
2286
2957
alphasort);
2292
2963
if(ret_errno != 0){
2293
2964
errno = ret_errno;
2294
2965
perror_plus("argz_add");
2966
free(direntries[i]);
2295
2967
continue;
2296
2968
}
2297
2969
if(debug){
2298
2970
fprintf_plus(stderr, "Will use interface \"%s\"\n",
2299
2971
direntries[i]->d_name);
2300
2972
}
2973
free(direntries[i]);
2301
2974
}
2302
2975
free(direntries);
2303
2976
} else {
2304
free(direntries);
2977
if(ret == 0){
2978
free(direntries);
2979
}
2305
2980
fprintf_plus(stderr, "Could not find a network interface\n");
2306
2981
exitcode = EXIT_FAILURE;
2307
2982
goto end;
2333
3008
errno = bring_up_interface(interface, delay);
2334
3009
if(not interface_was_up){
2335
3010
if(errno != 0){
2336
perror_plus("Failed to bring up interface");
3011
fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
3012
" %s\n", interface, strerror(errno));
2337
3013
} else {
2338
3014
errno = argz_add(&interfaces_to_take_down,
2339
3015
&interfaces_to_take_down_size,
2362
3038
goto end;
2363
3039
}
2364
3040
2365
ret = init_gnutls_global(pubkey, seckey, &mc);
3041
#if GNUTLS_VERSION_NUMBER >= 0x030606
3042
ret = init_gnutls_global(tls_pubkey, tls_privkey, dh_params_file, &mc);
3043
#elif GNUTLS_VERSION_NUMBER < 0x030600
3044
ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
3045
#else
3046
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
3047
#endif
2366
3048
if(ret == -1){
2367
3049
fprintf_plus(stderr, "init_gnutls_global failed\n");
2368
3050
exitcode = EX_UNAVAILABLE;
2490
3172
2491
3173
/* Allocate a new server */
2492
3174
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
2493
&config, NULL, NULL, &ret_errno);
3175
&config, NULL, NULL, &ret);
2494
3176
2495
3177
/* Free the Avahi configuration data */
2496
3178
avahi_server_config_free(&config);
2499
3181
/* Check if creating the Avahi server object succeeded */
2500
3182
if(mc.server == NULL){
2501
3183
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2502
avahi_strerror(ret_errno));
3184
avahi_strerror(ret));
2503
3185
exitcode = EX_UNAVAILABLE;
2504
3186
goto end;
2505
3187
}
2540
3222
end:
2541
3223
2542
3224
if(debug){
2543
fprintf_plus(stderr, "%s exiting\n", argv[0]);
3225
if(signal_received){
3226
fprintf_plus(stderr, "%s exiting due to signal %d: %s\n",
3227
argv[0], signal_received,
3228
strsignal(signal_received));
3229
} else {
3230
fprintf_plus(stderr, "%s exiting\n", argv[0]);
3231
}
2544
3232
}
2545
3233
2546
3234
/* Cleanup things */
2557
3245
2558
3246
if(gnutls_initialized){
2559
3247
gnutls_certificate_free_credentials(mc.cred);
2560
gnutls_global_deinit();
2561
3248
gnutls_dh_params_deinit(mc.dh_params);
2562
3249
}
2563
3250
2571
3258
mc.current_server->prev->next = NULL;
2572
3259
while(mc.current_server != NULL){
2573
3260
server *next = mc.current_server->next;
3261
#ifdef __GNUC__
3262
#pragma GCC diagnostic push
3263
#pragma GCC diagnostic ignored "-Wcast-qual"
3264
#endif
3265
free((char *)(mc.current_server->ip));
3266
#ifdef __GNUC__
3267
#pragma GCC diagnostic pop
3268
#endif
2574
3269
free(mc.current_server);
2575
3270
mc.current_server = next;
2576
3271
}
2578
3273
2579
3274
/* Re-raise privileges */
2580
3275
{
2581
ret_errno = raise_privileges();
2582
if(ret_errno != 0){
3276
ret = raise_privileges();
3277
if(ret != 0){
3278
errno = ret;
2583
3279
perror_plus("Failed to raise privileges");
2584
3280
} else {
2585
3281
2590
3286
/* Take down the network interfaces which were brought up */
2591
3287
{
2592
3288
char *interface = NULL;
2593
while((interface=argz_next(interfaces_to_take_down,
2594
interfaces_to_take_down_size,
2595
interface))){
2596
ret_errno = take_down_interface(interface);
2597
if(ret_errno != 0){
2598
errno = ret_errno;
3289
while((interface = argz_next(interfaces_to_take_down,
3290
interfaces_to_take_down_size,
3291
interface))){
3292
ret = take_down_interface(interface);
3293
if(ret != 0){
3294
errno = ret;
2599
3295
perror_plus("Failed to take down interface");
2600
3296
}
2601
3297
}
2606
3302
}
2607
3303
}
2608
3304
2609
ret_errno = lower_privileges_permanently();
2610
if(ret_errno != 0){
3305
ret = lower_privileges_permanently();
3306
if(ret != 0){
3307
errno = ret;
2611
3308
perror_plus("Failed to lower privileges permanently");
2612
3309
}
2613
3310
}
2615
3312
free(interfaces_to_take_down);
2616
3313
free(interfaces_hooks);
2617
3314
3315
void clean_dir_at(int base, const char * const dirname,
3316
uintmax_t level){
3317
struct dirent **direntries = NULL;
3318
int dret;
3319
int dir_fd = (int)TEMP_FAILURE_RETRY(openat(base, dirname,
3320
O_RDONLY
3321
| O_NOFOLLOW
3322
| O_DIRECTORY
3323
| O_PATH));
3324
if(dir_fd == -1){
3325
perror_plus("open");
3326
return;
3327
}
3328
int numentries = scandirat(dir_fd, ".", &direntries,
3329
notdotentries, alphasort);
3330
if(numentries >= 0){
3331
for(int i = 0; i < numentries; i++){
3332
if(debug){
3333
fprintf_plus(stderr, "Unlinking \"%s/%s\"\n",
3334
dirname, direntries[i]->d_name);
3335
}
3336
dret = unlinkat(dir_fd, direntries[i]->d_name, 0);
3337
if(dret == -1){
3338
if(errno == EISDIR){
3339
dret = unlinkat(dir_fd, direntries[i]->d_name,
3340
AT_REMOVEDIR);
3341
}
3342
if((dret == -1) and (errno == ENOTEMPTY)
3343
and (strcmp(direntries[i]->d_name, "private-keys-v1.d")
3344
== 0) and (level == 0)){
3345
/* Recurse only in this special case */
3346
clean_dir_at(dir_fd, direntries[i]->d_name, level+1);
3347
dret = 0;
3348
}
3349
if((dret == -1) and (errno != ENOENT)){
3350
fprintf_plus(stderr, "unlink(\"%s/%s\"): %s\n", dirname,
3351
direntries[i]->d_name, strerror(errno));
3352
}
3353
}
3354
free(direntries[i]);
3355
}
3356
3357
/* need to clean even if 0 because man page doesn't specify */
3358
free(direntries);
3359
dret = unlinkat(base, dirname, AT_REMOVEDIR);
3360
if(dret == -1 and errno != ENOENT){
3361
perror_plus("rmdir");
3362
}
3363
} else {
3364
perror_plus("scandirat");
3365
}
3366
close(dir_fd);
3367
}
3368
2618
3369
/* Removes the GPGME temp directory and all files inside */
2619
3370
if(tempdir != NULL){
2620
struct dirent **direntries = NULL;
2621
int tempdir_fd = (int)TEMP_FAILURE_RETRY(open(tempdir, O_RDONLY));
2622
if(tempdir_fd == -1){
2623
perror_plus("open");
2624
} else {
2625
int numentries = scandir(tempdir, &direntries, notdotentries,
2626
alphasort);
2627
if(numentries > 0){
2628
for(int i = 0; i < numentries; i++){
2629
ret = unlinkat(tempdir_fd, direntries[i]->d_name, 0);
2630
if(ret == -1){
2631
fprintf_plus(stderr, "unlinkat(open(\"%s\", O_RDONLY),"
2632
" \"%s\", 0): %s\n", tempdir,
2633
direntries[i]->d_name, strerror(errno));
2634
}
2635
}
2636
2637
/* need to clean even if 0 because man page doesn't specify */
2638
free(direntries);
2639
if(numentries == -1){
2640
perror_plus("scandir");
2641
}
2642
ret = rmdir(tempdir);
2643
if(ret == -1 and errno != ENOENT){
2644
perror_plus("rmdir");
2645
}
2646
}
2647
TEMP_FAILURE_RETRY(close(tempdir_fd));
2648
}
3371
clean_dir_at(-1, tempdir, 0);
2649
3372
}
2650
3373
2651
3374
if(quit_now){
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0