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 1313
- compare with another revision
- download diff
- download tarball
- view history from revision 1313
- Committer: Teddy Hogeborn
- Date: 2024-11-22 20:28:54 UTC
- Revision ID: teddy@recompile.se-20241122202854-dycuf117byxhxl32
mandos-monitor: Avoid debug messages from urwid
Avoid debug messages from urwid. Any logging output before the screen
has been set up will mangle the screen.
* mandos-monitor: When setting up logging, set urwid to only show log
messages of level INFO or above.
(Thanks to an anonymous contributor for reporting this.)
Avoid debug messages from urwid. Any logging output before the screen
has been set up will mangle the screen.
* mandos-monitor: When setting up logging, set urwid to only show log
messages of level INFO or above.
(Thanks to an anonymous contributor for reporting this.)
- files added:
- bugs.xml
- debian/tests
- debian/upstream
- 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-2012 Teddy Hogeborn
13
* Copyright © 2008-2012 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-2022 Teddy Hogeborn
13
* Copyright © 2008-2022 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 <assert.h> /* assert() */
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
#include <arpa/inet.h> /* inet_pton(), htons, inet_ntop() */
78
#include <iso646.h> /* not, or, and */
79
#include <argp.h> /* struct argp_option, error_t, struct
80
argp_state, struct argp,
81
argp_parse(), ARGP_KEY_ARG,
82
ARGP_KEY_END, ARGP_ERR_UNKNOWN */
83
#include <signal.h> /* sigemptyset(), sigaddset(),
84
sigaction(), SIGTERM, sig_atomic_t,
85
raise() */
86
#include <sysexits.h> /* EX_OSERR, EX_USAGE, EX_UNAVAILABLE,
87
EX_NOHOST, EX_IOERR, EX_PROTOCOL */
88
#include <sys/wait.h> /* waitpid(), WIFEXITED(),
89
WEXITSTATUS(), WTERMSIG() */
90
#include <grp.h> /* setgroups() */
91
#include <argz.h> /* argz_add_sep(), argz_next(),
92
argz_delete(), argz_append(),
93
argz_stringify(), argz_add(),
94
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 */
95
138
96
139
#ifdef __linux__
97
140
#include <sys/klog.h> /* klogctl() */
110
153
111
154
/* GnuTLS */
112
155
#include <gnutls/gnutls.h> /* All GnuTLS types, constants and
113
functions:
114
gnutls_*
115
init_gnutls_session(),
116
GNUTLS_* */
156
functions: gnutls_*, GNUTLS_* */
157
#if GNUTLS_VERSION_NUMBER < 0x030600
117
158
#include <gnutls/openpgp.h>
118
159
/* gnutls_certificate_set_openpgp_key_file(),
119
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
120
165
121
166
/* GPGME */
122
167
#include <gpgme.h> /* All GPGME types, constants and
123
168
functions:
124
gpgme_*
125
GPGME_PROTOCOL_OpenPGP,
126
GPG_ERR_NO_* */
169
gpgme_*, GPG_ERR_NO_*,
170
GPGME_IMPORT_*
171
GPGME_PROTOCOL_OpenPGP */
127
172
128
173
#define BUFFER_SIZE 256
129
174
130
175
#define PATHDIR "/conf/conf.d/mandos"
131
176
#define SECKEY "seckey.txt"
132
177
#define PUBKEY "pubkey.txt"
178
#define TLS_PRIVKEY "tls-privkey.pem"
179
#define TLS_PUBKEY "tls-pubkey.pem"
133
180
#define HOOKDIR "/lib/mandos/network-hooks.d"
134
181
135
182
bool debug = false;
139
186
static const char sys_class_net[] = "/sys/class/net";
140
187
char *connect_to = NULL;
141
188
const char *hookdir = HOOKDIR;
189
int hookdir_fd = -1;
142
190
uid_t uid = 65534;
143
191
gid_t gid = 65534;
144
192
145
193
/* Doubly linked list that need to be circularly linked when used */
146
194
typedef struct server{
147
195
const char *ip;
148
uint16_t port;
196
in_port_t port;
149
197
AvahiIfIndex if_index;
150
198
int af;
151
199
struct timespec last_seen;
155
203
156
204
/* Used for passing in values through the Avahi callback functions */
157
205
typedef struct {
158
AvahiSimplePoll *simple_poll;
159
206
AvahiServer *server;
160
207
gnutls_certificate_credentials_t cred;
161
208
unsigned int dh_bits;
163
210
const char *priority;
164
211
gpgme_ctx_t ctx;
165
212
server *current_server;
213
char *interfaces;
214
size_t interfaces_size;
166
215
} mandos_context;
167
216
168
/* global context so signal handler can reach it*/
169
mandos_context mc = { .simple_poll = NULL, .server = NULL,
170
.dh_bits = 1024, .priority = "SECURE256"
171
":!CTYPE-X.509:+CTYPE-OPENPGP",
172
.current_server = NULL };
217
/* global so signal handler can reach it*/
218
AvahiSimplePoll *simple_poll;
173
219
174
220
sig_atomic_t quit_now = 0;
175
221
int signal_received = 0;
183
229
perror(print_text);
184
230
}
185
231
186
__attribute__((format (gnu_printf, 2, 3)))
232
__attribute__((format (gnu_printf, 2, 3), nonnull))
187
233
int fprintf_plus(FILE *stream, const char *format, ...){
188
234
va_list ap;
189
235
va_start (ap, format);
190
236
191
237
TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
192
238
program_invocation_short_name));
193
return TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
239
return (int)TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
194
240
}
195
241
196
242
/*
198
244
* bytes. "buffer_capacity" is how much is currently allocated,
199
245
* "buffer_length" is how much is already used.
200
246
*/
247
__attribute__((nonnull, warn_unused_result))
201
248
size_t incbuffer(char **buffer, size_t buffer_length,
202
249
size_t buffer_capacity){
203
250
if(buffer_length + BUFFER_SIZE > buffer_capacity){
204
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
205
if(buffer == NULL){
251
char *new_buf = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
252
if(new_buf == NULL){
253
int old_errno = errno;
254
free(*buffer);
255
errno = old_errno;
256
*buffer = NULL;
206
257
return 0;
207
258
}
259
*buffer = new_buf;
208
260
buffer_capacity += BUFFER_SIZE;
209
261
}
210
262
return buffer_capacity;
211
263
}
212
264
213
265
/* Add server to set of servers to retry periodically */
214
bool add_server(const char *ip, uint16_t port, AvahiIfIndex if_index,
215
int af){
266
__attribute__((nonnull, warn_unused_result))
267
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
268
int af, server **current_server){
216
269
int ret;
217
270
server *new_server = malloc(sizeof(server));
218
271
if(new_server == NULL){
225
278
.af = af };
226
279
if(new_server->ip == NULL){
227
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);
228
296
return false;
229
297
}
230
298
/* Special case of first server */
231
if (mc.current_server == NULL){
299
if(*current_server == NULL){
232
300
new_server->next = new_server;
233
301
new_server->prev = new_server;
234
mc.current_server = new_server;
235
/* Place the new server last in the list */
302
*current_server = new_server;
236
303
} else {
237
new_server->next = mc.current_server;
238
new_server->prev = mc.current_server->prev;
304
/* Place the new server last in the list */
305
new_server->next = *current_server;
306
new_server->prev = (*current_server)->prev;
239
307
new_server->prev->next = new_server;
240
mc.current_server->prev = new_server;
241
}
242
ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);
243
if(ret == -1){
244
perror_plus("clock_gettime");
245
return false;
308
(*current_server)->prev = new_server;
246
309
}
247
310
return true;
248
311
}
249
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
250
365
/*
251
366
* Initialize GPGME.
252
367
*/
253
static bool init_gpgme(const char *seckey, const char *pubkey,
254
const char *tempdir){
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){
255
373
gpgme_error_t rc;
256
374
gpgme_engine_info_t engine_info;
257
375
258
259
376
/*
260
377
* Helper function to insert pub and seckey to the engine keyring.
261
378
*/
262
bool import_key(const char *filename){
379
bool import_key(const char * const filename){
263
380
int ret;
264
381
int fd;
265
382
gpgme_data_t pgp_data;
270
387
return false;
271
388
}
272
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
273
439
rc = gpgme_data_new_from_fd(&pgp_data, fd);
274
440
if(rc != GPG_ERR_NO_ERROR){
275
441
fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
277
443
return false;
278
444
}
279
445
280
rc = gpgme_op_import(mc.ctx, pgp_data);
446
rc = gpgme_op_import(mc->ctx, pgp_data);
281
447
if(rc != GPG_ERR_NO_ERROR){
282
448
fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
283
449
gpgme_strsource(rc), gpgme_strerror(rc));
284
450
return false;
285
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
}
286
527
287
ret = (int)TEMP_FAILURE_RETRY(close(fd));
528
ret = close(fd);
288
529
if(ret == -1){
289
530
perror_plus("close");
290
531
}
327
568
}
328
569
329
570
/* Create new GPGME "context" */
330
rc = gpgme_new(&(mc.ctx));
571
rc = gpgme_new(&(mc->ctx));
331
572
if(rc != GPG_ERR_NO_ERROR){
332
fprintf_plus(stderr, "Mandos plugin mandos-client: "
333
"bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
334
gpgme_strerror(rc));
573
fprintf_plus(stderr, "bad gpgme_new: %s: %s\n",
574
gpgme_strsource(rc), gpgme_strerror(rc));
335
575
return false;
336
576
}
337
577
346
586
* Decrypt OpenPGP data.
347
587
* Returns -1 on error
348
588
*/
589
__attribute__((nonnull, warn_unused_result))
349
590
static ssize_t pgp_packet_decrypt(const char *cryptotext,
350
591
size_t crypto_size,
351
char **plaintext){
592
char **plaintext,
593
mandos_context *mc){
352
594
gpgme_data_t dh_crypto, dh_plain;
353
595
gpgme_error_t rc;
354
596
ssize_t ret;
371
613
/* Create new empty GPGME data buffer for the plaintext */
372
614
rc = gpgme_data_new(&dh_plain);
373
615
if(rc != GPG_ERR_NO_ERROR){
374
fprintf_plus(stderr, "Mandos plugin mandos-client: "
375
"bad gpgme_data_new: %s: %s\n",
616
fprintf_plus(stderr, "bad gpgme_data_new: %s: %s\n",
376
617
gpgme_strsource(rc), gpgme_strerror(rc));
377
618
gpgme_data_release(dh_crypto);
378
619
return -1;
380
621
381
622
/* Decrypt data from the cryptotext data buffer to the plaintext
382
623
data buffer */
383
rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
624
rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
384
625
if(rc != GPG_ERR_NO_ERROR){
385
626
fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
386
627
gpgme_strsource(rc), gpgme_strerror(rc));
387
628
plaintext_length = -1;
388
629
if(debug){
389
630
gpgme_decrypt_result_t result;
390
result = gpgme_op_decrypt_result(mc.ctx);
631
result = gpgme_op_decrypt_result(mc->ctx);
391
632
if(result == NULL){
392
633
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
393
634
} else {
394
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
395
result->unsupported_algorithm);
396
fprintf_plus(stderr, "Wrong key usage: %u\n",
397
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");
398
641
if(result->file_name != NULL){
399
642
fprintf_plus(stderr, "File name: %s\n", result->file_name);
400
643
}
401
gpgme_recipient_t recipient;
402
recipient = result->recipients;
403
while(recipient != NULL){
644
645
for(gpgme_recipient_t r = result->recipients; r != NULL;
646
r = r->next){
404
647
fprintf_plus(stderr, "Public key algorithm: %s\n",
405
gpgme_pubkey_algo_name
406
(recipient->pubkey_algo));
407
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);
408
650
fprintf_plus(stderr, "Secret key available: %s\n",
409
recipient->status == GPG_ERR_NO_SECKEY
410
? "No" : "Yes");
411
recipient = recipient->next;
651
r->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
412
652
}
413
653
}
414
654
}
470
710
return plaintext_length;
471
711
}
472
712
473
static const char * safer_gnutls_strerror(int value){
474
const char *ret = gnutls_strerror(value); /* Spurious warning from
475
-Wunreachable-code */
476
if(ret == NULL)
477
ret = "(unknown)";
478
return ret;
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){
722
const char *ret = gnutls_strerror(value);
723
return safe_string(ret);
479
724
}
480
725
481
726
/* GnuTLS log function callback */
727
__attribute__((nonnull))
482
728
static void debuggnutls(__attribute__((unused)) int level,
483
729
const char* string){
484
730
fprintf_plus(stderr, "GnuTLS: %s", string);
485
731
}
486
732
733
__attribute__((nonnull(1, 2, 4), warn_unused_result))
487
734
static int init_gnutls_global(const char *pubkeyfilename,
488
const char *seckeyfilename){
735
const char *seckeyfilename,
736
const char *dhparamsfilename,
737
mandos_context *mc){
489
738
int ret;
490
739
491
740
if(debug){
492
741
fprintf_plus(stderr, "Initializing GnuTLS\n");
493
742
}
494
743
495
ret = gnutls_global_init();
496
if(ret != GNUTLS_E_SUCCESS){
497
fprintf_plus(stderr, "GnuTLS global_init: %s\n",
498
safer_gnutls_strerror(ret));
499
return -1;
500
}
501
502
744
if(debug){
503
745
/* "Use a log level over 10 to enable all debugging options."
504
746
* - GnuTLS manual
508
750
}
509
751
510
752
/* OpenPGP credentials */
511
ret = gnutls_certificate_allocate_credentials(&mc.cred);
753
ret = gnutls_certificate_allocate_credentials(&mc->cred);
512
754
if(ret != GNUTLS_E_SUCCESS){
513
755
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
514
756
safer_gnutls_strerror(ret));
515
gnutls_global_deinit();
516
757
return -1;
517
758
}
518
759
519
760
if(debug){
520
fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
521
" 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",
522
763
pubkeyfilename,
523
764
seckeyfilename);
524
765
}
525
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
526
780
ret = gnutls_certificate_set_openpgp_key_file
527
(mc.cred, pubkeyfilename, seckeyfilename,
781
(mc->cred, pubkeyfilename, seckeyfilename,
528
782
GNUTLS_OPENPGP_FMT_BASE64);
783
#else
784
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
785
#endif
529
786
if(ret != GNUTLS_E_SUCCESS){
530
787
fprintf_plus(stderr,
531
"Error[%d] while reading the OpenPGP key pair ('%s',"
788
"Error[%d] while reading the key pair ('%s',"
532
789
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
533
790
fprintf_plus(stderr, "The GnuTLS error is: %s\n",
534
791
safer_gnutls_strerror(ret));
536
793
}
537
794
538
795
/* GnuTLS server initialization */
539
ret = gnutls_dh_params_init(&mc.dh_params);
796
ret = gnutls_dh_params_init(&mc->dh_params);
540
797
if(ret != GNUTLS_E_SUCCESS){
541
798
fprintf_plus(stderr, "Error in GnuTLS DH parameter"
542
799
" initialization: %s\n",
543
800
safer_gnutls_strerror(ret));
544
801
goto globalfail;
545
802
}
546
ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
547
if(ret != GNUTLS_E_SUCCESS){
548
fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
549
safer_gnutls_strerror(ret));
550
goto globalfail;
551
}
552
553
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
}
554
985
555
986
return 0;
556
987
557
988
globalfail:
558
989
559
gnutls_certificate_free_credentials(mc.cred);
560
gnutls_global_deinit();
561
gnutls_dh_params_deinit(mc.dh_params);
990
gnutls_certificate_free_credentials(mc->cred);
991
gnutls_dh_params_deinit(mc->dh_params);
562
992
return -1;
563
993
}
564
994
565
static int init_gnutls_session(gnutls_session_t *session){
995
__attribute__((nonnull, warn_unused_result))
996
static int init_gnutls_session(gnutls_session_t *session,
997
mandos_context *mc){
566
998
int ret;
567
999
/* GnuTLS session creation */
568
1000
do {
569
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
));
570
1009
if(quit_now){
571
1010
return -1;
572
1011
}
580
1019
{
581
1020
const char *err;
582
1021
do {
583
ret = gnutls_priority_set_direct(*session, mc.priority, &err);
1022
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
584
1023
if(quit_now){
585
1024
gnutls_deinit(*session);
586
1025
return -1;
597
1036
598
1037
do {
599
1038
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
600
mc.cred);
1039
mc->cred);
601
1040
if(quit_now){
602
1041
gnutls_deinit(*session);
603
1042
return -1;
613
1052
/* ignore client certificate if any. */
614
1053
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
615
1054
616
gnutls_dh_set_prime_bits(*session, mc.dh_bits);
617
618
1055
return 0;
619
1056
}
620
1057
622
1059
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
623
1060
__attribute__((unused)) const char *txt){}
624
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
625
1235
/* Called when a Mandos server is found */
626
static int start_mandos_communication(const char *ip, uint16_t port,
1236
__attribute__((nonnull, warn_unused_result))
1237
static int start_mandos_communication(const char *ip, in_port_t port,
627
1238
AvahiIfIndex if_index,
628
int af){
1239
int af, mandos_context *mc){
629
1240
int ret, tcp_sd = -1;
630
1241
ssize_t sret;
631
union {
632
struct sockaddr_in in;
633
struct sockaddr_in6 in6;
634
} to;
1242
struct sockaddr_storage to;
635
1243
char *buffer = NULL;
636
1244
char *decrypted_buffer = NULL;
637
1245
size_t buffer_length = 0;
640
1248
int retval = -1;
641
1249
gnutls_session_t session;
642
1250
int pf; /* Protocol family */
1251
bool route_added = false;
643
1252
644
1253
errno = 0;
645
1254
661
1270
return -1;
662
1271
}
663
1272
664
ret = init_gnutls_session(&session);
1273
/* If the interface is specified and we have a list of interfaces */
1274
if(if_index != AVAHI_IF_UNSPEC and mc->interfaces != NULL){
1275
/* Check if the interface is one of the interfaces we are using */
1276
bool match = false;
1277
{
1278
char *interface = NULL;
1279
while((interface = argz_next(mc->interfaces,
1280
mc->interfaces_size,
1281
interface))){
1282
if(if_nametoindex(interface) == (unsigned int)if_index){
1283
match = true;
1284
break;
1285
}
1286
}
1287
}
1288
if(not match){
1289
/* This interface does not match any in the list, so we don't
1290
connect to the server */
1291
if(debug){
1292
char interface[IF_NAMESIZE];
1293
if(if_indextoname((unsigned int)if_index, interface) == NULL){
1294
perror_plus("if_indextoname");
1295
} else {
1296
fprintf_plus(stderr, "Skipping server on non-used interface"
1297
" \"%s\"\n",
1298
if_indextoname((unsigned int)if_index,
1299
interface));
1300
}
1301
}
1302
return -1;
1303
}
1304
}
1305
1306
ret = init_gnutls_session(&session, mc);
665
1307
if(ret != 0){
666
1308
return -1;
667
1309
}
668
1310
669
1311
if(debug){
670
1312
fprintf_plus(stderr, "Setting up a TCP connection to %s, port %"
671
PRIu16 "\n", ip, port);
1313
PRIuMAX "\n", ip, (uintmax_t)port);
672
1314
}
673
1315
674
tcp_sd = socket(pf, SOCK_STREAM, 0);
1316
tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
675
1317
if(tcp_sd < 0){
676
1318
int e = errno;
677
1319
perror_plus("socket");
684
1326
goto mandos_end;
685
1327
}
686
1328
687
memset(&to, 0, sizeof(to));
688
1329
if(af == AF_INET6){
689
to.in6.sin6_family = (sa_family_t)af;
690
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);
691
1333
} else { /* IPv4 */
692
to.in.sin_family = (sa_family_t)af;
693
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);
694
1337
}
695
1338
if(ret < 0 ){
696
1339
int e = errno;
705
1348
goto mandos_end;
706
1349
}
707
1350
if(af == AF_INET6){
708
to.in6.sin6_port = htons(port); /* Spurious warnings from
709
-Wconversion and
710
-Wunreachable-code */
711
712
if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
713
(&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
714
-Wunreachable-code*/
1351
((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
1352
if(IN6_IS_ADDR_LINKLOCAL
1353
(&((struct sockaddr_in6 *)&to)->sin6_addr)){
715
1354
if(if_index == AVAHI_IF_UNSPEC){
716
1355
fprintf_plus(stderr, "An IPv6 link-local address is"
717
1356
" incomplete without a network interface\n");
719
1358
goto mandos_end;
720
1359
}
721
1360
/* Set the network interface number as scope */
722
to.in6.sin6_scope_id = (uint32_t)if_index;
1361
((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
723
1362
}
724
1363
} else {
725
to.in.sin_port = htons(port); /* Spurious warnings from
726
-Wconversion and
727
-Wunreachable-code */
1364
((struct sockaddr_in *)&to)->sin_port = htons(port);
728
1365
}
729
1366
730
1367
if(quit_now){
738
1375
if(if_indextoname((unsigned int)if_index, interface) == NULL){
739
1376
perror_plus("if_indextoname");
740
1377
} else {
741
fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIu16
742
"\n", ip, interface, port);
1378
fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIuMAX
1379
"\n", ip, interface, (uintmax_t)port);
743
1380
}
744
1381
} else {
745
fprintf_plus(stderr, "Connection to: %s, port %" PRIu16 "\n",
746
ip, port);
1382
fprintf_plus(stderr, "Connection to: %s, port %" PRIuMAX "\n",
1383
ip, (uintmax_t)port);
747
1384
}
748
1385
char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
749
1386
INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
750
const char *pcret;
751
if(af == AF_INET6){
752
pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
753
sizeof(addrstr));
754
} else {
755
pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
756
sizeof(addrstr));
757
}
758
if(pcret == NULL){
759
perror_plus("inet_ntop");
760
} else {
761
if(strcmp(addrstr, ip) != 0){
762
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
763
}
764
}
765
}
766
767
if(quit_now){
768
errno = EINTR;
769
goto mandos_end;
770
}
771
772
if(af == AF_INET6){
773
ret = connect(tcp_sd, &to.in6, sizeof(to));
774
} else {
775
ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
776
}
777
if(ret < 0){
778
if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
779
int e = errno;
780
perror_plus("connect");
781
errno = e;
782
}
783
goto mandos_end;
784
}
785
786
if(quit_now){
787
errno = EINTR;
788
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;
789
1467
}
790
1468
791
1469
const char *out = mandos_protocol_version;
942
1620
if(buffer_length > 0){
943
1621
ssize_t decrypted_buffer_size;
944
1622
decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
945
&decrypted_buffer);
1623
&decrypted_buffer, mc);
946
1624
if(decrypted_buffer_size >= 0){
947
1625
1626
clearerr(stdout);
948
1627
written = 0;
949
1628
while(written < (size_t) decrypted_buffer_size){
950
1629
if(quit_now){
966
1645
}
967
1646
written += (size_t)ret;
968
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
}
969
1658
retval = 0;
970
1659
}
971
1660
}
974
1663
975
1664
mandos_end:
976
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
}
977
1672
int e = errno;
978
1673
free(decrypted_buffer);
979
1674
free(buffer);
980
1675
if(tcp_sd >= 0){
981
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
1676
ret = close(tcp_sd);
982
1677
}
983
1678
if(ret == -1){
984
1679
if(e == 0){
1009
1704
AVAHI_GCC_UNUSED AvahiStringList *txt,
1010
1705
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1011
1706
flags,
1012
AVAHI_GCC_UNUSED void* userdata){
1013
assert(r);
1707
void *mc){
1708
if(r == NULL){
1709
return;
1710
}
1014
1711
1015
1712
/* Called whenever a service has been resolved successfully or
1016
1713
timed out */
1017
1714
1018
1715
if(quit_now){
1716
avahi_s_service_resolver_free(r);
1019
1717
return;
1020
1718
}
1021
1719
1025
1723
fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
1026
1724
"'%s' of type '%s' in domain '%s': %s\n", name, type,
1027
1725
domain,
1028
avahi_strerror(avahi_server_errno(mc.server)));
1726
avahi_strerror(avahi_server_errno
1727
(((mandos_context*)mc)->server)));
1029
1728
break;
1030
1729
1031
1730
case AVAHI_RESOLVER_FOUND:
1037
1736
PRIdMAX ") on port %" PRIu16 "\n", name,
1038
1737
host_name, ip, (intmax_t)interface, port);
1039
1738
}
1040
int ret = start_mandos_communication(ip, port, interface,
1041
avahi_proto_to_af(proto));
1739
int ret = start_mandos_communication(ip, (in_port_t)port,
1740
interface,
1741
avahi_proto_to_af(proto),
1742
mc);
1042
1743
if(ret == 0){
1043
avahi_simple_poll_quit(mc.simple_poll);
1744
avahi_simple_poll_quit(simple_poll);
1044
1745
} else {
1045
if(not add_server(ip, port, interface,
1046
avahi_proto_to_af(proto))){
1746
if(not add_server(ip, (in_port_t)port, interface,
1747
avahi_proto_to_af(proto),
1748
&((mandos_context*)mc)->current_server)){
1047
1749
fprintf_plus(stderr, "Failed to add server \"%s\" to server"
1048
1750
" list\n", name);
1049
1751
}
1062
1764
const char *domain,
1063
1765
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1064
1766
flags,
1065
AVAHI_GCC_UNUSED void* userdata){
1066
assert(b);
1767
void *mc){
1768
if(b == NULL){
1769
return;
1770
}
1067
1771
1068
1772
/* Called whenever a new services becomes available on the LAN or
1069
1773
is removed from the LAN */
1077
1781
case AVAHI_BROWSER_FAILURE:
1078
1782
1079
1783
fprintf_plus(stderr, "(Avahi browser) %s\n",
1080
avahi_strerror(avahi_server_errno(mc.server)));
1081
avahi_simple_poll_quit(mc.simple_poll);
1784
avahi_strerror(avahi_server_errno
1785
(((mandos_context*)mc)->server)));
1786
avahi_simple_poll_quit(simple_poll);
1082
1787
return;
1083
1788
1084
1789
case AVAHI_BROWSER_NEW:
1087
1792
the callback function is called the Avahi server will free the
1088
1793
resolver for us. */
1089
1794
1090
if(avahi_s_service_resolver_new(mc.server, interface, protocol,
1091
name, type, domain, protocol, 0,
1092
resolve_callback, NULL) == NULL)
1795
if(avahi_s_service_resolver_new(((mandos_context*)mc)->server,
1796
interface, protocol, name, type,
1797
domain, protocol, 0,
1798
resolve_callback, mc) == NULL)
1093
1799
fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
1094
1800
" %s\n", name,
1095
avahi_strerror(avahi_server_errno(mc.server)));
1801
avahi_strerror(avahi_server_errno
1802
(((mandos_context*)mc)->server)));
1096
1803
break;
1097
1804
1098
1805
case AVAHI_BROWSER_REMOVE:
1117
1824
signal_received = sig;
1118
1825
int old_errno = errno;
1119
1826
/* set main loop to exit */
1120
if(mc.simple_poll != NULL){
1121
avahi_simple_poll_quit(mc.simple_poll);
1827
if(simple_poll != NULL){
1828
avahi_simple_poll_quit(simple_poll);
1122
1829
}
1123
1830
errno = old_errno;
1124
1831
}
1125
1832
1833
__attribute__((nonnull, warn_unused_result))
1126
1834
bool get_flags(const char *ifname, struct ifreq *ifr){
1127
1835
int ret;
1128
error_t ret_errno;
1836
int old_errno;
1129
1837
1130
1838
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1131
1839
if(s < 0){
1132
ret_errno = errno;
1840
old_errno = errno;
1133
1841
perror_plus("socket");
1134
errno = ret_errno;
1842
errno = old_errno;
1135
1843
return false;
1136
1844
}
1137
strcpy(ifr->ifr_name, ifname);
1845
strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
1846
ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
1138
1847
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1139
1848
if(ret == -1){
1140
1849
if(debug){
1141
ret_errno = errno;
1850
old_errno = errno;
1142
1851
perror_plus("ioctl SIOCGIFFLAGS");
1143
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;
1144
1858
}
1145
1859
return false;
1146
1860
}
1861
if((close(s) == -1) and debug){
1862
old_errno = errno;
1863
perror_plus("close");
1864
errno = old_errno;
1865
}
1147
1866
return true;
1148
1867
}
1149
1868
1869
__attribute__((nonnull, warn_unused_result))
1150
1870
bool good_flags(const char *ifname, const struct ifreq *ifr){
1151
1871
1152
1872
/* Reject the loopback device */
1194
1914
* corresponds to an acceptable network device.
1195
1915
* (This function is passed to scandir(3) as a filter function.)
1196
1916
*/
1917
__attribute__((nonnull, warn_unused_result))
1197
1918
int good_interface(const struct dirent *if_entry){
1198
1919
if(if_entry->d_name[0] == '.'){
1199
1920
return 0;
1217
1938
/*
1218
1939
* This function determines if a network interface is up.
1219
1940
*/
1941
__attribute__((nonnull, warn_unused_result))
1220
1942
bool interface_is_up(const char *interface){
1221
1943
struct ifreq ifr;
1222
1944
if(not get_flags(interface, &ifr)){
1233
1955
/*
1234
1956
* This function determines if a network interface is running
1235
1957
*/
1958
__attribute__((nonnull, warn_unused_result))
1236
1959
bool interface_is_running(const char *interface){
1237
1960
struct ifreq ifr;
1238
1961
if(not get_flags(interface, &ifr)){
1246
1969
return (bool)(ifr.ifr_flags & IFF_RUNNING);
1247
1970
}
1248
1971
1972
__attribute__((nonnull, pure, warn_unused_result))
1249
1973
int notdotentries(const struct dirent *direntry){
1250
1974
/* Skip "." and ".." */
1251
1975
if(direntry->d_name[0] == '.'
1258
1982
}
1259
1983
1260
1984
/* Is this directory entry a runnable program? */
1985
__attribute__((nonnull, warn_unused_result))
1261
1986
int runnable_hook(const struct dirent *direntry){
1262
1987
int ret;
1263
1988
size_t sret;
1271
1996
sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1272
1997
"abcdefghijklmnopqrstuvwxyz"
1273
1998
"0123456789"
1274
"_-");
1999
"_.-");
1275
2000
if((direntry->d_name)[sret] != '\0'){
1276
2001
/* Contains non-allowed characters */
1277
2002
if(debug){
1281
2006
return 0;
1282
2007
}
1283
2008
1284
char *fullname = NULL;
1285
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1286
if(ret < 0){
1287
perror_plus("asprintf");
1288
return 0;
1289
}
1290
1291
ret = stat(fullname, &st);
2009
ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1292
2010
if(ret == -1){
1293
2011
if(debug){
1294
2012
perror_plus("Could not stat hook");
1318
2036
return 1;
1319
2037
}
1320
2038
1321
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval){
2039
__attribute__((nonnull, warn_unused_result))
2040
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
2041
mandos_context *mc){
1322
2042
int ret;
1323
2043
struct timespec now;
1324
2044
struct timespec waited_time;
1325
2045
intmax_t block_time;
1326
2046
1327
2047
while(true){
1328
if(mc.current_server == NULL){
1329
if (debug){
2048
if(mc->current_server == NULL){
2049
if(debug){
1330
2050
fprintf_plus(stderr, "Wait until first server is found."
1331
2051
" No timeout!\n");
1332
2052
}
1333
2053
ret = avahi_simple_poll_iterate(s, -1);
1334
2054
} else {
1335
if (debug){
2055
if(debug){
1336
2056
fprintf_plus(stderr, "Check current_server if we should run"
1337
2057
" it, or wait\n");
1338
2058
}
1345
2065
/* Calculating in ms how long time between now and server
1346
2066
who we visted longest time ago. Now - last seen. */
1347
2067
waited_time.tv_sec = (now.tv_sec
1348
- mc.current_server->last_seen.tv_sec);
2068
- mc->current_server->last_seen.tv_sec);
1349
2069
waited_time.tv_nsec = (now.tv_nsec
1350
- mc.current_server->last_seen.tv_nsec);
2070
- mc->current_server->last_seen.tv_nsec);
1351
2071
/* total time is 10s/10,000ms.
1352
2072
Converting to s from ms by dividing by 1,000,
1353
2073
and ns to ms by dividing by 1,000,000. */
1355
2075
- ((intmax_t)waited_time.tv_sec * 1000))
1356
2076
- ((intmax_t)waited_time.tv_nsec / 1000000));
1357
2077
1358
if (debug){
2078
if(debug){
1359
2079
fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1360
2080
block_time);
1361
2081
}
1362
2082
1363
2083
if(block_time <= 0){
1364
ret = start_mandos_communication(mc.current_server->ip,
1365
mc.current_server->port,
1366
mc.current_server->if_index,
1367
mc.current_server->af);
2084
ret = start_mandos_communication(mc->current_server->ip,
2085
mc->current_server->port,
2086
mc->current_server->if_index,
2087
mc->current_server->af, mc);
1368
2088
if(ret == 0){
1369
avahi_simple_poll_quit(mc.simple_poll);
2089
avahi_simple_poll_quit(s);
1370
2090
return 0;
1371
2091
}
1372
2092
ret = clock_gettime(CLOCK_MONOTONIC,
1373
&mc.current_server->last_seen);
2093
&mc->current_server->last_seen);
1374
2094
if(ret == -1){
1375
2095
perror_plus("clock_gettime");
1376
2096
return -1;
1377
2097
}
1378
mc.current_server = mc.current_server->next;
2098
mc->current_server = mc->current_server->next;
1379
2099
block_time = 0; /* Call avahi to find new Mandos
1380
2100
servers, but don't block */
1381
2101
}
1383
2103
ret = avahi_simple_poll_iterate(s, (int)block_time);
1384
2104
}
1385
2105
if(ret != 0){
1386
if (ret > 0 or errno != EINTR){
2106
if(ret > 0 or errno != EINTR){
1387
2107
return (ret != 1) ? ret : 0;
1388
2108
}
1389
2109
}
1390
2110
}
1391
2111
}
1392
2112
1393
/* Set effective uid to 0, return errno */
1394
error_t raise_privileges(void){
1395
error_t old_errno = errno;
1396
error_t ret_errno = 0;
1397
if(seteuid(0) == -1){
1398
ret_errno = errno;
1399
perror_plus("seteuid");
1400
}
1401
errno = old_errno;
1402
return ret_errno;
1403
}
1404
1405
/* Set effective and real user ID to 0. Return errno. */
1406
error_t raise_privileges_permanently(void){
1407
error_t old_errno = errno;
1408
error_t ret_errno = raise_privileges();
1409
if(ret_errno != 0){
1410
errno = old_errno;
1411
return ret_errno;
1412
}
1413
if(setuid(0) == -1){
1414
ret_errno = errno;
1415
perror_plus("seteuid");
1416
}
1417
errno = old_errno;
1418
return ret_errno;
1419
}
1420
1421
/* Set effective user ID to unprivileged saved user ID */
1422
error_t lower_privileges(void){
1423
error_t old_errno = errno;
1424
error_t ret_errno = 0;
1425
if(seteuid(uid) == -1){
1426
ret_errno = errno;
1427
perror_plus("seteuid");
1428
}
1429
errno = old_errno;
1430
return ret_errno;
1431
}
1432
1433
/* Lower privileges permanently */
1434
error_t lower_privileges_permanently(void){
1435
error_t old_errno = errno;
1436
error_t ret_errno = 0;
1437
if(setuid(uid) == -1){
1438
ret_errno = errno;
1439
perror_plus("setuid");
1440
}
1441
errno = old_errno;
1442
return ret_errno;
1443
}
1444
1445
bool run_network_hooks(const char *mode, const char *interface,
2113
__attribute__((nonnull))
2114
void run_network_hooks(const char *mode, const char *interface,
1446
2115
const float delay){
1447
struct dirent **direntries;
1448
struct dirent *direntry;
1449
int ret;
1450
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1451
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);
1452
2139
if(numhooks == -1){
1453
2140
perror_plus("scandir");
1454
} else {
1455
int devnull = open("/dev/null", O_RDONLY);
1456
for(int i = 0; i < numhooks; i++){
1457
direntry = direntries[i];
1458
char *fullname = NULL;
1459
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1460
if(ret < 0){
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);
2151
}
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){
1461
2198
perror_plus("asprintf");
1462
continue;
1463
}
1464
if(debug){
1465
fprintf_plus(stderr, "Running network hook \"%s\"\n",
1466
direntry->d_name);
1467
}
1468
pid_t hook_pid = fork();
1469
if(hook_pid == 0){
1470
/* Child */
1471
/* Raise privileges */
1472
raise_privileges_permanently();
1473
/* Set group */
1474
errno = 0;
1475
ret = setgid(0);
1476
if(ret == -1){
1477
perror_plus("setgid");
1478
}
1479
/* Reset supplementary groups */
1480
errno = 0;
1481
ret = setgroups(0, NULL);
1482
if(ret == -1){
1483
perror_plus("setgroups");
1484
}
1485
dup2(devnull, STDIN_FILENO);
1486
close(devnull);
1487
dup2(STDERR_FILENO, STDOUT_FILENO);
1488
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1489
if(ret == -1){
1490
perror_plus("setenv");
1491
_exit(EX_OSERR);
1492
}
1493
ret = setenv("DEVICE", interface, 1);
1494
if(ret == -1){
1495
perror_plus("setenv");
1496
_exit(EX_OSERR);
1497
}
1498
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
1499
if(ret == -1){
1500
perror_plus("setenv");
1501
_exit(EX_OSERR);
1502
}
1503
ret = setenv("MODE", mode, 1);
1504
if(ret == -1){
1505
perror_plus("setenv");
1506
_exit(EX_OSERR);
1507
}
1508
char *delaystring;
1509
ret = asprintf(&delaystring, "%f", delay);
1510
if(ret == -1){
1511
perror_plus("asprintf");
1512
_exit(EX_OSERR);
1513
}
1514
ret = setenv("DELAY", delaystring, 1);
1515
if(ret == -1){
1516
free(delaystring);
1517
perror_plus("setenv");
1518
_exit(EX_OSERR);
1519
}
2199
_exit(EX_OSERR);
2200
}
2201
ret = setenv("DELAY", delaystring, 1);
2202
if(ret == -1){
1520
2203
free(delaystring);
1521
if(connect_to != NULL){
1522
ret = setenv("CONNECT", connect_to, 1);
1523
if(ret == -1){
1524
perror_plus("setenv");
1525
_exit(EX_OSERR);
1526
}
1527
}
1528
if(execl(fullname, direntry->d_name, mode, NULL) == -1){
1529
perror_plus("execl");
1530
_exit(EXIT_FAILURE);
1531
}
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;
1532
2272
} else {
1533
int status;
1534
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1535
perror_plus("waitpid");
1536
free(fullname);
1537
continue;
1538
}
1539
if(WIFEXITED(status)){
1540
if(WEXITSTATUS(status) != 0){
1541
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1542
" with status %d\n", direntry->d_name,
1543
WEXITSTATUS(status));
1544
free(fullname);
1545
continue;
1546
}
1547
} else if(WIFSIGNALED(status)){
1548
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1549
" signal %d\n", direntry->d_name,
1550
WTERMSIG(status));
1551
free(fullname);
1552
continue;
1553
} else {
1554
fprintf_plus(stderr, "Warning: network hook \"%s\""
1555
" crashed\n", direntry->d_name);
1556
free(fullname);
1557
continue;
1558
}
1559
}
1560
free(fullname);
1561
if(debug){
1562
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1563
direntry->d_name);
1564
}
1565
}
1566
close(devnull);
1567
}
1568
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);
1569
2292
}
1570
2293
1571
error_t bring_up_interface(const char *const interface,
1572
const float delay){
1573
int sd = -1;
1574
error_t old_errno = errno;
1575
error_t ret_errno = 0;
1576
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;
1577
2299
struct ifreq network;
1578
2300
unsigned int if_index = if_nametoindex(interface);
1579
2301
if(if_index == 0){
1588
2310
}
1589
2311
1590
2312
if(not interface_is_up(interface)){
1591
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)){
1592
2316
ret_errno = errno;
1593
2317
fprintf_plus(stderr, "Failed to get flags for interface "
1594
2318
"\"%s\"\n", interface);
2319
errno = old_errno;
1595
2320
return ret_errno;
1596
2321
}
1597
network.ifr_flags |= IFF_UP;
2322
network.ifr_flags |= IFF_UP; /* set flag */
1598
2323
1599
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1600
if(sd < 0){
2324
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
2325
if(sd == -1){
1601
2326
ret_errno = errno;
1602
2327
perror_plus("socket");
1603
2328
errno = old_errno;
1604
2329
return ret_errno;
1605
2330
}
1606
2331
1607
2332
if(quit_now){
1608
close(sd);
2333
ret = close(sd);
2334
if(ret == -1){
2335
perror_plus("close");
2336
}
1609
2337
errno = old_errno;
1610
2338
return EINTR;
1611
2339
}
1615
2343
interface);
1616
2344
}
1617
2345
1618
/* Raise priviliges */
1619
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
}
1620
2352
1621
2353
#ifdef __linux__
1622
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1623
messages about the network interface to mess up the prompt */
1624
int ret_linux = klogctl(8, NULL, 5);
1625
bool restore_loglevel = true;
1626
if(ret_linux == -1){
1627
restore_loglevel = false;
1628
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
}
1629
2365
}
1630
2366
#endif /* __linux__ */
1631
ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1632
ret_errno = errno;
2367
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
2368
ioctl_errno = errno;
1633
2369
#ifdef __linux__
1634
2370
if(restore_loglevel){
1635
2371
ret_linux = klogctl(7, NULL, 0);
1639
2375
}
1640
2376
#endif /* __linux__ */
1641
2377
1642
/* Lower privileges */
1643
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
}
1644
2387
1645
2388
/* Close the socket */
1646
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2389
ret = close(sd);
1647
2390
if(ret == -1){
1648
2391
perror_plus("close");
1649
2392
}
1650
2393
1651
2394
if(ret_setflags == -1){
1652
errno = ret_errno;
2395
errno = ioctl_errno;
1653
2396
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1654
2397
errno = old_errno;
1655
return ret_errno;
2398
return ioctl_errno;
1656
2399
}
1657
2400
} else if(debug){
1658
2401
fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
1661
2404
1662
2405
/* Sleep checking until interface is running.
1663
2406
Check every 0.25s, up to total time of delay */
1664
for(int i=0; i < delay * 4; i++){
2407
for(int i = 0; i < delay * 4; i++){
1665
2408
if(interface_is_running(interface)){
1666
2409
break;
1667
2410
}
1676
2419
return 0;
1677
2420
}
1678
2421
1679
error_t take_down_interface(const char *const interface){
1680
int sd = -1;
1681
error_t old_errno = errno;
1682
error_t ret_errno = 0;
1683
int ret, ret_setflags;
2422
__attribute__((nonnull, warn_unused_result))
2423
int take_down_interface(const char *const interface){
2424
int old_errno = errno;
1684
2425
struct ifreq network;
1685
2426
unsigned int if_index = if_nametoindex(interface);
1686
2427
if(if_index == 0){
1689
2430
return ENXIO;
1690
2431
}
1691
2432
if(interface_is_up(interface)){
2433
int ret_errno = 0;
2434
int ioctl_errno = 0;
1692
2435
if(not get_flags(interface, &network) and debug){
1693
2436
ret_errno = errno;
1694
2437
fprintf_plus(stderr, "Failed to get flags for interface "
1695
2438
"\"%s\"\n", interface);
2439
errno = old_errno;
1696
2440
return ret_errno;
1697
2441
}
1698
2442
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
1699
2443
1700
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1701
if(sd < 0){
2444
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
2445
if(sd == -1){
1702
2446
ret_errno = errno;
1703
2447
perror_plus("socket");
1704
2448
errno = old_errno;
1710
2454
interface);
1711
2455
}
1712
2456
1713
/* Raise priviliges */
1714
raise_privileges();
1715
1716
ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1717
ret_errno = errno;
1718
1719
/* Lower privileges */
1720
lower_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
}
2463
2464
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
2465
ioctl_errno = errno;
2466
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
}
1721
2476
1722
2477
/* Close the socket */
1723
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2478
int ret = close(sd);
1724
2479
if(ret == -1){
1725
2480
perror_plus("close");
1726
2481
}
1727
2482
1728
2483
if(ret_setflags == -1){
1729
errno = ret_errno;
2484
errno = ioctl_errno;
1730
2485
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
1731
2486
errno = old_errno;
1732
return ret_errno;
2487
return ioctl_errno;
1733
2488
}
1734
2489
} else if(debug){
1735
2490
fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
1741
2496
}
1742
2497
1743
2498
int main(int argc, char *argv[]){
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 };
1744
2512
AvahiSServiceBrowser *sb = NULL;
1745
2513
error_t ret_errno;
1746
2514
int ret;
1747
2515
intmax_t tmpmax;
1748
2516
char *tmp;
1749
2517
int exitcode = EXIT_SUCCESS;
1750
char *interfaces = NULL;
1751
size_t interfaces_size = 0;
1752
2518
char *interfaces_to_take_down = NULL;
1753
2519
size_t interfaces_to_take_down_size = 0;
1754
char tempdir[] = "/tmp/mandosXXXXXX";
1755
bool tempdir_created = false;
2520
char run_tempdir[] = "/run/tmp/mandosXXXXXX";
2521
char old_tempdir[] = "/tmp/mandosXXXXXX";
2522
char *tempdir = NULL;
1756
2523
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1757
2524
const char *seckey = PATHDIR "/" SECKEY;
1758
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;
1759
2531
char *interfaces_hooks = NULL;
1760
size_t interfaces_hooks_size = 0;
1761
2532
1762
2533
bool gnutls_initialized = false;
1763
2534
bool gpgme_initialized = false;
1809
2580
{ .name = "pubkey", .key = 'p',
1810
2581
.arg = "FILE",
1811
2582
.doc = "OpenPGP public key file base name",
1812
.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 },
1813
2600
{ .name = "dh-bits", .key = 129,
1814
2601
.arg = "BITS",
1815
2602
.doc = "Bit length of the prime number used in the"
1816
2603
" Diffie-Hellman key exchange",
1817
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 },
1818
2610
{ .name = "priority", .key = 130,
1819
2611
.arg = "STRING",
1820
2612
.doc = "GnuTLS priority string for the TLS handshake",
1854
2646
connect_to = arg;
1855
2647
break;
1856
2648
case 'i': /* --interface */
1857
ret_errno = argz_add_sep(&interfaces, &interfaces_size, arg,
1858
(int)',');
2649
ret_errno = argz_add_sep(&mc.interfaces, &mc.interfaces_size,
2650
arg, (int)',');
1859
2651
if(ret_errno != 0){
1860
2652
argp_error(state, "%s", strerror(ret_errno));
1861
2653
}
1866
2658
case 'p': /* --pubkey */
1867
2659
pubkey = arg;
1868
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;
1869
2671
case 129: /* --dh-bits */
1870
2672
errno = 0;
1871
2673
tmpmax = strtoimax(arg, &tmp, 10);
1875
2677
}
1876
2678
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
1877
2679
break;
2680
case 134: /* --dh-params */
2681
dh_params_file = arg;
2682
break;
1878
2683
case 130: /* --priority */
1879
2684
mc.priority = arg;
1880
2685
break;
1903
2708
argp_state_help(state, state->out_stream,
1904
2709
(ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
1905
2710
& ~(unsigned int)ARGP_HELP_EXIT_OK);
2711
__builtin_unreachable();
1906
2712
case -3: /* --usage */
1907
2713
argp_state_help(state, state->out_stream,
1908
2714
ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
2715
__builtin_unreachable();
1909
2716
case 'V': /* --version */
1910
2717
fprintf_plus(state->out_stream, "%s\n", argp_program_version);
1911
2718
exit(argp_err_exit_status);
1920
2727
.args_doc = "",
1921
2728
.doc = "Mandos client -- Get and decrypt"
1922
2729
" passwords from a Mandos server" };
1923
ret = argp_parse(&argp, argc, argv,
1924
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
1925
switch(ret){
2730
ret_errno = argp_parse(&argp, argc, argv,
2731
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2732
switch(ret_errno){
1926
2733
case 0:
1927
2734
break;
1928
2735
case ENOMEM:
1929
2736
default:
1930
errno = ret;
2737
errno = ret_errno;
1931
2738
perror_plus("argp_parse");
1932
2739
exitcode = EX_OSERR;
1933
2740
goto end;
1936
2743
goto end;
1937
2744
}
1938
2745
}
1939
2746
1940
2747
{
1941
/* Work around Debian bug #633582:
1942
<http://bugs.debian.org/633582> */
1943
1944
/* Re-raise priviliges */
1945
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 {
1946
2754
struct stat st;
1947
2755
2756
/* Work around Debian bug #633582:
2757
<https://bugs.debian.org/633582> */
2758
1948
2759
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
1949
2760
int seckey_fd = open(seckey, O_RDONLY);
1950
2761
if(seckey_fd == -1){
1962
2773
}
1963
2774
}
1964
2775
}
1965
TEMP_FAILURE_RETRY(close(seckey_fd));
2776
close(seckey_fd);
1966
2777
}
1967
2778
}
1968
2779
1969
2780
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
1970
2781
int pubkey_fd = open(pubkey, O_RDONLY);
1971
2782
if(pubkey_fd == -1){
1983
2794
}
1984
2795
}
1985
2796
}
1986
TEMP_FAILURE_RETRY(close(pubkey_fd));
1987
}
1988
}
1989
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
1990
2832
/* Lower privileges */
1991
errno = 0;
1992
ret = seteuid(uid);
1993
if(ret == -1){
1994
perror_plus("seteuid");
2833
ret = lower_privileges();
2834
if(ret != 0){
2835
errno = ret;
2836
perror_plus("Failed to lower privileges");
1995
2837
}
1996
2838
}
1997
2839
}
1998
2840
1999
/* Remove empty interface names */
2841
/* Remove invalid interface names (except "none") */
2000
2842
{
2001
2843
char *interface = NULL;
2002
while((interface = argz_next(interfaces, interfaces_size,
2844
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2003
2845
interface))){
2004
if(if_nametoindex(interface) == 0){
2005
if(interface[0] != '\0' and strcmp(interface, "none") != 0){
2846
if(strcmp(interface, "none") != 0
2847
and if_nametoindex(interface) == 0){
2848
if(interface[0] != '\0'){
2006
2849
fprintf_plus(stderr, "Not using nonexisting interface"
2007
2850
" \"%s\"\n", interface);
2008
2851
}
2009
argz_delete(&interfaces, &interfaces_size, interface);
2852
argz_delete(&mc.interfaces, &mc.interfaces_size, interface);
2010
2853
interface = NULL;
2011
2854
}
2012
2855
}
2014
2857
2015
2858
/* Run network hooks */
2016
2859
{
2017
ret_errno = argz_append(&interfaces_hooks, &interfaces_hooks_size,
2018
interfaces, interfaces_size);
2019
if(ret_errno != 0){
2020
errno = ret_errno;
2021
perror_plus("argz_append");
2022
goto end;
2023
}
2024
argz_stringify(interfaces_hooks, interfaces_hooks_size, (int)',');
2025
if(not run_network_hooks("start", interfaces_hooks, delay)){
2026
goto end;
2027
}
2860
if(mc.interfaces != NULL){
2861
interfaces_hooks = malloc(mc.interfaces_size);
2862
if(interfaces_hooks == NULL){
2863
perror_plus("malloc");
2864
goto end;
2865
}
2866
memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
2867
argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
2868
}
2869
run_network_hooks("start", interfaces_hooks != NULL ?
2870
interfaces_hooks : "", delay);
2028
2871
}
2029
2872
2030
2873
if(not debug){
2035
2878
from the signal handler */
2036
2879
/* Initialize the pseudo-RNG for Avahi */
2037
2880
srand((unsigned int) time(NULL));
2038
mc.simple_poll = avahi_simple_poll_new();
2039
if(mc.simple_poll == NULL){
2881
simple_poll = avahi_simple_poll_new();
2882
if(simple_poll == NULL){
2040
2883
fprintf_plus(stderr,
2041
2884
"Avahi: Failed to create simple poll object.\n");
2042
2885
exitcode = EX_UNAVAILABLE;
2107
2950
}
2108
2951
2109
2952
/* If no interfaces were specified, make a list */
2110
if(interfaces == NULL){
2111
struct dirent **direntries;
2953
if(mc.interfaces == NULL){
2954
struct dirent **direntries = NULL;
2112
2955
/* Look for any good interfaces */
2113
2956
ret = scandir(sys_class_net, &direntries, good_interface,
2114
2957
alphasort);
2115
2958
if(ret >= 1){
2116
2959
/* Add all found interfaces to interfaces list */
2117
2960
for(int i = 0; i < ret; ++i){
2118
ret_errno = argz_add(&interfaces, &interfaces_size,
2961
ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
2119
2962
direntries[i]->d_name);
2120
2963
if(ret_errno != 0){
2964
errno = ret_errno;
2121
2965
perror_plus("argz_add");
2966
free(direntries[i]);
2122
2967
continue;
2123
2968
}
2124
2969
if(debug){
2125
2970
fprintf_plus(stderr, "Will use interface \"%s\"\n",
2126
2971
direntries[i]->d_name);
2127
2972
}
2973
free(direntries[i]);
2128
2974
}
2129
2975
free(direntries);
2130
2976
} else {
2131
free(direntries);
2977
if(ret == 0){
2978
free(direntries);
2979
}
2132
2980
fprintf_plus(stderr, "Could not find a network interface\n");
2133
2981
exitcode = EXIT_FAILURE;
2134
2982
goto end;
2135
2983
}
2136
2984
}
2137
2985
2138
/* If we only got one interface, explicitly use only that one */
2139
if(argz_count(interfaces, interfaces_size) == 1){
2140
if(debug){
2141
fprintf_plus(stderr, "Using only interface \"%s\"\n",
2142
interfaces);
2143
}
2144
if_index = (AvahiIfIndex)if_nametoindex(interfaces);
2145
}
2146
2147
/* Bring up interfaces which are down */
2148
if(not (argz_count(interfaces, interfaces_size) == 1
2149
and strcmp(interfaces, "none") == 0)){
2986
/* Bring up interfaces which are down, and remove any "none"s */
2987
{
2150
2988
char *interface = NULL;
2151
while((interface = argz_next(interfaces, interfaces_size,
2989
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2152
2990
interface))){
2991
/* If interface name is "none", stop bringing up interfaces.
2992
Also remove all instances of "none" from the list */
2993
if(strcmp(interface, "none") == 0){
2994
argz_delete(&mc.interfaces, &mc.interfaces_size,
2995
interface);
2996
interface = NULL;
2997
while((interface = argz_next(mc.interfaces,
2998
mc.interfaces_size, interface))){
2999
if(strcmp(interface, "none") == 0){
3000
argz_delete(&mc.interfaces, &mc.interfaces_size,
3001
interface);
3002
interface = NULL;
3003
}
3004
}
3005
break;
3006
}
2153
3007
bool interface_was_up = interface_is_up(interface);
2154
ret = bring_up_interface(interface, delay);
3008
errno = bring_up_interface(interface, delay);
2155
3009
if(not interface_was_up){
2156
if(ret != 0){
2157
errno = ret;
2158
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));
2159
3013
} else {
2160
ret_errno = argz_add(&interfaces_to_take_down,
2161
&interfaces_to_take_down_size,
2162
interface);
3014
errno = argz_add(&interfaces_to_take_down,
3015
&interfaces_to_take_down_size,
3016
interface);
3017
if(errno != 0){
3018
perror_plus("argz_add");
3019
}
2163
3020
}
2164
3021
}
2165
3022
}
2166
free(interfaces);
2167
interfaces = NULL;
2168
interfaces_size = 0;
2169
3023
if(debug and (interfaces_to_take_down == NULL)){
2170
3024
fprintf_plus(stderr, "No interfaces were brought up\n");
2171
3025
}
2172
3026
}
2173
3027
3028
/* If we only got one interface, explicitly use only that one */
3029
if(argz_count(mc.interfaces, mc.interfaces_size) == 1){
3030
if(debug){
3031
fprintf_plus(stderr, "Using only interface \"%s\"\n",
3032
mc.interfaces);
3033
}
3034
if_index = (AvahiIfIndex)if_nametoindex(mc.interfaces);
3035
}
3036
2174
3037
if(quit_now){
2175
3038
goto end;
2176
3039
}
2177
3040
2178
ret = init_gnutls_global(pubkey, seckey);
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
2179
3048
if(ret == -1){
2180
3049
fprintf_plus(stderr, "init_gnutls_global failed\n");
2181
3050
exitcode = EX_UNAVAILABLE;
2188
3057
goto end;
2189
3058
}
2190
3059
2191
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){
2192
3070
perror_plus("mkdtemp");
2193
3071
goto end;
2194
3072
}
2195
tempdir_created = true;
2196
3073
2197
3074
if(quit_now){
2198
3075
goto end;
2199
3076
}
2200
3077
2201
if(not init_gpgme(pubkey, seckey, tempdir)){
3078
if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
2202
3079
fprintf_plus(stderr, "init_gpgme failed\n");
2203
3080
exitcode = EX_UNAVAILABLE;
2204
3081
goto end;
2225
3102
goto end;
2226
3103
}
2227
3104
2228
uint16_t port;
3105
in_port_t port;
2229
3106
errno = 0;
2230
3107
tmpmax = strtoimax(address+1, &tmp, 10);
2231
3108
if(errno != 0 or tmp == address+1 or *tmp != '\0'
2232
or tmpmax != (uint16_t)tmpmax){
3109
or tmpmax != (in_port_t)tmpmax){
2233
3110
fprintf_plus(stderr, "Bad port number\n");
2234
3111
exitcode = EX_USAGE;
2235
3112
goto end;
2236
3113
}
2237
3114
2238
3115
if(quit_now){
2239
3116
goto end;
2240
3117
}
2241
3118
2242
port = (uint16_t)tmpmax;
3119
port = (in_port_t)tmpmax;
2243
3120
*address = '\0';
2244
3121
/* Colon in address indicates IPv6 */
2245
3122
int af;
2261
3138
}
2262
3139
2263
3140
while(not quit_now){
2264
ret = start_mandos_communication(address, port, if_index, af);
3141
ret = start_mandos_communication(address, port, if_index, af,
3142
&mc);
2265
3143
if(quit_now or ret == 0){
2266
3144
break;
2267
3145
}
2269
3147
fprintf_plus(stderr, "Retrying in %d seconds\n",
2270
3148
(int)retry_interval);
2271
3149
}
2272
sleep((int)retry_interval);
3150
sleep((unsigned int)retry_interval);
2273
3151
}
2274
3152
2275
if (not quit_now){
3153
if(not quit_now){
2276
3154
exitcode = EXIT_SUCCESS;
2277
3155
}
2278
3156
2293
3171
config.publish_domain = 0;
2294
3172
2295
3173
/* Allocate a new server */
2296
mc.server = avahi_server_new(avahi_simple_poll_get
2297
(mc.simple_poll), &config, NULL,
2298
NULL, &ret_errno);
3174
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
3175
&config, NULL, NULL, &ret);
2299
3176
2300
3177
/* Free the Avahi configuration data */
2301
3178
avahi_server_config_free(&config);
2304
3181
/* Check if creating the Avahi server object succeeded */
2305
3182
if(mc.server == NULL){
2306
3183
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2307
avahi_strerror(ret_errno));
3184
avahi_strerror(ret));
2308
3185
exitcode = EX_UNAVAILABLE;
2309
3186
goto end;
2310
3187
}
2316
3193
/* Create the Avahi service browser */
2317
3194
sb = avahi_s_service_browser_new(mc.server, if_index,
2318
3195
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
2319
NULL, 0, browse_callback, NULL);
3196
NULL, 0, browse_callback,
3197
(void *)&mc);
2320
3198
if(sb == NULL){
2321
3199
fprintf_plus(stderr, "Failed to create service browser: %s\n",
2322
3200
avahi_strerror(avahi_server_errno(mc.server)));
2333
3211
if(debug){
2334
3212
fprintf_plus(stderr, "Starting Avahi loop search\n");
2335
3213
}
2336
2337
ret = avahi_loop_with_timeout(mc.simple_poll,
2338
(int)(retry_interval * 1000));
3214
3215
ret = avahi_loop_with_timeout(simple_poll,
3216
(int)(retry_interval * 1000), &mc);
2339
3217
if(debug){
2340
3218
fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
2341
3219
(ret == 0) ? "successfully" : "with error");
2344
3222
end:
2345
3223
2346
3224
if(debug){
2347
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
}
2348
3232
}
2349
3233
2350
3234
/* Cleanup things */
3235
free(mc.interfaces);
3236
2351
3237
if(sb != NULL)
2352
3238
avahi_s_service_browser_free(sb);
2353
3239
2354
3240
if(mc.server != NULL)
2355
3241
avahi_server_free(mc.server);
2356
3242
2357
if(mc.simple_poll != NULL)
2358
avahi_simple_poll_free(mc.simple_poll);
3243
if(simple_poll != NULL)
3244
avahi_simple_poll_free(simple_poll);
2359
3245
2360
3246
if(gnutls_initialized){
2361
3247
gnutls_certificate_free_credentials(mc.cred);
2362
gnutls_global_deinit();
2363
3248
gnutls_dh_params_deinit(mc.dh_params);
2364
3249
}
2365
3250
2373
3258
mc.current_server->prev->next = NULL;
2374
3259
while(mc.current_server != NULL){
2375
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
2376
3269
free(mc.current_server);
2377
3270
mc.current_server = next;
2378
3271
}
2379
3272
}
2380
3273
2381
/* Re-raise priviliges */
3274
/* Re-raise privileges */
2382
3275
{
2383
raise_privileges();
2384
2385
/* Run network hooks */
2386
run_network_hooks("stop", interfaces_hooks, delay);
2387
2388
/* Take down the network interfaces which were brought up */
2389
{
2390
char *interface = NULL;
2391
while((interface=argz_next(interfaces_to_take_down,
2392
interfaces_to_take_down_size,
2393
interface))){
2394
ret_errno = take_down_interface(interface);
2395
if(ret_errno != 0){
2396
errno = ret_errno;
2397
perror_plus("Failed to take down interface");
2398
}
2399
}
2400
if(debug and (interfaces_to_take_down == NULL)){
2401
fprintf_plus(stderr, "No interfaces needed to be taken"
2402
" down\n");
2403
}
2404
}
2405
2406
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
}
2407
3310
}
2408
3311
2409
3312
free(interfaces_to_take_down);
2410
3313
free(interfaces_hooks);
2411
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
2412
3369
/* Removes the GPGME temp directory and all files inside */
2413
if(tempdir_created){
2414
struct dirent **direntries = NULL;
2415
struct dirent *direntry = NULL;
2416
int numentries = scandir(tempdir, &direntries, notdotentries,
2417
alphasort);
2418
if (numentries > 0){
2419
for(int i = 0; i < numentries; i++){
2420
direntry = direntries[i];
2421
char *fullname = NULL;
2422
ret = asprintf(&fullname, "%s/%s", tempdir,
2423
direntry->d_name);
2424
if(ret < 0){
2425
perror_plus("asprintf");
2426
continue;
2427
}
2428
ret = remove(fullname);
2429
if(ret == -1){
2430
fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2431
strerror(errno));
2432
}
2433
free(fullname);
2434
}
2435
}
2436
2437
/* need to clean even if 0 because man page doesn't specify */
2438
free(direntries);
2439
if (numentries == -1){
2440
perror_plus("scandir");
2441
}
2442
ret = rmdir(tempdir);
2443
if(ret == -1 and errno != ENOENT){
2444
perror_plus("rmdir");
2445
}
3370
if(tempdir != NULL){
3371
clean_dir_at(-1, tempdir, 0);
2446
3372
}
2447
3373
2448
3374
if(quit_now){
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0