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