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 1213
- compare with another revision
- download diff
- download tarball
- view history from revision 1213
- Committer: teddy at recompile
- Date: 2020-04-05 21:30:59 UTC
- Revision ID: teddy@recompile.se-20200405213059-fb2a61ckqynrmatk
Fix file descriptor leak in mandos-client
When the local network has Mandos servers announcing themselves using
real, globally reachable, IPv6 addresses (i.e. not link-local
addresses), but there is no router on the local network providing IPv6
RA (Router Advertisement) packets, the client cannot reach the server
by normal means, since the client only has a link-local IPv6 address,
and has no usable route to reach the server's global IPv6 address.
(This is not a common situation, and usually only happens when the
router itself reboots and runs a Mandos client, since it cannot then
give RA packets to itself.) The client code has a solution for
this, which consists of adding a temporary local route to reach the
address of the server during communication, and removing this
temporary route afterwards.
This solution with a temporary route works, but has a file descriptor
leak; it leaks one file descriptor for each addition and for each
removal of a route. If one server requiring an added route is present
on the network, but no servers gives a password, making the client
retry after the default ten seconds, and we furthermore assume a
default 1024 open files limit, the client runs out of file descriptors
after about 90 minutes, after which time the client process will be
useless and fail to retrieve any passwords, necessitating manual
password entry via the keyboard.
Fix this by eliminating the file descriptor leak in the client.
* plugins.d/mandos-client.c (add_delete_local_route): Do
close(devnull) also in parent process, also if fork() fails, and on
any failure in child process.
When the local network has Mandos servers announcing themselves using
real, globally reachable, IPv6 addresses (i.e. not link-local
addresses), but there is no router on the local network providing IPv6
RA (Router Advertisement) packets, the client cannot reach the server
by normal means, since the client only has a link-local IPv6 address,
and has no usable route to reach the server's global IPv6 address.
(This is not a common situation, and usually only happens when the
router itself reboots and runs a Mandos client, since it cannot then
give RA packets to itself.) The client code has a solution for
this, which consists of adding a temporary local route to reach the
address of the server during communication, and removing this
temporary route afterwards.
This solution with a temporary route works, but has a file descriptor
leak; it leaks one file descriptor for each addition and for each
removal of a route. If one server requiring an added route is present
on the network, but no servers gives a password, making the client
retry after the default ten seconds, and we furthermore assume a
default 1024 open files limit, the client runs out of file descriptors
after about 90 minutes, after which time the client process will be
useless and fail to retrieve any passwords, necessitating manual
password entry via the keyboard.
Fix this by eliminating the file descriptor leak in the client.
* plugins.d/mandos-client.c (add_delete_local_route): Do
close(devnull) also in parent process, also if fork() fails, and on
any failure in child process.
- 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-2011 Teddy Hogeborn
13
* Copyright © 2008-2011 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-2019 Teddy Hogeborn
13
* Copyright © 2008-2019 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
#endif /* not _FILE_OFFSET_BITS */
39
40
40
41
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
41
42
42
43
#include <stdio.h> /* fprintf(), stderr, fwrite(),
43
stdout, ferror(), remove() */
44
#include <stdint.h> /* uint16_t, uint32_t */
44
stdout, ferror() */
45
#include <stdint.h> /* uint16_t, uint32_t, intptr_t */
45
46
#include <stddef.h> /* NULL, size_t, ssize_t */
46
47
#include <stdlib.h> /* free(), EXIT_SUCCESS, srand(),
47
48
strtof(), abort() */
48
49
#include <stdbool.h> /* bool, false, true */
49
#include <string.h> /* memset(), strcmp(), strlen(),
50
strerror(), asprintf(), strcpy() */
50
#include <string.h> /* strcmp(), strlen(), strerror(),
51
asprintf(), strncpy(), strsignal()
52
*/
51
53
#include <sys/ioctl.h> /* ioctl */
52
54
#include <sys/types.h> /* socket(), inet_pton(), sockaddr,
53
55
sockaddr_in6, PF_INET6,
55
57
opendir(), DIR */
56
58
#include <sys/stat.h> /* open(), S_ISREG */
57
59
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
58
inet_pton(), connect() */
59
#include <fcntl.h> /* open() */
60
inet_pton(), connect(),
61
getnameinfo() */
62
#include <fcntl.h> /* open(), unlinkat(), AT_REMOVEDIR */
60
63
#include <dirent.h> /* opendir(), struct dirent, readdir()
61
64
*/
62
65
#include <inttypes.h> /* PRIu16, PRIdMAX, intmax_t,
63
66
strtoimax() */
64
#include <assert.h> /* assert() */
65
#include <errno.h> /* perror(), errno,
67
#include <errno.h> /* perror(), errno, EINTR, EINVAL,
68
EAI_SYSTEM, ENETUNREACH,
69
EHOSTUNREACH, ECONNREFUSED, EPROTO,
70
EIO, ENOENT, ENXIO, ENOMEM, EISDIR,
71
ENOTEMPTY,
66
72
program_invocation_short_name */
67
73
#include <time.h> /* nanosleep(), time(), sleep() */
68
74
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
73
79
*/
74
80
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
75
81
getuid(), getgid(), seteuid(),
76
setgid(), pause(), _exit() */
77
#include <arpa/inet.h> /* inet_pton(), htons, inet_ntop() */
82
setgid(), pause(), _exit(),
83
unlinkat() */
84
#include <arpa/inet.h> /* inet_pton(), htons() */
78
85
#include <iso646.h> /* not, or, and */
79
86
#include <argp.h> /* struct argp_option, error_t, struct
80
87
argp_state, struct argp,
88
95
#include <sys/wait.h> /* waitpid(), WIFEXITED(),
89
96
WEXITSTATUS(), WTERMSIG() */
90
97
#include <grp.h> /* setgroups() */
98
#include <argz.h> /* argz_add_sep(), argz_next(),
99
argz_delete(), argz_append(),
100
argz_stringify(), argz_add(),
101
argz_count() */
102
#include <netdb.h> /* getnameinfo(), NI_NUMERICHOST,
103
EAI_SYSTEM, gai_strerror() */
91
104
92
105
#ifdef __linux__
93
106
#include <sys/klog.h> /* klogctl() */
110
123
gnutls_*
111
124
init_gnutls_session(),
112
125
GNUTLS_* */
126
#if GNUTLS_VERSION_NUMBER < 0x030600
113
127
#include <gnutls/openpgp.h>
114
128
/* gnutls_certificate_set_openpgp_key_file(),
115
129
GNUTLS_OPENPGP_FMT_BASE64 */
130
#elif GNUTLS_VERSION_NUMBER >= 0x030606
131
#include <gnutls/x509.h> /* gnutls_pkcs_encrypt_flags_t,
132
GNUTLS_PKCS_PLAIN,
133
GNUTLS_PKCS_NULL_PASSWORD */
134
#endif
116
135
117
136
/* GPGME */
118
137
#include <gpgme.h> /* All GPGME types, constants and
126
145
#define PATHDIR "/conf/conf.d/mandos"
127
146
#define SECKEY "seckey.txt"
128
147
#define PUBKEY "pubkey.txt"
148
#define TLS_PRIVKEY "tls-privkey.pem"
149
#define TLS_PUBKEY "tls-pubkey.pem"
129
150
#define HOOKDIR "/lib/mandos/network-hooks.d"
130
151
131
152
bool debug = false;
135
156
static const char sys_class_net[] = "/sys/class/net";
136
157
char *connect_to = NULL;
137
158
const char *hookdir = HOOKDIR;
159
int hookdir_fd = -1;
160
uid_t uid = 65534;
161
gid_t gid = 65534;
138
162
139
163
/* Doubly linked list that need to be circularly linked when used */
140
164
typedef struct server{
141
165
const char *ip;
142
uint16_t port;
166
in_port_t port;
143
167
AvahiIfIndex if_index;
144
168
int af;
145
169
struct timespec last_seen;
149
173
150
174
/* Used for passing in values through the Avahi callback functions */
151
175
typedef struct {
152
AvahiSimplePoll *simple_poll;
153
176
AvahiServer *server;
154
177
gnutls_certificate_credentials_t cred;
155
178
unsigned int dh_bits;
157
180
const char *priority;
158
181
gpgme_ctx_t ctx;
159
182
server *current_server;
183
char *interfaces;
184
size_t interfaces_size;
160
185
} mandos_context;
161
186
162
/* global context so signal handler can reach it*/
163
mandos_context mc = { .simple_poll = NULL, .server = NULL,
164
.dh_bits = 1024, .priority = "SECURE256"
165
":!CTYPE-X.509:+CTYPE-OPENPGP",
166
.current_server = NULL };
187
/* global so signal handler can reach it*/
188
AvahiSimplePoll *simple_poll;
167
189
168
190
sig_atomic_t quit_now = 0;
169
191
int signal_received = 0;
170
192
171
193
/* Function to use when printing errors */
172
194
void perror_plus(const char *print_text){
195
int e = errno;
173
196
fprintf(stderr, "Mandos plugin %s: ",
174
197
program_invocation_short_name);
198
errno = e;
175
199
perror(print_text);
176
200
}
177
201
202
__attribute__((format (gnu_printf, 2, 3), nonnull))
178
203
int fprintf_plus(FILE *stream, const char *format, ...){
179
204
va_list ap;
180
205
va_start (ap, format);
181
206
182
207
TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
183
208
program_invocation_short_name));
184
return TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
209
return (int)TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
185
210
}
186
211
187
212
/*
189
214
* bytes. "buffer_capacity" is how much is currently allocated,
190
215
* "buffer_length" is how much is already used.
191
216
*/
217
__attribute__((nonnull, warn_unused_result))
192
218
size_t incbuffer(char **buffer, size_t buffer_length,
193
219
size_t buffer_capacity){
194
220
if(buffer_length + BUFFER_SIZE > buffer_capacity){
195
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
196
if(buffer == NULL){
221
char *new_buf = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
222
if(new_buf == NULL){
223
int old_errno = errno;
224
free(*buffer);
225
errno = old_errno;
226
*buffer = NULL;
197
227
return 0;
198
228
}
229
*buffer = new_buf;
199
230
buffer_capacity += BUFFER_SIZE;
200
231
}
201
232
return buffer_capacity;
202
233
}
203
234
204
235
/* Add server to set of servers to retry periodically */
205
int add_server(const char *ip, uint16_t port, AvahiIfIndex if_index,
206
int af){
236
__attribute__((nonnull, warn_unused_result))
237
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
238
int af, server **current_server){
207
239
int ret;
208
240
server *new_server = malloc(sizeof(server));
209
241
if(new_server == NULL){
210
242
perror_plus("malloc");
211
return -1;
243
return false;
212
244
}
213
245
*new_server = (server){ .ip = strdup(ip),
214
246
.port = port,
216
248
.af = af };
217
249
if(new_server->ip == NULL){
218
250
perror_plus("strdup");
219
return -1;
251
free(new_server);
252
return false;
253
}
254
ret = clock_gettime(CLOCK_MONOTONIC, &(new_server->last_seen));
255
if(ret == -1){
256
perror_plus("clock_gettime");
257
#ifdef __GNUC__
258
#pragma GCC diagnostic push
259
#pragma GCC diagnostic ignored "-Wcast-qual"
260
#endif
261
free((char *)(new_server->ip));
262
#ifdef __GNUC__
263
#pragma GCC diagnostic pop
264
#endif
265
free(new_server);
266
return false;
220
267
}
221
268
/* Special case of first server */
222
if (mc.current_server == NULL){
269
if(*current_server == NULL){
223
270
new_server->next = new_server;
224
271
new_server->prev = new_server;
225
mc.current_server = new_server;
226
/* Place the new server last in the list */
272
*current_server = new_server;
227
273
} else {
228
new_server->next = mc.current_server;
229
new_server->prev = mc.current_server->prev;
274
/* Place the new server last in the list */
275
new_server->next = *current_server;
276
new_server->prev = (*current_server)->prev;
230
277
new_server->prev->next = new_server;
231
mc.current_server->prev = new_server;
232
}
233
ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);
234
if(ret == -1){
235
perror_plus("clock_gettime");
236
return -1;
237
}
238
return 0;
278
(*current_server)->prev = new_server;
279
}
280
return true;
281
}
282
283
/* Set effective uid to 0, return errno */
284
__attribute__((warn_unused_result))
285
int raise_privileges(void){
286
int old_errno = errno;
287
int ret = 0;
288
if(seteuid(0) == -1){
289
ret = errno;
290
}
291
errno = old_errno;
292
return ret;
293
}
294
295
/* Set effective and real user ID to 0. Return errno. */
296
__attribute__((warn_unused_result))
297
int raise_privileges_permanently(void){
298
int old_errno = errno;
299
int ret = raise_privileges();
300
if(ret != 0){
301
errno = old_errno;
302
return ret;
303
}
304
if(setuid(0) == -1){
305
ret = errno;
306
}
307
errno = old_errno;
308
return ret;
309
}
310
311
/* Set effective user ID to unprivileged saved user ID */
312
__attribute__((warn_unused_result))
313
int lower_privileges(void){
314
int old_errno = errno;
315
int ret = 0;
316
if(seteuid(uid) == -1){
317
ret = errno;
318
}
319
errno = old_errno;
320
return ret;
321
}
322
323
/* Lower privileges permanently */
324
__attribute__((warn_unused_result))
325
int lower_privileges_permanently(void){
326
int old_errno = errno;
327
int ret = 0;
328
if(setuid(uid) == -1){
329
ret = errno;
330
}
331
errno = old_errno;
332
return ret;
239
333
}
240
334
241
335
/*
242
336
* Initialize GPGME.
243
337
*/
244
static bool init_gpgme(const char *seckey, const char *pubkey,
245
const char *tempdir){
338
__attribute__((nonnull, warn_unused_result))
339
static bool init_gpgme(const char * const seckey,
340
const char * const pubkey,
341
const char * const tempdir,
342
mandos_context *mc){
246
343
gpgme_error_t rc;
247
344
gpgme_engine_info_t engine_info;
248
345
249
250
346
/*
251
347
* Helper function to insert pub and seckey to the engine keyring.
252
348
*/
253
bool import_key(const char *filename){
349
bool import_key(const char * const filename){
254
350
int ret;
255
351
int fd;
256
352
gpgme_data_t pgp_data;
261
357
return false;
262
358
}
263
359
360
/* Workaround for systems without a real-time clock; see also
361
Debian bug #894495: <https://bugs.debian.org/894495> */
362
do {
363
{
364
time_t currtime = time(NULL);
365
if(currtime != (time_t)-1){
366
struct tm tm;
367
if(gmtime_r(&currtime, &tm) == NULL) {
368
perror_plus("gmtime_r");
369
break;
370
}
371
if(tm.tm_year != 70 or tm.tm_mon != 0){
372
break;
373
}
374
if(debug){
375
fprintf_plus(stderr, "System clock is January 1970");
376
}
377
} else {
378
if(debug){
379
fprintf_plus(stderr, "System clock is invalid");
380
}
381
}
382
}
383
struct stat keystat;
384
ret = fstat(fd, &keystat);
385
if(ret != 0){
386
perror_plus("fstat");
387
break;
388
}
389
ret = raise_privileges();
390
if(ret != 0){
391
errno = ret;
392
perror_plus("Failed to raise privileges");
393
break;
394
}
395
if(debug){
396
fprintf_plus(stderr,
397
"Setting system clock to key file mtime");
398
}
399
time_t keytime = keystat.st_mtim.tv_sec;
400
if(stime(&keytime) != 0){
401
perror_plus("stime");
402
}
403
ret = lower_privileges();
404
if(ret != 0){
405
errno = ret;
406
perror_plus("Failed to lower privileges");
407
}
408
} while(false);
409
264
410
rc = gpgme_data_new_from_fd(&pgp_data, fd);
265
411
if(rc != GPG_ERR_NO_ERROR){
266
412
fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
268
414
return false;
269
415
}
270
416
271
rc = gpgme_op_import(mc.ctx, pgp_data);
417
rc = gpgme_op_import(mc->ctx, pgp_data);
272
418
if(rc != GPG_ERR_NO_ERROR){
273
419
fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
274
420
gpgme_strsource(rc), gpgme_strerror(rc));
275
421
return false;
276
422
}
423
{
424
gpgme_import_result_t import_result
425
= gpgme_op_import_result(mc->ctx);
426
if((import_result->imported < 1
427
or import_result->not_imported > 0)
428
and import_result->unchanged == 0){
429
fprintf_plus(stderr, "bad gpgme_op_import_results:\n");
430
fprintf_plus(stderr,
431
"The total number of considered keys: %d\n",
432
import_result->considered);
433
fprintf_plus(stderr,
434
"The number of keys without user ID: %d\n",
435
import_result->no_user_id);
436
fprintf_plus(stderr,
437
"The total number of imported keys: %d\n",
438
import_result->imported);
439
fprintf_plus(stderr, "The number of imported RSA keys: %d\n",
440
import_result->imported_rsa);
441
fprintf_plus(stderr, "The number of unchanged keys: %d\n",
442
import_result->unchanged);
443
fprintf_plus(stderr, "The number of new user IDs: %d\n",
444
import_result->new_user_ids);
445
fprintf_plus(stderr, "The number of new sub keys: %d\n",
446
import_result->new_sub_keys);
447
fprintf_plus(stderr, "The number of new signatures: %d\n",
448
import_result->new_signatures);
449
fprintf_plus(stderr, "The number of new revocations: %d\n",
450
import_result->new_revocations);
451
fprintf_plus(stderr,
452
"The total number of secret keys read: %d\n",
453
import_result->secret_read);
454
fprintf_plus(stderr,
455
"The number of imported secret keys: %d\n",
456
import_result->secret_imported);
457
fprintf_plus(stderr,
458
"The number of unchanged secret keys: %d\n",
459
import_result->secret_unchanged);
460
fprintf_plus(stderr, "The number of keys not imported: %d\n",
461
import_result->not_imported);
462
for(gpgme_import_status_t import_status
463
= import_result->imports;
464
import_status != NULL;
465
import_status = import_status->next){
466
fprintf_plus(stderr, "Import status for key: %s\n",
467
import_status->fpr);
468
if(import_status->result != GPG_ERR_NO_ERROR){
469
fprintf_plus(stderr, "Import result: %s: %s\n",
470
gpgme_strsource(import_status->result),
471
gpgme_strerror(import_status->result));
472
}
473
fprintf_plus(stderr, "Key status:\n");
474
fprintf_plus(stderr,
475
import_status->status & GPGME_IMPORT_NEW
476
? "The key was new.\n"
477
: "The key was not new.\n");
478
fprintf_plus(stderr,
479
import_status->status & GPGME_IMPORT_UID
480
? "The key contained new user IDs.\n"
481
: "The key did not contain new user IDs.\n");
482
fprintf_plus(stderr,
483
import_status->status & GPGME_IMPORT_SIG
484
? "The key contained new signatures.\n"
485
: "The key did not contain new signatures.\n");
486
fprintf_plus(stderr,
487
import_status->status & GPGME_IMPORT_SUBKEY
488
? "The key contained new sub keys.\n"
489
: "The key did not contain new sub keys.\n");
490
fprintf_plus(stderr,
491
import_status->status & GPGME_IMPORT_SECRET
492
? "The key contained a secret key.\n"
493
: "The key did not contain a secret key.\n");
494
}
495
return false;
496
}
497
}
277
498
278
ret = (int)TEMP_FAILURE_RETRY(close(fd));
499
ret = close(fd);
279
500
if(ret == -1){
280
501
perror_plus("close");
281
502
}
318
539
}
319
540
320
541
/* Create new GPGME "context" */
321
rc = gpgme_new(&(mc.ctx));
542
rc = gpgme_new(&(mc->ctx));
322
543
if(rc != GPG_ERR_NO_ERROR){
323
fprintf_plus(stderr, "Mandos plugin mandos-client: "
324
"bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
325
gpgme_strerror(rc));
544
fprintf_plus(stderr, "bad gpgme_new: %s: %s\n",
545
gpgme_strsource(rc), gpgme_strerror(rc));
326
546
return false;
327
547
}
328
548
337
557
* Decrypt OpenPGP data.
338
558
* Returns -1 on error
339
559
*/
560
__attribute__((nonnull, warn_unused_result))
340
561
static ssize_t pgp_packet_decrypt(const char *cryptotext,
341
562
size_t crypto_size,
342
char **plaintext){
563
char **plaintext,
564
mandos_context *mc){
343
565
gpgme_data_t dh_crypto, dh_plain;
344
566
gpgme_error_t rc;
345
567
ssize_t ret;
362
584
/* Create new empty GPGME data buffer for the plaintext */
363
585
rc = gpgme_data_new(&dh_plain);
364
586
if(rc != GPG_ERR_NO_ERROR){
365
fprintf_plus(stderr, "Mandos plugin mandos-client: "
366
"bad gpgme_data_new: %s: %s\n",
587
fprintf_plus(stderr, "bad gpgme_data_new: %s: %s\n",
367
588
gpgme_strsource(rc), gpgme_strerror(rc));
368
589
gpgme_data_release(dh_crypto);
369
590
return -1;
371
592
372
593
/* Decrypt data from the cryptotext data buffer to the plaintext
373
594
data buffer */
374
rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
595
rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
375
596
if(rc != GPG_ERR_NO_ERROR){
376
597
fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
377
598
gpgme_strsource(rc), gpgme_strerror(rc));
378
599
plaintext_length = -1;
379
600
if(debug){
380
601
gpgme_decrypt_result_t result;
381
result = gpgme_op_decrypt_result(mc.ctx);
602
result = gpgme_op_decrypt_result(mc->ctx);
382
603
if(result == NULL){
383
604
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
384
605
} else {
385
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
386
result->unsupported_algorithm);
387
fprintf_plus(stderr, "Wrong key usage: %u\n",
388
result->wrong_key_usage);
606
if(result->unsupported_algorithm != NULL) {
607
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
608
result->unsupported_algorithm);
609
}
610
fprintf_plus(stderr, "Wrong key usage: %s\n",
611
result->wrong_key_usage ? "Yes" : "No");
389
612
if(result->file_name != NULL){
390
613
fprintf_plus(stderr, "File name: %s\n", result->file_name);
391
614
}
392
gpgme_recipient_t recipient;
393
recipient = result->recipients;
394
while(recipient != NULL){
615
616
for(gpgme_recipient_t r = result->recipients; r != NULL;
617
r = r->next){
395
618
fprintf_plus(stderr, "Public key algorithm: %s\n",
396
gpgme_pubkey_algo_name
397
(recipient->pubkey_algo));
398
fprintf_plus(stderr, "Key ID: %s\n", recipient->keyid);
619
gpgme_pubkey_algo_name(r->pubkey_algo));
620
fprintf_plus(stderr, "Key ID: %s\n", r->keyid);
399
621
fprintf_plus(stderr, "Secret key available: %s\n",
400
recipient->status == GPG_ERR_NO_SECKEY
401
? "No" : "Yes");
402
recipient = recipient->next;
622
r->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
403
623
}
404
624
}
405
625
}
461
681
return plaintext_length;
462
682
}
463
683
464
static const char * safer_gnutls_strerror(int value){
465
const char *ret = gnutls_strerror(value); /* Spurious warning from
466
-Wunreachable-code */
467
if(ret == NULL)
468
ret = "(unknown)";
469
return ret;
684
__attribute__((warn_unused_result, const))
685
static const char *safe_string(const char *str){
686
if(str == NULL)
687
return "(unknown)";
688
return str;
689
}
690
691
__attribute__((warn_unused_result))
692
static const char *safer_gnutls_strerror(int value){
693
const char *ret = gnutls_strerror(value);
694
return safe_string(ret);
470
695
}
471
696
472
697
/* GnuTLS log function callback */
698
__attribute__((nonnull))
473
699
static void debuggnutls(__attribute__((unused)) int level,
474
700
const char* string){
475
701
fprintf_plus(stderr, "GnuTLS: %s", string);
476
702
}
477
703
704
__attribute__((nonnull(1, 2, 4), warn_unused_result))
478
705
static int init_gnutls_global(const char *pubkeyfilename,
479
const char *seckeyfilename){
706
const char *seckeyfilename,
707
const char *dhparamsfilename,
708
mandos_context *mc){
480
709
int ret;
481
710
482
711
if(debug){
483
712
fprintf_plus(stderr, "Initializing GnuTLS\n");
484
713
}
485
714
486
ret = gnutls_global_init();
487
if(ret != GNUTLS_E_SUCCESS){
488
fprintf_plus(stderr, "GnuTLS global_init: %s\n",
489
safer_gnutls_strerror(ret));
490
return -1;
491
}
492
493
715
if(debug){
494
716
/* "Use a log level over 10 to enable all debugging options."
495
717
* - GnuTLS manual
499
721
}
500
722
501
723
/* OpenPGP credentials */
502
ret = gnutls_certificate_allocate_credentials(&mc.cred);
724
ret = gnutls_certificate_allocate_credentials(&mc->cred);
503
725
if(ret != GNUTLS_E_SUCCESS){
504
726
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
505
727
safer_gnutls_strerror(ret));
506
gnutls_global_deinit();
507
728
return -1;
508
729
}
509
730
510
731
if(debug){
511
fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
512
" secret key %s as GnuTLS credentials\n",
732
fprintf_plus(stderr, "Attempting to use public key %s and"
733
" private key %s as GnuTLS credentials\n",
513
734
pubkeyfilename,
514
735
seckeyfilename);
515
736
}
516
737
738
#if GNUTLS_VERSION_NUMBER >= 0x030606
739
ret = gnutls_certificate_set_rawpk_key_file
740
(mc->cred, pubkeyfilename, seckeyfilename,
741
GNUTLS_X509_FMT_PEM, /* format */
742
NULL, /* pass */
743
/* key_usage */
744
GNUTLS_KEY_DIGITAL_SIGNATURE | GNUTLS_KEY_KEY_ENCIPHERMENT,
745
NULL, /* names */
746
0, /* names_length */
747
/* privkey_flags */
748
GNUTLS_PKCS_PLAIN | GNUTLS_PKCS_NULL_PASSWORD,
749
0); /* pkcs11_flags */
750
#elif GNUTLS_VERSION_NUMBER < 0x030600
517
751
ret = gnutls_certificate_set_openpgp_key_file
518
(mc.cred, pubkeyfilename, seckeyfilename,
752
(mc->cred, pubkeyfilename, seckeyfilename,
519
753
GNUTLS_OPENPGP_FMT_BASE64);
754
#else
755
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
756
#endif
520
757
if(ret != GNUTLS_E_SUCCESS){
521
758
fprintf_plus(stderr,
522
"Error[%d] while reading the OpenPGP key pair ('%s',"
759
"Error[%d] while reading the key pair ('%s',"
523
760
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
524
761
fprintf_plus(stderr, "The GnuTLS error is: %s\n",
525
762
safer_gnutls_strerror(ret));
527
764
}
528
765
529
766
/* GnuTLS server initialization */
530
ret = gnutls_dh_params_init(&mc.dh_params);
767
ret = gnutls_dh_params_init(&mc->dh_params);
531
768
if(ret != GNUTLS_E_SUCCESS){
532
769
fprintf_plus(stderr, "Error in GnuTLS DH parameter"
533
770
" initialization: %s\n",
534
771
safer_gnutls_strerror(ret));
535
772
goto globalfail;
536
773
}
537
ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
538
if(ret != GNUTLS_E_SUCCESS){
539
fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
540
safer_gnutls_strerror(ret));
541
goto globalfail;
542
}
543
544
gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
774
/* If a Diffie-Hellman parameters file was given, try to use it */
775
if(dhparamsfilename != NULL){
776
gnutls_datum_t params = { .data = NULL, .size = 0 };
777
do {
778
int dhpfile = open(dhparamsfilename, O_RDONLY);
779
if(dhpfile == -1){
780
perror_plus("open");
781
dhparamsfilename = NULL;
782
break;
783
}
784
size_t params_capacity = 0;
785
while(true){
786
params_capacity = incbuffer((char **)¶ms.data,
787
(size_t)params.size,
788
(size_t)params_capacity);
789
if(params_capacity == 0){
790
perror_plus("incbuffer");
791
free(params.data);
792
params.data = NULL;
793
dhparamsfilename = NULL;
794
break;
795
}
796
ssize_t bytes_read = read(dhpfile,
797
params.data + params.size,
798
BUFFER_SIZE);
799
/* EOF */
800
if(bytes_read == 0){
801
break;
802
}
803
/* check bytes_read for failure */
804
if(bytes_read < 0){
805
perror_plus("read");
806
free(params.data);
807
params.data = NULL;
808
dhparamsfilename = NULL;
809
break;
810
}
811
params.size += (unsigned int)bytes_read;
812
}
813
ret = close(dhpfile);
814
if(ret == -1){
815
perror_plus("close");
816
}
817
if(params.data == NULL){
818
dhparamsfilename = NULL;
819
}
820
if(dhparamsfilename == NULL){
821
break;
822
}
823
ret = gnutls_dh_params_import_pkcs3(mc->dh_params, ¶ms,
824
GNUTLS_X509_FMT_PEM);
825
if(ret != GNUTLS_E_SUCCESS){
826
fprintf_plus(stderr, "Failed to parse DH parameters in file"
827
" \"%s\": %s\n", dhparamsfilename,
828
safer_gnutls_strerror(ret));
829
dhparamsfilename = NULL;
830
}
831
free(params.data);
832
} while(false);
833
}
834
if(dhparamsfilename == NULL){
835
if(mc->dh_bits == 0){
836
#if GNUTLS_VERSION_NUMBER < 0x030600
837
/* Find out the optimal number of DH bits */
838
/* Try to read the private key file */
839
gnutls_datum_t buffer = { .data = NULL, .size = 0 };
840
do {
841
int secfile = open(seckeyfilename, O_RDONLY);
842
if(secfile == -1){
843
perror_plus("open");
844
break;
845
}
846
size_t buffer_capacity = 0;
847
while(true){
848
buffer_capacity = incbuffer((char **)&buffer.data,
849
(size_t)buffer.size,
850
(size_t)buffer_capacity);
851
if(buffer_capacity == 0){
852
perror_plus("incbuffer");
853
free(buffer.data);
854
buffer.data = NULL;
855
break;
856
}
857
ssize_t bytes_read = read(secfile,
858
buffer.data + buffer.size,
859
BUFFER_SIZE);
860
/* EOF */
861
if(bytes_read == 0){
862
break;
863
}
864
/* check bytes_read for failure */
865
if(bytes_read < 0){
866
perror_plus("read");
867
free(buffer.data);
868
buffer.data = NULL;
869
break;
870
}
871
buffer.size += (unsigned int)bytes_read;
872
}
873
close(secfile);
874
} while(false);
875
/* If successful, use buffer to parse private key */
876
gnutls_sec_param_t sec_param = GNUTLS_SEC_PARAM_ULTRA;
877
if(buffer.data != NULL){
878
{
879
gnutls_openpgp_privkey_t privkey = NULL;
880
ret = gnutls_openpgp_privkey_init(&privkey);
881
if(ret != GNUTLS_E_SUCCESS){
882
fprintf_plus(stderr, "Error initializing OpenPGP key"
883
" structure: %s",
884
safer_gnutls_strerror(ret));
885
free(buffer.data);
886
buffer.data = NULL;
887
} else {
888
ret = gnutls_openpgp_privkey_import
889
(privkey, &buffer, GNUTLS_OPENPGP_FMT_BASE64, "", 0);
890
if(ret != GNUTLS_E_SUCCESS){
891
fprintf_plus(stderr, "Error importing OpenPGP key : %s",
892
safer_gnutls_strerror(ret));
893
privkey = NULL;
894
}
895
free(buffer.data);
896
buffer.data = NULL;
897
if(privkey != NULL){
898
/* Use private key to suggest an appropriate
899
sec_param */
900
sec_param = gnutls_openpgp_privkey_sec_param(privkey);
901
gnutls_openpgp_privkey_deinit(privkey);
902
if(debug){
903
fprintf_plus(stderr, "This OpenPGP key implies using"
904
" a GnuTLS security parameter \"%s\".\n",
905
safe_string(gnutls_sec_param_get_name
906
(sec_param)));
907
}
908
}
909
}
910
}
911
if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
912
/* Err on the side of caution */
913
sec_param = GNUTLS_SEC_PARAM_ULTRA;
914
if(debug){
915
fprintf_plus(stderr, "Falling back to security parameter"
916
" \"%s\"\n",
917
safe_string(gnutls_sec_param_get_name
918
(sec_param)));
919
}
920
}
921
}
922
unsigned int uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
923
if(uret != 0){
924
mc->dh_bits = uret;
925
if(debug){
926
fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
927
" implies %u DH bits; using that.\n",
928
safe_string(gnutls_sec_param_get_name
929
(sec_param)),
930
mc->dh_bits);
931
}
932
} else {
933
fprintf_plus(stderr, "Failed to get implied number of DH"
934
" bits for security parameter \"%s\"): %s\n",
935
safe_string(gnutls_sec_param_get_name
936
(sec_param)),
937
safer_gnutls_strerror(ret));
938
goto globalfail;
939
}
940
#endif
941
} else { /* dh_bits != 0 */
942
if(debug){
943
fprintf_plus(stderr, "DH bits explicitly set to %u\n",
944
mc->dh_bits);
945
}
946
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
947
if(ret != GNUTLS_E_SUCCESS){
948
fprintf_plus(stderr, "Error in GnuTLS prime generation (%u"
949
" bits): %s\n", mc->dh_bits,
950
safer_gnutls_strerror(ret));
951
goto globalfail;
952
}
953
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
954
}
955
}
545
956
546
957
return 0;
547
958
548
959
globalfail:
549
960
550
gnutls_certificate_free_credentials(mc.cred);
551
gnutls_global_deinit();
552
gnutls_dh_params_deinit(mc.dh_params);
961
gnutls_certificate_free_credentials(mc->cred);
962
gnutls_dh_params_deinit(mc->dh_params);
553
963
return -1;
554
964
}
555
965
556
static int init_gnutls_session(gnutls_session_t *session){
966
__attribute__((nonnull, warn_unused_result))
967
static int init_gnutls_session(gnutls_session_t *session,
968
mandos_context *mc){
557
969
int ret;
558
970
/* GnuTLS session creation */
559
971
do {
560
ret = gnutls_init(session, GNUTLS_SERVER);
972
ret = gnutls_init(session, (GNUTLS_SERVER
973
#if GNUTLS_VERSION_NUMBER >= 0x030506
974
| GNUTLS_NO_TICKETS
975
#endif
976
#if GNUTLS_VERSION_NUMBER >= 0x030606
977
| GNUTLS_ENABLE_RAWPK
978
#endif
979
));
561
980
if(quit_now){
562
981
return -1;
563
982
}
571
990
{
572
991
const char *err;
573
992
do {
574
ret = gnutls_priority_set_direct(*session, mc.priority, &err);
993
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
575
994
if(quit_now){
576
995
gnutls_deinit(*session);
577
996
return -1;
588
1007
589
1008
do {
590
1009
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
591
mc.cred);
1010
mc->cred);
592
1011
if(quit_now){
593
1012
gnutls_deinit(*session);
594
1013
return -1;
604
1023
/* ignore client certificate if any. */
605
1024
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
606
1025
607
gnutls_dh_set_prime_bits(*session, mc.dh_bits);
608
609
1026
return 0;
610
1027
}
611
1028
613
1030
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
614
1031
__attribute__((unused)) const char *txt){}
615
1032
1033
/* Helper function to add_local_route() and delete_local_route() */
1034
__attribute__((nonnull, warn_unused_result))
1035
static bool add_delete_local_route(const bool add,
1036
const char *address,
1037
AvahiIfIndex if_index){
1038
int ret;
1039
char helper[] = "mandos-client-iprouteadddel";
1040
char add_arg[] = "add";
1041
char delete_arg[] = "delete";
1042
char debug_flag[] = "--debug";
1043
char *pluginhelperdir = getenv("MANDOSPLUGINHELPERDIR");
1044
if(pluginhelperdir == NULL){
1045
if(debug){
1046
fprintf_plus(stderr, "MANDOSPLUGINHELPERDIR environment"
1047
" variable not set; cannot run helper\n");
1048
}
1049
return false;
1050
}
1051
1052
char interface[IF_NAMESIZE];
1053
if(if_indextoname((unsigned int)if_index, interface) == NULL){
1054
perror_plus("if_indextoname");
1055
return false;
1056
}
1057
1058
int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
1059
if(devnull == -1){
1060
perror_plus("open(\"/dev/null\", O_RDONLY)");
1061
return false;
1062
}
1063
pid_t pid = fork();
1064
if(pid == 0){
1065
/* Child */
1066
/* Raise privileges */
1067
errno = raise_privileges_permanently();
1068
if(errno != 0){
1069
perror_plus("Failed to raise privileges");
1070
/* _exit(EX_NOPERM); */
1071
} else {
1072
/* Set group */
1073
errno = 0;
1074
ret = setgid(0);
1075
if(ret == -1){
1076
perror_plus("setgid");
1077
close(devnull);
1078
_exit(EX_NOPERM);
1079
}
1080
/* Reset supplementary groups */
1081
errno = 0;
1082
ret = setgroups(0, NULL);
1083
if(ret == -1){
1084
perror_plus("setgroups");
1085
close(devnull);
1086
_exit(EX_NOPERM);
1087
}
1088
}
1089
ret = dup2(devnull, STDIN_FILENO);
1090
if(ret == -1){
1091
perror_plus("dup2(devnull, STDIN_FILENO)");
1092
close(devnull);
1093
_exit(EX_OSERR);
1094
}
1095
ret = close(devnull);
1096
if(ret == -1){
1097
perror_plus("close");
1098
}
1099
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
1100
if(ret == -1){
1101
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
1102
_exit(EX_OSERR);
1103
}
1104
int helperdir_fd = (int)TEMP_FAILURE_RETRY(open(pluginhelperdir,
1105
O_RDONLY
1106
| O_DIRECTORY
1107
| O_PATH
1108
| O_CLOEXEC));
1109
if(helperdir_fd == -1){
1110
perror_plus("open");
1111
_exit(EX_UNAVAILABLE);
1112
}
1113
int helper_fd = (int)TEMP_FAILURE_RETRY(openat(helperdir_fd,
1114
helper, O_RDONLY));
1115
if(helper_fd == -1){
1116
perror_plus("openat");
1117
close(helperdir_fd);
1118
_exit(EX_UNAVAILABLE);
1119
}
1120
close(helperdir_fd);
1121
#ifdef __GNUC__
1122
#pragma GCC diagnostic push
1123
#pragma GCC diagnostic ignored "-Wcast-qual"
1124
#endif
1125
if(fexecve(helper_fd, (char *const [])
1126
{ helper, add ? add_arg : delete_arg, (char *)address,
1127
interface, debug ? debug_flag : NULL, NULL },
1128
environ) == -1){
1129
#ifdef __GNUC__
1130
#pragma GCC diagnostic pop
1131
#endif
1132
perror_plus("fexecve");
1133
_exit(EXIT_FAILURE);
1134
}
1135
}
1136
if(pid == -1){
1137
perror_plus("fork");
1138
close(devnull);
1139
return false;
1140
}
1141
ret = close(devnull);
1142
if(ret == -1){
1143
perror_plus("close");
1144
}
1145
int status;
1146
pid_t pret = -1;
1147
errno = 0;
1148
do {
1149
pret = waitpid(pid, &status, 0);
1150
if(pret == -1 and errno == EINTR and quit_now){
1151
int errno_raising = 0;
1152
if((errno = raise_privileges()) != 0){
1153
errno_raising = errno;
1154
perror_plus("Failed to raise privileges in order to"
1155
" kill helper program");
1156
}
1157
if(kill(pid, SIGTERM) == -1){
1158
perror_plus("kill");
1159
}
1160
if((errno_raising == 0) and (errno = lower_privileges()) != 0){
1161
perror_plus("Failed to lower privileges after killing"
1162
" helper program");
1163
}
1164
return false;
1165
}
1166
} while(pret == -1 and errno == EINTR);
1167
if(pret == -1){
1168
perror_plus("waitpid");
1169
return false;
1170
}
1171
if(WIFEXITED(status)){
1172
if(WEXITSTATUS(status) != 0){
1173
fprintf_plus(stderr, "Error: iprouteadddel exited"
1174
" with status %d\n", WEXITSTATUS(status));
1175
return false;
1176
}
1177
return true;
1178
}
1179
if(WIFSIGNALED(status)){
1180
fprintf_plus(stderr, "Error: iprouteadddel died by"
1181
" signal %d\n", WTERMSIG(status));
1182
return false;
1183
}
1184
fprintf_plus(stderr, "Error: iprouteadddel crashed\n");
1185
return false;
1186
}
1187
1188
__attribute__((nonnull, warn_unused_result))
1189
static bool add_local_route(const char *address,
1190
AvahiIfIndex if_index){
1191
if(debug){
1192
fprintf_plus(stderr, "Adding route to %s\n", address);
1193
}
1194
return add_delete_local_route(true, address, if_index);
1195
}
1196
1197
__attribute__((nonnull, warn_unused_result))
1198
static bool delete_local_route(const char *address,
1199
AvahiIfIndex if_index){
1200
if(debug){
1201
fprintf_plus(stderr, "Removing route to %s\n", address);
1202
}
1203
return add_delete_local_route(false, address, if_index);
1204
}
1205
616
1206
/* Called when a Mandos server is found */
617
static int start_mandos_communication(const char *ip, uint16_t port,
1207
__attribute__((nonnull, warn_unused_result))
1208
static int start_mandos_communication(const char *ip, in_port_t port,
618
1209
AvahiIfIndex if_index,
619
int af){
1210
int af, mandos_context *mc){
620
1211
int ret, tcp_sd = -1;
621
1212
ssize_t sret;
622
union {
623
struct sockaddr_in in;
624
struct sockaddr_in6 in6;
625
} to;
1213
struct sockaddr_storage to;
626
1214
char *buffer = NULL;
627
1215
char *decrypted_buffer = NULL;
628
1216
size_t buffer_length = 0;
631
1219
int retval = -1;
632
1220
gnutls_session_t session;
633
1221
int pf; /* Protocol family */
1222
bool route_added = false;
634
1223
635
1224
errno = 0;
636
1225
652
1241
return -1;
653
1242
}
654
1243
655
ret = init_gnutls_session(&session);
1244
/* If the interface is specified and we have a list of interfaces */
1245
if(if_index != AVAHI_IF_UNSPEC and mc->interfaces != NULL){
1246
/* Check if the interface is one of the interfaces we are using */
1247
bool match = false;
1248
{
1249
char *interface = NULL;
1250
while((interface = argz_next(mc->interfaces,
1251
mc->interfaces_size,
1252
interface))){
1253
if(if_nametoindex(interface) == (unsigned int)if_index){
1254
match = true;
1255
break;
1256
}
1257
}
1258
}
1259
if(not match){
1260
/* This interface does not match any in the list, so we don't
1261
connect to the server */
1262
if(debug){
1263
char interface[IF_NAMESIZE];
1264
if(if_indextoname((unsigned int)if_index, interface) == NULL){
1265
perror_plus("if_indextoname");
1266
} else {
1267
fprintf_plus(stderr, "Skipping server on non-used interface"
1268
" \"%s\"\n",
1269
if_indextoname((unsigned int)if_index,
1270
interface));
1271
}
1272
}
1273
return -1;
1274
}
1275
}
1276
1277
ret = init_gnutls_session(&session, mc);
656
1278
if(ret != 0){
657
1279
return -1;
658
1280
}
659
1281
660
1282
if(debug){
661
1283
fprintf_plus(stderr, "Setting up a TCP connection to %s, port %"
662
PRIu16 "\n", ip, port);
1284
PRIuMAX "\n", ip, (uintmax_t)port);
663
1285
}
664
1286
665
tcp_sd = socket(pf, SOCK_STREAM, 0);
1287
tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
666
1288
if(tcp_sd < 0){
667
1289
int e = errno;
668
1290
perror_plus("socket");
675
1297
goto mandos_end;
676
1298
}
677
1299
678
memset(&to, 0, sizeof(to));
679
1300
if(af == AF_INET6){
680
to.in6.sin6_family = (sa_family_t)af;
681
ret = inet_pton(af, ip, &to.in6.sin6_addr);
1301
struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)&to;
1302
*to6 = (struct sockaddr_in6){ .sin6_family = (sa_family_t)af };
1303
ret = inet_pton(af, ip, &to6->sin6_addr);
682
1304
} else { /* IPv4 */
683
to.in.sin_family = (sa_family_t)af;
684
ret = inet_pton(af, ip, &to.in.sin_addr);
1305
struct sockaddr_in *to4 = (struct sockaddr_in *)&to;
1306
*to4 = (struct sockaddr_in){ .sin_family = (sa_family_t)af };
1307
ret = inet_pton(af, ip, &to4->sin_addr);
685
1308
}
686
1309
if(ret < 0 ){
687
1310
int e = errno;
696
1319
goto mandos_end;
697
1320
}
698
1321
if(af == AF_INET6){
699
to.in6.sin6_port = htons(port); /* Spurious warnings from
700
-Wconversion and
701
-Wunreachable-code */
702
703
if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
704
(&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
705
-Wunreachable-code*/
1322
((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
1323
if(IN6_IS_ADDR_LINKLOCAL
1324
(&((struct sockaddr_in6 *)&to)->sin6_addr)){
706
1325
if(if_index == AVAHI_IF_UNSPEC){
707
1326
fprintf_plus(stderr, "An IPv6 link-local address is"
708
1327
" incomplete without a network interface\n");
710
1329
goto mandos_end;
711
1330
}
712
1331
/* Set the network interface number as scope */
713
to.in6.sin6_scope_id = (uint32_t)if_index;
1332
((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
714
1333
}
715
1334
} else {
716
to.in.sin_port = htons(port); /* Spurious warnings from
717
-Wconversion and
718
-Wunreachable-code */
1335
((struct sockaddr_in *)&to)->sin_port = htons(port);
719
1336
}
720
1337
721
1338
if(quit_now){
729
1346
if(if_indextoname((unsigned int)if_index, interface) == NULL){
730
1347
perror_plus("if_indextoname");
731
1348
} else {
732
fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIu16
733
"\n", ip, interface, port);
1349
fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIuMAX
1350
"\n", ip, interface, (uintmax_t)port);
734
1351
}
735
1352
} else {
736
fprintf_plus(stderr, "Connection to: %s, port %" PRIu16 "\n",
737
ip, port);
1353
fprintf_plus(stderr, "Connection to: %s, port %" PRIuMAX "\n",
1354
ip, (uintmax_t)port);
738
1355
}
739
1356
char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
740
1357
INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
741
const char *pcret;
742
if(af == AF_INET6){
743
pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
744
sizeof(addrstr));
745
} else {
746
pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
747
sizeof(addrstr));
748
}
749
if(pcret == NULL){
750
perror_plus("inet_ntop");
751
} else {
752
if(strcmp(addrstr, ip) != 0){
753
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
754
}
755
}
756
}
757
758
if(quit_now){
759
errno = EINTR;
760
goto mandos_end;
761
}
762
763
if(af == AF_INET6){
764
ret = connect(tcp_sd, &to.in6, sizeof(to));
765
} else {
766
ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
767
}
768
if(ret < 0){
769
if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
770
int e = errno;
771
perror_plus("connect");
772
errno = e;
773
}
774
goto mandos_end;
775
}
776
777
if(quit_now){
778
errno = EINTR;
779
goto mandos_end;
1358
if(af == AF_INET6){
1359
ret = getnameinfo((struct sockaddr *)&to,
1360
sizeof(struct sockaddr_in6),
1361
addrstr, sizeof(addrstr), NULL, 0,
1362
NI_NUMERICHOST);
1363
} else {
1364
ret = getnameinfo((struct sockaddr *)&to,
1365
sizeof(struct sockaddr_in),
1366
addrstr, sizeof(addrstr), NULL, 0,
1367
NI_NUMERICHOST);
1368
}
1369
if(ret == EAI_SYSTEM){
1370
perror_plus("getnameinfo");
1371
} else if(ret != 0) {
1372
fprintf_plus(stderr, "getnameinfo: %s", gai_strerror(ret));
1373
} else if(strcmp(addrstr, ip) != 0){
1374
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
1375
}
1376
}
1377
1378
if(quit_now){
1379
errno = EINTR;
1380
goto mandos_end;
1381
}
1382
1383
while(true){
1384
if(af == AF_INET6){
1385
ret = connect(tcp_sd, (struct sockaddr *)&to,
1386
sizeof(struct sockaddr_in6));
1387
} else {
1388
ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
1389
sizeof(struct sockaddr_in));
1390
}
1391
if(ret < 0){
1392
if(((errno == ENETUNREACH) or (errno == EHOSTUNREACH))
1393
and if_index != AVAHI_IF_UNSPEC
1394
and connect_to == NULL
1395
and not route_added and
1396
((af == AF_INET6 and not
1397
IN6_IS_ADDR_LINKLOCAL(&(((struct sockaddr_in6 *)
1398
&to)->sin6_addr)))
1399
or (af == AF_INET and
1400
/* Not a a IPv4LL address */
1401
(ntohl(((struct sockaddr_in *)&to)->sin_addr.s_addr)
1402
& 0xFFFF0000L) != 0xA9FE0000L))){
1403
/* Work around Avahi bug - Avahi does not announce link-local
1404
addresses if it has a global address, so local hosts with
1405
*only* a link-local address (e.g. Mandos clients) cannot
1406
connect to a Mandos server announced by Avahi on a server
1407
host with a global address. Work around this by retrying
1408
with an explicit route added with the server's address.
1409
1410
Avahi bug reference:
1411
https://lists.freedesktop.org/archives/avahi/2010-February/001833.html
1412
https://bugs.debian.org/587961
1413
*/
1414
if(debug){
1415
fprintf_plus(stderr, "Mandos server unreachable, trying"
1416
" direct route\n");
1417
}
1418
int e = errno;
1419
route_added = add_local_route(ip, if_index);
1420
if(route_added){
1421
continue;
1422
}
1423
errno = e;
1424
}
1425
if(errno != ECONNREFUSED or debug){
1426
int e = errno;
1427
perror_plus("connect");
1428
errno = e;
1429
}
1430
goto mandos_end;
1431
}
1432
1433
if(quit_now){
1434
errno = EINTR;
1435
goto mandos_end;
1436
}
1437
break;
780
1438
}
781
1439
782
1440
const char *out = mandos_protocol_version;
818
1476
goto mandos_end;
819
1477
}
820
1478
821
/* Spurious warning from -Wint-to-pointer-cast */
822
gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
1479
/* This casting via intptr_t is to eliminate warning about casting
1480
an int to a pointer type. This is exactly how the GnuTLS Guile
1481
function "set-session-transport-fd!" does it. */
1482
gnutls_transport_set_ptr(session,
1483
(gnutls_transport_ptr_t)(intptr_t)tcp_sd);
823
1484
824
1485
if(quit_now){
825
1486
errno = EINTR;
930
1591
if(buffer_length > 0){
931
1592
ssize_t decrypted_buffer_size;
932
1593
decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
933
&decrypted_buffer);
1594
&decrypted_buffer, mc);
934
1595
if(decrypted_buffer_size >= 0){
935
1596
1597
clearerr(stdout);
936
1598
written = 0;
937
1599
while(written < (size_t) decrypted_buffer_size){
938
1600
if(quit_now){
954
1616
}
955
1617
written += (size_t)ret;
956
1618
}
1619
ret = fflush(stdout);
1620
if(ret != 0){
1621
int e = errno;
1622
if(debug){
1623
fprintf_plus(stderr, "Error writing encrypted data: %s\n",
1624
strerror(errno));
1625
}
1626
errno = e;
1627
goto mandos_end;
1628
}
957
1629
retval = 0;
958
1630
}
959
1631
}
962
1634
963
1635
mandos_end:
964
1636
{
1637
if(route_added){
1638
if(not delete_local_route(ip, if_index)){
1639
fprintf_plus(stderr, "Failed to delete local route to %s on"
1640
" interface %d", ip, if_index);
1641
}
1642
}
965
1643
int e = errno;
966
1644
free(decrypted_buffer);
967
1645
free(buffer);
968
1646
if(tcp_sd >= 0){
969
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
1647
ret = close(tcp_sd);
970
1648
}
971
1649
if(ret == -1){
972
1650
if(e == 0){
997
1675
AVAHI_GCC_UNUSED AvahiStringList *txt,
998
1676
AVAHI_GCC_UNUSED AvahiLookupResultFlags
999
1677
flags,
1000
AVAHI_GCC_UNUSED void* userdata){
1001
assert(r);
1678
void *mc){
1679
if(r == NULL){
1680
return;
1681
}
1002
1682
1003
1683
/* Called whenever a service has been resolved successfully or
1004
1684
timed out */
1005
1685
1006
1686
if(quit_now){
1687
avahi_s_service_resolver_free(r);
1007
1688
return;
1008
1689
}
1009
1690
1013
1694
fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
1014
1695
"'%s' of type '%s' in domain '%s': %s\n", name, type,
1015
1696
domain,
1016
avahi_strerror(avahi_server_errno(mc.server)));
1697
avahi_strerror(avahi_server_errno
1698
(((mandos_context*)mc)->server)));
1017
1699
break;
1018
1700
1019
1701
case AVAHI_RESOLVER_FOUND:
1025
1707
PRIdMAX ") on port %" PRIu16 "\n", name,
1026
1708
host_name, ip, (intmax_t)interface, port);
1027
1709
}
1028
int ret = start_mandos_communication(ip, port, interface,
1029
avahi_proto_to_af(proto));
1710
int ret = start_mandos_communication(ip, (in_port_t)port,
1711
interface,
1712
avahi_proto_to_af(proto),
1713
mc);
1030
1714
if(ret == 0){
1031
avahi_simple_poll_quit(mc.simple_poll);
1715
avahi_simple_poll_quit(simple_poll);
1032
1716
} else {
1033
ret = add_server(ip, port, interface,
1034
avahi_proto_to_af(proto));
1717
if(not add_server(ip, (in_port_t)port, interface,
1718
avahi_proto_to_af(proto),
1719
&((mandos_context*)mc)->current_server)){
1720
fprintf_plus(stderr, "Failed to add server \"%s\" to server"
1721
" list\n", name);
1722
}
1035
1723
}
1036
1724
}
1037
1725
}
1047
1735
const char *domain,
1048
1736
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1049
1737
flags,
1050
AVAHI_GCC_UNUSED void* userdata){
1051
assert(b);
1738
void *mc){
1739
if(b == NULL){
1740
return;
1741
}
1052
1742
1053
1743
/* Called whenever a new services becomes available on the LAN or
1054
1744
is removed from the LAN */
1062
1752
case AVAHI_BROWSER_FAILURE:
1063
1753
1064
1754
fprintf_plus(stderr, "(Avahi browser) %s\n",
1065
avahi_strerror(avahi_server_errno(mc.server)));
1066
avahi_simple_poll_quit(mc.simple_poll);
1755
avahi_strerror(avahi_server_errno
1756
(((mandos_context*)mc)->server)));
1757
avahi_simple_poll_quit(simple_poll);
1067
1758
return;
1068
1759
1069
1760
case AVAHI_BROWSER_NEW:
1072
1763
the callback function is called the Avahi server will free the
1073
1764
resolver for us. */
1074
1765
1075
if(avahi_s_service_resolver_new(mc.server, interface, protocol,
1076
name, type, domain, protocol, 0,
1077
resolve_callback, NULL) == NULL)
1766
if(avahi_s_service_resolver_new(((mandos_context*)mc)->server,
1767
interface, protocol, name, type,
1768
domain, protocol, 0,
1769
resolve_callback, mc) == NULL)
1078
1770
fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
1079
1771
" %s\n", name,
1080
avahi_strerror(avahi_server_errno(mc.server)));
1772
avahi_strerror(avahi_server_errno
1773
(((mandos_context*)mc)->server)));
1081
1774
break;
1082
1775
1083
1776
case AVAHI_BROWSER_REMOVE:
1102
1795
signal_received = sig;
1103
1796
int old_errno = errno;
1104
1797
/* set main loop to exit */
1105
if(mc.simple_poll != NULL){
1106
avahi_simple_poll_quit(mc.simple_poll);
1798
if(simple_poll != NULL){
1799
avahi_simple_poll_quit(simple_poll);
1107
1800
}
1108
1801
errno = old_errno;
1109
1802
}
1110
1803
1804
__attribute__((nonnull, warn_unused_result))
1111
1805
bool get_flags(const char *ifname, struct ifreq *ifr){
1112
1806
int ret;
1807
int old_errno;
1113
1808
1114
1809
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1115
1810
if(s < 0){
1811
old_errno = errno;
1116
1812
perror_plus("socket");
1813
errno = old_errno;
1117
1814
return false;
1118
1815
}
1119
strcpy(ifr->ifr_name, ifname);
1816
strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
1817
ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
1120
1818
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1121
1819
if(ret == -1){
1122
1820
if(debug){
1821
old_errno = errno;
1123
1822
perror_plus("ioctl SIOCGIFFLAGS");
1823
errno = old_errno;
1824
}
1825
if((close(s) == -1) and debug){
1826
old_errno = errno;
1827
perror_plus("close");
1828
errno = old_errno;
1124
1829
}
1125
1830
return false;
1126
1831
}
1832
if((close(s) == -1) and debug){
1833
old_errno = errno;
1834
perror_plus("close");
1835
errno = old_errno;
1836
}
1127
1837
return true;
1128
1838
}
1129
1839
1840
__attribute__((nonnull, warn_unused_result))
1130
1841
bool good_flags(const char *ifname, const struct ifreq *ifr){
1131
1842
1132
1843
/* Reject the loopback device */
1174
1885
* corresponds to an acceptable network device.
1175
1886
* (This function is passed to scandir(3) as a filter function.)
1176
1887
*/
1888
__attribute__((nonnull, warn_unused_result))
1177
1889
int good_interface(const struct dirent *if_entry){
1178
1890
if(if_entry->d_name[0] == '.'){
1179
1891
return 0;
1195
1907
}
1196
1908
1197
1909
/*
1198
* This function determines if a directory entry in /sys/class/net
1199
* corresponds to an acceptable network device which is up.
1200
* (This function is passed to scandir(3) as a filter function.)
1201
*/
1202
int up_interface(const struct dirent *if_entry){
1203
if(if_entry->d_name[0] == '.'){
1204
return 0;
1205
}
1206
1207
struct ifreq ifr;
1208
if(not get_flags(if_entry->d_name, &ifr)){
1209
if(debug){
1210
fprintf_plus(stderr, "Failed to get flags for interface "
1211
"\"%s\"\n", if_entry->d_name);
1212
}
1213
return 0;
1214
}
1215
1216
/* Reject down interfaces */
1217
if(not (ifr.ifr_flags & IFF_UP)){
1218
if(debug){
1219
fprintf_plus(stderr, "Rejecting down interface \"%s\"\n",
1220
if_entry->d_name);
1221
}
1222
return 0;
1223
}
1224
1225
/* Reject non-running interfaces */
1226
if(not (ifr.ifr_flags & IFF_RUNNING)){
1227
if(debug){
1228
fprintf_plus(stderr, "Rejecting non-running interface \"%s\"\n",
1229
if_entry->d_name);
1230
}
1231
return 0;
1232
}
1233
1234
if(not good_flags(if_entry->d_name, &ifr)){
1235
return 0;
1236
}
1237
return 1;
1238
}
1239
1910
* This function determines if a network interface is up.
1911
*/
1912
__attribute__((nonnull, warn_unused_result))
1913
bool interface_is_up(const char *interface){
1914
struct ifreq ifr;
1915
if(not get_flags(interface, &ifr)){
1916
if(debug){
1917
fprintf_plus(stderr, "Failed to get flags for interface "
1918
"\"%s\"\n", interface);
1919
}
1920
return false;
1921
}
1922
1923
return (bool)(ifr.ifr_flags & IFF_UP);
1924
}
1925
1926
/*
1927
* This function determines if a network interface is running
1928
*/
1929
__attribute__((nonnull, warn_unused_result))
1930
bool interface_is_running(const char *interface){
1931
struct ifreq ifr;
1932
if(not get_flags(interface, &ifr)){
1933
if(debug){
1934
fprintf_plus(stderr, "Failed to get flags for interface "
1935
"\"%s\"\n", interface);
1936
}
1937
return false;
1938
}
1939
1940
return (bool)(ifr.ifr_flags & IFF_RUNNING);
1941
}
1942
1943
__attribute__((nonnull, pure, warn_unused_result))
1240
1944
int notdotentries(const struct dirent *direntry){
1241
1945
/* Skip "." and ".." */
1242
1946
if(direntry->d_name[0] == '.'
1249
1953
}
1250
1954
1251
1955
/* Is this directory entry a runnable program? */
1956
__attribute__((nonnull, warn_unused_result))
1252
1957
int runnable_hook(const struct dirent *direntry){
1253
1958
int ret;
1254
1959
size_t sret;
1262
1967
sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1263
1968
"abcdefghijklmnopqrstuvwxyz"
1264
1969
"0123456789"
1265
"_-");
1970
"_.-");
1266
1971
if((direntry->d_name)[sret] != '\0'){
1267
1972
/* Contains non-allowed characters */
1268
1973
if(debug){
1272
1977
return 0;
1273
1978
}
1274
1979
1275
char *fullname = NULL;
1276
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1277
if(ret < 0){
1278
perror_plus("asprintf");
1279
return 0;
1280
}
1281
1282
ret = stat(fullname, &st);
1980
ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1283
1981
if(ret == -1){
1284
1982
if(debug){
1285
1983
perror_plus("Could not stat hook");
1309
2007
return 1;
1310
2008
}
1311
2009
1312
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval){
2010
__attribute__((nonnull, warn_unused_result))
2011
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
2012
mandos_context *mc){
1313
2013
int ret;
1314
2014
struct timespec now;
1315
2015
struct timespec waited_time;
1316
2016
intmax_t block_time;
1317
2017
1318
2018
while(true){
1319
if(mc.current_server == NULL){
1320
if (debug){
2019
if(mc->current_server == NULL){
2020
if(debug){
1321
2021
fprintf_plus(stderr, "Wait until first server is found."
1322
2022
" No timeout!\n");
1323
2023
}
1324
2024
ret = avahi_simple_poll_iterate(s, -1);
1325
2025
} else {
1326
if (debug){
2026
if(debug){
1327
2027
fprintf_plus(stderr, "Check current_server if we should run"
1328
2028
" it, or wait\n");
1329
2029
}
1336
2036
/* Calculating in ms how long time between now and server
1337
2037
who we visted longest time ago. Now - last seen. */
1338
2038
waited_time.tv_sec = (now.tv_sec
1339
- mc.current_server->last_seen.tv_sec);
2039
- mc->current_server->last_seen.tv_sec);
1340
2040
waited_time.tv_nsec = (now.tv_nsec
1341
- mc.current_server->last_seen.tv_nsec);
2041
- mc->current_server->last_seen.tv_nsec);
1342
2042
/* total time is 10s/10,000ms.
1343
2043
Converting to s from ms by dividing by 1,000,
1344
2044
and ns to ms by dividing by 1,000,000. */
1346
2046
- ((intmax_t)waited_time.tv_sec * 1000))
1347
2047
- ((intmax_t)waited_time.tv_nsec / 1000000));
1348
2048
1349
if (debug){
2049
if(debug){
1350
2050
fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1351
2051
block_time);
1352
2052
}
1353
2053
1354
2054
if(block_time <= 0){
1355
ret = start_mandos_communication(mc.current_server->ip,
1356
mc.current_server->port,
1357
mc.current_server->if_index,
1358
mc.current_server->af);
2055
ret = start_mandos_communication(mc->current_server->ip,
2056
mc->current_server->port,
2057
mc->current_server->if_index,
2058
mc->current_server->af, mc);
1359
2059
if(ret == 0){
1360
avahi_simple_poll_quit(mc.simple_poll);
2060
avahi_simple_poll_quit(s);
1361
2061
return 0;
1362
2062
}
1363
2063
ret = clock_gettime(CLOCK_MONOTONIC,
1364
&mc.current_server->last_seen);
2064
&mc->current_server->last_seen);
1365
2065
if(ret == -1){
1366
2066
perror_plus("clock_gettime");
1367
2067
return -1;
1368
2068
}
1369
mc.current_server = mc.current_server->next;
2069
mc->current_server = mc->current_server->next;
1370
2070
block_time = 0; /* Call avahi to find new Mandos
1371
2071
servers, but don't block */
1372
2072
}
1374
2074
ret = avahi_simple_poll_iterate(s, (int)block_time);
1375
2075
}
1376
2076
if(ret != 0){
1377
if (ret > 0 or errno != EINTR){
2077
if(ret > 0 or errno != EINTR){
1378
2078
return (ret != 1) ? ret : 0;
1379
2079
}
1380
2080
}
1381
2081
}
1382
2082
}
1383
2083
1384
bool run_network_hooks(const char *mode, const char *interface,
2084
__attribute__((nonnull))
2085
void run_network_hooks(const char *mode, const char *interface,
1385
2086
const float delay){
1386
struct dirent **direntries;
1387
struct dirent *direntry;
1388
int ret;
1389
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1390
alphasort);
2087
struct dirent **direntries = NULL;
2088
if(hookdir_fd == -1){
2089
hookdir_fd = open(hookdir, O_RDONLY | O_DIRECTORY | O_PATH
2090
| O_CLOEXEC);
2091
if(hookdir_fd == -1){
2092
if(errno == ENOENT){
2093
if(debug){
2094
fprintf_plus(stderr, "Network hook directory \"%s\" not"
2095
" found\n", hookdir);
2096
}
2097
} else {
2098
perror_plus("open");
2099
}
2100
return;
2101
}
2102
}
2103
int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
2104
if(devnull == -1){
2105
perror_plus("open(\"/dev/null\", O_RDONLY)");
2106
return;
2107
}
2108
int numhooks = scandirat(hookdir_fd, ".", &direntries,
2109
runnable_hook, alphasort);
1391
2110
if(numhooks == -1){
1392
2111
perror_plus("scandir");
1393
} else {
1394
int devnull = open("/dev/null", O_RDONLY);
1395
for(int i = 0; i < numhooks; i++){
1396
direntry = direntries[i];
1397
char *fullname = NULL;
1398
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1399
if(ret < 0){
2112
close(devnull);
2113
return;
2114
}
2115
struct dirent *direntry;
2116
int ret;
2117
for(int i = 0; i < numhooks; i++){
2118
direntry = direntries[i];
2119
if(debug){
2120
fprintf_plus(stderr, "Running network hook \"%s\"\n",
2121
direntry->d_name);
2122
}
2123
pid_t hook_pid = fork();
2124
if(hook_pid == 0){
2125
/* Child */
2126
/* Raise privileges */
2127
errno = raise_privileges_permanently();
2128
if(errno != 0){
2129
perror_plus("Failed to raise privileges");
2130
_exit(EX_NOPERM);
2131
}
2132
/* Set group */
2133
errno = 0;
2134
ret = setgid(0);
2135
if(ret == -1){
2136
perror_plus("setgid");
2137
_exit(EX_NOPERM);
2138
}
2139
/* Reset supplementary groups */
2140
errno = 0;
2141
ret = setgroups(0, NULL);
2142
if(ret == -1){
2143
perror_plus("setgroups");
2144
_exit(EX_NOPERM);
2145
}
2146
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
2147
if(ret == -1){
2148
perror_plus("setenv");
2149
_exit(EX_OSERR);
2150
}
2151
ret = setenv("DEVICE", interface, 1);
2152
if(ret == -1){
2153
perror_plus("setenv");
2154
_exit(EX_OSERR);
2155
}
2156
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
2157
if(ret == -1){
2158
perror_plus("setenv");
2159
_exit(EX_OSERR);
2160
}
2161
ret = setenv("MODE", mode, 1);
2162
if(ret == -1){
2163
perror_plus("setenv");
2164
_exit(EX_OSERR);
2165
}
2166
char *delaystring;
2167
ret = asprintf(&delaystring, "%f", (double)delay);
2168
if(ret == -1){
1400
2169
perror_plus("asprintf");
1401
continue;
1402
}
1403
if(debug){
1404
fprintf_plus(stderr, "Running network hook \"%s\"\n",
1405
direntry->d_name);
1406
}
1407
pid_t hook_pid = fork();
1408
if(hook_pid == 0){
1409
/* Child */
1410
/* Raise privileges */
1411
errno = 0;
1412
ret = seteuid(0);
1413
if(ret == -1){
1414
perror_plus("seteuid");
1415
}
1416
/* Raise privileges even more */
1417
errno = 0;
1418
ret = setuid(0);
1419
if(ret == -1){
1420
perror_plus("setuid");
1421
}
1422
/* Set group */
1423
errno = 0;
1424
ret = setgid(0);
1425
if(ret == -1){
1426
perror_plus("setgid");
1427
}
1428
/* Reset supplementary groups */
1429
errno = 0;
1430
ret = setgroups(0, NULL);
1431
if(ret == -1){
1432
perror_plus("setgroups");
1433
}
1434
dup2(devnull, STDIN_FILENO);
1435
close(devnull);
1436
dup2(STDERR_FILENO, STDOUT_FILENO);
1437
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1438
if(ret == -1){
1439
perror_plus("setenv");
1440
_exit(EX_OSERR);
1441
}
1442
ret = setenv("DEVICE", interface, 1);
1443
if(ret == -1){
1444
perror_plus("setenv");
1445
_exit(EX_OSERR);
1446
}
1447
ret = setenv("VERBOSE", debug ? "1" : "0", 1);
1448
if(ret == -1){
1449
perror_plus("setenv");
1450
_exit(EX_OSERR);
1451
}
1452
ret = setenv("MODE", mode, 1);
1453
if(ret == -1){
1454
perror_plus("setenv");
1455
_exit(EX_OSERR);
1456
}
1457
char *delaystring;
1458
ret = asprintf(&delaystring, "%f", delay);
1459
if(ret == -1){
1460
perror_plus("asprintf");
1461
_exit(EX_OSERR);
1462
}
1463
ret = setenv("DELAY", delaystring, 1);
1464
if(ret == -1){
1465
free(delaystring);
1466
perror_plus("setenv");
1467
_exit(EX_OSERR);
1468
}
2170
_exit(EX_OSERR);
2171
}
2172
ret = setenv("DELAY", delaystring, 1);
2173
if(ret == -1){
1469
2174
free(delaystring);
1470
ret = execl(fullname, direntry->d_name, mode, NULL);
1471
perror_plus("execl");
1472
} else {
1473
int status;
1474
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1475
perror_plus("waitpid");
1476
free(fullname);
1477
continue;
1478
}
1479
if(WIFEXITED(status)){
1480
if(WEXITSTATUS(status) != 0){
1481
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1482
" with status %d\n", direntry->d_name,
1483
WEXITSTATUS(status));
1484
free(fullname);
1485
continue;
1486
}
1487
} else if(WIFSIGNALED(status)){
1488
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1489
" signal %d\n", direntry->d_name,
1490
WTERMSIG(status));
1491
free(fullname);
1492
continue;
1493
} else {
1494
fprintf_plus(stderr, "Warning: network hook \"%s\""
1495
" crashed\n", direntry->d_name);
1496
free(fullname);
1497
continue;
1498
}
1499
}
1500
free(fullname);
1501
if(debug){
1502
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1503
direntry->d_name);
1504
}
1505
}
1506
close(devnull);
1507
}
1508
return true;
2175
perror_plus("setenv");
2176
_exit(EX_OSERR);
2177
}
2178
free(delaystring);
2179
if(connect_to != NULL){
2180
ret = setenv("CONNECT", connect_to, 1);
2181
if(ret == -1){
2182
perror_plus("setenv");
2183
_exit(EX_OSERR);
2184
}
2185
}
2186
int hook_fd = (int)TEMP_FAILURE_RETRY(openat(hookdir_fd,
2187
direntry->d_name,
2188
O_RDONLY));
2189
if(hook_fd == -1){
2190
perror_plus("openat");
2191
_exit(EXIT_FAILURE);
2192
}
2193
if(close(hookdir_fd) == -1){
2194
perror_plus("close");
2195
_exit(EXIT_FAILURE);
2196
}
2197
ret = dup2(devnull, STDIN_FILENO);
2198
if(ret == -1){
2199
perror_plus("dup2(devnull, STDIN_FILENO)");
2200
_exit(EX_OSERR);
2201
}
2202
ret = close(devnull);
2203
if(ret == -1){
2204
perror_plus("close");
2205
_exit(EX_OSERR);
2206
}
2207
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
2208
if(ret == -1){
2209
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
2210
_exit(EX_OSERR);
2211
}
2212
if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
2213
environ) == -1){
2214
perror_plus("fexecve");
2215
_exit(EXIT_FAILURE);
2216
}
2217
} else {
2218
if(hook_pid == -1){
2219
perror_plus("fork");
2220
free(direntry);
2221
continue;
2222
}
2223
int status;
2224
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
2225
perror_plus("waitpid");
2226
free(direntry);
2227
continue;
2228
}
2229
if(WIFEXITED(status)){
2230
if(WEXITSTATUS(status) != 0){
2231
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
2232
" with status %d\n", direntry->d_name,
2233
WEXITSTATUS(status));
2234
free(direntry);
2235
continue;
2236
}
2237
} else if(WIFSIGNALED(status)){
2238
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
2239
" signal %d\n", direntry->d_name,
2240
WTERMSIG(status));
2241
free(direntry);
2242
continue;
2243
} else {
2244
fprintf_plus(stderr, "Warning: network hook \"%s\""
2245
" crashed\n", direntry->d_name);
2246
free(direntry);
2247
continue;
2248
}
2249
}
2250
if(debug){
2251
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
2252
direntry->d_name);
2253
}
2254
free(direntry);
2255
}
2256
free(direntries);
2257
if(close(hookdir_fd) == -1){
2258
perror_plus("close");
2259
} else {
2260
hookdir_fd = -1;
2261
}
2262
close(devnull);
2263
}
2264
2265
__attribute__((nonnull, warn_unused_result))
2266
int bring_up_interface(const char *const interface,
2267
const float delay){
2268
int old_errno = errno;
2269
int ret;
2270
struct ifreq network;
2271
unsigned int if_index = if_nametoindex(interface);
2272
if(if_index == 0){
2273
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
2274
errno = old_errno;
2275
return ENXIO;
2276
}
2277
2278
if(quit_now){
2279
errno = old_errno;
2280
return EINTR;
2281
}
2282
2283
if(not interface_is_up(interface)){
2284
int ret_errno = 0;
2285
int ioctl_errno = 0;
2286
if(not get_flags(interface, &network)){
2287
ret_errno = errno;
2288
fprintf_plus(stderr, "Failed to get flags for interface "
2289
"\"%s\"\n", interface);
2290
errno = old_errno;
2291
return ret_errno;
2292
}
2293
network.ifr_flags |= IFF_UP; /* set flag */
2294
2295
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
2296
if(sd == -1){
2297
ret_errno = errno;
2298
perror_plus("socket");
2299
errno = old_errno;
2300
return ret_errno;
2301
}
2302
2303
if(quit_now){
2304
ret = close(sd);
2305
if(ret == -1){
2306
perror_plus("close");
2307
}
2308
errno = old_errno;
2309
return EINTR;
2310
}
2311
2312
if(debug){
2313
fprintf_plus(stderr, "Bringing up interface \"%s\"\n",
2314
interface);
2315
}
2316
2317
/* Raise privileges */
2318
ret_errno = raise_privileges();
2319
if(ret_errno != 0){
2320
errno = ret_errno;
2321
perror_plus("Failed to raise privileges");
2322
}
2323
2324
#ifdef __linux__
2325
int ret_linux;
2326
bool restore_loglevel = false;
2327
if(ret_errno == 0){
2328
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
2329
messages about the network interface to mess up the prompt */
2330
ret_linux = klogctl(8, NULL, 5);
2331
if(ret_linux == -1){
2332
perror_plus("klogctl");
2333
} else {
2334
restore_loglevel = true;
2335
}
2336
}
2337
#endif /* __linux__ */
2338
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
2339
ioctl_errno = errno;
2340
#ifdef __linux__
2341
if(restore_loglevel){
2342
ret_linux = klogctl(7, NULL, 0);
2343
if(ret_linux == -1){
2344
perror_plus("klogctl");
2345
}
2346
}
2347
#endif /* __linux__ */
2348
2349
/* If raise_privileges() succeeded above */
2350
if(ret_errno == 0){
2351
/* Lower privileges */
2352
ret_errno = lower_privileges();
2353
if(ret_errno != 0){
2354
errno = ret_errno;
2355
perror_plus("Failed to lower privileges");
2356
}
2357
}
2358
2359
/* Close the socket */
2360
ret = close(sd);
2361
if(ret == -1){
2362
perror_plus("close");
2363
}
2364
2365
if(ret_setflags == -1){
2366
errno = ioctl_errno;
2367
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
2368
errno = old_errno;
2369
return ioctl_errno;
2370
}
2371
} else if(debug){
2372
fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
2373
interface);
2374
}
2375
2376
/* Sleep checking until interface is running.
2377
Check every 0.25s, up to total time of delay */
2378
for(int i = 0; i < delay * 4; i++){
2379
if(interface_is_running(interface)){
2380
break;
2381
}
2382
struct timespec sleeptime = { .tv_nsec = 250000000 };
2383
ret = nanosleep(&sleeptime, NULL);
2384
if(ret == -1 and errno != EINTR){
2385
perror_plus("nanosleep");
2386
}
2387
}
2388
2389
errno = old_errno;
2390
return 0;
2391
}
2392
2393
__attribute__((nonnull, warn_unused_result))
2394
int take_down_interface(const char *const interface){
2395
int old_errno = errno;
2396
struct ifreq network;
2397
unsigned int if_index = if_nametoindex(interface);
2398
if(if_index == 0){
2399
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
2400
errno = old_errno;
2401
return ENXIO;
2402
}
2403
if(interface_is_up(interface)){
2404
int ret_errno = 0;
2405
int ioctl_errno = 0;
2406
if(not get_flags(interface, &network) and debug){
2407
ret_errno = errno;
2408
fprintf_plus(stderr, "Failed to get flags for interface "
2409
"\"%s\"\n", interface);
2410
errno = old_errno;
2411
return ret_errno;
2412
}
2413
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
2414
2415
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
2416
if(sd == -1){
2417
ret_errno = errno;
2418
perror_plus("socket");
2419
errno = old_errno;
2420
return ret_errno;
2421
}
2422
2423
if(debug){
2424
fprintf_plus(stderr, "Taking down interface \"%s\"\n",
2425
interface);
2426
}
2427
2428
/* Raise privileges */
2429
ret_errno = raise_privileges();
2430
if(ret_errno != 0){
2431
errno = ret_errno;
2432
perror_plus("Failed to raise privileges");
2433
}
2434
2435
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
2436
ioctl_errno = errno;
2437
2438
/* If raise_privileges() succeeded above */
2439
if(ret_errno == 0){
2440
/* Lower privileges */
2441
ret_errno = lower_privileges();
2442
if(ret_errno != 0){
2443
errno = ret_errno;
2444
perror_plus("Failed to lower privileges");
2445
}
2446
}
2447
2448
/* Close the socket */
2449
int ret = close(sd);
2450
if(ret == -1){
2451
perror_plus("close");
2452
}
2453
2454
if(ret_setflags == -1){
2455
errno = ioctl_errno;
2456
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
2457
errno = old_errno;
2458
return ioctl_errno;
2459
}
2460
} else if(debug){
2461
fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
2462
interface);
2463
}
2464
2465
errno = old_errno;
2466
return 0;
1509
2467
}
1510
2468
1511
2469
int main(int argc, char *argv[]){
2470
mandos_context mc = { .server = NULL, .dh_bits = 0,
2471
#if GNUTLS_VERSION_NUMBER >= 0x030606
2472
.priority = "SECURE128:!CTYPE-X.509"
2473
":+CTYPE-RAWPK:!RSA:!VERS-ALL:+VERS-TLS1.3"
2474
":%PROFILE_ULTRA",
2475
#elif GNUTLS_VERSION_NUMBER < 0x030600
2476
.priority = "SECURE256:!CTYPE-X.509"
2477
":+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256",
2478
#else
2479
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
2480
#endif
2481
.current_server = NULL, .interfaces = NULL,
2482
.interfaces_size = 0 };
1512
2483
AvahiSServiceBrowser *sb = NULL;
1513
int error;
2484
error_t ret_errno;
1514
2485
int ret;
1515
2486
intmax_t tmpmax;
1516
2487
char *tmp;
1517
2488
int exitcode = EXIT_SUCCESS;
1518
const char *interface = "";
1519
struct ifreq network;
1520
int sd = -1;
1521
bool take_down_interface = false;
1522
uid_t uid;
1523
gid_t gid;
1524
char tempdir[] = "/tmp/mandosXXXXXX";
1525
bool tempdir_created = false;
2489
char *interfaces_to_take_down = NULL;
2490
size_t interfaces_to_take_down_size = 0;
2491
char run_tempdir[] = "/run/tmp/mandosXXXXXX";
2492
char old_tempdir[] = "/tmp/mandosXXXXXX";
2493
char *tempdir = NULL;
1526
2494
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1527
2495
const char *seckey = PATHDIR "/" SECKEY;
1528
2496
const char *pubkey = PATHDIR "/" PUBKEY;
2497
#if GNUTLS_VERSION_NUMBER >= 0x030606
2498
const char *tls_privkey = PATHDIR "/" TLS_PRIVKEY;
2499
const char *tls_pubkey = PATHDIR "/" TLS_PUBKEY;
2500
#endif
2501
const char *dh_params_file = NULL;
2502
char *interfaces_hooks = NULL;
1529
2503
1530
2504
bool gnutls_initialized = false;
1531
2505
bool gpgme_initialized = false;
1577
2551
{ .name = "pubkey", .key = 'p',
1578
2552
.arg = "FILE",
1579
2553
.doc = "OpenPGP public key file base name",
1580
.group = 2 },
2554
.group = 1 },
2555
{ .name = "tls-privkey", .key = 't',
2556
.arg = "FILE",
2557
#if GNUTLS_VERSION_NUMBER >= 0x030606
2558
.doc = "TLS private key file base name",
2559
#else
2560
.doc = "Dummy; ignored (requires GnuTLS 3.6.6)",
2561
#endif
2562
.group = 1 },
2563
{ .name = "tls-pubkey", .key = 'T',
2564
.arg = "FILE",
2565
#if GNUTLS_VERSION_NUMBER >= 0x030606
2566
.doc = "TLS public key file base name",
2567
#else
2568
.doc = "Dummy; ignored (requires GnuTLS 3.6.6)",
2569
#endif
2570
.group = 1 },
1581
2571
{ .name = "dh-bits", .key = 129,
1582
2572
.arg = "BITS",
1583
2573
.doc = "Bit length of the prime number used in the"
1584
2574
" Diffie-Hellman key exchange",
1585
2575
.group = 2 },
2576
{ .name = "dh-params", .key = 134,
2577
.arg = "FILE",
2578
.doc = "PEM-encoded PKCS#3 file with pre-generated parameters"
2579
" for the Diffie-Hellman key exchange",
2580
.group = 2 },
1586
2581
{ .name = "priority", .key = 130,
1587
2582
.arg = "STRING",
1588
2583
.doc = "GnuTLS priority string for the TLS handshake",
1593
2588
.group = 2 },
1594
2589
{ .name = "retry", .key = 132,
1595
2590
.arg = "SECONDS",
1596
.doc = "Retry interval used when denied by the mandos server",
2591
.doc = "Retry interval used when denied by the Mandos server",
1597
2592
.group = 2 },
1598
2593
{ .name = "network-hook-dir", .key = 133,
1599
2594
.arg = "DIR",
1622
2617
connect_to = arg;
1623
2618
break;
1624
2619
case 'i': /* --interface */
1625
interface = arg;
2620
ret_errno = argz_add_sep(&mc.interfaces, &mc.interfaces_size,
2621
arg, (int)',');
2622
if(ret_errno != 0){
2623
argp_error(state, "%s", strerror(ret_errno));
2624
}
1626
2625
break;
1627
2626
case 's': /* --seckey */
1628
2627
seckey = arg;
1630
2629
case 'p': /* --pubkey */
1631
2630
pubkey = arg;
1632
2631
break;
2632
case 't': /* --tls-privkey */
2633
#if GNUTLS_VERSION_NUMBER >= 0x030606
2634
tls_privkey = arg;
2635
#endif
2636
break;
2637
case 'T': /* --tls-pubkey */
2638
#if GNUTLS_VERSION_NUMBER >= 0x030606
2639
tls_pubkey = arg;
2640
#endif
2641
break;
1633
2642
case 129: /* --dh-bits */
1634
2643
errno = 0;
1635
2644
tmpmax = strtoimax(arg, &tmp, 10);
1639
2648
}
1640
2649
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
1641
2650
break;
2651
case 134: /* --dh-params */
2652
dh_params_file = arg;
2653
break;
1642
2654
case 130: /* --priority */
1643
2655
mc.priority = arg;
1644
2656
break;
1667
2679
argp_state_help(state, state->out_stream,
1668
2680
(ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
1669
2681
& ~(unsigned int)ARGP_HELP_EXIT_OK);
2682
__builtin_unreachable();
1670
2683
case -3: /* --usage */
1671
2684
argp_state_help(state, state->out_stream,
1672
2685
ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
2686
__builtin_unreachable();
1673
2687
case 'V': /* --version */
1674
fprintf_plus(state->out_stream,
1675
"Mandos plugin mandos-client: ");
1676
2688
fprintf_plus(state->out_stream, "%s\n", argp_program_version);
1677
2689
exit(argp_err_exit_status);
1678
2690
break;
1686
2698
.args_doc = "",
1687
2699
.doc = "Mandos client -- Get and decrypt"
1688
2700
" passwords from a Mandos server" };
1689
ret = argp_parse(&argp, argc, argv,
1690
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
1691
switch(ret){
2701
ret_errno = argp_parse(&argp, argc, argv,
2702
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2703
switch(ret_errno){
1692
2704
case 0:
1693
2705
break;
1694
2706
case ENOMEM:
1695
2707
default:
1696
errno = ret;
2708
errno = ret_errno;
1697
2709
perror_plus("argp_parse");
1698
2710
exitcode = EX_OSERR;
1699
2711
goto end;
1702
2714
goto end;
1703
2715
}
1704
2716
}
1705
2717
1706
2718
{
1707
2719
/* Work around Debian bug #633582:
1708
<http://bugs.debian.org/633582> */
2720
<https://bugs.debian.org/633582> */
1709
2721
1710
/* Re-raise priviliges */
1711
errno = 0;
1712
ret = seteuid(0);
1713
if(ret == -1){
1714
perror_plus("seteuid");
2722
/* Re-raise privileges */
2723
ret = raise_privileges();
2724
if(ret != 0){
2725
errno = ret;
2726
perror_plus("Failed to raise privileges");
1715
2727
} else {
1716
2728
struct stat st;
1717
2729
1732
2744
}
1733
2745
}
1734
2746
}
1735
TEMP_FAILURE_RETRY(close(seckey_fd));
2747
close(seckey_fd);
1736
2748
}
1737
2749
}
1738
2750
1739
2751
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
1740
2752
int pubkey_fd = open(pubkey, O_RDONLY);
1741
2753
if(pubkey_fd == -1){
1753
2765
}
1754
2766
}
1755
2767
}
1756
TEMP_FAILURE_RETRY(close(pubkey_fd));
1757
}
1758
}
1759
2768
close(pubkey_fd);
2769
}
2770
}
2771
2772
if(dh_params_file != NULL
2773
and strcmp(dh_params_file, PATHDIR "/dhparams.pem" ) == 0){
2774
int dhparams_fd = open(dh_params_file, O_RDONLY);
2775
if(dhparams_fd == -1){
2776
perror_plus("open");
2777
} else {
2778
ret = (int)TEMP_FAILURE_RETRY(fstat(dhparams_fd, &st));
2779
if(ret == -1){
2780
perror_plus("fstat");
2781
} else {
2782
if(S_ISREG(st.st_mode)
2783
and st.st_uid == 0 and st.st_gid == 0){
2784
ret = fchown(dhparams_fd, uid, gid);
2785
if(ret == -1){
2786
perror_plus("fchown");
2787
}
2788
}
2789
}
2790
close(dhparams_fd);
2791
}
2792
}
2793
1760
2794
/* Lower privileges */
1761
errno = 0;
1762
ret = seteuid(uid);
1763
if(ret == -1){
1764
perror_plus("seteuid");
2795
ret = lower_privileges();
2796
if(ret != 0){
2797
errno = ret;
2798
perror_plus("Failed to lower privileges");
2799
}
2800
}
2801
}
2802
2803
/* Remove invalid interface names (except "none") */
2804
{
2805
char *interface = NULL;
2806
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2807
interface))){
2808
if(strcmp(interface, "none") != 0
2809
and if_nametoindex(interface) == 0){
2810
if(interface[0] != '\0'){
2811
fprintf_plus(stderr, "Not using nonexisting interface"
2812
" \"%s\"\n", interface);
2813
}
2814
argz_delete(&mc.interfaces, &mc.interfaces_size, interface);
2815
interface = NULL;
1765
2816
}
1766
2817
}
1767
2818
}
1768
2819
1769
2820
/* Run network hooks */
1770
if(not run_network_hooks("start", interface, delay)){
1771
goto end;
2821
{
2822
if(mc.interfaces != NULL){
2823
interfaces_hooks = malloc(mc.interfaces_size);
2824
if(interfaces_hooks == NULL){
2825
perror_plus("malloc");
2826
goto end;
2827
}
2828
memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
2829
argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
2830
}
2831
run_network_hooks("start", interfaces_hooks != NULL ?
2832
interfaces_hooks : "", delay);
1772
2833
}
1773
2834
1774
2835
if(not debug){
1775
2836
avahi_set_log_function(empty_log);
1776
2837
}
1777
2838
1778
if(interface[0] == '\0'){
1779
struct dirent **direntries;
1780
/* First look for interfaces that are up */
1781
ret = scandir(sys_class_net, &direntries, up_interface,
1782
alphasort);
1783
if(ret == 0){
1784
/* No up interfaces, look for any good interfaces */
1785
free(direntries);
1786
ret = scandir(sys_class_net, &direntries, good_interface,
1787
alphasort);
1788
}
1789
if(ret >= 1){
1790
/* Pick the first interface returned */
1791
interface = strdup(direntries[0]->d_name);
1792
if(debug){
1793
fprintf_plus(stderr, "Using interface \"%s\"\n", interface);
1794
}
1795
if(interface == NULL){
1796
perror_plus("malloc");
1797
free(direntries);
1798
exitcode = EXIT_FAILURE;
1799
goto end;
1800
}
1801
free(direntries);
1802
} else {
1803
free(direntries);
1804
fprintf_plus(stderr, "Could not find a network interface\n");
1805
exitcode = EXIT_FAILURE;
1806
goto end;
1807
}
1808
}
1809
1810
2839
/* Initialize Avahi early so avahi_simple_poll_quit() can be called
1811
2840
from the signal handler */
1812
2841
/* Initialize the pseudo-RNG for Avahi */
1813
2842
srand((unsigned int) time(NULL));
1814
mc.simple_poll = avahi_simple_poll_new();
1815
if(mc.simple_poll == NULL){
2843
simple_poll = avahi_simple_poll_new();
2844
if(simple_poll == NULL){
1816
2845
fprintf_plus(stderr,
1817
2846
"Avahi: Failed to create simple poll object.\n");
1818
2847
exitcode = EX_UNAVAILABLE;
1882
2911
}
1883
2912
}
1884
2913
1885
/* If the interface is down, bring it up */
1886
if(strcmp(interface, "none") != 0){
1887
if_index = (AvahiIfIndex) if_nametoindex(interface);
1888
if(if_index == 0){
1889
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1890
exitcode = EX_UNAVAILABLE;
1891
goto end;
1892
}
1893
1894
if(quit_now){
1895
goto end;
1896
}
1897
1898
/* Re-raise priviliges */
1899
errno = 0;
1900
ret = seteuid(0);
1901
if(ret == -1){
1902
perror_plus("seteuid");
1903
}
1904
1905
#ifdef __linux__
1906
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1907
messages about the network interface to mess up the prompt */
1908
ret = klogctl(8, NULL, 5);
1909
bool restore_loglevel = true;
1910
if(ret == -1){
1911
restore_loglevel = false;
1912
perror_plus("klogctl");
1913
}
1914
#endif /* __linux__ */
1915
1916
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1917
if(sd < 0){
1918
perror_plus("socket");
1919
exitcode = EX_OSERR;
1920
#ifdef __linux__
1921
if(restore_loglevel){
1922
ret = klogctl(7, NULL, 0);
1923
if(ret == -1){
1924
perror_plus("klogctl");
1925
}
1926
}
1927
#endif /* __linux__ */
1928
/* Lower privileges */
1929
errno = 0;
1930
ret = seteuid(uid);
1931
if(ret == -1){
1932
perror_plus("seteuid");
1933
}
1934
goto end;
1935
}
1936
strcpy(network.ifr_name, interface);
1937
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1938
if(ret == -1){
1939
perror_plus("ioctl SIOCGIFFLAGS");
1940
#ifdef __linux__
1941
if(restore_loglevel){
1942
ret = klogctl(7, NULL, 0);
1943
if(ret == -1){
1944
perror_plus("klogctl");
1945
}
1946
}
1947
#endif /* __linux__ */
1948
exitcode = EX_OSERR;
1949
/* Lower privileges */
1950
errno = 0;
1951
ret = seteuid(uid);
1952
if(ret == -1){
1953
perror_plus("seteuid");
1954
}
1955
goto end;
1956
}
1957
if((network.ifr_flags & IFF_UP) == 0){
1958
network.ifr_flags |= IFF_UP;
1959
take_down_interface = true;
1960
ret = ioctl(sd, SIOCSIFFLAGS, &network);
1961
if(ret == -1){
1962
take_down_interface = false;
1963
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1964
exitcode = EX_OSERR;
1965
#ifdef __linux__
1966
if(restore_loglevel){
1967
ret = klogctl(7, NULL, 0);
1968
if(ret == -1){
1969
perror_plus("klogctl");
2914
/* If no interfaces were specified, make a list */
2915
if(mc.interfaces == NULL){
2916
struct dirent **direntries = NULL;
2917
/* Look for any good interfaces */
2918
ret = scandir(sys_class_net, &direntries, good_interface,
2919
alphasort);
2920
if(ret >= 1){
2921
/* Add all found interfaces to interfaces list */
2922
for(int i = 0; i < ret; ++i){
2923
ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
2924
direntries[i]->d_name);
2925
if(ret_errno != 0){
2926
errno = ret_errno;
2927
perror_plus("argz_add");
2928
free(direntries[i]);
2929
continue;
2930
}
2931
if(debug){
2932
fprintf_plus(stderr, "Will use interface \"%s\"\n",
2933
direntries[i]->d_name);
2934
}
2935
free(direntries[i]);
2936
}
2937
free(direntries);
2938
} else {
2939
if(ret == 0){
2940
free(direntries);
2941
}
2942
fprintf_plus(stderr, "Could not find a network interface\n");
2943
exitcode = EXIT_FAILURE;
2944
goto end;
2945
}
2946
}
2947
2948
/* Bring up interfaces which are down, and remove any "none"s */
2949
{
2950
char *interface = NULL;
2951
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2952
interface))){
2953
/* If interface name is "none", stop bringing up interfaces.
2954
Also remove all instances of "none" from the list */
2955
if(strcmp(interface, "none") == 0){
2956
argz_delete(&mc.interfaces, &mc.interfaces_size,
2957
interface);
2958
interface = NULL;
2959
while((interface = argz_next(mc.interfaces,
2960
mc.interfaces_size, interface))){
2961
if(strcmp(interface, "none") == 0){
2962
argz_delete(&mc.interfaces, &mc.interfaces_size,
2963
interface);
2964
interface = NULL;
1970
2965
}
1971
2966
}
1972
#endif /* __linux__ */
1973
/* Lower privileges */
1974
errno = 0;
1975
ret = seteuid(uid);
1976
if(ret == -1){
1977
perror_plus("seteuid");
1978
}
1979
goto end;
1980
}
1981
}
1982
/* Sleep checking until interface is running.
1983
Check every 0.25s, up to total time of delay */
1984
for(int i=0; i < delay * 4; i++){
1985
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1986
if(ret == -1){
1987
perror_plus("ioctl SIOCGIFFLAGS");
1988
} else if(network.ifr_flags & IFF_RUNNING){
1989
2967
break;
1990
2968
}
1991
struct timespec sleeptime = { .tv_nsec = 250000000 };
1992
ret = nanosleep(&sleeptime, NULL);
1993
if(ret == -1 and errno != EINTR){
1994
perror_plus("nanosleep");
1995
}
1996
}
1997
if(not take_down_interface){
1998
/* We won't need the socket anymore */
1999
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2000
if(ret == -1){
2001
perror_plus("close");
2002
}
2003
}
2004
#ifdef __linux__
2005
if(restore_loglevel){
2006
/* Restores kernel loglevel to default */
2007
ret = klogctl(7, NULL, 0);
2008
if(ret == -1){
2009
perror_plus("klogctl");
2010
}
2011
}
2012
#endif /* __linux__ */
2013
/* Lower privileges */
2014
errno = 0;
2015
/* Lower privileges */
2016
ret = seteuid(uid);
2017
if(ret == -1){
2018
perror_plus("seteuid");
2019
}
2969
bool interface_was_up = interface_is_up(interface);
2970
errno = bring_up_interface(interface, delay);
2971
if(not interface_was_up){
2972
if(errno != 0){
2973
fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
2974
" %s\n", interface, strerror(errno));
2975
} else {
2976
errno = argz_add(&interfaces_to_take_down,
2977
&interfaces_to_take_down_size,
2978
interface);
2979
if(errno != 0){
2980
perror_plus("argz_add");
2981
}
2982
}
2983
}
2984
}
2985
if(debug and (interfaces_to_take_down == NULL)){
2986
fprintf_plus(stderr, "No interfaces were brought up\n");
2987
}
2988
}
2989
2990
/* If we only got one interface, explicitly use only that one */
2991
if(argz_count(mc.interfaces, mc.interfaces_size) == 1){
2992
if(debug){
2993
fprintf_plus(stderr, "Using only interface \"%s\"\n",
2994
mc.interfaces);
2995
}
2996
if_index = (AvahiIfIndex)if_nametoindex(mc.interfaces);
2020
2997
}
2021
2998
2022
2999
if(quit_now){
2023
3000
goto end;
2024
3001
}
2025
3002
2026
ret = init_gnutls_global(pubkey, seckey);
3003
#if GNUTLS_VERSION_NUMBER >= 0x030606
3004
ret = init_gnutls_global(tls_pubkey, tls_privkey, dh_params_file, &mc);
3005
#elif GNUTLS_VERSION_NUMBER < 0x030600
3006
ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
3007
#else
3008
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
3009
#endif
2027
3010
if(ret == -1){
2028
3011
fprintf_plus(stderr, "init_gnutls_global failed\n");
2029
3012
exitcode = EX_UNAVAILABLE;
2036
3019
goto end;
2037
3020
}
2038
3021
2039
if(mkdtemp(tempdir) == NULL){
3022
/* Try /run/tmp before /tmp */
3023
tempdir = mkdtemp(run_tempdir);
3024
if(tempdir == NULL and errno == ENOENT){
3025
if(debug){
3026
fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
3027
run_tempdir, old_tempdir);
3028
}
3029
tempdir = mkdtemp(old_tempdir);
3030
}
3031
if(tempdir == NULL){
2040
3032
perror_plus("mkdtemp");
2041
3033
goto end;
2042
3034
}
2043
tempdir_created = true;
2044
3035
2045
3036
if(quit_now){
2046
3037
goto end;
2047
3038
}
2048
3039
2049
if(not init_gpgme(pubkey, seckey, tempdir)){
3040
if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
2050
3041
fprintf_plus(stderr, "init_gpgme failed\n");
2051
3042
exitcode = EX_UNAVAILABLE;
2052
3043
goto end;
2062
3053
/* Connect directly, do not use Zeroconf */
2063
3054
/* (Mainly meant for debugging) */
2064
3055
char *address = strrchr(connect_to, ':');
3056
2065
3057
if(address == NULL){
2066
3058
fprintf_plus(stderr, "No colon in address\n");
2067
3059
exitcode = EX_USAGE;
2072
3064
goto end;
2073
3065
}
2074
3066
2075
uint16_t port;
3067
in_port_t port;
2076
3068
errno = 0;
2077
3069
tmpmax = strtoimax(address+1, &tmp, 10);
2078
3070
if(errno != 0 or tmp == address+1 or *tmp != '\0'
2079
or tmpmax != (uint16_t)tmpmax){
3071
or tmpmax != (in_port_t)tmpmax){
2080
3072
fprintf_plus(stderr, "Bad port number\n");
2081
3073
exitcode = EX_USAGE;
2082
3074
goto end;
2083
3075
}
2084
3076
2085
3077
if(quit_now){
2086
3078
goto end;
2087
3079
}
2088
3080
2089
port = (uint16_t)tmpmax;
3081
port = (in_port_t)tmpmax;
2090
3082
*address = '\0';
2091
3083
/* Colon in address indicates IPv6 */
2092
3084
int af;
2108
3100
}
2109
3101
2110
3102
while(not quit_now){
2111
ret = start_mandos_communication(address, port, if_index, af);
3103
ret = start_mandos_communication(address, port, if_index, af,
3104
&mc);
2112
3105
if(quit_now or ret == 0){
2113
3106
break;
2114
3107
}
2116
3109
fprintf_plus(stderr, "Retrying in %d seconds\n",
2117
3110
(int)retry_interval);
2118
3111
}
2119
sleep((int)retry_interval);
3112
sleep((unsigned int)retry_interval);
2120
3113
}
2121
3114
2122
if (not quit_now){
3115
if(not quit_now){
2123
3116
exitcode = EXIT_SUCCESS;
2124
3117
}
2125
3118
2140
3133
config.publish_domain = 0;
2141
3134
2142
3135
/* Allocate a new server */
2143
mc.server = avahi_server_new(avahi_simple_poll_get
2144
(mc.simple_poll), &config, NULL,
2145
NULL, &error);
3136
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
3137
&config, NULL, NULL, &ret);
2146
3138
2147
3139
/* Free the Avahi configuration data */
2148
3140
avahi_server_config_free(&config);
2151
3143
/* Check if creating the Avahi server object succeeded */
2152
3144
if(mc.server == NULL){
2153
3145
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2154
avahi_strerror(error));
3146
avahi_strerror(ret));
2155
3147
exitcode = EX_UNAVAILABLE;
2156
3148
goto end;
2157
3149
}
2163
3155
/* Create the Avahi service browser */
2164
3156
sb = avahi_s_service_browser_new(mc.server, if_index,
2165
3157
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
2166
NULL, 0, browse_callback, NULL);
3158
NULL, 0, browse_callback,
3159
(void *)&mc);
2167
3160
if(sb == NULL){
2168
3161
fprintf_plus(stderr, "Failed to create service browser: %s\n",
2169
3162
avahi_strerror(avahi_server_errno(mc.server)));
2180
3173
if(debug){
2181
3174
fprintf_plus(stderr, "Starting Avahi loop search\n");
2182
3175
}
2183
2184
ret = avahi_loop_with_timeout(mc.simple_poll,
2185
(int)(retry_interval * 1000));
3176
3177
ret = avahi_loop_with_timeout(simple_poll,
3178
(int)(retry_interval * 1000), &mc);
2186
3179
if(debug){
2187
3180
fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
2188
3181
(ret == 0) ? "successfully" : "with error");
2191
3184
end:
2192
3185
2193
3186
if(debug){
2194
fprintf_plus(stderr, "%s exiting\n", argv[0]);
3187
if(signal_received){
3188
fprintf_plus(stderr, "%s exiting due to signal %d: %s\n",
3189
argv[0], signal_received,
3190
strsignal(signal_received));
3191
} else {
3192
fprintf_plus(stderr, "%s exiting\n", argv[0]);
3193
}
2195
3194
}
2196
3195
2197
3196
/* Cleanup things */
3197
free(mc.interfaces);
3198
2198
3199
if(sb != NULL)
2199
3200
avahi_s_service_browser_free(sb);
2200
3201
2201
3202
if(mc.server != NULL)
2202
3203
avahi_server_free(mc.server);
2203
3204
2204
if(mc.simple_poll != NULL)
2205
avahi_simple_poll_free(mc.simple_poll);
3205
if(simple_poll != NULL)
3206
avahi_simple_poll_free(simple_poll);
2206
3207
2207
3208
if(gnutls_initialized){
2208
3209
gnutls_certificate_free_credentials(mc.cred);
2209
gnutls_global_deinit();
2210
3210
gnutls_dh_params_deinit(mc.dh_params);
2211
3211
}
2212
3212
2220
3220
mc.current_server->prev->next = NULL;
2221
3221
while(mc.current_server != NULL){
2222
3222
server *next = mc.current_server->next;
3223
#ifdef __GNUC__
3224
#pragma GCC diagnostic push
3225
#pragma GCC diagnostic ignored "-Wcast-qual"
3226
#endif
3227
free((char *)(mc.current_server->ip));
3228
#ifdef __GNUC__
3229
#pragma GCC diagnostic pop
3230
#endif
2223
3231
free(mc.current_server);
2224
3232
mc.current_server = next;
2225
3233
}
2226
3234
}
2227
3235
2228
/* Run network hooks */
2229
run_network_hooks("stop", interface, delay);
2230
2231
/* Re-raise priviliges */
3236
/* Re-raise privileges */
2232
3237
{
2233
errno = 0;
2234
ret = seteuid(0);
2235
if(ret == -1){
2236
perror_plus("seteuid");
3238
ret = raise_privileges();
3239
if(ret != 0){
3240
errno = ret;
3241
perror_plus("Failed to raise privileges");
3242
} else {
3243
3244
/* Run network hooks */
3245
run_network_hooks("stop", interfaces_hooks != NULL ?
3246
interfaces_hooks : "", delay);
3247
3248
/* Take down the network interfaces which were brought up */
3249
{
3250
char *interface = NULL;
3251
while((interface = argz_next(interfaces_to_take_down,
3252
interfaces_to_take_down_size,
3253
interface))){
3254
ret = take_down_interface(interface);
3255
if(ret != 0){
3256
errno = ret;
3257
perror_plus("Failed to take down interface");
3258
}
3259
}
3260
if(debug and (interfaces_to_take_down == NULL)){
3261
fprintf_plus(stderr, "No interfaces needed to be taken"
3262
" down\n");
3263
}
3264
}
2237
3265
}
2238
3266
2239
/* Take down the network interface */
2240
if(take_down_interface and geteuid() == 0){
2241
ret = ioctl(sd, SIOCGIFFLAGS, &network);
2242
if(ret == -1){
2243
perror_plus("ioctl SIOCGIFFLAGS");
2244
} else if(network.ifr_flags & IFF_UP){
2245
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
2246
ret = ioctl(sd, SIOCSIFFLAGS, &network);
2247
if(ret == -1){
2248
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
2249
}
2250
}
2251
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2252
if(ret == -1){
2253
perror_plus("close");
2254
}
3267
ret = lower_privileges_permanently();
3268
if(ret != 0){
3269
errno = ret;
3270
perror_plus("Failed to lower privileges permanently");
2255
3271
}
2256
3272
}
2257
/* Lower privileges permanently */
2258
errno = 0;
2259
ret = setuid(uid);
2260
if(ret == -1){
2261
perror_plus("setuid");
3273
3274
free(interfaces_to_take_down);
3275
free(interfaces_hooks);
3276
3277
void clean_dir_at(int base, const char * const dirname,
3278
uintmax_t level){
3279
struct dirent **direntries = NULL;
3280
int dret;
3281
int dir_fd = (int)TEMP_FAILURE_RETRY(openat(base, dirname,
3282
O_RDONLY
3283
| O_NOFOLLOW
3284
| O_DIRECTORY
3285
| O_PATH));
3286
if(dir_fd == -1){
3287
perror_plus("open");
3288
return;
3289
}
3290
int numentries = scandirat(dir_fd, ".", &direntries,
3291
notdotentries, alphasort);
3292
if(numentries >= 0){
3293
for(int i = 0; i < numentries; i++){
3294
if(debug){
3295
fprintf_plus(stderr, "Unlinking \"%s/%s\"\n",
3296
dirname, direntries[i]->d_name);
3297
}
3298
dret = unlinkat(dir_fd, direntries[i]->d_name, 0);
3299
if(dret == -1){
3300
if(errno == EISDIR){
3301
dret = unlinkat(dir_fd, direntries[i]->d_name,
3302
AT_REMOVEDIR);
3303
}
3304
if((dret == -1) and (errno == ENOTEMPTY)
3305
and (strcmp(direntries[i]->d_name, "private-keys-v1.d")
3306
== 0) and (level == 0)){
3307
/* Recurse only in this special case */
3308
clean_dir_at(dir_fd, direntries[i]->d_name, level+1);
3309
dret = 0;
3310
}
3311
if((dret == -1) and (errno != ENOENT)){
3312
fprintf_plus(stderr, "unlink(\"%s/%s\"): %s\n", dirname,
3313
direntries[i]->d_name, strerror(errno));
3314
}
3315
}
3316
free(direntries[i]);
3317
}
3318
3319
/* need to clean even if 0 because man page doesn't specify */
3320
free(direntries);
3321
dret = unlinkat(base, dirname, AT_REMOVEDIR);
3322
if(dret == -1 and errno != ENOENT){
3323
perror_plus("rmdir");
3324
}
3325
} else {
3326
perror_plus("scandirat");
3327
}
3328
close(dir_fd);
2262
3329
}
2263
3330
2264
3331
/* Removes the GPGME temp directory and all files inside */
2265
if(tempdir_created){
2266
struct dirent **direntries = NULL;
2267
struct dirent *direntry = NULL;
2268
int numentries = scandir(tempdir, &direntries, notdotentries,
2269
alphasort);
2270
if (numentries > 0){
2271
for(int i = 0; i < numentries; i++){
2272
direntry = direntries[i];
2273
char *fullname = NULL;
2274
ret = asprintf(&fullname, "%s/%s", tempdir,
2275
direntry->d_name);
2276
if(ret < 0){
2277
perror_plus("asprintf");
2278
continue;
2279
}
2280
ret = remove(fullname);
2281
if(ret == -1){
2282
fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2283
strerror(errno));
2284
}
2285
free(fullname);
2286
}
2287
}
2288
2289
/* need to clean even if 0 because man page doesn't specify */
2290
free(direntries);
2291
if (numentries == -1){
2292
perror_plus("scandir");
2293
}
2294
ret = rmdir(tempdir);
2295
if(ret == -1 and errno != ENOENT){
2296
perror_plus("rmdir");
2297
}
3332
if(tempdir != NULL){
3333
clean_dir_at(-1, tempdir, 0);
2298
3334
}
2299
3335
2300
3336
if(quit_now){
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0