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:
- debian/upstream-signing-key.pgp
- files modified:
- .bzrignore
added
removed
plugins.d/mandos-client.c
9
9
* "browse_callback", and parts of "main".
10
10
*
11
11
* Everything else is
12
* Copyright © 2008-2013 Teddy Hogeborn
13
* Copyright © 2008-2013 Björn Påhlsson
14
*
15
* This program is free software: you can redistribute it and/or
16
* modify it under the terms of the GNU General Public License as
17
* published by the Free Software Foundation, either version 3 of the
18
* License, or (at your option) any later version.
19
*
20
* This program is distributed in the hope that it will be useful, but
12
* Copyright © 2008-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,
57
59
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
58
60
inet_pton(), connect(),
59
61
getnameinfo() */
60
#include <fcntl.h> /* open() */
62
#include <fcntl.h> /* open(), unlinkat(), AT_REMOVEDIR */
61
63
#include <dirent.h> /* opendir(), struct dirent, readdir()
62
64
*/
63
65
#include <inttypes.h> /* PRIu16, PRIdMAX, intmax_t,
64
66
strtoimax() */
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() */
82
setgid(), pause(), _exit(),
83
unlinkat() */
77
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
116
123
gnutls_*
117
124
init_gnutls_session(),
118
125
GNUTLS_* */
126
#if GNUTLS_VERSION_NUMBER < 0x030600
119
127
#include <gnutls/openpgp.h>
120
128
/* gnutls_certificate_set_openpgp_key_file(),
121
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
122
135
123
136
/* GPGME */
124
137
#include <gpgme.h> /* All GPGME types, constants and
132
145
#define PATHDIR "/conf/conf.d/mandos"
133
146
#define SECKEY "seckey.txt"
134
147
#define PUBKEY "pubkey.txt"
148
#define TLS_PRIVKEY "tls-privkey.pem"
149
#define TLS_PUBKEY "tls-pubkey.pem"
135
150
#define HOOKDIR "/lib/mandos/network-hooks.d"
136
151
137
152
bool debug = false;
141
156
static const char sys_class_net[] = "/sys/class/net";
142
157
char *connect_to = NULL;
143
158
const char *hookdir = HOOKDIR;
159
int hookdir_fd = -1;
144
160
uid_t uid = 65534;
145
161
gid_t gid = 65534;
146
162
183
199
perror(print_text);
184
200
}
185
201
186
__attribute__((format (gnu_printf, 2, 3)))
202
__attribute__((format (gnu_printf, 2, 3), nonnull))
187
203
int fprintf_plus(FILE *stream, const char *format, ...){
188
204
va_list ap;
189
205
va_start (ap, format);
198
214
* bytes. "buffer_capacity" is how much is currently allocated,
199
215
* "buffer_length" is how much is already used.
200
216
*/
217
__attribute__((nonnull, warn_unused_result))
201
218
size_t incbuffer(char **buffer, size_t buffer_length,
202
219
size_t buffer_capacity){
203
220
if(buffer_length + BUFFER_SIZE > buffer_capacity){
216
233
}
217
234
218
235
/* Add server to set of servers to retry periodically */
236
__attribute__((nonnull, warn_unused_result))
219
237
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
220
238
int af, server **current_server){
221
239
int ret;
230
248
.af = af };
231
249
if(new_server->ip == NULL){
232
250
perror_plus("strdup");
251
free(new_server);
233
252
return false;
234
253
}
235
254
ret = clock_gettime(CLOCK_MONOTONIC, &(new_server->last_seen));
236
255
if(ret == -1){
237
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);
238
266
return false;
239
267
}
240
268
/* Special case of first server */
242
270
new_server->next = new_server;
243
271
new_server->prev = new_server;
244
272
*current_server = new_server;
245
/* Place the new server last in the list */
246
273
} else {
274
/* Place the new server last in the list */
247
275
new_server->next = *current_server;
248
276
new_server->prev = (*current_server)->prev;
249
277
new_server->prev->next = new_server;
252
280
return true;
253
281
}
254
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
255
335
/*
256
336
* Initialize GPGME.
257
337
*/
258
static bool init_gpgme(const char *seckey, const char *pubkey,
259
const char *tempdir, mandos_context *mc){
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){
260
343
gpgme_error_t rc;
261
344
gpgme_engine_info_t engine_info;
262
345
263
346
/*
264
347
* Helper function to insert pub and seckey to the engine keyring.
265
348
*/
266
bool import_key(const char *filename){
349
bool import_key(const char * const filename){
267
350
int ret;
268
351
int fd;
269
352
gpgme_data_t pgp_data;
274
357
return false;
275
358
}
276
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
277
410
rc = gpgme_data_new_from_fd(&pgp_data, fd);
278
411
if(rc != GPG_ERR_NO_ERROR){
279
412
fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
287
420
gpgme_strsource(rc), gpgme_strerror(rc));
288
421
return false;
289
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
}
290
498
291
ret = (int)TEMP_FAILURE_RETRY(close(fd));
499
ret = close(fd);
292
500
if(ret == -1){
293
501
perror_plus("close");
294
502
}
333
541
/* Create new GPGME "context" */
334
542
rc = gpgme_new(&(mc->ctx));
335
543
if(rc != GPG_ERR_NO_ERROR){
336
fprintf_plus(stderr, "Mandos plugin mandos-client: "
337
"bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
338
gpgme_strerror(rc));
544
fprintf_plus(stderr, "bad gpgme_new: %s: %s\n",
545
gpgme_strsource(rc), gpgme_strerror(rc));
339
546
return false;
340
547
}
341
548
350
557
* Decrypt OpenPGP data.
351
558
* Returns -1 on error
352
559
*/
560
__attribute__((nonnull, warn_unused_result))
353
561
static ssize_t pgp_packet_decrypt(const char *cryptotext,
354
562
size_t crypto_size,
355
563
char **plaintext,
376
584
/* Create new empty GPGME data buffer for the plaintext */
377
585
rc = gpgme_data_new(&dh_plain);
378
586
if(rc != GPG_ERR_NO_ERROR){
379
fprintf_plus(stderr, "Mandos plugin mandos-client: "
380
"bad gpgme_data_new: %s: %s\n",
587
fprintf_plus(stderr, "bad gpgme_data_new: %s: %s\n",
381
588
gpgme_strsource(rc), gpgme_strerror(rc));
382
589
gpgme_data_release(dh_crypto);
383
590
return -1;
396
603
if(result == NULL){
397
604
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
398
605
} else {
399
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
400
result->unsupported_algorithm);
401
fprintf_plus(stderr, "Wrong key usage: %u\n",
402
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");
403
612
if(result->file_name != NULL){
404
613
fprintf_plus(stderr, "File name: %s\n", result->file_name);
405
614
}
406
gpgme_recipient_t recipient;
407
recipient = result->recipients;
408
while(recipient != NULL){
615
616
for(gpgme_recipient_t r = result->recipients; r != NULL;
617
r = r->next){
409
618
fprintf_plus(stderr, "Public key algorithm: %s\n",
410
gpgme_pubkey_algo_name
411
(recipient->pubkey_algo));
412
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);
413
621
fprintf_plus(stderr, "Secret key available: %s\n",
414
recipient->status == GPG_ERR_NO_SECKEY
415
? "No" : "Yes");
416
recipient = recipient->next;
622
r->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
417
623
}
418
624
}
419
625
}
475
681
return plaintext_length;
476
682
}
477
683
478
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){
479
693
const char *ret = gnutls_strerror(value);
480
if(ret == NULL)
481
ret = "(unknown)";
482
return ret;
694
return safe_string(ret);
483
695
}
484
696
485
697
/* GnuTLS log function callback */
698
__attribute__((nonnull))
486
699
static void debuggnutls(__attribute__((unused)) int level,
487
700
const char* string){
488
701
fprintf_plus(stderr, "GnuTLS: %s", string);
489
702
}
490
703
704
__attribute__((nonnull(1, 2, 4), warn_unused_result))
491
705
static int init_gnutls_global(const char *pubkeyfilename,
492
706
const char *seckeyfilename,
707
const char *dhparamsfilename,
493
708
mandos_context *mc){
494
709
int ret;
495
710
497
712
fprintf_plus(stderr, "Initializing GnuTLS\n");
498
713
}
499
714
500
ret = gnutls_global_init();
501
if(ret != GNUTLS_E_SUCCESS){
502
fprintf_plus(stderr, "GnuTLS global_init: %s\n",
503
safer_gnutls_strerror(ret));
504
return -1;
505
}
506
507
715
if(debug){
508
716
/* "Use a log level over 10 to enable all debugging options."
509
717
* - GnuTLS manual
517
725
if(ret != GNUTLS_E_SUCCESS){
518
726
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
519
727
safer_gnutls_strerror(ret));
520
gnutls_global_deinit();
521
728
return -1;
522
729
}
523
730
524
731
if(debug){
525
fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
526
" 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",
527
734
pubkeyfilename,
528
735
seckeyfilename);
529
736
}
530
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
531
751
ret = gnutls_certificate_set_openpgp_key_file
532
752
(mc->cred, pubkeyfilename, seckeyfilename,
533
753
GNUTLS_OPENPGP_FMT_BASE64);
754
#else
755
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
756
#endif
534
757
if(ret != GNUTLS_E_SUCCESS){
535
758
fprintf_plus(stderr,
536
"Error[%d] while reading the OpenPGP key pair ('%s',"
759
"Error[%d] while reading the key pair ('%s',"
537
760
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
538
761
fprintf_plus(stderr, "The GnuTLS error is: %s\n",
539
762
safer_gnutls_strerror(ret));
548
771
safer_gnutls_strerror(ret));
549
772
goto globalfail;
550
773
}
551
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
552
if(ret != GNUTLS_E_SUCCESS){
553
fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
554
safer_gnutls_strerror(ret));
555
goto globalfail;
556
}
557
558
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
}
559
956
560
957
return 0;
561
958
562
959
globalfail:
563
960
564
961
gnutls_certificate_free_credentials(mc->cred);
565
gnutls_global_deinit();
566
962
gnutls_dh_params_deinit(mc->dh_params);
567
963
return -1;
568
964
}
569
965
966
__attribute__((nonnull, warn_unused_result))
570
967
static int init_gnutls_session(gnutls_session_t *session,
571
968
mandos_context *mc){
572
969
int ret;
573
970
/* GnuTLS session creation */
574
971
do {
575
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
));
576
980
if(quit_now){
577
981
return -1;
578
982
}
619
1023
/* ignore client certificate if any. */
620
1024
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
621
1025
622
gnutls_dh_set_prime_bits(*session, mc->dh_bits);
623
624
1026
return 0;
625
1027
}
626
1028
628
1030
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
629
1031
__attribute__((unused)) const char *txt){}
630
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
631
1206
/* Called when a Mandos server is found */
1207
__attribute__((nonnull, warn_unused_result))
632
1208
static int start_mandos_communication(const char *ip, in_port_t port,
633
1209
AvahiIfIndex if_index,
634
1210
int af, mandos_context *mc){
643
1219
int retval = -1;
644
1220
gnutls_session_t session;
645
1221
int pf; /* Protocol family */
1222
bool route_added = false;
646
1223
647
1224
errno = 0;
648
1225
670
1247
bool match = false;
671
1248
{
672
1249
char *interface = NULL;
673
while((interface=argz_next(mc->interfaces, mc->interfaces_size,
674
interface))){
1250
while((interface = argz_next(mc->interfaces,
1251
mc->interfaces_size,
1252
interface))){
675
1253
if(if_nametoindex(interface) == (unsigned int)if_index){
676
1254
match = true;
677
1255
break;
706
1284
PRIuMAX "\n", ip, (uintmax_t)port);
707
1285
}
708
1286
709
tcp_sd = socket(pf, SOCK_STREAM, 0);
1287
tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
710
1288
if(tcp_sd < 0){
711
1289
int e = errno;
712
1290
perror_plus("socket");
719
1297
goto mandos_end;
720
1298
}
721
1299
722
memset(&to, 0, sizeof(to));
723
1300
if(af == AF_INET6){
724
((struct sockaddr_in6 *)&to)->sin6_family = (sa_family_t)af;
725
ret = inet_pton(af, ip, &((struct sockaddr_in6 *)&to)->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);
726
1304
} else { /* IPv4 */
727
((struct sockaddr_in *)&to)->sin_family = (sa_family_t)af;
728
ret = inet_pton(af, ip, &((struct sockaddr_in *)&to)->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);
729
1308
}
730
1309
if(ret < 0 ){
731
1310
int e = errno;
740
1319
goto mandos_end;
741
1320
}
742
1321
if(af == AF_INET6){
743
((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
1322
((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
744
1323
if(IN6_IS_ADDR_LINKLOCAL
745
1324
(&((struct sockaddr_in6 *)&to)->sin6_addr)){
746
1325
if(if_index == AVAHI_IF_UNSPEC){
801
1380
goto mandos_end;
802
1381
}
803
1382
804
if(af == AF_INET6){
805
ret = connect(tcp_sd, (struct sockaddr *)&to,
806
sizeof(struct sockaddr_in6));
807
} else {
808
ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
809
sizeof(struct sockaddr_in));
810
}
811
if(ret < 0){
812
if((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
813
int e = errno;
814
perror_plus("connect");
815
errno = e;
816
}
817
goto mandos_end;
818
}
819
820
if(quit_now){
821
errno = EINTR;
822
goto mandos_end;
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;
823
1438
}
824
1439
825
1440
const char *out = mandos_protocol_version;
979
1594
&decrypted_buffer, mc);
980
1595
if(decrypted_buffer_size >= 0){
981
1596
1597
clearerr(stdout);
982
1598
written = 0;
983
1599
while(written < (size_t) decrypted_buffer_size){
984
1600
if(quit_now){
1000
1616
}
1001
1617
written += (size_t)ret;
1002
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
}
1003
1629
retval = 0;
1004
1630
}
1005
1631
}
1008
1634
1009
1635
mandos_end:
1010
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
}
1011
1643
int e = errno;
1012
1644
free(decrypted_buffer);
1013
1645
free(buffer);
1014
1646
if(tcp_sd >= 0){
1015
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
1647
ret = close(tcp_sd);
1016
1648
}
1017
1649
if(ret == -1){
1018
1650
if(e == 0){
1043
1675
AVAHI_GCC_UNUSED AvahiStringList *txt,
1044
1676
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1045
1677
flags,
1046
void* mc){
1678
void *mc){
1047
1679
if(r == NULL){
1048
1680
return;
1049
1681
}
1052
1684
timed out */
1053
1685
1054
1686
if(quit_now){
1687
avahi_s_service_resolver_free(r);
1055
1688
return;
1056
1689
}
1057
1690
1102
1735
const char *domain,
1103
1736
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1104
1737
flags,
1105
void* mc){
1738
void *mc){
1106
1739
if(b == NULL){
1107
1740
return;
1108
1741
}
1168
1801
errno = old_errno;
1169
1802
}
1170
1803
1804
__attribute__((nonnull, warn_unused_result))
1171
1805
bool get_flags(const char *ifname, struct ifreq *ifr){
1172
1806
int ret;
1173
error_t ret_errno;
1807
int old_errno;
1174
1808
1175
1809
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1176
1810
if(s < 0){
1177
ret_errno = errno;
1811
old_errno = errno;
1178
1812
perror_plus("socket");
1179
errno = ret_errno;
1813
errno = old_errno;
1180
1814
return false;
1181
1815
}
1182
strcpy(ifr->ifr_name, ifname);
1816
strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
1817
ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
1183
1818
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1184
1819
if(ret == -1){
1185
1820
if(debug){
1186
ret_errno = errno;
1821
old_errno = errno;
1187
1822
perror_plus("ioctl SIOCGIFFLAGS");
1188
errno = ret_errno;
1823
errno = old_errno;
1824
}
1825
if((close(s) == -1) and debug){
1826
old_errno = errno;
1827
perror_plus("close");
1828
errno = old_errno;
1189
1829
}
1190
1830
return false;
1191
1831
}
1832
if((close(s) == -1) and debug){
1833
old_errno = errno;
1834
perror_plus("close");
1835
errno = old_errno;
1836
}
1192
1837
return true;
1193
1838
}
1194
1839
1840
__attribute__((nonnull, warn_unused_result))
1195
1841
bool good_flags(const char *ifname, const struct ifreq *ifr){
1196
1842
1197
1843
/* Reject the loopback device */
1239
1885
* corresponds to an acceptable network device.
1240
1886
* (This function is passed to scandir(3) as a filter function.)
1241
1887
*/
1888
__attribute__((nonnull, warn_unused_result))
1242
1889
int good_interface(const struct dirent *if_entry){
1243
1890
if(if_entry->d_name[0] == '.'){
1244
1891
return 0;
1262
1909
/*
1263
1910
* This function determines if a network interface is up.
1264
1911
*/
1912
__attribute__((nonnull, warn_unused_result))
1265
1913
bool interface_is_up(const char *interface){
1266
1914
struct ifreq ifr;
1267
1915
if(not get_flags(interface, &ifr)){
1278
1926
/*
1279
1927
* This function determines if a network interface is running
1280
1928
*/
1929
__attribute__((nonnull, warn_unused_result))
1281
1930
bool interface_is_running(const char *interface){
1282
1931
struct ifreq ifr;
1283
1932
if(not get_flags(interface, &ifr)){
1291
1940
return (bool)(ifr.ifr_flags & IFF_RUNNING);
1292
1941
}
1293
1942
1943
__attribute__((nonnull, pure, warn_unused_result))
1294
1944
int notdotentries(const struct dirent *direntry){
1295
1945
/* Skip "." and ".." */
1296
1946
if(direntry->d_name[0] == '.'
1303
1953
}
1304
1954
1305
1955
/* Is this directory entry a runnable program? */
1956
__attribute__((nonnull, warn_unused_result))
1306
1957
int runnable_hook(const struct dirent *direntry){
1307
1958
int ret;
1308
1959
size_t sret;
1316
1967
sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1317
1968
"abcdefghijklmnopqrstuvwxyz"
1318
1969
"0123456789"
1319
"_-");
1970
"_.-");
1320
1971
if((direntry->d_name)[sret] != '\0'){
1321
1972
/* Contains non-allowed characters */
1322
1973
if(debug){
1326
1977
return 0;
1327
1978
}
1328
1979
1329
char *fullname = NULL;
1330
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1331
if(ret < 0){
1332
perror_plus("asprintf");
1333
return 0;
1334
}
1335
1336
ret = stat(fullname, &st);
1980
ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1337
1981
if(ret == -1){
1338
1982
if(debug){
1339
1983
perror_plus("Could not stat hook");
1363
2007
return 1;
1364
2008
}
1365
2009
2010
__attribute__((nonnull, warn_unused_result))
1366
2011
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
1367
2012
mandos_context *mc){
1368
2013
int ret;
1436
2081
}
1437
2082
}
1438
2083
1439
/* Set effective uid to 0, return errno */
1440
error_t raise_privileges(void){
1441
error_t old_errno = errno;
1442
error_t ret_errno = 0;
1443
if(seteuid(0) == -1){
1444
ret_errno = errno;
1445
perror_plus("seteuid");
1446
}
1447
errno = old_errno;
1448
return ret_errno;
1449
}
1450
1451
/* Set effective and real user ID to 0. Return errno. */
1452
error_t raise_privileges_permanently(void){
1453
error_t old_errno = errno;
1454
error_t ret_errno = raise_privileges();
1455
if(ret_errno != 0){
1456
errno = old_errno;
1457
return ret_errno;
1458
}
1459
if(setuid(0) == -1){
1460
ret_errno = errno;
1461
perror_plus("seteuid");
1462
}
1463
errno = old_errno;
1464
return ret_errno;
1465
}
1466
1467
/* Set effective user ID to unprivileged saved user ID */
1468
error_t lower_privileges(void){
1469
error_t old_errno = errno;
1470
error_t ret_errno = 0;
1471
if(seteuid(uid) == -1){
1472
ret_errno = errno;
1473
perror_plus("seteuid");
1474
}
1475
errno = old_errno;
1476
return ret_errno;
1477
}
1478
1479
/* Lower privileges permanently */
1480
error_t lower_privileges_permanently(void){
1481
error_t old_errno = errno;
1482
error_t ret_errno = 0;
1483
if(setuid(uid) == -1){
1484
ret_errno = errno;
1485
perror_plus("setuid");
1486
}
1487
errno = old_errno;
1488
return ret_errno;
1489
}
1490
1491
bool run_network_hooks(const char *mode, const char *interface,
2084
__attribute__((nonnull))
2085
void run_network_hooks(const char *mode, const char *interface,
1492
2086
const float delay){
1493
struct dirent **direntries;
1494
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1495
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);
1496
2110
if(numhooks == -1){
1497
if(errno == ENOENT){
1498
if(debug){
1499
fprintf_plus(stderr, "Network hook directory \"%s\" not"
1500
" found\n", hookdir);
1501
}
1502
} else {
1503
perror_plus("scandir");
2111
perror_plus("scandir");
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);
1504
2122
}
1505
} else {
1506
struct dirent *direntry;
1507
int ret;
1508
int devnull = open("/dev/null", O_RDONLY);
1509
for(int i = 0; i < numhooks; i++){
1510
direntry = direntries[i];
1511
char *fullname = NULL;
1512
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1513
if(ret < 0){
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){
1514
2169
perror_plus("asprintf");
1515
continue;
1516
}
1517
if(debug){
1518
fprintf_plus(stderr, "Running network hook \"%s\"\n",
1519
direntry->d_name);
1520
}
1521
pid_t hook_pid = fork();
1522
if(hook_pid == 0){
1523
/* Child */
1524
/* Raise privileges */
1525
raise_privileges_permanently();
1526
/* Set group */
1527
errno = 0;
1528
ret = setgid(0);
1529
if(ret == -1){
1530
perror_plus("setgid");
1531
}
1532
/* Reset supplementary groups */
1533
errno = 0;
1534
ret = setgroups(0, NULL);
1535
if(ret == -1){
1536
perror_plus("setgroups");
1537
}
1538
dup2(devnull, STDIN_FILENO);
1539
close(devnull);
1540
dup2(STDERR_FILENO, STDOUT_FILENO);
1541
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1542
if(ret == -1){
1543
perror_plus("setenv");
1544
_exit(EX_OSERR);
1545
}
1546
ret = setenv("DEVICE", interface, 1);
1547
if(ret == -1){
1548
perror_plus("setenv");
1549
_exit(EX_OSERR);
1550
}
1551
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
1552
if(ret == -1){
1553
perror_plus("setenv");
1554
_exit(EX_OSERR);
1555
}
1556
ret = setenv("MODE", mode, 1);
1557
if(ret == -1){
1558
perror_plus("setenv");
1559
_exit(EX_OSERR);
1560
}
1561
char *delaystring;
1562
ret = asprintf(&delaystring, "%f", delay);
1563
if(ret == -1){
1564
perror_plus("asprintf");
1565
_exit(EX_OSERR);
1566
}
1567
ret = setenv("DELAY", delaystring, 1);
1568
if(ret == -1){
1569
free(delaystring);
1570
perror_plus("setenv");
1571
_exit(EX_OSERR);
1572
}
2170
_exit(EX_OSERR);
2171
}
2172
ret = setenv("DELAY", delaystring, 1);
2173
if(ret == -1){
1573
2174
free(delaystring);
1574
if(connect_to != NULL){
1575
ret = setenv("CONNECT", connect_to, 1);
1576
if(ret == -1){
1577
perror_plus("setenv");
1578
_exit(EX_OSERR);
1579
}
1580
}
1581
if(execl(fullname, direntry->d_name, mode, NULL) == -1){
1582
perror_plus("execl");
1583
_exit(EXIT_FAILURE);
1584
}
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;
1585
2243
} else {
1586
int status;
1587
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1588
perror_plus("waitpid");
1589
free(fullname);
1590
continue;
1591
}
1592
if(WIFEXITED(status)){
1593
if(WEXITSTATUS(status) != 0){
1594
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1595
" with status %d\n", direntry->d_name,
1596
WEXITSTATUS(status));
1597
free(fullname);
1598
continue;
1599
}
1600
} else if(WIFSIGNALED(status)){
1601
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1602
" signal %d\n", direntry->d_name,
1603
WTERMSIG(status));
1604
free(fullname);
1605
continue;
1606
} else {
1607
fprintf_plus(stderr, "Warning: network hook \"%s\""
1608
" crashed\n", direntry->d_name);
1609
free(fullname);
1610
continue;
1611
}
1612
}
1613
free(fullname);
1614
if(debug){
1615
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1616
direntry->d_name);
1617
}
1618
}
1619
close(devnull);
1620
}
1621
return true;
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);
1622
2263
}
1623
2264
1624
error_t bring_up_interface(const char *const interface,
1625
const float delay){
1626
int sd = -1;
1627
error_t old_errno = errno;
1628
error_t ret_errno = 0;
1629
int ret, ret_setflags;
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;
1630
2270
struct ifreq network;
1631
2271
unsigned int if_index = if_nametoindex(interface);
1632
2272
if(if_index == 0){
1641
2281
}
1642
2282
1643
2283
if(not interface_is_up(interface)){
1644
if(not get_flags(interface, &network) and debug){
2284
int ret_errno = 0;
2285
int ioctl_errno = 0;
2286
if(not get_flags(interface, &network)){
1645
2287
ret_errno = errno;
1646
2288
fprintf_plus(stderr, "Failed to get flags for interface "
1647
2289
"\"%s\"\n", interface);
2290
errno = old_errno;
1648
2291
return ret_errno;
1649
2292
}
1650
network.ifr_flags |= IFF_UP;
2293
network.ifr_flags |= IFF_UP; /* set flag */
1651
2294
1652
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1653
if(sd < 0){
2295
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
2296
if(sd == -1){
1654
2297
ret_errno = errno;
1655
2298
perror_plus("socket");
1656
2299
errno = old_errno;
1657
2300
return ret_errno;
1658
2301
}
1659
2302
1660
2303
if(quit_now){
1661
close(sd);
2304
ret = close(sd);
2305
if(ret == -1){
2306
perror_plus("close");
2307
}
1662
2308
errno = old_errno;
1663
2309
return EINTR;
1664
2310
}
1668
2314
interface);
1669
2315
}
1670
2316
1671
/* Raise priviliges */
1672
raise_privileges();
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
}
1673
2323
1674
2324
#ifdef __linux__
1675
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1676
messages about the network interface to mess up the prompt */
1677
int ret_linux = klogctl(8, NULL, 5);
1678
bool restore_loglevel = true;
1679
if(ret_linux == -1){
1680
restore_loglevel = false;
1681
perror_plus("klogctl");
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
}
1682
2336
}
1683
2337
#endif /* __linux__ */
1684
ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1685
ret_errno = errno;
2338
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
2339
ioctl_errno = errno;
1686
2340
#ifdef __linux__
1687
2341
if(restore_loglevel){
1688
2342
ret_linux = klogctl(7, NULL, 0);
1692
2346
}
1693
2347
#endif /* __linux__ */
1694
2348
1695
/* Lower privileges */
1696
lower_privileges();
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
}
1697
2358
1698
2359
/* Close the socket */
1699
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2360
ret = close(sd);
1700
2361
if(ret == -1){
1701
2362
perror_plus("close");
1702
2363
}
1703
2364
1704
2365
if(ret_setflags == -1){
1705
errno = ret_errno;
2366
errno = ioctl_errno;
1706
2367
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1707
2368
errno = old_errno;
1708
return ret_errno;
2369
return ioctl_errno;
1709
2370
}
1710
2371
} else if(debug){
1711
2372
fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
1714
2375
1715
2376
/* Sleep checking until interface is running.
1716
2377
Check every 0.25s, up to total time of delay */
1717
for(int i=0; i < delay * 4; i++){
2378
for(int i = 0; i < delay * 4; i++){
1718
2379
if(interface_is_running(interface)){
1719
2380
break;
1720
2381
}
1729
2390
return 0;
1730
2391
}
1731
2392
1732
error_t take_down_interface(const char *const interface){
1733
error_t old_errno = errno;
2393
__attribute__((nonnull, warn_unused_result))
2394
int take_down_interface(const char *const interface){
2395
int old_errno = errno;
1734
2396
struct ifreq network;
1735
2397
unsigned int if_index = if_nametoindex(interface);
1736
2398
if(if_index == 0){
1739
2401
return ENXIO;
1740
2402
}
1741
2403
if(interface_is_up(interface)){
1742
error_t ret_errno = 0;
2404
int ret_errno = 0;
2405
int ioctl_errno = 0;
1743
2406
if(not get_flags(interface, &network) and debug){
1744
2407
ret_errno = errno;
1745
2408
fprintf_plus(stderr, "Failed to get flags for interface "
1746
2409
"\"%s\"\n", interface);
2410
errno = old_errno;
1747
2411
return ret_errno;
1748
2412
}
1749
2413
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
1750
2414
1751
2415
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1752
if(sd < 0){
2416
if(sd == -1){
1753
2417
ret_errno = errno;
1754
2418
perror_plus("socket");
1755
2419
errno = old_errno;
1761
2425
interface);
1762
2426
}
1763
2427
1764
/* Raise priviliges */
1765
raise_privileges();
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
}
1766
2434
1767
2435
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1768
ret_errno = errno;
2436
ioctl_errno = errno;
1769
2437
1770
/* Lower privileges */
1771
lower_privileges();
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
}
1772
2447
1773
2448
/* Close the socket */
1774
int ret = (int)TEMP_FAILURE_RETRY(close(sd));
2449
int ret = close(sd);
1775
2450
if(ret == -1){
1776
2451
perror_plus("close");
1777
2452
}
1778
2453
1779
2454
if(ret_setflags == -1){
1780
errno = ret_errno;
2455
errno = ioctl_errno;
1781
2456
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
1782
2457
errno = old_errno;
1783
return ret_errno;
2458
return ioctl_errno;
1784
2459
}
1785
2460
} else if(debug){
1786
2461
fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
1792
2467
}
1793
2468
1794
2469
int main(int argc, char *argv[]){
1795
mandos_context mc = { .server = NULL, .dh_bits = 1024,
1796
.priority = "SECURE256:!CTYPE-X.509:"
1797
"+CTYPE-OPENPGP", .current_server = NULL,
1798
.interfaces = NULL, .interfaces_size = 0 };
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 };
1799
2483
AvahiSServiceBrowser *sb = NULL;
1800
2484
error_t ret_errno;
1801
2485
int ret;
1804
2488
int exitcode = EXIT_SUCCESS;
1805
2489
char *interfaces_to_take_down = NULL;
1806
2490
size_t interfaces_to_take_down_size = 0;
1807
char tempdir[] = "/tmp/mandosXXXXXX";
1808
bool tempdir_created = false;
2491
char run_tempdir[] = "/run/tmp/mandosXXXXXX";
2492
char old_tempdir[] = "/tmp/mandosXXXXXX";
2493
char *tempdir = NULL;
1809
2494
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1810
2495
const char *seckey = PATHDIR "/" SECKEY;
1811
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;
1812
2502
char *interfaces_hooks = NULL;
1813
2503
1814
2504
bool gnutls_initialized = false;
1861
2551
{ .name = "pubkey", .key = 'p',
1862
2552
.arg = "FILE",
1863
2553
.doc = "OpenPGP public key file base name",
1864
.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 },
1865
2571
{ .name = "dh-bits", .key = 129,
1866
2572
.arg = "BITS",
1867
2573
.doc = "Bit length of the prime number used in the"
1868
2574
" Diffie-Hellman key exchange",
1869
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 },
1870
2581
{ .name = "priority", .key = 130,
1871
2582
.arg = "STRING",
1872
2583
.doc = "GnuTLS priority string for the TLS handshake",
1918
2629
case 'p': /* --pubkey */
1919
2630
pubkey = arg;
1920
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;
1921
2642
case 129: /* --dh-bits */
1922
2643
errno = 0;
1923
2644
tmpmax = strtoimax(arg, &tmp, 10);
1927
2648
}
1928
2649
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
1929
2650
break;
2651
case 134: /* --dh-params */
2652
dh_params_file = arg;
2653
break;
1930
2654
case 130: /* --priority */
1931
2655
mc.priority = arg;
1932
2656
break;
1955
2679
argp_state_help(state, state->out_stream,
1956
2680
(ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
1957
2681
& ~(unsigned int)ARGP_HELP_EXIT_OK);
2682
__builtin_unreachable();
1958
2683
case -3: /* --usage */
1959
2684
argp_state_help(state, state->out_stream,
1960
2685
ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
2686
__builtin_unreachable();
1961
2687
case 'V': /* --version */
1962
2688
fprintf_plus(state->out_stream, "%s\n", argp_program_version);
1963
2689
exit(argp_err_exit_status);
1972
2698
.args_doc = "",
1973
2699
.doc = "Mandos client -- Get and decrypt"
1974
2700
" passwords from a Mandos server" };
1975
ret = argp_parse(&argp, argc, argv,
1976
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
1977
switch(ret){
2701
ret_errno = argp_parse(&argp, argc, argv,
2702
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2703
switch(ret_errno){
1978
2704
case 0:
1979
2705
break;
1980
2706
case ENOMEM:
1981
2707
default:
1982
errno = ret;
2708
errno = ret_errno;
1983
2709
perror_plus("argp_parse");
1984
2710
exitcode = EX_OSERR;
1985
2711
goto end;
1988
2714
goto end;
1989
2715
}
1990
2716
}
1991
2717
1992
2718
{
1993
2719
/* Work around Debian bug #633582:
1994
<http://bugs.debian.org/633582> */
2720
<https://bugs.debian.org/633582> */
1995
2721
1996
/* Re-raise priviliges */
1997
if(raise_privileges() == 0){
2722
/* Re-raise privileges */
2723
ret = raise_privileges();
2724
if(ret != 0){
2725
errno = ret;
2726
perror_plus("Failed to raise privileges");
2727
} else {
1998
2728
struct stat st;
1999
2729
2000
2730
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
2014
2744
}
2015
2745
}
2016
2746
}
2017
TEMP_FAILURE_RETRY(close(seckey_fd));
2747
close(seckey_fd);
2018
2748
}
2019
2749
}
2020
2750
2021
2751
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2022
2752
int pubkey_fd = open(pubkey, O_RDONLY);
2023
2753
if(pubkey_fd == -1){
2035
2765
}
2036
2766
}
2037
2767
}
2038
TEMP_FAILURE_RETRY(close(pubkey_fd));
2039
}
2040
}
2041
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
2042
2794
/* Lower privileges */
2043
lower_privileges();
2795
ret = lower_privileges();
2796
if(ret != 0){
2797
errno = ret;
2798
perror_plus("Failed to lower privileges");
2799
}
2044
2800
}
2045
2801
}
2046
2802
2072
2828
memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
2073
2829
argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
2074
2830
}
2075
if(not run_network_hooks("start", interfaces_hooks != NULL ?
2076
interfaces_hooks : "", delay)){
2077
goto end;
2078
}
2831
run_network_hooks("start", interfaces_hooks != NULL ?
2832
interfaces_hooks : "", delay);
2079
2833
}
2080
2834
2081
2835
if(not debug){
2159
2913
2160
2914
/* If no interfaces were specified, make a list */
2161
2915
if(mc.interfaces == NULL){
2162
struct dirent **direntries;
2916
struct dirent **direntries = NULL;
2163
2917
/* Look for any good interfaces */
2164
2918
ret = scandir(sys_class_net, &direntries, good_interface,
2165
2919
alphasort);
2171
2925
if(ret_errno != 0){
2172
2926
errno = ret_errno;
2173
2927
perror_plus("argz_add");
2928
free(direntries[i]);
2174
2929
continue;
2175
2930
}
2176
2931
if(debug){
2177
2932
fprintf_plus(stderr, "Will use interface \"%s\"\n",
2178
2933
direntries[i]->d_name);
2179
2934
}
2935
free(direntries[i]);
2180
2936
}
2181
2937
free(direntries);
2182
2938
} else {
2183
free(direntries);
2939
if(ret == 0){
2940
free(direntries);
2941
}
2184
2942
fprintf_plus(stderr, "Could not find a network interface\n");
2185
2943
exitcode = EXIT_FAILURE;
2186
2944
goto end;
2209
2967
break;
2210
2968
}
2211
2969
bool interface_was_up = interface_is_up(interface);
2212
ret = bring_up_interface(interface, delay);
2970
errno = bring_up_interface(interface, delay);
2213
2971
if(not interface_was_up){
2214
if(ret != 0){
2215
errno = ret;
2216
perror_plus("Failed to bring up interface");
2972
if(errno != 0){
2973
fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
2974
" %s\n", interface, strerror(errno));
2217
2975
} else {
2218
ret_errno = argz_add(&interfaces_to_take_down,
2219
&interfaces_to_take_down_size,
2220
interface);
2221
if(ret_errno != 0){
2222
errno = ret_errno;
2976
errno = argz_add(&interfaces_to_take_down,
2977
&interfaces_to_take_down_size,
2978
interface);
2979
if(errno != 0){
2223
2980
perror_plus("argz_add");
2224
2981
}
2225
2982
}
2243
3000
goto end;
2244
3001
}
2245
3002
2246
ret = init_gnutls_global(pubkey, seckey, &mc);
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
2247
3010
if(ret == -1){
2248
3011
fprintf_plus(stderr, "init_gnutls_global failed\n");
2249
3012
exitcode = EX_UNAVAILABLE;
2256
3019
goto end;
2257
3020
}
2258
3021
2259
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){
2260
3032
perror_plus("mkdtemp");
2261
3033
goto end;
2262
3034
}
2263
tempdir_created = true;
2264
3035
2265
3036
if(quit_now){
2266
3037
goto end;
2363
3134
2364
3135
/* Allocate a new server */
2365
3136
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
2366
&config, NULL, NULL, &ret_errno);
3137
&config, NULL, NULL, &ret);
2367
3138
2368
3139
/* Free the Avahi configuration data */
2369
3140
avahi_server_config_free(&config);
2372
3143
/* Check if creating the Avahi server object succeeded */
2373
3144
if(mc.server == NULL){
2374
3145
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2375
avahi_strerror(ret_errno));
3146
avahi_strerror(ret));
2376
3147
exitcode = EX_UNAVAILABLE;
2377
3148
goto end;
2378
3149
}
2402
3173
if(debug){
2403
3174
fprintf_plus(stderr, "Starting Avahi loop search\n");
2404
3175
}
2405
3176
2406
3177
ret = avahi_loop_with_timeout(simple_poll,
2407
3178
(int)(retry_interval * 1000), &mc);
2408
3179
if(debug){
2413
3184
end:
2414
3185
2415
3186
if(debug){
2416
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
}
2417
3194
}
2418
3195
2419
3196
/* Cleanup things */
2430
3207
2431
3208
if(gnutls_initialized){
2432
3209
gnutls_certificate_free_credentials(mc.cred);
2433
gnutls_global_deinit();
2434
3210
gnutls_dh_params_deinit(mc.dh_params);
2435
3211
}
2436
3212
2444
3220
mc.current_server->prev->next = NULL;
2445
3221
while(mc.current_server != NULL){
2446
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
2447
3231
free(mc.current_server);
2448
3232
mc.current_server = next;
2449
3233
}
2450
3234
}
2451
3235
2452
/* Re-raise priviliges */
3236
/* Re-raise privileges */
2453
3237
{
2454
raise_privileges();
2455
2456
/* Run network hooks */
2457
run_network_hooks("stop", interfaces_hooks != NULL ?
2458
interfaces_hooks : "", delay);
2459
2460
/* Take down the network interfaces which were brought up */
2461
{
2462
char *interface = NULL;
2463
while((interface=argz_next(interfaces_to_take_down,
2464
interfaces_to_take_down_size,
2465
interface))){
2466
ret_errno = take_down_interface(interface);
2467
if(ret_errno != 0){
2468
errno = ret_errno;
2469
perror_plus("Failed to take down interface");
2470
}
2471
}
2472
if(debug and (interfaces_to_take_down == NULL)){
2473
fprintf_plus(stderr, "No interfaces needed to be taken"
2474
" down\n");
2475
}
2476
}
2477
2478
lower_privileges_permanently();
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
}
3265
}
3266
3267
ret = lower_privileges_permanently();
3268
if(ret != 0){
3269
errno = ret;
3270
perror_plus("Failed to lower privileges permanently");
3271
}
2479
3272
}
2480
3273
2481
3274
free(interfaces_to_take_down);
2482
3275
free(interfaces_hooks);
2483
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);
3329
}
3330
2484
3331
/* Removes the GPGME temp directory and all files inside */
2485
if(tempdir_created){
2486
struct dirent **direntries = NULL;
2487
struct dirent *direntry = NULL;
2488
int numentries = scandir(tempdir, &direntries, notdotentries,
2489
alphasort);
2490
if(numentries > 0){
2491
for(int i = 0; i < numentries; i++){
2492
direntry = direntries[i];
2493
char *fullname = NULL;
2494
ret = asprintf(&fullname, "%s/%s", tempdir,
2495
direntry->d_name);
2496
if(ret < 0){
2497
perror_plus("asprintf");
2498
continue;
2499
}
2500
ret = remove(fullname);
2501
if(ret == -1){
2502
fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2503
strerror(errno));
2504
}
2505
free(fullname);
2506
}
2507
}
2508
2509
/* need to clean even if 0 because man page doesn't specify */
2510
free(direntries);
2511
if(numentries == -1){
2512
perror_plus("scandir");
2513
}
2514
ret = rmdir(tempdir);
2515
if(ret == -1 and errno != ENOENT){
2516
perror_plus("rmdir");
2517
}
3332
if(tempdir != NULL){
3333
clean_dir_at(-1, tempdir, 0);
2518
3334
}
2519
3335
2520
3336
if(quit_now){
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0