(root)/mandos/release
» Revision
237.7.398
(compared to revision 237.7.147)
: plugins.d/mandos-client.c
To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to plugins.d/mandos-client.c
- browse files at revision 237.7.398
- compare with another revision
- download diff
- download tarball
- view history from revision 237.7.398
- Committer: Teddy Hogeborn
- Date: 2016-06-03 17:27:03 UTC
- mto: (237.7.594 trunk)
- mto: This revision was merged to the branch mainline in revision 343.
- Revision ID: teddy@recompile.se-20160603172703-mc6tjor6rhq4xy74
mandos: Bug fix: Do multiprocessing cleanup correctly on exit
* mandos (main): Save module "multiprocessing" and open file "wnull"
as scope variables accessible by function cleanup(),
since the module and global variable may not be
accessible when the cleanup() function is run as
scheduled by atexit().
* mandos (main): Save module "multiprocessing" and open file "wnull"
as scope variables accessible by function cleanup(),
since the module and global variable may not be
accessible when the cleanup() function is run as
scheduled by atexit().
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-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() */
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(), 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 <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,
65
70
program_invocation_short_name */
66
71
#include <time.h> /* nanosleep(), time(), sleep() */
67
72
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
72
77
*/
73
78
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
74
79
getuid(), getgid(), seteuid(),
75
setgid(), pause(), _exit() */
76
#include <arpa/inet.h> /* inet_pton(), htons, inet_ntop() */
80
setgid(), pause(), _exit(),
81
unlinkat() */
82
#include <arpa/inet.h> /* inet_pton(), htons() */
77
83
#include <iso646.h> /* not, or, and */
78
84
#include <argp.h> /* struct argp_option, error_t, struct
79
85
argp_state, struct argp,
91
97
argz_delete(), argz_append(),
92
98
argz_stringify(), argz_add(),
93
99
argz_count() */
100
#include <netdb.h> /* getnameinfo(), NI_NUMERICHOST,
101
EAI_SYSTEM, gai_strerror() */
94
102
95
103
#ifdef __linux__
96
104
#include <sys/klog.h> /* klogctl() */
138
146
static const char sys_class_net[] = "/sys/class/net";
139
147
char *connect_to = NULL;
140
148
const char *hookdir = HOOKDIR;
149
int hookdir_fd = -1;
141
150
uid_t uid = 65534;
142
151
gid_t gid = 65534;
143
152
154
163
155
164
/* Used for passing in values through the Avahi callback functions */
156
165
typedef struct {
157
AvahiSimplePoll *simple_poll;
158
166
AvahiServer *server;
159
167
gnutls_certificate_credentials_t cred;
160
168
unsigned int dh_bits;
162
170
const char *priority;
163
171
gpgme_ctx_t ctx;
164
172
server *current_server;
173
char *interfaces;
174
size_t interfaces_size;
165
175
} mandos_context;
166
176
167
/* global context so signal handler can reach it*/
168
mandos_context mc = { .simple_poll = NULL, .server = NULL,
169
.dh_bits = 1024, .priority = "SECURE256"
170
":!CTYPE-X.509:+CTYPE-OPENPGP",
171
.current_server = NULL };
177
/* global so signal handler can reach it*/
178
AvahiSimplePoll *simple_poll;
172
179
173
180
sig_atomic_t quit_now = 0;
174
181
int signal_received = 0;
182
189
perror(print_text);
183
190
}
184
191
185
__attribute__((format (gnu_printf, 2, 3)))
192
__attribute__((format (gnu_printf, 2, 3), nonnull))
186
193
int fprintf_plus(FILE *stream, const char *format, ...){
187
194
va_list ap;
188
195
va_start (ap, format);
189
196
190
197
TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
191
198
program_invocation_short_name));
192
return TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
199
return (int)TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
193
200
}
194
201
195
202
/*
197
204
* bytes. "buffer_capacity" is how much is currently allocated,
198
205
* "buffer_length" is how much is already used.
199
206
*/
207
__attribute__((nonnull, warn_unused_result))
200
208
size_t incbuffer(char **buffer, size_t buffer_length,
201
209
size_t buffer_capacity){
202
210
if(buffer_length + BUFFER_SIZE > buffer_capacity){
203
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
204
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;
205
217
return 0;
206
218
}
219
*buffer = new_buf;
207
220
buffer_capacity += BUFFER_SIZE;
208
221
}
209
222
return buffer_capacity;
210
223
}
211
224
212
225
/* Add server to set of servers to retry periodically */
226
__attribute__((nonnull, warn_unused_result))
213
227
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
214
int af){
228
int af, server **current_server){
215
229
int ret;
216
230
server *new_server = malloc(sizeof(server));
217
231
if(new_server == NULL){
224
238
.af = af };
225
239
if(new_server->ip == NULL){
226
240
perror_plus("strdup");
241
free(new_server);
242
return false;
243
}
244
ret = clock_gettime(CLOCK_MONOTONIC, &(new_server->last_seen));
245
if(ret == -1){
246
perror_plus("clock_gettime");
247
#ifdef __GNUC__
248
#pragma GCC diagnostic push
249
#pragma GCC diagnostic ignored "-Wcast-qual"
250
#endif
251
free((char *)(new_server->ip));
252
#ifdef __GNUC__
253
#pragma GCC diagnostic pop
254
#endif
255
free(new_server);
227
256
return false;
228
257
}
229
258
/* Special case of first server */
230
if (mc.current_server == NULL){
259
if(*current_server == NULL){
231
260
new_server->next = new_server;
232
261
new_server->prev = new_server;
233
mc.current_server = new_server;
234
/* Place the new server last in the list */
262
*current_server = new_server;
235
263
} else {
236
new_server->next = mc.current_server;
237
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;
238
267
new_server->prev->next = new_server;
239
mc.current_server->prev = new_server;
240
}
241
ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);
242
if(ret == -1){
243
perror_plus("clock_gettime");
244
return false;
268
(*current_server)->prev = new_server;
245
269
}
246
270
return true;
247
271
}
249
273
/*
250
274
* Initialize GPGME.
251
275
*/
252
static bool init_gpgme(const char *seckey, const char *pubkey,
253
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){
254
281
gpgme_error_t rc;
255
282
gpgme_engine_info_t engine_info;
256
283
257
258
284
/*
259
285
* Helper function to insert pub and seckey to the engine keyring.
260
286
*/
261
bool import_key(const char *filename){
287
bool import_key(const char * const filename){
262
288
int ret;
263
289
int fd;
264
290
gpgme_data_t pgp_data;
276
302
return false;
277
303
}
278
304
279
rc = gpgme_op_import(mc.ctx, pgp_data);
305
rc = gpgme_op_import(mc->ctx, pgp_data);
280
306
if(rc != GPG_ERR_NO_ERROR){
281
307
fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
282
308
gpgme_strsource(rc), gpgme_strerror(rc));
283
309
return false;
284
310
}
285
311
286
ret = (int)TEMP_FAILURE_RETRY(close(fd));
312
ret = close(fd);
287
313
if(ret == -1){
288
314
perror_plus("close");
289
315
}
326
352
}
327
353
328
354
/* Create new GPGME "context" */
329
rc = gpgme_new(&(mc.ctx));
355
rc = gpgme_new(&(mc->ctx));
330
356
if(rc != GPG_ERR_NO_ERROR){
331
357
fprintf_plus(stderr, "Mandos plugin mandos-client: "
332
358
"bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
345
371
* Decrypt OpenPGP data.
346
372
* Returns -1 on error
347
373
*/
374
__attribute__((nonnull, warn_unused_result))
348
375
static ssize_t pgp_packet_decrypt(const char *cryptotext,
349
376
size_t crypto_size,
350
char **plaintext){
377
char **plaintext,
378
mandos_context *mc){
351
379
gpgme_data_t dh_crypto, dh_plain;
352
380
gpgme_error_t rc;
353
381
ssize_t ret;
379
407
380
408
/* Decrypt data from the cryptotext data buffer to the plaintext
381
409
data buffer */
382
rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
410
rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
383
411
if(rc != GPG_ERR_NO_ERROR){
384
412
fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
385
413
gpgme_strsource(rc), gpgme_strerror(rc));
386
414
plaintext_length = -1;
387
415
if(debug){
388
416
gpgme_decrypt_result_t result;
389
result = gpgme_op_decrypt_result(mc.ctx);
417
result = gpgme_op_decrypt_result(mc->ctx);
390
418
if(result == NULL){
391
419
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
392
420
} else {
469
497
return plaintext_length;
470
498
}
471
499
472
static const char * safer_gnutls_strerror(int value){
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){
473
509
const char *ret = gnutls_strerror(value);
474
if(ret == NULL)
475
ret = "(unknown)";
476
return ret;
510
return safe_string(ret);
477
511
}
478
512
479
513
/* GnuTLS log function callback */
514
__attribute__((nonnull))
480
515
static void debuggnutls(__attribute__((unused)) int level,
481
516
const char* string){
482
517
fprintf_plus(stderr, "GnuTLS: %s", string);
483
518
}
484
519
520
__attribute__((nonnull(1, 2, 4), warn_unused_result))
485
521
static int init_gnutls_global(const char *pubkeyfilename,
486
const char *seckeyfilename){
522
const char *seckeyfilename,
523
const char *dhparamsfilename,
524
mandos_context *mc){
487
525
int ret;
526
unsigned int uret;
488
527
489
528
if(debug){
490
529
fprintf_plus(stderr, "Initializing GnuTLS\n");
491
530
}
492
531
493
ret = gnutls_global_init();
494
if(ret != GNUTLS_E_SUCCESS){
495
fprintf_plus(stderr, "GnuTLS global_init: %s\n",
496
safer_gnutls_strerror(ret));
497
return -1;
498
}
499
500
532
if(debug){
501
533
/* "Use a log level over 10 to enable all debugging options."
502
534
* - GnuTLS manual
506
538
}
507
539
508
540
/* OpenPGP credentials */
509
ret = gnutls_certificate_allocate_credentials(&mc.cred);
541
ret = gnutls_certificate_allocate_credentials(&mc->cred);
510
542
if(ret != GNUTLS_E_SUCCESS){
511
543
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
512
544
safer_gnutls_strerror(ret));
513
gnutls_global_deinit();
514
545
return -1;
515
546
}
516
547
522
553
}
523
554
524
555
ret = gnutls_certificate_set_openpgp_key_file
525
(mc.cred, pubkeyfilename, seckeyfilename,
556
(mc->cred, pubkeyfilename, seckeyfilename,
526
557
GNUTLS_OPENPGP_FMT_BASE64);
527
558
if(ret != GNUTLS_E_SUCCESS){
528
559
fprintf_plus(stderr,
534
565
}
535
566
536
567
/* GnuTLS server initialization */
537
ret = gnutls_dh_params_init(&mc.dh_params);
568
ret = gnutls_dh_params_init(&mc->dh_params);
538
569
if(ret != GNUTLS_E_SUCCESS){
539
570
fprintf_plus(stderr, "Error in GnuTLS DH parameter"
540
571
" initialization: %s\n",
541
572
safer_gnutls_strerror(ret));
542
573
goto globalfail;
543
574
}
544
ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
545
if(ret != GNUTLS_E_SUCCESS){
546
fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
547
safer_gnutls_strerror(ret));
548
goto globalfail;
549
}
550
551
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);
552
748
553
749
return 0;
554
750
555
751
globalfail:
556
752
557
gnutls_certificate_free_credentials(mc.cred);
558
gnutls_global_deinit();
559
gnutls_dh_params_deinit(mc.dh_params);
753
gnutls_certificate_free_credentials(mc->cred);
754
gnutls_dh_params_deinit(mc->dh_params);
560
755
return -1;
561
756
}
562
757
563
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){
564
761
int ret;
565
762
/* GnuTLS session creation */
566
763
do {
578
775
{
579
776
const char *err;
580
777
do {
581
ret = gnutls_priority_set_direct(*session, mc.priority, &err);
778
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
582
779
if(quit_now){
583
780
gnutls_deinit(*session);
584
781
return -1;
595
792
596
793
do {
597
794
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
598
mc.cred);
795
mc->cred);
599
796
if(quit_now){
600
797
gnutls_deinit(*session);
601
798
return -1;
611
808
/* ignore client certificate if any. */
612
809
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
613
810
614
gnutls_dh_set_prime_bits(*session, mc.dh_bits);
615
616
811
return 0;
617
812
}
618
813
620
815
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
621
816
__attribute__((unused)) const char *txt){}
622
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
623
1036
/* Called when a Mandos server is found */
1037
__attribute__((nonnull, warn_unused_result))
624
1038
static int start_mandos_communication(const char *ip, in_port_t port,
625
1039
AvahiIfIndex if_index,
626
int af){
1040
int af, mandos_context *mc){
627
1041
int ret, tcp_sd = -1;
628
1042
ssize_t sret;
629
union {
630
struct sockaddr_in in;
631
struct sockaddr_in6 in6;
632
} to;
1043
struct sockaddr_storage to;
633
1044
char *buffer = NULL;
634
1045
char *decrypted_buffer = NULL;
635
1046
size_t buffer_length = 0;
638
1049
int retval = -1;
639
1050
gnutls_session_t session;
640
1051
int pf; /* Protocol family */
1052
bool route_added = false;
641
1053
642
1054
errno = 0;
643
1055
659
1071
return -1;
660
1072
}
661
1073
662
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);
663
1107
if(ret != 0){
664
1108
return -1;
665
1109
}
669
1113
PRIuMAX "\n", ip, (uintmax_t)port);
670
1114
}
671
1115
672
tcp_sd = socket(pf, SOCK_STREAM, 0);
1116
tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
673
1117
if(tcp_sd < 0){
674
1118
int e = errno;
675
1119
perror_plus("socket");
682
1126
goto mandos_end;
683
1127
}
684
1128
685
memset(&to, 0, sizeof(to));
686
1129
if(af == AF_INET6){
687
to.in6.sin6_family = (sa_family_t)af;
688
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);
689
1133
} else { /* IPv4 */
690
to.in.sin_family = (sa_family_t)af;
691
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);
692
1137
}
693
1138
if(ret < 0 ){
694
1139
int e = errno;
703
1148
goto mandos_end;
704
1149
}
705
1150
if(af == AF_INET6){
706
to.in6.sin6_port = htons(port);
707
if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
708
(&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
709
-Wunreachable-code*/
1151
((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
1152
if(IN6_IS_ADDR_LINKLOCAL
1153
(&((struct sockaddr_in6 *)&to)->sin6_addr)){
710
1154
if(if_index == AVAHI_IF_UNSPEC){
711
1155
fprintf_plus(stderr, "An IPv6 link-local address is"
712
1156
" incomplete without a network interface\n");
714
1158
goto mandos_end;
715
1159
}
716
1160
/* Set the network interface number as scope */
717
to.in6.sin6_scope_id = (uint32_t)if_index;
1161
((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
718
1162
}
719
1163
} else {
720
to.in.sin_port = htons(port); /* Spurious warnings from
721
-Wconversion and
722
-Wunreachable-code */
1164
((struct sockaddr_in *)&to)->sin_port = htons(port);
723
1165
}
724
1166
725
1167
if(quit_now){
742
1184
}
743
1185
char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
744
1186
INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
745
const char *pcret;
746
if(af == AF_INET6){
747
pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
748
sizeof(addrstr));
749
} else {
750
pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
751
sizeof(addrstr));
752
}
753
if(pcret == NULL){
754
perror_plus("inet_ntop");
755
} else {
756
if(strcmp(addrstr, ip) != 0){
757
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
758
}
759
}
760
}
761
762
if(quit_now){
763
errno = EINTR;
764
goto mandos_end;
765
}
766
767
if(af == AF_INET6){
768
ret = connect(tcp_sd, &to.in6, sizeof(to));
769
} else {
770
ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
771
}
772
if(ret < 0){
773
if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
774
int e = errno;
775
perror_plus("connect");
776
errno = e;
777
}
778
goto mandos_end;
779
}
780
781
if(quit_now){
782
errno = EINTR;
783
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;
784
1267
}
785
1268
786
1269
const char *out = mandos_protocol_version;
937
1420
if(buffer_length > 0){
938
1421
ssize_t decrypted_buffer_size;
939
1422
decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
940
&decrypted_buffer);
1423
&decrypted_buffer, mc);
941
1424
if(decrypted_buffer_size >= 0){
942
1425
943
1426
written = 0;
969
1452
970
1453
mandos_end:
971
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
}
972
1461
int e = errno;
973
1462
free(decrypted_buffer);
974
1463
free(buffer);
975
1464
if(tcp_sd >= 0){
976
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
1465
ret = close(tcp_sd);
977
1466
}
978
1467
if(ret == -1){
979
1468
if(e == 0){
991
1480
return retval;
992
1481
}
993
1482
1483
__attribute__((nonnull))
994
1484
static void resolve_callback(AvahiSServiceResolver *r,
995
1485
AvahiIfIndex interface,
996
1486
AvahiProtocol proto,
1004
1494
AVAHI_GCC_UNUSED AvahiStringList *txt,
1005
1495
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1006
1496
flags,
1007
AVAHI_GCC_UNUSED void* userdata){
1497
void *mc){
1008
1498
if(r == NULL){
1009
1499
return;
1010
1500
}
1013
1503
timed out */
1014
1504
1015
1505
if(quit_now){
1506
avahi_s_service_resolver_free(r);
1016
1507
return;
1017
1508
}
1018
1509
1022
1513
fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
1023
1514
"'%s' of type '%s' in domain '%s': %s\n", name, type,
1024
1515
domain,
1025
avahi_strerror(avahi_server_errno(mc.server)));
1516
avahi_strerror(avahi_server_errno
1517
(((mandos_context*)mc)->server)));
1026
1518
break;
1027
1519
1028
1520
case AVAHI_RESOLVER_FOUND:
1036
1528
}
1037
1529
int ret = start_mandos_communication(ip, (in_port_t)port,
1038
1530
interface,
1039
avahi_proto_to_af(proto));
1531
avahi_proto_to_af(proto),
1532
mc);
1040
1533
if(ret == 0){
1041
avahi_simple_poll_quit(mc.simple_poll);
1534
avahi_simple_poll_quit(simple_poll);
1042
1535
} else {
1043
1536
if(not add_server(ip, (in_port_t)port, interface,
1044
avahi_proto_to_af(proto))){
1537
avahi_proto_to_af(proto),
1538
&((mandos_context*)mc)->current_server)){
1045
1539
fprintf_plus(stderr, "Failed to add server \"%s\" to server"
1046
1540
" list\n", name);
1047
1541
}
1060
1554
const char *domain,
1061
1555
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1062
1556
flags,
1063
AVAHI_GCC_UNUSED void* userdata){
1557
void *mc){
1064
1558
if(b == NULL){
1065
1559
return;
1066
1560
}
1077
1571
case AVAHI_BROWSER_FAILURE:
1078
1572
1079
1573
fprintf_plus(stderr, "(Avahi browser) %s\n",
1080
avahi_strerror(avahi_server_errno(mc.server)));
1081
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);
1082
1577
return;
1083
1578
1084
1579
case AVAHI_BROWSER_NEW:
1087
1582
the callback function is called the Avahi server will free the
1088
1583
resolver for us. */
1089
1584
1090
if(avahi_s_service_resolver_new(mc.server, interface, protocol,
1091
name, type, domain, protocol, 0,
1092
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)
1093
1589
fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
1094
1590
" %s\n", name,
1095
avahi_strerror(avahi_server_errno(mc.server)));
1591
avahi_strerror(avahi_server_errno
1592
(((mandos_context*)mc)->server)));
1096
1593
break;
1097
1594
1098
1595
case AVAHI_BROWSER_REMOVE:
1117
1614
signal_received = sig;
1118
1615
int old_errno = errno;
1119
1616
/* set main loop to exit */
1120
if(mc.simple_poll != NULL){
1121
avahi_simple_poll_quit(mc.simple_poll);
1617
if(simple_poll != NULL){
1618
avahi_simple_poll_quit(simple_poll);
1122
1619
}
1123
1620
errno = old_errno;
1124
1621
}
1125
1622
1623
__attribute__((nonnull, warn_unused_result))
1126
1624
bool get_flags(const char *ifname, struct ifreq *ifr){
1127
1625
int ret;
1128
error_t ret_errno;
1626
int old_errno;
1129
1627
1130
1628
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1131
1629
if(s < 0){
1132
ret_errno = errno;
1630
old_errno = errno;
1133
1631
perror_plus("socket");
1134
errno = ret_errno;
1632
errno = old_errno;
1135
1633
return false;
1136
1634
}
1137
strcpy(ifr->ifr_name, ifname);
1635
strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
1636
ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
1138
1637
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1139
1638
if(ret == -1){
1140
1639
if(debug){
1141
ret_errno = errno;
1640
old_errno = errno;
1142
1641
perror_plus("ioctl SIOCGIFFLAGS");
1143
errno = ret_errno;
1642
errno = old_errno;
1144
1643
}
1145
1644
return false;
1146
1645
}
1147
1646
return true;
1148
1647
}
1149
1648
1649
__attribute__((nonnull, warn_unused_result))
1150
1650
bool good_flags(const char *ifname, const struct ifreq *ifr){
1151
1651
1152
1652
/* Reject the loopback device */
1194
1694
* corresponds to an acceptable network device.
1195
1695
* (This function is passed to scandir(3) as a filter function.)
1196
1696
*/
1697
__attribute__((nonnull, warn_unused_result))
1197
1698
int good_interface(const struct dirent *if_entry){
1198
1699
if(if_entry->d_name[0] == '.'){
1199
1700
return 0;
1217
1718
/*
1218
1719
* This function determines if a network interface is up.
1219
1720
*/
1721
__attribute__((nonnull, warn_unused_result))
1220
1722
bool interface_is_up(const char *interface){
1221
1723
struct ifreq ifr;
1222
1724
if(not get_flags(interface, &ifr)){
1233
1735
/*
1234
1736
* This function determines if a network interface is running
1235
1737
*/
1738
__attribute__((nonnull, warn_unused_result))
1236
1739
bool interface_is_running(const char *interface){
1237
1740
struct ifreq ifr;
1238
1741
if(not get_flags(interface, &ifr)){
1246
1749
return (bool)(ifr.ifr_flags & IFF_RUNNING);
1247
1750
}
1248
1751
1752
__attribute__((nonnull, pure, warn_unused_result))
1249
1753
int notdotentries(const struct dirent *direntry){
1250
1754
/* Skip "." and ".." */
1251
1755
if(direntry->d_name[0] == '.'
1258
1762
}
1259
1763
1260
1764
/* Is this directory entry a runnable program? */
1765
__attribute__((nonnull, warn_unused_result))
1261
1766
int runnable_hook(const struct dirent *direntry){
1262
1767
int ret;
1263
1768
size_t sret;
1271
1776
sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1272
1777
"abcdefghijklmnopqrstuvwxyz"
1273
1778
"0123456789"
1274
"_-");
1779
"_.-");
1275
1780
if((direntry->d_name)[sret] != '\0'){
1276
1781
/* Contains non-allowed characters */
1277
1782
if(debug){
1281
1786
return 0;
1282
1787
}
1283
1788
1284
char *fullname = NULL;
1285
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1286
if(ret < 0){
1287
perror_plus("asprintf");
1288
return 0;
1289
}
1290
1291
ret = stat(fullname, &st);
1789
ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1292
1790
if(ret == -1){
1293
1791
if(debug){
1294
1792
perror_plus("Could not stat hook");
1318
1816
return 1;
1319
1817
}
1320
1818
1321
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){
1322
1822
int ret;
1323
1823
struct timespec now;
1324
1824
struct timespec waited_time;
1325
1825
intmax_t block_time;
1326
1826
1327
1827
while(true){
1328
if(mc.current_server == NULL){
1329
if (debug){
1828
if(mc->current_server == NULL){
1829
if(debug){
1330
1830
fprintf_plus(stderr, "Wait until first server is found."
1331
1831
" No timeout!\n");
1332
1832
}
1333
1833
ret = avahi_simple_poll_iterate(s, -1);
1334
1834
} else {
1335
if (debug){
1835
if(debug){
1336
1836
fprintf_plus(stderr, "Check current_server if we should run"
1337
1837
" it, or wait\n");
1338
1838
}
1345
1845
/* Calculating in ms how long time between now and server
1346
1846
who we visted longest time ago. Now - last seen. */
1347
1847
waited_time.tv_sec = (now.tv_sec
1348
- mc.current_server->last_seen.tv_sec);
1848
- mc->current_server->last_seen.tv_sec);
1349
1849
waited_time.tv_nsec = (now.tv_nsec
1350
- mc.current_server->last_seen.tv_nsec);
1850
- mc->current_server->last_seen.tv_nsec);
1351
1851
/* total time is 10s/10,000ms.
1352
1852
Converting to s from ms by dividing by 1,000,
1353
1853
and ns to ms by dividing by 1,000,000. */
1355
1855
- ((intmax_t)waited_time.tv_sec * 1000))
1356
1856
- ((intmax_t)waited_time.tv_nsec / 1000000));
1357
1857
1358
if (debug){
1858
if(debug){
1359
1859
fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1360
1860
block_time);
1361
1861
}
1362
1862
1363
1863
if(block_time <= 0){
1364
ret = start_mandos_communication(mc.current_server->ip,
1365
mc.current_server->port,
1366
mc.current_server->if_index,
1367
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);
1368
1868
if(ret == 0){
1369
avahi_simple_poll_quit(mc.simple_poll);
1869
avahi_simple_poll_quit(s);
1370
1870
return 0;
1371
1871
}
1372
1872
ret = clock_gettime(CLOCK_MONOTONIC,
1373
&mc.current_server->last_seen);
1873
&mc->current_server->last_seen);
1374
1874
if(ret == -1){
1375
1875
perror_plus("clock_gettime");
1376
1876
return -1;
1377
1877
}
1378
mc.current_server = mc.current_server->next;
1878
mc->current_server = mc->current_server->next;
1379
1879
block_time = 0; /* Call avahi to find new Mandos
1380
1880
servers, but don't block */
1381
1881
}
1383
1883
ret = avahi_simple_poll_iterate(s, (int)block_time);
1384
1884
}
1385
1885
if(ret != 0){
1386
if (ret > 0 or errno != EINTR){
1886
if(ret > 0 or errno != EINTR){
1387
1887
return (ret != 1) ? ret : 0;
1388
1888
}
1389
1889
}
1390
1890
}
1391
1891
}
1392
1892
1393
/* Set effective uid to 0, return errno */
1394
error_t raise_privileges(void){
1395
error_t old_errno = errno;
1396
error_t ret_errno = 0;
1397
if(seteuid(0) == -1){
1398
ret_errno = errno;
1399
perror_plus("seteuid");
1400
}
1401
errno = old_errno;
1402
return ret_errno;
1403
}
1404
1405
/* Set effective and real user ID to 0. Return errno. */
1406
error_t raise_privileges_permanently(void){
1407
error_t old_errno = errno;
1408
error_t ret_errno = raise_privileges();
1409
if(ret_errno != 0){
1410
errno = old_errno;
1411
return ret_errno;
1412
}
1413
if(setuid(0) == -1){
1414
ret_errno = errno;
1415
perror_plus("seteuid");
1416
}
1417
errno = old_errno;
1418
return ret_errno;
1419
}
1420
1421
/* Set effective user ID to unprivileged saved user ID */
1422
error_t lower_privileges(void){
1423
error_t old_errno = errno;
1424
error_t ret_errno = 0;
1425
if(seteuid(uid) == -1){
1426
ret_errno = errno;
1427
perror_plus("seteuid");
1428
}
1429
errno = old_errno;
1430
return ret_errno;
1431
}
1432
1433
/* Lower privileges permanently */
1434
error_t lower_privileges_permanently(void){
1435
error_t old_errno = errno;
1436
error_t ret_errno = 0;
1437
if(setuid(uid) == -1){
1438
ret_errno = errno;
1439
perror_plus("setuid");
1440
}
1441
errno = old_errno;
1442
return ret_errno;
1443
}
1444
1445
bool run_network_hooks(const char *mode, const char *interface,
1893
__attribute__((nonnull))
1894
void run_network_hooks(const char *mode, const char *interface,
1446
1895
const float delay){
1447
struct dirent **direntries;
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);
1914
if(numhooks == -1){
1915
perror_plus("scandir");
1916
return;
1917
}
1448
1918
struct dirent *direntry;
1449
1919
int ret;
1450
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1451
alphasort);
1452
if(numhooks == -1){
1453
if(errno == ENOENT){
1454
if(debug){
1455
fprintf_plus(stderr, "Network hook directory \"%s\" not"
1456
" found\n", hookdir);
1457
}
1458
} else {
1459
perror_plus("scandir");
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);
1460
1930
}
1461
} else {
1462
int devnull = open("/dev/null", O_RDONLY);
1463
for(int i = 0; i < numhooks; i++){
1464
direntry = direntries[i];
1465
char *fullname = NULL;
1466
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1467
if(ret < 0){
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){
1468
1977
perror_plus("asprintf");
1469
continue;
1470
}
1471
if(debug){
1472
fprintf_plus(stderr, "Running network hook \"%s\"\n",
1473
direntry->d_name);
1474
}
1475
pid_t hook_pid = fork();
1476
if(hook_pid == 0){
1477
/* Child */
1478
/* Raise privileges */
1479
raise_privileges_permanently();
1480
/* Set group */
1481
errno = 0;
1482
ret = setgid(0);
1483
if(ret == -1){
1484
perror_plus("setgid");
1485
}
1486
/* Reset supplementary groups */
1487
errno = 0;
1488
ret = setgroups(0, NULL);
1489
if(ret == -1){
1490
perror_plus("setgroups");
1491
}
1492
dup2(devnull, STDIN_FILENO);
1493
close(devnull);
1494
dup2(STDERR_FILENO, STDOUT_FILENO);
1495
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1496
if(ret == -1){
1497
perror_plus("setenv");
1498
_exit(EX_OSERR);
1499
}
1500
ret = setenv("DEVICE", interface, 1);
1501
if(ret == -1){
1502
perror_plus("setenv");
1503
_exit(EX_OSERR);
1504
}
1505
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
1506
if(ret == -1){
1507
perror_plus("setenv");
1508
_exit(EX_OSERR);
1509
}
1510
ret = setenv("MODE", mode, 1);
1511
if(ret == -1){
1512
perror_plus("setenv");
1513
_exit(EX_OSERR);
1514
}
1515
char *delaystring;
1516
ret = asprintf(&delaystring, "%f", delay);
1517
if(ret == -1){
1518
perror_plus("asprintf");
1519
_exit(EX_OSERR);
1520
}
1521
ret = setenv("DELAY", delaystring, 1);
1522
if(ret == -1){
1523
free(delaystring);
1524
perror_plus("setenv");
1525
_exit(EX_OSERR);
1526
}
1978
_exit(EX_OSERR);
1979
}
1980
ret = setenv("DELAY", delaystring, 1);
1981
if(ret == -1){
1527
1982
free(delaystring);
1528
if(connect_to != NULL){
1529
ret = setenv("CONNECT", connect_to, 1);
1530
if(ret == -1){
1531
perror_plus("setenv");
1532
_exit(EX_OSERR);
1533
}
1534
}
1535
if(execl(fullname, direntry->d_name, mode, NULL) == -1){
1536
perror_plus("execl");
1537
_exit(EXIT_FAILURE);
1538
}
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;
1539
2051
} else {
1540
int status;
1541
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1542
perror_plus("waitpid");
1543
free(fullname);
1544
continue;
1545
}
1546
if(WIFEXITED(status)){
1547
if(WEXITSTATUS(status) != 0){
1548
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1549
" with status %d\n", direntry->d_name,
1550
WEXITSTATUS(status));
1551
free(fullname);
1552
continue;
1553
}
1554
} else if(WIFSIGNALED(status)){
1555
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1556
" signal %d\n", direntry->d_name,
1557
WTERMSIG(status));
1558
free(fullname);
1559
continue;
1560
} else {
1561
fprintf_plus(stderr, "Warning: network hook \"%s\""
1562
" crashed\n", direntry->d_name);
1563
free(fullname);
1564
continue;
1565
}
1566
}
1567
free(fullname);
1568
if(debug){
1569
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1570
direntry->d_name);
1571
}
1572
}
1573
close(devnull);
1574
}
1575
return true;
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);
1576
2071
}
1577
2072
1578
error_t bring_up_interface(const char *const interface,
1579
const float delay){
1580
int sd = -1;
1581
error_t old_errno = errno;
1582
error_t ret_errno = 0;
1583
int ret, ret_setflags;
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;
1584
2078
struct ifreq network;
1585
2079
unsigned int if_index = if_nametoindex(interface);
1586
2080
if(if_index == 0){
1595
2089
}
1596
2090
1597
2091
if(not interface_is_up(interface)){
1598
if(not get_flags(interface, &network) and debug){
2092
int ret_errno = 0;
2093
int ioctl_errno = 0;
2094
if(not get_flags(interface, &network)){
1599
2095
ret_errno = errno;
1600
2096
fprintf_plus(stderr, "Failed to get flags for interface "
1601
2097
"\"%s\"\n", interface);
2098
errno = old_errno;
1602
2099
return ret_errno;
1603
2100
}
1604
network.ifr_flags |= IFF_UP;
2101
network.ifr_flags |= IFF_UP; /* set flag */
1605
2102
1606
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1607
if(sd < 0){
2103
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
2104
if(sd == -1){
1608
2105
ret_errno = errno;
1609
2106
perror_plus("socket");
1610
2107
errno = old_errno;
1611
2108
return ret_errno;
1612
2109
}
1613
2110
1614
2111
if(quit_now){
1615
close(sd);
2112
ret = close(sd);
2113
if(ret == -1){
2114
perror_plus("close");
2115
}
1616
2116
errno = old_errno;
1617
2117
return EINTR;
1618
2118
}
1622
2122
interface);
1623
2123
}
1624
2124
1625
/* Raise priviliges */
1626
raise_privileges();
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
}
1627
2131
1628
2132
#ifdef __linux__
1629
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1630
messages about the network interface to mess up the prompt */
1631
int ret_linux = klogctl(8, NULL, 5);
1632
bool restore_loglevel = true;
1633
if(ret_linux == -1){
1634
restore_loglevel = false;
1635
perror_plus("klogctl");
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
}
1636
2144
}
1637
2145
#endif /* __linux__ */
1638
ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1639
ret_errno = errno;
2146
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
2147
ioctl_errno = errno;
1640
2148
#ifdef __linux__
1641
2149
if(restore_loglevel){
1642
2150
ret_linux = klogctl(7, NULL, 0);
1646
2154
}
1647
2155
#endif /* __linux__ */
1648
2156
1649
/* Lower privileges */
1650
lower_privileges();
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
}
1651
2166
1652
2167
/* Close the socket */
1653
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2168
ret = close(sd);
1654
2169
if(ret == -1){
1655
2170
perror_plus("close");
1656
2171
}
1657
2172
1658
2173
if(ret_setflags == -1){
1659
errno = ret_errno;
2174
errno = ioctl_errno;
1660
2175
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1661
2176
errno = old_errno;
1662
return ret_errno;
2177
return ioctl_errno;
1663
2178
}
1664
2179
} else if(debug){
1665
2180
fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
1683
2198
return 0;
1684
2199
}
1685
2200
1686
error_t take_down_interface(const char *const interface){
1687
int sd = -1;
1688
error_t old_errno = errno;
1689
error_t ret_errno = 0;
1690
int ret, ret_setflags;
2201
__attribute__((nonnull, warn_unused_result))
2202
int take_down_interface(const char *const interface){
2203
int old_errno = errno;
1691
2204
struct ifreq network;
1692
2205
unsigned int if_index = if_nametoindex(interface);
1693
2206
if(if_index == 0){
1696
2209
return ENXIO;
1697
2210
}
1698
2211
if(interface_is_up(interface)){
2212
int ret_errno = 0;
2213
int ioctl_errno = 0;
1699
2214
if(not get_flags(interface, &network) and debug){
1700
2215
ret_errno = errno;
1701
2216
fprintf_plus(stderr, "Failed to get flags for interface "
1702
2217
"\"%s\"\n", interface);
2218
errno = old_errno;
1703
2219
return ret_errno;
1704
2220
}
1705
2221
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
1706
2222
1707
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1708
if(sd < 0){
2223
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
2224
if(sd == -1){
1709
2225
ret_errno = errno;
1710
2226
perror_plus("socket");
1711
2227
errno = old_errno;
1717
2233
interface);
1718
2234
}
1719
2235
1720
/* Raise priviliges */
1721
raise_privileges();
1722
1723
ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1724
ret_errno = errno;
1725
1726
/* Lower privileges */
1727
lower_privileges();
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
}
1728
2255
1729
2256
/* Close the socket */
1730
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2257
int ret = close(sd);
1731
2258
if(ret == -1){
1732
2259
perror_plus("close");
1733
2260
}
1734
2261
1735
2262
if(ret_setflags == -1){
1736
errno = ret_errno;
2263
errno = ioctl_errno;
1737
2264
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
1738
2265
errno = old_errno;
1739
return ret_errno;
2266
return ioctl_errno;
1740
2267
}
1741
2268
} else if(debug){
1742
2269
fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
1748
2275
}
1749
2276
1750
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 };
1751
2283
AvahiSServiceBrowser *sb = NULL;
1752
2284
error_t ret_errno;
1753
2285
int ret;
1754
2286
intmax_t tmpmax;
1755
2287
char *tmp;
1756
2288
int exitcode = EXIT_SUCCESS;
1757
char *interfaces = NULL;
1758
size_t interfaces_size = 0;
1759
2289
char *interfaces_to_take_down = NULL;
1760
2290
size_t interfaces_to_take_down_size = 0;
1761
char tempdir[] = "/tmp/mandosXXXXXX";
1762
bool tempdir_created = false;
2291
char run_tempdir[] = "/run/tmp/mandosXXXXXX";
2292
char old_tempdir[] = "/tmp/mandosXXXXXX";
2293
char *tempdir = NULL;
1763
2294
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1764
2295
const char *seckey = PATHDIR "/" SECKEY;
1765
2296
const char *pubkey = PATHDIR "/" PUBKEY;
2297
const char *dh_params_file = NULL;
1766
2298
char *interfaces_hooks = NULL;
1767
size_t interfaces_hooks_size = 0;
1768
2299
1769
2300
bool gnutls_initialized = false;
1770
2301
bool gpgme_initialized = false;
1822
2353
.doc = "Bit length of the prime number used in the"
1823
2354
" Diffie-Hellman key exchange",
1824
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 },
1825
2361
{ .name = "priority", .key = 130,
1826
2362
.arg = "STRING",
1827
2363
.doc = "GnuTLS priority string for the TLS handshake",
1861
2397
connect_to = arg;
1862
2398
break;
1863
2399
case 'i': /* --interface */
1864
ret_errno = argz_add_sep(&interfaces, &interfaces_size, arg,
1865
(int)',');
2400
ret_errno = argz_add_sep(&mc.interfaces, &mc.interfaces_size,
2401
arg, (int)',');
1866
2402
if(ret_errno != 0){
1867
2403
argp_error(state, "%s", strerror(ret_errno));
1868
2404
}
1882
2418
}
1883
2419
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
1884
2420
break;
2421
case 134: /* --dh-params */
2422
dh_params_file = arg;
2423
break;
1885
2424
case 130: /* --priority */
1886
2425
mc.priority = arg;
1887
2426
break;
1927
2466
.args_doc = "",
1928
2467
.doc = "Mandos client -- Get and decrypt"
1929
2468
" passwords from a Mandos server" };
1930
ret = argp_parse(&argp, argc, argv,
1931
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
1932
switch(ret){
2469
ret_errno = argp_parse(&argp, argc, argv,
2470
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2471
switch(ret_errno){
1933
2472
case 0:
1934
2473
break;
1935
2474
case ENOMEM:
1936
2475
default:
1937
errno = ret;
2476
errno = ret_errno;
1938
2477
perror_plus("argp_parse");
1939
2478
exitcode = EX_OSERR;
1940
2479
goto end;
1943
2482
goto end;
1944
2483
}
1945
2484
}
1946
2485
1947
2486
{
1948
2487
/* Work around Debian bug #633582:
1949
2488
<http://bugs.debian.org/633582> */
1950
2489
1951
/* Re-raise priviliges */
1952
if(raise_privileges() == 0){
2490
/* Re-raise privileges */
2491
ret = raise_privileges();
2492
if(ret != 0){
2493
errno = ret;
2494
perror_plus("Failed to raise privileges");
2495
} else {
1953
2496
struct stat st;
1954
2497
1955
2498
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
1969
2512
}
1970
2513
}
1971
2514
}
1972
TEMP_FAILURE_RETRY(close(seckey_fd));
2515
close(seckey_fd);
1973
2516
}
1974
2517
}
1975
2518
1976
2519
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
1977
2520
int pubkey_fd = open(pubkey, O_RDONLY);
1978
2521
if(pubkey_fd == -1){
1990
2533
}
1991
2534
}
1992
2535
}
1993
TEMP_FAILURE_RETRY(close(pubkey_fd));
1994
}
1995
}
1996
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
1997
2562
/* Lower privileges */
1998
errno = 0;
1999
ret = seteuid(uid);
2000
if(ret == -1){
2001
perror_plus("seteuid");
2563
ret = lower_privileges();
2564
if(ret != 0){
2565
errno = ret;
2566
perror_plus("Failed to lower privileges");
2002
2567
}
2003
2568
}
2004
2569
}
2005
2570
2006
/* Remove empty interface names */
2571
/* Remove invalid interface names (except "none") */
2007
2572
{
2008
2573
char *interface = NULL;
2009
while((interface = argz_next(interfaces, interfaces_size,
2574
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2010
2575
interface))){
2011
if(if_nametoindex(interface) == 0){
2012
if(interface[0] != '\0' and strcmp(interface, "none") != 0){
2576
if(strcmp(interface, "none") != 0
2577
and if_nametoindex(interface) == 0){
2578
if(interface[0] != '\0'){
2013
2579
fprintf_plus(stderr, "Not using nonexisting interface"
2014
2580
" \"%s\"\n", interface);
2015
2581
}
2016
argz_delete(&interfaces, &interfaces_size, interface);
2582
argz_delete(&mc.interfaces, &mc.interfaces_size, interface);
2017
2583
interface = NULL;
2018
2584
}
2019
2585
}
2021
2587
2022
2588
/* Run network hooks */
2023
2589
{
2024
2025
if(interfaces != NULL){
2026
interfaces_hooks = malloc(interfaces_size);
2590
if(mc.interfaces != NULL){
2591
interfaces_hooks = malloc(mc.interfaces_size);
2027
2592
if(interfaces_hooks == NULL){
2028
2593
perror_plus("malloc");
2029
2594
goto end;
2030
2595
}
2031
memcpy(interfaces_hooks, interfaces, interfaces_size);
2032
interfaces_hooks_size = interfaces_size;
2033
argz_stringify(interfaces_hooks, interfaces_hooks_size,
2034
(int)',');
2035
}
2036
if(not run_network_hooks("start", interfaces_hooks != NULL ?
2037
interfaces_hooks : "", delay)){
2038
goto end;
2039
}
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);
2040
2601
}
2041
2602
2042
2603
if(not debug){
2047
2608
from the signal handler */
2048
2609
/* Initialize the pseudo-RNG for Avahi */
2049
2610
srand((unsigned int) time(NULL));
2050
mc.simple_poll = avahi_simple_poll_new();
2051
if(mc.simple_poll == NULL){
2611
simple_poll = avahi_simple_poll_new();
2612
if(simple_poll == NULL){
2052
2613
fprintf_plus(stderr,
2053
2614
"Avahi: Failed to create simple poll object.\n");
2054
2615
exitcode = EX_UNAVAILABLE;
2119
2680
}
2120
2681
2121
2682
/* If no interfaces were specified, make a list */
2122
if(interfaces == NULL){
2123
struct dirent **direntries;
2683
if(mc.interfaces == NULL){
2684
struct dirent **direntries = NULL;
2124
2685
/* Look for any good interfaces */
2125
2686
ret = scandir(sys_class_net, &direntries, good_interface,
2126
2687
alphasort);
2127
2688
if(ret >= 1){
2128
2689
/* Add all found interfaces to interfaces list */
2129
2690
for(int i = 0; i < ret; ++i){
2130
ret_errno = argz_add(&interfaces, &interfaces_size,
2691
ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
2131
2692
direntries[i]->d_name);
2132
2693
if(ret_errno != 0){
2694
errno = ret_errno;
2133
2695
perror_plus("argz_add");
2696
free(direntries[i]);
2134
2697
continue;
2135
2698
}
2136
2699
if(debug){
2137
2700
fprintf_plus(stderr, "Will use interface \"%s\"\n",
2138
2701
direntries[i]->d_name);
2139
2702
}
2703
free(direntries[i]);
2140
2704
}
2141
2705
free(direntries);
2142
2706
} else {
2143
free(direntries);
2707
if(ret == 0){
2708
free(direntries);
2709
}
2144
2710
fprintf_plus(stderr, "Could not find a network interface\n");
2145
2711
exitcode = EXIT_FAILURE;
2146
2712
goto end;
2147
2713
}
2148
2714
}
2149
2715
2150
/* If we only got one interface, explicitly use only that one */
2151
if(argz_count(interfaces, interfaces_size) == 1){
2152
if(debug){
2153
fprintf_plus(stderr, "Using only interface \"%s\"\n",
2154
interfaces);
2155
}
2156
if_index = (AvahiIfIndex)if_nametoindex(interfaces);
2157
}
2158
2159
/* Bring up interfaces which are down */
2160
if(not (argz_count(interfaces, interfaces_size) == 1
2161
and strcmp(interfaces, "none") == 0)){
2716
/* Bring up interfaces which are down, and remove any "none"s */
2717
{
2162
2718
char *interface = NULL;
2163
while((interface = argz_next(interfaces, interfaces_size,
2719
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2164
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;
2733
}
2734
}
2735
break;
2736
}
2165
2737
bool interface_was_up = interface_is_up(interface);
2166
ret = bring_up_interface(interface, delay);
2738
errno = bring_up_interface(interface, delay);
2167
2739
if(not interface_was_up){
2168
if(ret != 0){
2169
errno = ret;
2170
perror_plus("Failed to bring up interface");
2740
if(errno != 0){
2741
fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
2742
" %s\n", interface, strerror(errno));
2171
2743
} else {
2172
ret_errno = argz_add(&interfaces_to_take_down,
2173
&interfaces_to_take_down_size,
2174
interface);
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
}
2175
2750
}
2176
2751
}
2177
2752
}
2178
free(interfaces);
2179
interfaces = NULL;
2180
interfaces_size = 0;
2181
2753
if(debug and (interfaces_to_take_down == NULL)){
2182
2754
fprintf_plus(stderr, "No interfaces were brought up\n");
2183
2755
}
2184
2756
}
2185
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);
2765
}
2766
2186
2767
if(quit_now){
2187
2768
goto end;
2188
2769
}
2189
2770
2190
ret = init_gnutls_global(pubkey, seckey);
2771
ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
2191
2772
if(ret == -1){
2192
2773
fprintf_plus(stderr, "init_gnutls_global failed\n");
2193
2774
exitcode = EX_UNAVAILABLE;
2200
2781
goto end;
2201
2782
}
2202
2783
2203
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){
2204
2794
perror_plus("mkdtemp");
2205
2795
goto end;
2206
2796
}
2207
tempdir_created = true;
2208
2797
2209
2798
if(quit_now){
2210
2799
goto end;
2211
2800
}
2212
2801
2213
if(not init_gpgme(pubkey, seckey, tempdir)){
2802
if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
2214
2803
fprintf_plus(stderr, "init_gpgme failed\n");
2215
2804
exitcode = EX_UNAVAILABLE;
2216
2805
goto end;
2246
2835
exitcode = EX_USAGE;
2247
2836
goto end;
2248
2837
}
2249
2838
2250
2839
if(quit_now){
2251
2840
goto end;
2252
2841
}
2273
2862
}
2274
2863
2275
2864
while(not quit_now){
2276
ret = start_mandos_communication(address, port, if_index, af);
2865
ret = start_mandos_communication(address, port, if_index, af,
2866
&mc);
2277
2867
if(quit_now or ret == 0){
2278
2868
break;
2279
2869
}
2281
2871
fprintf_plus(stderr, "Retrying in %d seconds\n",
2282
2872
(int)retry_interval);
2283
2873
}
2284
sleep((int)retry_interval);
2874
sleep((unsigned int)retry_interval);
2285
2875
}
2286
2876
2287
if (not quit_now){
2877
if(not quit_now){
2288
2878
exitcode = EXIT_SUCCESS;
2289
2879
}
2290
2880
2305
2895
config.publish_domain = 0;
2306
2896
2307
2897
/* Allocate a new server */
2308
mc.server = avahi_server_new(avahi_simple_poll_get
2309
(mc.simple_poll), &config, NULL,
2310
NULL, &ret_errno);
2898
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
2899
&config, NULL, NULL, &ret);
2311
2900
2312
2901
/* Free the Avahi configuration data */
2313
2902
avahi_server_config_free(&config);
2316
2905
/* Check if creating the Avahi server object succeeded */
2317
2906
if(mc.server == NULL){
2318
2907
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2319
avahi_strerror(ret_errno));
2908
avahi_strerror(ret));
2320
2909
exitcode = EX_UNAVAILABLE;
2321
2910
goto end;
2322
2911
}
2328
2917
/* Create the Avahi service browser */
2329
2918
sb = avahi_s_service_browser_new(mc.server, if_index,
2330
2919
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
2331
NULL, 0, browse_callback, NULL);
2920
NULL, 0, browse_callback,
2921
(void *)&mc);
2332
2922
if(sb == NULL){
2333
2923
fprintf_plus(stderr, "Failed to create service browser: %s\n",
2334
2924
avahi_strerror(avahi_server_errno(mc.server)));
2345
2935
if(debug){
2346
2936
fprintf_plus(stderr, "Starting Avahi loop search\n");
2347
2937
}
2348
2349
ret = avahi_loop_with_timeout(mc.simple_poll,
2350
(int)(retry_interval * 1000));
2938
2939
ret = avahi_loop_with_timeout(simple_poll,
2940
(int)(retry_interval * 1000), &mc);
2351
2941
if(debug){
2352
2942
fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
2353
2943
(ret == 0) ? "successfully" : "with error");
2360
2950
}
2361
2951
2362
2952
/* Cleanup things */
2953
free(mc.interfaces);
2954
2363
2955
if(sb != NULL)
2364
2956
avahi_s_service_browser_free(sb);
2365
2957
2366
2958
if(mc.server != NULL)
2367
2959
avahi_server_free(mc.server);
2368
2960
2369
if(mc.simple_poll != NULL)
2370
avahi_simple_poll_free(mc.simple_poll);
2961
if(simple_poll != NULL)
2962
avahi_simple_poll_free(simple_poll);
2371
2963
2372
2964
if(gnutls_initialized){
2373
2965
gnutls_certificate_free_credentials(mc.cred);
2374
gnutls_global_deinit();
2375
2966
gnutls_dh_params_deinit(mc.dh_params);
2376
2967
}
2377
2968
2385
2976
mc.current_server->prev->next = NULL;
2386
2977
while(mc.current_server != NULL){
2387
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
2388
2987
free(mc.current_server);
2389
2988
mc.current_server = next;
2390
2989
}
2391
2990
}
2392
2991
2393
/* Re-raise priviliges */
2992
/* Re-raise privileges */
2394
2993
{
2395
raise_privileges();
2396
2397
/* Run network hooks */
2398
run_network_hooks("stop", interfaces_hooks != NULL ?
2399
interfaces_hooks : "", delay);
2400
2401
/* Take down the network interfaces which were brought up */
2402
{
2403
char *interface = NULL;
2404
while((interface=argz_next(interfaces_to_take_down,
2405
interfaces_to_take_down_size,
2406
interface))){
2407
ret_errno = take_down_interface(interface);
2408
if(ret_errno != 0){
2409
errno = ret_errno;
2410
perror_plus("Failed to take down interface");
2411
}
2412
}
2413
if(debug and (interfaces_to_take_down == NULL)){
2414
fprintf_plus(stderr, "No interfaces needed to be taken"
2415
" down\n");
2416
}
2417
}
2418
2419
lower_privileges_permanently();
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
}
3020
}
3021
}
3022
3023
ret = lower_privileges_permanently();
3024
if(ret != 0){
3025
errno = ret;
3026
perror_plus("Failed to lower privileges permanently");
3027
}
2420
3028
}
2421
3029
2422
3030
free(interfaces_to_take_down);
2423
3031
free(interfaces_hooks);
2424
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);
3087
}
3088
2425
3089
/* Removes the GPGME temp directory and all files inside */
2426
if(tempdir_created){
2427
struct dirent **direntries = NULL;
2428
struct dirent *direntry = NULL;
2429
int numentries = scandir(tempdir, &direntries, notdotentries,
2430
alphasort);
2431
if (numentries > 0){
2432
for(int i = 0; i < numentries; i++){
2433
direntry = direntries[i];
2434
char *fullname = NULL;
2435
ret = asprintf(&fullname, "%s/%s", tempdir,
2436
direntry->d_name);
2437
if(ret < 0){
2438
perror_plus("asprintf");
2439
continue;
2440
}
2441
ret = remove(fullname);
2442
if(ret == -1){
2443
fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2444
strerror(errno));
2445
}
2446
free(fullname);
2447
}
2448
}
2449
2450
/* need to clean even if 0 because man page doesn't specify */
2451
free(direntries);
2452
if (numentries == -1){
2453
perror_plus("scandir");
2454
}
2455
ret = rmdir(tempdir);
2456
if(ret == -1 and errno != ENOENT){
2457
perror_plus("rmdir");
2458
}
3090
if(tempdir != NULL){
3091
clean_dir_at(-1, tempdir, 0);
2459
3092
}
2460
3093
2461
3094
if(quit_now){
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0