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 1131
- compare with another revision
- download diff
- download tarball
- view history from revision 1131
- Committer: Teddy Hogeborn
- Date: 2019-07-29 16:35:53 UTC
- Revision ID: teddy@recompile.se-20190729163553-1i442i2cbx64c537
Make tests and man page examples match
Make the tests test_manual_page_example[1-5] match exactly what is
written in the manual page, and add comments to manual page as
reminders to keep tests and manual page examples in sync.
* mandos-ctl (Test_commands_from_options.test_manual_page_example_1):
Remove "--verbose" option, since the manual does not have it as the
first example, and change assertion to match.
* mandos-ctl.xml (EXAMPLE): Add comments to all examples documenting
which test function they correspond to. Also remove unnecessary
quotes from option arguments in fourth example, and clarify language
slightly in fifth example.
Make the tests test_manual_page_example[1-5] match exactly what is
written in the manual page, and add comments to manual page as
reminders to keep tests and manual page examples in sync.
* mandos-ctl (Test_commands_from_options.test_manual_page_example_1):
Remove "--verbose" option, since the manual does not have it as the
first example, and change assertion to match.
* mandos-ctl.xml (EXAMPLE): Add comments to all examples documenting
which test function they correspond to. Also remove unnecessary
quotes from option arguments in fourth example, and clarify language
slightly in fifth example.
- files added:
- bugs.xml
- debian/tests
- debian/upstream
- dracut-module
- plugin-helpers
- files removed:
- initramfs-tools-hook-conf
- files modified:
- .bzrignore
added
removed
plugins.d/mandos-client.c
9
9
* "browse_callback", and parts of "main".
10
10
*
11
11
* Everything else is
12
* Copyright © 2008-2012 Teddy Hogeborn
13
* Copyright © 2008-2012 Björn Påhlsson
14
*
15
* This program is free software: you can redistribute it and/or
16
* modify it under the terms of the GNU General Public License as
17
* published by the Free Software Foundation, either version 3 of the
18
* License, or (at your option) any later version.
19
*
20
* This program is distributed in the hope that it will be useful, but
12
* Copyright © 2008-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
stdout, ferror() */
44
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 <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,
65
72
program_invocation_short_name */
66
73
#include <time.h> /* nanosleep(), time(), sleep() */
67
74
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
72
79
*/
73
80
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
74
81
getuid(), getgid(), seteuid(),
75
setgid(), pause(), _exit() */
76
#include <arpa/inet.h> /* inet_pton(), htons, inet_ntop() */
82
setgid(), pause(), _exit(),
83
unlinkat() */
84
#include <arpa/inet.h> /* inet_pton(), htons() */
77
85
#include <iso646.h> /* not, or, and */
78
86
#include <argp.h> /* struct argp_option, error_t, struct
79
87
argp_state, struct argp,
91
99
argz_delete(), argz_append(),
92
100
argz_stringify(), argz_add(),
93
101
argz_count() */
102
#include <netdb.h> /* getnameinfo(), NI_NUMERICHOST,
103
EAI_SYSTEM, gai_strerror() */
94
104
95
105
#ifdef __linux__
96
106
#include <sys/klog.h> /* klogctl() */
113
123
gnutls_*
114
124
init_gnutls_session(),
115
125
GNUTLS_* */
126
#if GNUTLS_VERSION_NUMBER < 0x030600
116
127
#include <gnutls/openpgp.h>
117
128
/* gnutls_certificate_set_openpgp_key_file(),
118
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
119
135
120
136
/* GPGME */
121
137
#include <gpgme.h> /* All GPGME types, constants and
129
145
#define PATHDIR "/conf/conf.d/mandos"
130
146
#define SECKEY "seckey.txt"
131
147
#define PUBKEY "pubkey.txt"
148
#define TLS_PRIVKEY "tls-privkey.pem"
149
#define TLS_PUBKEY "tls-pubkey.pem"
132
150
#define HOOKDIR "/lib/mandos/network-hooks.d"
133
151
134
152
bool debug = false;
138
156
static const char sys_class_net[] = "/sys/class/net";
139
157
char *connect_to = NULL;
140
158
const char *hookdir = HOOKDIR;
159
int hookdir_fd = -1;
141
160
uid_t uid = 65534;
142
161
gid_t gid = 65534;
143
162
161
180
const char *priority;
162
181
gpgme_ctx_t ctx;
163
182
server *current_server;
183
char *interfaces;
184
size_t interfaces_size;
164
185
} mandos_context;
165
186
166
187
/* global so signal handler can reach it*/
167
188
AvahiSimplePoll *simple_poll;
168
mandos_context mc = { .server = NULL, .dh_bits = 1024,
169
.priority = "SECURE256:!CTYPE-X.509:"
170
"+CTYPE-OPENPGP", .current_server = NULL };
171
189
172
190
sig_atomic_t quit_now = 0;
173
191
int signal_received = 0;
181
199
perror(print_text);
182
200
}
183
201
184
__attribute__((format (gnu_printf, 2, 3)))
202
__attribute__((format (gnu_printf, 2, 3), nonnull))
185
203
int fprintf_plus(FILE *stream, const char *format, ...){
186
204
va_list ap;
187
205
va_start (ap, format);
188
206
189
207
TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
190
208
program_invocation_short_name));
191
return TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
209
return (int)TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
192
210
}
193
211
194
212
/*
196
214
* bytes. "buffer_capacity" is how much is currently allocated,
197
215
* "buffer_length" is how much is already used.
198
216
*/
217
__attribute__((nonnull, warn_unused_result))
199
218
size_t incbuffer(char **buffer, size_t buffer_length,
200
219
size_t buffer_capacity){
201
220
if(buffer_length + BUFFER_SIZE > buffer_capacity){
202
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
203
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;
204
227
return 0;
205
228
}
229
*buffer = new_buf;
206
230
buffer_capacity += BUFFER_SIZE;
207
231
}
208
232
return buffer_capacity;
209
233
}
210
234
211
235
/* Add server to set of servers to retry periodically */
236
__attribute__((nonnull, warn_unused_result))
212
237
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
213
int af){
238
int af, server **current_server){
214
239
int ret;
215
240
server *new_server = malloc(sizeof(server));
216
241
if(new_server == NULL){
223
248
.af = af };
224
249
if(new_server->ip == NULL){
225
250
perror_plus("strdup");
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);
226
266
return false;
227
267
}
228
268
/* Special case of first server */
229
if (mc.current_server == NULL){
269
if(*current_server == NULL){
230
270
new_server->next = new_server;
231
271
new_server->prev = new_server;
232
mc.current_server = new_server;
233
/* Place the new server last in the list */
272
*current_server = new_server;
234
273
} else {
235
new_server->next = mc.current_server;
236
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;
237
277
new_server->prev->next = new_server;
238
mc.current_server->prev = new_server;
239
}
240
ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);
241
if(ret == -1){
242
perror_plus("clock_gettime");
243
return false;
278
(*current_server)->prev = new_server;
244
279
}
245
280
return true;
246
281
}
247
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;
333
}
334
248
335
/*
249
336
* Initialize GPGME.
250
337
*/
251
static bool init_gpgme(const char *seckey, const char *pubkey,
252
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){
253
343
gpgme_error_t rc;
254
344
gpgme_engine_info_t engine_info;
255
345
256
346
/*
257
347
* Helper function to insert pub and seckey to the engine keyring.
258
348
*/
259
bool import_key(const char *filename){
349
bool import_key(const char * const filename){
260
350
int ret;
261
351
int fd;
262
352
gpgme_data_t pgp_data;
267
357
return false;
268
358
}
269
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
270
410
rc = gpgme_data_new_from_fd(&pgp_data, fd);
271
411
if(rc != GPG_ERR_NO_ERROR){
272
412
fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
274
414
return false;
275
415
}
276
416
277
rc = gpgme_op_import(mc.ctx, pgp_data);
417
rc = gpgme_op_import(mc->ctx, pgp_data);
278
418
if(rc != GPG_ERR_NO_ERROR){
279
419
fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
280
420
gpgme_strsource(rc), gpgme_strerror(rc));
281
421
return false;
282
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
}
283
498
284
ret = (int)TEMP_FAILURE_RETRY(close(fd));
499
ret = close(fd);
285
500
if(ret == -1){
286
501
perror_plus("close");
287
502
}
324
539
}
325
540
326
541
/* Create new GPGME "context" */
327
rc = gpgme_new(&(mc.ctx));
542
rc = gpgme_new(&(mc->ctx));
328
543
if(rc != GPG_ERR_NO_ERROR){
329
fprintf_plus(stderr, "Mandos plugin mandos-client: "
330
"bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
331
gpgme_strerror(rc));
544
fprintf_plus(stderr, "bad gpgme_new: %s: %s\n",
545
gpgme_strsource(rc), gpgme_strerror(rc));
332
546
return false;
333
547
}
334
548
343
557
* Decrypt OpenPGP data.
344
558
* Returns -1 on error
345
559
*/
560
__attribute__((nonnull, warn_unused_result))
346
561
static ssize_t pgp_packet_decrypt(const char *cryptotext,
347
562
size_t crypto_size,
348
char **plaintext){
563
char **plaintext,
564
mandos_context *mc){
349
565
gpgme_data_t dh_crypto, dh_plain;
350
566
gpgme_error_t rc;
351
567
ssize_t ret;
368
584
/* Create new empty GPGME data buffer for the plaintext */
369
585
rc = gpgme_data_new(&dh_plain);
370
586
if(rc != GPG_ERR_NO_ERROR){
371
fprintf_plus(stderr, "Mandos plugin mandos-client: "
372
"bad gpgme_data_new: %s: %s\n",
587
fprintf_plus(stderr, "bad gpgme_data_new: %s: %s\n",
373
588
gpgme_strsource(rc), gpgme_strerror(rc));
374
589
gpgme_data_release(dh_crypto);
375
590
return -1;
377
592
378
593
/* Decrypt data from the cryptotext data buffer to the plaintext
379
594
data buffer */
380
rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
595
rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
381
596
if(rc != GPG_ERR_NO_ERROR){
382
597
fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
383
598
gpgme_strsource(rc), gpgme_strerror(rc));
384
599
plaintext_length = -1;
385
600
if(debug){
386
601
gpgme_decrypt_result_t result;
387
result = gpgme_op_decrypt_result(mc.ctx);
602
result = gpgme_op_decrypt_result(mc->ctx);
388
603
if(result == NULL){
389
604
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
390
605
} else {
391
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
392
result->unsupported_algorithm);
393
fprintf_plus(stderr, "Wrong key usage: %u\n",
394
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");
395
612
if(result->file_name != NULL){
396
613
fprintf_plus(stderr, "File name: %s\n", result->file_name);
397
614
}
398
gpgme_recipient_t recipient;
399
recipient = result->recipients;
400
while(recipient != NULL){
615
616
for(gpgme_recipient_t r = result->recipients; r != NULL;
617
r = r->next){
401
618
fprintf_plus(stderr, "Public key algorithm: %s\n",
402
gpgme_pubkey_algo_name
403
(recipient->pubkey_algo));
404
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);
405
621
fprintf_plus(stderr, "Secret key available: %s\n",
406
recipient->status == GPG_ERR_NO_SECKEY
407
? "No" : "Yes");
408
recipient = recipient->next;
622
r->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
409
623
}
410
624
}
411
625
}
467
681
return plaintext_length;
468
682
}
469
683
470
static const char * safer_gnutls_strerror(int value){
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){
471
693
const char *ret = gnutls_strerror(value);
472
if(ret == NULL)
473
ret = "(unknown)";
474
return ret;
694
return safe_string(ret);
475
695
}
476
696
477
697
/* GnuTLS log function callback */
698
__attribute__((nonnull))
478
699
static void debuggnutls(__attribute__((unused)) int level,
479
700
const char* string){
480
701
fprintf_plus(stderr, "GnuTLS: %s", string);
481
702
}
482
703
704
__attribute__((nonnull(1, 2, 4), warn_unused_result))
483
705
static int init_gnutls_global(const char *pubkeyfilename,
484
const char *seckeyfilename){
706
const char *seckeyfilename,
707
const char *dhparamsfilename,
708
mandos_context *mc){
485
709
int ret;
486
710
487
711
if(debug){
488
712
fprintf_plus(stderr, "Initializing GnuTLS\n");
489
713
}
490
714
491
ret = gnutls_global_init();
492
if(ret != GNUTLS_E_SUCCESS){
493
fprintf_plus(stderr, "GnuTLS global_init: %s\n",
494
safer_gnutls_strerror(ret));
495
return -1;
496
}
497
498
715
if(debug){
499
716
/* "Use a log level over 10 to enable all debugging options."
500
717
* - GnuTLS manual
504
721
}
505
722
506
723
/* OpenPGP credentials */
507
ret = gnutls_certificate_allocate_credentials(&mc.cred);
724
ret = gnutls_certificate_allocate_credentials(&mc->cred);
508
725
if(ret != GNUTLS_E_SUCCESS){
509
726
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
510
727
safer_gnutls_strerror(ret));
511
gnutls_global_deinit();
512
728
return -1;
513
729
}
514
730
515
731
if(debug){
516
fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
517
" 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",
518
734
pubkeyfilename,
519
735
seckeyfilename);
520
736
}
521
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
522
751
ret = gnutls_certificate_set_openpgp_key_file
523
(mc.cred, pubkeyfilename, seckeyfilename,
752
(mc->cred, pubkeyfilename, seckeyfilename,
524
753
GNUTLS_OPENPGP_FMT_BASE64);
754
#else
755
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
756
#endif
525
757
if(ret != GNUTLS_E_SUCCESS){
526
758
fprintf_plus(stderr,
527
"Error[%d] while reading the OpenPGP key pair ('%s',"
759
"Error[%d] while reading the key pair ('%s',"
528
760
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
529
761
fprintf_plus(stderr, "The GnuTLS error is: %s\n",
530
762
safer_gnutls_strerror(ret));
532
764
}
533
765
534
766
/* GnuTLS server initialization */
535
ret = gnutls_dh_params_init(&mc.dh_params);
767
ret = gnutls_dh_params_init(&mc->dh_params);
536
768
if(ret != GNUTLS_E_SUCCESS){
537
769
fprintf_plus(stderr, "Error in GnuTLS DH parameter"
538
770
" initialization: %s\n",
539
771
safer_gnutls_strerror(ret));
540
772
goto globalfail;
541
773
}
542
ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
543
if(ret != GNUTLS_E_SUCCESS){
544
fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
545
safer_gnutls_strerror(ret));
546
goto globalfail;
547
}
548
549
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
}
550
956
551
957
return 0;
552
958
553
959
globalfail:
554
960
555
gnutls_certificate_free_credentials(mc.cred);
556
gnutls_global_deinit();
557
gnutls_dh_params_deinit(mc.dh_params);
961
gnutls_certificate_free_credentials(mc->cred);
962
gnutls_dh_params_deinit(mc->dh_params);
558
963
return -1;
559
964
}
560
965
561
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){
562
969
int ret;
563
970
/* GnuTLS session creation */
564
971
do {
565
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
));
566
980
if(quit_now){
567
981
return -1;
568
982
}
576
990
{
577
991
const char *err;
578
992
do {
579
ret = gnutls_priority_set_direct(*session, mc.priority, &err);
993
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
580
994
if(quit_now){
581
995
gnutls_deinit(*session);
582
996
return -1;
593
1007
594
1008
do {
595
1009
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
596
mc.cred);
1010
mc->cred);
597
1011
if(quit_now){
598
1012
gnutls_deinit(*session);
599
1013
return -1;
609
1023
/* ignore client certificate if any. */
610
1024
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
611
1025
612
gnutls_dh_set_prime_bits(*session, mc.dh_bits);
613
614
1026
return 0;
615
1027
}
616
1028
618
1030
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
619
1031
__attribute__((unused)) const char *txt){}
620
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
_exit(EX_NOPERM);
1078
}
1079
/* Reset supplementary groups */
1080
errno = 0;
1081
ret = setgroups(0, NULL);
1082
if(ret == -1){
1083
perror_plus("setgroups");
1084
_exit(EX_NOPERM);
1085
}
1086
}
1087
ret = dup2(devnull, STDIN_FILENO);
1088
if(ret == -1){
1089
perror_plus("dup2(devnull, STDIN_FILENO)");
1090
_exit(EX_OSERR);
1091
}
1092
ret = close(devnull);
1093
if(ret == -1){
1094
perror_plus("close");
1095
_exit(EX_OSERR);
1096
}
1097
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
1098
if(ret == -1){
1099
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
1100
_exit(EX_OSERR);
1101
}
1102
int helperdir_fd = (int)TEMP_FAILURE_RETRY(open(pluginhelperdir,
1103
O_RDONLY
1104
| O_DIRECTORY
1105
| O_PATH
1106
| O_CLOEXEC));
1107
if(helperdir_fd == -1){
1108
perror_plus("open");
1109
_exit(EX_UNAVAILABLE);
1110
}
1111
int helper_fd = (int)TEMP_FAILURE_RETRY(openat(helperdir_fd,
1112
helper, O_RDONLY));
1113
if(helper_fd == -1){
1114
perror_plus("openat");
1115
close(helperdir_fd);
1116
_exit(EX_UNAVAILABLE);
1117
}
1118
close(helperdir_fd);
1119
#ifdef __GNUC__
1120
#pragma GCC diagnostic push
1121
#pragma GCC diagnostic ignored "-Wcast-qual"
1122
#endif
1123
if(fexecve(helper_fd, (char *const [])
1124
{ helper, add ? add_arg : delete_arg, (char *)address,
1125
interface, debug ? debug_flag : NULL, NULL },
1126
environ) == -1){
1127
#ifdef __GNUC__
1128
#pragma GCC diagnostic pop
1129
#endif
1130
perror_plus("fexecve");
1131
_exit(EXIT_FAILURE);
1132
}
1133
}
1134
if(pid == -1){
1135
perror_plus("fork");
1136
return false;
1137
}
1138
int status;
1139
pid_t pret = -1;
1140
errno = 0;
1141
do {
1142
pret = waitpid(pid, &status, 0);
1143
if(pret == -1 and errno == EINTR and quit_now){
1144
int errno_raising = 0;
1145
if((errno = raise_privileges()) != 0){
1146
errno_raising = errno;
1147
perror_plus("Failed to raise privileges in order to"
1148
" kill helper program");
1149
}
1150
if(kill(pid, SIGTERM) == -1){
1151
perror_plus("kill");
1152
}
1153
if((errno_raising == 0) and (errno = lower_privileges()) != 0){
1154
perror_plus("Failed to lower privileges after killing"
1155
" helper program");
1156
}
1157
return false;
1158
}
1159
} while(pret == -1 and errno == EINTR);
1160
if(pret == -1){
1161
perror_plus("waitpid");
1162
return false;
1163
}
1164
if(WIFEXITED(status)){
1165
if(WEXITSTATUS(status) != 0){
1166
fprintf_plus(stderr, "Error: iprouteadddel exited"
1167
" with status %d\n", WEXITSTATUS(status));
1168
return false;
1169
}
1170
return true;
1171
}
1172
if(WIFSIGNALED(status)){
1173
fprintf_plus(stderr, "Error: iprouteadddel died by"
1174
" signal %d\n", WTERMSIG(status));
1175
return false;
1176
}
1177
fprintf_plus(stderr, "Error: iprouteadddel crashed\n");
1178
return false;
1179
}
1180
1181
__attribute__((nonnull, warn_unused_result))
1182
static bool add_local_route(const char *address,
1183
AvahiIfIndex if_index){
1184
if(debug){
1185
fprintf_plus(stderr, "Adding route to %s\n", address);
1186
}
1187
return add_delete_local_route(true, address, if_index);
1188
}
1189
1190
__attribute__((nonnull, warn_unused_result))
1191
static bool delete_local_route(const char *address,
1192
AvahiIfIndex if_index){
1193
if(debug){
1194
fprintf_plus(stderr, "Removing route to %s\n", address);
1195
}
1196
return add_delete_local_route(false, address, if_index);
1197
}
1198
621
1199
/* Called when a Mandos server is found */
1200
__attribute__((nonnull, warn_unused_result))
622
1201
static int start_mandos_communication(const char *ip, in_port_t port,
623
1202
AvahiIfIndex if_index,
624
int af){
1203
int af, mandos_context *mc){
625
1204
int ret, tcp_sd = -1;
626
1205
ssize_t sret;
627
union {
628
struct sockaddr_in in;
629
struct sockaddr_in6 in6;
630
} to;
1206
struct sockaddr_storage to;
631
1207
char *buffer = NULL;
632
1208
char *decrypted_buffer = NULL;
633
1209
size_t buffer_length = 0;
636
1212
int retval = -1;
637
1213
gnutls_session_t session;
638
1214
int pf; /* Protocol family */
1215
bool route_added = false;
639
1216
640
1217
errno = 0;
641
1218
657
1234
return -1;
658
1235
}
659
1236
660
ret = init_gnutls_session(&session);
1237
/* If the interface is specified and we have a list of interfaces */
1238
if(if_index != AVAHI_IF_UNSPEC and mc->interfaces != NULL){
1239
/* Check if the interface is one of the interfaces we are using */
1240
bool match = false;
1241
{
1242
char *interface = NULL;
1243
while((interface = argz_next(mc->interfaces,
1244
mc->interfaces_size,
1245
interface))){
1246
if(if_nametoindex(interface) == (unsigned int)if_index){
1247
match = true;
1248
break;
1249
}
1250
}
1251
}
1252
if(not match){
1253
/* This interface does not match any in the list, so we don't
1254
connect to the server */
1255
if(debug){
1256
char interface[IF_NAMESIZE];
1257
if(if_indextoname((unsigned int)if_index, interface) == NULL){
1258
perror_plus("if_indextoname");
1259
} else {
1260
fprintf_plus(stderr, "Skipping server on non-used interface"
1261
" \"%s\"\n",
1262
if_indextoname((unsigned int)if_index,
1263
interface));
1264
}
1265
}
1266
return -1;
1267
}
1268
}
1269
1270
ret = init_gnutls_session(&session, mc);
661
1271
if(ret != 0){
662
1272
return -1;
663
1273
}
667
1277
PRIuMAX "\n", ip, (uintmax_t)port);
668
1278
}
669
1279
670
tcp_sd = socket(pf, SOCK_STREAM, 0);
1280
tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
671
1281
if(tcp_sd < 0){
672
1282
int e = errno;
673
1283
perror_plus("socket");
680
1290
goto mandos_end;
681
1291
}
682
1292
683
memset(&to, 0, sizeof(to));
684
1293
if(af == AF_INET6){
685
to.in6.sin6_family = (sa_family_t)af;
686
ret = inet_pton(af, ip, &to.in6.sin6_addr);
1294
struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)&to;
1295
*to6 = (struct sockaddr_in6){ .sin6_family = (sa_family_t)af };
1296
ret = inet_pton(af, ip, &to6->sin6_addr);
687
1297
} else { /* IPv4 */
688
to.in.sin_family = (sa_family_t)af;
689
ret = inet_pton(af, ip, &to.in.sin_addr);
1298
struct sockaddr_in *to4 = (struct sockaddr_in *)&to;
1299
*to4 = (struct sockaddr_in){ .sin_family = (sa_family_t)af };
1300
ret = inet_pton(af, ip, &to4->sin_addr);
690
1301
}
691
1302
if(ret < 0 ){
692
1303
int e = errno;
701
1312
goto mandos_end;
702
1313
}
703
1314
if(af == AF_INET6){
704
to.in6.sin6_port = htons(port);
705
if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
706
(&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
707
-Wunreachable-code*/
1315
((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
1316
if(IN6_IS_ADDR_LINKLOCAL
1317
(&((struct sockaddr_in6 *)&to)->sin6_addr)){
708
1318
if(if_index == AVAHI_IF_UNSPEC){
709
1319
fprintf_plus(stderr, "An IPv6 link-local address is"
710
1320
" incomplete without a network interface\n");
712
1322
goto mandos_end;
713
1323
}
714
1324
/* Set the network interface number as scope */
715
to.in6.sin6_scope_id = (uint32_t)if_index;
1325
((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
716
1326
}
717
1327
} else {
718
to.in.sin_port = htons(port); /* Spurious warnings from
719
-Wconversion and
720
-Wunreachable-code */
1328
((struct sockaddr_in *)&to)->sin_port = htons(port);
721
1329
}
722
1330
723
1331
if(quit_now){
740
1348
}
741
1349
char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
742
1350
INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
743
const char *pcret;
744
if(af == AF_INET6){
745
pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
746
sizeof(addrstr));
747
} else {
748
pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
749
sizeof(addrstr));
750
}
751
if(pcret == NULL){
752
perror_plus("inet_ntop");
753
} else {
754
if(strcmp(addrstr, ip) != 0){
755
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
756
}
757
}
758
}
759
760
if(quit_now){
761
errno = EINTR;
762
goto mandos_end;
763
}
764
765
if(af == AF_INET6){
766
ret = connect(tcp_sd, &to.in6, sizeof(to));
767
} else {
768
ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
769
}
770
if(ret < 0){
771
if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
772
int e = errno;
773
perror_plus("connect");
774
errno = e;
775
}
776
goto mandos_end;
777
}
778
779
if(quit_now){
780
errno = EINTR;
781
goto mandos_end;
1351
if(af == AF_INET6){
1352
ret = getnameinfo((struct sockaddr *)&to,
1353
sizeof(struct sockaddr_in6),
1354
addrstr, sizeof(addrstr), NULL, 0,
1355
NI_NUMERICHOST);
1356
} else {
1357
ret = getnameinfo((struct sockaddr *)&to,
1358
sizeof(struct sockaddr_in),
1359
addrstr, sizeof(addrstr), NULL, 0,
1360
NI_NUMERICHOST);
1361
}
1362
if(ret == EAI_SYSTEM){
1363
perror_plus("getnameinfo");
1364
} else if(ret != 0) {
1365
fprintf_plus(stderr, "getnameinfo: %s", gai_strerror(ret));
1366
} else if(strcmp(addrstr, ip) != 0){
1367
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
1368
}
1369
}
1370
1371
if(quit_now){
1372
errno = EINTR;
1373
goto mandos_end;
1374
}
1375
1376
while(true){
1377
if(af == AF_INET6){
1378
ret = connect(tcp_sd, (struct sockaddr *)&to,
1379
sizeof(struct sockaddr_in6));
1380
} else {
1381
ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
1382
sizeof(struct sockaddr_in));
1383
}
1384
if(ret < 0){
1385
if(((errno == ENETUNREACH) or (errno == EHOSTUNREACH))
1386
and if_index != AVAHI_IF_UNSPEC
1387
and connect_to == NULL
1388
and not route_added and
1389
((af == AF_INET6 and not
1390
IN6_IS_ADDR_LINKLOCAL(&(((struct sockaddr_in6 *)
1391
&to)->sin6_addr)))
1392
or (af == AF_INET and
1393
/* Not a a IPv4LL address */
1394
(ntohl(((struct sockaddr_in *)&to)->sin_addr.s_addr)
1395
& 0xFFFF0000L) != 0xA9FE0000L))){
1396
/* Work around Avahi bug - Avahi does not announce link-local
1397
addresses if it has a global address, so local hosts with
1398
*only* a link-local address (e.g. Mandos clients) cannot
1399
connect to a Mandos server announced by Avahi on a server
1400
host with a global address. Work around this by retrying
1401
with an explicit route added with the server's address.
1402
1403
Avahi bug reference:
1404
https://lists.freedesktop.org/archives/avahi/2010-February/001833.html
1405
https://bugs.debian.org/587961
1406
*/
1407
if(debug){
1408
fprintf_plus(stderr, "Mandos server unreachable, trying"
1409
" direct route\n");
1410
}
1411
int e = errno;
1412
route_added = add_local_route(ip, if_index);
1413
if(route_added){
1414
continue;
1415
}
1416
errno = e;
1417
}
1418
if(errno != ECONNREFUSED or debug){
1419
int e = errno;
1420
perror_plus("connect");
1421
errno = e;
1422
}
1423
goto mandos_end;
1424
}
1425
1426
if(quit_now){
1427
errno = EINTR;
1428
goto mandos_end;
1429
}
1430
break;
782
1431
}
783
1432
784
1433
const char *out = mandos_protocol_version;
935
1584
if(buffer_length > 0){
936
1585
ssize_t decrypted_buffer_size;
937
1586
decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
938
&decrypted_buffer);
1587
&decrypted_buffer, mc);
939
1588
if(decrypted_buffer_size >= 0){
940
1589
1590
clearerr(stdout);
941
1591
written = 0;
942
1592
while(written < (size_t) decrypted_buffer_size){
943
1593
if(quit_now){
959
1609
}
960
1610
written += (size_t)ret;
961
1611
}
1612
ret = fflush(stdout);
1613
if(ret != 0){
1614
int e = errno;
1615
if(debug){
1616
fprintf_plus(stderr, "Error writing encrypted data: %s\n",
1617
strerror(errno));
1618
}
1619
errno = e;
1620
goto mandos_end;
1621
}
962
1622
retval = 0;
963
1623
}
964
1624
}
967
1627
968
1628
mandos_end:
969
1629
{
1630
if(route_added){
1631
if(not delete_local_route(ip, if_index)){
1632
fprintf_plus(stderr, "Failed to delete local route to %s on"
1633
" interface %d", ip, if_index);
1634
}
1635
}
970
1636
int e = errno;
971
1637
free(decrypted_buffer);
972
1638
free(buffer);
973
1639
if(tcp_sd >= 0){
974
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
1640
ret = close(tcp_sd);
975
1641
}
976
1642
if(ret == -1){
977
1643
if(e == 0){
1002
1668
AVAHI_GCC_UNUSED AvahiStringList *txt,
1003
1669
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1004
1670
flags,
1005
AVAHI_GCC_UNUSED void* userdata){
1671
void *mc){
1006
1672
if(r == NULL){
1007
1673
return;
1008
1674
}
1011
1677
timed out */
1012
1678
1013
1679
if(quit_now){
1680
avahi_s_service_resolver_free(r);
1014
1681
return;
1015
1682
}
1016
1683
1020
1687
fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
1021
1688
"'%s' of type '%s' in domain '%s': %s\n", name, type,
1022
1689
domain,
1023
avahi_strerror(avahi_server_errno(mc.server)));
1690
avahi_strerror(avahi_server_errno
1691
(((mandos_context*)mc)->server)));
1024
1692
break;
1025
1693
1026
1694
case AVAHI_RESOLVER_FOUND:
1034
1702
}
1035
1703
int ret = start_mandos_communication(ip, (in_port_t)port,
1036
1704
interface,
1037
avahi_proto_to_af(proto));
1705
avahi_proto_to_af(proto),
1706
mc);
1038
1707
if(ret == 0){
1039
1708
avahi_simple_poll_quit(simple_poll);
1040
1709
} else {
1041
1710
if(not add_server(ip, (in_port_t)port, interface,
1042
avahi_proto_to_af(proto))){
1711
avahi_proto_to_af(proto),
1712
&((mandos_context*)mc)->current_server)){
1043
1713
fprintf_plus(stderr, "Failed to add server \"%s\" to server"
1044
1714
" list\n", name);
1045
1715
}
1058
1728
const char *domain,
1059
1729
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1060
1730
flags,
1061
AVAHI_GCC_UNUSED void* userdata){
1731
void *mc){
1062
1732
if(b == NULL){
1063
1733
return;
1064
1734
}
1075
1745
case AVAHI_BROWSER_FAILURE:
1076
1746
1077
1747
fprintf_plus(stderr, "(Avahi browser) %s\n",
1078
avahi_strerror(avahi_server_errno(mc.server)));
1748
avahi_strerror(avahi_server_errno
1749
(((mandos_context*)mc)->server)));
1079
1750
avahi_simple_poll_quit(simple_poll);
1080
1751
return;
1081
1752
1085
1756
the callback function is called the Avahi server will free the
1086
1757
resolver for us. */
1087
1758
1088
if(avahi_s_service_resolver_new(mc.server, interface, protocol,
1089
name, type, domain, protocol, 0,
1090
resolve_callback, NULL) == NULL)
1759
if(avahi_s_service_resolver_new(((mandos_context*)mc)->server,
1760
interface, protocol, name, type,
1761
domain, protocol, 0,
1762
resolve_callback, mc) == NULL)
1091
1763
fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
1092
1764
" %s\n", name,
1093
avahi_strerror(avahi_server_errno(mc.server)));
1765
avahi_strerror(avahi_server_errno
1766
(((mandos_context*)mc)->server)));
1094
1767
break;
1095
1768
1096
1769
case AVAHI_BROWSER_REMOVE:
1121
1794
errno = old_errno;
1122
1795
}
1123
1796
1797
__attribute__((nonnull, warn_unused_result))
1124
1798
bool get_flags(const char *ifname, struct ifreq *ifr){
1125
1799
int ret;
1126
error_t ret_errno;
1800
int old_errno;
1127
1801
1128
1802
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1129
1803
if(s < 0){
1130
ret_errno = errno;
1804
old_errno = errno;
1131
1805
perror_plus("socket");
1132
errno = ret_errno;
1806
errno = old_errno;
1133
1807
return false;
1134
1808
}
1135
strcpy(ifr->ifr_name, ifname);
1809
strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
1810
ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
1136
1811
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1137
1812
if(ret == -1){
1138
1813
if(debug){
1139
ret_errno = errno;
1814
old_errno = errno;
1140
1815
perror_plus("ioctl SIOCGIFFLAGS");
1141
errno = ret_errno;
1816
errno = old_errno;
1817
}
1818
if((close(s) == -1) and debug){
1819
old_errno = errno;
1820
perror_plus("close");
1821
errno = old_errno;
1142
1822
}
1143
1823
return false;
1144
1824
}
1825
if((close(s) == -1) and debug){
1826
old_errno = errno;
1827
perror_plus("close");
1828
errno = old_errno;
1829
}
1145
1830
return true;
1146
1831
}
1147
1832
1833
__attribute__((nonnull, warn_unused_result))
1148
1834
bool good_flags(const char *ifname, const struct ifreq *ifr){
1149
1835
1150
1836
/* Reject the loopback device */
1192
1878
* corresponds to an acceptable network device.
1193
1879
* (This function is passed to scandir(3) as a filter function.)
1194
1880
*/
1881
__attribute__((nonnull, warn_unused_result))
1195
1882
int good_interface(const struct dirent *if_entry){
1196
1883
if(if_entry->d_name[0] == '.'){
1197
1884
return 0;
1215
1902
/*
1216
1903
* This function determines if a network interface is up.
1217
1904
*/
1905
__attribute__((nonnull, warn_unused_result))
1218
1906
bool interface_is_up(const char *interface){
1219
1907
struct ifreq ifr;
1220
1908
if(not get_flags(interface, &ifr)){
1231
1919
/*
1232
1920
* This function determines if a network interface is running
1233
1921
*/
1922
__attribute__((nonnull, warn_unused_result))
1234
1923
bool interface_is_running(const char *interface){
1235
1924
struct ifreq ifr;
1236
1925
if(not get_flags(interface, &ifr)){
1244
1933
return (bool)(ifr.ifr_flags & IFF_RUNNING);
1245
1934
}
1246
1935
1936
__attribute__((nonnull, pure, warn_unused_result))
1247
1937
int notdotentries(const struct dirent *direntry){
1248
1938
/* Skip "." and ".." */
1249
1939
if(direntry->d_name[0] == '.'
1256
1946
}
1257
1947
1258
1948
/* Is this directory entry a runnable program? */
1949
__attribute__((nonnull, warn_unused_result))
1259
1950
int runnable_hook(const struct dirent *direntry){
1260
1951
int ret;
1261
1952
size_t sret;
1269
1960
sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1270
1961
"abcdefghijklmnopqrstuvwxyz"
1271
1962
"0123456789"
1272
"_-");
1963
"_.-");
1273
1964
if((direntry->d_name)[sret] != '\0'){
1274
1965
/* Contains non-allowed characters */
1275
1966
if(debug){
1279
1970
return 0;
1280
1971
}
1281
1972
1282
char *fullname = NULL;
1283
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1284
if(ret < 0){
1285
perror_plus("asprintf");
1286
return 0;
1287
}
1288
1289
ret = stat(fullname, &st);
1973
ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1290
1974
if(ret == -1){
1291
1975
if(debug){
1292
1976
perror_plus("Could not stat hook");
1316
2000
return 1;
1317
2001
}
1318
2002
1319
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval){
2003
__attribute__((nonnull, warn_unused_result))
2004
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
2005
mandos_context *mc){
1320
2006
int ret;
1321
2007
struct timespec now;
1322
2008
struct timespec waited_time;
1323
2009
intmax_t block_time;
1324
2010
1325
2011
while(true){
1326
if(mc.current_server == NULL){
1327
if (debug){
2012
if(mc->current_server == NULL){
2013
if(debug){
1328
2014
fprintf_plus(stderr, "Wait until first server is found."
1329
2015
" No timeout!\n");
1330
2016
}
1331
2017
ret = avahi_simple_poll_iterate(s, -1);
1332
2018
} else {
1333
if (debug){
2019
if(debug){
1334
2020
fprintf_plus(stderr, "Check current_server if we should run"
1335
2021
" it, or wait\n");
1336
2022
}
1343
2029
/* Calculating in ms how long time between now and server
1344
2030
who we visted longest time ago. Now - last seen. */
1345
2031
waited_time.tv_sec = (now.tv_sec
1346
- mc.current_server->last_seen.tv_sec);
2032
- mc->current_server->last_seen.tv_sec);
1347
2033
waited_time.tv_nsec = (now.tv_nsec
1348
- mc.current_server->last_seen.tv_nsec);
2034
- mc->current_server->last_seen.tv_nsec);
1349
2035
/* total time is 10s/10,000ms.
1350
2036
Converting to s from ms by dividing by 1,000,
1351
2037
and ns to ms by dividing by 1,000,000. */
1353
2039
- ((intmax_t)waited_time.tv_sec * 1000))
1354
2040
- ((intmax_t)waited_time.tv_nsec / 1000000));
1355
2041
1356
if (debug){
2042
if(debug){
1357
2043
fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1358
2044
block_time);
1359
2045
}
1360
2046
1361
2047
if(block_time <= 0){
1362
ret = start_mandos_communication(mc.current_server->ip,
1363
mc.current_server->port,
1364
mc.current_server->if_index,
1365
mc.current_server->af);
2048
ret = start_mandos_communication(mc->current_server->ip,
2049
mc->current_server->port,
2050
mc->current_server->if_index,
2051
mc->current_server->af, mc);
1366
2052
if(ret == 0){
1367
avahi_simple_poll_quit(simple_poll);
2053
avahi_simple_poll_quit(s);
1368
2054
return 0;
1369
2055
}
1370
2056
ret = clock_gettime(CLOCK_MONOTONIC,
1371
&mc.current_server->last_seen);
2057
&mc->current_server->last_seen);
1372
2058
if(ret == -1){
1373
2059
perror_plus("clock_gettime");
1374
2060
return -1;
1375
2061
}
1376
mc.current_server = mc.current_server->next;
2062
mc->current_server = mc->current_server->next;
1377
2063
block_time = 0; /* Call avahi to find new Mandos
1378
2064
servers, but don't block */
1379
2065
}
1381
2067
ret = avahi_simple_poll_iterate(s, (int)block_time);
1382
2068
}
1383
2069
if(ret != 0){
1384
if (ret > 0 or errno != EINTR){
2070
if(ret > 0 or errno != EINTR){
1385
2071
return (ret != 1) ? ret : 0;
1386
2072
}
1387
2073
}
1388
2074
}
1389
2075
}
1390
2076
1391
/* Set effective uid to 0, return errno */
1392
error_t raise_privileges(void){
1393
error_t old_errno = errno;
1394
error_t ret_errno = 0;
1395
if(seteuid(0) == -1){
1396
ret_errno = errno;
1397
perror_plus("seteuid");
1398
}
1399
errno = old_errno;
1400
return ret_errno;
1401
}
1402
1403
/* Set effective and real user ID to 0. Return errno. */
1404
error_t raise_privileges_permanently(void){
1405
error_t old_errno = errno;
1406
error_t ret_errno = raise_privileges();
1407
if(ret_errno != 0){
1408
errno = old_errno;
1409
return ret_errno;
1410
}
1411
if(setuid(0) == -1){
1412
ret_errno = errno;
1413
perror_plus("seteuid");
1414
}
1415
errno = old_errno;
1416
return ret_errno;
1417
}
1418
1419
/* Set effective user ID to unprivileged saved user ID */
1420
error_t lower_privileges(void){
1421
error_t old_errno = errno;
1422
error_t ret_errno = 0;
1423
if(seteuid(uid) == -1){
1424
ret_errno = errno;
1425
perror_plus("seteuid");
1426
}
1427
errno = old_errno;
1428
return ret_errno;
1429
}
1430
1431
/* Lower privileges permanently */
1432
error_t lower_privileges_permanently(void){
1433
error_t old_errno = errno;
1434
error_t ret_errno = 0;
1435
if(setuid(uid) == -1){
1436
ret_errno = errno;
1437
perror_plus("setuid");
1438
}
1439
errno = old_errno;
1440
return ret_errno;
1441
}
1442
1443
bool run_network_hooks(const char *mode, const char *interface,
2077
__attribute__((nonnull))
2078
void run_network_hooks(const char *mode, const char *interface,
1444
2079
const float delay){
1445
struct dirent **direntries;
2080
struct dirent **direntries = NULL;
2081
if(hookdir_fd == -1){
2082
hookdir_fd = open(hookdir, O_RDONLY | O_DIRECTORY | O_PATH
2083
| O_CLOEXEC);
2084
if(hookdir_fd == -1){
2085
if(errno == ENOENT){
2086
if(debug){
2087
fprintf_plus(stderr, "Network hook directory \"%s\" not"
2088
" found\n", hookdir);
2089
}
2090
} else {
2091
perror_plus("open");
2092
}
2093
return;
2094
}
2095
}
2096
int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
2097
if(devnull == -1){
2098
perror_plus("open(\"/dev/null\", O_RDONLY)");
2099
return;
2100
}
2101
int numhooks = scandirat(hookdir_fd, ".", &direntries,
2102
runnable_hook, alphasort);
2103
if(numhooks == -1){
2104
perror_plus("scandir");
2105
close(devnull);
2106
return;
2107
}
1446
2108
struct dirent *direntry;
1447
2109
int ret;
1448
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1449
alphasort);
1450
if(numhooks == -1){
1451
if(errno == ENOENT){
1452
if(debug){
1453
fprintf_plus(stderr, "Network hook directory \"%s\" not"
1454
" found\n", hookdir);
1455
}
1456
} else {
1457
perror_plus("scandir");
2110
for(int i = 0; i < numhooks; i++){
2111
direntry = direntries[i];
2112
if(debug){
2113
fprintf_plus(stderr, "Running network hook \"%s\"\n",
2114
direntry->d_name);
1458
2115
}
1459
} else {
1460
int devnull = open("/dev/null", O_RDONLY);
1461
for(int i = 0; i < numhooks; i++){
1462
direntry = direntries[i];
1463
char *fullname = NULL;
1464
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1465
if(ret < 0){
2116
pid_t hook_pid = fork();
2117
if(hook_pid == 0){
2118
/* Child */
2119
/* Raise privileges */
2120
errno = raise_privileges_permanently();
2121
if(errno != 0){
2122
perror_plus("Failed to raise privileges");
2123
_exit(EX_NOPERM);
2124
}
2125
/* Set group */
2126
errno = 0;
2127
ret = setgid(0);
2128
if(ret == -1){
2129
perror_plus("setgid");
2130
_exit(EX_NOPERM);
2131
}
2132
/* Reset supplementary groups */
2133
errno = 0;
2134
ret = setgroups(0, NULL);
2135
if(ret == -1){
2136
perror_plus("setgroups");
2137
_exit(EX_NOPERM);
2138
}
2139
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
2140
if(ret == -1){
2141
perror_plus("setenv");
2142
_exit(EX_OSERR);
2143
}
2144
ret = setenv("DEVICE", interface, 1);
2145
if(ret == -1){
2146
perror_plus("setenv");
2147
_exit(EX_OSERR);
2148
}
2149
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
2150
if(ret == -1){
2151
perror_plus("setenv");
2152
_exit(EX_OSERR);
2153
}
2154
ret = setenv("MODE", mode, 1);
2155
if(ret == -1){
2156
perror_plus("setenv");
2157
_exit(EX_OSERR);
2158
}
2159
char *delaystring;
2160
ret = asprintf(&delaystring, "%f", (double)delay);
2161
if(ret == -1){
1466
2162
perror_plus("asprintf");
1467
continue;
1468
}
1469
if(debug){
1470
fprintf_plus(stderr, "Running network hook \"%s\"\n",
1471
direntry->d_name);
1472
}
1473
pid_t hook_pid = fork();
1474
if(hook_pid == 0){
1475
/* Child */
1476
/* Raise privileges */
1477
raise_privileges_permanently();
1478
/* Set group */
1479
errno = 0;
1480
ret = setgid(0);
1481
if(ret == -1){
1482
perror_plus("setgid");
1483
}
1484
/* Reset supplementary groups */
1485
errno = 0;
1486
ret = setgroups(0, NULL);
1487
if(ret == -1){
1488
perror_plus("setgroups");
1489
}
1490
dup2(devnull, STDIN_FILENO);
1491
close(devnull);
1492
dup2(STDERR_FILENO, STDOUT_FILENO);
1493
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1494
if(ret == -1){
1495
perror_plus("setenv");
1496
_exit(EX_OSERR);
1497
}
1498
ret = setenv("DEVICE", interface, 1);
1499
if(ret == -1){
1500
perror_plus("setenv");
1501
_exit(EX_OSERR);
1502
}
1503
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
1504
if(ret == -1){
1505
perror_plus("setenv");
1506
_exit(EX_OSERR);
1507
}
1508
ret = setenv("MODE", mode, 1);
1509
if(ret == -1){
1510
perror_plus("setenv");
1511
_exit(EX_OSERR);
1512
}
1513
char *delaystring;
1514
ret = asprintf(&delaystring, "%f", delay);
1515
if(ret == -1){
1516
perror_plus("asprintf");
1517
_exit(EX_OSERR);
1518
}
1519
ret = setenv("DELAY", delaystring, 1);
1520
if(ret == -1){
1521
free(delaystring);
1522
perror_plus("setenv");
1523
_exit(EX_OSERR);
1524
}
2163
_exit(EX_OSERR);
2164
}
2165
ret = setenv("DELAY", delaystring, 1);
2166
if(ret == -1){
1525
2167
free(delaystring);
1526
if(connect_to != NULL){
1527
ret = setenv("CONNECT", connect_to, 1);
1528
if(ret == -1){
1529
perror_plus("setenv");
1530
_exit(EX_OSERR);
1531
}
1532
}
1533
if(execl(fullname, direntry->d_name, mode, NULL) == -1){
1534
perror_plus("execl");
1535
_exit(EXIT_FAILURE);
1536
}
2168
perror_plus("setenv");
2169
_exit(EX_OSERR);
2170
}
2171
free(delaystring);
2172
if(connect_to != NULL){
2173
ret = setenv("CONNECT", connect_to, 1);
2174
if(ret == -1){
2175
perror_plus("setenv");
2176
_exit(EX_OSERR);
2177
}
2178
}
2179
int hook_fd = (int)TEMP_FAILURE_RETRY(openat(hookdir_fd,
2180
direntry->d_name,
2181
O_RDONLY));
2182
if(hook_fd == -1){
2183
perror_plus("openat");
2184
_exit(EXIT_FAILURE);
2185
}
2186
if(close(hookdir_fd) == -1){
2187
perror_plus("close");
2188
_exit(EXIT_FAILURE);
2189
}
2190
ret = dup2(devnull, STDIN_FILENO);
2191
if(ret == -1){
2192
perror_plus("dup2(devnull, STDIN_FILENO)");
2193
_exit(EX_OSERR);
2194
}
2195
ret = close(devnull);
2196
if(ret == -1){
2197
perror_plus("close");
2198
_exit(EX_OSERR);
2199
}
2200
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
2201
if(ret == -1){
2202
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
2203
_exit(EX_OSERR);
2204
}
2205
if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
2206
environ) == -1){
2207
perror_plus("fexecve");
2208
_exit(EXIT_FAILURE);
2209
}
2210
} else {
2211
if(hook_pid == -1){
2212
perror_plus("fork");
2213
free(direntry);
2214
continue;
2215
}
2216
int status;
2217
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
2218
perror_plus("waitpid");
2219
free(direntry);
2220
continue;
2221
}
2222
if(WIFEXITED(status)){
2223
if(WEXITSTATUS(status) != 0){
2224
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
2225
" with status %d\n", direntry->d_name,
2226
WEXITSTATUS(status));
2227
free(direntry);
2228
continue;
2229
}
2230
} else if(WIFSIGNALED(status)){
2231
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
2232
" signal %d\n", direntry->d_name,
2233
WTERMSIG(status));
2234
free(direntry);
2235
continue;
1537
2236
} else {
1538
int status;
1539
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1540
perror_plus("waitpid");
1541
free(fullname);
1542
continue;
1543
}
1544
if(WIFEXITED(status)){
1545
if(WEXITSTATUS(status) != 0){
1546
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1547
" with status %d\n", direntry->d_name,
1548
WEXITSTATUS(status));
1549
free(fullname);
1550
continue;
1551
}
1552
} else if(WIFSIGNALED(status)){
1553
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1554
" signal %d\n", direntry->d_name,
1555
WTERMSIG(status));
1556
free(fullname);
1557
continue;
1558
} else {
1559
fprintf_plus(stderr, "Warning: network hook \"%s\""
1560
" crashed\n", direntry->d_name);
1561
free(fullname);
1562
continue;
1563
}
1564
}
1565
free(fullname);
1566
if(debug){
1567
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1568
direntry->d_name);
1569
}
1570
}
1571
close(devnull);
1572
}
1573
return true;
2237
fprintf_plus(stderr, "Warning: network hook \"%s\""
2238
" crashed\n", direntry->d_name);
2239
free(direntry);
2240
continue;
2241
}
2242
}
2243
if(debug){
2244
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
2245
direntry->d_name);
2246
}
2247
free(direntry);
2248
}
2249
free(direntries);
2250
if(close(hookdir_fd) == -1){
2251
perror_plus("close");
2252
} else {
2253
hookdir_fd = -1;
2254
}
2255
close(devnull);
1574
2256
}
1575
2257
1576
error_t bring_up_interface(const char *const interface,
1577
const float delay){
1578
int sd = -1;
1579
error_t old_errno = errno;
1580
error_t ret_errno = 0;
1581
int ret, ret_setflags;
2258
__attribute__((nonnull, warn_unused_result))
2259
int bring_up_interface(const char *const interface,
2260
const float delay){
2261
int old_errno = errno;
2262
int ret;
1582
2263
struct ifreq network;
1583
2264
unsigned int if_index = if_nametoindex(interface);
1584
2265
if(if_index == 0){
1593
2274
}
1594
2275
1595
2276
if(not interface_is_up(interface)){
1596
if(not get_flags(interface, &network) and debug){
2277
int ret_errno = 0;
2278
int ioctl_errno = 0;
2279
if(not get_flags(interface, &network)){
1597
2280
ret_errno = errno;
1598
2281
fprintf_plus(stderr, "Failed to get flags for interface "
1599
2282
"\"%s\"\n", interface);
2283
errno = old_errno;
1600
2284
return ret_errno;
1601
2285
}
1602
network.ifr_flags |= IFF_UP;
2286
network.ifr_flags |= IFF_UP; /* set flag */
1603
2287
1604
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1605
if(sd < 0){
2288
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
2289
if(sd == -1){
1606
2290
ret_errno = errno;
1607
2291
perror_plus("socket");
1608
2292
errno = old_errno;
1609
2293
return ret_errno;
1610
2294
}
1611
2295
1612
2296
if(quit_now){
1613
close(sd);
2297
ret = close(sd);
2298
if(ret == -1){
2299
perror_plus("close");
2300
}
1614
2301
errno = old_errno;
1615
2302
return EINTR;
1616
2303
}
1620
2307
interface);
1621
2308
}
1622
2309
1623
/* Raise priviliges */
1624
raise_privileges();
2310
/* Raise privileges */
2311
ret_errno = raise_privileges();
2312
if(ret_errno != 0){
2313
errno = ret_errno;
2314
perror_plus("Failed to raise privileges");
2315
}
1625
2316
1626
2317
#ifdef __linux__
1627
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1628
messages about the network interface to mess up the prompt */
1629
int ret_linux = klogctl(8, NULL, 5);
1630
bool restore_loglevel = true;
1631
if(ret_linux == -1){
1632
restore_loglevel = false;
1633
perror_plus("klogctl");
2318
int ret_linux;
2319
bool restore_loglevel = false;
2320
if(ret_errno == 0){
2321
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
2322
messages about the network interface to mess up the prompt */
2323
ret_linux = klogctl(8, NULL, 5);
2324
if(ret_linux == -1){
2325
perror_plus("klogctl");
2326
} else {
2327
restore_loglevel = true;
2328
}
1634
2329
}
1635
2330
#endif /* __linux__ */
1636
ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1637
ret_errno = errno;
2331
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
2332
ioctl_errno = errno;
1638
2333
#ifdef __linux__
1639
2334
if(restore_loglevel){
1640
2335
ret_linux = klogctl(7, NULL, 0);
1644
2339
}
1645
2340
#endif /* __linux__ */
1646
2341
1647
/* Lower privileges */
1648
lower_privileges();
2342
/* If raise_privileges() succeeded above */
2343
if(ret_errno == 0){
2344
/* Lower privileges */
2345
ret_errno = lower_privileges();
2346
if(ret_errno != 0){
2347
errno = ret_errno;
2348
perror_plus("Failed to lower privileges");
2349
}
2350
}
1649
2351
1650
2352
/* Close the socket */
1651
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2353
ret = close(sd);
1652
2354
if(ret == -1){
1653
2355
perror_plus("close");
1654
2356
}
1655
2357
1656
2358
if(ret_setflags == -1){
1657
errno = ret_errno;
2359
errno = ioctl_errno;
1658
2360
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1659
2361
errno = old_errno;
1660
return ret_errno;
2362
return ioctl_errno;
1661
2363
}
1662
2364
} else if(debug){
1663
2365
fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
1666
2368
1667
2369
/* Sleep checking until interface is running.
1668
2370
Check every 0.25s, up to total time of delay */
1669
for(int i=0; i < delay * 4; i++){
2371
for(int i = 0; i < delay * 4; i++){
1670
2372
if(interface_is_running(interface)){
1671
2373
break;
1672
2374
}
1681
2383
return 0;
1682
2384
}
1683
2385
1684
error_t take_down_interface(const char *const interface){
1685
int sd = -1;
1686
error_t old_errno = errno;
1687
error_t ret_errno = 0;
1688
int ret, ret_setflags;
2386
__attribute__((nonnull, warn_unused_result))
2387
int take_down_interface(const char *const interface){
2388
int old_errno = errno;
1689
2389
struct ifreq network;
1690
2390
unsigned int if_index = if_nametoindex(interface);
1691
2391
if(if_index == 0){
1694
2394
return ENXIO;
1695
2395
}
1696
2396
if(interface_is_up(interface)){
2397
int ret_errno = 0;
2398
int ioctl_errno = 0;
1697
2399
if(not get_flags(interface, &network) and debug){
1698
2400
ret_errno = errno;
1699
2401
fprintf_plus(stderr, "Failed to get flags for interface "
1700
2402
"\"%s\"\n", interface);
2403
errno = old_errno;
1701
2404
return ret_errno;
1702
2405
}
1703
2406
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
1704
2407
1705
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1706
if(sd < 0){
2408
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
2409
if(sd == -1){
1707
2410
ret_errno = errno;
1708
2411
perror_plus("socket");
1709
2412
errno = old_errno;
1715
2418
interface);
1716
2419
}
1717
2420
1718
/* Raise priviliges */
1719
raise_privileges();
1720
1721
ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1722
ret_errno = errno;
1723
1724
/* Lower privileges */
1725
lower_privileges();
2421
/* Raise privileges */
2422
ret_errno = raise_privileges();
2423
if(ret_errno != 0){
2424
errno = ret_errno;
2425
perror_plus("Failed to raise privileges");
2426
}
2427
2428
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
2429
ioctl_errno = errno;
2430
2431
/* If raise_privileges() succeeded above */
2432
if(ret_errno == 0){
2433
/* Lower privileges */
2434
ret_errno = lower_privileges();
2435
if(ret_errno != 0){
2436
errno = ret_errno;
2437
perror_plus("Failed to lower privileges");
2438
}
2439
}
1726
2440
1727
2441
/* Close the socket */
1728
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2442
int ret = close(sd);
1729
2443
if(ret == -1){
1730
2444
perror_plus("close");
1731
2445
}
1732
2446
1733
2447
if(ret_setflags == -1){
1734
errno = ret_errno;
2448
errno = ioctl_errno;
1735
2449
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
1736
2450
errno = old_errno;
1737
return ret_errno;
2451
return ioctl_errno;
1738
2452
}
1739
2453
} else if(debug){
1740
2454
fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
1746
2460
}
1747
2461
1748
2462
int main(int argc, char *argv[]){
2463
mandos_context mc = { .server = NULL, .dh_bits = 0,
2464
#if GNUTLS_VERSION_NUMBER >= 0x030606
2465
.priority = "SECURE128:!CTYPE-X.509"
2466
":+CTYPE-RAWPK:!RSA:!VERS-ALL:+VERS-TLS1.3"
2467
":%PROFILE_ULTRA",
2468
#elif GNUTLS_VERSION_NUMBER < 0x030600
2469
.priority = "SECURE256:!CTYPE-X.509"
2470
":+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256",
2471
#else
2472
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
2473
#endif
2474
.current_server = NULL, .interfaces = NULL,
2475
.interfaces_size = 0 };
1749
2476
AvahiSServiceBrowser *sb = NULL;
1750
2477
error_t ret_errno;
1751
2478
int ret;
1752
2479
intmax_t tmpmax;
1753
2480
char *tmp;
1754
2481
int exitcode = EXIT_SUCCESS;
1755
char *interfaces = NULL;
1756
size_t interfaces_size = 0;
1757
2482
char *interfaces_to_take_down = NULL;
1758
2483
size_t interfaces_to_take_down_size = 0;
1759
char tempdir[] = "/tmp/mandosXXXXXX";
1760
bool tempdir_created = false;
2484
char run_tempdir[] = "/run/tmp/mandosXXXXXX";
2485
char old_tempdir[] = "/tmp/mandosXXXXXX";
2486
char *tempdir = NULL;
1761
2487
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1762
2488
const char *seckey = PATHDIR "/" SECKEY;
1763
2489
const char *pubkey = PATHDIR "/" PUBKEY;
2490
#if GNUTLS_VERSION_NUMBER >= 0x030606
2491
const char *tls_privkey = PATHDIR "/" TLS_PRIVKEY;
2492
const char *tls_pubkey = PATHDIR "/" TLS_PUBKEY;
2493
#endif
2494
const char *dh_params_file = NULL;
1764
2495
char *interfaces_hooks = NULL;
1765
size_t interfaces_hooks_size = 0;
1766
2496
1767
2497
bool gnutls_initialized = false;
1768
2498
bool gpgme_initialized = false;
1814
2544
{ .name = "pubkey", .key = 'p',
1815
2545
.arg = "FILE",
1816
2546
.doc = "OpenPGP public key file base name",
1817
.group = 2 },
2547
.group = 1 },
2548
{ .name = "tls-privkey", .key = 't',
2549
.arg = "FILE",
2550
#if GNUTLS_VERSION_NUMBER >= 0x030606
2551
.doc = "TLS private key file base name",
2552
#else
2553
.doc = "Dummy; ignored (requires GnuTLS 3.6.6)",
2554
#endif
2555
.group = 1 },
2556
{ .name = "tls-pubkey", .key = 'T',
2557
.arg = "FILE",
2558
#if GNUTLS_VERSION_NUMBER >= 0x030606
2559
.doc = "TLS public key file base name",
2560
#else
2561
.doc = "Dummy; ignored (requires GnuTLS 3.6.6)",
2562
#endif
2563
.group = 1 },
1818
2564
{ .name = "dh-bits", .key = 129,
1819
2565
.arg = "BITS",
1820
2566
.doc = "Bit length of the prime number used in the"
1821
2567
" Diffie-Hellman key exchange",
1822
2568
.group = 2 },
2569
{ .name = "dh-params", .key = 134,
2570
.arg = "FILE",
2571
.doc = "PEM-encoded PKCS#3 file with pre-generated parameters"
2572
" for the Diffie-Hellman key exchange",
2573
.group = 2 },
1823
2574
{ .name = "priority", .key = 130,
1824
2575
.arg = "STRING",
1825
2576
.doc = "GnuTLS priority string for the TLS handshake",
1859
2610
connect_to = arg;
1860
2611
break;
1861
2612
case 'i': /* --interface */
1862
ret_errno = argz_add_sep(&interfaces, &interfaces_size, arg,
1863
(int)',');
2613
ret_errno = argz_add_sep(&mc.interfaces, &mc.interfaces_size,
2614
arg, (int)',');
1864
2615
if(ret_errno != 0){
1865
2616
argp_error(state, "%s", strerror(ret_errno));
1866
2617
}
1871
2622
case 'p': /* --pubkey */
1872
2623
pubkey = arg;
1873
2624
break;
2625
case 't': /* --tls-privkey */
2626
#if GNUTLS_VERSION_NUMBER >= 0x030606
2627
tls_privkey = arg;
2628
#endif
2629
break;
2630
case 'T': /* --tls-pubkey */
2631
#if GNUTLS_VERSION_NUMBER >= 0x030606
2632
tls_pubkey = arg;
2633
#endif
2634
break;
1874
2635
case 129: /* --dh-bits */
1875
2636
errno = 0;
1876
2637
tmpmax = strtoimax(arg, &tmp, 10);
1880
2641
}
1881
2642
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
1882
2643
break;
2644
case 134: /* --dh-params */
2645
dh_params_file = arg;
2646
break;
1883
2647
case 130: /* --priority */
1884
2648
mc.priority = arg;
1885
2649
break;
1908
2672
argp_state_help(state, state->out_stream,
1909
2673
(ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
1910
2674
& ~(unsigned int)ARGP_HELP_EXIT_OK);
2675
__builtin_unreachable();
1911
2676
case -3: /* --usage */
1912
2677
argp_state_help(state, state->out_stream,
1913
2678
ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
2679
__builtin_unreachable();
1914
2680
case 'V': /* --version */
1915
2681
fprintf_plus(state->out_stream, "%s\n", argp_program_version);
1916
2682
exit(argp_err_exit_status);
1925
2691
.args_doc = "",
1926
2692
.doc = "Mandos client -- Get and decrypt"
1927
2693
" passwords from a Mandos server" };
1928
ret = argp_parse(&argp, argc, argv,
1929
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
1930
switch(ret){
2694
ret_errno = argp_parse(&argp, argc, argv,
2695
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2696
switch(ret_errno){
1931
2697
case 0:
1932
2698
break;
1933
2699
case ENOMEM:
1934
2700
default:
1935
errno = ret;
2701
errno = ret_errno;
1936
2702
perror_plus("argp_parse");
1937
2703
exitcode = EX_OSERR;
1938
2704
goto end;
1941
2707
goto end;
1942
2708
}
1943
2709
}
1944
2710
1945
2711
{
1946
2712
/* Work around Debian bug #633582:
1947
<http://bugs.debian.org/633582> */
2713
<https://bugs.debian.org/633582> */
1948
2714
1949
/* Re-raise priviliges */
1950
if(raise_privileges() == 0){
2715
/* Re-raise privileges */
2716
ret = raise_privileges();
2717
if(ret != 0){
2718
errno = ret;
2719
perror_plus("Failed to raise privileges");
2720
} else {
1951
2721
struct stat st;
1952
2722
1953
2723
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
1967
2737
}
1968
2738
}
1969
2739
}
1970
TEMP_FAILURE_RETRY(close(seckey_fd));
2740
close(seckey_fd);
1971
2741
}
1972
2742
}
1973
2743
1974
2744
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
1975
2745
int pubkey_fd = open(pubkey, O_RDONLY);
1976
2746
if(pubkey_fd == -1){
1988
2758
}
1989
2759
}
1990
2760
}
1991
TEMP_FAILURE_RETRY(close(pubkey_fd));
1992
}
1993
}
1994
2761
close(pubkey_fd);
2762
}
2763
}
2764
2765
if(dh_params_file != NULL
2766
and strcmp(dh_params_file, PATHDIR "/dhparams.pem" ) == 0){
2767
int dhparams_fd = open(dh_params_file, O_RDONLY);
2768
if(dhparams_fd == -1){
2769
perror_plus("open");
2770
} else {
2771
ret = (int)TEMP_FAILURE_RETRY(fstat(dhparams_fd, &st));
2772
if(ret == -1){
2773
perror_plus("fstat");
2774
} else {
2775
if(S_ISREG(st.st_mode)
2776
and st.st_uid == 0 and st.st_gid == 0){
2777
ret = fchown(dhparams_fd, uid, gid);
2778
if(ret == -1){
2779
perror_plus("fchown");
2780
}
2781
}
2782
}
2783
close(dhparams_fd);
2784
}
2785
}
2786
1995
2787
/* Lower privileges */
1996
errno = 0;
1997
ret = seteuid(uid);
1998
if(ret == -1){
1999
perror_plus("seteuid");
2788
ret = lower_privileges();
2789
if(ret != 0){
2790
errno = ret;
2791
perror_plus("Failed to lower privileges");
2000
2792
}
2001
2793
}
2002
2794
}
2003
2795
2004
/* Remove empty interface names */
2796
/* Remove invalid interface names (except "none") */
2005
2797
{
2006
2798
char *interface = NULL;
2007
while((interface = argz_next(interfaces, interfaces_size,
2799
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2008
2800
interface))){
2009
if(if_nametoindex(interface) == 0){
2010
if(interface[0] != '\0' and strcmp(interface, "none") != 0){
2801
if(strcmp(interface, "none") != 0
2802
and if_nametoindex(interface) == 0){
2803
if(interface[0] != '\0'){
2011
2804
fprintf_plus(stderr, "Not using nonexisting interface"
2012
2805
" \"%s\"\n", interface);
2013
2806
}
2014
argz_delete(&interfaces, &interfaces_size, interface);
2807
argz_delete(&mc.interfaces, &mc.interfaces_size, interface);
2015
2808
interface = NULL;
2016
2809
}
2017
2810
}
2019
2812
2020
2813
/* Run network hooks */
2021
2814
{
2022
2023
if(interfaces != NULL){
2024
interfaces_hooks = malloc(interfaces_size);
2815
if(mc.interfaces != NULL){
2816
interfaces_hooks = malloc(mc.interfaces_size);
2025
2817
if(interfaces_hooks == NULL){
2026
2818
perror_plus("malloc");
2027
2819
goto end;
2028
2820
}
2029
memcpy(interfaces_hooks, interfaces, interfaces_size);
2030
interfaces_hooks_size = interfaces_size;
2031
argz_stringify(interfaces_hooks, interfaces_hooks_size,
2032
(int)',');
2033
}
2034
if(not run_network_hooks("start", interfaces_hooks != NULL ?
2035
interfaces_hooks : "", delay)){
2036
goto end;
2037
}
2821
memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
2822
argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
2823
}
2824
run_network_hooks("start", interfaces_hooks != NULL ?
2825
interfaces_hooks : "", delay);
2038
2826
}
2039
2827
2040
2828
if(not debug){
2117
2905
}
2118
2906
2119
2907
/* If no interfaces were specified, make a list */
2120
if(interfaces == NULL){
2121
struct dirent **direntries;
2908
if(mc.interfaces == NULL){
2909
struct dirent **direntries = NULL;
2122
2910
/* Look for any good interfaces */
2123
2911
ret = scandir(sys_class_net, &direntries, good_interface,
2124
2912
alphasort);
2125
2913
if(ret >= 1){
2126
2914
/* Add all found interfaces to interfaces list */
2127
2915
for(int i = 0; i < ret; ++i){
2128
ret_errno = argz_add(&interfaces, &interfaces_size,
2916
ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
2129
2917
direntries[i]->d_name);
2130
2918
if(ret_errno != 0){
2919
errno = ret_errno;
2131
2920
perror_plus("argz_add");
2921
free(direntries[i]);
2132
2922
continue;
2133
2923
}
2134
2924
if(debug){
2135
2925
fprintf_plus(stderr, "Will use interface \"%s\"\n",
2136
2926
direntries[i]->d_name);
2137
2927
}
2928
free(direntries[i]);
2138
2929
}
2139
2930
free(direntries);
2140
2931
} else {
2141
free(direntries);
2932
if(ret == 0){
2933
free(direntries);
2934
}
2142
2935
fprintf_plus(stderr, "Could not find a network interface\n");
2143
2936
exitcode = EXIT_FAILURE;
2144
2937
goto end;
2145
2938
}
2146
2939
}
2147
2940
2148
/* If we only got one interface, explicitly use only that one */
2149
if(argz_count(interfaces, interfaces_size) == 1){
2150
if(debug){
2151
fprintf_plus(stderr, "Using only interface \"%s\"\n",
2152
interfaces);
2153
}
2154
if_index = (AvahiIfIndex)if_nametoindex(interfaces);
2155
}
2156
2157
/* Bring up interfaces which are down */
2158
if(not (argz_count(interfaces, interfaces_size) == 1
2159
and strcmp(interfaces, "none") == 0)){
2941
/* Bring up interfaces which are down, and remove any "none"s */
2942
{
2160
2943
char *interface = NULL;
2161
while((interface = argz_next(interfaces, interfaces_size,
2944
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2162
2945
interface))){
2946
/* If interface name is "none", stop bringing up interfaces.
2947
Also remove all instances of "none" from the list */
2948
if(strcmp(interface, "none") == 0){
2949
argz_delete(&mc.interfaces, &mc.interfaces_size,
2950
interface);
2951
interface = NULL;
2952
while((interface = argz_next(mc.interfaces,
2953
mc.interfaces_size, interface))){
2954
if(strcmp(interface, "none") == 0){
2955
argz_delete(&mc.interfaces, &mc.interfaces_size,
2956
interface);
2957
interface = NULL;
2958
}
2959
}
2960
break;
2961
}
2163
2962
bool interface_was_up = interface_is_up(interface);
2164
ret = bring_up_interface(interface, delay);
2963
errno = bring_up_interface(interface, delay);
2165
2964
if(not interface_was_up){
2166
if(ret != 0){
2167
errno = ret;
2168
perror_plus("Failed to bring up interface");
2965
if(errno != 0){
2966
fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
2967
" %s\n", interface, strerror(errno));
2169
2968
} else {
2170
ret_errno = argz_add(&interfaces_to_take_down,
2171
&interfaces_to_take_down_size,
2172
interface);
2969
errno = argz_add(&interfaces_to_take_down,
2970
&interfaces_to_take_down_size,
2971
interface);
2972
if(errno != 0){
2973
perror_plus("argz_add");
2974
}
2173
2975
}
2174
2976
}
2175
2977
}
2176
free(interfaces);
2177
interfaces = NULL;
2178
interfaces_size = 0;
2179
2978
if(debug and (interfaces_to_take_down == NULL)){
2180
2979
fprintf_plus(stderr, "No interfaces were brought up\n");
2181
2980
}
2182
2981
}
2183
2982
2983
/* If we only got one interface, explicitly use only that one */
2984
if(argz_count(mc.interfaces, mc.interfaces_size) == 1){
2985
if(debug){
2986
fprintf_plus(stderr, "Using only interface \"%s\"\n",
2987
mc.interfaces);
2988
}
2989
if_index = (AvahiIfIndex)if_nametoindex(mc.interfaces);
2990
}
2991
2184
2992
if(quit_now){
2185
2993
goto end;
2186
2994
}
2187
2995
2188
ret = init_gnutls_global(pubkey, seckey);
2996
#if GNUTLS_VERSION_NUMBER >= 0x030606
2997
ret = init_gnutls_global(tls_pubkey, tls_privkey, dh_params_file, &mc);
2998
#elif GNUTLS_VERSION_NUMBER < 0x030600
2999
ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
3000
#else
3001
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
3002
#endif
2189
3003
if(ret == -1){
2190
3004
fprintf_plus(stderr, "init_gnutls_global failed\n");
2191
3005
exitcode = EX_UNAVAILABLE;
2198
3012
goto end;
2199
3013
}
2200
3014
2201
if(mkdtemp(tempdir) == NULL){
3015
/* Try /run/tmp before /tmp */
3016
tempdir = mkdtemp(run_tempdir);
3017
if(tempdir == NULL and errno == ENOENT){
3018
if(debug){
3019
fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
3020
run_tempdir, old_tempdir);
3021
}
3022
tempdir = mkdtemp(old_tempdir);
3023
}
3024
if(tempdir == NULL){
2202
3025
perror_plus("mkdtemp");
2203
3026
goto end;
2204
3027
}
2205
tempdir_created = true;
2206
3028
2207
3029
if(quit_now){
2208
3030
goto end;
2209
3031
}
2210
3032
2211
if(not init_gpgme(pubkey, seckey, tempdir)){
3033
if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
2212
3034
fprintf_plus(stderr, "init_gpgme failed\n");
2213
3035
exitcode = EX_UNAVAILABLE;
2214
3036
goto end;
2244
3066
exitcode = EX_USAGE;
2245
3067
goto end;
2246
3068
}
2247
3069
2248
3070
if(quit_now){
2249
3071
goto end;
2250
3072
}
2271
3093
}
2272
3094
2273
3095
while(not quit_now){
2274
ret = start_mandos_communication(address, port, if_index, af);
3096
ret = start_mandos_communication(address, port, if_index, af,
3097
&mc);
2275
3098
if(quit_now or ret == 0){
2276
3099
break;
2277
3100
}
2279
3102
fprintf_plus(stderr, "Retrying in %d seconds\n",
2280
3103
(int)retry_interval);
2281
3104
}
2282
sleep((int)retry_interval);
3105
sleep((unsigned int)retry_interval);
2283
3106
}
2284
3107
2285
if (not quit_now){
3108
if(not quit_now){
2286
3109
exitcode = EXIT_SUCCESS;
2287
3110
}
2288
3111
2304
3127
2305
3128
/* Allocate a new server */
2306
3129
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
2307
&config, NULL, NULL, &ret_errno);
3130
&config, NULL, NULL, &ret);
2308
3131
2309
3132
/* Free the Avahi configuration data */
2310
3133
avahi_server_config_free(&config);
2313
3136
/* Check if creating the Avahi server object succeeded */
2314
3137
if(mc.server == NULL){
2315
3138
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2316
avahi_strerror(ret_errno));
3139
avahi_strerror(ret));
2317
3140
exitcode = EX_UNAVAILABLE;
2318
3141
goto end;
2319
3142
}
2325
3148
/* Create the Avahi service browser */
2326
3149
sb = avahi_s_service_browser_new(mc.server, if_index,
2327
3150
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
2328
NULL, 0, browse_callback, NULL);
3151
NULL, 0, browse_callback,
3152
(void *)&mc);
2329
3153
if(sb == NULL){
2330
3154
fprintf_plus(stderr, "Failed to create service browser: %s\n",
2331
3155
avahi_strerror(avahi_server_errno(mc.server)));
2342
3166
if(debug){
2343
3167
fprintf_plus(stderr, "Starting Avahi loop search\n");
2344
3168
}
2345
3169
2346
3170
ret = avahi_loop_with_timeout(simple_poll,
2347
(int)(retry_interval * 1000));
3171
(int)(retry_interval * 1000), &mc);
2348
3172
if(debug){
2349
3173
fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
2350
3174
(ret == 0) ? "successfully" : "with error");
2353
3177
end:
2354
3178
2355
3179
if(debug){
2356
fprintf_plus(stderr, "%s exiting\n", argv[0]);
3180
if(signal_received){
3181
fprintf_plus(stderr, "%s exiting due to signal %d: %s\n",
3182
argv[0], signal_received,
3183
strsignal(signal_received));
3184
} else {
3185
fprintf_plus(stderr, "%s exiting\n", argv[0]);
3186
}
2357
3187
}
2358
3188
2359
3189
/* Cleanup things */
3190
free(mc.interfaces);
3191
2360
3192
if(sb != NULL)
2361
3193
avahi_s_service_browser_free(sb);
2362
3194
2368
3200
2369
3201
if(gnutls_initialized){
2370
3202
gnutls_certificate_free_credentials(mc.cred);
2371
gnutls_global_deinit();
2372
3203
gnutls_dh_params_deinit(mc.dh_params);
2373
3204
}
2374
3205
2382
3213
mc.current_server->prev->next = NULL;
2383
3214
while(mc.current_server != NULL){
2384
3215
server *next = mc.current_server->next;
3216
#ifdef __GNUC__
3217
#pragma GCC diagnostic push
3218
#pragma GCC diagnostic ignored "-Wcast-qual"
3219
#endif
3220
free((char *)(mc.current_server->ip));
3221
#ifdef __GNUC__
3222
#pragma GCC diagnostic pop
3223
#endif
2385
3224
free(mc.current_server);
2386
3225
mc.current_server = next;
2387
3226
}
2388
3227
}
2389
3228
2390
/* Re-raise priviliges */
3229
/* Re-raise privileges */
2391
3230
{
2392
raise_privileges();
2393
2394
/* Run network hooks */
2395
run_network_hooks("stop", interfaces_hooks != NULL ?
2396
interfaces_hooks : "", delay);
2397
2398
/* Take down the network interfaces which were brought up */
2399
{
2400
char *interface = NULL;
2401
while((interface=argz_next(interfaces_to_take_down,
2402
interfaces_to_take_down_size,
2403
interface))){
2404
ret_errno = take_down_interface(interface);
2405
if(ret_errno != 0){
2406
errno = ret_errno;
2407
perror_plus("Failed to take down interface");
2408
}
2409
}
2410
if(debug and (interfaces_to_take_down == NULL)){
2411
fprintf_plus(stderr, "No interfaces needed to be taken"
2412
" down\n");
2413
}
2414
}
2415
2416
lower_privileges_permanently();
3231
ret = raise_privileges();
3232
if(ret != 0){
3233
errno = ret;
3234
perror_plus("Failed to raise privileges");
3235
} else {
3236
3237
/* Run network hooks */
3238
run_network_hooks("stop", interfaces_hooks != NULL ?
3239
interfaces_hooks : "", delay);
3240
3241
/* Take down the network interfaces which were brought up */
3242
{
3243
char *interface = NULL;
3244
while((interface = argz_next(interfaces_to_take_down,
3245
interfaces_to_take_down_size,
3246
interface))){
3247
ret = take_down_interface(interface);
3248
if(ret != 0){
3249
errno = ret;
3250
perror_plus("Failed to take down interface");
3251
}
3252
}
3253
if(debug and (interfaces_to_take_down == NULL)){
3254
fprintf_plus(stderr, "No interfaces needed to be taken"
3255
" down\n");
3256
}
3257
}
3258
}
3259
3260
ret = lower_privileges_permanently();
3261
if(ret != 0){
3262
errno = ret;
3263
perror_plus("Failed to lower privileges permanently");
3264
}
2417
3265
}
2418
3266
2419
3267
free(interfaces_to_take_down);
2420
3268
free(interfaces_hooks);
2421
3269
3270
void clean_dir_at(int base, const char * const dirname,
3271
uintmax_t level){
3272
struct dirent **direntries = NULL;
3273
int dret;
3274
int dir_fd = (int)TEMP_FAILURE_RETRY(openat(base, dirname,
3275
O_RDONLY
3276
| O_NOFOLLOW
3277
| O_DIRECTORY
3278
| O_PATH));
3279
if(dir_fd == -1){
3280
perror_plus("open");
3281
return;
3282
}
3283
int numentries = scandirat(dir_fd, ".", &direntries,
3284
notdotentries, alphasort);
3285
if(numentries >= 0){
3286
for(int i = 0; i < numentries; i++){
3287
if(debug){
3288
fprintf_plus(stderr, "Unlinking \"%s/%s\"\n",
3289
dirname, direntries[i]->d_name);
3290
}
3291
dret = unlinkat(dir_fd, direntries[i]->d_name, 0);
3292
if(dret == -1){
3293
if(errno == EISDIR){
3294
dret = unlinkat(dir_fd, direntries[i]->d_name,
3295
AT_REMOVEDIR);
3296
}
3297
if((dret == -1) and (errno == ENOTEMPTY)
3298
and (strcmp(direntries[i]->d_name, "private-keys-v1.d")
3299
== 0) and (level == 0)){
3300
/* Recurse only in this special case */
3301
clean_dir_at(dir_fd, direntries[i]->d_name, level+1);
3302
dret = 0;
3303
}
3304
if((dret == -1) and (errno != ENOENT)){
3305
fprintf_plus(stderr, "unlink(\"%s/%s\"): %s\n", dirname,
3306
direntries[i]->d_name, strerror(errno));
3307
}
3308
}
3309
free(direntries[i]);
3310
}
3311
3312
/* need to clean even if 0 because man page doesn't specify */
3313
free(direntries);
3314
dret = unlinkat(base, dirname, AT_REMOVEDIR);
3315
if(dret == -1 and errno != ENOENT){
3316
perror_plus("rmdir");
3317
}
3318
} else {
3319
perror_plus("scandirat");
3320
}
3321
close(dir_fd);
3322
}
3323
2422
3324
/* Removes the GPGME temp directory and all files inside */
2423
if(tempdir_created){
2424
struct dirent **direntries = NULL;
2425
struct dirent *direntry = NULL;
2426
int numentries = scandir(tempdir, &direntries, notdotentries,
2427
alphasort);
2428
if (numentries > 0){
2429
for(int i = 0; i < numentries; i++){
2430
direntry = direntries[i];
2431
char *fullname = NULL;
2432
ret = asprintf(&fullname, "%s/%s", tempdir,
2433
direntry->d_name);
2434
if(ret < 0){
2435
perror_plus("asprintf");
2436
continue;
2437
}
2438
ret = remove(fullname);
2439
if(ret == -1){
2440
fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2441
strerror(errno));
2442
}
2443
free(fullname);
2444
}
2445
}
2446
2447
/* need to clean even if 0 because man page doesn't specify */
2448
free(direntries);
2449
if (numentries == -1){
2450
perror_plus("scandir");
2451
}
2452
ret = rmdir(tempdir);
2453
if(ret == -1 and errno != ENOENT){
2454
perror_plus("rmdir");
2455
}
3325
if(tempdir != NULL){
3326
clean_dir_at(-1, tempdir, 0);
2456
3327
}
2457
3328
2458
3329
if(quit_now){
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0