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 833
- compare with another revision
- download diff
- download tarball
- view history from revision 833
- Committer: Teddy Hogeborn
- Date: 2016-03-17 20:40:55 UTC
- Revision ID: teddy@recompile.se-20160317204055-bhsh5xsidq7w5cxu
Client: Fix plymouth agent; broken since 1.7.2.
Fix an very old memory bug in the plymouth agent (which has been
present since its apperance in version 1.2), but which was only
recently detected at run time due to the new -fsanitize=address
compile- time flag, which has been used since version 1.7.2. This
detection of a memory access violation causes the program to abort,
making the Plymouth graphical boot system unable to accept interactive
input of passwords when using the Mandos client.
* plugins.d/plymouth.c (exec_and_wait): Fix memory allocation bug when
allocating new_argv. Also tolerate a zero-length argv.
Fix an very old memory bug in the plymouth agent (which has been
present since its apperance in version 1.2), but which was only
recently detected at run time due to the new -fsanitize=address
compile- time flag, which has been used since version 1.7.2. This
detection of a memory access violation causes the program to abort,
making the Plymouth graphical boot system unable to accept interactive
input of passwords when using the Mandos client.
* plugins.d/plymouth.c (exec_and_wait): Fix memory allocation bug when
allocating new_argv. Also tolerate a zero-length argv.
- files added:
- 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-2011 Teddy Hogeborn
13
* Copyright © 2008-2011 Björn Påhlsson
12
* Copyright © 2008-2016 Teddy Hogeborn
13
* Copyright © 2008-2016 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() */
44
#include <stdint.h> /* uint16_t, uint32_t */
43
stdout, ferror() */
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(), strncpy() */
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(), AT_REMOVEDIR */
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
#include <errno.h> /* perror(), errno,
65
#include <errno.h> /* perror(), errno, EINTR, EINVAL,
66
EAI_SYSTEM, ENETUNREACH,
67
EHOSTUNREACH, ECONNREFUSED, EPROTO,
68
EIO, ENOENT, ENXIO, ENOMEM, EISDIR,
69
ENOTEMPTY,
66
70
program_invocation_short_name */
67
71
#include <time.h> /* nanosleep(), time(), sleep() */
68
72
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
73
77
*/
74
78
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
75
79
getuid(), getgid(), seteuid(),
76
setgid(), pause() */
77
#include <arpa/inet.h> /* inet_pton(), htons, inet_ntop() */
80
setgid(), pause(), _exit(),
81
unlinkat() */
82
#include <arpa/inet.h> /* inet_pton(), htons() */
78
83
#include <iso646.h> /* not, or, and */
79
84
#include <argp.h> /* struct argp_option, error_t, struct
80
85
argp_state, struct argp,
87
92
EX_NOHOST, EX_IOERR, EX_PROTOCOL */
88
93
#include <sys/wait.h> /* waitpid(), WIFEXITED(),
89
94
WEXITSTATUS(), WTERMSIG() */
95
#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() */
90
102
91
103
#ifdef __linux__
92
104
#include <sys/klog.h> /* klogctl() */
134
146
static const char sys_class_net[] = "/sys/class/net";
135
147
char *connect_to = NULL;
136
148
const char *hookdir = HOOKDIR;
149
int hookdir_fd = -1;
150
uid_t uid = 65534;
151
gid_t gid = 65534;
137
152
138
153
/* Doubly linked list that need to be circularly linked when used */
139
154
typedef struct server{
140
155
const char *ip;
141
uint16_t port;
156
in_port_t port;
142
157
AvahiIfIndex if_index;
143
158
int af;
144
159
struct timespec last_seen;
148
163
149
164
/* Used for passing in values through the Avahi callback functions */
150
165
typedef struct {
151
AvahiSimplePoll *simple_poll;
152
166
AvahiServer *server;
153
167
gnutls_certificate_credentials_t cred;
154
168
unsigned int dh_bits;
156
170
const char *priority;
157
171
gpgme_ctx_t ctx;
158
172
server *current_server;
173
char *interfaces;
174
size_t interfaces_size;
159
175
} mandos_context;
160
176
161
/* global context so signal handler can reach it*/
162
mandos_context mc = { .simple_poll = NULL, .server = NULL,
163
.dh_bits = 1024, .priority = "SECURE256"
164
":!CTYPE-X.509:+CTYPE-OPENPGP",
165
.current_server = NULL };
177
/* global so signal handler can reach it*/
178
AvahiSimplePoll *simple_poll;
166
179
167
180
sig_atomic_t quit_now = 0;
168
181
int signal_received = 0;
169
182
170
183
/* Function to use when printing errors */
171
184
void perror_plus(const char *print_text){
185
int e = errno;
172
186
fprintf(stderr, "Mandos plugin %s: ",
173
187
program_invocation_short_name);
188
errno = e;
174
189
perror(print_text);
175
190
}
176
191
192
__attribute__((format (gnu_printf, 2, 3), nonnull))
177
193
int fprintf_plus(FILE *stream, const char *format, ...){
178
194
va_list ap;
179
195
va_start (ap, format);
180
196
181
197
TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
182
198
program_invocation_short_name));
183
return TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
199
return (int)TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
184
200
}
185
201
186
202
/*
188
204
* bytes. "buffer_capacity" is how much is currently allocated,
189
205
* "buffer_length" is how much is already used.
190
206
*/
207
__attribute__((nonnull, warn_unused_result))
191
208
size_t incbuffer(char **buffer, size_t buffer_length,
192
209
size_t buffer_capacity){
193
210
if(buffer_length + BUFFER_SIZE > buffer_capacity){
194
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
195
if(buffer == NULL){
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;
196
217
return 0;
197
218
}
219
*buffer = new_buf;
198
220
buffer_capacity += BUFFER_SIZE;
199
221
}
200
222
return buffer_capacity;
201
223
}
202
224
203
225
/* Add server to set of servers to retry periodically */
204
int add_server(const char *ip, uint16_t port, AvahiIfIndex if_index,
205
int af){
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){
206
229
int ret;
207
230
server *new_server = malloc(sizeof(server));
208
231
if(new_server == NULL){
209
232
perror_plus("malloc");
210
return -1;
233
return false;
211
234
}
212
235
*new_server = (server){ .ip = strdup(ip),
213
236
.port = port,
215
238
.af = af };
216
239
if(new_server->ip == NULL){
217
240
perror_plus("strdup");
218
return -1;
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
return false;
219
257
}
220
258
/* Special case of first server */
221
if (mc.current_server == NULL){
259
if(*current_server == NULL){
222
260
new_server->next = new_server;
223
261
new_server->prev = new_server;
224
mc.current_server = new_server;
225
/* Place the new server last in the list */
262
*current_server = new_server;
226
263
} else {
227
new_server->next = mc.current_server;
228
new_server->prev = mc.current_server->prev;
264
/* Place the new server last in the list */
265
new_server->next = *current_server;
266
new_server->prev = (*current_server)->prev;
229
267
new_server->prev->next = new_server;
230
mc.current_server->prev = new_server;
231
}
232
ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);
233
if(ret == -1){
234
perror_plus("clock_gettime");
235
return -1;
236
}
237
return 0;
268
(*current_server)->prev = new_server;
269
}
270
return true;
238
271
}
239
272
240
273
/*
241
274
* Initialize GPGME.
242
275
*/
243
static bool init_gpgme(const char *seckey, const char *pubkey,
244
const char *tempdir){
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){
245
281
gpgme_error_t rc;
246
282
gpgme_engine_info_t engine_info;
247
283
248
249
284
/*
250
285
* Helper function to insert pub and seckey to the engine keyring.
251
286
*/
252
bool import_key(const char *filename){
287
bool import_key(const char * const filename){
253
288
int ret;
254
289
int fd;
255
290
gpgme_data_t pgp_data;
267
302
return false;
268
303
}
269
304
270
rc = gpgme_op_import(mc.ctx, pgp_data);
305
rc = gpgme_op_import(mc->ctx, pgp_data);
271
306
if(rc != GPG_ERR_NO_ERROR){
272
307
fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
273
308
gpgme_strsource(rc), gpgme_strerror(rc));
274
309
return false;
275
310
}
276
311
277
ret = (int)TEMP_FAILURE_RETRY(close(fd));
312
ret = close(fd);
278
313
if(ret == -1){
279
314
perror_plus("close");
280
315
}
317
352
}
318
353
319
354
/* Create new GPGME "context" */
320
rc = gpgme_new(&(mc.ctx));
355
rc = gpgme_new(&(mc->ctx));
321
356
if(rc != GPG_ERR_NO_ERROR){
322
357
fprintf_plus(stderr, "Mandos plugin mandos-client: "
323
358
"bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
336
371
* Decrypt OpenPGP data.
337
372
* Returns -1 on error
338
373
*/
374
__attribute__((nonnull, warn_unused_result))
339
375
static ssize_t pgp_packet_decrypt(const char *cryptotext,
340
376
size_t crypto_size,
341
char **plaintext){
377
char **plaintext,
378
mandos_context *mc){
342
379
gpgme_data_t dh_crypto, dh_plain;
343
380
gpgme_error_t rc;
344
381
ssize_t ret;
370
407
371
408
/* Decrypt data from the cryptotext data buffer to the plaintext
372
409
data buffer */
373
rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
410
rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
374
411
if(rc != GPG_ERR_NO_ERROR){
375
412
fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
376
413
gpgme_strsource(rc), gpgme_strerror(rc));
377
414
plaintext_length = -1;
378
415
if(debug){
379
416
gpgme_decrypt_result_t result;
380
result = gpgme_op_decrypt_result(mc.ctx);
417
result = gpgme_op_decrypt_result(mc->ctx);
381
418
if(result == NULL){
382
419
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
383
420
} else {
460
497
return plaintext_length;
461
498
}
462
499
463
static const char * safer_gnutls_strerror(int value){
464
const char *ret = gnutls_strerror(value); /* Spurious warning from
465
-Wunreachable-code */
466
if(ret == NULL)
467
ret = "(unknown)";
468
return ret;
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);
469
511
}
470
512
471
513
/* GnuTLS log function callback */
514
__attribute__((nonnull))
472
515
static void debuggnutls(__attribute__((unused)) int level,
473
516
const char* string){
474
517
fprintf_plus(stderr, "GnuTLS: %s", string);
475
518
}
476
519
520
__attribute__((nonnull(1, 2, 4), warn_unused_result))
477
521
static int init_gnutls_global(const char *pubkeyfilename,
478
const char *seckeyfilename){
522
const char *seckeyfilename,
523
const char *dhparamsfilename,
524
mandos_context *mc){
479
525
int ret;
526
unsigned int uret;
480
527
481
528
if(debug){
482
529
fprintf_plus(stderr, "Initializing GnuTLS\n");
483
530
}
484
531
485
ret = gnutls_global_init();
486
if(ret != GNUTLS_E_SUCCESS){
487
fprintf_plus(stderr, "GnuTLS global_init: %s\n",
488
safer_gnutls_strerror(ret));
489
return -1;
490
}
491
492
532
if(debug){
493
533
/* "Use a log level over 10 to enable all debugging options."
494
534
* - GnuTLS manual
498
538
}
499
539
500
540
/* OpenPGP credentials */
501
ret = gnutls_certificate_allocate_credentials(&mc.cred);
541
ret = gnutls_certificate_allocate_credentials(&mc->cred);
502
542
if(ret != GNUTLS_E_SUCCESS){
503
543
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
504
544
safer_gnutls_strerror(ret));
505
gnutls_global_deinit();
506
545
return -1;
507
546
}
508
547
514
553
}
515
554
516
555
ret = gnutls_certificate_set_openpgp_key_file
517
(mc.cred, pubkeyfilename, seckeyfilename,
556
(mc->cred, pubkeyfilename, seckeyfilename,
518
557
GNUTLS_OPENPGP_FMT_BASE64);
519
558
if(ret != GNUTLS_E_SUCCESS){
520
559
fprintf_plus(stderr,
526
565
}
527
566
528
567
/* GnuTLS server initialization */
529
ret = gnutls_dh_params_init(&mc.dh_params);
568
ret = gnutls_dh_params_init(&mc->dh_params);
530
569
if(ret != GNUTLS_E_SUCCESS){
531
570
fprintf_plus(stderr, "Error in GnuTLS DH parameter"
532
571
" initialization: %s\n",
533
572
safer_gnutls_strerror(ret));
534
573
goto globalfail;
535
574
}
536
ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
537
if(ret != GNUTLS_E_SUCCESS){
538
fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
539
safer_gnutls_strerror(ret));
540
goto globalfail;
541
}
542
543
gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
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);
544
748
545
749
return 0;
546
750
547
751
globalfail:
548
752
549
gnutls_certificate_free_credentials(mc.cred);
550
gnutls_global_deinit();
551
gnutls_dh_params_deinit(mc.dh_params);
753
gnutls_certificate_free_credentials(mc->cred);
754
gnutls_dh_params_deinit(mc->dh_params);
552
755
return -1;
553
756
}
554
757
555
static int init_gnutls_session(gnutls_session_t *session){
758
__attribute__((nonnull, warn_unused_result))
759
static int init_gnutls_session(gnutls_session_t *session,
760
mandos_context *mc){
556
761
int ret;
557
762
/* GnuTLS session creation */
558
763
do {
570
775
{
571
776
const char *err;
572
777
do {
573
ret = gnutls_priority_set_direct(*session, mc.priority, &err);
778
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
574
779
if(quit_now){
575
780
gnutls_deinit(*session);
576
781
return -1;
587
792
588
793
do {
589
794
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
590
mc.cred);
795
mc->cred);
591
796
if(quit_now){
592
797
gnutls_deinit(*session);
593
798
return -1;
603
808
/* ignore client certificate if any. */
604
809
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
605
810
606
gnutls_dh_set_prime_bits(*session, mc.dh_bits);
607
608
811
return 0;
609
812
}
610
813
612
815
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
613
816
__attribute__((unused)) const char *txt){}
614
817
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
615
1036
/* Called when a Mandos server is found */
616
static int start_mandos_communication(const char *ip, uint16_t port,
1037
__attribute__((nonnull, warn_unused_result))
1038
static int start_mandos_communication(const char *ip, in_port_t port,
617
1039
AvahiIfIndex if_index,
618
int af){
1040
int af, mandos_context *mc){
619
1041
int ret, tcp_sd = -1;
620
1042
ssize_t sret;
621
union {
622
struct sockaddr_in in;
623
struct sockaddr_in6 in6;
624
} to;
1043
struct sockaddr_storage to;
625
1044
char *buffer = NULL;
626
1045
char *decrypted_buffer = NULL;
627
1046
size_t buffer_length = 0;
630
1049
int retval = -1;
631
1050
gnutls_session_t session;
632
1051
int pf; /* Protocol family */
1052
bool route_added = false;
633
1053
634
1054
errno = 0;
635
1055
651
1071
return -1;
652
1072
}
653
1073
654
ret = init_gnutls_session(&session);
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);
655
1107
if(ret != 0){
656
1108
return -1;
657
1109
}
658
1110
659
1111
if(debug){
660
1112
fprintf_plus(stderr, "Setting up a TCP connection to %s, port %"
661
PRIu16 "\n", ip, port);
1113
PRIuMAX "\n", ip, (uintmax_t)port);
662
1114
}
663
1115
664
tcp_sd = socket(pf, SOCK_STREAM, 0);
1116
tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
665
1117
if(tcp_sd < 0){
666
1118
int e = errno;
667
1119
perror_plus("socket");
674
1126
goto mandos_end;
675
1127
}
676
1128
677
memset(&to, 0, sizeof(to));
678
1129
if(af == AF_INET6){
679
to.in6.sin6_family = (sa_family_t)af;
680
ret = inet_pton(af, ip, &to.in6.sin6_addr);
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);
681
1133
} else { /* IPv4 */
682
to.in.sin_family = (sa_family_t)af;
683
ret = inet_pton(af, ip, &to.in.sin_addr);
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);
684
1137
}
685
1138
if(ret < 0 ){
686
1139
int e = errno;
695
1148
goto mandos_end;
696
1149
}
697
1150
if(af == AF_INET6){
698
to.in6.sin6_port = htons(port); /* Spurious warnings from
699
-Wconversion and
700
-Wunreachable-code */
701
702
if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
703
(&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
704
-Wunreachable-code*/
1151
((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
1152
if(IN6_IS_ADDR_LINKLOCAL
1153
(&((struct sockaddr_in6 *)&to)->sin6_addr)){
705
1154
if(if_index == AVAHI_IF_UNSPEC){
706
1155
fprintf_plus(stderr, "An IPv6 link-local address is"
707
1156
" incomplete without a network interface\n");
709
1158
goto mandos_end;
710
1159
}
711
1160
/* Set the network interface number as scope */
712
to.in6.sin6_scope_id = (uint32_t)if_index;
1161
((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
713
1162
}
714
1163
} else {
715
to.in.sin_port = htons(port); /* Spurious warnings from
716
-Wconversion and
717
-Wunreachable-code */
1164
((struct sockaddr_in *)&to)->sin_port = htons(port);
718
1165
}
719
1166
720
1167
if(quit_now){
728
1175
if(if_indextoname((unsigned int)if_index, interface) == NULL){
729
1176
perror_plus("if_indextoname");
730
1177
} else {
731
fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIu16
732
"\n", ip, interface, port);
1178
fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIuMAX
1179
"\n", ip, interface, (uintmax_t)port);
733
1180
}
734
1181
} else {
735
fprintf_plus(stderr, "Connection to: %s, port %" PRIu16 "\n",
736
ip, port);
1182
fprintf_plus(stderr, "Connection to: %s, port %" PRIuMAX "\n",
1183
ip, (uintmax_t)port);
737
1184
}
738
1185
char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
739
1186
INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
740
const char *pcret;
741
if(af == AF_INET6){
742
pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
743
sizeof(addrstr));
744
} else {
745
pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
746
sizeof(addrstr));
747
}
748
if(pcret == NULL){
749
perror_plus("inet_ntop");
750
} else {
751
if(strcmp(addrstr, ip) != 0){
752
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
753
}
754
}
755
}
756
757
if(quit_now){
758
errno = EINTR;
759
goto mandos_end;
760
}
761
762
if(af == AF_INET6){
763
ret = connect(tcp_sd, &to.in6, sizeof(to));
764
} else {
765
ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
766
}
767
if(ret < 0){
768
if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
769
int e = errno;
770
perror_plus("connect");
771
errno = e;
772
}
773
goto mandos_end;
774
}
775
776
if(quit_now){
777
errno = EINTR;
778
goto mandos_end;
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
http://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;
779
1267
}
780
1268
781
1269
const char *out = mandos_protocol_version;
817
1305
goto mandos_end;
818
1306
}
819
1307
820
/* Spurious warning from -Wint-to-pointer-cast */
821
gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
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);
822
1313
823
1314
if(quit_now){
824
1315
errno = EINTR;
929
1420
if(buffer_length > 0){
930
1421
ssize_t decrypted_buffer_size;
931
1422
decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
932
&decrypted_buffer);
1423
&decrypted_buffer, mc);
933
1424
if(decrypted_buffer_size >= 0){
934
1425
935
1426
written = 0;
961
1452
962
1453
mandos_end:
963
1454
{
1455
if(route_added){
1456
if(not delete_local_route(ip, if_index)){
1457
fprintf_plus(stderr, "Failed to delete local route to %s on"
1458
" interface %d", ip, if_index);
1459
}
1460
}
964
1461
int e = errno;
965
1462
free(decrypted_buffer);
966
1463
free(buffer);
967
1464
if(tcp_sd >= 0){
968
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
1465
ret = close(tcp_sd);
969
1466
}
970
1467
if(ret == -1){
971
1468
if(e == 0){
983
1480
return retval;
984
1481
}
985
1482
1483
__attribute__((nonnull))
986
1484
static void resolve_callback(AvahiSServiceResolver *r,
987
1485
AvahiIfIndex interface,
988
1486
AvahiProtocol proto,
996
1494
AVAHI_GCC_UNUSED AvahiStringList *txt,
997
1495
AVAHI_GCC_UNUSED AvahiLookupResultFlags
998
1496
flags,
999
AVAHI_GCC_UNUSED void* userdata){
1000
assert(r);
1497
void *mc){
1498
if(r == NULL){
1499
return;
1500
}
1001
1501
1002
1502
/* Called whenever a service has been resolved successfully or
1003
1503
timed out */
1004
1504
1005
1505
if(quit_now){
1506
avahi_s_service_resolver_free(r);
1006
1507
return;
1007
1508
}
1008
1509
1012
1513
fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
1013
1514
"'%s' of type '%s' in domain '%s': %s\n", name, type,
1014
1515
domain,
1015
avahi_strerror(avahi_server_errno(mc.server)));
1516
avahi_strerror(avahi_server_errno
1517
(((mandos_context*)mc)->server)));
1016
1518
break;
1017
1519
1018
1520
case AVAHI_RESOLVER_FOUND:
1024
1526
PRIdMAX ") on port %" PRIu16 "\n", name,
1025
1527
host_name, ip, (intmax_t)interface, port);
1026
1528
}
1027
int ret = start_mandos_communication(ip, port, interface,
1028
avahi_proto_to_af(proto));
1529
int ret = start_mandos_communication(ip, (in_port_t)port,
1530
interface,
1531
avahi_proto_to_af(proto),
1532
mc);
1029
1533
if(ret == 0){
1030
avahi_simple_poll_quit(mc.simple_poll);
1534
avahi_simple_poll_quit(simple_poll);
1031
1535
} else {
1032
ret = add_server(ip, port, interface,
1033
avahi_proto_to_af(proto));
1536
if(not add_server(ip, (in_port_t)port, interface,
1537
avahi_proto_to_af(proto),
1538
&((mandos_context*)mc)->current_server)){
1539
fprintf_plus(stderr, "Failed to add server \"%s\" to server"
1540
" list\n", name);
1541
}
1034
1542
}
1035
1543
}
1036
1544
}
1046
1554
const char *domain,
1047
1555
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1048
1556
flags,
1049
AVAHI_GCC_UNUSED void* userdata){
1050
assert(b);
1557
void *mc){
1558
if(b == NULL){
1559
return;
1560
}
1051
1561
1052
1562
/* Called whenever a new services becomes available on the LAN or
1053
1563
is removed from the LAN */
1061
1571
case AVAHI_BROWSER_FAILURE:
1062
1572
1063
1573
fprintf_plus(stderr, "(Avahi browser) %s\n",
1064
avahi_strerror(avahi_server_errno(mc.server)));
1065
avahi_simple_poll_quit(mc.simple_poll);
1574
avahi_strerror(avahi_server_errno
1575
(((mandos_context*)mc)->server)));
1576
avahi_simple_poll_quit(simple_poll);
1066
1577
return;
1067
1578
1068
1579
case AVAHI_BROWSER_NEW:
1071
1582
the callback function is called the Avahi server will free the
1072
1583
resolver for us. */
1073
1584
1074
if(avahi_s_service_resolver_new(mc.server, interface, protocol,
1075
name, type, domain, protocol, 0,
1076
resolve_callback, NULL) == NULL)
1585
if(avahi_s_service_resolver_new(((mandos_context*)mc)->server,
1586
interface, protocol, name, type,
1587
domain, protocol, 0,
1588
resolve_callback, mc) == NULL)
1077
1589
fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
1078
1590
" %s\n", name,
1079
avahi_strerror(avahi_server_errno(mc.server)));
1591
avahi_strerror(avahi_server_errno
1592
(((mandos_context*)mc)->server)));
1080
1593
break;
1081
1594
1082
1595
case AVAHI_BROWSER_REMOVE:
1101
1614
signal_received = sig;
1102
1615
int old_errno = errno;
1103
1616
/* set main loop to exit */
1104
if(mc.simple_poll != NULL){
1105
avahi_simple_poll_quit(mc.simple_poll);
1617
if(simple_poll != NULL){
1618
avahi_simple_poll_quit(simple_poll);
1106
1619
}
1107
1620
errno = old_errno;
1108
1621
}
1109
1622
1623
__attribute__((nonnull, warn_unused_result))
1110
1624
bool get_flags(const char *ifname, struct ifreq *ifr){
1111
1625
int ret;
1626
int old_errno;
1112
1627
1113
1628
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1114
1629
if(s < 0){
1630
old_errno = errno;
1115
1631
perror_plus("socket");
1632
errno = old_errno;
1116
1633
return false;
1117
1634
}
1118
strcpy(ifr->ifr_name, ifname);
1635
strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
1636
ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
1119
1637
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1120
1638
if(ret == -1){
1121
1639
if(debug){
1640
old_errno = errno;
1122
1641
perror_plus("ioctl SIOCGIFFLAGS");
1642
errno = old_errno;
1123
1643
}
1124
1644
return false;
1125
1645
}
1126
1646
return true;
1127
1647
}
1128
1648
1649
__attribute__((nonnull, warn_unused_result))
1129
1650
bool good_flags(const char *ifname, const struct ifreq *ifr){
1130
1651
1131
1652
/* Reject the loopback device */
1173
1694
* corresponds to an acceptable network device.
1174
1695
* (This function is passed to scandir(3) as a filter function.)
1175
1696
*/
1697
__attribute__((nonnull, warn_unused_result))
1176
1698
int good_interface(const struct dirent *if_entry){
1177
1699
if(if_entry->d_name[0] == '.'){
1178
1700
return 0;
1194
1716
}
1195
1717
1196
1718
/*
1197
* This function determines if a directory entry in /sys/class/net
1198
* corresponds to an acceptable network device which is up.
1199
* (This function is passed to scandir(3) as a filter function.)
1200
*/
1201
int up_interface(const struct dirent *if_entry){
1202
if(if_entry->d_name[0] == '.'){
1203
return 0;
1204
}
1205
1206
struct ifreq ifr;
1207
if(not get_flags(if_entry->d_name, &ifr)){
1208
if(debug){
1209
fprintf_plus(stderr, "Failed to get flags for interface "
1210
"\"%s\"\n", if_entry->d_name);
1211
}
1212
return 0;
1213
}
1214
1215
/* Reject down interfaces */
1216
if(not (ifr.ifr_flags & IFF_UP)){
1217
if(debug){
1218
fprintf_plus(stderr, "Rejecting down interface \"%s\"\n",
1219
if_entry->d_name);
1220
}
1221
return 0;
1222
}
1223
1224
/* Reject non-running interfaces */
1225
if(not (ifr.ifr_flags & IFF_RUNNING)){
1226
if(debug){
1227
fprintf_plus(stderr, "Rejecting non-running interface \"%s\"\n",
1228
if_entry->d_name);
1229
}
1230
return 0;
1231
}
1232
1233
if(not good_flags(if_entry->d_name, &ifr)){
1234
return 0;
1235
}
1236
return 1;
1237
}
1238
1719
* This function determines if a network interface is up.
1720
*/
1721
__attribute__((nonnull, warn_unused_result))
1722
bool interface_is_up(const char *interface){
1723
struct ifreq ifr;
1724
if(not get_flags(interface, &ifr)){
1725
if(debug){
1726
fprintf_plus(stderr, "Failed to get flags for interface "
1727
"\"%s\"\n", interface);
1728
}
1729
return false;
1730
}
1731
1732
return (bool)(ifr.ifr_flags & IFF_UP);
1733
}
1734
1735
/*
1736
* This function determines if a network interface is running
1737
*/
1738
__attribute__((nonnull, warn_unused_result))
1739
bool interface_is_running(const char *interface){
1740
struct ifreq ifr;
1741
if(not get_flags(interface, &ifr)){
1742
if(debug){
1743
fprintf_plus(stderr, "Failed to get flags for interface "
1744
"\"%s\"\n", interface);
1745
}
1746
return false;
1747
}
1748
1749
return (bool)(ifr.ifr_flags & IFF_RUNNING);
1750
}
1751
1752
__attribute__((nonnull, pure, warn_unused_result))
1239
1753
int notdotentries(const struct dirent *direntry){
1240
1754
/* Skip "." and ".." */
1241
1755
if(direntry->d_name[0] == '.'
1248
1762
}
1249
1763
1250
1764
/* Is this directory entry a runnable program? */
1765
__attribute__((nonnull, warn_unused_result))
1251
1766
int runnable_hook(const struct dirent *direntry){
1252
1767
int ret;
1253
1768
size_t sret;
1261
1776
sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1262
1777
"abcdefghijklmnopqrstuvwxyz"
1263
1778
"0123456789"
1264
"_-");
1779
"_.-");
1265
1780
if((direntry->d_name)[sret] != '\0'){
1266
1781
/* Contains non-allowed characters */
1267
1782
if(debug){
1271
1786
return 0;
1272
1787
}
1273
1788
1274
char *fullname = NULL;
1275
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1276
if(ret < 0){
1277
perror_plus("asprintf");
1278
return 0;
1279
}
1280
1281
ret = stat(fullname, &st);
1789
ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1282
1790
if(ret == -1){
1283
1791
if(debug){
1284
1792
perror_plus("Could not stat hook");
1301
1809
}
1302
1810
return 0;
1303
1811
}
1812
if(debug){
1813
fprintf_plus(stderr, "Hook \"%s\" is acceptable\n",
1814
direntry->d_name);
1815
}
1304
1816
return 1;
1305
1817
}
1306
1818
1307
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval){
1819
__attribute__((nonnull, warn_unused_result))
1820
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
1821
mandos_context *mc){
1308
1822
int ret;
1309
1823
struct timespec now;
1310
1824
struct timespec waited_time;
1311
1825
intmax_t block_time;
1312
1826
1313
1827
while(true){
1314
if(mc.current_server == NULL){
1315
if (debug){
1828
if(mc->current_server == NULL){
1829
if(debug){
1316
1830
fprintf_plus(stderr, "Wait until first server is found."
1317
1831
" No timeout!\n");
1318
1832
}
1319
1833
ret = avahi_simple_poll_iterate(s, -1);
1320
1834
} else {
1321
if (debug){
1835
if(debug){
1322
1836
fprintf_plus(stderr, "Check current_server if we should run"
1323
1837
" it, or wait\n");
1324
1838
}
1331
1845
/* Calculating in ms how long time between now and server
1332
1846
who we visted longest time ago. Now - last seen. */
1333
1847
waited_time.tv_sec = (now.tv_sec
1334
- mc.current_server->last_seen.tv_sec);
1848
- mc->current_server->last_seen.tv_sec);
1335
1849
waited_time.tv_nsec = (now.tv_nsec
1336
- mc.current_server->last_seen.tv_nsec);
1850
- mc->current_server->last_seen.tv_nsec);
1337
1851
/* total time is 10s/10,000ms.
1338
1852
Converting to s from ms by dividing by 1,000,
1339
1853
and ns to ms by dividing by 1,000,000. */
1341
1855
- ((intmax_t)waited_time.tv_sec * 1000))
1342
1856
- ((intmax_t)waited_time.tv_nsec / 1000000));
1343
1857
1344
if (debug){
1858
if(debug){
1345
1859
fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1346
1860
block_time);
1347
1861
}
1348
1862
1349
1863
if(block_time <= 0){
1350
ret = start_mandos_communication(mc.current_server->ip,
1351
mc.current_server->port,
1352
mc.current_server->if_index,
1353
mc.current_server->af);
1864
ret = start_mandos_communication(mc->current_server->ip,
1865
mc->current_server->port,
1866
mc->current_server->if_index,
1867
mc->current_server->af, mc);
1354
1868
if(ret == 0){
1355
avahi_simple_poll_quit(mc.simple_poll);
1869
avahi_simple_poll_quit(s);
1356
1870
return 0;
1357
1871
}
1358
1872
ret = clock_gettime(CLOCK_MONOTONIC,
1359
&mc.current_server->last_seen);
1873
&mc->current_server->last_seen);
1360
1874
if(ret == -1){
1361
1875
perror_plus("clock_gettime");
1362
1876
return -1;
1363
1877
}
1364
mc.current_server = mc.current_server->next;
1878
mc->current_server = mc->current_server->next;
1365
1879
block_time = 0; /* Call avahi to find new Mandos
1366
1880
servers, but don't block */
1367
1881
}
1369
1883
ret = avahi_simple_poll_iterate(s, (int)block_time);
1370
1884
}
1371
1885
if(ret != 0){
1372
if (ret > 0 or errno != EINTR){
1886
if(ret > 0 or errno != EINTR){
1373
1887
return (ret != 1) ? ret : 0;
1374
1888
}
1375
1889
}
1376
1890
}
1377
1891
}
1378
1892
1379
bool run_network_hooks(const char *mode, const char *interface,
1893
__attribute__((nonnull))
1894
void run_network_hooks(const char *mode, const char *interface,
1380
1895
const float delay){
1381
struct dirent **direntries;
1382
struct dirent *direntry;
1383
int ret;
1384
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1385
alphasort);
1896
struct dirent **direntries = NULL;
1897
if(hookdir_fd == -1){
1898
hookdir_fd = open(hookdir, O_RDONLY | O_DIRECTORY | O_PATH
1899
| O_CLOEXEC);
1900
if(hookdir_fd == -1){
1901
if(errno == ENOENT){
1902
if(debug){
1903
fprintf_plus(stderr, "Network hook directory \"%s\" not"
1904
" found\n", hookdir);
1905
}
1906
} else {
1907
perror_plus("open");
1908
}
1909
return;
1910
}
1911
}
1912
int numhooks = scandirat(hookdir_fd, ".", &direntries,
1913
runnable_hook, alphasort);
1386
1914
if(numhooks == -1){
1387
1915
perror_plus("scandir");
1388
} else {
1389
int devnull = open("/dev/null", O_RDONLY);
1390
for(int i = 0; i < numhooks; i++){
1391
direntry = direntries[i];
1392
char *fullname = NULL;
1393
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1394
if(ret < 0){
1916
return;
1917
}
1918
struct dirent *direntry;
1919
int ret;
1920
int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
1921
if(devnull == -1){
1922
perror_plus("open(\"/dev/null\", O_RDONLY)");
1923
return;
1924
}
1925
for(int i = 0; i < numhooks; i++){
1926
direntry = direntries[i];
1927
if(debug){
1928
fprintf_plus(stderr, "Running network hook \"%s\"\n",
1929
direntry->d_name);
1930
}
1931
pid_t hook_pid = fork();
1932
if(hook_pid == 0){
1933
/* Child */
1934
/* Raise privileges */
1935
errno = raise_privileges_permanently();
1936
if(errno != 0){
1937
perror_plus("Failed to raise privileges");
1938
_exit(EX_NOPERM);
1939
}
1940
/* Set group */
1941
errno = 0;
1942
ret = setgid(0);
1943
if(ret == -1){
1944
perror_plus("setgid");
1945
_exit(EX_NOPERM);
1946
}
1947
/* Reset supplementary groups */
1948
errno = 0;
1949
ret = setgroups(0, NULL);
1950
if(ret == -1){
1951
perror_plus("setgroups");
1952
_exit(EX_NOPERM);
1953
}
1954
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1955
if(ret == -1){
1956
perror_plus("setenv");
1957
_exit(EX_OSERR);
1958
}
1959
ret = setenv("DEVICE", interface, 1);
1960
if(ret == -1){
1961
perror_plus("setenv");
1962
_exit(EX_OSERR);
1963
}
1964
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
1965
if(ret == -1){
1966
perror_plus("setenv");
1967
_exit(EX_OSERR);
1968
}
1969
ret = setenv("MODE", mode, 1);
1970
if(ret == -1){
1971
perror_plus("setenv");
1972
_exit(EX_OSERR);
1973
}
1974
char *delaystring;
1975
ret = asprintf(&delaystring, "%f", (double)delay);
1976
if(ret == -1){
1395
1977
perror_plus("asprintf");
1396
continue;
1397
}
1398
if(debug){
1399
fprintf_plus(stderr, "Running network hook \"%s\"\n",
1400
direntry->d_name);
1401
}
1402
pid_t hook_pid = fork();
1403
if(hook_pid == 0){
1404
/* Child */
1405
dup2(devnull, STDIN_FILENO);
1406
close(devnull);
1407
dup2(STDERR_FILENO, STDOUT_FILENO);
1408
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1409
if(ret == -1){
1410
perror_plus("setenv");
1411
return false;
1412
}
1413
ret = setenv("DEVICE", interface, 1);
1414
if(ret == -1){
1415
perror_plus("setenv");
1416
return false;
1417
}
1418
ret = setenv("VERBOSE", debug ? "1" : "0", 1);
1419
if(ret == -1){
1420
perror_plus("setenv");
1421
return false;
1422
}
1423
ret = setenv("MODE", mode, 1);
1424
if(ret == -1){
1425
perror_plus("setenv");
1426
return false;
1427
}
1428
char *delaystring;
1429
ret = asprintf(&delaystring, "%f", delay);
1430
if(ret == -1){
1431
perror_plus("asprintf");
1432
return false;
1433
}
1434
ret = setenv("DELAY", delaystring, 1);
1435
if(ret == -1){
1436
free(delaystring);
1437
perror_plus("setenv");
1438
return false;
1439
}
1978
_exit(EX_OSERR);
1979
}
1980
ret = setenv("DELAY", delaystring, 1);
1981
if(ret == -1){
1440
1982
free(delaystring);
1441
ret = execl(fullname, direntry->d_name, mode, NULL);
1442
perror_plus("execl");
1443
} else {
1444
int status;
1445
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1446
perror_plus("waitpid");
1447
free(fullname);
1448
continue;
1449
}
1450
if(WIFEXITED(status)){
1451
if(WEXITSTATUS(status) != 0){
1452
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1453
" with status %d\n", direntry->d_name,
1454
WEXITSTATUS(status));
1455
free(fullname);
1456
continue;
1457
}
1458
} else if(WIFSIGNALED(status)){
1459
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1460
" signal %d\n", direntry->d_name,
1461
WTERMSIG(status));
1462
free(fullname);
1463
continue;
1464
} else {
1465
fprintf_plus(stderr, "Warning: network hook \"%s\""
1466
" crashed\n", direntry->d_name);
1467
free(fullname);
1468
continue;
1469
}
1470
}
1471
free(fullname);
1472
if(quit_now){
1473
break;
1474
}
1475
}
1476
close(devnull);
1477
}
1478
return true;
1983
perror_plus("setenv");
1984
_exit(EX_OSERR);
1985
}
1986
free(delaystring);
1987
if(connect_to != NULL){
1988
ret = setenv("CONNECT", connect_to, 1);
1989
if(ret == -1){
1990
perror_plus("setenv");
1991
_exit(EX_OSERR);
1992
}
1993
}
1994
int hook_fd = (int)TEMP_FAILURE_RETRY(openat(hookdir_fd,
1995
direntry->d_name,
1996
O_RDONLY));
1997
if(hook_fd == -1){
1998
perror_plus("openat");
1999
_exit(EXIT_FAILURE);
2000
}
2001
if(close(hookdir_fd) == -1){
2002
perror_plus("close");
2003
_exit(EXIT_FAILURE);
2004
}
2005
ret = dup2(devnull, STDIN_FILENO);
2006
if(ret == -1){
2007
perror_plus("dup2(devnull, STDIN_FILENO)");
2008
_exit(EX_OSERR);
2009
}
2010
ret = close(devnull);
2011
if(ret == -1){
2012
perror_plus("close");
2013
_exit(EX_OSERR);
2014
}
2015
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
2016
if(ret == -1){
2017
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
2018
_exit(EX_OSERR);
2019
}
2020
if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
2021
environ) == -1){
2022
perror_plus("fexecve");
2023
_exit(EXIT_FAILURE);
2024
}
2025
} else {
2026
if(hook_pid == -1){
2027
perror_plus("fork");
2028
free(direntry);
2029
continue;
2030
}
2031
int status;
2032
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
2033
perror_plus("waitpid");
2034
free(direntry);
2035
continue;
2036
}
2037
if(WIFEXITED(status)){
2038
if(WEXITSTATUS(status) != 0){
2039
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
2040
" with status %d\n", direntry->d_name,
2041
WEXITSTATUS(status));
2042
free(direntry);
2043
continue;
2044
}
2045
} else if(WIFSIGNALED(status)){
2046
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
2047
" signal %d\n", direntry->d_name,
2048
WTERMSIG(status));
2049
free(direntry);
2050
continue;
2051
} else {
2052
fprintf_plus(stderr, "Warning: network hook \"%s\""
2053
" crashed\n", direntry->d_name);
2054
free(direntry);
2055
continue;
2056
}
2057
}
2058
if(debug){
2059
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
2060
direntry->d_name);
2061
}
2062
free(direntry);
2063
}
2064
free(direntries);
2065
if(close(hookdir_fd) == -1){
2066
perror_plus("close");
2067
} else {
2068
hookdir_fd = -1;
2069
}
2070
close(devnull);
2071
}
2072
2073
__attribute__((nonnull, warn_unused_result))
2074
int bring_up_interface(const char *const interface,
2075
const float delay){
2076
int old_errno = errno;
2077
int ret;
2078
struct ifreq network;
2079
unsigned int if_index = if_nametoindex(interface);
2080
if(if_index == 0){
2081
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
2082
errno = old_errno;
2083
return ENXIO;
2084
}
2085
2086
if(quit_now){
2087
errno = old_errno;
2088
return EINTR;
2089
}
2090
2091
if(not interface_is_up(interface)){
2092
int ret_errno = 0;
2093
int ioctl_errno = 0;
2094
if(not get_flags(interface, &network)){
2095
ret_errno = errno;
2096
fprintf_plus(stderr, "Failed to get flags for interface "
2097
"\"%s\"\n", interface);
2098
errno = old_errno;
2099
return ret_errno;
2100
}
2101
network.ifr_flags |= IFF_UP; /* set flag */
2102
2103
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
2104
if(sd == -1){
2105
ret_errno = errno;
2106
perror_plus("socket");
2107
errno = old_errno;
2108
return ret_errno;
2109
}
2110
2111
if(quit_now){
2112
ret = close(sd);
2113
if(ret == -1){
2114
perror_plus("close");
2115
}
2116
errno = old_errno;
2117
return EINTR;
2118
}
2119
2120
if(debug){
2121
fprintf_plus(stderr, "Bringing up interface \"%s\"\n",
2122
interface);
2123
}
2124
2125
/* Raise privileges */
2126
ret_errno = raise_privileges();
2127
if(ret_errno != 0){
2128
errno = ret_errno;
2129
perror_plus("Failed to raise privileges");
2130
}
2131
2132
#ifdef __linux__
2133
int ret_linux;
2134
bool restore_loglevel = false;
2135
if(ret_errno == 0){
2136
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
2137
messages about the network interface to mess up the prompt */
2138
ret_linux = klogctl(8, NULL, 5);
2139
if(ret_linux == -1){
2140
perror_plus("klogctl");
2141
} else {
2142
restore_loglevel = true;
2143
}
2144
}
2145
#endif /* __linux__ */
2146
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
2147
ioctl_errno = errno;
2148
#ifdef __linux__
2149
if(restore_loglevel){
2150
ret_linux = klogctl(7, NULL, 0);
2151
if(ret_linux == -1){
2152
perror_plus("klogctl");
2153
}
2154
}
2155
#endif /* __linux__ */
2156
2157
/* If raise_privileges() succeeded above */
2158
if(ret_errno == 0){
2159
/* Lower privileges */
2160
ret_errno = lower_privileges();
2161
if(ret_errno != 0){
2162
errno = ret_errno;
2163
perror_plus("Failed to lower privileges");
2164
}
2165
}
2166
2167
/* Close the socket */
2168
ret = close(sd);
2169
if(ret == -1){
2170
perror_plus("close");
2171
}
2172
2173
if(ret_setflags == -1){
2174
errno = ioctl_errno;
2175
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
2176
errno = old_errno;
2177
return ioctl_errno;
2178
}
2179
} else if(debug){
2180
fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
2181
interface);
2182
}
2183
2184
/* Sleep checking until interface is running.
2185
Check every 0.25s, up to total time of delay */
2186
for(int i=0; i < delay * 4; i++){
2187
if(interface_is_running(interface)){
2188
break;
2189
}
2190
struct timespec sleeptime = { .tv_nsec = 250000000 };
2191
ret = nanosleep(&sleeptime, NULL);
2192
if(ret == -1 and errno != EINTR){
2193
perror_plus("nanosleep");
2194
}
2195
}
2196
2197
errno = old_errno;
2198
return 0;
2199
}
2200
2201
__attribute__((nonnull, warn_unused_result))
2202
int take_down_interface(const char *const interface){
2203
int old_errno = errno;
2204
struct ifreq network;
2205
unsigned int if_index = if_nametoindex(interface);
2206
if(if_index == 0){
2207
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
2208
errno = old_errno;
2209
return ENXIO;
2210
}
2211
if(interface_is_up(interface)){
2212
int ret_errno = 0;
2213
int ioctl_errno = 0;
2214
if(not get_flags(interface, &network) and debug){
2215
ret_errno = errno;
2216
fprintf_plus(stderr, "Failed to get flags for interface "
2217
"\"%s\"\n", interface);
2218
errno = old_errno;
2219
return ret_errno;
2220
}
2221
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
2222
2223
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
2224
if(sd == -1){
2225
ret_errno = errno;
2226
perror_plus("socket");
2227
errno = old_errno;
2228
return ret_errno;
2229
}
2230
2231
if(debug){
2232
fprintf_plus(stderr, "Taking down interface \"%s\"\n",
2233
interface);
2234
}
2235
2236
/* Raise privileges */
2237
ret_errno = raise_privileges();
2238
if(ret_errno != 0){
2239
errno = ret_errno;
2240
perror_plus("Failed to raise privileges");
2241
}
2242
2243
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
2244
ioctl_errno = errno;
2245
2246
/* If raise_privileges() succeeded above */
2247
if(ret_errno == 0){
2248
/* Lower privileges */
2249
ret_errno = lower_privileges();
2250
if(ret_errno != 0){
2251
errno = ret_errno;
2252
perror_plus("Failed to lower privileges");
2253
}
2254
}
2255
2256
/* Close the socket */
2257
int ret = close(sd);
2258
if(ret == -1){
2259
perror_plus("close");
2260
}
2261
2262
if(ret_setflags == -1){
2263
errno = ioctl_errno;
2264
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
2265
errno = old_errno;
2266
return ioctl_errno;
2267
}
2268
} else if(debug){
2269
fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
2270
interface);
2271
}
2272
2273
errno = old_errno;
2274
return 0;
1479
2275
}
1480
2276
1481
2277
int main(int argc, char *argv[]){
2278
mandos_context mc = { .server = NULL, .dh_bits = 0,
2279
.priority = "SECURE256:!CTYPE-X.509"
2280
":+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256",
2281
.current_server = NULL, .interfaces = NULL,
2282
.interfaces_size = 0 };
1482
2283
AvahiSServiceBrowser *sb = NULL;
1483
int error;
2284
error_t ret_errno;
1484
2285
int ret;
1485
2286
intmax_t tmpmax;
1486
2287
char *tmp;
1487
2288
int exitcode = EXIT_SUCCESS;
1488
const char *interface = "";
1489
struct ifreq network;
1490
int sd = -1;
1491
bool take_down_interface = false;
1492
uid_t uid;
1493
gid_t gid;
1494
char tempdir[] = "/tmp/mandosXXXXXX";
1495
bool tempdir_created = false;
2289
char *interfaces_to_take_down = NULL;
2290
size_t interfaces_to_take_down_size = 0;
2291
char run_tempdir[] = "/run/tmp/mandosXXXXXX";
2292
char old_tempdir[] = "/tmp/mandosXXXXXX";
2293
char *tempdir = NULL;
1496
2294
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1497
2295
const char *seckey = PATHDIR "/" SECKEY;
1498
2296
const char *pubkey = PATHDIR "/" PUBKEY;
2297
const char *dh_params_file = NULL;
2298
char *interfaces_hooks = NULL;
1499
2299
1500
2300
bool gnutls_initialized = false;
1501
2301
bool gpgme_initialized = false;
1553
2353
.doc = "Bit length of the prime number used in the"
1554
2354
" Diffie-Hellman key exchange",
1555
2355
.group = 2 },
2356
{ .name = "dh-params", .key = 134,
2357
.arg = "FILE",
2358
.doc = "PEM-encoded PKCS#3 file with pre-generated parameters"
2359
" for the Diffie-Hellman key exchange",
2360
.group = 2 },
1556
2361
{ .name = "priority", .key = 130,
1557
2362
.arg = "STRING",
1558
2363
.doc = "GnuTLS priority string for the TLS handshake",
1563
2368
.group = 2 },
1564
2369
{ .name = "retry", .key = 132,
1565
2370
.arg = "SECONDS",
1566
.doc = "Retry interval used when denied by the mandos server",
2371
.doc = "Retry interval used when denied by the Mandos server",
1567
2372
.group = 2 },
1568
2373
{ .name = "network-hook-dir", .key = 133,
1569
2374
.arg = "DIR",
1592
2397
connect_to = arg;
1593
2398
break;
1594
2399
case 'i': /* --interface */
1595
interface = arg;
2400
ret_errno = argz_add_sep(&mc.interfaces, &mc.interfaces_size,
2401
arg, (int)',');
2402
if(ret_errno != 0){
2403
argp_error(state, "%s", strerror(ret_errno));
2404
}
1596
2405
break;
1597
2406
case 's': /* --seckey */
1598
2407
seckey = arg;
1609
2418
}
1610
2419
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
1611
2420
break;
2421
case 134: /* --dh-params */
2422
dh_params_file = arg;
2423
break;
1612
2424
case 130: /* --priority */
1613
2425
mc.priority = arg;
1614
2426
break;
1641
2453
argp_state_help(state, state->out_stream,
1642
2454
ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
1643
2455
case 'V': /* --version */
1644
fprintf_plus(state->out_stream,
1645
"Mandos plugin mandos-client: ");
1646
2456
fprintf_plus(state->out_stream, "%s\n", argp_program_version);
1647
2457
exit(argp_err_exit_status);
1648
2458
break;
1656
2466
.args_doc = "",
1657
2467
.doc = "Mandos client -- Get and decrypt"
1658
2468
" passwords from a Mandos server" };
1659
ret = argp_parse(&argp, argc, argv,
1660
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
1661
switch(ret){
2469
ret_errno = argp_parse(&argp, argc, argv,
2470
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2471
switch(ret_errno){
1662
2472
case 0:
1663
2473
break;
1664
2474
case ENOMEM:
1665
2475
default:
1666
errno = ret;
2476
errno = ret_errno;
1667
2477
perror_plus("argp_parse");
1668
2478
exitcode = EX_OSERR;
1669
2479
goto end;
1672
2482
goto end;
1673
2483
}
1674
2484
}
1675
1676
if(getuid() == 0){
2485
2486
{
1677
2487
/* Work around Debian bug #633582:
1678
2488
<http://bugs.debian.org/633582> */
1679
struct stat st;
1680
1681
/* Re-raise priviliges */
1682
errno = 0;
1683
ret = seteuid(0);
1684
if(ret == -1){
1685
perror_plus("seteuid");
1686
}
1687
1688
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
1689
int seckey_fd = open(seckey, O_RDONLY);
1690
if(seckey_fd == -1){
1691
perror_plus("open");
1692
} else {
1693
ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
1694
if(ret == -1){
1695
perror_plus("fstat");
1696
} else {
1697
if(S_ISREG(st.st_mode)
1698
and st.st_uid == 0 and st.st_gid == 0){
1699
ret = fchown(seckey_fd, uid, gid);
1700
if(ret == -1){
1701
perror_plus("fchown");
1702
}
1703
}
1704
}
1705
TEMP_FAILURE_RETRY(close(seckey_fd));
1706
}
1707
}
1708
1709
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
1710
int pubkey_fd = open(pubkey, O_RDONLY);
1711
if(pubkey_fd == -1){
1712
perror_plus("open");
1713
} else {
1714
ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
1715
if(ret == -1){
1716
perror_plus("fstat");
1717
} else {
1718
if(S_ISREG(st.st_mode)
1719
and st.st_uid == 0 and st.st_gid == 0){
1720
ret = fchown(pubkey_fd, uid, gid);
1721
if(ret == -1){
1722
perror_plus("fchown");
1723
}
1724
}
1725
}
1726
TEMP_FAILURE_RETRY(close(pubkey_fd));
1727
}
1728
}
1729
1730
/* Lower privileges */
1731
errno = 0;
1732
ret = seteuid(uid);
1733
if(ret == -1){
1734
perror_plus("seteuid");
2489
2490
/* Re-raise privileges */
2491
ret = raise_privileges();
2492
if(ret != 0){
2493
errno = ret;
2494
perror_plus("Failed to raise privileges");
2495
} else {
2496
struct stat st;
2497
2498
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
2499
int seckey_fd = open(seckey, O_RDONLY);
2500
if(seckey_fd == -1){
2501
perror_plus("open");
2502
} else {
2503
ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
2504
if(ret == -1){
2505
perror_plus("fstat");
2506
} else {
2507
if(S_ISREG(st.st_mode)
2508
and st.st_uid == 0 and st.st_gid == 0){
2509
ret = fchown(seckey_fd, uid, gid);
2510
if(ret == -1){
2511
perror_plus("fchown");
2512
}
2513
}
2514
}
2515
close(seckey_fd);
2516
}
2517
}
2518
2519
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2520
int pubkey_fd = open(pubkey, O_RDONLY);
2521
if(pubkey_fd == -1){
2522
perror_plus("open");
2523
} else {
2524
ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
2525
if(ret == -1){
2526
perror_plus("fstat");
2527
} else {
2528
if(S_ISREG(st.st_mode)
2529
and st.st_uid == 0 and st.st_gid == 0){
2530
ret = fchown(pubkey_fd, uid, gid);
2531
if(ret == -1){
2532
perror_plus("fchown");
2533
}
2534
}
2535
}
2536
close(pubkey_fd);
2537
}
2538
}
2539
2540
if(dh_params_file != NULL
2541
and strcmp(dh_params_file, PATHDIR "/dhparams.pem" ) == 0){
2542
int dhparams_fd = open(dh_params_file, O_RDONLY);
2543
if(dhparams_fd == -1){
2544
perror_plus("open");
2545
} else {
2546
ret = (int)TEMP_FAILURE_RETRY(fstat(dhparams_fd, &st));
2547
if(ret == -1){
2548
perror_plus("fstat");
2549
} else {
2550
if(S_ISREG(st.st_mode)
2551
and st.st_uid == 0 and st.st_gid == 0){
2552
ret = fchown(dhparams_fd, uid, gid);
2553
if(ret == -1){
2554
perror_plus("fchown");
2555
}
2556
}
2557
}
2558
close(dhparams_fd);
2559
}
2560
}
2561
2562
/* Lower privileges */
2563
ret = lower_privileges();
2564
if(ret != 0){
2565
errno = ret;
2566
perror_plus("Failed to lower privileges");
2567
}
2568
}
2569
}
2570
2571
/* Remove invalid interface names (except "none") */
2572
{
2573
char *interface = NULL;
2574
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2575
interface))){
2576
if(strcmp(interface, "none") != 0
2577
and if_nametoindex(interface) == 0){
2578
if(interface[0] != '\0'){
2579
fprintf_plus(stderr, "Not using nonexisting interface"
2580
" \"%s\"\n", interface);
2581
}
2582
argz_delete(&mc.interfaces, &mc.interfaces_size, interface);
2583
interface = NULL;
2584
}
1735
2585
}
1736
2586
}
1737
2587
1738
2588
/* Run network hooks */
1739
2589
{
1740
if(getuid() == 0){
1741
/* Re-raise priviliges */
1742
errno = 0;
1743
ret = seteuid(0);
1744
if(ret == -1){
1745
perror_plus("seteuid");
1746
}
1747
}
1748
if(not run_network_hooks("start", interface, delay)){
1749
goto end;
1750
}
1751
if(getuid() == 0){
1752
/* Lower privileges */
1753
errno = 0;
1754
ret = seteuid(uid);
1755
if(ret == -1){
1756
perror_plus("seteuid");
1757
}
1758
}
2590
if(mc.interfaces != NULL){
2591
interfaces_hooks = malloc(mc.interfaces_size);
2592
if(interfaces_hooks == NULL){
2593
perror_plus("malloc");
2594
goto end;
2595
}
2596
memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
2597
argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
2598
}
2599
run_network_hooks("start", interfaces_hooks != NULL ?
2600
interfaces_hooks : "", delay);
1759
2601
}
1760
2602
1761
2603
if(not debug){
1762
2604
avahi_set_log_function(empty_log);
1763
2605
}
1764
2606
1765
if(interface[0] == '\0'){
1766
struct dirent **direntries;
1767
/* First look for interfaces that are up */
1768
ret = scandir(sys_class_net, &direntries, up_interface,
1769
alphasort);
1770
if(ret == 0){
1771
/* No up interfaces, look for any good interfaces */
1772
free(direntries);
1773
ret = scandir(sys_class_net, &direntries, good_interface,
1774
alphasort);
1775
}
1776
if(ret >= 1){
1777
/* Pick the first interface returned */
1778
interface = strdup(direntries[0]->d_name);
1779
if(debug){
1780
fprintf_plus(stderr, "Using interface \"%s\"\n", interface);
1781
}
1782
if(interface == NULL){
1783
perror_plus("malloc");
1784
free(direntries);
1785
exitcode = EXIT_FAILURE;
1786
goto end;
1787
}
1788
free(direntries);
1789
} else {
1790
free(direntries);
1791
fprintf_plus(stderr, "Could not find a network interface\n");
1792
exitcode = EXIT_FAILURE;
1793
goto end;
1794
}
1795
}
1796
1797
2607
/* Initialize Avahi early so avahi_simple_poll_quit() can be called
1798
2608
from the signal handler */
1799
2609
/* Initialize the pseudo-RNG for Avahi */
1800
2610
srand((unsigned int) time(NULL));
1801
mc.simple_poll = avahi_simple_poll_new();
1802
if(mc.simple_poll == NULL){
2611
simple_poll = avahi_simple_poll_new();
2612
if(simple_poll == NULL){
1803
2613
fprintf_plus(stderr,
1804
2614
"Avahi: Failed to create simple poll object.\n");
1805
2615
exitcode = EX_UNAVAILABLE;
1869
2679
}
1870
2680
}
1871
2681
1872
/* If the interface is down, bring it up */
1873
if(strcmp(interface, "none") != 0){
1874
if_index = (AvahiIfIndex) if_nametoindex(interface);
1875
if(if_index == 0){
1876
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1877
exitcode = EX_UNAVAILABLE;
1878
goto end;
1879
}
1880
1881
if(quit_now){
1882
goto end;
1883
}
1884
1885
/* Re-raise priviliges */
1886
errno = 0;
1887
ret = seteuid(0);
1888
if(ret == -1){
1889
perror_plus("seteuid");
1890
}
1891
1892
#ifdef __linux__
1893
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1894
messages about the network interface to mess up the prompt */
1895
ret = klogctl(8, NULL, 5);
1896
bool restore_loglevel = true;
1897
if(ret == -1){
1898
restore_loglevel = false;
1899
perror_plus("klogctl");
1900
}
1901
#endif /* __linux__ */
1902
1903
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1904
if(sd < 0){
1905
perror_plus("socket");
1906
exitcode = EX_OSERR;
1907
#ifdef __linux__
1908
if(restore_loglevel){
1909
ret = klogctl(7, NULL, 0);
1910
if(ret == -1){
1911
perror_plus("klogctl");
1912
}
1913
}
1914
#endif /* __linux__ */
1915
/* Lower privileges */
1916
errno = 0;
1917
ret = seteuid(uid);
1918
if(ret == -1){
1919
perror_plus("seteuid");
1920
}
1921
goto end;
1922
}
1923
strcpy(network.ifr_name, interface);
1924
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1925
if(ret == -1){
1926
perror_plus("ioctl SIOCGIFFLAGS");
1927
#ifdef __linux__
1928
if(restore_loglevel){
1929
ret = klogctl(7, NULL, 0);
1930
if(ret == -1){
1931
perror_plus("klogctl");
1932
}
1933
}
1934
#endif /* __linux__ */
1935
exitcode = EX_OSERR;
1936
/* Lower privileges */
1937
errno = 0;
1938
ret = seteuid(uid);
1939
if(ret == -1){
1940
perror_plus("seteuid");
1941
}
1942
goto end;
1943
}
1944
if((network.ifr_flags & IFF_UP) == 0){
1945
network.ifr_flags |= IFF_UP;
1946
take_down_interface = true;
1947
ret = ioctl(sd, SIOCSIFFLAGS, &network);
1948
if(ret == -1){
1949
take_down_interface = false;
1950
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1951
exitcode = EX_OSERR;
1952
#ifdef __linux__
1953
if(restore_loglevel){
1954
ret = klogctl(7, NULL, 0);
1955
if(ret == -1){
1956
perror_plus("klogctl");
2682
/* If no interfaces were specified, make a list */
2683
if(mc.interfaces == NULL){
2684
struct dirent **direntries = NULL;
2685
/* Look for any good interfaces */
2686
ret = scandir(sys_class_net, &direntries, good_interface,
2687
alphasort);
2688
if(ret >= 1){
2689
/* Add all found interfaces to interfaces list */
2690
for(int i = 0; i < ret; ++i){
2691
ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
2692
direntries[i]->d_name);
2693
if(ret_errno != 0){
2694
errno = ret_errno;
2695
perror_plus("argz_add");
2696
free(direntries[i]);
2697
continue;
2698
}
2699
if(debug){
2700
fprintf_plus(stderr, "Will use interface \"%s\"\n",
2701
direntries[i]->d_name);
2702
}
2703
free(direntries[i]);
2704
}
2705
free(direntries);
2706
} else {
2707
if(ret == 0){
2708
free(direntries);
2709
}
2710
fprintf_plus(stderr, "Could not find a network interface\n");
2711
exitcode = EXIT_FAILURE;
2712
goto end;
2713
}
2714
}
2715
2716
/* Bring up interfaces which are down, and remove any "none"s */
2717
{
2718
char *interface = NULL;
2719
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2720
interface))){
2721
/* If interface name is "none", stop bringing up interfaces.
2722
Also remove all instances of "none" from the list */
2723
if(strcmp(interface, "none") == 0){
2724
argz_delete(&mc.interfaces, &mc.interfaces_size,
2725
interface);
2726
interface = NULL;
2727
while((interface = argz_next(mc.interfaces,
2728
mc.interfaces_size, interface))){
2729
if(strcmp(interface, "none") == 0){
2730
argz_delete(&mc.interfaces, &mc.interfaces_size,
2731
interface);
2732
interface = NULL;
1957
2733
}
1958
2734
}
1959
#endif /* __linux__ */
1960
/* Lower privileges */
1961
errno = 0;
1962
ret = seteuid(uid);
1963
if(ret == -1){
1964
perror_plus("seteuid");
1965
}
1966
goto end;
1967
}
1968
}
1969
/* Sleep checking until interface is running.
1970
Check every 0.25s, up to total time of delay */
1971
for(int i=0; i < delay * 4; i++){
1972
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1973
if(ret == -1){
1974
perror_plus("ioctl SIOCGIFFLAGS");
1975
} else if(network.ifr_flags & IFF_RUNNING){
1976
2735
break;
1977
2736
}
1978
struct timespec sleeptime = { .tv_nsec = 250000000 };
1979
ret = nanosleep(&sleeptime, NULL);
1980
if(ret == -1 and errno != EINTR){
1981
perror_plus("nanosleep");
1982
}
1983
}
1984
if(not take_down_interface){
1985
/* We won't need the socket anymore */
1986
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1987
if(ret == -1){
1988
perror_plus("close");
1989
}
1990
}
1991
#ifdef __linux__
1992
if(restore_loglevel){
1993
/* Restores kernel loglevel to default */
1994
ret = klogctl(7, NULL, 0);
1995
if(ret == -1){
1996
perror_plus("klogctl");
1997
}
1998
}
1999
#endif /* __linux__ */
2000
/* Lower privileges */
2001
errno = 0;
2002
/* Lower privileges */
2003
ret = seteuid(uid);
2004
if(ret == -1){
2005
perror_plus("seteuid");
2006
}
2737
bool interface_was_up = interface_is_up(interface);
2738
errno = bring_up_interface(interface, delay);
2739
if(not interface_was_up){
2740
if(errno != 0){
2741
fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
2742
" %s\n", interface, strerror(errno));
2743
} else {
2744
errno = argz_add(&interfaces_to_take_down,
2745
&interfaces_to_take_down_size,
2746
interface);
2747
if(errno != 0){
2748
perror_plus("argz_add");
2749
}
2750
}
2751
}
2752
}
2753
if(debug and (interfaces_to_take_down == NULL)){
2754
fprintf_plus(stderr, "No interfaces were brought up\n");
2755
}
2756
}
2757
2758
/* If we only got one interface, explicitly use only that one */
2759
if(argz_count(mc.interfaces, mc.interfaces_size) == 1){
2760
if(debug){
2761
fprintf_plus(stderr, "Using only interface \"%s\"\n",
2762
mc.interfaces);
2763
}
2764
if_index = (AvahiIfIndex)if_nametoindex(mc.interfaces);
2007
2765
}
2008
2766
2009
2767
if(quit_now){
2010
2768
goto end;
2011
2769
}
2012
2770
2013
ret = init_gnutls_global(pubkey, seckey);
2771
ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
2014
2772
if(ret == -1){
2015
2773
fprintf_plus(stderr, "init_gnutls_global failed\n");
2016
2774
exitcode = EX_UNAVAILABLE;
2023
2781
goto end;
2024
2782
}
2025
2783
2026
if(mkdtemp(tempdir) == NULL){
2784
/* Try /run/tmp before /tmp */
2785
tempdir = mkdtemp(run_tempdir);
2786
if(tempdir == NULL and errno == ENOENT){
2787
if(debug){
2788
fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
2789
run_tempdir, old_tempdir);
2790
}
2791
tempdir = mkdtemp(old_tempdir);
2792
}
2793
if(tempdir == NULL){
2027
2794
perror_plus("mkdtemp");
2028
2795
goto end;
2029
2796
}
2030
tempdir_created = true;
2031
2797
2032
2798
if(quit_now){
2033
2799
goto end;
2034
2800
}
2035
2801
2036
if(not init_gpgme(pubkey, seckey, tempdir)){
2802
if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
2037
2803
fprintf_plus(stderr, "init_gpgme failed\n");
2038
2804
exitcode = EX_UNAVAILABLE;
2039
2805
goto end;
2049
2815
/* Connect directly, do not use Zeroconf */
2050
2816
/* (Mainly meant for debugging) */
2051
2817
char *address = strrchr(connect_to, ':');
2818
2052
2819
if(address == NULL){
2053
2820
fprintf_plus(stderr, "No colon in address\n");
2054
2821
exitcode = EX_USAGE;
2059
2826
goto end;
2060
2827
}
2061
2828
2062
uint16_t port;
2829
in_port_t port;
2063
2830
errno = 0;
2064
2831
tmpmax = strtoimax(address+1, &tmp, 10);
2065
2832
if(errno != 0 or tmp == address+1 or *tmp != '\0'
2066
or tmpmax != (uint16_t)tmpmax){
2833
or tmpmax != (in_port_t)tmpmax){
2067
2834
fprintf_plus(stderr, "Bad port number\n");
2068
2835
exitcode = EX_USAGE;
2069
2836
goto end;
2070
2837
}
2071
2838
2072
2839
if(quit_now){
2073
2840
goto end;
2074
2841
}
2075
2842
2076
port = (uint16_t)tmpmax;
2843
port = (in_port_t)tmpmax;
2077
2844
*address = '\0';
2078
2845
/* Colon in address indicates IPv6 */
2079
2846
int af;
2095
2862
}
2096
2863
2097
2864
while(not quit_now){
2098
ret = start_mandos_communication(address, port, if_index, af);
2865
ret = start_mandos_communication(address, port, if_index, af,
2866
&mc);
2099
2867
if(quit_now or ret == 0){
2100
2868
break;
2101
2869
}
2103
2871
fprintf_plus(stderr, "Retrying in %d seconds\n",
2104
2872
(int)retry_interval);
2105
2873
}
2106
sleep((int)retry_interval);
2874
sleep((unsigned int)retry_interval);
2107
2875
}
2108
2876
2109
if (not quit_now){
2877
if(not quit_now){
2110
2878
exitcode = EXIT_SUCCESS;
2111
2879
}
2112
2880
2127
2895
config.publish_domain = 0;
2128
2896
2129
2897
/* Allocate a new server */
2130
mc.server = avahi_server_new(avahi_simple_poll_get
2131
(mc.simple_poll), &config, NULL,
2132
NULL, &error);
2898
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
2899
&config, NULL, NULL, &ret);
2133
2900
2134
2901
/* Free the Avahi configuration data */
2135
2902
avahi_server_config_free(&config);
2138
2905
/* Check if creating the Avahi server object succeeded */
2139
2906
if(mc.server == NULL){
2140
2907
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2141
avahi_strerror(error));
2908
avahi_strerror(ret));
2142
2909
exitcode = EX_UNAVAILABLE;
2143
2910
goto end;
2144
2911
}
2150
2917
/* Create the Avahi service browser */
2151
2918
sb = avahi_s_service_browser_new(mc.server, if_index,
2152
2919
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
2153
NULL, 0, browse_callback, NULL);
2920
NULL, 0, browse_callback,
2921
(void *)&mc);
2154
2922
if(sb == NULL){
2155
2923
fprintf_plus(stderr, "Failed to create service browser: %s\n",
2156
2924
avahi_strerror(avahi_server_errno(mc.server)));
2167
2935
if(debug){
2168
2936
fprintf_plus(stderr, "Starting Avahi loop search\n");
2169
2937
}
2170
2171
ret = avahi_loop_with_timeout(mc.simple_poll,
2172
(int)(retry_interval * 1000));
2938
2939
ret = avahi_loop_with_timeout(simple_poll,
2940
(int)(retry_interval * 1000), &mc);
2173
2941
if(debug){
2174
2942
fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
2175
2943
(ret == 0) ? "successfully" : "with error");
2182
2950
}
2183
2951
2184
2952
/* Cleanup things */
2953
free(mc.interfaces);
2954
2185
2955
if(sb != NULL)
2186
2956
avahi_s_service_browser_free(sb);
2187
2957
2188
2958
if(mc.server != NULL)
2189
2959
avahi_server_free(mc.server);
2190
2960
2191
if(mc.simple_poll != NULL)
2192
avahi_simple_poll_free(mc.simple_poll);
2961
if(simple_poll != NULL)
2962
avahi_simple_poll_free(simple_poll);
2193
2963
2194
2964
if(gnutls_initialized){
2195
2965
gnutls_certificate_free_credentials(mc.cred);
2196
gnutls_global_deinit();
2197
2966
gnutls_dh_params_deinit(mc.dh_params);
2198
2967
}
2199
2968
2200
2969
if(gpgme_initialized){
2201
2970
gpgme_release(mc.ctx);
2202
2971
}
2203
2972
2204
2973
/* Cleans up the circular linked list of Mandos servers the client
2205
2974
has seen */
2206
2975
if(mc.current_server != NULL){
2207
2976
mc.current_server->prev->next = NULL;
2208
2977
while(mc.current_server != NULL){
2209
2978
server *next = mc.current_server->next;
2979
#ifdef __GNUC__
2980
#pragma GCC diagnostic push
2981
#pragma GCC diagnostic ignored "-Wcast-qual"
2982
#endif
2983
free((char *)(mc.current_server->ip));
2984
#ifdef __GNUC__
2985
#pragma GCC diagnostic pop
2986
#endif
2210
2987
free(mc.current_server);
2211
2988
mc.current_server = next;
2212
2989
}
2213
2990
}
2214
2991
2215
/* Re-raise priviliges */
2992
/* Re-raise privileges */
2216
2993
{
2217
if(getuid() == 0){
2218
errno = 0;
2219
ret = seteuid(0);
2220
if(ret == -1){
2221
perror_plus("seteuid");
2994
ret = raise_privileges();
2995
if(ret != 0){
2996
errno = ret;
2997
perror_plus("Failed to raise privileges");
2998
} else {
2999
3000
/* Run network hooks */
3001
run_network_hooks("stop", interfaces_hooks != NULL ?
3002
interfaces_hooks : "", delay);
3003
3004
/* Take down the network interfaces which were brought up */
3005
{
3006
char *interface = NULL;
3007
while((interface=argz_next(interfaces_to_take_down,
3008
interfaces_to_take_down_size,
3009
interface))){
3010
ret = take_down_interface(interface);
3011
if(ret != 0){
3012
errno = ret;
3013
perror_plus("Failed to take down interface");
3014
}
3015
}
3016
if(debug and (interfaces_to_take_down == NULL)){
3017
fprintf_plus(stderr, "No interfaces needed to be taken"
3018
" down\n");
3019
}
2222
3020
}
2223
3021
}
2224
/* Run network hooks */
2225
if(not run_network_hooks("stop", interface, delay)){
2226
goto end;
2227
}
2228
3022
2229
/* Take down the network interface */
2230
if(take_down_interface and geteuid() == 0){
2231
ret = ioctl(sd, SIOCGIFFLAGS, &network);
2232
if(ret == -1){
2233
perror_plus("ioctl SIOCGIFFLAGS");
2234
} else if(network.ifr_flags & IFF_UP){
2235
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
2236
ret = ioctl(sd, SIOCSIFFLAGS, &network);
2237
if(ret == -1){
2238
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
2239
}
2240
}
2241
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2242
if(ret == -1){
2243
perror_plus("close");
2244
}
3023
ret = lower_privileges_permanently();
3024
if(ret != 0){
3025
errno = ret;
3026
perror_plus("Failed to lower privileges permanently");
2245
3027
}
2246
3028
}
2247
if(getuid() == 0){
2248
/* Lower privileges permanently */
2249
errno = 0;
2250
ret = setuid(uid);
2251
if(ret == -1){
2252
perror_plus("setuid");
2253
}
3029
3030
free(interfaces_to_take_down);
3031
free(interfaces_hooks);
3032
3033
void clean_dir_at(int base, const char * const dirname,
3034
uintmax_t level){
3035
struct dirent **direntries = NULL;
3036
int dret;
3037
int dir_fd = (int)TEMP_FAILURE_RETRY(openat(base, dirname,
3038
O_RDONLY
3039
| O_NOFOLLOW
3040
| O_DIRECTORY
3041
| O_PATH));
3042
if(dir_fd == -1){
3043
perror_plus("open");
3044
}
3045
int numentries = scandirat(dir_fd, ".", &direntries,
3046
notdotentries, alphasort);
3047
if(numentries >= 0){
3048
for(int i = 0; i < numentries; i++){
3049
if(debug){
3050
fprintf_plus(stderr, "Unlinking \"%s/%s\"\n",
3051
dirname, direntries[i]->d_name);
3052
}
3053
dret = unlinkat(dir_fd, direntries[i]->d_name, 0);
3054
if(dret == -1){
3055
if(errno == EISDIR){
3056
dret = unlinkat(dir_fd, direntries[i]->d_name,
3057
AT_REMOVEDIR);
3058
}
3059
if((dret == -1) and (errno == ENOTEMPTY)
3060
and (strcmp(direntries[i]->d_name, "private-keys-v1.d")
3061
== 0) and (level == 0)){
3062
/* Recurse only in this special case */
3063
clean_dir_at(dir_fd, direntries[i]->d_name, level+1);
3064
dret = 0;
3065
}
3066
if(dret == -1){
3067
fprintf_plus(stderr, "unlink(\"%s/%s\"): %s\n", dirname,
3068
direntries[i]->d_name, strerror(errno));
3069
}
3070
}
3071
free(direntries[i]);
3072
}
3073
3074
/* need to clean even if 0 because man page doesn't specify */
3075
free(direntries);
3076
if(numentries == -1){
3077
perror_plus("scandirat");
3078
}
3079
dret = unlinkat(base, dirname, AT_REMOVEDIR);
3080
if(dret == -1 and errno != ENOENT){
3081
perror_plus("rmdir");
3082
}
3083
} else {
3084
perror_plus("scandirat");
3085
}
3086
close(dir_fd);
2254
3087
}
2255
3088
2256
3089
/* Removes the GPGME temp directory and all files inside */
2257
if(tempdir_created){
2258
struct dirent **direntries = NULL;
2259
struct dirent *direntry = NULL;
2260
int numentries = scandir(tempdir, &direntries, notdotentries,
2261
alphasort);
2262
if (numentries > 0){
2263
for(int i = 0; i < numentries; i++){
2264
direntry = direntries[i];
2265
char *fullname = NULL;
2266
ret = asprintf(&fullname, "%s/%s", tempdir,
2267
direntry->d_name);
2268
if(ret < 0){
2269
perror_plus("asprintf");
2270
continue;
2271
}
2272
ret = remove(fullname);
2273
if(ret == -1){
2274
fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2275
strerror(errno));
2276
}
2277
free(fullname);
2278
}
2279
}
2280
2281
/* need to clean even if 0 because man page doesn't specify */
2282
free(direntries);
2283
if (numentries == -1){
2284
perror_plus("scandir");
2285
}
2286
ret = rmdir(tempdir);
2287
if(ret == -1 and errno != ENOENT){
2288
perror_plus("rmdir");
2289
}
3090
if(tempdir != NULL){
3091
clean_dir_at(-1, tempdir, 0);
2290
3092
}
2291
3093
2292
3094
if(quit_now){
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0