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