To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to plugins.d/mandos-client.c
- browse files at revision 1237
- compare with another revision
- download diff
- download tarball
- view history from revision 1237
- Committer: Teddy Hogeborn
- Date: 2021-02-03 23:10:42 UTC
- 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
- debian/upstream
- dracut-module
- plugin-helpers
- files removed:
- debian/upstream-signing-key.pgp
- 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-2013 Teddy Hogeborn
13
* Copyright © 2008-2013 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
*/
32
33
/* Needed by GPGME, specifically gpgme_data_seek() */
33
34
#ifndef _LARGEFILE_SOURCE
34
35
#define _LARGEFILE_SOURCE
35
#endif
36
#endif /* not _LARGEFILE_SOURCE */
36
37
#ifndef _FILE_OFFSET_BITS
37
38
#define _FILE_OFFSET_BITS 64
38
#endif
39
40
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
41
42
#include <stdio.h> /* fprintf(), stderr, fwrite(),
43
stdout, ferror(), remove() */
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() */
39
#endif /* not _FILE_OFFSET_BITS */
40
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
#include <fcntl.h> /* open() */
60
#include <dirent.h> /* opendir(), struct dirent, readdir()
61
*/
62
#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,
63
129
strtoimax() */
64
#include <errno.h> /* perror(), errno,
65
program_invocation_short_name */
66
#include <time.h> /* nanosleep(), time(), sleep() */
67
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
68
SIOCSIFFLAGS, if_indextoname(),
69
if_nametoindex(), IF_NAMESIZE */
70
#include <netinet/in.h> /* IN6_IS_ADDR_LINKLOCAL,
71
INET_ADDRSTRLEN, INET6_ADDRSTRLEN
72
*/
73
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
74
getuid(), getgid(), seteuid(),
75
setgid(), pause(), _exit() */
76
#include <arpa/inet.h> /* inet_pton(), htons, inet_ntop() */
77
#include <iso646.h> /* not, or, and */
78
#include <argp.h> /* struct argp_option, error_t, struct
79
argp_state, struct argp,
80
argp_parse(), ARGP_KEY_ARG,
81
ARGP_KEY_END, ARGP_ERR_UNKNOWN */
82
#include <signal.h> /* sigemptyset(), sigaddset(),
83
sigaction(), SIGTERM, sig_atomic_t,
84
raise() */
85
#include <sysexits.h> /* EX_OSERR, EX_USAGE, EX_UNAVAILABLE,
86
EX_NOHOST, EX_IOERR, EX_PROTOCOL */
87
#include <sys/wait.h> /* waitpid(), WIFEXITED(),
88
WEXITSTATUS(), WTERMSIG() */
89
#include <grp.h> /* setgroups() */
90
#include <argz.h> /* argz_add_sep(), argz_next(),
91
argz_delete(), argz_append(),
92
argz_stringify(), argz_add(),
93
argz_count() */
130
#include <arpa/inet.h> /* inet_pton() */
131
#include <stdint.h> /* uint32_t, intptr_t, uint16_t */
132
#include <netdb.h> /* getnameinfo(), NI_NUMERICHOST,
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 */
94
138
95
139
#ifdef __linux__
96
140
#include <sys/klog.h> /* klogctl() */
109
153
110
154
/* GnuTLS */
111
155
#include <gnutls/gnutls.h> /* All GnuTLS types, constants and
112
functions:
113
gnutls_*
114
init_gnutls_session(),
115
GNUTLS_* */
156
functions: gnutls_*, GNUTLS_* */
157
#if GNUTLS_VERSION_NUMBER < 0x030600
116
158
#include <gnutls/openpgp.h>
117
159
/* gnutls_certificate_set_openpgp_key_file(),
118
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
119
165
120
166
/* GPGME */
121
167
#include <gpgme.h> /* All GPGME types, constants and
122
168
functions:
123
gpgme_*
124
GPGME_PROTOCOL_OpenPGP,
125
GPG_ERR_NO_* */
169
gpgme_*, GPG_ERR_NO_*,
170
GPGME_IMPORT_*
171
GPGME_PROTOCOL_OpenPGP */
126
172
127
173
#define BUFFER_SIZE 256
128
174
129
175
#define PATHDIR "/conf/conf.d/mandos"
130
176
#define SECKEY "seckey.txt"
131
177
#define PUBKEY "pubkey.txt"
178
#define TLS_PRIVKEY "tls-privkey.pem"
179
#define TLS_PUBKEY "tls-pubkey.pem"
132
180
#define HOOKDIR "/lib/mandos/network-hooks.d"
133
181
134
182
bool debug = false;
138
186
static const char sys_class_net[] = "/sys/class/net";
139
187
char *connect_to = NULL;
140
188
const char *hookdir = HOOKDIR;
189
int hookdir_fd = -1;
141
190
uid_t uid = 65534;
142
191
gid_t gid = 65534;
143
192
180
229
perror(print_text);
181
230
}
182
231
183
__attribute__((format (gnu_printf, 2, 3)))
232
__attribute__((format (gnu_printf, 2, 3), nonnull))
184
233
int fprintf_plus(FILE *stream, const char *format, ...){
185
234
va_list ap;
186
235
va_start (ap, format);
195
244
* bytes. "buffer_capacity" is how much is currently allocated,
196
245
* "buffer_length" is how much is already used.
197
246
*/
247
__attribute__((nonnull, warn_unused_result))
198
248
size_t incbuffer(char **buffer, size_t buffer_length,
199
249
size_t buffer_capacity){
200
250
if(buffer_length + BUFFER_SIZE > buffer_capacity){
213
263
}
214
264
215
265
/* Add server to set of servers to retry periodically */
266
__attribute__((nonnull, warn_unused_result))
216
267
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
217
268
int af, server **current_server){
218
269
int ret;
227
278
.af = af };
228
279
if(new_server->ip == NULL){
229
280
perror_plus("strdup");
281
free(new_server);
282
return false;
283
}
284
ret = clock_gettime(CLOCK_MONOTONIC, &(new_server->last_seen));
285
if(ret == -1){
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);
230
296
return false;
231
297
}
232
298
/* Special case of first server */
234
300
new_server->next = new_server;
235
301
new_server->prev = new_server;
236
302
*current_server = new_server;
237
/* Place the new server last in the list */
238
303
} else {
304
/* Place the new server last in the list */
239
305
new_server->next = *current_server;
240
306
new_server->prev = (*current_server)->prev;
241
307
new_server->prev->next = new_server;
242
308
(*current_server)->prev = new_server;
243
309
}
244
ret = clock_gettime(CLOCK_MONOTONIC, &(*current_server)->last_seen);
245
if(ret == -1){
246
perror_plus("clock_gettime");
247
return false;
248
}
249
310
return true;
250
311
}
251
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
252
365
/*
253
366
* Initialize GPGME.
254
367
*/
255
static bool init_gpgme(const char *seckey, const char *pubkey,
256
const char *tempdir, mandos_context *mc){
368
__attribute__((nonnull, warn_unused_result))
369
static bool init_gpgme(const char * const seckey,
370
const char * const pubkey,
371
const char * const tempdir,
372
mandos_context *mc){
257
373
gpgme_error_t rc;
258
374
gpgme_engine_info_t engine_info;
259
375
260
376
/*
261
377
* Helper function to insert pub and seckey to the engine keyring.
262
378
*/
263
bool import_key(const char *filename){
379
bool import_key(const char * const filename){
264
380
int ret;
265
381
int fd;
266
382
gpgme_data_t pgp_data;
271
387
return false;
272
388
}
273
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
274
439
rc = gpgme_data_new_from_fd(&pgp_data, fd);
275
440
if(rc != GPG_ERR_NO_ERROR){
276
441
fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
284
449
gpgme_strsource(rc), gpgme_strerror(rc));
285
450
return false;
286
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
}
287
527
288
ret = (int)TEMP_FAILURE_RETRY(close(fd));
528
ret = close(fd);
289
529
if(ret == -1){
290
530
perror_plus("close");
291
531
}
330
570
/* Create new GPGME "context" */
331
571
rc = gpgme_new(&(mc->ctx));
332
572
if(rc != GPG_ERR_NO_ERROR){
333
fprintf_plus(stderr, "Mandos plugin mandos-client: "
334
"bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
335
gpgme_strerror(rc));
573
fprintf_plus(stderr, "bad gpgme_new: %s: %s\n",
574
gpgme_strsource(rc), gpgme_strerror(rc));
336
575
return false;
337
576
}
338
577
347
586
* Decrypt OpenPGP data.
348
587
* Returns -1 on error
349
588
*/
589
__attribute__((nonnull, warn_unused_result))
350
590
static ssize_t pgp_packet_decrypt(const char *cryptotext,
351
591
size_t crypto_size,
352
592
char **plaintext,
373
613
/* Create new empty GPGME data buffer for the plaintext */
374
614
rc = gpgme_data_new(&dh_plain);
375
615
if(rc != GPG_ERR_NO_ERROR){
376
fprintf_plus(stderr, "Mandos plugin mandos-client: "
377
"bad gpgme_data_new: %s: %s\n",
616
fprintf_plus(stderr, "bad gpgme_data_new: %s: %s\n",
378
617
gpgme_strsource(rc), gpgme_strerror(rc));
379
618
gpgme_data_release(dh_crypto);
380
619
return -1;
393
632
if(result == NULL){
394
633
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
395
634
} else {
396
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
397
result->unsupported_algorithm);
398
fprintf_plus(stderr, "Wrong key usage: %u\n",
399
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");
400
641
if(result->file_name != NULL){
401
642
fprintf_plus(stderr, "File name: %s\n", result->file_name);
402
643
}
403
gpgme_recipient_t recipient;
404
recipient = result->recipients;
405
while(recipient != NULL){
644
645
for(gpgme_recipient_t r = result->recipients; r != NULL;
646
r = r->next){
406
647
fprintf_plus(stderr, "Public key algorithm: %s\n",
407
gpgme_pubkey_algo_name
408
(recipient->pubkey_algo));
409
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);
410
650
fprintf_plus(stderr, "Secret key available: %s\n",
411
recipient->status == GPG_ERR_NO_SECKEY
412
? "No" : "Yes");
413
recipient = recipient->next;
651
r->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
414
652
}
415
653
}
416
654
}
472
710
return plaintext_length;
473
711
}
474
712
475
static const char * safer_gnutls_strerror(int value){
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
720
__attribute__((warn_unused_result))
721
static const char *safer_gnutls_strerror(int value){
476
722
const char *ret = gnutls_strerror(value);
477
if(ret == NULL)
478
ret = "(unknown)";
479
return ret;
723
return safe_string(ret);
480
724
}
481
725
482
726
/* GnuTLS log function callback */
727
__attribute__((nonnull))
483
728
static void debuggnutls(__attribute__((unused)) int level,
484
729
const char* string){
485
730
fprintf_plus(stderr, "GnuTLS: %s", string);
486
731
}
487
732
733
__attribute__((nonnull(1, 2, 4), warn_unused_result))
488
734
static int init_gnutls_global(const char *pubkeyfilename,
489
735
const char *seckeyfilename,
736
const char *dhparamsfilename,
490
737
mandos_context *mc){
491
738
int ret;
492
739
494
741
fprintf_plus(stderr, "Initializing GnuTLS\n");
495
742
}
496
743
497
ret = gnutls_global_init();
498
if(ret != GNUTLS_E_SUCCESS){
499
fprintf_plus(stderr, "GnuTLS global_init: %s\n",
500
safer_gnutls_strerror(ret));
501
return -1;
502
}
503
504
744
if(debug){
505
745
/* "Use a log level over 10 to enable all debugging options."
506
746
* - GnuTLS manual
514
754
if(ret != GNUTLS_E_SUCCESS){
515
755
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
516
756
safer_gnutls_strerror(ret));
517
gnutls_global_deinit();
518
757
return -1;
519
758
}
520
759
521
760
if(debug){
522
fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
523
" 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",
524
763
pubkeyfilename,
525
764
seckeyfilename);
526
765
}
527
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
528
780
ret = gnutls_certificate_set_openpgp_key_file
529
781
(mc->cred, pubkeyfilename, seckeyfilename,
530
782
GNUTLS_OPENPGP_FMT_BASE64);
783
#else
784
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
785
#endif
531
786
if(ret != GNUTLS_E_SUCCESS){
532
787
fprintf_plus(stderr,
533
"Error[%d] while reading the OpenPGP key pair ('%s',"
788
"Error[%d] while reading the key pair ('%s',"
534
789
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
535
790
fprintf_plus(stderr, "The GnuTLS error is: %s\n",
536
791
safer_gnutls_strerror(ret));
545
800
safer_gnutls_strerror(ret));
546
801
goto globalfail;
547
802
}
548
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
549
if(ret != GNUTLS_E_SUCCESS){
550
fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
551
safer_gnutls_strerror(ret));
552
goto globalfail;
553
}
554
555
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
}
556
985
557
986
return 0;
558
987
559
988
globalfail:
560
989
561
990
gnutls_certificate_free_credentials(mc->cred);
562
gnutls_global_deinit();
563
991
gnutls_dh_params_deinit(mc->dh_params);
564
992
return -1;
565
993
}
566
994
995
__attribute__((nonnull, warn_unused_result))
567
996
static int init_gnutls_session(gnutls_session_t *session,
568
997
mandos_context *mc){
569
998
int ret;
570
999
/* GnuTLS session creation */
571
1000
do {
572
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
));
573
1009
if(quit_now){
574
1010
return -1;
575
1011
}
616
1052
/* ignore client certificate if any. */
617
1053
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
618
1054
619
gnutls_dh_set_prime_bits(*session, mc->dh_bits);
620
621
1055
return 0;
622
1056
}
623
1057
625
1059
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
626
1060
__attribute__((unused)) const char *txt){}
627
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
628
1235
/* Called when a Mandos server is found */
1236
__attribute__((nonnull, warn_unused_result))
629
1237
static int start_mandos_communication(const char *ip, in_port_t port,
630
1238
AvahiIfIndex if_index,
631
1239
int af, mandos_context *mc){
632
1240
int ret, tcp_sd = -1;
633
1241
ssize_t sret;
634
union {
635
struct sockaddr_in in;
636
struct sockaddr_in6 in6;
637
} to;
1242
struct sockaddr_storage to;
638
1243
char *buffer = NULL;
639
1244
char *decrypted_buffer = NULL;
640
1245
size_t buffer_length = 0;
643
1248
int retval = -1;
644
1249
gnutls_session_t session;
645
1250
int pf; /* Protocol family */
1251
bool route_added = false;
646
1252
647
1253
errno = 0;
648
1254
670
1276
bool match = false;
671
1277
{
672
1278
char *interface = NULL;
673
while((interface=argz_next(mc->interfaces, mc->interfaces_size,
674
interface))){
1279
while((interface = argz_next(mc->interfaces,
1280
mc->interfaces_size,
1281
interface))){
675
1282
if(if_nametoindex(interface) == (unsigned int)if_index){
676
1283
match = true;
677
1284
break;
706
1313
PRIuMAX "\n", ip, (uintmax_t)port);
707
1314
}
708
1315
709
tcp_sd = socket(pf, SOCK_STREAM, 0);
1316
tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
710
1317
if(tcp_sd < 0){
711
1318
int e = errno;
712
1319
perror_plus("socket");
719
1326
goto mandos_end;
720
1327
}
721
1328
722
memset(&to, 0, sizeof(to));
723
1329
if(af == AF_INET6){
724
to.in6.sin6_family = (sa_family_t)af;
725
ret = inet_pton(af, ip, &to.in6.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);
726
1333
} else { /* IPv4 */
727
to.in.sin_family = (sa_family_t)af;
728
ret = inet_pton(af, ip, &to.in.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);
729
1337
}
730
1338
if(ret < 0 ){
731
1339
int e = errno;
740
1348
goto mandos_end;
741
1349
}
742
1350
if(af == AF_INET6){
743
to.in6.sin6_port = htons(port);
744
#ifdef __GNUC__
745
#pragma GCC diagnostic push
746
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
747
#endif
748
if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
749
(&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower */
750
#ifdef __GNUC__
751
#pragma GCC diagnostic pop
752
#endif
1351
((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
1352
if(IN6_IS_ADDR_LINKLOCAL
1353
(&((struct sockaddr_in6 *)&to)->sin6_addr)){
753
1354
if(if_index == AVAHI_IF_UNSPEC){
754
1355
fprintf_plus(stderr, "An IPv6 link-local address is"
755
1356
" incomplete without a network interface\n");
757
1358
goto mandos_end;
758
1359
}
759
1360
/* Set the network interface number as scope */
760
to.in6.sin6_scope_id = (uint32_t)if_index;
1361
((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
761
1362
}
762
1363
} else {
763
to.in.sin_port = htons(port);
1364
((struct sockaddr_in *)&to)->sin_port = htons(port);
764
1365
}
765
1366
766
1367
if(quit_now){
783
1384
}
784
1385
char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
785
1386
INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
786
const char *pcret;
787
if(af == AF_INET6){
788
pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
789
sizeof(addrstr));
790
} else {
791
pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
792
sizeof(addrstr));
793
}
794
if(pcret == NULL){
795
perror_plus("inet_ntop");
796
} else {
797
if(strcmp(addrstr, ip) != 0){
798
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
799
}
800
}
801
}
802
803
if(quit_now){
804
errno = EINTR;
805
goto mandos_end;
806
}
807
808
if(af == AF_INET6){
809
ret = connect(tcp_sd, &to.in6, sizeof(to));
810
} else {
811
ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
812
}
813
if(ret < 0){
814
if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
815
int e = errno;
816
perror_plus("connect");
817
errno = e;
818
}
819
goto mandos_end;
820
}
821
822
if(quit_now){
823
errno = EINTR;
824
goto mandos_end;
1387
if(af == AF_INET6){
1388
ret = getnameinfo((struct sockaddr *)&to,
1389
sizeof(struct sockaddr_in6),
1390
addrstr, sizeof(addrstr), NULL, 0,
1391
NI_NUMERICHOST);
1392
} else {
1393
ret = getnameinfo((struct sockaddr *)&to,
1394
sizeof(struct sockaddr_in),
1395
addrstr, sizeof(addrstr), NULL, 0,
1396
NI_NUMERICHOST);
1397
}
1398
if(ret == EAI_SYSTEM){
1399
perror_plus("getnameinfo");
1400
} else if(ret != 0) {
1401
fprintf_plus(stderr, "getnameinfo: %s", gai_strerror(ret));
1402
} else if(strcmp(addrstr, ip) != 0){
1403
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
1404
}
1405
}
1406
1407
if(quit_now){
1408
errno = EINTR;
1409
goto mandos_end;
1410
}
1411
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;
825
1467
}
826
1468
827
1469
const char *out = mandos_protocol_version;
981
1623
&decrypted_buffer, mc);
982
1624
if(decrypted_buffer_size >= 0){
983
1625
1626
clearerr(stdout);
984
1627
written = 0;
985
1628
while(written < (size_t) decrypted_buffer_size){
986
1629
if(quit_now){
1002
1645
}
1003
1646
written += (size_t)ret;
1004
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
}
1005
1658
retval = 0;
1006
1659
}
1007
1660
}
1010
1663
1011
1664
mandos_end:
1012
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
}
1013
1672
int e = errno;
1014
1673
free(decrypted_buffer);
1015
1674
free(buffer);
1016
1675
if(tcp_sd >= 0){
1017
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
1676
ret = close(tcp_sd);
1018
1677
}
1019
1678
if(ret == -1){
1020
1679
if(e == 0){
1045
1704
AVAHI_GCC_UNUSED AvahiStringList *txt,
1046
1705
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1047
1706
flags,
1048
void* mc){
1707
void *mc){
1049
1708
if(r == NULL){
1050
1709
return;
1051
1710
}
1054
1713
timed out */
1055
1714
1056
1715
if(quit_now){
1716
avahi_s_service_resolver_free(r);
1057
1717
return;
1058
1718
}
1059
1719
1104
1764
const char *domain,
1105
1765
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1106
1766
flags,
1107
void* mc){
1767
void *mc){
1108
1768
if(b == NULL){
1109
1769
return;
1110
1770
}
1170
1830
errno = old_errno;
1171
1831
}
1172
1832
1833
__attribute__((nonnull, warn_unused_result))
1173
1834
bool get_flags(const char *ifname, struct ifreq *ifr){
1174
1835
int ret;
1175
error_t ret_errno;
1836
int old_errno;
1176
1837
1177
1838
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1178
1839
if(s < 0){
1179
ret_errno = errno;
1840
old_errno = errno;
1180
1841
perror_plus("socket");
1181
errno = ret_errno;
1842
errno = old_errno;
1182
1843
return false;
1183
1844
}
1184
strcpy(ifr->ifr_name, ifname);
1845
strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
1846
ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
1185
1847
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1186
1848
if(ret == -1){
1187
1849
if(debug){
1188
ret_errno = errno;
1850
old_errno = errno;
1189
1851
perror_plus("ioctl SIOCGIFFLAGS");
1190
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;
1191
1858
}
1192
1859
return false;
1193
1860
}
1861
if((close(s) == -1) and debug){
1862
old_errno = errno;
1863
perror_plus("close");
1864
errno = old_errno;
1865
}
1194
1866
return true;
1195
1867
}
1196
1868
1869
__attribute__((nonnull, warn_unused_result))
1197
1870
bool good_flags(const char *ifname, const struct ifreq *ifr){
1198
1871
1199
1872
/* Reject the loopback device */
1241
1914
* corresponds to an acceptable network device.
1242
1915
* (This function is passed to scandir(3) as a filter function.)
1243
1916
*/
1917
__attribute__((nonnull, warn_unused_result))
1244
1918
int good_interface(const struct dirent *if_entry){
1245
1919
if(if_entry->d_name[0] == '.'){
1246
1920
return 0;
1264
1938
/*
1265
1939
* This function determines if a network interface is up.
1266
1940
*/
1941
__attribute__((nonnull, warn_unused_result))
1267
1942
bool interface_is_up(const char *interface){
1268
1943
struct ifreq ifr;
1269
1944
if(not get_flags(interface, &ifr)){
1280
1955
/*
1281
1956
* This function determines if a network interface is running
1282
1957
*/
1958
__attribute__((nonnull, warn_unused_result))
1283
1959
bool interface_is_running(const char *interface){
1284
1960
struct ifreq ifr;
1285
1961
if(not get_flags(interface, &ifr)){
1293
1969
return (bool)(ifr.ifr_flags & IFF_RUNNING);
1294
1970
}
1295
1971
1972
__attribute__((nonnull, pure, warn_unused_result))
1296
1973
int notdotentries(const struct dirent *direntry){
1297
1974
/* Skip "." and ".." */
1298
1975
if(direntry->d_name[0] == '.'
1305
1982
}
1306
1983
1307
1984
/* Is this directory entry a runnable program? */
1985
__attribute__((nonnull, warn_unused_result))
1308
1986
int runnable_hook(const struct dirent *direntry){
1309
1987
int ret;
1310
1988
size_t sret;
1318
1996
sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1319
1997
"abcdefghijklmnopqrstuvwxyz"
1320
1998
"0123456789"
1321
"_-");
1999
"_.-");
1322
2000
if((direntry->d_name)[sret] != '\0'){
1323
2001
/* Contains non-allowed characters */
1324
2002
if(debug){
1328
2006
return 0;
1329
2007
}
1330
2008
1331
char *fullname = NULL;
1332
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1333
if(ret < 0){
1334
perror_plus("asprintf");
1335
return 0;
1336
}
1337
1338
ret = stat(fullname, &st);
2009
ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1339
2010
if(ret == -1){
1340
2011
if(debug){
1341
2012
perror_plus("Could not stat hook");
1365
2036
return 1;
1366
2037
}
1367
2038
2039
__attribute__((nonnull, warn_unused_result))
1368
2040
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
1369
2041
mandos_context *mc){
1370
2042
int ret;
1374
2046
1375
2047
while(true){
1376
2048
if(mc->current_server == NULL){
1377
if (debug){
2049
if(debug){
1378
2050
fprintf_plus(stderr, "Wait until first server is found."
1379
2051
" No timeout!\n");
1380
2052
}
1381
2053
ret = avahi_simple_poll_iterate(s, -1);
1382
2054
} else {
1383
if (debug){
2055
if(debug){
1384
2056
fprintf_plus(stderr, "Check current_server if we should run"
1385
2057
" it, or wait\n");
1386
2058
}
1403
2075
- ((intmax_t)waited_time.tv_sec * 1000))
1404
2076
- ((intmax_t)waited_time.tv_nsec / 1000000));
1405
2077
1406
if (debug){
2078
if(debug){
1407
2079
fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1408
2080
block_time);
1409
2081
}
1431
2103
ret = avahi_simple_poll_iterate(s, (int)block_time);
1432
2104
}
1433
2105
if(ret != 0){
1434
if (ret > 0 or errno != EINTR){
2106
if(ret > 0 or errno != EINTR){
1435
2107
return (ret != 1) ? ret : 0;
1436
2108
}
1437
2109
}
1438
2110
}
1439
2111
}
1440
2112
1441
/* Set effective uid to 0, return errno */
1442
error_t raise_privileges(void){
1443
error_t old_errno = errno;
1444
error_t ret_errno = 0;
1445
if(seteuid(0) == -1){
1446
ret_errno = errno;
1447
perror_plus("seteuid");
1448
}
1449
errno = old_errno;
1450
return ret_errno;
1451
}
1452
1453
/* Set effective and real user ID to 0. Return errno. */
1454
error_t raise_privileges_permanently(void){
1455
error_t old_errno = errno;
1456
error_t ret_errno = raise_privileges();
1457
if(ret_errno != 0){
1458
errno = old_errno;
1459
return ret_errno;
1460
}
1461
if(setuid(0) == -1){
1462
ret_errno = errno;
1463
perror_plus("seteuid");
1464
}
1465
errno = old_errno;
1466
return ret_errno;
1467
}
1468
1469
/* Set effective user ID to unprivileged saved user ID */
1470
error_t lower_privileges(void){
1471
error_t old_errno = errno;
1472
error_t ret_errno = 0;
1473
if(seteuid(uid) == -1){
1474
ret_errno = errno;
1475
perror_plus("seteuid");
1476
}
1477
errno = old_errno;
1478
return ret_errno;
1479
}
1480
1481
/* Lower privileges permanently */
1482
error_t lower_privileges_permanently(void){
1483
error_t old_errno = errno;
1484
error_t ret_errno = 0;
1485
if(setuid(uid) == -1){
1486
ret_errno = errno;
1487
perror_plus("setuid");
1488
}
1489
errno = old_errno;
1490
return ret_errno;
1491
}
1492
1493
bool run_network_hooks(const char *mode, const char *interface,
2113
__attribute__((nonnull))
2114
void run_network_hooks(const char *mode, const char *interface,
1494
2115
const float delay){
1495
struct dirent **direntries;
1496
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1497
alphasort);
2116
struct dirent **direntries = NULL;
2117
if(hookdir_fd == -1){
2118
hookdir_fd = open(hookdir, O_RDONLY | O_DIRECTORY | O_PATH
2119
| O_CLOEXEC);
2120
if(hookdir_fd == -1){
2121
if(errno == ENOENT){
2122
if(debug){
2123
fprintf_plus(stderr, "Network hook directory \"%s\" not"
2124
" found\n", hookdir);
2125
}
2126
} else {
2127
perror_plus("open");
2128
}
2129
return;
2130
}
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
}
2137
int numhooks = scandirat(hookdir_fd, ".", &direntries,
2138
runnable_hook, alphasort);
1498
2139
if(numhooks == -1){
1499
if(errno == ENOENT){
1500
if(debug){
1501
fprintf_plus(stderr, "Network hook directory \"%s\" not"
1502
" found\n", hookdir);
1503
}
1504
} else {
1505
perror_plus("scandir");
2140
perror_plus("scandir");
2141
close(devnull);
2142
return;
2143
}
2144
struct dirent *direntry;
2145
int ret;
2146
for(int i = 0; i < numhooks; i++){
2147
direntry = direntries[i];
2148
if(debug){
2149
fprintf_plus(stderr, "Running network hook \"%s\"\n",
2150
direntry->d_name);
1506
2151
}
1507
} else {
1508
struct dirent *direntry;
1509
int ret;
1510
int devnull = open("/dev/null", O_RDONLY);
1511
for(int i = 0; i < numhooks; i++){
1512
direntry = direntries[i];
1513
char *fullname = NULL;
1514
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1515
if(ret < 0){
2152
pid_t hook_pid = fork();
2153
if(hook_pid == 0){
2154
/* Child */
2155
/* Raise privileges */
2156
errno = raise_privileges_permanently();
2157
if(errno != 0){
2158
perror_plus("Failed to raise privileges");
2159
_exit(EX_NOPERM);
2160
}
2161
/* Set group */
2162
errno = 0;
2163
ret = setgid(0);
2164
if(ret == -1){
2165
perror_plus("setgid");
2166
_exit(EX_NOPERM);
2167
}
2168
/* Reset supplementary groups */
2169
errno = 0;
2170
ret = setgroups(0, NULL);
2171
if(ret == -1){
2172
perror_plus("setgroups");
2173
_exit(EX_NOPERM);
2174
}
2175
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
2176
if(ret == -1){
2177
perror_plus("setenv");
2178
_exit(EX_OSERR);
2179
}
2180
ret = setenv("DEVICE", interface, 1);
2181
if(ret == -1){
2182
perror_plus("setenv");
2183
_exit(EX_OSERR);
2184
}
2185
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
2186
if(ret == -1){
2187
perror_plus("setenv");
2188
_exit(EX_OSERR);
2189
}
2190
ret = setenv("MODE", mode, 1);
2191
if(ret == -1){
2192
perror_plus("setenv");
2193
_exit(EX_OSERR);
2194
}
2195
char *delaystring;
2196
ret = asprintf(&delaystring, "%f", (double)delay);
2197
if(ret == -1){
1516
2198
perror_plus("asprintf");
1517
continue;
1518
}
1519
if(debug){
1520
fprintf_plus(stderr, "Running network hook \"%s\"\n",
1521
direntry->d_name);
1522
}
1523
pid_t hook_pid = fork();
1524
if(hook_pid == 0){
1525
/* Child */
1526
/* Raise privileges */
1527
raise_privileges_permanently();
1528
/* Set group */
1529
errno = 0;
1530
ret = setgid(0);
1531
if(ret == -1){
1532
perror_plus("setgid");
1533
}
1534
/* Reset supplementary groups */
1535
errno = 0;
1536
ret = setgroups(0, NULL);
1537
if(ret == -1){
1538
perror_plus("setgroups");
1539
}
1540
dup2(devnull, STDIN_FILENO);
1541
close(devnull);
1542
dup2(STDERR_FILENO, STDOUT_FILENO);
1543
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1544
if(ret == -1){
1545
perror_plus("setenv");
1546
_exit(EX_OSERR);
1547
}
1548
ret = setenv("DEVICE", interface, 1);
1549
if(ret == -1){
1550
perror_plus("setenv");
1551
_exit(EX_OSERR);
1552
}
1553
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
1554
if(ret == -1){
1555
perror_plus("setenv");
1556
_exit(EX_OSERR);
1557
}
1558
ret = setenv("MODE", mode, 1);
1559
if(ret == -1){
1560
perror_plus("setenv");
1561
_exit(EX_OSERR);
1562
}
1563
char *delaystring;
1564
ret = asprintf(&delaystring, "%f", delay);
1565
if(ret == -1){
1566
perror_plus("asprintf");
1567
_exit(EX_OSERR);
1568
}
1569
ret = setenv("DELAY", delaystring, 1);
1570
if(ret == -1){
1571
free(delaystring);
1572
perror_plus("setenv");
1573
_exit(EX_OSERR);
1574
}
2199
_exit(EX_OSERR);
2200
}
2201
ret = setenv("DELAY", delaystring, 1);
2202
if(ret == -1){
1575
2203
free(delaystring);
1576
if(connect_to != NULL){
1577
ret = setenv("CONNECT", connect_to, 1);
1578
if(ret == -1){
1579
perror_plus("setenv");
1580
_exit(EX_OSERR);
1581
}
1582
}
1583
if(execl(fullname, direntry->d_name, mode, NULL) == -1){
1584
perror_plus("execl");
1585
_exit(EXIT_FAILURE);
1586
}
2204
perror_plus("setenv");
2205
_exit(EX_OSERR);
2206
}
2207
free(delaystring);
2208
if(connect_to != NULL){
2209
ret = setenv("CONNECT", connect_to, 1);
2210
if(ret == -1){
2211
perror_plus("setenv");
2212
_exit(EX_OSERR);
2213
}
2214
}
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){
2243
perror_plus("fexecve");
2244
_exit(EXIT_FAILURE);
2245
}
2246
} else {
2247
if(hook_pid == -1){
2248
perror_plus("fork");
2249
free(direntry);
2250
continue;
2251
}
2252
int status;
2253
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
2254
perror_plus("waitpid");
2255
free(direntry);
2256
continue;
2257
}
2258
if(WIFEXITED(status)){
2259
if(WEXITSTATUS(status) != 0){
2260
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
2261
" with status %d\n", direntry->d_name,
2262
WEXITSTATUS(status));
2263
free(direntry);
2264
continue;
2265
}
2266
} else if(WIFSIGNALED(status)){
2267
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
2268
" signal %d\n", direntry->d_name,
2269
WTERMSIG(status));
2270
free(direntry);
2271
continue;
1587
2272
} else {
1588
int status;
1589
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1590
perror_plus("waitpid");
1591
free(fullname);
1592
continue;
1593
}
1594
if(WIFEXITED(status)){
1595
if(WEXITSTATUS(status) != 0){
1596
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1597
" with status %d\n", direntry->d_name,
1598
WEXITSTATUS(status));
1599
free(fullname);
1600
continue;
1601
}
1602
} else if(WIFSIGNALED(status)){
1603
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1604
" signal %d\n", direntry->d_name,
1605
WTERMSIG(status));
1606
free(fullname);
1607
continue;
1608
} else {
1609
fprintf_plus(stderr, "Warning: network hook \"%s\""
1610
" crashed\n", direntry->d_name);
1611
free(fullname);
1612
continue;
1613
}
1614
}
1615
free(fullname);
1616
if(debug){
1617
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1618
direntry->d_name);
1619
}
1620
}
1621
close(devnull);
1622
}
1623
return true;
2273
fprintf_plus(stderr, "Warning: network hook \"%s\""
2274
" crashed\n", direntry->d_name);
2275
free(direntry);
2276
continue;
2277
}
2278
}
2279
if(debug){
2280
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
2281
direntry->d_name);
2282
}
2283
free(direntry);
2284
}
2285
free(direntries);
2286
if(close(hookdir_fd) == -1){
2287
perror_plus("close");
2288
} else {
2289
hookdir_fd = -1;
2290
}
2291
close(devnull);
1624
2292
}
1625
2293
1626
error_t bring_up_interface(const char *const interface,
1627
const float delay){
1628
int sd = -1;
1629
error_t old_errno = errno;
1630
error_t ret_errno = 0;
1631
int ret, ret_setflags;
2294
__attribute__((nonnull, warn_unused_result))
2295
int bring_up_interface(const char *const interface,
2296
const float delay){
2297
int old_errno = errno;
2298
int ret;
1632
2299
struct ifreq network;
1633
2300
unsigned int if_index = if_nametoindex(interface);
1634
2301
if(if_index == 0){
1643
2310
}
1644
2311
1645
2312
if(not interface_is_up(interface)){
1646
if(not get_flags(interface, &network) and debug){
2313
int ret_errno = 0;
2314
int ioctl_errno = 0;
2315
if(not get_flags(interface, &network)){
1647
2316
ret_errno = errno;
1648
2317
fprintf_plus(stderr, "Failed to get flags for interface "
1649
2318
"\"%s\"\n", interface);
2319
errno = old_errno;
1650
2320
return ret_errno;
1651
2321
}
1652
network.ifr_flags |= IFF_UP;
2322
network.ifr_flags |= IFF_UP; /* set flag */
1653
2323
1654
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1655
if(sd < 0){
2324
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
2325
if(sd == -1){
1656
2326
ret_errno = errno;
1657
2327
perror_plus("socket");
1658
2328
errno = old_errno;
1659
2329
return ret_errno;
1660
2330
}
1661
2331
1662
2332
if(quit_now){
1663
close(sd);
2333
ret = close(sd);
2334
if(ret == -1){
2335
perror_plus("close");
2336
}
1664
2337
errno = old_errno;
1665
2338
return EINTR;
1666
2339
}
1670
2343
interface);
1671
2344
}
1672
2345
1673
/* Raise priviliges */
1674
raise_privileges();
2346
/* Raise privileges */
2347
ret_errno = raise_privileges();
2348
if(ret_errno != 0){
2349
errno = ret_errno;
2350
perror_plus("Failed to raise privileges");
2351
}
1675
2352
1676
2353
#ifdef __linux__
1677
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1678
messages about the network interface to mess up the prompt */
1679
int ret_linux = klogctl(8, NULL, 5);
1680
bool restore_loglevel = true;
1681
if(ret_linux == -1){
1682
restore_loglevel = false;
1683
perror_plus("klogctl");
2354
int ret_linux;
2355
bool restore_loglevel = false;
2356
if(ret_errno == 0){
2357
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
2358
messages about the network interface to mess up the prompt */
2359
ret_linux = klogctl(8, NULL, 5);
2360
if(ret_linux == -1){
2361
perror_plus("klogctl");
2362
} else {
2363
restore_loglevel = true;
2364
}
1684
2365
}
1685
2366
#endif /* __linux__ */
1686
ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1687
ret_errno = errno;
2367
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
2368
ioctl_errno = errno;
1688
2369
#ifdef __linux__
1689
2370
if(restore_loglevel){
1690
2371
ret_linux = klogctl(7, NULL, 0);
1694
2375
}
1695
2376
#endif /* __linux__ */
1696
2377
1697
/* Lower privileges */
1698
lower_privileges();
2378
/* If raise_privileges() succeeded above */
2379
if(ret_errno == 0){
2380
/* Lower privileges */
2381
ret_errno = lower_privileges();
2382
if(ret_errno != 0){
2383
errno = ret_errno;
2384
perror_plus("Failed to lower privileges");
2385
}
2386
}
1699
2387
1700
2388
/* Close the socket */
1701
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2389
ret = close(sd);
1702
2390
if(ret == -1){
1703
2391
perror_plus("close");
1704
2392
}
1705
2393
1706
2394
if(ret_setflags == -1){
1707
errno = ret_errno;
2395
errno = ioctl_errno;
1708
2396
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1709
2397
errno = old_errno;
1710
return ret_errno;
2398
return ioctl_errno;
1711
2399
}
1712
2400
} else if(debug){
1713
2401
fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
1716
2404
1717
2405
/* Sleep checking until interface is running.
1718
2406
Check every 0.25s, up to total time of delay */
1719
for(int i=0; i < delay * 4; i++){
2407
for(int i = 0; i < delay * 4; i++){
1720
2408
if(interface_is_running(interface)){
1721
2409
break;
1722
2410
}
1731
2419
return 0;
1732
2420
}
1733
2421
1734
error_t take_down_interface(const char *const interface){
1735
error_t old_errno = errno;
2422
__attribute__((nonnull, warn_unused_result))
2423
int take_down_interface(const char *const interface){
2424
int old_errno = errno;
1736
2425
struct ifreq network;
1737
2426
unsigned int if_index = if_nametoindex(interface);
1738
2427
if(if_index == 0){
1741
2430
return ENXIO;
1742
2431
}
1743
2432
if(interface_is_up(interface)){
1744
error_t ret_errno = 0;
2433
int ret_errno = 0;
2434
int ioctl_errno = 0;
1745
2435
if(not get_flags(interface, &network) and debug){
1746
2436
ret_errno = errno;
1747
2437
fprintf_plus(stderr, "Failed to get flags for interface "
1748
2438
"\"%s\"\n", interface);
2439
errno = old_errno;
1749
2440
return ret_errno;
1750
2441
}
1751
2442
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
1752
2443
1753
2444
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1754
if(sd < 0){
2445
if(sd == -1){
1755
2446
ret_errno = errno;
1756
2447
perror_plus("socket");
1757
2448
errno = old_errno;
1763
2454
interface);
1764
2455
}
1765
2456
1766
/* Raise priviliges */
1767
raise_privileges();
2457
/* Raise privileges */
2458
ret_errno = raise_privileges();
2459
if(ret_errno != 0){
2460
errno = ret_errno;
2461
perror_plus("Failed to raise privileges");
2462
}
1768
2463
1769
2464
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1770
ret_errno = errno;
2465
ioctl_errno = errno;
1771
2466
1772
/* Lower privileges */
1773
lower_privileges();
2467
/* If raise_privileges() succeeded above */
2468
if(ret_errno == 0){
2469
/* Lower privileges */
2470
ret_errno = lower_privileges();
2471
if(ret_errno != 0){
2472
errno = ret_errno;
2473
perror_plus("Failed to lower privileges");
2474
}
2475
}
1774
2476
1775
2477
/* Close the socket */
1776
int ret = (int)TEMP_FAILURE_RETRY(close(sd));
2478
int ret = close(sd);
1777
2479
if(ret == -1){
1778
2480
perror_plus("close");
1779
2481
}
1780
2482
1781
2483
if(ret_setflags == -1){
1782
errno = ret_errno;
2484
errno = ioctl_errno;
1783
2485
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
1784
2486
errno = old_errno;
1785
return ret_errno;
2487
return ioctl_errno;
1786
2488
}
1787
2489
} else if(debug){
1788
2490
fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
1794
2496
}
1795
2497
1796
2498
int main(int argc, char *argv[]){
1797
mandos_context mc = { .server = NULL, .dh_bits = 1024,
1798
.priority = "SECURE256:!CTYPE-X.509:"
1799
"+CTYPE-OPENPGP", .current_server = NULL,
1800
.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 };
1801
2512
AvahiSServiceBrowser *sb = NULL;
1802
2513
error_t ret_errno;
1803
2514
int ret;
1806
2517
int exitcode = EXIT_SUCCESS;
1807
2518
char *interfaces_to_take_down = NULL;
1808
2519
size_t interfaces_to_take_down_size = 0;
1809
char tempdir[] = "/tmp/mandosXXXXXX";
1810
bool tempdir_created = false;
2520
char run_tempdir[] = "/run/tmp/mandosXXXXXX";
2521
char old_tempdir[] = "/tmp/mandosXXXXXX";
2522
char *tempdir = NULL;
1811
2523
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1812
2524
const char *seckey = PATHDIR "/" SECKEY;
1813
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;
1814
2531
char *interfaces_hooks = NULL;
1815
2532
1816
2533
bool gnutls_initialized = false;
1863
2580
{ .name = "pubkey", .key = 'p',
1864
2581
.arg = "FILE",
1865
2582
.doc = "OpenPGP public key file base name",
1866
.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 },
1867
2600
{ .name = "dh-bits", .key = 129,
1868
2601
.arg = "BITS",
1869
2602
.doc = "Bit length of the prime number used in the"
1870
2603
" Diffie-Hellman key exchange",
1871
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 },
1872
2610
{ .name = "priority", .key = 130,
1873
2611
.arg = "STRING",
1874
2612
.doc = "GnuTLS priority string for the TLS handshake",
1920
2658
case 'p': /* --pubkey */
1921
2659
pubkey = arg;
1922
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;
1923
2671
case 129: /* --dh-bits */
1924
2672
errno = 0;
1925
2673
tmpmax = strtoimax(arg, &tmp, 10);
1929
2677
}
1930
2678
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
1931
2679
break;
2680
case 134: /* --dh-params */
2681
dh_params_file = arg;
2682
break;
1932
2683
case 130: /* --priority */
1933
2684
mc.priority = arg;
1934
2685
break;
1957
2708
argp_state_help(state, state->out_stream,
1958
2709
(ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
1959
2710
& ~(unsigned int)ARGP_HELP_EXIT_OK);
2711
__builtin_unreachable();
1960
2712
case -3: /* --usage */
1961
2713
argp_state_help(state, state->out_stream,
1962
2714
ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
2715
__builtin_unreachable();
1963
2716
case 'V': /* --version */
1964
2717
fprintf_plus(state->out_stream, "%s\n", argp_program_version);
1965
2718
exit(argp_err_exit_status);
1974
2727
.args_doc = "",
1975
2728
.doc = "Mandos client -- Get and decrypt"
1976
2729
" passwords from a Mandos server" };
1977
ret = argp_parse(&argp, argc, argv,
1978
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
1979
switch(ret){
2730
ret_errno = argp_parse(&argp, argc, argv,
2731
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2732
switch(ret_errno){
1980
2733
case 0:
1981
2734
break;
1982
2735
case ENOMEM:
1983
2736
default:
1984
errno = ret;
2737
errno = ret_errno;
1985
2738
perror_plus("argp_parse");
1986
2739
exitcode = EX_OSERR;
1987
2740
goto end;
1990
2743
goto end;
1991
2744
}
1992
2745
}
1993
2746
1994
2747
{
1995
/* Work around Debian bug #633582:
1996
<http://bugs.debian.org/633582> */
1997
1998
/* Re-raise priviliges */
1999
if(raise_privileges() == 0){
2748
/* Re-raise privileges */
2749
ret = raise_privileges();
2750
if(ret != 0){
2751
errno = ret;
2752
perror_plus("Failed to raise privileges");
2753
} else {
2000
2754
struct stat st;
2001
2755
2756
/* Work around Debian bug #633582:
2757
<https://bugs.debian.org/633582> */
2758
2002
2759
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
2003
2760
int seckey_fd = open(seckey, O_RDONLY);
2004
2761
if(seckey_fd == -1){
2016
2773
}
2017
2774
}
2018
2775
}
2019
TEMP_FAILURE_RETRY(close(seckey_fd));
2776
close(seckey_fd);
2020
2777
}
2021
2778
}
2022
2779
2023
2780
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2024
2781
int pubkey_fd = open(pubkey, O_RDONLY);
2025
2782
if(pubkey_fd == -1){
2037
2794
}
2038
2795
}
2039
2796
}
2040
TEMP_FAILURE_RETRY(close(pubkey_fd));
2041
}
2042
}
2043
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
2044
2832
/* Lower privileges */
2045
lower_privileges();
2833
ret = lower_privileges();
2834
if(ret != 0){
2835
errno = ret;
2836
perror_plus("Failed to lower privileges");
2837
}
2046
2838
}
2047
2839
}
2048
2840
2074
2866
memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
2075
2867
argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
2076
2868
}
2077
if(not run_network_hooks("start", interfaces_hooks != NULL ?
2078
interfaces_hooks : "", delay)){
2079
goto end;
2080
}
2869
run_network_hooks("start", interfaces_hooks != NULL ?
2870
interfaces_hooks : "", delay);
2081
2871
}
2082
2872
2083
2873
if(not debug){
2161
2951
2162
2952
/* If no interfaces were specified, make a list */
2163
2953
if(mc.interfaces == NULL){
2164
struct dirent **direntries;
2954
struct dirent **direntries = NULL;
2165
2955
/* Look for any good interfaces */
2166
2956
ret = scandir(sys_class_net, &direntries, good_interface,
2167
2957
alphasort);
2173
2963
if(ret_errno != 0){
2174
2964
errno = ret_errno;
2175
2965
perror_plus("argz_add");
2966
free(direntries[i]);
2176
2967
continue;
2177
2968
}
2178
2969
if(debug){
2179
2970
fprintf_plus(stderr, "Will use interface \"%s\"\n",
2180
2971
direntries[i]->d_name);
2181
2972
}
2973
free(direntries[i]);
2182
2974
}
2183
2975
free(direntries);
2184
2976
} else {
2185
free(direntries);
2977
if(ret == 0){
2978
free(direntries);
2979
}
2186
2980
fprintf_plus(stderr, "Could not find a network interface\n");
2187
2981
exitcode = EXIT_FAILURE;
2188
2982
goto end;
2211
3005
break;
2212
3006
}
2213
3007
bool interface_was_up = interface_is_up(interface);
2214
ret = bring_up_interface(interface, delay);
3008
errno = bring_up_interface(interface, delay);
2215
3009
if(not interface_was_up){
2216
if(ret != 0){
2217
errno = ret;
2218
perror_plus("Failed to bring up interface");
3010
if(errno != 0){
3011
fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
3012
" %s\n", interface, strerror(errno));
2219
3013
} else {
2220
ret_errno = argz_add(&interfaces_to_take_down,
2221
&interfaces_to_take_down_size,
2222
interface);
2223
if(ret_errno != 0){
2224
errno = ret_errno;
3014
errno = argz_add(&interfaces_to_take_down,
3015
&interfaces_to_take_down_size,
3016
interface);
3017
if(errno != 0){
2225
3018
perror_plus("argz_add");
2226
3019
}
2227
3020
}
2245
3038
goto end;
2246
3039
}
2247
3040
2248
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
2249
3048
if(ret == -1){
2250
3049
fprintf_plus(stderr, "init_gnutls_global failed\n");
2251
3050
exitcode = EX_UNAVAILABLE;
2258
3057
goto end;
2259
3058
}
2260
3059
2261
if(mkdtemp(tempdir) == NULL){
3060
/* Try /run/tmp before /tmp */
3061
tempdir = mkdtemp(run_tempdir);
3062
if(tempdir == NULL and errno == ENOENT){
3063
if(debug){
3064
fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
3065
run_tempdir, old_tempdir);
3066
}
3067
tempdir = mkdtemp(old_tempdir);
3068
}
3069
if(tempdir == NULL){
2262
3070
perror_plus("mkdtemp");
2263
3071
goto end;
2264
3072
}
2265
tempdir_created = true;
2266
3073
2267
3074
if(quit_now){
2268
3075
goto end;
2343
3150
sleep((unsigned int)retry_interval);
2344
3151
}
2345
3152
2346
if (not quit_now){
3153
if(not quit_now){
2347
3154
exitcode = EXIT_SUCCESS;
2348
3155
}
2349
3156
2365
3172
2366
3173
/* Allocate a new server */
2367
3174
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
2368
&config, NULL, NULL, &ret_errno);
3175
&config, NULL, NULL, &ret);
2369
3176
2370
3177
/* Free the Avahi configuration data */
2371
3178
avahi_server_config_free(&config);
2374
3181
/* Check if creating the Avahi server object succeeded */
2375
3182
if(mc.server == NULL){
2376
3183
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2377
avahi_strerror(ret_errno));
3184
avahi_strerror(ret));
2378
3185
exitcode = EX_UNAVAILABLE;
2379
3186
goto end;
2380
3187
}
2404
3211
if(debug){
2405
3212
fprintf_plus(stderr, "Starting Avahi loop search\n");
2406
3213
}
2407
3214
2408
3215
ret = avahi_loop_with_timeout(simple_poll,
2409
3216
(int)(retry_interval * 1000), &mc);
2410
3217
if(debug){
2415
3222
end:
2416
3223
2417
3224
if(debug){
2418
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
}
2419
3232
}
2420
3233
2421
3234
/* Cleanup things */
2432
3245
2433
3246
if(gnutls_initialized){
2434
3247
gnutls_certificate_free_credentials(mc.cred);
2435
gnutls_global_deinit();
2436
3248
gnutls_dh_params_deinit(mc.dh_params);
2437
3249
}
2438
3250
2446
3258
mc.current_server->prev->next = NULL;
2447
3259
while(mc.current_server != NULL){
2448
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
2449
3269
free(mc.current_server);
2450
3270
mc.current_server = next;
2451
3271
}
2452
3272
}
2453
3273
2454
/* Re-raise priviliges */
3274
/* Re-raise privileges */
2455
3275
{
2456
raise_privileges();
2457
2458
/* Run network hooks */
2459
run_network_hooks("stop", interfaces_hooks != NULL ?
2460
interfaces_hooks : "", delay);
2461
2462
/* Take down the network interfaces which were brought up */
2463
{
2464
char *interface = NULL;
2465
while((interface=argz_next(interfaces_to_take_down,
2466
interfaces_to_take_down_size,
2467
interface))){
2468
ret_errno = take_down_interface(interface);
2469
if(ret_errno != 0){
2470
errno = ret_errno;
2471
perror_plus("Failed to take down interface");
2472
}
2473
}
2474
if(debug and (interfaces_to_take_down == NULL)){
2475
fprintf_plus(stderr, "No interfaces needed to be taken"
2476
" down\n");
2477
}
2478
}
2479
2480
lower_privileges_permanently();
3276
ret = raise_privileges();
3277
if(ret != 0){
3278
errno = ret;
3279
perror_plus("Failed to raise privileges");
3280
} else {
3281
3282
/* Run network hooks */
3283
run_network_hooks("stop", interfaces_hooks != NULL ?
3284
interfaces_hooks : "", delay);
3285
3286
/* Take down the network interfaces which were brought up */
3287
{
3288
char *interface = NULL;
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;
3295
perror_plus("Failed to take down interface");
3296
}
3297
}
3298
if(debug and (interfaces_to_take_down == NULL)){
3299
fprintf_plus(stderr, "No interfaces needed to be taken"
3300
" down\n");
3301
}
3302
}
3303
}
3304
3305
ret = lower_privileges_permanently();
3306
if(ret != 0){
3307
errno = ret;
3308
perror_plus("Failed to lower privileges permanently");
3309
}
2481
3310
}
2482
3311
2483
3312
free(interfaces_to_take_down);
2484
3313
free(interfaces_hooks);
2485
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
2486
3369
/* Removes the GPGME temp directory and all files inside */
2487
if(tempdir_created){
2488
struct dirent **direntries = NULL;
2489
struct dirent *direntry = NULL;
2490
int numentries = scandir(tempdir, &direntries, notdotentries,
2491
alphasort);
2492
if (numentries > 0){
2493
for(int i = 0; i < numentries; i++){
2494
direntry = direntries[i];
2495
char *fullname = NULL;
2496
ret = asprintf(&fullname, "%s/%s", tempdir,
2497
direntry->d_name);
2498
if(ret < 0){
2499
perror_plus("asprintf");
2500
continue;
2501
}
2502
ret = remove(fullname);
2503
if(ret == -1){
2504
fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2505
strerror(errno));
2506
}
2507
free(fullname);
2508
}
2509
}
2510
2511
/* need to clean even if 0 because man page doesn't specify */
2512
free(direntries);
2513
if (numentries == -1){
2514
perror_plus("scandir");
2515
}
2516
ret = rmdir(tempdir);
2517
if(ret == -1 and errno != ENOENT){
2518
perror_plus("rmdir");
2519
}
3370
if(tempdir != NULL){
3371
clean_dir_at(-1, tempdir, 0);
2520
3372
}
2521
3373
2522
3374
if(quit_now){
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0