117
47
#include <avahi-common/malloc.h>
118
48
#include <avahi-common/error.h>
121
#include <gnutls/gnutls.h> /* All GnuTLS types, constants and
124
init_gnutls_session(),
126
#if GNUTLS_VERSION_NUMBER < 0x030600
127
#include <gnutls/openpgp.h>
128
/* gnutls_certificate_set_openpgp_key_file(),
129
GNUTLS_OPENPGP_FMT_BASE64 */
130
#elif GNUTLS_VERSION_NUMBER >= 0x030606
131
#include <gnutls/x509.h> /* gnutls_pkcs_encrypt_flags_t,
133
GNUTLS_PKCS_NULL_PASSWORD */
137
#include <gpgme.h> /* All GPGME types, constants and
140
GPGME_PROTOCOL_OpenPGP,
51
#include <sys/types.h> /* socket(), inet_pton() */
52
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
53
struct in6_addr, inet_pton() */
54
#include <gnutls/gnutls.h> /* All GnuTLS stuff */
55
#include <gnutls/openpgp.h> /* GnuTLS with openpgp stuff */
57
#include <unistd.h> /* close() */
58
#include <netinet/in.h>
59
#include <stdbool.h> /* true */
60
#include <string.h> /* memset */
61
#include <arpa/inet.h> /* inet_pton() */
62
#include <iso646.h> /* not */
65
#include <errno.h> /* perror() */
143
71
#define BUFFER_SIZE 256
145
#define PATHDIR "/conf/conf.d/mandos"
146
#define SECKEY "seckey.txt"
147
#define PUBKEY "pubkey.txt"
148
#define TLS_PRIVKEY "tls-privkey.pem"
149
#define TLS_PUBKEY "tls-pubkey.pem"
150
#define HOOKDIR "/lib/mandos/network-hooks.d"
74
const char *certdir = "/conf/conf.d/cryptkeyreq/";
75
const char *certfile = "openpgp-client.txt";
76
const char *certkey = "openpgp-client-key.txt";
152
78
bool debug = false;
153
static const char mandos_protocol_version[] = "1";
154
const char *argp_program_version = "mandos-client " VERSION;
155
const char *argp_program_bug_address = "<mandos@recompile.se>";
156
static const char sys_class_net[] = "/sys/class/net";
157
char *connect_to = NULL;
158
const char *hookdir = HOOKDIR;
163
/* Doubly linked list that need to be circularly linked when used */
164
typedef struct server{
167
AvahiIfIndex if_index;
169
struct timespec last_seen;
174
/* Used for passing in values through the Avahi callback functions */
81
gnutls_session_t session;
177
82
gnutls_certificate_credentials_t cred;
178
unsigned int dh_bits;
179
83
gnutls_dh_params_t dh_params;
180
const char *priority;
87
ssize_t pgp_packet_decrypt (char *packet, size_t packet_size,
88
char **new_packet, const char *homedir){
89
gpgme_data_t dh_crypto, dh_plain;
182
server *current_server;
184
size_t interfaces_size;
187
/* global so signal handler can reach it*/
188
AvahiSimplePoll *simple_poll;
190
sig_atomic_t quit_now = 0;
191
int signal_received = 0;
193
/* Function to use when printing errors */
194
void perror_plus(const char *print_text){
196
fprintf(stderr, "Mandos plugin %s: ",
197
program_invocation_short_name);
202
__attribute__((format (gnu_printf, 2, 3), nonnull))
203
int fprintf_plus(FILE *stream, const char *format, ...){
205
va_start (ap, format);
207
TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
208
program_invocation_short_name));
209
return (int)TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
213
* Make additional room in "buffer" for at least BUFFER_SIZE more
214
* bytes. "buffer_capacity" is how much is currently allocated,
215
* "buffer_length" is how much is already used.
217
__attribute__((nonnull, warn_unused_result))
218
size_t incbuffer(char **buffer, size_t buffer_length,
219
size_t buffer_capacity){
220
if(buffer_length + BUFFER_SIZE > buffer_capacity){
221
char *new_buf = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
223
int old_errno = errno;
230
buffer_capacity += BUFFER_SIZE;
232
return buffer_capacity;
235
/* Add server to set of servers to retry periodically */
236
__attribute__((nonnull, warn_unused_result))
237
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
238
int af, server **current_server){
240
server *new_server = malloc(sizeof(server));
241
if(new_server == NULL){
242
perror_plus("malloc");
245
*new_server = (server){ .ip = strdup(ip),
247
.if_index = if_index,
249
if(new_server->ip == NULL){
250
perror_plus("strdup");
254
ret = clock_gettime(CLOCK_MONOTONIC, &(new_server->last_seen));
256
perror_plus("clock_gettime");
258
#pragma GCC diagnostic push
259
#pragma GCC diagnostic ignored "-Wcast-qual"
261
free((char *)(new_server->ip));
263
#pragma GCC diagnostic pop
268
/* Special case of first server */
269
if(*current_server == NULL){
270
new_server->next = new_server;
271
new_server->prev = new_server;
272
*current_server = new_server;
274
/* Place the new server last in the list */
275
new_server->next = *current_server;
276
new_server->prev = (*current_server)->prev;
277
new_server->prev->next = new_server;
278
(*current_server)->prev = new_server;
283
/* Set effective uid to 0, return errno */
284
__attribute__((warn_unused_result))
285
int raise_privileges(void){
286
int old_errno = errno;
288
if(seteuid(0) == -1){
295
/* Set effective and real user ID to 0. Return errno. */
296
__attribute__((warn_unused_result))
297
int raise_privileges_permanently(void){
298
int old_errno = errno;
299
int ret = raise_privileges();
311
/* Set effective user ID to unprivileged saved user ID */
312
__attribute__((warn_unused_result))
313
int lower_privileges(void){
314
int old_errno = errno;
316
if(seteuid(uid) == -1){
323
/* Lower privileges permanently */
324
__attribute__((warn_unused_result))
325
int lower_privileges_permanently(void){
326
int old_errno = errno;
328
if(setuid(uid) == -1){
338
__attribute__((nonnull, warn_unused_result))
339
static bool init_gpgme(const char * const seckey,
340
const char * const pubkey,
341
const char * const tempdir,
93
ssize_t new_packet_capacity = 0;
94
ssize_t new_packet_length = 0;
344
95
gpgme_engine_info_t engine_info;
347
* Helper function to insert pub and seckey to the engine keyring.
349
bool import_key(const char * const filename){
352
gpgme_data_t pgp_data;
354
fd = (int)TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
360
/* Workaround for systems without a real-time clock; see also
361
Debian bug #894495: <https://bugs.debian.org/894495> */
364
time_t currtime = time(NULL);
365
if(currtime != (time_t)-1){
367
if(gmtime_r(&currtime, &tm) == NULL) {
368
perror_plus("gmtime_r");
371
if(tm.tm_year != 70 or tm.tm_mon != 0){
375
fprintf_plus(stderr, "System clock is January 1970");
379
fprintf_plus(stderr, "System clock is invalid");
384
ret = fstat(fd, &keystat);
386
perror_plus("fstat");
389
ret = raise_privileges();
392
perror_plus("Failed to raise privileges");
397
"Setting system clock to key file mtime");
399
if(clock_settime(CLOCK_REALTIME, &keystat.st_mtim) != 0){
400
perror_plus("clock_settime");
402
ret = lower_privileges();
405
perror_plus("Failed to lower privileges");
409
rc = gpgme_data_new_from_fd(&pgp_data, fd);
410
if(rc != GPG_ERR_NO_ERROR){
411
fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
412
gpgme_strsource(rc), gpgme_strerror(rc));
416
rc = gpgme_op_import(mc->ctx, pgp_data);
417
if(rc != GPG_ERR_NO_ERROR){
418
fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
419
gpgme_strsource(rc), gpgme_strerror(rc));
423
gpgme_import_result_t import_result
424
= gpgme_op_import_result(mc->ctx);
425
if((import_result->imported < 1
426
or import_result->not_imported > 0)
427
and import_result->unchanged == 0){
428
fprintf_plus(stderr, "bad gpgme_op_import_results:\n");
430
"The total number of considered keys: %d\n",
431
import_result->considered);
433
"The number of keys without user ID: %d\n",
434
import_result->no_user_id);
436
"The total number of imported keys: %d\n",
437
import_result->imported);
438
fprintf_plus(stderr, "The number of imported RSA keys: %d\n",
439
import_result->imported_rsa);
440
fprintf_plus(stderr, "The number of unchanged keys: %d\n",
441
import_result->unchanged);
442
fprintf_plus(stderr, "The number of new user IDs: %d\n",
443
import_result->new_user_ids);
444
fprintf_plus(stderr, "The number of new sub keys: %d\n",
445
import_result->new_sub_keys);
446
fprintf_plus(stderr, "The number of new signatures: %d\n",
447
import_result->new_signatures);
448
fprintf_plus(stderr, "The number of new revocations: %d\n",
449
import_result->new_revocations);
451
"The total number of secret keys read: %d\n",
452
import_result->secret_read);
454
"The number of imported secret keys: %d\n",
455
import_result->secret_imported);
457
"The number of unchanged secret keys: %d\n",
458
import_result->secret_unchanged);
459
fprintf_plus(stderr, "The number of keys not imported: %d\n",
460
import_result->not_imported);
461
for(gpgme_import_status_t import_status
462
= import_result->imports;
463
import_status != NULL;
464
import_status = import_status->next){
465
fprintf_plus(stderr, "Import status for key: %s\n",
467
if(import_status->result != GPG_ERR_NO_ERROR){
468
fprintf_plus(stderr, "Import result: %s: %s\n",
469
gpgme_strsource(import_status->result),
470
gpgme_strerror(import_status->result));
472
fprintf_plus(stderr, "Key status:\n");
474
import_status->status & GPGME_IMPORT_NEW
475
? "The key was new.\n"
476
: "The key was not new.\n");
478
import_status->status & GPGME_IMPORT_UID
479
? "The key contained new user IDs.\n"
480
: "The key did not contain new user IDs.\n");
482
import_status->status & GPGME_IMPORT_SIG
483
? "The key contained new signatures.\n"
484
: "The key did not contain new signatures.\n");
486
import_status->status & GPGME_IMPORT_SUBKEY
487
? "The key contained new sub keys.\n"
488
: "The key did not contain new sub keys.\n");
490
import_status->status & GPGME_IMPORT_SECRET
491
? "The key contained a secret key.\n"
492
: "The key did not contain a secret key.\n");
500
perror_plus("close");
502
gpgme_data_release(pgp_data);
507
fprintf_plus(stderr, "Initializing GPGME\n");
98
fprintf(stderr, "Trying to decrypt OpenPGP packet\n");
511
102
gpgme_check_version(NULL);
512
103
rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
513
if(rc != GPG_ERR_NO_ERROR){
514
fprintf_plus(stderr, "bad gpgme_engine_check_version: %s: %s\n",
515
gpgme_strsource(rc), gpgme_strerror(rc));
104
if (rc != GPG_ERR_NO_ERROR){
105
fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
106
gpgme_strsource(rc), gpgme_strerror(rc));
519
/* Set GPGME home directory for the OpenPGP engine only */
520
rc = gpgme_get_engine_info(&engine_info);
521
if(rc != GPG_ERR_NO_ERROR){
522
fprintf_plus(stderr, "bad gpgme_get_engine_info: %s: %s\n",
523
gpgme_strsource(rc), gpgme_strerror(rc));
110
/* Set GPGME home directory */
111
rc = gpgme_get_engine_info (&engine_info);
112
if (rc != GPG_ERR_NO_ERROR){
113
fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
114
gpgme_strsource(rc), gpgme_strerror(rc));
526
117
while(engine_info != NULL){
527
118
if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){
528
119
gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,
529
engine_info->file_name, tempdir);
120
engine_info->file_name, homedir);
532
123
engine_info = engine_info->next;
534
125
if(engine_info == NULL){
535
fprintf_plus(stderr, "Could not set GPGME home dir to %s\n",
540
/* Create new GPGME "context" */
541
rc = gpgme_new(&(mc->ctx));
542
if(rc != GPG_ERR_NO_ERROR){
543
fprintf_plus(stderr, "bad gpgme_new: %s: %s\n",
544
gpgme_strsource(rc), gpgme_strerror(rc));
548
if(not import_key(pubkey) or not import_key(seckey)){
556
* Decrypt OpenPGP data.
557
* Returns -1 on error
559
__attribute__((nonnull, warn_unused_result))
560
static ssize_t pgp_packet_decrypt(const char *cryptotext,
564
gpgme_data_t dh_crypto, dh_plain;
567
size_t plaintext_capacity = 0;
568
ssize_t plaintext_length = 0;
571
fprintf_plus(stderr, "Trying to decrypt OpenPGP data\n");
574
/* Create new GPGME data buffer from memory cryptotext */
575
rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
577
if(rc != GPG_ERR_NO_ERROR){
578
fprintf_plus(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
579
gpgme_strsource(rc), gpgme_strerror(rc));
126
fprintf(stderr, "Could not set home dir to %s\n", homedir);
130
/* Create new GPGME data buffer from packet buffer */
131
rc = gpgme_data_new_from_mem(&dh_crypto, packet, packet_size, 0);
132
if (rc != GPG_ERR_NO_ERROR){
133
fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
134
gpgme_strsource(rc), gpgme_strerror(rc));
583
138
/* Create new empty GPGME data buffer for the plaintext */
584
139
rc = gpgme_data_new(&dh_plain);
585
if(rc != GPG_ERR_NO_ERROR){
586
fprintf_plus(stderr, "bad gpgme_data_new: %s: %s\n",
587
gpgme_strsource(rc), gpgme_strerror(rc));
588
gpgme_data_release(dh_crypto);
592
/* Decrypt data from the cryptotext data buffer to the plaintext
594
rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
595
if(rc != GPG_ERR_NO_ERROR){
596
fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
597
gpgme_strsource(rc), gpgme_strerror(rc));
598
plaintext_length = -1;
600
gpgme_decrypt_result_t result;
601
result = gpgme_op_decrypt_result(mc->ctx);
603
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
605
if(result->unsupported_algorithm != NULL) {
606
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
607
result->unsupported_algorithm);
609
fprintf_plus(stderr, "Wrong key usage: %s\n",
610
result->wrong_key_usage ? "Yes" : "No");
611
if(result->file_name != NULL){
612
fprintf_plus(stderr, "File name: %s\n", result->file_name);
615
for(gpgme_recipient_t r = result->recipients; r != NULL;
617
fprintf_plus(stderr, "Public key algorithm: %s\n",
618
gpgme_pubkey_algo_name(r->pubkey_algo));
619
fprintf_plus(stderr, "Key ID: %s\n", r->keyid);
620
fprintf_plus(stderr, "Secret key available: %s\n",
621
r->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
140
if (rc != GPG_ERR_NO_ERROR){
141
fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
142
gpgme_strsource(rc), gpgme_strerror(rc));
146
/* Create new GPGME "context" */
147
rc = gpgme_new(&ctx);
148
if (rc != GPG_ERR_NO_ERROR){
149
fprintf(stderr, "bad gpgme_new: %s: %s\n",
150
gpgme_strsource(rc), gpgme_strerror(rc));
154
/* Decrypt data from the FILE pointer to the plaintext data
156
rc = gpgme_op_decrypt(ctx, dh_crypto, dh_plain);
157
if (rc != GPG_ERR_NO_ERROR){
158
fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
159
gpgme_strsource(rc), gpgme_strerror(rc));
164
fprintf(stderr, "Decryption of OpenPGP packet succeeded\n");
168
gpgme_decrypt_result_t result;
169
result = gpgme_op_decrypt_result(ctx);
171
fprintf(stderr, "gpgme_op_decrypt_result failed\n");
173
fprintf(stderr, "Unsupported algorithm: %s\n",
174
result->unsupported_algorithm);
175
fprintf(stderr, "Wrong key usage: %d\n",
176
result->wrong_key_usage);
177
if(result->file_name != NULL){
178
fprintf(stderr, "File name: %s\n", result->file_name);
180
gpgme_recipient_t recipient;
181
recipient = result->recipients;
183
while(recipient != NULL){
184
fprintf(stderr, "Public key algorithm: %s\n",
185
gpgme_pubkey_algo_name(recipient->pubkey_algo));
186
fprintf(stderr, "Key ID: %s\n", recipient->keyid);
187
fprintf(stderr, "Secret key available: %s\n",
188
recipient->status == GPG_ERR_NO_SECKEY
190
recipient = recipient->next;
629
fprintf_plus(stderr, "Decryption of OpenPGP data succeeded\n");
196
/* Delete the GPGME FILE pointer cryptotext data buffer */
197
gpgme_data_release(dh_crypto);
632
199
/* Seek back to the beginning of the GPGME plaintext data buffer */
633
if(gpgme_data_seek(dh_plain, (off_t)0, SEEK_SET) == -1){
634
perror_plus("gpgme_data_seek");
635
plaintext_length = -1;
200
gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET);
641
plaintext_capacity = incbuffer(plaintext,
642
(size_t)plaintext_length,
644
if(plaintext_capacity == 0){
645
perror_plus("incbuffer");
646
plaintext_length = -1;
204
if (new_packet_length + BUFFER_SIZE > new_packet_capacity){
205
*new_packet = realloc(*new_packet,
206
(unsigned int)new_packet_capacity
208
if (*new_packet == NULL){
212
new_packet_capacity += BUFFER_SIZE;
650
ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
215
ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length,
652
217
/* Print the data, if any */
658
perror_plus("gpgme_data_read");
659
plaintext_length = -1;
662
plaintext_length += ret;
666
fprintf_plus(stderr, "Decrypted password is: ");
667
for(ssize_t i = 0; i < plaintext_length; i++){
668
fprintf(stderr, "%02hhX ", (*plaintext)[i]);
670
fprintf(stderr, "\n");
675
/* Delete the GPGME cryptotext data buffer */
676
gpgme_data_release(dh_crypto);
222
perror("gpgme_data_read");
225
new_packet_length += ret;
228
/* FIXME: check characters before printing to screen so to not print
229
terminal control characters */
231
/* fprintf(stderr, "decrypted password is: "); */
232
/* fwrite(*new_packet, 1, new_packet_length, stderr); */
233
/* fprintf(stderr, "\n"); */
678
236
/* Delete the GPGME plaintext data buffer */
679
237
gpgme_data_release(dh_plain);
680
return plaintext_length;
683
__attribute__((warn_unused_result, const))
684
static const char *safe_string(const char *str){
690
__attribute__((warn_unused_result))
691
static const char *safer_gnutls_strerror(int value){
692
const char *ret = gnutls_strerror(value);
693
return safe_string(ret);
696
/* GnuTLS log function callback */
697
__attribute__((nonnull))
698
static void debuggnutls(__attribute__((unused)) int level,
700
fprintf_plus(stderr, "GnuTLS: %s", string);
703
__attribute__((nonnull(1, 2, 4), warn_unused_result))
704
static int init_gnutls_global(const char *pubkeyfilename,
705
const char *seckeyfilename,
706
const char *dhparamsfilename,
238
return new_packet_length;
241
static const char * safer_gnutls_strerror (int value) {
242
const char *ret = gnutls_strerror (value);
248
void debuggnutls(__attribute__((unused)) int level,
250
fprintf(stderr, "%s", string);
253
int initgnutls(encrypted_session *es){
711
fprintf_plus(stderr, "Initializing GnuTLS\n");
715
/* "Use a log level over 10 to enable all debugging options."
258
fprintf(stderr, "Initializing GnuTLS\n");
261
if ((ret = gnutls_global_init ())
262
!= GNUTLS_E_SUCCESS) {
263
fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
718
268
gnutls_global_set_log_level(11);
719
269
gnutls_global_set_log_function(debuggnutls);
722
/* OpenPGP credentials */
723
ret = gnutls_certificate_allocate_credentials(&mc->cred);
724
if(ret != GNUTLS_E_SUCCESS){
725
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
726
safer_gnutls_strerror(ret));
272
/* openpgp credentials */
273
if ((ret = gnutls_certificate_allocate_credentials (&es->cred))
274
!= GNUTLS_E_SUCCESS) {
275
fprintf (stderr, "memory error: %s\n",
276
safer_gnutls_strerror(ret));
731
fprintf_plus(stderr, "Attempting to use public key %s and"
732
" private key %s as GnuTLS credentials\n",
281
fprintf(stderr, "Attempting to use OpenPGP certificate %s"
282
" and keyfile %s as GnuTLS credentials\n", certfile,
737
#if GNUTLS_VERSION_NUMBER >= 0x030606
738
ret = gnutls_certificate_set_rawpk_key_file
739
(mc->cred, pubkeyfilename, seckeyfilename,
740
GNUTLS_X509_FMT_PEM, /* format */
743
GNUTLS_KEY_DIGITAL_SIGNATURE | GNUTLS_KEY_KEY_ENCIPHERMENT,
745
0, /* names_length */
747
GNUTLS_PKCS_PLAIN | GNUTLS_PKCS_NULL_PASSWORD,
748
0); /* pkcs11_flags */
749
#elif GNUTLS_VERSION_NUMBER < 0x030600
750
286
ret = gnutls_certificate_set_openpgp_key_file
751
(mc->cred, pubkeyfilename, seckeyfilename,
752
GNUTLS_OPENPGP_FMT_BASE64);
754
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
756
if(ret != GNUTLS_E_SUCCESS){
758
"Error[%d] while reading the key pair ('%s',"
759
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
760
fprintf_plus(stderr, "The GnuTLS error is: %s\n",
761
safer_gnutls_strerror(ret));
765
/* GnuTLS server initialization */
766
ret = gnutls_dh_params_init(&mc->dh_params);
767
if(ret != GNUTLS_E_SUCCESS){
768
fprintf_plus(stderr, "Error in GnuTLS DH parameter"
769
" initialization: %s\n",
770
safer_gnutls_strerror(ret));
773
/* If a Diffie-Hellman parameters file was given, try to use it */
774
if(dhparamsfilename != NULL){
775
gnutls_datum_t params = { .data = NULL, .size = 0 };
777
int dhpfile = open(dhparamsfilename, O_RDONLY);
780
dhparamsfilename = NULL;
783
size_t params_capacity = 0;
785
params_capacity = incbuffer((char **)¶ms.data,
787
(size_t)params_capacity);
788
if(params_capacity == 0){
789
perror_plus("incbuffer");
792
dhparamsfilename = NULL;
795
ssize_t bytes_read = read(dhpfile,
796
params.data + params.size,
802
/* check bytes_read for failure */
807
dhparamsfilename = NULL;
810
params.size += (unsigned int)bytes_read;
812
ret = close(dhpfile);
814
perror_plus("close");
816
if(params.data == NULL){
817
dhparamsfilename = NULL;
819
if(dhparamsfilename == NULL){
822
ret = gnutls_dh_params_import_pkcs3(mc->dh_params, ¶ms,
823
GNUTLS_X509_FMT_PEM);
824
if(ret != GNUTLS_E_SUCCESS){
825
fprintf_plus(stderr, "Failed to parse DH parameters in file"
826
" \"%s\": %s\n", dhparamsfilename,
827
safer_gnutls_strerror(ret));
828
dhparamsfilename = NULL;
833
if(dhparamsfilename == NULL){
834
if(mc->dh_bits == 0){
835
#if GNUTLS_VERSION_NUMBER < 0x030600
836
/* Find out the optimal number of DH bits */
837
/* Try to read the private key file */
838
gnutls_datum_t buffer = { .data = NULL, .size = 0 };
840
int secfile = open(seckeyfilename, O_RDONLY);
845
size_t buffer_capacity = 0;
847
buffer_capacity = incbuffer((char **)&buffer.data,
849
(size_t)buffer_capacity);
850
if(buffer_capacity == 0){
851
perror_plus("incbuffer");
856
ssize_t bytes_read = read(secfile,
857
buffer.data + buffer.size,
863
/* check bytes_read for failure */
870
buffer.size += (unsigned int)bytes_read;
874
/* If successful, use buffer to parse private key */
875
gnutls_sec_param_t sec_param = GNUTLS_SEC_PARAM_ULTRA;
876
if(buffer.data != NULL){
878
gnutls_openpgp_privkey_t privkey = NULL;
879
ret = gnutls_openpgp_privkey_init(&privkey);
880
if(ret != GNUTLS_E_SUCCESS){
881
fprintf_plus(stderr, "Error initializing OpenPGP key"
883
safer_gnutls_strerror(ret));
887
ret = gnutls_openpgp_privkey_import
888
(privkey, &buffer, GNUTLS_OPENPGP_FMT_BASE64, "", 0);
889
if(ret != GNUTLS_E_SUCCESS){
890
fprintf_plus(stderr, "Error importing OpenPGP key : %s",
891
safer_gnutls_strerror(ret));
897
/* Use private key to suggest an appropriate
899
sec_param = gnutls_openpgp_privkey_sec_param(privkey);
900
gnutls_openpgp_privkey_deinit(privkey);
902
fprintf_plus(stderr, "This OpenPGP key implies using"
903
" a GnuTLS security parameter \"%s\".\n",
904
safe_string(gnutls_sec_param_get_name
910
if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
911
/* Err on the side of caution */
912
sec_param = GNUTLS_SEC_PARAM_ULTRA;
914
fprintf_plus(stderr, "Falling back to security parameter"
916
safe_string(gnutls_sec_param_get_name
921
unsigned int uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
925
fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
926
" implies %u DH bits; using that.\n",
927
safe_string(gnutls_sec_param_get_name
932
fprintf_plus(stderr, "Failed to get implied number of DH"
933
" bits for security parameter \"%s\"): %s\n",
934
safe_string(gnutls_sec_param_get_name
936
safer_gnutls_strerror(ret));
940
} else { /* dh_bits != 0 */
942
fprintf_plus(stderr, "DH bits explicitly set to %u\n",
945
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
946
if(ret != GNUTLS_E_SUCCESS){
947
fprintf_plus(stderr, "Error in GnuTLS prime generation (%u"
948
" bits): %s\n", mc->dh_bits,
949
safer_gnutls_strerror(ret));
952
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
960
gnutls_certificate_free_credentials(mc->cred);
961
gnutls_dh_params_deinit(mc->dh_params);
965
__attribute__((nonnull, warn_unused_result))
966
static int init_gnutls_session(gnutls_session_t *session,
969
/* GnuTLS session creation */
971
ret = gnutls_init(session, (GNUTLS_SERVER
972
#if GNUTLS_VERSION_NUMBER >= 0x030506
975
#if GNUTLS_VERSION_NUMBER >= 0x030606
976
| GNUTLS_ENABLE_RAWPK
982
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
983
if(ret != GNUTLS_E_SUCCESS){
985
"Error in GnuTLS session initialization: %s\n",
986
safer_gnutls_strerror(ret));
992
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
994
gnutls_deinit(*session);
997
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
998
if(ret != GNUTLS_E_SUCCESS){
999
fprintf_plus(stderr, "Syntax error at: %s\n", err);
1000
fprintf_plus(stderr, "GnuTLS error: %s\n",
1001
safer_gnutls_strerror(ret));
1002
gnutls_deinit(*session);
1008
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
1011
gnutls_deinit(*session);
1014
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
1015
if(ret != GNUTLS_E_SUCCESS){
1016
fprintf_plus(stderr, "Error setting GnuTLS credentials: %s\n",
1017
safer_gnutls_strerror(ret));
1018
gnutls_deinit(*session);
287
(es->cred, certfile, certkey, GNUTLS_OPENPGP_FMT_BASE64);
288
if (ret != GNUTLS_E_SUCCESS) {
290
(stderr, "Error[%d] while reading the OpenPGP key pair ('%s',"
292
ret, certfile, certkey);
293
fprintf(stdout, "The Error is: %s\n",
294
safer_gnutls_strerror(ret));
298
//GnuTLS server initialization
299
if ((ret = gnutls_dh_params_init (&es->dh_params))
300
!= GNUTLS_E_SUCCESS) {
301
fprintf (stderr, "Error in dh parameter initialization: %s\n",
302
safer_gnutls_strerror(ret));
306
if ((ret = gnutls_dh_params_generate2 (es->dh_params, DH_BITS))
307
!= GNUTLS_E_SUCCESS) {
308
fprintf (stderr, "Error in prime generation: %s\n",
309
safer_gnutls_strerror(ret));
313
gnutls_certificate_set_dh_params (es->cred, es->dh_params);
315
// GnuTLS session creation
316
if ((ret = gnutls_init (&es->session, GNUTLS_SERVER))
317
!= GNUTLS_E_SUCCESS){
318
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
319
safer_gnutls_strerror(ret));
322
if ((ret = gnutls_priority_set_direct (es->session, "NORMAL", &err))
323
!= GNUTLS_E_SUCCESS) {
324
fprintf(stderr, "Syntax error at: %s\n", err);
325
fprintf(stderr, "GnuTLS error: %s\n",
326
safer_gnutls_strerror(ret));
330
if ((ret = gnutls_credentials_set
331
(es->session, GNUTLS_CRD_CERTIFICATE, es->cred))
332
!= GNUTLS_E_SUCCESS) {
333
fprintf(stderr, "Error setting a credentials set: %s\n",
334
safer_gnutls_strerror(ret));
1022
338
/* ignore client certificate if any. */
1023
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
339
gnutls_certificate_server_set_request (es->session,
342
gnutls_dh_set_prime_bits (es->session, DH_BITS);
1028
/* Avahi log function callback */
1029
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
1030
__attribute__((unused)) const char *txt){}
1032
/* Helper function to add_local_route() and delete_local_route() */
1033
__attribute__((nonnull, warn_unused_result))
1034
static bool add_delete_local_route(const bool add,
1035
const char *address,
1036
AvahiIfIndex if_index){
1038
char helper[] = "mandos-client-iprouteadddel";
1039
char add_arg[] = "add";
1040
char delete_arg[] = "delete";
1041
char debug_flag[] = "--debug";
1042
char *pluginhelperdir = getenv("MANDOSPLUGINHELPERDIR");
1043
if(pluginhelperdir == NULL){
1045
fprintf_plus(stderr, "MANDOSPLUGINHELPERDIR environment"
1046
" variable not set; cannot run helper\n");
1051
char interface[IF_NAMESIZE];
1052
if(if_indextoname((unsigned int)if_index, interface) == NULL){
1053
perror_plus("if_indextoname");
1057
int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
1059
perror_plus("open(\"/dev/null\", O_RDONLY)");
1065
/* Raise privileges */
1066
errno = raise_privileges_permanently();
1068
perror_plus("Failed to raise privileges");
1069
/* _exit(EX_NOPERM); */
1075
perror_plus("setgid");
1079
/* Reset supplementary groups */
1081
ret = setgroups(0, NULL);
1083
perror_plus("setgroups");
1088
ret = dup2(devnull, STDIN_FILENO);
1090
perror_plus("dup2(devnull, STDIN_FILENO)");
1094
ret = close(devnull);
1096
perror_plus("close");
1098
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
1100
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
1103
int helperdir_fd = (int)TEMP_FAILURE_RETRY(open(pluginhelperdir,
1108
if(helperdir_fd == -1){
1109
perror_plus("open");
1110
_exit(EX_UNAVAILABLE);
1112
int helper_fd = (int)TEMP_FAILURE_RETRY(openat(helperdir_fd,
1114
if(helper_fd == -1){
1115
perror_plus("openat");
1116
close(helperdir_fd);
1117
_exit(EX_UNAVAILABLE);
1119
close(helperdir_fd);
1121
#pragma GCC diagnostic push
1122
#pragma GCC diagnostic ignored "-Wcast-qual"
1124
if(fexecve(helper_fd, (char *const [])
1125
{ helper, add ? add_arg : delete_arg, (char *)address,
1126
interface, debug ? debug_flag : NULL, NULL },
1129
#pragma GCC diagnostic pop
1131
perror_plus("fexecve");
1132
_exit(EXIT_FAILURE);
1136
perror_plus("fork");
1140
ret = close(devnull);
1142
perror_plus("close");
1148
pret = waitpid(pid, &status, 0);
1149
if(pret == -1 and errno == EINTR and quit_now){
1150
int errno_raising = 0;
1151
if((errno = raise_privileges()) != 0){
1152
errno_raising = errno;
1153
perror_plus("Failed to raise privileges in order to"
1154
" kill helper program");
1156
if(kill(pid, SIGTERM) == -1){
1157
perror_plus("kill");
1159
if((errno_raising == 0) and (errno = lower_privileges()) != 0){
1160
perror_plus("Failed to lower privileges after killing"
1165
} while(pret == -1 and errno == EINTR);
1167
perror_plus("waitpid");
1170
if(WIFEXITED(status)){
1171
if(WEXITSTATUS(status) != 0){
1172
fprintf_plus(stderr, "Error: iprouteadddel exited"
1173
" with status %d\n", WEXITSTATUS(status));
1178
if(WIFSIGNALED(status)){
1179
fprintf_plus(stderr, "Error: iprouteadddel died by"
1180
" signal %d\n", WTERMSIG(status));
1183
fprintf_plus(stderr, "Error: iprouteadddel crashed\n");
1187
__attribute__((nonnull, warn_unused_result))
1188
static bool add_local_route(const char *address,
1189
AvahiIfIndex if_index){
1191
fprintf_plus(stderr, "Adding route to %s\n", address);
1193
return add_delete_local_route(true, address, if_index);
1196
__attribute__((nonnull, warn_unused_result))
1197
static bool delete_local_route(const char *address,
1198
AvahiIfIndex if_index){
1200
fprintf_plus(stderr, "Removing route to %s\n", address);
1202
return add_delete_local_route(false, address, if_index);
1205
/* Called when a Mandos server is found */
1206
__attribute__((nonnull, warn_unused_result))
1207
static int start_mandos_communication(const char *ip, in_port_t port,
1208
AvahiIfIndex if_index,
1209
int af, mandos_context *mc){
1210
int ret, tcp_sd = -1;
1212
struct sockaddr_storage to;
347
void empty_log(__attribute__((unused)) AvahiLogLevel level,
348
__attribute__((unused)) const char *txt){}
350
int start_mandos_communication(const char *ip, uint16_t port,
351
unsigned int if_index){
353
struct sockaddr_in6 to;
354
encrypted_session es;
1213
355
char *buffer = NULL;
1214
char *decrypted_buffer = NULL;
356
char *decrypted_buffer;
1215
357
size_t buffer_length = 0;
1216
358
size_t buffer_capacity = 0;
1219
gnutls_session_t session;
1220
int pf; /* Protocol family */
1221
bool route_added = false;
1238
fprintf_plus(stderr, "Bad address family: %d\n", af);
1243
/* If the interface is specified and we have a list of interfaces */
1244
if(if_index != AVAHI_IF_UNSPEC and mc->interfaces != NULL){
1245
/* Check if the interface is one of the interfaces we are using */
1248
char *interface = NULL;
1249
while((interface = argz_next(mc->interfaces,
1250
mc->interfaces_size,
1252
if(if_nametoindex(interface) == (unsigned int)if_index){
1259
/* This interface does not match any in the list, so we don't
1260
connect to the server */
1262
char interface[IF_NAMESIZE];
1263
if(if_indextoname((unsigned int)if_index, interface) == NULL){
1264
perror_plus("if_indextoname");
1266
fprintf_plus(stderr, "Skipping server on non-used interface"
1268
if_indextoname((unsigned int)if_index,
1276
ret = init_gnutls_session(&session, mc);
1282
fprintf_plus(stderr, "Setting up a TCP connection to %s, port %"
1283
PRIuMAX "\n", ip, (uintmax_t)port);
1286
tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
1289
perror_plus("socket");
1300
struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)&to;
1301
*to6 = (struct sockaddr_in6){ .sin6_family = (sa_family_t)af };
1302
ret = inet_pton(af, ip, &to6->sin6_addr);
1304
struct sockaddr_in *to4 = (struct sockaddr_in *)&to;
1305
*to4 = (struct sockaddr_in){ .sin_family = (sa_family_t)af };
1306
ret = inet_pton(af, ip, &to4->sin_addr);
1310
perror_plus("inet_pton");
359
ssize_t decrypted_buffer_size;
362
char interface[IF_NAMESIZE];
365
fprintf(stderr, "Setting up a tcp connection to %s\n", ip);
368
tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
374
if(if_indextoname(if_index, interface) == NULL){
376
perror("if_indextoname");
382
fprintf(stderr, "Binding to interface %s\n", interface);
385
memset(&to,0,sizeof(to)); /* Spurious warning */
386
to.sin6_family = AF_INET6;
387
ret = inet_pton(AF_INET6, ip, &to.sin6_addr);
1316
fprintf_plus(stderr, "Bad address: %s\n", ip);
1321
((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
1322
if(IN6_IS_ADDR_LINKLOCAL
1323
(&((struct sockaddr_in6 *)&to)->sin6_addr)){
1324
if(if_index == AVAHI_IF_UNSPEC){
1325
fprintf_plus(stderr, "An IPv6 link-local address is"
1326
" incomplete without a network interface\n");
1330
/* Set the network interface number as scope */
1331
((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
1334
((struct sockaddr_in *)&to)->sin_port = htons(port);
1343
if(af == AF_INET6 and if_index != AVAHI_IF_UNSPEC){
1344
char interface[IF_NAMESIZE];
1345
if(if_indextoname((unsigned int)if_index, interface) == NULL){
1346
perror_plus("if_indextoname");
1348
fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIuMAX
1349
"\n", ip, interface, (uintmax_t)port);
1352
fprintf_plus(stderr, "Connection to: %s, port %" PRIuMAX "\n",
1353
ip, (uintmax_t)port);
1355
char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
1356
INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
1358
ret = getnameinfo((struct sockaddr *)&to,
1359
sizeof(struct sockaddr_in6),
1360
addrstr, sizeof(addrstr), NULL, 0,
1363
ret = getnameinfo((struct sockaddr *)&to,
1364
sizeof(struct sockaddr_in),
1365
addrstr, sizeof(addrstr), NULL, 0,
1368
if(ret == EAI_SYSTEM){
1369
perror_plus("getnameinfo");
1370
} else if(ret != 0) {
1371
fprintf_plus(stderr, "getnameinfo: %s", gai_strerror(ret));
1372
} else if(strcmp(addrstr, ip) != 0){
1373
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
1384
ret = connect(tcp_sd, (struct sockaddr *)&to,
1385
sizeof(struct sockaddr_in6));
1387
ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
1388
sizeof(struct sockaddr_in));
1391
if(((errno == ENETUNREACH) or (errno == EHOSTUNREACH))
1392
and if_index != AVAHI_IF_UNSPEC
1393
and connect_to == NULL
1394
and not route_added and
1395
((af == AF_INET6 and not
1396
IN6_IS_ADDR_LINKLOCAL(&(((struct sockaddr_in6 *)
1398
or (af == AF_INET and
1399
/* Not a a IPv4LL address */
1400
(ntohl(((struct sockaddr_in *)&to)->sin_addr.s_addr)
1401
& 0xFFFF0000L) != 0xA9FE0000L))){
1402
/* Work around Avahi bug - Avahi does not announce link-local
1403
addresses if it has a global address, so local hosts with
1404
*only* a link-local address (e.g. Mandos clients) cannot
1405
connect to a Mandos server announced by Avahi on a server
1406
host with a global address. Work around this by retrying
1407
with an explicit route added with the server's address.
1409
Avahi bug reference:
1410
https://lists.freedesktop.org/archives/avahi/2010-February/001833.html
1411
https://bugs.debian.org/587961
1414
fprintf_plus(stderr, "Mandos server unreachable, trying"
1418
route_added = add_local_route(ip, if_index);
1424
if(errno != ECONNREFUSED or debug){
1426
perror_plus("connect");
1439
const char *out = mandos_protocol_version;
1442
size_t out_size = strlen(out);
1443
ret = (int)TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
1444
out_size - written));
1447
perror_plus("write");
1451
written += (size_t)ret;
1452
if(written < out_size){
1455
if(out == mandos_protocol_version){
1470
fprintf_plus(stderr, "Establishing TLS session with %s\n", ip);
1478
/* This casting via intptr_t is to eliminate warning about casting
1479
an int to a pointer type. This is exactly how the GnuTLS Guile
1480
function "set-session-transport-fd!" does it. */
1481
gnutls_transport_set_ptr(session,
1482
(gnutls_transport_ptr_t)(intptr_t)tcp_sd);
1490
ret = gnutls_handshake(session);
1495
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
1497
if(ret != GNUTLS_E_SUCCESS){
393
fprintf(stderr, "Bad address: %s\n", ip);
396
to.sin6_port = htons(port); /* Spurious warning */
398
to.sin6_scope_id = (uint32_t)if_index;
401
fprintf(stderr, "Connection to: %s\n", ip);
404
ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
410
ret = initgnutls (&es);
416
gnutls_transport_set_ptr (es.session,
417
(gnutls_transport_ptr_t) tcp_sd);
420
fprintf(stderr, "Establishing TLS session with %s\n", ip);
423
ret = gnutls_handshake (es.session);
425
if (ret != GNUTLS_E_SUCCESS){
1499
fprintf_plus(stderr, "*** GnuTLS Handshake failed ***\n");
427
fprintf(stderr, "\n*** Handshake failed ***\n");
1506
/* Read OpenPGP packet that contains the wanted password */
434
//Retrieve OpenPGP packet that contains the wanted password
1509
fprintf_plus(stderr, "Retrieving OpenPGP encrypted password from"
437
fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
1520
buffer_capacity = incbuffer(&buffer, buffer_length,
1522
if(buffer_capacity == 0){
1524
perror_plus("incbuffer");
1534
sret = gnutls_record_recv(session, buffer+buffer_length,
442
if (buffer_length + BUFFER_SIZE > buffer_capacity){
443
buffer = realloc(buffer, buffer_capacity + BUFFER_SIZE);
448
buffer_capacity += BUFFER_SIZE;
451
ret = gnutls_record_recv
452
(es.session, buffer+buffer_length, BUFFER_SIZE);
1541
458
case GNUTLS_E_INTERRUPTED:
1542
459
case GNUTLS_E_AGAIN:
1544
461
case GNUTLS_E_REHANDSHAKE:
1546
ret = gnutls_handshake(session);
1552
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
1554
fprintf_plus(stderr, "*** GnuTLS Re-handshake failed "
462
ret = gnutls_handshake (es.session);
464
fprintf(stderr, "\n*** Handshake failed ***\n");
1562
fprintf_plus(stderr, "Unknown error while reading data from"
1563
" encrypted session with Mandos server\n");
1564
gnutls_bye(session, GNUTLS_SHUT_RDWR);
471
fprintf(stderr, "Unknown error while reading data from"
472
" encrypted session with mandos server\n");
474
gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
1569
buffer_length += (size_t) sret;
1574
fprintf_plus(stderr, "Closing TLS session\n");
1583
ret = gnutls_bye(session, GNUTLS_SHUT_RDWR);
1588
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
1590
if(buffer_length > 0){
1591
ssize_t decrypted_buffer_size;
1592
decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
1593
&decrypted_buffer, mc);
1594
if(decrypted_buffer_size >= 0){
1598
while(written < (size_t) decrypted_buffer_size){
1604
ret = (int)fwrite(decrypted_buffer + written, 1,
1605
(size_t)decrypted_buffer_size - written,
478
buffer_length += (size_t) ret;
482
if (buffer_length > 0){
483
decrypted_buffer_size = pgp_packet_decrypt(buffer,
487
if (decrypted_buffer_size >= 0){
488
while(written < decrypted_buffer_size){
489
ret = (int)fwrite (decrypted_buffer + written, 1,
490
(size_t)decrypted_buffer_size - written,
1607
492
if(ret == 0 and ferror(stdout)){
1610
fprintf_plus(stderr, "Error writing encrypted data: %s\n",
494
fprintf(stderr, "Error writing encrypted data: %s\n",
1616
500
written += (size_t)ret;
1618
ret = fflush(stdout);
1622
fprintf_plus(stderr, "Error writing encrypted data: %s\n",
1632
/* Shutdown procedure */
1637
if(not delete_local_route(ip, if_index)){
1638
fprintf_plus(stderr, "Failed to delete local route to %s on"
1639
" interface %d", ip, if_index);
1643
free(decrypted_buffer);
1646
ret = close(tcp_sd);
1652
perror_plus("close");
1654
gnutls_deinit(session);
502
free(decrypted_buffer);
511
fprintf(stderr, "Closing TLS session\n");
515
gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
518
gnutls_deinit (es.session);
519
gnutls_certificate_free_credentials (es.cred);
520
gnutls_global_deinit ();
1664
static void resolve_callback(AvahiSServiceResolver *r,
1665
AvahiIfIndex interface,
1666
AvahiProtocol proto,
1667
AvahiResolverEvent event,
1671
const char *host_name,
1672
const AvahiAddress *address,
1674
AVAHI_GCC_UNUSED AvahiStringList *txt,
1675
AVAHI_GCC_UNUSED AvahiLookupResultFlags
524
static AvahiSimplePoll *simple_poll = NULL;
525
static AvahiServer *server = NULL;
527
static void resolve_callback(
528
AvahiSServiceResolver *r,
529
AvahiIfIndex interface,
530
AVAHI_GCC_UNUSED AvahiProtocol protocol,
531
AvahiResolverEvent event,
535
const char *host_name,
536
const AvahiAddress *address,
538
AVAHI_GCC_UNUSED AvahiStringList *txt,
539
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
540
AVAHI_GCC_UNUSED void* userdata) {
542
assert(r); /* Spurious warning */
1682
544
/* Called whenever a service has been resolved successfully or
1686
avahi_s_service_resolver_free(r);
1692
549
case AVAHI_RESOLVER_FAILURE:
1693
fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
1694
"'%s' of type '%s' in domain '%s': %s\n", name, type,
1696
avahi_strerror(avahi_server_errno
1697
(((mandos_context*)mc)->server)));
550
fprintf(stderr, "(Resolver) Failed to resolve service '%s' of"
551
" type '%s' in domain '%s': %s\n", name, type, domain,
552
avahi_strerror(avahi_server_errno(server)));
1700
555
case AVAHI_RESOLVER_FOUND:
1702
557
char ip[AVAHI_ADDRESS_STR_MAX];
1703
558
avahi_address_snprint(ip, sizeof(ip), address);
1705
fprintf_plus(stderr, "Mandos server \"%s\" found on %s (%s, %"
1706
PRIdMAX ") on port %" PRIu16 "\n", name,
1707
host_name, ip, (intmax_t)interface, port);
560
fprintf(stderr, "Mandos server \"%s\" found on %s (%s) on"
561
" port %d\n", name, host_name, ip, port);
1709
int ret = start_mandos_communication(ip, (in_port_t)port,
1711
avahi_proto_to_af(proto),
1714
avahi_simple_poll_quit(simple_poll);
1716
if(not add_server(ip, (in_port_t)port, interface,
1717
avahi_proto_to_af(proto),
1718
&((mandos_context*)mc)->current_server)){
1719
fprintf_plus(stderr, "Failed to add server \"%s\" to server"
563
int ret = start_mandos_communication(ip, port,
564
(unsigned int) interface);
1725
570
avahi_s_service_resolver_free(r);
1728
static void browse_callback(AvahiSServiceBrowser *b,
1729
AvahiIfIndex interface,
1730
AvahiProtocol protocol,
1731
AvahiBrowserEvent event,
1735
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1742
/* Called whenever a new services becomes available on the LAN or
1743
is removed from the LAN */
1751
case AVAHI_BROWSER_FAILURE:
1753
fprintf_plus(stderr, "(Avahi browser) %s\n",
1754
avahi_strerror(avahi_server_errno
1755
(((mandos_context*)mc)->server)));
1756
avahi_simple_poll_quit(simple_poll);
1759
case AVAHI_BROWSER_NEW:
1760
/* We ignore the returned Avahi resolver object. In the callback
1761
function we free it. If the Avahi server is terminated before
1762
the callback function is called the Avahi server will free the
1765
if(avahi_s_service_resolver_new(((mandos_context*)mc)->server,
1766
interface, protocol, name, type,
1767
domain, protocol, 0,
1768
resolve_callback, mc) == NULL)
1769
fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
1771
avahi_strerror(avahi_server_errno
1772
(((mandos_context*)mc)->server)));
1775
case AVAHI_BROWSER_REMOVE:
1778
case AVAHI_BROWSER_ALL_FOR_NOW:
1779
case AVAHI_BROWSER_CACHE_EXHAUSTED:
1781
fprintf_plus(stderr, "No Mandos server found, still"
1788
/* Signal handler that stops main loop after SIGTERM */
1789
static void handle_sigterm(int sig){
1794
signal_received = sig;
1795
int old_errno = errno;
1796
/* set main loop to exit */
1797
if(simple_poll != NULL){
1798
avahi_simple_poll_quit(simple_poll);
1803
__attribute__((nonnull, warn_unused_result))
1804
bool get_flags(const char *ifname, struct ifreq *ifr){
1808
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1811
perror_plus("socket");
1815
strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
1816
ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
1817
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1821
perror_plus("ioctl SIOCGIFFLAGS");
1824
if((close(s) == -1) and debug){
1826
perror_plus("close");
1831
if((close(s) == -1) and debug){
1833
perror_plus("close");
1839
__attribute__((nonnull, warn_unused_result))
1840
bool good_flags(const char *ifname, const struct ifreq *ifr){
1842
/* Reject the loopback device */
1843
if(ifr->ifr_flags & IFF_LOOPBACK){
1845
fprintf_plus(stderr, "Rejecting loopback interface \"%s\"\n",
1850
/* Accept point-to-point devices only if connect_to is specified */
1851
if(connect_to != NULL and (ifr->ifr_flags & IFF_POINTOPOINT)){
1853
fprintf_plus(stderr, "Accepting point-to-point interface"
1854
" \"%s\"\n", ifname);
1858
/* Otherwise, reject non-broadcast-capable devices */
1859
if(not (ifr->ifr_flags & IFF_BROADCAST)){
1861
fprintf_plus(stderr, "Rejecting non-broadcast interface"
1862
" \"%s\"\n", ifname);
1866
/* Reject non-ARP interfaces (including dummy interfaces) */
1867
if(ifr->ifr_flags & IFF_NOARP){
1869
fprintf_plus(stderr, "Rejecting non-ARP interface \"%s\"\n",
1875
/* Accept this device */
1877
fprintf_plus(stderr, "Interface \"%s\" is good\n", ifname);
1883
* This function determines if a directory entry in /sys/class/net
1884
* corresponds to an acceptable network device.
1885
* (This function is passed to scandir(3) as a filter function.)
1887
__attribute__((nonnull, warn_unused_result))
1888
int good_interface(const struct dirent *if_entry){
1889
if(if_entry->d_name[0] == '.'){
1894
if(not get_flags(if_entry->d_name, &ifr)){
1896
fprintf_plus(stderr, "Failed to get flags for interface "
1897
"\"%s\"\n", if_entry->d_name);
1902
if(not good_flags(if_entry->d_name, &ifr)){
1909
* This function determines if a network interface is up.
1911
__attribute__((nonnull, warn_unused_result))
1912
bool interface_is_up(const char *interface){
1914
if(not get_flags(interface, &ifr)){
1916
fprintf_plus(stderr, "Failed to get flags for interface "
1917
"\"%s\"\n", interface);
1922
return (bool)(ifr.ifr_flags & IFF_UP);
1926
* This function determines if a network interface is running
1928
__attribute__((nonnull, warn_unused_result))
1929
bool interface_is_running(const char *interface){
1931
if(not get_flags(interface, &ifr)){
1933
fprintf_plus(stderr, "Failed to get flags for interface "
1934
"\"%s\"\n", interface);
1939
return (bool)(ifr.ifr_flags & IFF_RUNNING);
1942
__attribute__((nonnull, pure, warn_unused_result))
1943
int notdotentries(const struct dirent *direntry){
1944
/* Skip "." and ".." */
1945
if(direntry->d_name[0] == '.'
1946
and (direntry->d_name[1] == '\0'
1947
or (direntry->d_name[1] == '.'
1948
and direntry->d_name[2] == '\0'))){
1954
/* Is this directory entry a runnable program? */
1955
__attribute__((nonnull, warn_unused_result))
1956
int runnable_hook(const struct dirent *direntry){
1961
if((direntry->d_name)[0] == '\0'){
1966
sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1967
"abcdefghijklmnopqrstuvwxyz"
1970
if((direntry->d_name)[sret] != '\0'){
1971
/* Contains non-allowed characters */
1973
fprintf_plus(stderr, "Ignoring hook \"%s\" with bad name\n",
1979
ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1982
perror_plus("Could not stat hook");
1986
if(not (S_ISREG(st.st_mode))){
1987
/* Not a regular file */
1989
fprintf_plus(stderr, "Ignoring hook \"%s\" - not a file\n",
1994
if(not (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))){
1995
/* Not executable */
1997
fprintf_plus(stderr, "Ignoring hook \"%s\" - not executable\n",
2003
fprintf_plus(stderr, "Hook \"%s\" is acceptable\n",
2009
__attribute__((nonnull, warn_unused_result))
2010
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
2011
mandos_context *mc){
2013
struct timespec now;
2014
struct timespec waited_time;
2015
intmax_t block_time;
2018
if(mc->current_server == NULL){
2020
fprintf_plus(stderr, "Wait until first server is found."
2023
ret = avahi_simple_poll_iterate(s, -1);
2026
fprintf_plus(stderr, "Check current_server if we should run"
2029
/* the current time */
2030
ret = clock_gettime(CLOCK_MONOTONIC, &now);
2032
perror_plus("clock_gettime");
2035
/* Calculating in ms how long time between now and server
2036
who we visted longest time ago. Now - last seen. */
2037
waited_time.tv_sec = (now.tv_sec
2038
- mc->current_server->last_seen.tv_sec);
2039
waited_time.tv_nsec = (now.tv_nsec
2040
- mc->current_server->last_seen.tv_nsec);
2041
/* total time is 10s/10,000ms.
2042
Converting to s from ms by dividing by 1,000,
2043
and ns to ms by dividing by 1,000,000. */
2044
block_time = ((retry_interval
2045
- ((intmax_t)waited_time.tv_sec * 1000))
2046
- ((intmax_t)waited_time.tv_nsec / 1000000));
2049
fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
2053
if(block_time <= 0){
2054
ret = start_mandos_communication(mc->current_server->ip,
2055
mc->current_server->port,
2056
mc->current_server->if_index,
2057
mc->current_server->af, mc);
2059
avahi_simple_poll_quit(s);
2062
ret = clock_gettime(CLOCK_MONOTONIC,
2063
&mc->current_server->last_seen);
2065
perror_plus("clock_gettime");
2068
mc->current_server = mc->current_server->next;
2069
block_time = 0; /* Call avahi to find new Mandos
2070
servers, but don't block */
2073
ret = avahi_simple_poll_iterate(s, (int)block_time);
2076
if(ret > 0 or errno != EINTR){
2077
return (ret != 1) ? ret : 0;
2083
__attribute__((nonnull))
2084
void run_network_hooks(const char *mode, const char *interface,
2086
struct dirent **direntries = NULL;
2087
if(hookdir_fd == -1){
2088
hookdir_fd = open(hookdir, O_RDONLY | O_DIRECTORY | O_PATH
2090
if(hookdir_fd == -1){
2091
if(errno == ENOENT){
2093
fprintf_plus(stderr, "Network hook directory \"%s\" not"
2094
" found\n", hookdir);
2097
perror_plus("open");
573
static void browse_callback(
574
AvahiSServiceBrowser *b,
575
AvahiIfIndex interface,
576
AvahiProtocol protocol,
577
AvahiBrowserEvent event,
581
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
584
AvahiServer *s = userdata;
585
assert(b); /* Spurious warning */
587
/* Called whenever a new services becomes available on the LAN or
588
is removed from the LAN */
592
case AVAHI_BROWSER_FAILURE:
594
fprintf(stderr, "(Browser) %s\n",
595
avahi_strerror(avahi_server_errno(server)));
596
avahi_simple_poll_quit(simple_poll);
2102
int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
2104
perror_plus("open(\"/dev/null\", O_RDONLY)");
2107
int numhooks = scandirat(hookdir_fd, ".", &direntries,
2108
runnable_hook, alphasort);
2110
perror_plus("scandir");
2114
struct dirent *direntry;
2116
for(int i = 0; i < numhooks; i++){
2117
direntry = direntries[i];
2119
fprintf_plus(stderr, "Running network hook \"%s\"\n",
2122
pid_t hook_pid = fork();
2125
/* Raise privileges */
2126
errno = raise_privileges_permanently();
2128
perror_plus("Failed to raise privileges");
2135
perror_plus("setgid");
2138
/* Reset supplementary groups */
2140
ret = setgroups(0, NULL);
2142
perror_plus("setgroups");
2145
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
2147
perror_plus("setenv");
2150
ret = setenv("DEVICE", interface, 1);
2152
perror_plus("setenv");
2155
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
2157
perror_plus("setenv");
2160
ret = setenv("MODE", mode, 1);
2162
perror_plus("setenv");
2166
ret = asprintf(&delaystring, "%f", (double)delay);
2168
perror_plus("asprintf");
2171
ret = setenv("DELAY", delaystring, 1);
2174
perror_plus("setenv");
2178
if(connect_to != NULL){
2179
ret = setenv("CONNECT", connect_to, 1);
2181
perror_plus("setenv");
2185
int hook_fd = (int)TEMP_FAILURE_RETRY(openat(hookdir_fd,
2189
perror_plus("openat");
2190
_exit(EXIT_FAILURE);
2192
if(close(hookdir_fd) == -1){
2193
perror_plus("close");
2194
_exit(EXIT_FAILURE);
2196
ret = dup2(devnull, STDIN_FILENO);
2198
perror_plus("dup2(devnull, STDIN_FILENO)");
2201
ret = close(devnull);
2203
perror_plus("close");
2206
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
2208
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
2211
if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
2213
perror_plus("fexecve");
2214
_exit(EXIT_FAILURE);
2218
perror_plus("fork");
2223
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
2224
perror_plus("waitpid");
2228
if(WIFEXITED(status)){
2229
if(WEXITSTATUS(status) != 0){
2230
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
2231
" with status %d\n", direntry->d_name,
2232
WEXITSTATUS(status));
2236
} else if(WIFSIGNALED(status)){
2237
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
2238
" signal %d\n", direntry->d_name,
2243
fprintf_plus(stderr, "Warning: network hook \"%s\""
2244
" crashed\n", direntry->d_name);
2250
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
2256
if(close(hookdir_fd) == -1){
2257
perror_plus("close");
2264
__attribute__((nonnull, warn_unused_result))
2265
int bring_up_interface(const char *const interface,
2267
int old_errno = errno;
2269
struct ifreq network;
2270
unsigned int if_index = if_nametoindex(interface);
2272
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
2282
if(not interface_is_up(interface)){
2284
int ioctl_errno = 0;
2285
if(not get_flags(interface, &network)){
2287
fprintf_plus(stderr, "Failed to get flags for interface "
2288
"\"%s\"\n", interface);
2292
network.ifr_flags |= IFF_UP; /* set flag */
2294
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
2297
perror_plus("socket");
2305
perror_plus("close");
2312
fprintf_plus(stderr, "Bringing up interface \"%s\"\n",
2316
/* Raise privileges */
2317
ret_errno = raise_privileges();
2320
perror_plus("Failed to raise privileges");
2325
bool restore_loglevel = false;
2327
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
2328
messages about the network interface to mess up the prompt */
2329
ret_linux = klogctl(8, NULL, 5);
2330
if(ret_linux == -1){
2331
perror_plus("klogctl");
2333
restore_loglevel = true;
2336
#endif /* __linux__ */
2337
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
2338
ioctl_errno = errno;
2340
if(restore_loglevel){
2341
ret_linux = klogctl(7, NULL, 0);
2342
if(ret_linux == -1){
2343
perror_plus("klogctl");
2346
#endif /* __linux__ */
2348
/* If raise_privileges() succeeded above */
2350
/* Lower privileges */
2351
ret_errno = lower_privileges();
2354
perror_plus("Failed to lower privileges");
2358
/* Close the socket */
2361
perror_plus("close");
2364
if(ret_setflags == -1){
2365
errno = ioctl_errno;
2366
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
2371
fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
2375
/* Sleep checking until interface is running.
2376
Check every 0.25s, up to total time of delay */
2377
for(int i = 0; i < delay * 4; i++){
2378
if(interface_is_running(interface)){
2381
struct timespec sleeptime = { .tv_nsec = 250000000 };
2382
ret = nanosleep(&sleeptime, NULL);
2383
if(ret == -1 and errno != EINTR){
2384
perror_plus("nanosleep");
2392
__attribute__((nonnull, warn_unused_result))
2393
int take_down_interface(const char *const interface){
2394
int old_errno = errno;
2395
struct ifreq network;
2396
unsigned int if_index = if_nametoindex(interface);
2398
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
2402
if(interface_is_up(interface)){
2404
int ioctl_errno = 0;
2405
if(not get_flags(interface, &network) and debug){
2407
fprintf_plus(stderr, "Failed to get flags for interface "
2408
"\"%s\"\n", interface);
2412
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
2414
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
2417
perror_plus("socket");
2423
fprintf_plus(stderr, "Taking down interface \"%s\"\n",
2427
/* Raise privileges */
2428
ret_errno = raise_privileges();
2431
perror_plus("Failed to raise privileges");
2434
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
2435
ioctl_errno = errno;
2437
/* If raise_privileges() succeeded above */
2439
/* Lower privileges */
2440
ret_errno = lower_privileges();
2443
perror_plus("Failed to lower privileges");
2447
/* Close the socket */
2448
int ret = close(sd);
2450
perror_plus("close");
2453
if(ret_setflags == -1){
2454
errno = ioctl_errno;
2455
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
2460
fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
2468
int main(int argc, char *argv[]){
2469
mandos_context mc = { .server = NULL, .dh_bits = 0,
2470
#if GNUTLS_VERSION_NUMBER >= 0x030606
2471
.priority = "SECURE128:!CTYPE-X.509"
2472
":+CTYPE-RAWPK:!RSA:!VERS-ALL:+VERS-TLS1.3"
2474
#elif GNUTLS_VERSION_NUMBER < 0x030600
2475
.priority = "SECURE256:!CTYPE-X.509"
2476
":+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256",
2478
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
2480
.current_server = NULL, .interfaces = NULL,
2481
.interfaces_size = 0 };
2482
AvahiSServiceBrowser *sb = NULL;
599
case AVAHI_BROWSER_NEW:
600
/* We ignore the returned resolver object. In the callback
601
function we free it. If the server is terminated before
602
the callback function is called the server will free
603
the resolver for us. */
605
if (!(avahi_s_service_resolver_new(s, interface, protocol, name,
607
AVAHI_PROTO_INET6, 0,
608
resolve_callback, s)))
609
fprintf(stderr, "Failed to resolve service '%s': %s\n", name,
610
avahi_strerror(avahi_server_errno(s)));
613
case AVAHI_BROWSER_REMOVE:
616
case AVAHI_BROWSER_ALL_FOR_NOW:
617
case AVAHI_BROWSER_CACHE_EXHAUSTED:
622
/* combinds two strings and returns the malloced new string. som sane checks could/should be added */
623
const char *combinestrings(const char *first, const char *second){
2487
int exitcode = EXIT_SUCCESS;
2488
char *interfaces_to_take_down = NULL;
2489
size_t interfaces_to_take_down_size = 0;
2490
char run_tempdir[] = "/run/tmp/mandosXXXXXX";
2491
char old_tempdir[] = "/tmp/mandosXXXXXX";
2492
char *tempdir = NULL;
2493
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
2494
const char *seckey = PATHDIR "/" SECKEY;
2495
const char *pubkey = PATHDIR "/" PUBKEY;
2496
#if GNUTLS_VERSION_NUMBER >= 0x030606
2497
const char *tls_privkey = PATHDIR "/" TLS_PRIVKEY;
2498
const char *tls_pubkey = PATHDIR "/" TLS_PUBKEY;
2500
const char *dh_params_file = NULL;
2501
char *interfaces_hooks = NULL;
2503
bool gnutls_initialized = false;
2504
bool gpgme_initialized = false;
2506
double retry_interval = 10; /* 10s between trying a server and
2507
retrying the same server again */
2509
struct sigaction old_sigterm_action = { .sa_handler = SIG_DFL };
2510
struct sigaction sigterm_action = { .sa_handler = handle_sigterm };
2515
/* Lower any group privileges we might have, just to be safe */
2519
perror_plus("setgid");
2522
/* Lower user privileges (temporarily) */
2526
perror_plus("seteuid");
2534
struct argp_option options[] = {
2535
{ .name = "debug", .key = 128,
2536
.doc = "Debug mode", .group = 3 },
2537
{ .name = "connect", .key = 'c',
2538
.arg = "ADDRESS:PORT",
2539
.doc = "Connect directly to a specific Mandos server",
2541
{ .name = "interface", .key = 'i',
2543
.doc = "Network interface that will be used to search for"
2546
{ .name = "seckey", .key = 's',
2548
.doc = "OpenPGP secret key file base name",
2550
{ .name = "pubkey", .key = 'p',
2552
.doc = "OpenPGP public key file base name",
2554
{ .name = "tls-privkey", .key = 't',
2556
#if GNUTLS_VERSION_NUMBER >= 0x030606
2557
.doc = "TLS private key file base name",
2559
.doc = "Dummy; ignored (requires GnuTLS 3.6.6)",
2562
{ .name = "tls-pubkey", .key = 'T',
2564
#if GNUTLS_VERSION_NUMBER >= 0x030606
2565
.doc = "TLS public key file base name",
2567
.doc = "Dummy; ignored (requires GnuTLS 3.6.6)",
2570
{ .name = "dh-bits", .key = 129,
2572
.doc = "Bit length of the prime number used in the"
2573
" Diffie-Hellman key exchange",
2575
{ .name = "dh-params", .key = 134,
2577
.doc = "PEM-encoded PKCS#3 file with pre-generated parameters"
2578
" for the Diffie-Hellman key exchange",
2580
{ .name = "priority", .key = 130,
2582
.doc = "GnuTLS priority string for the TLS handshake",
2584
{ .name = "delay", .key = 131,
2586
.doc = "Maximum delay to wait for interface startup",
2588
{ .name = "retry", .key = 132,
2590
.doc = "Retry interval used when denied by the Mandos server",
2592
{ .name = "network-hook-dir", .key = 133,
2594
.doc = "Directory where network hooks are located",
2597
* These reproduce what we would get without ARGP_NO_HELP
2599
{ .name = "help", .key = '?',
2600
.doc = "Give this help list", .group = -1 },
2601
{ .name = "usage", .key = -3,
2602
.doc = "Give a short usage message", .group = -1 },
2603
{ .name = "version", .key = 'V',
2604
.doc = "Print program version", .group = -1 },
2608
error_t parse_opt(int key, char *arg,
2609
struct argp_state *state){
2612
case 128: /* --debug */
2615
case 'c': /* --connect */
2618
case 'i': /* --interface */
2619
ret_errno = argz_add_sep(&mc.interfaces, &mc.interfaces_size,
2622
argp_error(state, "%s", strerror(ret_errno));
2625
case 's': /* --seckey */
2628
case 'p': /* --pubkey */
2631
case 't': /* --tls-privkey */
2632
#if GNUTLS_VERSION_NUMBER >= 0x030606
2636
case 'T': /* --tls-pubkey */
2637
#if GNUTLS_VERSION_NUMBER >= 0x030606
2641
case 129: /* --dh-bits */
2643
tmpmax = strtoimax(arg, &tmp, 10);
2644
if(errno != 0 or tmp == arg or *tmp != '\0'
2645
or tmpmax != (typeof(mc.dh_bits))tmpmax){
2646
argp_error(state, "Bad number of DH bits");
2648
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
2650
case 134: /* --dh-params */
2651
dh_params_file = arg;
2653
case 130: /* --priority */
2656
case 131: /* --delay */
2658
delay = strtof(arg, &tmp);
2659
if(errno != 0 or tmp == arg or *tmp != '\0'){
2660
argp_error(state, "Bad delay");
2662
case 132: /* --retry */
2664
retry_interval = strtod(arg, &tmp);
2665
if(errno != 0 or tmp == arg or *tmp != '\0'
2666
or (retry_interval * 1000) > INT_MAX
2667
or retry_interval < 0){
2668
argp_error(state, "Bad retry interval");
2671
case 133: /* --network-hook-dir */
2675
* These reproduce what we would get without ARGP_NO_HELP
2677
case '?': /* --help */
2678
argp_state_help(state, state->out_stream,
2679
(ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
2680
& ~(unsigned int)ARGP_HELP_EXIT_OK);
2681
__builtin_unreachable();
2682
case -3: /* --usage */
2683
argp_state_help(state, state->out_stream,
2684
ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
2685
__builtin_unreachable();
2686
case 'V': /* --version */
2687
fprintf_plus(state->out_stream, "%s\n", argp_program_version);
2688
exit(argp_err_exit_status);
2691
return ARGP_ERR_UNKNOWN;
2696
struct argp argp = { .options = options, .parser = parse_opt,
2698
.doc = "Mandos client -- Get and decrypt"
2699
" passwords from a Mandos server" };
2700
ret_errno = argp_parse(&argp, argc, argv,
2701
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2708
perror_plus("argp_parse");
2709
exitcode = EX_OSERR;
2712
exitcode = EX_USAGE;
2718
/* Work around Debian bug #633582:
2719
<https://bugs.debian.org/633582> */
2721
/* Re-raise privileges */
2722
ret = raise_privileges();
2725
perror_plus("Failed to raise privileges");
2729
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
2730
int seckey_fd = open(seckey, O_RDONLY);
2731
if(seckey_fd == -1){
2732
perror_plus("open");
2734
ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
2736
perror_plus("fstat");
2738
if(S_ISREG(st.st_mode)
2739
and st.st_uid == 0 and st.st_gid == 0){
2740
ret = fchown(seckey_fd, uid, gid);
2742
perror_plus("fchown");
2750
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2751
int pubkey_fd = open(pubkey, O_RDONLY);
2752
if(pubkey_fd == -1){
2753
perror_plus("open");
2755
ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
2757
perror_plus("fstat");
2759
if(S_ISREG(st.st_mode)
2760
and st.st_uid == 0 and st.st_gid == 0){
2761
ret = fchown(pubkey_fd, uid, gid);
2763
perror_plus("fchown");
2771
if(dh_params_file != NULL
2772
and strcmp(dh_params_file, PATHDIR "/dhparams.pem" ) == 0){
2773
int dhparams_fd = open(dh_params_file, O_RDONLY);
2774
if(dhparams_fd == -1){
2775
perror_plus("open");
2777
ret = (int)TEMP_FAILURE_RETRY(fstat(dhparams_fd, &st));
2779
perror_plus("fstat");
2781
if(S_ISREG(st.st_mode)
2782
and st.st_uid == 0 and st.st_gid == 0){
2783
ret = fchown(dhparams_fd, uid, gid);
2785
perror_plus("fchown");
2793
/* Lower privileges */
2794
ret = lower_privileges();
2797
perror_plus("Failed to lower privileges");
2802
/* Remove invalid interface names (except "none") */
2804
char *interface = NULL;
2805
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2807
if(strcmp(interface, "none") != 0
2808
and if_nametoindex(interface) == 0){
2809
if(interface[0] != '\0'){
2810
fprintf_plus(stderr, "Not using nonexisting interface"
2811
" \"%s\"\n", interface);
2813
argz_delete(&mc.interfaces, &mc.interfaces_size, interface);
2819
/* Run network hooks */
2821
if(mc.interfaces != NULL){
2822
interfaces_hooks = malloc(mc.interfaces_size);
2823
if(interfaces_hooks == NULL){
2824
perror_plus("malloc");
2827
memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
2828
argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
2830
run_network_hooks("start", interfaces_hooks != NULL ?
2831
interfaces_hooks : "", delay);
2835
avahi_set_log_function(empty_log);
2838
/* Initialize Avahi early so avahi_simple_poll_quit() can be called
2839
from the signal handler */
2840
/* Initialize the pseudo-RNG for Avahi */
2841
srand((unsigned int) time(NULL));
2842
simple_poll = avahi_simple_poll_new();
2843
if(simple_poll == NULL){
2844
fprintf_plus(stderr,
2845
"Avahi: Failed to create simple poll object.\n");
2846
exitcode = EX_UNAVAILABLE;
2850
sigemptyset(&sigterm_action.sa_mask);
2851
ret = sigaddset(&sigterm_action.sa_mask, SIGINT);
2853
perror_plus("sigaddset");
2854
exitcode = EX_OSERR;
2857
ret = sigaddset(&sigterm_action.sa_mask, SIGHUP);
2859
perror_plus("sigaddset");
2860
exitcode = EX_OSERR;
2863
ret = sigaddset(&sigterm_action.sa_mask, SIGTERM);
2865
perror_plus("sigaddset");
2866
exitcode = EX_OSERR;
2869
/* Need to check if the handler is SIG_IGN before handling:
2870
| [[info:libc:Initial Signal Actions]] |
2871
| [[info:libc:Basic Signal Handling]] |
2873
ret = sigaction(SIGINT, NULL, &old_sigterm_action);
2875
perror_plus("sigaction");
2878
if(old_sigterm_action.sa_handler != SIG_IGN){
2879
ret = sigaction(SIGINT, &sigterm_action, NULL);
2881
perror_plus("sigaction");
2882
exitcode = EX_OSERR;
2886
ret = sigaction(SIGHUP, NULL, &old_sigterm_action);
2888
perror_plus("sigaction");
2891
if(old_sigterm_action.sa_handler != SIG_IGN){
2892
ret = sigaction(SIGHUP, &sigterm_action, NULL);
2894
perror_plus("sigaction");
2895
exitcode = EX_OSERR;
2899
ret = sigaction(SIGTERM, NULL, &old_sigterm_action);
2901
perror_plus("sigaction");
2904
if(old_sigterm_action.sa_handler != SIG_IGN){
2905
ret = sigaction(SIGTERM, &sigterm_action, NULL);
2907
perror_plus("sigaction");
2908
exitcode = EX_OSERR;
2913
/* If no interfaces were specified, make a list */
2914
if(mc.interfaces == NULL){
2915
struct dirent **direntries = NULL;
2916
/* Look for any good interfaces */
2917
ret = scandir(sys_class_net, &direntries, good_interface,
2920
/* Add all found interfaces to interfaces list */
2921
for(int i = 0; i < ret; ++i){
2922
ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
2923
direntries[i]->d_name);
2926
perror_plus("argz_add");
2927
free(direntries[i]);
2931
fprintf_plus(stderr, "Will use interface \"%s\"\n",
2932
direntries[i]->d_name);
2934
free(direntries[i]);
2941
fprintf_plus(stderr, "Could not find a network interface\n");
2942
exitcode = EXIT_FAILURE;
2947
/* Bring up interfaces which are down, and remove any "none"s */
2949
char *interface = NULL;
2950
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2952
/* If interface name is "none", stop bringing up interfaces.
2953
Also remove all instances of "none" from the list */
2954
if(strcmp(interface, "none") == 0){
2955
argz_delete(&mc.interfaces, &mc.interfaces_size,
2958
while((interface = argz_next(mc.interfaces,
2959
mc.interfaces_size, interface))){
2960
if(strcmp(interface, "none") == 0){
2961
argz_delete(&mc.interfaces, &mc.interfaces_size,
2968
bool interface_was_up = interface_is_up(interface);
2969
errno = bring_up_interface(interface, delay);
2970
if(not interface_was_up){
2972
fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
2973
" %s\n", interface, strerror(errno));
2975
errno = argz_add(&interfaces_to_take_down,
2976
&interfaces_to_take_down_size,
2979
perror_plus("argz_add");
2984
if(debug and (interfaces_to_take_down == NULL)){
2985
fprintf_plus(stderr, "No interfaces were brought up\n");
2989
/* If we only got one interface, explicitly use only that one */
2990
if(argz_count(mc.interfaces, mc.interfaces_size) == 1){
2992
fprintf_plus(stderr, "Using only interface \"%s\"\n",
2995
if_index = (AvahiIfIndex)if_nametoindex(mc.interfaces);
3002
#if GNUTLS_VERSION_NUMBER >= 0x030606
3003
ret = init_gnutls_global(tls_pubkey, tls_privkey, dh_params_file, &mc);
3004
#elif GNUTLS_VERSION_NUMBER < 0x030600
3005
ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
3007
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
3010
fprintf_plus(stderr, "init_gnutls_global failed\n");
3011
exitcode = EX_UNAVAILABLE;
3014
gnutls_initialized = true;
3021
/* Try /run/tmp before /tmp */
3022
tempdir = mkdtemp(run_tempdir);
3023
if(tempdir == NULL and errno == ENOENT){
3025
fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
3026
run_tempdir, old_tempdir);
3028
tempdir = mkdtemp(old_tempdir);
3030
if(tempdir == NULL){
3031
perror_plus("mkdtemp");
3039
if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
3040
fprintf_plus(stderr, "init_gpgme failed\n");
3041
exitcode = EX_UNAVAILABLE;
3044
gpgme_initialized = true;
3051
if(connect_to != NULL){
3052
/* Connect directly, do not use Zeroconf */
3053
/* (Mainly meant for debugging) */
3054
char *address = strrchr(connect_to, ':');
3056
if(address == NULL){
3057
fprintf_plus(stderr, "No colon in address\n");
3058
exitcode = EX_USAGE;
3068
tmpmax = strtoimax(address+1, &tmp, 10);
3069
if(errno != 0 or tmp == address+1 or *tmp != '\0'
3070
or tmpmax != (in_port_t)tmpmax){
3071
fprintf_plus(stderr, "Bad port number\n");
3072
exitcode = EX_USAGE;
3080
port = (in_port_t)tmpmax;
3082
/* Colon in address indicates IPv6 */
3084
if(strchr(connect_to, ':') != NULL){
3086
/* Accept [] around IPv6 address - see RFC 5952 */
3087
if(connect_to[0] == '[' and address[-1] == ']')
3095
address = connect_to;
3101
while(not quit_now){
3102
ret = start_mandos_communication(address, port, if_index, af,
3104
if(quit_now or ret == 0){
3108
fprintf_plus(stderr, "Retrying in %d seconds\n",
3109
(int)retry_interval);
3111
sleep((unsigned int)retry_interval);
3115
exitcode = EXIT_SUCCESS;
625
tmp = malloc(strlen(first) + strlen(second));
636
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
3126
637
AvahiServerConfig config;
3127
/* Do not publish any local Zeroconf records */
638
AvahiSServiceBrowser *sb = NULL;
641
int returncode = EXIT_SUCCESS;
642
const char *interface = "eth0";
645
static struct option long_options[] = {
646
{"debug", no_argument, (int *)&debug, 1},
647
{"interface", required_argument, 0, 'i'},
648
{"certdir", required_argument, 0, 'd'},
649
{"certkey", required_argument, 0, 'c'},
650
{"certfile", required_argument, 0, 'k'},
653
int option_index = 0;
654
ret = getopt_long (argc, argv, "i:", long_options,
681
certfile = combinestrings(certdir, certfile);
682
if (certfile == NULL){
686
certkey = combinestrings(certdir, certkey);
687
if (certkey == NULL){
692
avahi_set_log_function(empty_log);
695
/* Initialize the psuedo-RNG */
696
srand((unsigned int) time(NULL));
698
/* Allocate main loop object */
699
if (!(simple_poll = avahi_simple_poll_new())) {
700
fprintf(stderr, "Failed to create simple poll object.\n");
705
/* Do not publish any local records */
3128
706
avahi_server_config_init(&config);
3129
707
config.publish_hinfo = 0;
3130
708
config.publish_addresses = 0;
3131
709
config.publish_workstation = 0;
3132
710
config.publish_domain = 0;
3134
712
/* Allocate a new server */
3135
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
3136
&config, NULL, NULL, &ret);
3138
/* Free the Avahi configuration data */
713
server = avahi_server_new(avahi_simple_poll_get(simple_poll),
714
&config, NULL, NULL, &error);
716
/* Free the configuration data */
3139
717
avahi_server_config_free(&config);
3142
/* Check if creating the Avahi server object succeeded */
3143
if(mc.server == NULL){
3144
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
3145
avahi_strerror(ret));
3146
exitcode = EX_UNAVAILABLE;
3154
/* Create the Avahi service browser */
3155
sb = avahi_s_service_browser_new(mc.server, if_index,
3156
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
3157
NULL, 0, browse_callback,
3160
fprintf_plus(stderr, "Failed to create service browser: %s\n",
3161
avahi_strerror(avahi_server_errno(mc.server)));
3162
exitcode = EX_UNAVAILABLE;
3170
/* Run the main loop */
3173
fprintf_plus(stderr, "Starting Avahi loop search\n");
3176
ret = avahi_loop_with_timeout(simple_poll,
3177
(int)(retry_interval * 1000), &mc);
3179
fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
3180
(ret == 0) ? "successfully" : "with error");
3186
if(signal_received){
3187
fprintf_plus(stderr, "%s exiting due to signal %d: %s\n",
3188
argv[0], signal_received,
3189
strsignal(signal_received));
3191
fprintf_plus(stderr, "%s exiting\n", argv[0]);
3195
/* Cleanup things */
3196
free(mc.interfaces);
3199
avahi_s_service_browser_free(sb);
3201
if(mc.server != NULL)
3202
avahi_server_free(mc.server);
3204
if(simple_poll != NULL)
3205
avahi_simple_poll_free(simple_poll);
3207
if(gnutls_initialized){
3208
gnutls_certificate_free_credentials(mc.cred);
3209
gnutls_dh_params_deinit(mc.dh_params);
3212
if(gpgme_initialized){
3213
gpgme_release(mc.ctx);
3216
/* Cleans up the circular linked list of Mandos servers the client
3218
if(mc.current_server != NULL){
3219
mc.current_server->prev->next = NULL;
3220
while(mc.current_server != NULL){
3221
server *next = mc.current_server->next;
3223
#pragma GCC diagnostic push
3224
#pragma GCC diagnostic ignored "-Wcast-qual"
3226
free((char *)(mc.current_server->ip));
3228
#pragma GCC diagnostic pop
3230
free(mc.current_server);
3231
mc.current_server = next;
3235
/* Re-raise privileges */
3237
ret = raise_privileges();
3240
perror_plus("Failed to raise privileges");
3243
/* Run network hooks */
3244
run_network_hooks("stop", interfaces_hooks != NULL ?
3245
interfaces_hooks : "", delay);
3247
/* Take down the network interfaces which were brought up */
3249
char *interface = NULL;
3250
while((interface = argz_next(interfaces_to_take_down,
3251
interfaces_to_take_down_size,
3253
ret = take_down_interface(interface);
3256
perror_plus("Failed to take down interface");
3259
if(debug and (interfaces_to_take_down == NULL)){
3260
fprintf_plus(stderr, "No interfaces needed to be taken"
3266
ret = lower_privileges_permanently();
3269
perror_plus("Failed to lower privileges permanently");
3273
free(interfaces_to_take_down);
3274
free(interfaces_hooks);
3276
void clean_dir_at(int base, const char * const dirname,
3278
struct dirent **direntries = NULL;
3280
int dir_fd = (int)TEMP_FAILURE_RETRY(openat(base, dirname,
3286
perror_plus("open");
3289
int numentries = scandirat(dir_fd, ".", &direntries,
3290
notdotentries, alphasort);
3291
if(numentries >= 0){
3292
for(int i = 0; i < numentries; i++){
3294
fprintf_plus(stderr, "Unlinking \"%s/%s\"\n",
3295
dirname, direntries[i]->d_name);
3297
dret = unlinkat(dir_fd, direntries[i]->d_name, 0);
3299
if(errno == EISDIR){
3300
dret = unlinkat(dir_fd, direntries[i]->d_name,
3303
if((dret == -1) and (errno == ENOTEMPTY)
3304
and (strcmp(direntries[i]->d_name, "private-keys-v1.d")
3305
== 0) and (level == 0)){
3306
/* Recurse only in this special case */
3307
clean_dir_at(dir_fd, direntries[i]->d_name, level+1);
3310
if((dret == -1) and (errno != ENOENT)){
3311
fprintf_plus(stderr, "unlink(\"%s/%s\"): %s\n", dirname,
3312
direntries[i]->d_name, strerror(errno));
3315
free(direntries[i]);
3318
/* need to clean even if 0 because man page doesn't specify */
3320
dret = unlinkat(base, dirname, AT_REMOVEDIR);
3321
if(dret == -1 and errno != ENOENT){
3322
perror_plus("rmdir");
3325
perror_plus("scandirat");
3330
/* Removes the GPGME temp directory and all files inside */
3331
if(tempdir != NULL){
3332
clean_dir_at(-1, tempdir, 0);
3336
sigemptyset(&old_sigterm_action.sa_mask);
3337
old_sigterm_action.sa_handler = SIG_DFL;
3338
ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
3339
&old_sigterm_action,
3342
perror_plus("sigaction");
3345
ret = raise(signal_received);
3346
} while(ret != 0 and errno == EINTR);
3348
perror_plus("raise");
3351
TEMP_FAILURE_RETRY(pause());
719
/* Check if creating the server object succeeded */
721
fprintf(stderr, "Failed to create server: %s\n",
722
avahi_strerror(error));
723
returncode = EXIT_FAILURE;
727
/* Create the service browser */
728
sb = avahi_s_service_browser_new(server,
730
if_nametoindex(interface),
732
"_mandos._tcp", NULL, 0,
733
browse_callback, server);
735
fprintf(stderr, "Failed to create service browser: %s\n",
736
avahi_strerror(avahi_server_errno(server)));
737
returncode = EXIT_FAILURE;
741
/* Run the main loop */
744
fprintf(stderr, "Starting avahi loop search\n");
747
avahi_simple_poll_loop(simple_poll);
752
fprintf(stderr, "%s exiting\n", argv[0]);
757
avahi_s_service_browser_free(sb);
760
avahi_server_free(server);
763
avahi_simple_poll_free(simple_poll);