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 541
- compare with another revision
- download diff
- download tarball
- view history from revision 541
- Committer: Teddy Hogeborn
- Date: 2011-12-31 20:07:11 UTC
- mfrom: (535.1.9 wireless-network-hook)
- Revision ID: teddy@recompile.se-20111231200711-6dli3r8drftem57r
Merge new wireless network hook. Fix bridge network hook to use
hardware addresses instead of interface names. Implement and document
new "CONNECT" environment variable for network hooks.
hardware addresses instead of interface names. Implement and document
new "CONNECT" environment variable for network hooks.
- files removed:
- bugs.xml
- debian/upstream
- plugin-helpers
- 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-2017 Teddy Hogeborn
13
* Copyright © 2008-2017 Björn Påhlsson
12
* Copyright © 2008-2011 Teddy Hogeborn
13
* Copyright © 2008-2011 Björn Påhlsson
14
14
*
15
15
* This program is free software: you can redistribute it and/or
16
16
* modify it under the terms of the GNU General Public License as
32
32
/* Needed by GPGME, specifically gpgme_data_seek() */
33
33
#ifndef _LARGEFILE_SOURCE
34
34
#define _LARGEFILE_SOURCE
35
#endif /* not _LARGEFILE_SOURCE */
35
#endif
36
36
#ifndef _FILE_OFFSET_BITS
37
37
#define _FILE_OFFSET_BITS 64
38
#endif /* not _FILE_OFFSET_BITS */
38
#endif
39
39
40
40
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
41
41
42
42
#include <stdio.h> /* fprintf(), stderr, fwrite(),
43
stdout, ferror() */
44
#include <stdint.h> /* uint16_t, uint32_t, intptr_t */
43
stdout, ferror(), remove() */
44
#include <stdint.h> /* uint16_t, uint32_t */
45
45
#include <stddef.h> /* NULL, size_t, ssize_t */
46
46
#include <stdlib.h> /* free(), EXIT_SUCCESS, srand(),
47
47
strtof(), abort() */
48
48
#include <stdbool.h> /* bool, false, true */
49
#include <string.h> /* strcmp(), strlen(), strerror(),
50
asprintf(), strncpy(), strsignal()
51
*/
49
#include <string.h> /* memset(), strcmp(), strlen(),
50
strerror(), asprintf(), strcpy() */
52
51
#include <sys/ioctl.h> /* ioctl */
53
52
#include <sys/types.h> /* socket(), inet_pton(), sockaddr,
54
53
sockaddr_in6, PF_INET6,
56
55
opendir(), DIR */
57
56
#include <sys/stat.h> /* open(), S_ISREG */
58
57
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
59
inet_pton(), connect(),
60
getnameinfo() */
61
#include <fcntl.h> /* open(), unlinkat(), AT_REMOVEDIR */
58
inet_pton(), connect() */
59
#include <fcntl.h> /* open() */
62
60
#include <dirent.h> /* opendir(), struct dirent, readdir()
63
61
*/
64
62
#include <inttypes.h> /* PRIu16, PRIdMAX, intmax_t,
65
63
strtoimax() */
66
#include <errno.h> /* perror(), errno, EINTR, EINVAL,
67
EAI_SYSTEM, ENETUNREACH,
68
EHOSTUNREACH, ECONNREFUSED, EPROTO,
69
EIO, ENOENT, ENXIO, ENOMEM, EISDIR,
70
ENOTEMPTY,
64
#include <assert.h> /* assert() */
65
#include <errno.h> /* perror(), errno,
71
66
program_invocation_short_name */
72
67
#include <time.h> /* nanosleep(), time(), sleep() */
73
68
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
78
73
*/
79
74
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
80
75
getuid(), getgid(), seteuid(),
81
setgid(), pause(), _exit(),
82
unlinkat() */
83
#include <arpa/inet.h> /* inet_pton(), htons() */
76
setgid(), pause(), _exit() */
77
#include <arpa/inet.h> /* inet_pton(), htons, inet_ntop() */
84
78
#include <iso646.h> /* not, or, and */
85
79
#include <argp.h> /* struct argp_option, error_t, struct
86
80
argp_state, struct argp,
94
88
#include <sys/wait.h> /* waitpid(), WIFEXITED(),
95
89
WEXITSTATUS(), WTERMSIG() */
96
90
#include <grp.h> /* setgroups() */
97
#include <argz.h> /* argz_add_sep(), argz_next(),
98
argz_delete(), argz_append(),
99
argz_stringify(), argz_add(),
100
argz_count() */
101
#include <netdb.h> /* getnameinfo(), NI_NUMERICHOST,
102
EAI_SYSTEM, gai_strerror() */
103
91
104
92
#ifdef __linux__
105
93
#include <sys/klog.h> /* klogctl() */
147
135
static const char sys_class_net[] = "/sys/class/net";
148
136
char *connect_to = NULL;
149
137
const char *hookdir = HOOKDIR;
150
int hookdir_fd = -1;
151
uid_t uid = 65534;
152
gid_t gid = 65534;
153
138
154
139
/* Doubly linked list that need to be circularly linked when used */
155
140
typedef struct server{
156
141
const char *ip;
157
in_port_t port;
142
uint16_t port;
158
143
AvahiIfIndex if_index;
159
144
int af;
160
145
struct timespec last_seen;
164
149
165
150
/* Used for passing in values through the Avahi callback functions */
166
151
typedef struct {
152
AvahiSimplePoll *simple_poll;
167
153
AvahiServer *server;
168
154
gnutls_certificate_credentials_t cred;
169
155
unsigned int dh_bits;
171
157
const char *priority;
172
158
gpgme_ctx_t ctx;
173
159
server *current_server;
174
char *interfaces;
175
size_t interfaces_size;
176
160
} mandos_context;
177
161
178
/* global so signal handler can reach it*/
179
AvahiSimplePoll *simple_poll;
162
/* global context so signal handler can reach it*/
163
mandos_context mc = { .simple_poll = NULL, .server = NULL,
164
.dh_bits = 1024, .priority = "SECURE256"
165
":!CTYPE-X.509:+CTYPE-OPENPGP",
166
.current_server = NULL };
180
167
181
168
sig_atomic_t quit_now = 0;
182
169
int signal_received = 0;
190
177
perror(print_text);
191
178
}
192
179
193
__attribute__((format (gnu_printf, 2, 3), nonnull))
180
__attribute__((format (gnu_printf, 2, 3)))
194
181
int fprintf_plus(FILE *stream, const char *format, ...){
195
182
va_list ap;
196
183
va_start (ap, format);
197
184
198
185
TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
199
186
program_invocation_short_name));
200
return (int)TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
187
return TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
201
188
}
202
189
203
190
/*
205
192
* bytes. "buffer_capacity" is how much is currently allocated,
206
193
* "buffer_length" is how much is already used.
207
194
*/
208
__attribute__((nonnull, warn_unused_result))
209
195
size_t incbuffer(char **buffer, size_t buffer_length,
210
196
size_t buffer_capacity){
211
197
if(buffer_length + BUFFER_SIZE > buffer_capacity){
212
char *new_buf = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
213
if(new_buf == NULL){
214
int old_errno = errno;
215
free(*buffer);
216
errno = old_errno;
217
*buffer = NULL;
198
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
199
if(buffer == NULL){
218
200
return 0;
219
201
}
220
*buffer = new_buf;
221
202
buffer_capacity += BUFFER_SIZE;
222
203
}
223
204
return buffer_capacity;
224
205
}
225
206
226
207
/* Add server to set of servers to retry periodically */
227
__attribute__((nonnull, warn_unused_result))
228
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
229
int af, server **current_server){
208
bool add_server(const char *ip, uint16_t port, AvahiIfIndex if_index,
209
int af){
230
210
int ret;
231
211
server *new_server = malloc(sizeof(server));
232
212
if(new_server == NULL){
239
219
.af = af };
240
220
if(new_server->ip == NULL){
241
221
perror_plus("strdup");
242
free(new_server);
243
return false;
244
}
245
ret = clock_gettime(CLOCK_MONOTONIC, &(new_server->last_seen));
246
if(ret == -1){
247
perror_plus("clock_gettime");
248
#ifdef __GNUC__
249
#pragma GCC diagnostic push
250
#pragma GCC diagnostic ignored "-Wcast-qual"
251
#endif
252
free((char *)(new_server->ip));
253
#ifdef __GNUC__
254
#pragma GCC diagnostic pop
255
#endif
256
free(new_server);
257
222
return false;
258
223
}
259
224
/* Special case of first server */
260
if(*current_server == NULL){
225
if (mc.current_server == NULL){
261
226
new_server->next = new_server;
262
227
new_server->prev = new_server;
263
*current_server = new_server;
228
mc.current_server = new_server;
229
/* Place the new server last in the list */
264
230
} else {
265
/* Place the new server last in the list */
266
new_server->next = *current_server;
267
new_server->prev = (*current_server)->prev;
231
new_server->next = mc.current_server;
232
new_server->prev = mc.current_server->prev;
268
233
new_server->prev->next = new_server;
269
(*current_server)->prev = new_server;
234
mc.current_server->prev = new_server;
235
}
236
ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);
237
if(ret == -1){
238
perror_plus("clock_gettime");
239
return false;
270
240
}
271
241
return true;
272
242
}
274
244
/*
275
245
* Initialize GPGME.
276
246
*/
277
__attribute__((nonnull, warn_unused_result))
278
static bool init_gpgme(const char * const seckey,
279
const char * const pubkey,
280
const char * const tempdir,
281
mandos_context *mc){
247
static bool init_gpgme(const char *seckey, const char *pubkey,
248
const char *tempdir){
282
249
gpgme_error_t rc;
283
250
gpgme_engine_info_t engine_info;
284
251
252
285
253
/*
286
254
* Helper function to insert pub and seckey to the engine keyring.
287
255
*/
288
bool import_key(const char * const filename){
256
bool import_key(const char *filename){
289
257
int ret;
290
258
int fd;
291
259
gpgme_data_t pgp_data;
303
271
return false;
304
272
}
305
273
306
rc = gpgme_op_import(mc->ctx, pgp_data);
274
rc = gpgme_op_import(mc.ctx, pgp_data);
307
275
if(rc != GPG_ERR_NO_ERROR){
308
276
fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
309
277
gpgme_strsource(rc), gpgme_strerror(rc));
310
278
return false;
311
279
}
312
280
313
ret = close(fd);
281
ret = (int)TEMP_FAILURE_RETRY(close(fd));
314
282
if(ret == -1){
315
283
perror_plus("close");
316
284
}
353
321
}
354
322
355
323
/* Create new GPGME "context" */
356
rc = gpgme_new(&(mc->ctx));
324
rc = gpgme_new(&(mc.ctx));
357
325
if(rc != GPG_ERR_NO_ERROR){
358
326
fprintf_plus(stderr, "Mandos plugin mandos-client: "
359
327
"bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
372
340
* Decrypt OpenPGP data.
373
341
* Returns -1 on error
374
342
*/
375
__attribute__((nonnull, warn_unused_result))
376
343
static ssize_t pgp_packet_decrypt(const char *cryptotext,
377
344
size_t crypto_size,
378
char **plaintext,
379
mandos_context *mc){
345
char **plaintext){
380
346
gpgme_data_t dh_crypto, dh_plain;
381
347
gpgme_error_t rc;
382
348
ssize_t ret;
408
374
409
375
/* Decrypt data from the cryptotext data buffer to the plaintext
410
376
data buffer */
411
rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
377
rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
412
378
if(rc != GPG_ERR_NO_ERROR){
413
379
fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
414
380
gpgme_strsource(rc), gpgme_strerror(rc));
415
381
plaintext_length = -1;
416
382
if(debug){
417
383
gpgme_decrypt_result_t result;
418
result = gpgme_op_decrypt_result(mc->ctx);
384
result = gpgme_op_decrypt_result(mc.ctx);
419
385
if(result == NULL){
420
386
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
421
387
} else {
498
464
return plaintext_length;
499
465
}
500
466
501
__attribute__((warn_unused_result, const))
502
static const char *safe_string(const char *str){
503
if(str == NULL)
504
return "(unknown)";
505
return str;
506
}
507
508
__attribute__((warn_unused_result))
509
static const char *safer_gnutls_strerror(int value){
510
const char *ret = gnutls_strerror(value);
511
return safe_string(ret);
467
static const char * safer_gnutls_strerror(int value){
468
const char *ret = gnutls_strerror(value); /* Spurious warning from
469
-Wunreachable-code */
470
if(ret == NULL)
471
ret = "(unknown)";
472
return ret;
512
473
}
513
474
514
475
/* GnuTLS log function callback */
515
__attribute__((nonnull))
516
476
static void debuggnutls(__attribute__((unused)) int level,
517
477
const char* string){
518
478
fprintf_plus(stderr, "GnuTLS: %s", string);
519
479
}
520
480
521
__attribute__((nonnull(1, 2, 4), warn_unused_result))
522
481
static int init_gnutls_global(const char *pubkeyfilename,
523
const char *seckeyfilename,
524
const char *dhparamsfilename,
525
mandos_context *mc){
482
const char *seckeyfilename){
526
483
int ret;
527
unsigned int uret;
528
484
529
485
if(debug){
530
486
fprintf_plus(stderr, "Initializing GnuTLS\n");
531
487
}
532
488
489
ret = gnutls_global_init();
490
if(ret != GNUTLS_E_SUCCESS){
491
fprintf_plus(stderr, "GnuTLS global_init: %s\n",
492
safer_gnutls_strerror(ret));
493
return -1;
494
}
495
533
496
if(debug){
534
497
/* "Use a log level over 10 to enable all debugging options."
535
498
* - GnuTLS manual
539
502
}
540
503
541
504
/* OpenPGP credentials */
542
ret = gnutls_certificate_allocate_credentials(&mc->cred);
505
ret = gnutls_certificate_allocate_credentials(&mc.cred);
543
506
if(ret != GNUTLS_E_SUCCESS){
544
507
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
545
508
safer_gnutls_strerror(ret));
509
gnutls_global_deinit();
546
510
return -1;
547
511
}
548
512
554
518
}
555
519
556
520
ret = gnutls_certificate_set_openpgp_key_file
557
(mc->cred, pubkeyfilename, seckeyfilename,
521
(mc.cred, pubkeyfilename, seckeyfilename,
558
522
GNUTLS_OPENPGP_FMT_BASE64);
559
523
if(ret != GNUTLS_E_SUCCESS){
560
524
fprintf_plus(stderr,
566
530
}
567
531
568
532
/* GnuTLS server initialization */
569
ret = gnutls_dh_params_init(&mc->dh_params);
533
ret = gnutls_dh_params_init(&mc.dh_params);
570
534
if(ret != GNUTLS_E_SUCCESS){
571
535
fprintf_plus(stderr, "Error in GnuTLS DH parameter"
572
536
" initialization: %s\n",
573
537
safer_gnutls_strerror(ret));
574
538
goto globalfail;
575
539
}
576
/* If a Diffie-Hellman parameters file was given, try to use it */
577
if(dhparamsfilename != NULL){
578
gnutls_datum_t params = { .data = NULL, .size = 0 };
579
do {
580
int dhpfile = open(dhparamsfilename, O_RDONLY);
581
if(dhpfile == -1){
582
perror_plus("open");
583
dhparamsfilename = NULL;
584
break;
585
}
586
size_t params_capacity = 0;
587
while(true){
588
params_capacity = incbuffer((char **)¶ms.data,
589
(size_t)params.size,
590
(size_t)params_capacity);
591
if(params_capacity == 0){
592
perror_plus("incbuffer");
593
free(params.data);
594
params.data = NULL;
595
dhparamsfilename = NULL;
596
break;
597
}
598
ssize_t bytes_read = read(dhpfile,
599
params.data + params.size,
600
BUFFER_SIZE);
601
/* EOF */
602
if(bytes_read == 0){
603
break;
604
}
605
/* check bytes_read for failure */
606
if(bytes_read < 0){
607
perror_plus("read");
608
free(params.data);
609
params.data = NULL;
610
dhparamsfilename = NULL;
611
break;
612
}
613
params.size += (unsigned int)bytes_read;
614
}
615
if(params.data == NULL){
616
dhparamsfilename = NULL;
617
}
618
if(dhparamsfilename == NULL){
619
break;
620
}
621
ret = gnutls_dh_params_import_pkcs3(mc->dh_params, ¶ms,
622
GNUTLS_X509_FMT_PEM);
623
if(ret != GNUTLS_E_SUCCESS){
624
fprintf_plus(stderr, "Failed to parse DH parameters in file"
625
" \"%s\": %s\n", dhparamsfilename,
626
safer_gnutls_strerror(ret));
627
dhparamsfilename = NULL;
628
}
629
free(params.data);
630
} while(false);
631
}
632
if(dhparamsfilename == NULL){
633
if(mc->dh_bits == 0){
634
/* Find out the optimal number of DH bits */
635
/* Try to read the private key file */
636
gnutls_datum_t buffer = { .data = NULL, .size = 0 };
637
do {
638
int secfile = open(seckeyfilename, O_RDONLY);
639
if(secfile == -1){
640
perror_plus("open");
641
break;
642
}
643
size_t buffer_capacity = 0;
644
while(true){
645
buffer_capacity = incbuffer((char **)&buffer.data,
646
(size_t)buffer.size,
647
(size_t)buffer_capacity);
648
if(buffer_capacity == 0){
649
perror_plus("incbuffer");
650
free(buffer.data);
651
buffer.data = NULL;
652
break;
653
}
654
ssize_t bytes_read = read(secfile,
655
buffer.data + buffer.size,
656
BUFFER_SIZE);
657
/* EOF */
658
if(bytes_read == 0){
659
break;
660
}
661
/* check bytes_read for failure */
662
if(bytes_read < 0){
663
perror_plus("read");
664
free(buffer.data);
665
buffer.data = NULL;
666
break;
667
}
668
buffer.size += (unsigned int)bytes_read;
669
}
670
close(secfile);
671
} while(false);
672
/* If successful, use buffer to parse private key */
673
gnutls_sec_param_t sec_param = GNUTLS_SEC_PARAM_ULTRA;
674
if(buffer.data != NULL){
675
{
676
gnutls_openpgp_privkey_t privkey = NULL;
677
ret = gnutls_openpgp_privkey_init(&privkey);
678
if(ret != GNUTLS_E_SUCCESS){
679
fprintf_plus(stderr, "Error initializing OpenPGP key"
680
" structure: %s",
681
safer_gnutls_strerror(ret));
682
free(buffer.data);
683
buffer.data = NULL;
684
} else {
685
ret = gnutls_openpgp_privkey_import
686
(privkey, &buffer, GNUTLS_OPENPGP_FMT_BASE64, "", 0);
687
if(ret != GNUTLS_E_SUCCESS){
688
fprintf_plus(stderr, "Error importing OpenPGP key : %s",
689
safer_gnutls_strerror(ret));
690
privkey = NULL;
691
}
692
free(buffer.data);
693
buffer.data = NULL;
694
if(privkey != NULL){
695
/* Use private key to suggest an appropriate
696
sec_param */
697
sec_param = gnutls_openpgp_privkey_sec_param(privkey);
698
gnutls_openpgp_privkey_deinit(privkey);
699
if(debug){
700
fprintf_plus(stderr, "This OpenPGP key implies using"
701
" a GnuTLS security parameter \"%s\".\n",
702
safe_string(gnutls_sec_param_get_name
703
(sec_param)));
704
}
705
}
706
}
707
}
708
if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
709
/* Err on the side of caution */
710
sec_param = GNUTLS_SEC_PARAM_ULTRA;
711
if(debug){
712
fprintf_plus(stderr, "Falling back to security parameter"
713
" \"%s\"\n",
714
safe_string(gnutls_sec_param_get_name
715
(sec_param)));
716
}
717
}
718
}
719
uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
720
if(uret != 0){
721
mc->dh_bits = uret;
722
if(debug){
723
fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
724
" implies %u DH bits; using that.\n",
725
safe_string(gnutls_sec_param_get_name
726
(sec_param)),
727
mc->dh_bits);
728
}
729
} else {
730
fprintf_plus(stderr, "Failed to get implied number of DH"
731
" bits for security parameter \"%s\"): %s\n",
732
safe_string(gnutls_sec_param_get_name
733
(sec_param)),
734
safer_gnutls_strerror(ret));
735
goto globalfail;
736
}
737
} else if(debug){
738
fprintf_plus(stderr, "DH bits explicitly set to %u\n",
739
mc->dh_bits);
740
}
741
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
742
if(ret != GNUTLS_E_SUCCESS){
743
fprintf_plus(stderr, "Error in GnuTLS prime generation (%u"
744
" bits): %s\n", mc->dh_bits,
745
safer_gnutls_strerror(ret));
746
goto globalfail;
747
}
748
}
749
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
540
ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
541
if(ret != GNUTLS_E_SUCCESS){
542
fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
543
safer_gnutls_strerror(ret));
544
goto globalfail;
545
}
546
547
gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
750
548
751
549
return 0;
752
550
753
551
globalfail:
754
552
755
gnutls_certificate_free_credentials(mc->cred);
756
gnutls_dh_params_deinit(mc->dh_params);
553
gnutls_certificate_free_credentials(mc.cred);
554
gnutls_global_deinit();
555
gnutls_dh_params_deinit(mc.dh_params);
757
556
return -1;
758
557
}
759
558
760
__attribute__((nonnull, warn_unused_result))
761
static int init_gnutls_session(gnutls_session_t *session,
762
mandos_context *mc){
559
static int init_gnutls_session(gnutls_session_t *session){
763
560
int ret;
764
561
/* GnuTLS session creation */
765
562
do {
777
574
{
778
575
const char *err;
779
576
do {
780
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
577
ret = gnutls_priority_set_direct(*session, mc.priority, &err);
781
578
if(quit_now){
782
579
gnutls_deinit(*session);
783
580
return -1;
794
591
795
592
do {
796
593
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
797
mc->cred);
594
mc.cred);
798
595
if(quit_now){
799
596
gnutls_deinit(*session);
800
597
return -1;
810
607
/* ignore client certificate if any. */
811
608
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
812
609
610
gnutls_dh_set_prime_bits(*session, mc.dh_bits);
611
813
612
return 0;
814
613
}
815
614
817
616
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
818
617
__attribute__((unused)) const char *txt){}
819
618
820
/* Set effective uid to 0, return errno */
821
__attribute__((warn_unused_result))
822
int raise_privileges(void){
823
int old_errno = errno;
824
int ret = 0;
825
if(seteuid(0) == -1){
826
ret = errno;
827
}
828
errno = old_errno;
829
return ret;
830
}
831
832
/* Set effective and real user ID to 0. Return errno. */
833
__attribute__((warn_unused_result))
834
int raise_privileges_permanently(void){
835
int old_errno = errno;
836
int ret = raise_privileges();
837
if(ret != 0){
838
errno = old_errno;
839
return ret;
840
}
841
if(setuid(0) == -1){
842
ret = errno;
843
}
844
errno = old_errno;
845
return ret;
846
}
847
848
/* Set effective user ID to unprivileged saved user ID */
849
__attribute__((warn_unused_result))
850
int lower_privileges(void){
851
int old_errno = errno;
852
int ret = 0;
853
if(seteuid(uid) == -1){
854
ret = errno;
855
}
856
errno = old_errno;
857
return ret;
858
}
859
860
/* Lower privileges permanently */
861
__attribute__((warn_unused_result))
862
int lower_privileges_permanently(void){
863
int old_errno = errno;
864
int ret = 0;
865
if(setuid(uid) == -1){
866
ret = errno;
867
}
868
errno = old_errno;
869
return ret;
870
}
871
872
/* Helper function to add_local_route() and delete_local_route() */
873
__attribute__((nonnull, warn_unused_result))
874
static bool add_delete_local_route(const bool add,
875
const char *address,
876
AvahiIfIndex if_index){
877
int ret;
878
char helper[] = "mandos-client-iprouteadddel";
879
char add_arg[] = "add";
880
char delete_arg[] = "delete";
881
char debug_flag[] = "--debug";
882
char *pluginhelperdir = getenv("MANDOSPLUGINHELPERDIR");
883
if(pluginhelperdir == NULL){
884
if(debug){
885
fprintf_plus(stderr, "MANDOSPLUGINHELPERDIR environment"
886
" variable not set; cannot run helper\n");
887
}
888
return false;
889
}
890
891
char interface[IF_NAMESIZE];
892
if(if_indextoname((unsigned int)if_index, interface) == NULL){
893
perror_plus("if_indextoname");
894
return false;
895
}
896
897
int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
898
if(devnull == -1){
899
perror_plus("open(\"/dev/null\", O_RDONLY)");
900
return false;
901
}
902
pid_t pid = fork();
903
if(pid == 0){
904
/* Child */
905
/* Raise privileges */
906
errno = raise_privileges_permanently();
907
if(errno != 0){
908
perror_plus("Failed to raise privileges");
909
/* _exit(EX_NOPERM); */
910
} else {
911
/* Set group */
912
errno = 0;
913
ret = setgid(0);
914
if(ret == -1){
915
perror_plus("setgid");
916
_exit(EX_NOPERM);
917
}
918
/* Reset supplementary groups */
919
errno = 0;
920
ret = setgroups(0, NULL);
921
if(ret == -1){
922
perror_plus("setgroups");
923
_exit(EX_NOPERM);
924
}
925
}
926
ret = dup2(devnull, STDIN_FILENO);
927
if(ret == -1){
928
perror_plus("dup2(devnull, STDIN_FILENO)");
929
_exit(EX_OSERR);
930
}
931
ret = close(devnull);
932
if(ret == -1){
933
perror_plus("close");
934
_exit(EX_OSERR);
935
}
936
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
937
if(ret == -1){
938
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
939
_exit(EX_OSERR);
940
}
941
int helperdir_fd = (int)TEMP_FAILURE_RETRY(open(pluginhelperdir,
942
O_RDONLY
943
| O_DIRECTORY
944
| O_PATH
945
| O_CLOEXEC));
946
if(helperdir_fd == -1){
947
perror_plus("open");
948
_exit(EX_UNAVAILABLE);
949
}
950
int helper_fd = (int)TEMP_FAILURE_RETRY(openat(helperdir_fd,
951
helper, O_RDONLY));
952
if(helper_fd == -1){
953
perror_plus("openat");
954
close(helperdir_fd);
955
_exit(EX_UNAVAILABLE);
956
}
957
close(helperdir_fd);
958
#ifdef __GNUC__
959
#pragma GCC diagnostic push
960
#pragma GCC diagnostic ignored "-Wcast-qual"
961
#endif
962
if(fexecve(helper_fd, (char *const [])
963
{ helper, add ? add_arg : delete_arg, (char *)address,
964
interface, debug ? debug_flag : NULL, NULL },
965
environ) == -1){
966
#ifdef __GNUC__
967
#pragma GCC diagnostic pop
968
#endif
969
perror_plus("fexecve");
970
_exit(EXIT_FAILURE);
971
}
972
}
973
if(pid == -1){
974
perror_plus("fork");
975
return false;
976
}
977
int status;
978
pid_t pret = -1;
979
errno = 0;
980
do {
981
pret = waitpid(pid, &status, 0);
982
if(pret == -1 and errno == EINTR and quit_now){
983
int errno_raising = 0;
984
if((errno = raise_privileges()) != 0){
985
errno_raising = errno;
986
perror_plus("Failed to raise privileges in order to"
987
" kill helper program");
988
}
989
if(kill(pid, SIGTERM) == -1){
990
perror_plus("kill");
991
}
992
if((errno_raising == 0) and (errno = lower_privileges()) != 0){
993
perror_plus("Failed to lower privileges after killing"
994
" helper program");
995
}
996
return false;
997
}
998
} while(pret == -1 and errno == EINTR);
999
if(pret == -1){
1000
perror_plus("waitpid");
1001
return false;
1002
}
1003
if(WIFEXITED(status)){
1004
if(WEXITSTATUS(status) != 0){
1005
fprintf_plus(stderr, "Error: iprouteadddel exited"
1006
" with status %d\n", WEXITSTATUS(status));
1007
return false;
1008
}
1009
return true;
1010
}
1011
if(WIFSIGNALED(status)){
1012
fprintf_plus(stderr, "Error: iprouteadddel died by"
1013
" signal %d\n", WTERMSIG(status));
1014
return false;
1015
}
1016
fprintf_plus(stderr, "Error: iprouteadddel crashed\n");
1017
return false;
1018
}
1019
1020
__attribute__((nonnull, warn_unused_result))
1021
static bool add_local_route(const char *address,
1022
AvahiIfIndex if_index){
1023
if(debug){
1024
fprintf_plus(stderr, "Adding route to %s\n", address);
1025
}
1026
return add_delete_local_route(true, address, if_index);
1027
}
1028
1029
__attribute__((nonnull, warn_unused_result))
1030
static bool delete_local_route(const char *address,
1031
AvahiIfIndex if_index){
1032
if(debug){
1033
fprintf_plus(stderr, "Removing route to %s\n", address);
1034
}
1035
return add_delete_local_route(false, address, if_index);
1036
}
1037
1038
619
/* Called when a Mandos server is found */
1039
__attribute__((nonnull, warn_unused_result))
1040
static int start_mandos_communication(const char *ip, in_port_t port,
620
static int start_mandos_communication(const char *ip, uint16_t port,
1041
621
AvahiIfIndex if_index,
1042
int af, mandos_context *mc){
622
int af){
1043
623
int ret, tcp_sd = -1;
1044
624
ssize_t sret;
1045
struct sockaddr_storage to;
625
union {
626
struct sockaddr_in in;
627
struct sockaddr_in6 in6;
628
} to;
1046
629
char *buffer = NULL;
1047
630
char *decrypted_buffer = NULL;
1048
631
size_t buffer_length = 0;
1051
634
int retval = -1;
1052
635
gnutls_session_t session;
1053
636
int pf; /* Protocol family */
1054
bool route_added = false;
1055
637
1056
638
errno = 0;
1057
639
1073
655
return -1;
1074
656
}
1075
657
1076
/* If the interface is specified and we have a list of interfaces */
1077
if(if_index != AVAHI_IF_UNSPEC and mc->interfaces != NULL){
1078
/* Check if the interface is one of the interfaces we are using */
1079
bool match = false;
1080
{
1081
char *interface = NULL;
1082
while((interface = argz_next(mc->interfaces,
1083
mc->interfaces_size,
1084
interface))){
1085
if(if_nametoindex(interface) == (unsigned int)if_index){
1086
match = true;
1087
break;
1088
}
1089
}
1090
}
1091
if(not match){
1092
/* This interface does not match any in the list, so we don't
1093
connect to the server */
1094
if(debug){
1095
char interface[IF_NAMESIZE];
1096
if(if_indextoname((unsigned int)if_index, interface) == NULL){
1097
perror_plus("if_indextoname");
1098
} else {
1099
fprintf_plus(stderr, "Skipping server on non-used interface"
1100
" \"%s\"\n",
1101
if_indextoname((unsigned int)if_index,
1102
interface));
1103
}
1104
}
1105
return -1;
1106
}
1107
}
1108
1109
ret = init_gnutls_session(&session, mc);
658
ret = init_gnutls_session(&session);
1110
659
if(ret != 0){
1111
660
return -1;
1112
661
}
1113
662
1114
663
if(debug){
1115
664
fprintf_plus(stderr, "Setting up a TCP connection to %s, port %"
1116
PRIuMAX "\n", ip, (uintmax_t)port);
665
PRIu16 "\n", ip, port);
1117
666
}
1118
667
1119
tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
668
tcp_sd = socket(pf, SOCK_STREAM, 0);
1120
669
if(tcp_sd < 0){
1121
670
int e = errno;
1122
671
perror_plus("socket");
1129
678
goto mandos_end;
1130
679
}
1131
680
681
memset(&to, 0, sizeof(to));
1132
682
if(af == AF_INET6){
1133
struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)&to;
1134
*to6 = (struct sockaddr_in6){ .sin6_family = (sa_family_t)af };
1135
ret = inet_pton(af, ip, &to6->sin6_addr);
683
to.in6.sin6_family = (sa_family_t)af;
684
ret = inet_pton(af, ip, &to.in6.sin6_addr);
1136
685
} else { /* IPv4 */
1137
struct sockaddr_in *to4 = (struct sockaddr_in *)&to;
1138
*to4 = (struct sockaddr_in){ .sin_family = (sa_family_t)af };
1139
ret = inet_pton(af, ip, &to4->sin_addr);
686
to.in.sin_family = (sa_family_t)af;
687
ret = inet_pton(af, ip, &to.in.sin_addr);
1140
688
}
1141
689
if(ret < 0 ){
1142
690
int e = errno;
1151
699
goto mandos_end;
1152
700
}
1153
701
if(af == AF_INET6){
1154
((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
1155
if(IN6_IS_ADDR_LINKLOCAL
1156
(&((struct sockaddr_in6 *)&to)->sin6_addr)){
702
to.in6.sin6_port = htons(port); /* Spurious warnings from
703
-Wconversion and
704
-Wunreachable-code */
705
706
if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
707
(&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
708
-Wunreachable-code*/
1157
709
if(if_index == AVAHI_IF_UNSPEC){
1158
710
fprintf_plus(stderr, "An IPv6 link-local address is"
1159
711
" incomplete without a network interface\n");
1161
713
goto mandos_end;
1162
714
}
1163
715
/* Set the network interface number as scope */
1164
((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
716
to.in6.sin6_scope_id = (uint32_t)if_index;
1165
717
}
1166
718
} else {
1167
((struct sockaddr_in *)&to)->sin_port = htons(port);
719
to.in.sin_port = htons(port); /* Spurious warnings from
720
-Wconversion and
721
-Wunreachable-code */
1168
722
}
1169
723
1170
724
if(quit_now){
1178
732
if(if_indextoname((unsigned int)if_index, interface) == NULL){
1179
733
perror_plus("if_indextoname");
1180
734
} else {
1181
fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIuMAX
1182
"\n", ip, interface, (uintmax_t)port);
735
fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIu16
736
"\n", ip, interface, port);
1183
737
}
1184
738
} else {
1185
fprintf_plus(stderr, "Connection to: %s, port %" PRIuMAX "\n",
1186
ip, (uintmax_t)port);
739
fprintf_plus(stderr, "Connection to: %s, port %" PRIu16 "\n",
740
ip, port);
1187
741
}
1188
742
char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
1189
743
INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
1190
if(af == AF_INET6){
1191
ret = getnameinfo((struct sockaddr *)&to,
1192
sizeof(struct sockaddr_in6),
1193
addrstr, sizeof(addrstr), NULL, 0,
1194
NI_NUMERICHOST);
1195
} else {
1196
ret = getnameinfo((struct sockaddr *)&to,
1197
sizeof(struct sockaddr_in),
1198
addrstr, sizeof(addrstr), NULL, 0,
1199
NI_NUMERICHOST);
1200
}
1201
if(ret == EAI_SYSTEM){
1202
perror_plus("getnameinfo");
1203
} else if(ret != 0) {
1204
fprintf_plus(stderr, "getnameinfo: %s", gai_strerror(ret));
1205
} else if(strcmp(addrstr, ip) != 0){
1206
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
1207
}
1208
}
1209
1210
if(quit_now){
1211
errno = EINTR;
1212
goto mandos_end;
1213
}
1214
1215
while(true){
1216
if(af == AF_INET6){
1217
ret = connect(tcp_sd, (struct sockaddr *)&to,
1218
sizeof(struct sockaddr_in6));
1219
} else {
1220
ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
1221
sizeof(struct sockaddr_in));
1222
}
1223
if(ret < 0){
1224
if(((errno == ENETUNREACH) or (errno == EHOSTUNREACH))
1225
and if_index != AVAHI_IF_UNSPEC
1226
and connect_to == NULL
1227
and not route_added and
1228
((af == AF_INET6 and not
1229
IN6_IS_ADDR_LINKLOCAL(&(((struct sockaddr_in6 *)
1230
&to)->sin6_addr)))
1231
or (af == AF_INET and
1232
/* Not a a IPv4LL address */
1233
(ntohl(((struct sockaddr_in *)&to)->sin_addr.s_addr)
1234
& 0xFFFF0000L) != 0xA9FE0000L))){
1235
/* Work around Avahi bug - Avahi does not announce link-local
1236
addresses if it has a global address, so local hosts with
1237
*only* a link-local address (e.g. Mandos clients) cannot
1238
connect to a Mandos server announced by Avahi on a server
1239
host with a global address. Work around this by retrying
1240
with an explicit route added with the server's address.
1241
1242
Avahi bug reference:
1243
https://lists.freedesktop.org/archives/avahi/2010-February/001833.html
1244
https://bugs.debian.org/587961
1245
*/
1246
if(debug){
1247
fprintf_plus(stderr, "Mandos server unreachable, trying"
1248
" direct route\n");
1249
}
1250
int e = errno;
1251
route_added = add_local_route(ip, if_index);
1252
if(route_added){
1253
continue;
1254
}
1255
errno = e;
1256
}
1257
if(errno != ECONNREFUSED or debug){
1258
int e = errno;
1259
perror_plus("connect");
1260
errno = e;
1261
}
1262
goto mandos_end;
1263
}
1264
1265
if(quit_now){
1266
errno = EINTR;
1267
goto mandos_end;
1268
}
1269
break;
744
const char *pcret;
745
if(af == AF_INET6){
746
pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
747
sizeof(addrstr));
748
} else {
749
pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
750
sizeof(addrstr));
751
}
752
if(pcret == NULL){
753
perror_plus("inet_ntop");
754
} else {
755
if(strcmp(addrstr, ip) != 0){
756
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
757
}
758
}
759
}
760
761
if(quit_now){
762
errno = EINTR;
763
goto mandos_end;
764
}
765
766
if(af == AF_INET6){
767
ret = connect(tcp_sd, &to.in6, sizeof(to));
768
} else {
769
ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
770
}
771
if(ret < 0){
772
if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
773
int e = errno;
774
perror_plus("connect");
775
errno = e;
776
}
777
goto mandos_end;
778
}
779
780
if(quit_now){
781
errno = EINTR;
782
goto mandos_end;
1270
783
}
1271
784
1272
785
const char *out = mandos_protocol_version;
1308
821
goto mandos_end;
1309
822
}
1310
823
1311
/* This casting via intptr_t is to eliminate warning about casting
1312
an int to a pointer type. This is exactly how the GnuTLS Guile
1313
function "set-session-transport-fd!" does it. */
1314
gnutls_transport_set_ptr(session,
1315
(gnutls_transport_ptr_t)(intptr_t)tcp_sd);
824
/* Spurious warning from -Wint-to-pointer-cast */
825
gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
1316
826
1317
827
if(quit_now){
1318
828
errno = EINTR;
1423
933
if(buffer_length > 0){
1424
934
ssize_t decrypted_buffer_size;
1425
935
decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
1426
&decrypted_buffer, mc);
936
&decrypted_buffer);
1427
937
if(decrypted_buffer_size >= 0){
1428
938
1429
clearerr(stdout);
1430
939
written = 0;
1431
940
while(written < (size_t) decrypted_buffer_size){
1432
941
if(quit_now){
1448
957
}
1449
958
written += (size_t)ret;
1450
959
}
1451
ret = fflush(stdout);
1452
if(ret != 0){
1453
int e = errno;
1454
if(debug){
1455
fprintf_plus(stderr, "Error writing encrypted data: %s\n",
1456
strerror(errno));
1457
}
1458
errno = e;
1459
goto mandos_end;
1460
}
1461
960
retval = 0;
1462
961
}
1463
962
}
1466
965
1467
966
mandos_end:
1468
967
{
1469
if(route_added){
1470
if(not delete_local_route(ip, if_index)){
1471
fprintf_plus(stderr, "Failed to delete local route to %s on"
1472
" interface %d", ip, if_index);
1473
}
1474
}
1475
968
int e = errno;
1476
969
free(decrypted_buffer);
1477
970
free(buffer);
1478
971
if(tcp_sd >= 0){
1479
ret = close(tcp_sd);
972
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
1480
973
}
1481
974
if(ret == -1){
1482
975
if(e == 0){
1507
1000
AVAHI_GCC_UNUSED AvahiStringList *txt,
1508
1001
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1509
1002
flags,
1510
void *mc){
1511
if(r == NULL){
1512
return;
1513
}
1003
AVAHI_GCC_UNUSED void* userdata){
1004
assert(r);
1514
1005
1515
1006
/* Called whenever a service has been resolved successfully or
1516
1007
timed out */
1517
1008
1518
1009
if(quit_now){
1519
avahi_s_service_resolver_free(r);
1520
1010
return;
1521
1011
}
1522
1012
1526
1016
fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
1527
1017
"'%s' of type '%s' in domain '%s': %s\n", name, type,
1528
1018
domain,
1529
avahi_strerror(avahi_server_errno
1530
(((mandos_context*)mc)->server)));
1019
avahi_strerror(avahi_server_errno(mc.server)));
1531
1020
break;
1532
1021
1533
1022
case AVAHI_RESOLVER_FOUND:
1539
1028
PRIdMAX ") on port %" PRIu16 "\n", name,
1540
1029
host_name, ip, (intmax_t)interface, port);
1541
1030
}
1542
int ret = start_mandos_communication(ip, (in_port_t)port,
1543
interface,
1544
avahi_proto_to_af(proto),
1545
mc);
1031
int ret = start_mandos_communication(ip, port, interface,
1032
avahi_proto_to_af(proto));
1546
1033
if(ret == 0){
1547
avahi_simple_poll_quit(simple_poll);
1034
avahi_simple_poll_quit(mc.simple_poll);
1548
1035
} else {
1549
if(not add_server(ip, (in_port_t)port, interface,
1550
avahi_proto_to_af(proto),
1551
&((mandos_context*)mc)->current_server)){
1036
if(not add_server(ip, port, interface,
1037
avahi_proto_to_af(proto))){
1552
1038
fprintf_plus(stderr, "Failed to add server \"%s\" to server"
1553
1039
" list\n", name);
1554
1040
}
1567
1053
const char *domain,
1568
1054
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1569
1055
flags,
1570
void *mc){
1571
if(b == NULL){
1572
return;
1573
}
1056
AVAHI_GCC_UNUSED void* userdata){
1057
assert(b);
1574
1058
1575
1059
/* Called whenever a new services becomes available on the LAN or
1576
1060
is removed from the LAN */
1584
1068
case AVAHI_BROWSER_FAILURE:
1585
1069
1586
1070
fprintf_plus(stderr, "(Avahi browser) %s\n",
1587
avahi_strerror(avahi_server_errno
1588
(((mandos_context*)mc)->server)));
1589
avahi_simple_poll_quit(simple_poll);
1071
avahi_strerror(avahi_server_errno(mc.server)));
1072
avahi_simple_poll_quit(mc.simple_poll);
1590
1073
return;
1591
1074
1592
1075
case AVAHI_BROWSER_NEW:
1595
1078
the callback function is called the Avahi server will free the
1596
1079
resolver for us. */
1597
1080
1598
if(avahi_s_service_resolver_new(((mandos_context*)mc)->server,
1599
interface, protocol, name, type,
1600
domain, protocol, 0,
1601
resolve_callback, mc) == NULL)
1081
if(avahi_s_service_resolver_new(mc.server, interface, protocol,
1082
name, type, domain, protocol, 0,
1083
resolve_callback, NULL) == NULL)
1602
1084
fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
1603
1085
" %s\n", name,
1604
avahi_strerror(avahi_server_errno
1605
(((mandos_context*)mc)->server)));
1086
avahi_strerror(avahi_server_errno(mc.server)));
1606
1087
break;
1607
1088
1608
1089
case AVAHI_BROWSER_REMOVE:
1627
1108
signal_received = sig;
1628
1109
int old_errno = errno;
1629
1110
/* set main loop to exit */
1630
if(simple_poll != NULL){
1631
avahi_simple_poll_quit(simple_poll);
1111
if(mc.simple_poll != NULL){
1112
avahi_simple_poll_quit(mc.simple_poll);
1632
1113
}
1633
1114
errno = old_errno;
1634
1115
}
1635
1116
1636
__attribute__((nonnull, warn_unused_result))
1637
1117
bool get_flags(const char *ifname, struct ifreq *ifr){
1638
1118
int ret;
1639
int old_errno;
1640
1119
1641
1120
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1642
1121
if(s < 0){
1643
old_errno = errno;
1644
1122
perror_plus("socket");
1645
errno = old_errno;
1646
1123
return false;
1647
1124
}
1648
strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
1649
ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
1125
strcpy(ifr->ifr_name, ifname);
1650
1126
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1651
1127
if(ret == -1){
1652
1128
if(debug){
1653
old_errno = errno;
1654
1129
perror_plus("ioctl SIOCGIFFLAGS");
1655
errno = old_errno;
1656
1130
}
1657
1131
return false;
1658
1132
}
1659
1133
return true;
1660
1134
}
1661
1135
1662
__attribute__((nonnull, warn_unused_result))
1663
1136
bool good_flags(const char *ifname, const struct ifreq *ifr){
1664
1137
1665
1138
/* Reject the loopback device */
1707
1180
* corresponds to an acceptable network device.
1708
1181
* (This function is passed to scandir(3) as a filter function.)
1709
1182
*/
1710
__attribute__((nonnull, warn_unused_result))
1711
1183
int good_interface(const struct dirent *if_entry){
1712
1184
if(if_entry->d_name[0] == '.'){
1713
1185
return 0;
1729
1201
}
1730
1202
1731
1203
/*
1732
* This function determines if a network interface is up.
1733
*/
1734
__attribute__((nonnull, warn_unused_result))
1735
bool interface_is_up(const char *interface){
1736
struct ifreq ifr;
1737
if(not get_flags(interface, &ifr)){
1738
if(debug){
1739
fprintf_plus(stderr, "Failed to get flags for interface "
1740
"\"%s\"\n", interface);
1741
}
1742
return false;
1743
}
1744
1745
return (bool)(ifr.ifr_flags & IFF_UP);
1746
}
1747
1748
/*
1749
* This function determines if a network interface is running
1750
*/
1751
__attribute__((nonnull, warn_unused_result))
1752
bool interface_is_running(const char *interface){
1753
struct ifreq ifr;
1754
if(not get_flags(interface, &ifr)){
1755
if(debug){
1756
fprintf_plus(stderr, "Failed to get flags for interface "
1757
"\"%s\"\n", interface);
1758
}
1759
return false;
1760
}
1761
1762
return (bool)(ifr.ifr_flags & IFF_RUNNING);
1763
}
1764
1765
__attribute__((nonnull, pure, warn_unused_result))
1204
* This function determines if a directory entry in /sys/class/net
1205
* corresponds to an acceptable network device which is up.
1206
* (This function is passed to scandir(3) as a filter function.)
1207
*/
1208
int up_interface(const struct dirent *if_entry){
1209
if(if_entry->d_name[0] == '.'){
1210
return 0;
1211
}
1212
1213
struct ifreq ifr;
1214
if(not get_flags(if_entry->d_name, &ifr)){
1215
if(debug){
1216
fprintf_plus(stderr, "Failed to get flags for interface "
1217
"\"%s\"\n", if_entry->d_name);
1218
}
1219
return 0;
1220
}
1221
1222
/* Reject down interfaces */
1223
if(not (ifr.ifr_flags & IFF_UP)){
1224
if(debug){
1225
fprintf_plus(stderr, "Rejecting down interface \"%s\"\n",
1226
if_entry->d_name);
1227
}
1228
return 0;
1229
}
1230
1231
/* Reject non-running interfaces */
1232
if(not (ifr.ifr_flags & IFF_RUNNING)){
1233
if(debug){
1234
fprintf_plus(stderr, "Rejecting non-running interface \"%s\"\n",
1235
if_entry->d_name);
1236
}
1237
return 0;
1238
}
1239
1240
if(not good_flags(if_entry->d_name, &ifr)){
1241
return 0;
1242
}
1243
return 1;
1244
}
1245
1766
1246
int notdotentries(const struct dirent *direntry){
1767
1247
/* Skip "." and ".." */
1768
1248
if(direntry->d_name[0] == '.'
1775
1255
}
1776
1256
1777
1257
/* Is this directory entry a runnable program? */
1778
__attribute__((nonnull, warn_unused_result))
1779
1258
int runnable_hook(const struct dirent *direntry){
1780
1259
int ret;
1781
1260
size_t sret;
1789
1268
sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1790
1269
"abcdefghijklmnopqrstuvwxyz"
1791
1270
"0123456789"
1792
"_.-");
1271
"_-");
1793
1272
if((direntry->d_name)[sret] != '\0'){
1794
1273
/* Contains non-allowed characters */
1795
1274
if(debug){
1799
1278
return 0;
1800
1279
}
1801
1280
1802
ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1281
char *fullname = NULL;
1282
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1283
if(ret < 0){
1284
perror_plus("asprintf");
1285
return 0;
1286
}
1287
1288
ret = stat(fullname, &st);
1803
1289
if(ret == -1){
1804
1290
if(debug){
1805
1291
perror_plus("Could not stat hook");
1829
1315
return 1;
1830
1316
}
1831
1317
1832
__attribute__((nonnull, warn_unused_result))
1833
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
1834
mandos_context *mc){
1318
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval){
1835
1319
int ret;
1836
1320
struct timespec now;
1837
1321
struct timespec waited_time;
1838
1322
intmax_t block_time;
1839
1323
1840
1324
while(true){
1841
if(mc->current_server == NULL){
1842
if(debug){
1325
if(mc.current_server == NULL){
1326
if (debug){
1843
1327
fprintf_plus(stderr, "Wait until first server is found."
1844
1328
" No timeout!\n");
1845
1329
}
1846
1330
ret = avahi_simple_poll_iterate(s, -1);
1847
1331
} else {
1848
if(debug){
1332
if (debug){
1849
1333
fprintf_plus(stderr, "Check current_server if we should run"
1850
1334
" it, or wait\n");
1851
1335
}
1858
1342
/* Calculating in ms how long time between now and server
1859
1343
who we visted longest time ago. Now - last seen. */
1860
1344
waited_time.tv_sec = (now.tv_sec
1861
- mc->current_server->last_seen.tv_sec);
1345
- mc.current_server->last_seen.tv_sec);
1862
1346
waited_time.tv_nsec = (now.tv_nsec
1863
- mc->current_server->last_seen.tv_nsec);
1347
- mc.current_server->last_seen.tv_nsec);
1864
1348
/* total time is 10s/10,000ms.
1865
1349
Converting to s from ms by dividing by 1,000,
1866
1350
and ns to ms by dividing by 1,000,000. */
1868
1352
- ((intmax_t)waited_time.tv_sec * 1000))
1869
1353
- ((intmax_t)waited_time.tv_nsec / 1000000));
1870
1354
1871
if(debug){
1355
if (debug){
1872
1356
fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1873
1357
block_time);
1874
1358
}
1875
1359
1876
1360
if(block_time <= 0){
1877
ret = start_mandos_communication(mc->current_server->ip,
1878
mc->current_server->port,
1879
mc->current_server->if_index,
1880
mc->current_server->af, mc);
1361
ret = start_mandos_communication(mc.current_server->ip,
1362
mc.current_server->port,
1363
mc.current_server->if_index,
1364
mc.current_server->af);
1881
1365
if(ret == 0){
1882
avahi_simple_poll_quit(s);
1366
avahi_simple_poll_quit(mc.simple_poll);
1883
1367
return 0;
1884
1368
}
1885
1369
ret = clock_gettime(CLOCK_MONOTONIC,
1886
&mc->current_server->last_seen);
1370
&mc.current_server->last_seen);
1887
1371
if(ret == -1){
1888
1372
perror_plus("clock_gettime");
1889
1373
return -1;
1890
1374
}
1891
mc->current_server = mc->current_server->next;
1375
mc.current_server = mc.current_server->next;
1892
1376
block_time = 0; /* Call avahi to find new Mandos
1893
1377
servers, but don't block */
1894
1378
}
1896
1380
ret = avahi_simple_poll_iterate(s, (int)block_time);
1897
1381
}
1898
1382
if(ret != 0){
1899
if(ret > 0 or errno != EINTR){
1383
if (ret > 0 or errno != EINTR){
1900
1384
return (ret != 1) ? ret : 0;
1901
1385
}
1902
1386
}
1903
1387
}
1904
1388
}
1905
1389
1906
__attribute__((nonnull))
1907
void run_network_hooks(const char *mode, const char *interface,
1390
bool run_network_hooks(const char *mode, const char *interface,
1908
1391
const float delay){
1909
struct dirent **direntries = NULL;
1910
if(hookdir_fd == -1){
1911
hookdir_fd = open(hookdir, O_RDONLY | O_DIRECTORY | O_PATH
1912
| O_CLOEXEC);
1913
if(hookdir_fd == -1){
1914
if(errno == ENOENT){
1915
if(debug){
1916
fprintf_plus(stderr, "Network hook directory \"%s\" not"
1917
" found\n", hookdir);
1918
}
1919
} else {
1920
perror_plus("open");
1921
}
1922
return;
1923
}
1924
}
1925
int numhooks = scandirat(hookdir_fd, ".", &direntries,
1926
runnable_hook, alphasort);
1392
struct dirent **direntries;
1393
struct dirent *direntry;
1394
int ret;
1395
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1396
alphasort);
1927
1397
if(numhooks == -1){
1928
1398
perror_plus("scandir");
1929
return;
1930
}
1931
struct dirent *direntry;
1932
int ret;
1933
int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
1934
if(devnull == -1){
1935
perror_plus("open(\"/dev/null\", O_RDONLY)");
1936
return;
1937
}
1938
for(int i = 0; i < numhooks; i++){
1939
direntry = direntries[i];
1940
if(debug){
1941
fprintf_plus(stderr, "Running network hook \"%s\"\n",
1942
direntry->d_name);
1943
}
1944
pid_t hook_pid = fork();
1945
if(hook_pid == 0){
1946
/* Child */
1947
/* Raise privileges */
1948
errno = raise_privileges_permanently();
1949
if(errno != 0){
1950
perror_plus("Failed to raise privileges");
1951
_exit(EX_NOPERM);
1952
}
1953
/* Set group */
1954
errno = 0;
1955
ret = setgid(0);
1956
if(ret == -1){
1957
perror_plus("setgid");
1958
_exit(EX_NOPERM);
1959
}
1960
/* Reset supplementary groups */
1961
errno = 0;
1962
ret = setgroups(0, NULL);
1963
if(ret == -1){
1964
perror_plus("setgroups");
1965
_exit(EX_NOPERM);
1966
}
1967
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1968
if(ret == -1){
1969
perror_plus("setenv");
1970
_exit(EX_OSERR);
1971
}
1972
ret = setenv("DEVICE", interface, 1);
1973
if(ret == -1){
1974
perror_plus("setenv");
1975
_exit(EX_OSERR);
1976
}
1977
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
1978
if(ret == -1){
1979
perror_plus("setenv");
1980
_exit(EX_OSERR);
1981
}
1982
ret = setenv("MODE", mode, 1);
1983
if(ret == -1){
1984
perror_plus("setenv");
1985
_exit(EX_OSERR);
1986
}
1987
char *delaystring;
1988
ret = asprintf(&delaystring, "%f", (double)delay);
1989
if(ret == -1){
1399
} else {
1400
int devnull = open("/dev/null", O_RDONLY);
1401
for(int i = 0; i < numhooks; i++){
1402
direntry = direntries[i];
1403
char *fullname = NULL;
1404
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1405
if(ret < 0){
1990
1406
perror_plus("asprintf");
1991
_exit(EX_OSERR);
1992
}
1993
ret = setenv("DELAY", delaystring, 1);
1994
if(ret == -1){
1407
continue;
1408
}
1409
if(debug){
1410
fprintf_plus(stderr, "Running network hook \"%s\"\n",
1411
direntry->d_name);
1412
}
1413
pid_t hook_pid = fork();
1414
if(hook_pid == 0){
1415
/* Child */
1416
/* Raise privileges */
1417
errno = 0;
1418
ret = seteuid(0);
1419
if(ret == -1){
1420
perror_plus("seteuid");
1421
}
1422
/* Raise privileges even more */
1423
errno = 0;
1424
ret = setuid(0);
1425
if(ret == -1){
1426
perror_plus("setuid");
1427
}
1428
/* Set group */
1429
errno = 0;
1430
ret = setgid(0);
1431
if(ret == -1){
1432
perror_plus("setgid");
1433
}
1434
/* Reset supplementary groups */
1435
errno = 0;
1436
ret = setgroups(0, NULL);
1437
if(ret == -1){
1438
perror_plus("setgroups");
1439
}
1440
dup2(devnull, STDIN_FILENO);
1441
close(devnull);
1442
dup2(STDERR_FILENO, STDOUT_FILENO);
1443
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1444
if(ret == -1){
1445
perror_plus("setenv");
1446
_exit(EX_OSERR);
1447
}
1448
ret = setenv("DEVICE", interface, 1);
1449
if(ret == -1){
1450
perror_plus("setenv");
1451
_exit(EX_OSERR);
1452
}
1453
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
1454
if(ret == -1){
1455
perror_plus("setenv");
1456
_exit(EX_OSERR);
1457
}
1458
ret = setenv("MODE", mode, 1);
1459
if(ret == -1){
1460
perror_plus("setenv");
1461
_exit(EX_OSERR);
1462
}
1463
char *delaystring;
1464
ret = asprintf(&delaystring, "%f", delay);
1465
if(ret == -1){
1466
perror_plus("asprintf");
1467
_exit(EX_OSERR);
1468
}
1469
ret = setenv("DELAY", delaystring, 1);
1470
if(ret == -1){
1471
free(delaystring);
1472
perror_plus("setenv");
1473
_exit(EX_OSERR);
1474
}
1995
1475
free(delaystring);
1996
perror_plus("setenv");
1997
_exit(EX_OSERR);
1998
}
1999
free(delaystring);
2000
if(connect_to != NULL){
2001
ret = setenv("CONNECT", connect_to, 1);
2002
if(ret == -1){
2003
perror_plus("setenv");
2004
_exit(EX_OSERR);
2005
}
2006
}
2007
int hook_fd = (int)TEMP_FAILURE_RETRY(openat(hookdir_fd,
2008
direntry->d_name,
2009
O_RDONLY));
2010
if(hook_fd == -1){
2011
perror_plus("openat");
2012
_exit(EXIT_FAILURE);
2013
}
2014
if(close(hookdir_fd) == -1){
2015
perror_plus("close");
2016
_exit(EXIT_FAILURE);
2017
}
2018
ret = dup2(devnull, STDIN_FILENO);
2019
if(ret == -1){
2020
perror_plus("dup2(devnull, STDIN_FILENO)");
2021
_exit(EX_OSERR);
2022
}
2023
ret = close(devnull);
2024
if(ret == -1){
2025
perror_plus("close");
2026
_exit(EX_OSERR);
2027
}
2028
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
2029
if(ret == -1){
2030
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
2031
_exit(EX_OSERR);
2032
}
2033
if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
2034
environ) == -1){
2035
perror_plus("fexecve");
2036
_exit(EXIT_FAILURE);
2037
}
2038
} else {
2039
if(hook_pid == -1){
2040
perror_plus("fork");
2041
free(direntry);
2042
continue;
2043
}
2044
int status;
2045
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
2046
perror_plus("waitpid");
2047
free(direntry);
2048
continue;
2049
}
2050
if(WIFEXITED(status)){
2051
if(WEXITSTATUS(status) != 0){
2052
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
2053
" with status %d\n", direntry->d_name,
2054
WEXITSTATUS(status));
2055
free(direntry);
2056
continue;
2057
}
2058
} else if(WIFSIGNALED(status)){
2059
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
2060
" signal %d\n", direntry->d_name,
2061
WTERMSIG(status));
2062
free(direntry);
2063
continue;
2064
} else {
2065
fprintf_plus(stderr, "Warning: network hook \"%s\""
2066
" crashed\n", direntry->d_name);
2067
free(direntry);
2068
continue;
2069
}
2070
}
2071
if(debug){
2072
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
2073
direntry->d_name);
2074
}
2075
free(direntry);
2076
}
2077
free(direntries);
2078
if(close(hookdir_fd) == -1){
2079
perror_plus("close");
2080
} else {
2081
hookdir_fd = -1;
2082
}
2083
close(devnull);
2084
}
2085
2086
__attribute__((nonnull, warn_unused_result))
2087
int bring_up_interface(const char *const interface,
2088
const float delay){
2089
int old_errno = errno;
2090
int ret;
2091
struct ifreq network;
2092
unsigned int if_index = if_nametoindex(interface);
2093
if(if_index == 0){
2094
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
2095
errno = old_errno;
2096
return ENXIO;
2097
}
2098
2099
if(quit_now){
2100
errno = old_errno;
2101
return EINTR;
2102
}
2103
2104
if(not interface_is_up(interface)){
2105
int ret_errno = 0;
2106
int ioctl_errno = 0;
2107
if(not get_flags(interface, &network)){
2108
ret_errno = errno;
2109
fprintf_plus(stderr, "Failed to get flags for interface "
2110
"\"%s\"\n", interface);
2111
errno = old_errno;
2112
return ret_errno;
2113
}
2114
network.ifr_flags |= IFF_UP; /* set flag */
2115
2116
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
2117
if(sd == -1){
2118
ret_errno = errno;
2119
perror_plus("socket");
2120
errno = old_errno;
2121
return ret_errno;
2122
}
2123
2124
if(quit_now){
2125
ret = close(sd);
2126
if(ret == -1){
2127
perror_plus("close");
2128
}
2129
errno = old_errno;
2130
return EINTR;
2131
}
2132
2133
if(debug){
2134
fprintf_plus(stderr, "Bringing up interface \"%s\"\n",
2135
interface);
2136
}
2137
2138
/* Raise privileges */
2139
ret_errno = raise_privileges();
2140
if(ret_errno != 0){
2141
errno = ret_errno;
2142
perror_plus("Failed to raise privileges");
2143
}
2144
2145
#ifdef __linux__
2146
int ret_linux;
2147
bool restore_loglevel = false;
2148
if(ret_errno == 0){
2149
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
2150
messages about the network interface to mess up the prompt */
2151
ret_linux = klogctl(8, NULL, 5);
2152
if(ret_linux == -1){
2153
perror_plus("klogctl");
2154
} else {
2155
restore_loglevel = true;
2156
}
2157
}
2158
#endif /* __linux__ */
2159
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
2160
ioctl_errno = errno;
2161
#ifdef __linux__
2162
if(restore_loglevel){
2163
ret_linux = klogctl(7, NULL, 0);
2164
if(ret_linux == -1){
2165
perror_plus("klogctl");
2166
}
2167
}
2168
#endif /* __linux__ */
2169
2170
/* If raise_privileges() succeeded above */
2171
if(ret_errno == 0){
2172
/* Lower privileges */
2173
ret_errno = lower_privileges();
2174
if(ret_errno != 0){
2175
errno = ret_errno;
2176
perror_plus("Failed to lower privileges");
2177
}
2178
}
2179
2180
/* Close the socket */
2181
ret = close(sd);
2182
if(ret == -1){
2183
perror_plus("close");
2184
}
2185
2186
if(ret_setflags == -1){
2187
errno = ioctl_errno;
2188
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
2189
errno = old_errno;
2190
return ioctl_errno;
2191
}
2192
} else if(debug){
2193
fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
2194
interface);
2195
}
2196
2197
/* Sleep checking until interface is running.
2198
Check every 0.25s, up to total time of delay */
2199
for(int i = 0; i < delay * 4; i++){
2200
if(interface_is_running(interface)){
2201
break;
2202
}
2203
struct timespec sleeptime = { .tv_nsec = 250000000 };
2204
ret = nanosleep(&sleeptime, NULL);
2205
if(ret == -1 and errno != EINTR){
2206
perror_plus("nanosleep");
2207
}
2208
}
2209
2210
errno = old_errno;
2211
return 0;
2212
}
2213
2214
__attribute__((nonnull, warn_unused_result))
2215
int take_down_interface(const char *const interface){
2216
int old_errno = errno;
2217
struct ifreq network;
2218
unsigned int if_index = if_nametoindex(interface);
2219
if(if_index == 0){
2220
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
2221
errno = old_errno;
2222
return ENXIO;
2223
}
2224
if(interface_is_up(interface)){
2225
int ret_errno = 0;
2226
int ioctl_errno = 0;
2227
if(not get_flags(interface, &network) and debug){
2228
ret_errno = errno;
2229
fprintf_plus(stderr, "Failed to get flags for interface "
2230
"\"%s\"\n", interface);
2231
errno = old_errno;
2232
return ret_errno;
2233
}
2234
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
2235
2236
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
2237
if(sd == -1){
2238
ret_errno = errno;
2239
perror_plus("socket");
2240
errno = old_errno;
2241
return ret_errno;
2242
}
2243
2244
if(debug){
2245
fprintf_plus(stderr, "Taking down interface \"%s\"\n",
2246
interface);
2247
}
2248
2249
/* Raise privileges */
2250
ret_errno = raise_privileges();
2251
if(ret_errno != 0){
2252
errno = ret_errno;
2253
perror_plus("Failed to raise privileges");
2254
}
2255
2256
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
2257
ioctl_errno = errno;
2258
2259
/* If raise_privileges() succeeded above */
2260
if(ret_errno == 0){
2261
/* Lower privileges */
2262
ret_errno = lower_privileges();
2263
if(ret_errno != 0){
2264
errno = ret_errno;
2265
perror_plus("Failed to lower privileges");
2266
}
2267
}
2268
2269
/* Close the socket */
2270
int ret = close(sd);
2271
if(ret == -1){
2272
perror_plus("close");
2273
}
2274
2275
if(ret_setflags == -1){
2276
errno = ioctl_errno;
2277
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
2278
errno = old_errno;
2279
return ioctl_errno;
2280
}
2281
} else if(debug){
2282
fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
2283
interface);
2284
}
2285
2286
errno = old_errno;
2287
return 0;
1476
if(connect_to != NULL){
1477
ret = setenv("CONNECT", connect_to, 1);
1478
if(ret == -1){
1479
perror_plus("setenv");
1480
_exit(EX_OSERR);
1481
}
1482
}
1483
if(execl(fullname, direntry->d_name, mode, NULL) == -1){
1484
perror_plus("execl");
1485
_exit(EXIT_FAILURE);
1486
}
1487
} else {
1488
int status;
1489
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1490
perror_plus("waitpid");
1491
free(fullname);
1492
continue;
1493
}
1494
if(WIFEXITED(status)){
1495
if(WEXITSTATUS(status) != 0){
1496
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1497
" with status %d\n", direntry->d_name,
1498
WEXITSTATUS(status));
1499
free(fullname);
1500
continue;
1501
}
1502
} else if(WIFSIGNALED(status)){
1503
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1504
" signal %d\n", direntry->d_name,
1505
WTERMSIG(status));
1506
free(fullname);
1507
continue;
1508
} else {
1509
fprintf_plus(stderr, "Warning: network hook \"%s\""
1510
" crashed\n", direntry->d_name);
1511
free(fullname);
1512
continue;
1513
}
1514
}
1515
free(fullname);
1516
if(debug){
1517
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1518
direntry->d_name);
1519
}
1520
}
1521
close(devnull);
1522
}
1523
return true;
2288
1524
}
2289
1525
2290
1526
int main(int argc, char *argv[]){
2291
mandos_context mc = { .server = NULL, .dh_bits = 0,
2292
.priority = "SECURE256:!CTYPE-X.509"
2293
":+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256",
2294
.current_server = NULL, .interfaces = NULL,
2295
.interfaces_size = 0 };
2296
1527
AvahiSServiceBrowser *sb = NULL;
2297
error_t ret_errno;
1528
int error;
2298
1529
int ret;
2299
1530
intmax_t tmpmax;
2300
1531
char *tmp;
2301
1532
int exitcode = EXIT_SUCCESS;
2302
char *interfaces_to_take_down = NULL;
2303
size_t interfaces_to_take_down_size = 0;
2304
char run_tempdir[] = "/run/tmp/mandosXXXXXX";
2305
char old_tempdir[] = "/tmp/mandosXXXXXX";
2306
char *tempdir = NULL;
1533
const char *interface = "";
1534
struct ifreq network;
1535
int sd = -1;
1536
bool take_down_interface = false;
1537
uid_t uid;
1538
gid_t gid;
1539
char tempdir[] = "/tmp/mandosXXXXXX";
1540
bool tempdir_created = false;
2307
1541
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
2308
1542
const char *seckey = PATHDIR "/" SECKEY;
2309
1543
const char *pubkey = PATHDIR "/" PUBKEY;
2310
const char *dh_params_file = NULL;
2311
char *interfaces_hooks = NULL;
2312
1544
2313
1545
bool gnutls_initialized = false;
2314
1546
bool gpgme_initialized = false;
2366
1598
.doc = "Bit length of the prime number used in the"
2367
1599
" Diffie-Hellman key exchange",
2368
1600
.group = 2 },
2369
{ .name = "dh-params", .key = 134,
2370
.arg = "FILE",
2371
.doc = "PEM-encoded PKCS#3 file with pre-generated parameters"
2372
" for the Diffie-Hellman key exchange",
2373
.group = 2 },
2374
1601
{ .name = "priority", .key = 130,
2375
1602
.arg = "STRING",
2376
1603
.doc = "GnuTLS priority string for the TLS handshake",
2410
1637
connect_to = arg;
2411
1638
break;
2412
1639
case 'i': /* --interface */
2413
ret_errno = argz_add_sep(&mc.interfaces, &mc.interfaces_size,
2414
arg, (int)',');
2415
if(ret_errno != 0){
2416
argp_error(state, "%s", strerror(ret_errno));
2417
}
1640
interface = arg;
2418
1641
break;
2419
1642
case 's': /* --seckey */
2420
1643
seckey = arg;
2431
1654
}
2432
1655
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
2433
1656
break;
2434
case 134: /* --dh-params */
2435
dh_params_file = arg;
2436
break;
2437
1657
case 130: /* --priority */
2438
1658
mc.priority = arg;
2439
1659
break;
2479
1699
.args_doc = "",
2480
1700
.doc = "Mandos client -- Get and decrypt"
2481
1701
" passwords from a Mandos server" };
2482
ret_errno = argp_parse(&argp, argc, argv,
2483
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2484
switch(ret_errno){
1702
ret = argp_parse(&argp, argc, argv,
1703
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
1704
switch(ret){
2485
1705
case 0:
2486
1706
break;
2487
1707
case ENOMEM:
2488
1708
default:
2489
errno = ret_errno;
1709
errno = ret;
2490
1710
perror_plus("argp_parse");
2491
1711
exitcode = EX_OSERR;
2492
1712
goto end;
2495
1715
goto end;
2496
1716
}
2497
1717
}
2498
1718
2499
1719
{
2500
1720
/* Work around Debian bug #633582:
2501
<https://bugs.debian.org/633582> */
1721
<http://bugs.debian.org/633582> */
2502
1722
2503
/* Re-raise privileges */
2504
ret = raise_privileges();
2505
if(ret != 0){
2506
errno = ret;
2507
perror_plus("Failed to raise privileges");
1723
/* Re-raise priviliges */
1724
errno = 0;
1725
ret = seteuid(0);
1726
if(ret == -1){
1727
perror_plus("seteuid");
2508
1728
} else {
2509
1729
struct stat st;
2510
1730
2525
1745
}
2526
1746
}
2527
1747
}
2528
close(seckey_fd);
1748
TEMP_FAILURE_RETRY(close(seckey_fd));
2529
1749
}
2530
1750
}
2531
1751
2532
1752
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2533
1753
int pubkey_fd = open(pubkey, O_RDONLY);
2534
1754
if(pubkey_fd == -1){
2546
1766
}
2547
1767
}
2548
1768
}
2549
close(pubkey_fd);
2550
}
2551
}
2552
2553
if(dh_params_file != NULL
2554
and strcmp(dh_params_file, PATHDIR "/dhparams.pem" ) == 0){
2555
int dhparams_fd = open(dh_params_file, O_RDONLY);
2556
if(dhparams_fd == -1){
2557
perror_plus("open");
2558
} else {
2559
ret = (int)TEMP_FAILURE_RETRY(fstat(dhparams_fd, &st));
2560
if(ret == -1){
2561
perror_plus("fstat");
2562
} else {
2563
if(S_ISREG(st.st_mode)
2564
and st.st_uid == 0 and st.st_gid == 0){
2565
ret = fchown(dhparams_fd, uid, gid);
2566
if(ret == -1){
2567
perror_plus("fchown");
2568
}
2569
}
2570
}
2571
close(dhparams_fd);
2572
}
2573
}
2574
1769
TEMP_FAILURE_RETRY(close(pubkey_fd));
1770
}
1771
}
1772
2575
1773
/* Lower privileges */
2576
ret = lower_privileges();
2577
if(ret != 0){
2578
errno = ret;
2579
perror_plus("Failed to lower privileges");
2580
}
2581
}
2582
}
2583
2584
/* Remove invalid interface names (except "none") */
2585
{
2586
char *interface = NULL;
2587
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2588
interface))){
2589
if(strcmp(interface, "none") != 0
2590
and if_nametoindex(interface) == 0){
2591
if(interface[0] != '\0'){
2592
fprintf_plus(stderr, "Not using nonexisting interface"
2593
" \"%s\"\n", interface);
2594
}
2595
argz_delete(&mc.interfaces, &mc.interfaces_size, interface);
2596
interface = NULL;
1774
errno = 0;
1775
ret = seteuid(uid);
1776
if(ret == -1){
1777
perror_plus("seteuid");
2597
1778
}
2598
1779
}
2599
1780
}
2600
1781
2601
1782
/* Run network hooks */
2602
{
2603
if(mc.interfaces != NULL){
2604
interfaces_hooks = malloc(mc.interfaces_size);
2605
if(interfaces_hooks == NULL){
2606
perror_plus("malloc");
2607
goto end;
2608
}
2609
memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
2610
argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
2611
}
2612
run_network_hooks("start", interfaces_hooks != NULL ?
2613
interfaces_hooks : "", delay);
1783
if(not run_network_hooks("start", interface, delay)){
1784
goto end;
2614
1785
}
2615
1786
2616
1787
if(not debug){
2617
1788
avahi_set_log_function(empty_log);
2618
1789
}
2619
1790
1791
if(interface[0] == '\0'){
1792
struct dirent **direntries;
1793
/* First look for interfaces that are up */
1794
ret = scandir(sys_class_net, &direntries, up_interface,
1795
alphasort);
1796
if(ret == 0){
1797
/* No up interfaces, look for any good interfaces */
1798
free(direntries);
1799
ret = scandir(sys_class_net, &direntries, good_interface,
1800
alphasort);
1801
}
1802
if(ret >= 1){
1803
/* Pick the first interface returned */
1804
interface = strdup(direntries[0]->d_name);
1805
if(debug){
1806
fprintf_plus(stderr, "Using interface \"%s\"\n", interface);
1807
}
1808
if(interface == NULL){
1809
perror_plus("malloc");
1810
free(direntries);
1811
exitcode = EXIT_FAILURE;
1812
goto end;
1813
}
1814
free(direntries);
1815
} else {
1816
free(direntries);
1817
fprintf_plus(stderr, "Could not find a network interface\n");
1818
exitcode = EXIT_FAILURE;
1819
goto end;
1820
}
1821
}
1822
2620
1823
/* Initialize Avahi early so avahi_simple_poll_quit() can be called
2621
1824
from the signal handler */
2622
1825
/* Initialize the pseudo-RNG for Avahi */
2623
1826
srand((unsigned int) time(NULL));
2624
simple_poll = avahi_simple_poll_new();
2625
if(simple_poll == NULL){
1827
mc.simple_poll = avahi_simple_poll_new();
1828
if(mc.simple_poll == NULL){
2626
1829
fprintf_plus(stderr,
2627
1830
"Avahi: Failed to create simple poll object.\n");
2628
1831
exitcode = EX_UNAVAILABLE;
2692
1895
}
2693
1896
}
2694
1897
2695
/* If no interfaces were specified, make a list */
2696
if(mc.interfaces == NULL){
2697
struct dirent **direntries = NULL;
2698
/* Look for any good interfaces */
2699
ret = scandir(sys_class_net, &direntries, good_interface,
2700
alphasort);
2701
if(ret >= 1){
2702
/* Add all found interfaces to interfaces list */
2703
for(int i = 0; i < ret; ++i){
2704
ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
2705
direntries[i]->d_name);
2706
if(ret_errno != 0){
2707
errno = ret_errno;
2708
perror_plus("argz_add");
2709
free(direntries[i]);
2710
continue;
2711
}
2712
if(debug){
2713
fprintf_plus(stderr, "Will use interface \"%s\"\n",
2714
direntries[i]->d_name);
2715
}
2716
free(direntries[i]);
2717
}
2718
free(direntries);
2719
} else {
2720
if(ret == 0){
2721
free(direntries);
2722
}
2723
fprintf_plus(stderr, "Could not find a network interface\n");
2724
exitcode = EXIT_FAILURE;
2725
goto end;
2726
}
2727
}
2728
2729
/* Bring up interfaces which are down, and remove any "none"s */
2730
{
2731
char *interface = NULL;
2732
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2733
interface))){
2734
/* If interface name is "none", stop bringing up interfaces.
2735
Also remove all instances of "none" from the list */
2736
if(strcmp(interface, "none") == 0){
2737
argz_delete(&mc.interfaces, &mc.interfaces_size,
2738
interface);
2739
interface = NULL;
2740
while((interface = argz_next(mc.interfaces,
2741
mc.interfaces_size, interface))){
2742
if(strcmp(interface, "none") == 0){
2743
argz_delete(&mc.interfaces, &mc.interfaces_size,
2744
interface);
2745
interface = NULL;
1898
/* If the interface is down, bring it up */
1899
if(strcmp(interface, "none") != 0){
1900
if_index = (AvahiIfIndex) if_nametoindex(interface);
1901
if(if_index == 0){
1902
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1903
exitcode = EX_UNAVAILABLE;
1904
goto end;
1905
}
1906
1907
if(quit_now){
1908
goto end;
1909
}
1910
1911
/* Re-raise priviliges */
1912
errno = 0;
1913
ret = seteuid(0);
1914
if(ret == -1){
1915
perror_plus("seteuid");
1916
}
1917
1918
#ifdef __linux__
1919
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1920
messages about the network interface to mess up the prompt */
1921
ret = klogctl(8, NULL, 5);
1922
bool restore_loglevel = true;
1923
if(ret == -1){
1924
restore_loglevel = false;
1925
perror_plus("klogctl");
1926
}
1927
#endif /* __linux__ */
1928
1929
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1930
if(sd < 0){
1931
perror_plus("socket");
1932
exitcode = EX_OSERR;
1933
#ifdef __linux__
1934
if(restore_loglevel){
1935
ret = klogctl(7, NULL, 0);
1936
if(ret == -1){
1937
perror_plus("klogctl");
1938
}
1939
}
1940
#endif /* __linux__ */
1941
/* Lower privileges */
1942
errno = 0;
1943
ret = seteuid(uid);
1944
if(ret == -1){
1945
perror_plus("seteuid");
1946
}
1947
goto end;
1948
}
1949
strcpy(network.ifr_name, interface);
1950
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1951
if(ret == -1){
1952
perror_plus("ioctl SIOCGIFFLAGS");
1953
#ifdef __linux__
1954
if(restore_loglevel){
1955
ret = klogctl(7, NULL, 0);
1956
if(ret == -1){
1957
perror_plus("klogctl");
1958
}
1959
}
1960
#endif /* __linux__ */
1961
exitcode = EX_OSERR;
1962
/* Lower privileges */
1963
errno = 0;
1964
ret = seteuid(uid);
1965
if(ret == -1){
1966
perror_plus("seteuid");
1967
}
1968
goto end;
1969
}
1970
if((network.ifr_flags & IFF_UP) == 0){
1971
network.ifr_flags |= IFF_UP;
1972
take_down_interface = true;
1973
ret = ioctl(sd, SIOCSIFFLAGS, &network);
1974
if(ret == -1){
1975
take_down_interface = false;
1976
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1977
exitcode = EX_OSERR;
1978
#ifdef __linux__
1979
if(restore_loglevel){
1980
ret = klogctl(7, NULL, 0);
1981
if(ret == -1){
1982
perror_plus("klogctl");
2746
1983
}
2747
1984
}
1985
#endif /* __linux__ */
1986
/* Lower privileges */
1987
errno = 0;
1988
ret = seteuid(uid);
1989
if(ret == -1){
1990
perror_plus("seteuid");
1991
}
1992
goto end;
1993
}
1994
}
1995
/* Sleep checking until interface is running.
1996
Check every 0.25s, up to total time of delay */
1997
for(int i=0; i < delay * 4; i++){
1998
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1999
if(ret == -1){
2000
perror_plus("ioctl SIOCGIFFLAGS");
2001
} else if(network.ifr_flags & IFF_RUNNING){
2748
2002
break;
2749
2003
}
2750
bool interface_was_up = interface_is_up(interface);
2751
errno = bring_up_interface(interface, delay);
2752
if(not interface_was_up){
2753
if(errno != 0){
2754
fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
2755
" %s\n", interface, strerror(errno));
2756
} else {
2757
errno = argz_add(&interfaces_to_take_down,
2758
&interfaces_to_take_down_size,
2759
interface);
2760
if(errno != 0){
2761
perror_plus("argz_add");
2762
}
2763
}
2764
}
2765
}
2766
if(debug and (interfaces_to_take_down == NULL)){
2767
fprintf_plus(stderr, "No interfaces were brought up\n");
2768
}
2769
}
2770
2771
/* If we only got one interface, explicitly use only that one */
2772
if(argz_count(mc.interfaces, mc.interfaces_size) == 1){
2773
if(debug){
2774
fprintf_plus(stderr, "Using only interface \"%s\"\n",
2775
mc.interfaces);
2776
}
2777
if_index = (AvahiIfIndex)if_nametoindex(mc.interfaces);
2004
struct timespec sleeptime = { .tv_nsec = 250000000 };
2005
ret = nanosleep(&sleeptime, NULL);
2006
if(ret == -1 and errno != EINTR){
2007
perror_plus("nanosleep");
2008
}
2009
}
2010
if(not take_down_interface){
2011
/* We won't need the socket anymore */
2012
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2013
if(ret == -1){
2014
perror_plus("close");
2015
}
2016
}
2017
#ifdef __linux__
2018
if(restore_loglevel){
2019
/* Restores kernel loglevel to default */
2020
ret = klogctl(7, NULL, 0);
2021
if(ret == -1){
2022
perror_plus("klogctl");
2023
}
2024
}
2025
#endif /* __linux__ */
2026
/* Lower privileges */
2027
errno = 0;
2028
/* Lower privileges */
2029
ret = seteuid(uid);
2030
if(ret == -1){
2031
perror_plus("seteuid");
2032
}
2778
2033
}
2779
2034
2780
2035
if(quit_now){
2781
2036
goto end;
2782
2037
}
2783
2038
2784
ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
2039
ret = init_gnutls_global(pubkey, seckey);
2785
2040
if(ret == -1){
2786
2041
fprintf_plus(stderr, "init_gnutls_global failed\n");
2787
2042
exitcode = EX_UNAVAILABLE;
2794
2049
goto end;
2795
2050
}
2796
2051
2797
/* Try /run/tmp before /tmp */
2798
tempdir = mkdtemp(run_tempdir);
2799
if(tempdir == NULL and errno == ENOENT){
2800
if(debug){
2801
fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
2802
run_tempdir, old_tempdir);
2803
}
2804
tempdir = mkdtemp(old_tempdir);
2805
}
2806
if(tempdir == NULL){
2052
if(mkdtemp(tempdir) == NULL){
2807
2053
perror_plus("mkdtemp");
2808
2054
goto end;
2809
2055
}
2056
tempdir_created = true;
2810
2057
2811
2058
if(quit_now){
2812
2059
goto end;
2813
2060
}
2814
2061
2815
if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
2062
if(not init_gpgme(pubkey, seckey, tempdir)){
2816
2063
fprintf_plus(stderr, "init_gpgme failed\n");
2817
2064
exitcode = EX_UNAVAILABLE;
2818
2065
goto end;
2828
2075
/* Connect directly, do not use Zeroconf */
2829
2076
/* (Mainly meant for debugging) */
2830
2077
char *address = strrchr(connect_to, ':');
2831
2832
2078
if(address == NULL){
2833
2079
fprintf_plus(stderr, "No colon in address\n");
2834
2080
exitcode = EX_USAGE;
2839
2085
goto end;
2840
2086
}
2841
2087
2842
in_port_t port;
2088
uint16_t port;
2843
2089
errno = 0;
2844
2090
tmpmax = strtoimax(address+1, &tmp, 10);
2845
2091
if(errno != 0 or tmp == address+1 or *tmp != '\0'
2846
or tmpmax != (in_port_t)tmpmax){
2092
or tmpmax != (uint16_t)tmpmax){
2847
2093
fprintf_plus(stderr, "Bad port number\n");
2848
2094
exitcode = EX_USAGE;
2849
2095
goto end;
2850
2096
}
2851
2097
2852
2098
if(quit_now){
2853
2099
goto end;
2854
2100
}
2855
2101
2856
port = (in_port_t)tmpmax;
2102
port = (uint16_t)tmpmax;
2857
2103
*address = '\0';
2858
2104
/* Colon in address indicates IPv6 */
2859
2105
int af;
2875
2121
}
2876
2122
2877
2123
while(not quit_now){
2878
ret = start_mandos_communication(address, port, if_index, af,
2879
&mc);
2124
ret = start_mandos_communication(address, port, if_index, af);
2880
2125
if(quit_now or ret == 0){
2881
2126
break;
2882
2127
}
2884
2129
fprintf_plus(stderr, "Retrying in %d seconds\n",
2885
2130
(int)retry_interval);
2886
2131
}
2887
sleep((unsigned int)retry_interval);
2132
sleep((int)retry_interval);
2888
2133
}
2889
2134
2890
if(not quit_now){
2135
if (not quit_now){
2891
2136
exitcode = EXIT_SUCCESS;
2892
2137
}
2893
2138
2908
2153
config.publish_domain = 0;
2909
2154
2910
2155
/* Allocate a new server */
2911
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
2912
&config, NULL, NULL, &ret);
2156
mc.server = avahi_server_new(avahi_simple_poll_get
2157
(mc.simple_poll), &config, NULL,
2158
NULL, &error);
2913
2159
2914
2160
/* Free the Avahi configuration data */
2915
2161
avahi_server_config_free(&config);
2918
2164
/* Check if creating the Avahi server object succeeded */
2919
2165
if(mc.server == NULL){
2920
2166
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2921
avahi_strerror(ret));
2167
avahi_strerror(error));
2922
2168
exitcode = EX_UNAVAILABLE;
2923
2169
goto end;
2924
2170
}
2930
2176
/* Create the Avahi service browser */
2931
2177
sb = avahi_s_service_browser_new(mc.server, if_index,
2932
2178
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
2933
NULL, 0, browse_callback,
2934
(void *)&mc);
2179
NULL, 0, browse_callback, NULL);
2935
2180
if(sb == NULL){
2936
2181
fprintf_plus(stderr, "Failed to create service browser: %s\n",
2937
2182
avahi_strerror(avahi_server_errno(mc.server)));
2948
2193
if(debug){
2949
2194
fprintf_plus(stderr, "Starting Avahi loop search\n");
2950
2195
}
2951
2952
ret = avahi_loop_with_timeout(simple_poll,
2953
(int)(retry_interval * 1000), &mc);
2196
2197
ret = avahi_loop_with_timeout(mc.simple_poll,
2198
(int)(retry_interval * 1000));
2954
2199
if(debug){
2955
2200
fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
2956
2201
(ret == 0) ? "successfully" : "with error");
2959
2204
end:
2960
2205
2961
2206
if(debug){
2962
if(signal_received){
2963
fprintf_plus(stderr, "%s exiting due to signal %d: %s\n",
2964
argv[0], signal_received,
2965
strsignal(signal_received));
2966
} else {
2967
fprintf_plus(stderr, "%s exiting\n", argv[0]);
2968
}
2207
fprintf_plus(stderr, "%s exiting\n", argv[0]);
2969
2208
}
2970
2209
2971
2210
/* Cleanup things */
2972
free(mc.interfaces);
2973
2974
2211
if(sb != NULL)
2975
2212
avahi_s_service_browser_free(sb);
2976
2213
2977
2214
if(mc.server != NULL)
2978
2215
avahi_server_free(mc.server);
2979
2216
2980
if(simple_poll != NULL)
2981
avahi_simple_poll_free(simple_poll);
2217
if(mc.simple_poll != NULL)
2218
avahi_simple_poll_free(mc.simple_poll);
2982
2219
2983
2220
if(gnutls_initialized){
2984
2221
gnutls_certificate_free_credentials(mc.cred);
2222
gnutls_global_deinit();
2985
2223
gnutls_dh_params_deinit(mc.dh_params);
2986
2224
}
2987
2225
2995
2233
mc.current_server->prev->next = NULL;
2996
2234
while(mc.current_server != NULL){
2997
2235
server *next = mc.current_server->next;
2998
#ifdef __GNUC__
2999
#pragma GCC diagnostic push
3000
#pragma GCC diagnostic ignored "-Wcast-qual"
3001
#endif
3002
free((char *)(mc.current_server->ip));
3003
#ifdef __GNUC__
3004
#pragma GCC diagnostic pop
3005
#endif
3006
2236
free(mc.current_server);
3007
2237
mc.current_server = next;
3008
2238
}
3009
2239
}
3010
2240
3011
/* Re-raise privileges */
2241
/* Run network hooks */
2242
run_network_hooks("stop", interface, delay);
2243
2244
/* Re-raise priviliges */
3012
2245
{
3013
ret = raise_privileges();
3014
if(ret != 0){
3015
errno = ret;
3016
perror_plus("Failed to raise privileges");
3017
} else {
3018
3019
/* Run network hooks */
3020
run_network_hooks("stop", interfaces_hooks != NULL ?
3021
interfaces_hooks : "", delay);
3022
3023
/* Take down the network interfaces which were brought up */
3024
{
3025
char *interface = NULL;
3026
while((interface = argz_next(interfaces_to_take_down,
3027
interfaces_to_take_down_size,
3028
interface))){
3029
ret = take_down_interface(interface);
3030
if(ret != 0){
3031
errno = ret;
3032
perror_plus("Failed to take down interface");
3033
}
3034
}
3035
if(debug and (interfaces_to_take_down == NULL)){
3036
fprintf_plus(stderr, "No interfaces needed to be taken"
3037
" down\n");
3038
}
3039
}
2246
errno = 0;
2247
ret = seteuid(0);
2248
if(ret == -1){
2249
perror_plus("seteuid");
3040
2250
}
3041
2251
3042
ret = lower_privileges_permanently();
3043
if(ret != 0){
3044
errno = ret;
3045
perror_plus("Failed to lower privileges permanently");
2252
/* Take down the network interface */
2253
if(take_down_interface and geteuid() == 0){
2254
ret = ioctl(sd, SIOCGIFFLAGS, &network);
2255
if(ret == -1){
2256
perror_plus("ioctl SIOCGIFFLAGS");
2257
} else if(network.ifr_flags & IFF_UP){
2258
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
2259
ret = ioctl(sd, SIOCSIFFLAGS, &network);
2260
if(ret == -1){
2261
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
2262
}
2263
}
2264
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2265
if(ret == -1){
2266
perror_plus("close");
2267
}
3046
2268
}
3047
2269
}
3048
3049
free(interfaces_to_take_down);
3050
free(interfaces_hooks);
3051
3052
void clean_dir_at(int base, const char * const dirname,
3053
uintmax_t level){
2270
/* Lower privileges permanently */
2271
errno = 0;
2272
ret = setuid(uid);
2273
if(ret == -1){
2274
perror_plus("setuid");
2275
}
2276
2277
/* Removes the GPGME temp directory and all files inside */
2278
if(tempdir_created){
3054
2279
struct dirent **direntries = NULL;
3055
int dret;
3056
int dir_fd = (int)TEMP_FAILURE_RETRY(openat(base, dirname,
3057
O_RDONLY
3058
| O_NOFOLLOW
3059
| O_DIRECTORY
3060
| O_PATH));
3061
if(dir_fd == -1){
3062
perror_plus("open");
3063
}
3064
int numentries = scandirat(dir_fd, ".", &direntries,
3065
notdotentries, alphasort);
3066
if(numentries >= 0){
2280
struct dirent *direntry = NULL;
2281
int numentries = scandir(tempdir, &direntries, notdotentries,
2282
alphasort);
2283
if (numentries > 0){
3067
2284
for(int i = 0; i < numentries; i++){
3068
if(debug){
3069
fprintf_plus(stderr, "Unlinking \"%s/%s\"\n",
3070
dirname, direntries[i]->d_name);
3071
}
3072
dret = unlinkat(dir_fd, direntries[i]->d_name, 0);
3073
if(dret == -1){
3074
if(errno == EISDIR){
3075
dret = unlinkat(dir_fd, direntries[i]->d_name,
3076
AT_REMOVEDIR);
3077
}
3078
if((dret == -1) and (errno == ENOTEMPTY)
3079
and (strcmp(direntries[i]->d_name, "private-keys-v1.d")
3080
== 0) and (level == 0)){
3081
/* Recurse only in this special case */
3082
clean_dir_at(dir_fd, direntries[i]->d_name, level+1);
3083
dret = 0;
3084
}
3085
if(dret == -1){
3086
fprintf_plus(stderr, "unlink(\"%s/%s\"): %s\n", dirname,
3087
direntries[i]->d_name, strerror(errno));
3088
}
3089
}
3090
free(direntries[i]);
3091
}
3092
3093
/* need to clean even if 0 because man page doesn't specify */
3094
free(direntries);
3095
if(numentries == -1){
3096
perror_plus("scandirat");
3097
}
3098
dret = unlinkat(base, dirname, AT_REMOVEDIR);
3099
if(dret == -1 and errno != ENOENT){
3100
perror_plus("rmdir");
3101
}
3102
} else {
3103
perror_plus("scandirat");
3104
}
3105
close(dir_fd);
3106
}
3107
3108
/* Removes the GPGME temp directory and all files inside */
3109
if(tempdir != NULL){
3110
clean_dir_at(-1, tempdir, 0);
2285
direntry = direntries[i];
2286
char *fullname = NULL;
2287
ret = asprintf(&fullname, "%s/%s", tempdir,
2288
direntry->d_name);
2289
if(ret < 0){
2290
perror_plus("asprintf");
2291
continue;
2292
}
2293
ret = remove(fullname);
2294
if(ret == -1){
2295
fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2296
strerror(errno));
2297
}
2298
free(fullname);
2299
}
2300
}
2301
2302
/* need to clean even if 0 because man page doesn't specify */
2303
free(direntries);
2304
if (numentries == -1){
2305
perror_plus("scandir");
2306
}
2307
ret = rmdir(tempdir);
2308
if(ret == -1 and errno != ENOENT){
2309
perror_plus("rmdir");
2310
}
3111
2311
}
3112
2312
3113
2313
if(quit_now){
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0