To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to plugins.d/mandos-client.c
- browse files at revision 875
- compare with another revision
- download diff
- download tarball
- view history from revision 875
- Committer: Teddy Hogeborn
- Date: 2016-08-26 18:44:21 UTC
- Revision ID: teddy@recompile.se-20160826184421-gjqjgzxy3lupx9n3
Fix bug where mandos server could not find GnuTLS library
* mandos (GnuTLS): Try to find both "gnutls" and variant name
"gnutls-deb0", for a Debian Jessie system which
does not have the package "gnutls28-dev" installed.
* mandos (GnuTLS): Try to find both "gnutls" and variant name
"gnutls-deb0", for a Debian Jessie system which
does not have the package "gnutls28-dev" installed.
- files added:
- .bzr-builddeb
- debian
- debian/po
- debian/source
- debian/upstream
- network-hooks.d
- plugin-helpers
- plugins.d
- files removed:
- bad-ca.pem
- files renamed:
- mandos-clients.conf => clients.conf
- server.py => mandos
- files modified:
- Makefile
added
removed
plugins.d/mandos-client.c
1
/* -*- coding: utf-8 -*- */
2
/*
3
* Mandos-client - get and decrypt data from a Mandos server
4
*
5
* This program is partly derived from an example program for an Avahi
6
* service browser, downloaded from
7
* <http://avahi.org/browser/examples/core-browse-services.c>. This
8
* includes the following functions: "resolve_callback",
9
* "browse_callback", and parts of "main".
10
*
11
* Everything else is
12
* Copyright © 2008-2016 Teddy Hogeborn
13
* Copyright © 2008-2016 Björn Påhlsson
14
*
15
* This program is free software: you can redistribute it and/or
16
* modify it under the terms of the GNU General Public License as
17
* published by the Free Software Foundation, either version 3 of the
18
* License, or (at your option) any later version.
19
*
20
* This program is distributed in the hope that it will be useful, but
21
* WITHOUT ANY WARRANTY; without even the implied warranty of
22
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23
* General Public License for more details.
24
*
25
* You should have received a copy of the GNU General Public License
26
* along with this program. If not, see
27
* <http://www.gnu.org/licenses/>.
28
*
29
* Contact the authors at <mandos@recompile.se>.
30
*/
31
32
/* Needed by GPGME, specifically gpgme_data_seek() */
33
#ifndef _LARGEFILE_SOURCE
34
#define _LARGEFILE_SOURCE
35
#endif /* not _LARGEFILE_SOURCE */
36
#ifndef _FILE_OFFSET_BITS
37
#define _FILE_OFFSET_BITS 64
38
#endif /* not _FILE_OFFSET_BITS */
39
40
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
41
42
#include <stdio.h> /* fprintf(), stderr, fwrite(),
43
stdout, ferror() */
44
#include <stdint.h> /* uint16_t, uint32_t, intptr_t */
45
#include <stddef.h> /* NULL, size_t, ssize_t */
46
#include <stdlib.h> /* free(), EXIT_SUCCESS, srand(),
47
strtof(), abort() */
48
#include <stdbool.h> /* bool, false, true */
49
#include <string.h> /* strcmp(), strlen(), strerror(),
50
asprintf(), strncpy(), strsignal()
51
*/
52
#include <sys/ioctl.h> /* ioctl */
53
#include <sys/types.h> /* socket(), inet_pton(), sockaddr,
54
sockaddr_in6, PF_INET6,
55
SOCK_STREAM, uid_t, gid_t, open(),
56
opendir(), DIR */
57
#include <sys/stat.h> /* open(), S_ISREG */
58
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
59
inet_pton(), connect(),
60
getnameinfo() */
61
#include <fcntl.h> /* open(), unlinkat(), AT_REMOVEDIR */
62
#include <dirent.h> /* opendir(), struct dirent, readdir()
63
*/
64
#include <inttypes.h> /* PRIu16, PRIdMAX, intmax_t,
65
strtoimax() */
66
#include <errno.h> /* perror(), errno, EINTR, EINVAL,
67
EAI_SYSTEM, ENETUNREACH,
68
EHOSTUNREACH, ECONNREFUSED, EPROTO,
69
EIO, ENOENT, ENXIO, ENOMEM, EISDIR,
70
ENOTEMPTY,
71
program_invocation_short_name */
72
#include <time.h> /* nanosleep(), time(), sleep() */
73
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
74
SIOCSIFFLAGS, if_indextoname(),
75
if_nametoindex(), IF_NAMESIZE */
76
#include <netinet/in.h> /* IN6_IS_ADDR_LINKLOCAL,
77
INET_ADDRSTRLEN, INET6_ADDRSTRLEN
78
*/
79
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
80
getuid(), getgid(), seteuid(),
81
setgid(), pause(), _exit(),
82
unlinkat() */
83
#include <arpa/inet.h> /* inet_pton(), htons() */
84
#include <iso646.h> /* not, or, and */
85
#include <argp.h> /* struct argp_option, error_t, struct
86
argp_state, struct argp,
87
argp_parse(), ARGP_KEY_ARG,
88
ARGP_KEY_END, ARGP_ERR_UNKNOWN */
89
#include <signal.h> /* sigemptyset(), sigaddset(),
90
sigaction(), SIGTERM, sig_atomic_t,
91
raise() */
92
#include <sysexits.h> /* EX_OSERR, EX_USAGE, EX_UNAVAILABLE,
93
EX_NOHOST, EX_IOERR, EX_PROTOCOL */
94
#include <sys/wait.h> /* waitpid(), WIFEXITED(),
95
WEXITSTATUS(), WTERMSIG() */
96
#include <grp.h> /* setgroups() */
97
#include <argz.h> /* argz_add_sep(), argz_next(),
98
argz_delete(), argz_append(),
99
argz_stringify(), argz_add(),
100
argz_count() */
101
#include <netdb.h> /* getnameinfo(), NI_NUMERICHOST,
102
EAI_SYSTEM, gai_strerror() */
103
104
#ifdef __linux__
105
#include <sys/klog.h> /* klogctl() */
106
#endif /* __linux__ */
107
108
/* Avahi */
109
/* All Avahi types, constants and functions
110
Avahi*, avahi_*,
111
AVAHI_* */
112
#include <avahi-core/core.h>
113
#include <avahi-core/lookup.h>
114
#include <avahi-core/log.h>
115
#include <avahi-common/simple-watch.h>
116
#include <avahi-common/malloc.h>
117
#include <avahi-common/error.h>
118
119
/* GnuTLS */
120
#include <gnutls/gnutls.h> /* All GnuTLS types, constants and
121
functions:
122
gnutls_*
123
init_gnutls_session(),
124
GNUTLS_* */
125
#include <gnutls/openpgp.h>
126
/* gnutls_certificate_set_openpgp_key_file(),
127
GNUTLS_OPENPGP_FMT_BASE64 */
128
129
/* GPGME */
130
#include <gpgme.h> /* All GPGME types, constants and
131
functions:
132
gpgme_*
133
GPGME_PROTOCOL_OpenPGP,
134
GPG_ERR_NO_* */
135
136
#define BUFFER_SIZE 256
137
138
#define PATHDIR "/conf/conf.d/mandos"
139
#define SECKEY "seckey.txt"
140
#define PUBKEY "pubkey.txt"
141
#define HOOKDIR "/lib/mandos/network-hooks.d"
142
143
bool debug = false;
144
static const char mandos_protocol_version[] = "1";
145
const char *argp_program_version = "mandos-client " VERSION;
146
const char *argp_program_bug_address = "<mandos@recompile.se>";
147
static const char sys_class_net[] = "/sys/class/net";
148
char *connect_to = NULL;
149
const char *hookdir = HOOKDIR;
150
int hookdir_fd = -1;
151
uid_t uid = 65534;
152
gid_t gid = 65534;
153
154
/* Doubly linked list that need to be circularly linked when used */
155
typedef struct server{
156
const char *ip;
157
in_port_t port;
158
AvahiIfIndex if_index;
159
int af;
160
struct timespec last_seen;
161
struct server *next;
162
struct server *prev;
163
} server;
164
165
/* Used for passing in values through the Avahi callback functions */
166
typedef struct {
167
AvahiServer *server;
168
gnutls_certificate_credentials_t cred;
169
unsigned int dh_bits;
170
gnutls_dh_params_t dh_params;
171
const char *priority;
172
gpgme_ctx_t ctx;
173
server *current_server;
174
char *interfaces;
175
size_t interfaces_size;
176
} mandos_context;
177
178
/* global so signal handler can reach it*/
179
AvahiSimplePoll *simple_poll;
180
181
sig_atomic_t quit_now = 0;
182
int signal_received = 0;
183
184
/* Function to use when printing errors */
185
void perror_plus(const char *print_text){
186
int e = errno;
187
fprintf(stderr, "Mandos plugin %s: ",
188
program_invocation_short_name);
189
errno = e;
190
perror(print_text);
191
}
192
193
__attribute__((format (gnu_printf, 2, 3), nonnull))
194
int fprintf_plus(FILE *stream, const char *format, ...){
195
va_list ap;
196
va_start (ap, format);
197
198
TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
199
program_invocation_short_name));
200
return (int)TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
201
}
202
203
/*
204
* Make additional room in "buffer" for at least BUFFER_SIZE more
205
* bytes. "buffer_capacity" is how much is currently allocated,
206
* "buffer_length" is how much is already used.
207
*/
208
__attribute__((nonnull, warn_unused_result))
209
size_t incbuffer(char **buffer, size_t buffer_length,
210
size_t buffer_capacity){
211
if(buffer_length + BUFFER_SIZE > buffer_capacity){
212
char *new_buf = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
213
if(new_buf == NULL){
214
int old_errno = errno;
215
free(*buffer);
216
errno = old_errno;
217
*buffer = NULL;
218
return 0;
219
}
220
*buffer = new_buf;
221
buffer_capacity += BUFFER_SIZE;
222
}
223
return buffer_capacity;
224
}
225
226
/* Add server to set of servers to retry periodically */
227
__attribute__((nonnull, warn_unused_result))
228
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
229
int af, server **current_server){
230
int ret;
231
server *new_server = malloc(sizeof(server));
232
if(new_server == NULL){
233
perror_plus("malloc");
234
return false;
235
}
236
*new_server = (server){ .ip = strdup(ip),
237
.port = port,
238
.if_index = if_index,
239
.af = af };
240
if(new_server->ip == NULL){
241
perror_plus("strdup");
242
free(new_server);
243
return false;
244
}
245
ret = clock_gettime(CLOCK_MONOTONIC, &(new_server->last_seen));
246
if(ret == -1){
247
perror_plus("clock_gettime");
248
#ifdef __GNUC__
249
#pragma GCC diagnostic push
250
#pragma GCC diagnostic ignored "-Wcast-qual"
251
#endif
252
free((char *)(new_server->ip));
253
#ifdef __GNUC__
254
#pragma GCC diagnostic pop
255
#endif
256
free(new_server);
257
return false;
258
}
259
/* Special case of first server */
260
if(*current_server == NULL){
261
new_server->next = new_server;
262
new_server->prev = new_server;
263
*current_server = new_server;
264
} else {
265
/* Place the new server last in the list */
266
new_server->next = *current_server;
267
new_server->prev = (*current_server)->prev;
268
new_server->prev->next = new_server;
269
(*current_server)->prev = new_server;
270
}
271
return true;
272
}
273
274
/*
275
* Initialize GPGME.
276
*/
277
__attribute__((nonnull, warn_unused_result))
278
static bool init_gpgme(const char * const seckey,
279
const char * const pubkey,
280
const char * const tempdir,
281
mandos_context *mc){
282
gpgme_error_t rc;
283
gpgme_engine_info_t engine_info;
284
285
/*
286
* Helper function to insert pub and seckey to the engine keyring.
287
*/
288
bool import_key(const char * const filename){
289
int ret;
290
int fd;
291
gpgme_data_t pgp_data;
292
293
fd = (int)TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
294
if(fd == -1){
295
perror_plus("open");
296
return false;
297
}
298
299
rc = gpgme_data_new_from_fd(&pgp_data, fd);
300
if(rc != GPG_ERR_NO_ERROR){
301
fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
302
gpgme_strsource(rc), gpgme_strerror(rc));
303
return false;
304
}
305
306
rc = gpgme_op_import(mc->ctx, pgp_data);
307
if(rc != GPG_ERR_NO_ERROR){
308
fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
309
gpgme_strsource(rc), gpgme_strerror(rc));
310
return false;
311
}
312
313
ret = close(fd);
314
if(ret == -1){
315
perror_plus("close");
316
}
317
gpgme_data_release(pgp_data);
318
return true;
319
}
320
321
if(debug){
322
fprintf_plus(stderr, "Initializing GPGME\n");
323
}
324
325
/* Init GPGME */
326
gpgme_check_version(NULL);
327
rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
328
if(rc != GPG_ERR_NO_ERROR){
329
fprintf_plus(stderr, "bad gpgme_engine_check_version: %s: %s\n",
330
gpgme_strsource(rc), gpgme_strerror(rc));
331
return false;
332
}
333
334
/* Set GPGME home directory for the OpenPGP engine only */
335
rc = gpgme_get_engine_info(&engine_info);
336
if(rc != GPG_ERR_NO_ERROR){
337
fprintf_plus(stderr, "bad gpgme_get_engine_info: %s: %s\n",
338
gpgme_strsource(rc), gpgme_strerror(rc));
339
return false;
340
}
341
while(engine_info != NULL){
342
if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){
343
gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,
344
engine_info->file_name, tempdir);
345
break;
346
}
347
engine_info = engine_info->next;
348
}
349
if(engine_info == NULL){
350
fprintf_plus(stderr, "Could not set GPGME home dir to %s\n",
351
tempdir);
352
return false;
353
}
354
355
/* Create new GPGME "context" */
356
rc = gpgme_new(&(mc->ctx));
357
if(rc != GPG_ERR_NO_ERROR){
358
fprintf_plus(stderr, "Mandos plugin mandos-client: "
359
"bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
360
gpgme_strerror(rc));
361
return false;
362
}
363
364
if(not import_key(pubkey) or not import_key(seckey)){
365
return false;
366
}
367
368
return true;
369
}
370
371
/*
372
* Decrypt OpenPGP data.
373
* Returns -1 on error
374
*/
375
__attribute__((nonnull, warn_unused_result))
376
static ssize_t pgp_packet_decrypt(const char *cryptotext,
377
size_t crypto_size,
378
char **plaintext,
379
mandos_context *mc){
380
gpgme_data_t dh_crypto, dh_plain;
381
gpgme_error_t rc;
382
ssize_t ret;
383
size_t plaintext_capacity = 0;
384
ssize_t plaintext_length = 0;
385
386
if(debug){
387
fprintf_plus(stderr, "Trying to decrypt OpenPGP data\n");
388
}
389
390
/* Create new GPGME data buffer from memory cryptotext */
391
rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
392
0);
393
if(rc != GPG_ERR_NO_ERROR){
394
fprintf_plus(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
395
gpgme_strsource(rc), gpgme_strerror(rc));
396
return -1;
397
}
398
399
/* Create new empty GPGME data buffer for the plaintext */
400
rc = gpgme_data_new(&dh_plain);
401
if(rc != GPG_ERR_NO_ERROR){
402
fprintf_plus(stderr, "Mandos plugin mandos-client: "
403
"bad gpgme_data_new: %s: %s\n",
404
gpgme_strsource(rc), gpgme_strerror(rc));
405
gpgme_data_release(dh_crypto);
406
return -1;
407
}
408
409
/* Decrypt data from the cryptotext data buffer to the plaintext
410
data buffer */
411
rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
412
if(rc != GPG_ERR_NO_ERROR){
413
fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
414
gpgme_strsource(rc), gpgme_strerror(rc));
415
plaintext_length = -1;
416
if(debug){
417
gpgme_decrypt_result_t result;
418
result = gpgme_op_decrypt_result(mc->ctx);
419
if(result == NULL){
420
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
421
} else {
422
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
423
result->unsupported_algorithm);
424
fprintf_plus(stderr, "Wrong key usage: %u\n",
425
result->wrong_key_usage);
426
if(result->file_name != NULL){
427
fprintf_plus(stderr, "File name: %s\n", result->file_name);
428
}
429
gpgme_recipient_t recipient;
430
recipient = result->recipients;
431
while(recipient != NULL){
432
fprintf_plus(stderr, "Public key algorithm: %s\n",
433
gpgme_pubkey_algo_name
434
(recipient->pubkey_algo));
435
fprintf_plus(stderr, "Key ID: %s\n", recipient->keyid);
436
fprintf_plus(stderr, "Secret key available: %s\n",
437
recipient->status == GPG_ERR_NO_SECKEY
438
? "No" : "Yes");
439
recipient = recipient->next;
440
}
441
}
442
}
443
goto decrypt_end;
444
}
445
446
if(debug){
447
fprintf_plus(stderr, "Decryption of OpenPGP data succeeded\n");
448
}
449
450
/* Seek back to the beginning of the GPGME plaintext data buffer */
451
if(gpgme_data_seek(dh_plain, (off_t)0, SEEK_SET) == -1){
452
perror_plus("gpgme_data_seek");
453
plaintext_length = -1;
454
goto decrypt_end;
455
}
456
457
*plaintext = NULL;
458
while(true){
459
plaintext_capacity = incbuffer(plaintext,
460
(size_t)plaintext_length,
461
plaintext_capacity);
462
if(plaintext_capacity == 0){
463
perror_plus("incbuffer");
464
plaintext_length = -1;
465
goto decrypt_end;
466
}
467
468
ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
469
BUFFER_SIZE);
470
/* Print the data, if any */
471
if(ret == 0){
472
/* EOF */
473
break;
474
}
475
if(ret < 0){
476
perror_plus("gpgme_data_read");
477
plaintext_length = -1;
478
goto decrypt_end;
479
}
480
plaintext_length += ret;
481
}
482
483
if(debug){
484
fprintf_plus(stderr, "Decrypted password is: ");
485
for(ssize_t i = 0; i < plaintext_length; i++){
486
fprintf(stderr, "%02hhX ", (*plaintext)[i]);
487
}
488
fprintf(stderr, "\n");
489
}
490
491
decrypt_end:
492
493
/* Delete the GPGME cryptotext data buffer */
494
gpgme_data_release(dh_crypto);
495
496
/* Delete the GPGME plaintext data buffer */
497
gpgme_data_release(dh_plain);
498
return plaintext_length;
499
}
500
501
__attribute__((warn_unused_result, const))
502
static const char *safe_string(const char *str){
503
if(str == NULL)
504
return "(unknown)";
505
return str;
506
}
507
508
__attribute__((warn_unused_result))
509
static const char *safer_gnutls_strerror(int value){
510
const char *ret = gnutls_strerror(value);
511
return safe_string(ret);
512
}
513
514
/* GnuTLS log function callback */
515
__attribute__((nonnull))
516
static void debuggnutls(__attribute__((unused)) int level,
517
const char* string){
518
fprintf_plus(stderr, "GnuTLS: %s", string);
519
}
520
521
__attribute__((nonnull(1, 2, 4), warn_unused_result))
522
static int init_gnutls_global(const char *pubkeyfilename,
523
const char *seckeyfilename,
524
const char *dhparamsfilename,
525
mandos_context *mc){
526
int ret;
527
unsigned int uret;
528
529
if(debug){
530
fprintf_plus(stderr, "Initializing GnuTLS\n");
531
}
532
533
if(debug){
534
/* "Use a log level over 10 to enable all debugging options."
535
* - GnuTLS manual
536
*/
537
gnutls_global_set_log_level(11);
538
gnutls_global_set_log_function(debuggnutls);
539
}
540
541
/* OpenPGP credentials */
542
ret = gnutls_certificate_allocate_credentials(&mc->cred);
543
if(ret != GNUTLS_E_SUCCESS){
544
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
545
safer_gnutls_strerror(ret));
546
return -1;
547
}
548
549
if(debug){
550
fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
551
" secret key %s as GnuTLS credentials\n",
552
pubkeyfilename,
553
seckeyfilename);
554
}
555
556
ret = gnutls_certificate_set_openpgp_key_file
557
(mc->cred, pubkeyfilename, seckeyfilename,
558
GNUTLS_OPENPGP_FMT_BASE64);
559
if(ret != GNUTLS_E_SUCCESS){
560
fprintf_plus(stderr,
561
"Error[%d] while reading the OpenPGP key pair ('%s',"
562
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
563
fprintf_plus(stderr, "The GnuTLS error is: %s\n",
564
safer_gnutls_strerror(ret));
565
goto globalfail;
566
}
567
568
/* GnuTLS server initialization */
569
ret = gnutls_dh_params_init(&mc->dh_params);
570
if(ret != GNUTLS_E_SUCCESS){
571
fprintf_plus(stderr, "Error in GnuTLS DH parameter"
572
" initialization: %s\n",
573
safer_gnutls_strerror(ret));
574
goto globalfail;
575
}
576
/* If a Diffie-Hellman parameters file was given, try to use it */
577
if(dhparamsfilename != NULL){
578
gnutls_datum_t params = { .data = NULL, .size = 0 };
579
do {
580
int dhpfile = open(dhparamsfilename, O_RDONLY);
581
if(dhpfile == -1){
582
perror_plus("open");
583
dhparamsfilename = NULL;
584
break;
585
}
586
size_t params_capacity = 0;
587
while(true){
588
params_capacity = incbuffer((char **)¶ms.data,
589
(size_t)params.size,
590
(size_t)params_capacity);
591
if(params_capacity == 0){
592
perror_plus("incbuffer");
593
free(params.data);
594
params.data = NULL;
595
dhparamsfilename = NULL;
596
break;
597
}
598
ssize_t bytes_read = read(dhpfile,
599
params.data + params.size,
600
BUFFER_SIZE);
601
/* EOF */
602
if(bytes_read == 0){
603
break;
604
}
605
/* check bytes_read for failure */
606
if(bytes_read < 0){
607
perror_plus("read");
608
free(params.data);
609
params.data = NULL;
610
dhparamsfilename = NULL;
611
break;
612
}
613
params.size += (unsigned int)bytes_read;
614
}
615
if(params.data == NULL){
616
dhparamsfilename = NULL;
617
}
618
if(dhparamsfilename == NULL){
619
break;
620
}
621
ret = gnutls_dh_params_import_pkcs3(mc->dh_params, ¶ms,
622
GNUTLS_X509_FMT_PEM);
623
if(ret != GNUTLS_E_SUCCESS){
624
fprintf_plus(stderr, "Failed to parse DH parameters in file"
625
" \"%s\": %s\n", dhparamsfilename,
626
safer_gnutls_strerror(ret));
627
dhparamsfilename = NULL;
628
}
629
} while(false);
630
}
631
if(dhparamsfilename == NULL){
632
if(mc->dh_bits == 0){
633
/* Find out the optimal number of DH bits */
634
/* Try to read the private key file */
635
gnutls_datum_t buffer = { .data = NULL, .size = 0 };
636
do {
637
int secfile = open(seckeyfilename, O_RDONLY);
638
if(secfile == -1){
639
perror_plus("open");
640
break;
641
}
642
size_t buffer_capacity = 0;
643
while(true){
644
buffer_capacity = incbuffer((char **)&buffer.data,
645
(size_t)buffer.size,
646
(size_t)buffer_capacity);
647
if(buffer_capacity == 0){
648
perror_plus("incbuffer");
649
free(buffer.data);
650
buffer.data = NULL;
651
break;
652
}
653
ssize_t bytes_read = read(secfile,
654
buffer.data + buffer.size,
655
BUFFER_SIZE);
656
/* EOF */
657
if(bytes_read == 0){
658
break;
659
}
660
/* check bytes_read for failure */
661
if(bytes_read < 0){
662
perror_plus("read");
663
free(buffer.data);
664
buffer.data = NULL;
665
break;
666
}
667
buffer.size += (unsigned int)bytes_read;
668
}
669
close(secfile);
670
} while(false);
671
/* If successful, use buffer to parse private key */
672
gnutls_sec_param_t sec_param = GNUTLS_SEC_PARAM_ULTRA;
673
if(buffer.data != NULL){
674
{
675
gnutls_openpgp_privkey_t privkey = NULL;
676
ret = gnutls_openpgp_privkey_init(&privkey);
677
if(ret != GNUTLS_E_SUCCESS){
678
fprintf_plus(stderr, "Error initializing OpenPGP key"
679
" structure: %s",
680
safer_gnutls_strerror(ret));
681
free(buffer.data);
682
buffer.data = NULL;
683
} else {
684
ret = gnutls_openpgp_privkey_import
685
(privkey, &buffer, GNUTLS_OPENPGP_FMT_BASE64, "", 0);
686
if(ret != GNUTLS_E_SUCCESS){
687
fprintf_plus(stderr, "Error importing OpenPGP key : %s",
688
safer_gnutls_strerror(ret));
689
privkey = NULL;
690
}
691
free(buffer.data);
692
buffer.data = NULL;
693
if(privkey != NULL){
694
/* Use private key to suggest an appropriate
695
sec_param */
696
sec_param = gnutls_openpgp_privkey_sec_param(privkey);
697
gnutls_openpgp_privkey_deinit(privkey);
698
if(debug){
699
fprintf_plus(stderr, "This OpenPGP key implies using"
700
" a GnuTLS security parameter \"%s\".\n",
701
safe_string(gnutls_sec_param_get_name
702
(sec_param)));
703
}
704
}
705
}
706
}
707
if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
708
/* Err on the side of caution */
709
sec_param = GNUTLS_SEC_PARAM_ULTRA;
710
if(debug){
711
fprintf_plus(stderr, "Falling back to security parameter"
712
" \"%s\"\n",
713
safe_string(gnutls_sec_param_get_name
714
(sec_param)));
715
}
716
}
717
}
718
uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
719
if(uret != 0){
720
mc->dh_bits = uret;
721
if(debug){
722
fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
723
" implies %u DH bits; using that.\n",
724
safe_string(gnutls_sec_param_get_name
725
(sec_param)),
726
mc->dh_bits);
727
}
728
} else {
729
fprintf_plus(stderr, "Failed to get implied number of DH"
730
" bits for security parameter \"%s\"): %s\n",
731
safe_string(gnutls_sec_param_get_name
732
(sec_param)),
733
safer_gnutls_strerror(ret));
734
goto globalfail;
735
}
736
} else if(debug){
737
fprintf_plus(stderr, "DH bits explicitly set to %u\n",
738
mc->dh_bits);
739
}
740
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
741
if(ret != GNUTLS_E_SUCCESS){
742
fprintf_plus(stderr, "Error in GnuTLS prime generation (%u"
743
" bits): %s\n", mc->dh_bits,
744
safer_gnutls_strerror(ret));
745
goto globalfail;
746
}
747
}
748
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
749
750
return 0;
751
752
globalfail:
753
754
gnutls_certificate_free_credentials(mc->cred);
755
gnutls_dh_params_deinit(mc->dh_params);
756
return -1;
757
}
758
759
__attribute__((nonnull, warn_unused_result))
760
static int init_gnutls_session(gnutls_session_t *session,
761
mandos_context *mc){
762
int ret;
763
/* GnuTLS session creation */
764
do {
765
ret = gnutls_init(session, GNUTLS_SERVER);
766
if(quit_now){
767
return -1;
768
}
769
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
770
if(ret != GNUTLS_E_SUCCESS){
771
fprintf_plus(stderr,
772
"Error in GnuTLS session initialization: %s\n",
773
safer_gnutls_strerror(ret));
774
}
775
776
{
777
const char *err;
778
do {
779
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
780
if(quit_now){
781
gnutls_deinit(*session);
782
return -1;
783
}
784
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
785
if(ret != GNUTLS_E_SUCCESS){
786
fprintf_plus(stderr, "Syntax error at: %s\n", err);
787
fprintf_plus(stderr, "GnuTLS error: %s\n",
788
safer_gnutls_strerror(ret));
789
gnutls_deinit(*session);
790
return -1;
791
}
792
}
793
794
do {
795
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
796
mc->cred);
797
if(quit_now){
798
gnutls_deinit(*session);
799
return -1;
800
}
801
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
802
if(ret != GNUTLS_E_SUCCESS){
803
fprintf_plus(stderr, "Error setting GnuTLS credentials: %s\n",
804
safer_gnutls_strerror(ret));
805
gnutls_deinit(*session);
806
return -1;
807
}
808
809
/* ignore client certificate if any. */
810
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
811
812
return 0;
813
}
814
815
/* Avahi log function callback */
816
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
817
__attribute__((unused)) const char *txt){}
818
819
/* Set effective uid to 0, return errno */
820
__attribute__((warn_unused_result))
821
int raise_privileges(void){
822
int old_errno = errno;
823
int ret = 0;
824
if(seteuid(0) == -1){
825
ret = errno;
826
}
827
errno = old_errno;
828
return ret;
829
}
830
831
/* Set effective and real user ID to 0. Return errno. */
832
__attribute__((warn_unused_result))
833
int raise_privileges_permanently(void){
834
int old_errno = errno;
835
int ret = raise_privileges();
836
if(ret != 0){
837
errno = old_errno;
838
return ret;
839
}
840
if(setuid(0) == -1){
841
ret = errno;
842
}
843
errno = old_errno;
844
return ret;
845
}
846
847
/* Set effective user ID to unprivileged saved user ID */
848
__attribute__((warn_unused_result))
849
int lower_privileges(void){
850
int old_errno = errno;
851
int ret = 0;
852
if(seteuid(uid) == -1){
853
ret = errno;
854
}
855
errno = old_errno;
856
return ret;
857
}
858
859
/* Lower privileges permanently */
860
__attribute__((warn_unused_result))
861
int lower_privileges_permanently(void){
862
int old_errno = errno;
863
int ret = 0;
864
if(setuid(uid) == -1){
865
ret = errno;
866
}
867
errno = old_errno;
868
return ret;
869
}
870
871
/* Helper function to add_local_route() and delete_local_route() */
872
__attribute__((nonnull, warn_unused_result))
873
static bool add_delete_local_route(const bool add,
874
const char *address,
875
AvahiIfIndex if_index){
876
int ret;
877
char helper[] = "mandos-client-iprouteadddel";
878
char add_arg[] = "add";
879
char delete_arg[] = "delete";
880
char debug_flag[] = "--debug";
881
char *pluginhelperdir = getenv("MANDOSPLUGINHELPERDIR");
882
if(pluginhelperdir == NULL){
883
if(debug){
884
fprintf_plus(stderr, "MANDOSPLUGINHELPERDIR environment"
885
" variable not set; cannot run helper\n");
886
}
887
return false;
888
}
889
890
char interface[IF_NAMESIZE];
891
if(if_indextoname((unsigned int)if_index, interface) == NULL){
892
perror_plus("if_indextoname");
893
return false;
894
}
895
896
int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
897
if(devnull == -1){
898
perror_plus("open(\"/dev/null\", O_RDONLY)");
899
return false;
900
}
901
pid_t pid = fork();
902
if(pid == 0){
903
/* Child */
904
/* Raise privileges */
905
errno = raise_privileges_permanently();
906
if(errno != 0){
907
perror_plus("Failed to raise privileges");
908
/* _exit(EX_NOPERM); */
909
} else {
910
/* Set group */
911
errno = 0;
912
ret = setgid(0);
913
if(ret == -1){
914
perror_plus("setgid");
915
_exit(EX_NOPERM);
916
}
917
/* Reset supplementary groups */
918
errno = 0;
919
ret = setgroups(0, NULL);
920
if(ret == -1){
921
perror_plus("setgroups");
922
_exit(EX_NOPERM);
923
}
924
}
925
ret = dup2(devnull, STDIN_FILENO);
926
if(ret == -1){
927
perror_plus("dup2(devnull, STDIN_FILENO)");
928
_exit(EX_OSERR);
929
}
930
ret = close(devnull);
931
if(ret == -1){
932
perror_plus("close");
933
_exit(EX_OSERR);
934
}
935
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
936
if(ret == -1){
937
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
938
_exit(EX_OSERR);
939
}
940
int helperdir_fd = (int)TEMP_FAILURE_RETRY(open(pluginhelperdir,
941
O_RDONLY
942
| O_DIRECTORY
943
| O_PATH
944
| O_CLOEXEC));
945
if(helperdir_fd == -1){
946
perror_plus("open");
947
_exit(EX_UNAVAILABLE);
948
}
949
int helper_fd = (int)TEMP_FAILURE_RETRY(openat(helperdir_fd,
950
helper, O_RDONLY));
951
if(helper_fd == -1){
952
perror_plus("openat");
953
close(helperdir_fd);
954
_exit(EX_UNAVAILABLE);
955
}
956
close(helperdir_fd);
957
#ifdef __GNUC__
958
#pragma GCC diagnostic push
959
#pragma GCC diagnostic ignored "-Wcast-qual"
960
#endif
961
if(fexecve(helper_fd, (char *const [])
962
{ helper, add ? add_arg : delete_arg, (char *)address,
963
interface, debug ? debug_flag : NULL, NULL },
964
environ) == -1){
965
#ifdef __GNUC__
966
#pragma GCC diagnostic pop
967
#endif
968
perror_plus("fexecve");
969
_exit(EXIT_FAILURE);
970
}
971
}
972
if(pid == -1){
973
perror_plus("fork");
974
return false;
975
}
976
int status;
977
pid_t pret = -1;
978
errno = 0;
979
do {
980
pret = waitpid(pid, &status, 0);
981
if(pret == -1 and errno == EINTR and quit_now){
982
int errno_raising = 0;
983
if((errno = raise_privileges()) != 0){
984
errno_raising = errno;
985
perror_plus("Failed to raise privileges in order to"
986
" kill helper program");
987
}
988
if(kill(pid, SIGTERM) == -1){
989
perror_plus("kill");
990
}
991
if((errno_raising == 0) and (errno = lower_privileges()) != 0){
992
perror_plus("Failed to lower privileges after killing"
993
" helper program");
994
}
995
return false;
996
}
997
} while(pret == -1 and errno == EINTR);
998
if(pret == -1){
999
perror_plus("waitpid");
1000
return false;
1001
}
1002
if(WIFEXITED(status)){
1003
if(WEXITSTATUS(status) != 0){
1004
fprintf_plus(stderr, "Error: iprouteadddel exited"
1005
" with status %d\n", WEXITSTATUS(status));
1006
return false;
1007
}
1008
return true;
1009
}
1010
if(WIFSIGNALED(status)){
1011
fprintf_plus(stderr, "Error: iprouteadddel died by"
1012
" signal %d\n", WTERMSIG(status));
1013
return false;
1014
}
1015
fprintf_plus(stderr, "Error: iprouteadddel crashed\n");
1016
return false;
1017
}
1018
1019
__attribute__((nonnull, warn_unused_result))
1020
static bool add_local_route(const char *address,
1021
AvahiIfIndex if_index){
1022
if(debug){
1023
fprintf_plus(stderr, "Adding route to %s\n", address);
1024
}
1025
return add_delete_local_route(true, address, if_index);
1026
}
1027
1028
__attribute__((nonnull, warn_unused_result))
1029
static bool delete_local_route(const char *address,
1030
AvahiIfIndex if_index){
1031
if(debug){
1032
fprintf_plus(stderr, "Removing route to %s\n", address);
1033
}
1034
return add_delete_local_route(false, address, if_index);
1035
}
1036
1037
/* Called when a Mandos server is found */
1038
__attribute__((nonnull, warn_unused_result))
1039
static int start_mandos_communication(const char *ip, in_port_t port,
1040
AvahiIfIndex if_index,
1041
int af, mandos_context *mc){
1042
int ret, tcp_sd = -1;
1043
ssize_t sret;
1044
struct sockaddr_storage to;
1045
char *buffer = NULL;
1046
char *decrypted_buffer = NULL;
1047
size_t buffer_length = 0;
1048
size_t buffer_capacity = 0;
1049
size_t written;
1050
int retval = -1;
1051
gnutls_session_t session;
1052
int pf; /* Protocol family */
1053
bool route_added = false;
1054
1055
errno = 0;
1056
1057
if(quit_now){
1058
errno = EINTR;
1059
return -1;
1060
}
1061
1062
switch(af){
1063
case AF_INET6:
1064
pf = PF_INET6;
1065
break;
1066
case AF_INET:
1067
pf = PF_INET;
1068
break;
1069
default:
1070
fprintf_plus(stderr, "Bad address family: %d\n", af);
1071
errno = EINVAL;
1072
return -1;
1073
}
1074
1075
/* If the interface is specified and we have a list of interfaces */
1076
if(if_index != AVAHI_IF_UNSPEC and mc->interfaces != NULL){
1077
/* Check if the interface is one of the interfaces we are using */
1078
bool match = false;
1079
{
1080
char *interface = NULL;
1081
while((interface=argz_next(mc->interfaces, mc->interfaces_size,
1082
interface))){
1083
if(if_nametoindex(interface) == (unsigned int)if_index){
1084
match = true;
1085
break;
1086
}
1087
}
1088
}
1089
if(not match){
1090
/* This interface does not match any in the list, so we don't
1091
connect to the server */
1092
if(debug){
1093
char interface[IF_NAMESIZE];
1094
if(if_indextoname((unsigned int)if_index, interface) == NULL){
1095
perror_plus("if_indextoname");
1096
} else {
1097
fprintf_plus(stderr, "Skipping server on non-used interface"
1098
" \"%s\"\n",
1099
if_indextoname((unsigned int)if_index,
1100
interface));
1101
}
1102
}
1103
return -1;
1104
}
1105
}
1106
1107
ret = init_gnutls_session(&session, mc);
1108
if(ret != 0){
1109
return -1;
1110
}
1111
1112
if(debug){
1113
fprintf_plus(stderr, "Setting up a TCP connection to %s, port %"
1114
PRIuMAX "\n", ip, (uintmax_t)port);
1115
}
1116
1117
tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
1118
if(tcp_sd < 0){
1119
int e = errno;
1120
perror_plus("socket");
1121
errno = e;
1122
goto mandos_end;
1123
}
1124
1125
if(quit_now){
1126
errno = EINTR;
1127
goto mandos_end;
1128
}
1129
1130
if(af == AF_INET6){
1131
struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)&to;
1132
*to6 = (struct sockaddr_in6){ .sin6_family = (sa_family_t)af };
1133
ret = inet_pton(af, ip, &to6->sin6_addr);
1134
} else { /* IPv4 */
1135
struct sockaddr_in *to4 = (struct sockaddr_in *)&to;
1136
*to4 = (struct sockaddr_in){ .sin_family = (sa_family_t)af };
1137
ret = inet_pton(af, ip, &to4->sin_addr);
1138
}
1139
if(ret < 0 ){
1140
int e = errno;
1141
perror_plus("inet_pton");
1142
errno = e;
1143
goto mandos_end;
1144
}
1145
if(ret == 0){
1146
int e = errno;
1147
fprintf_plus(stderr, "Bad address: %s\n", ip);
1148
errno = e;
1149
goto mandos_end;
1150
}
1151
if(af == AF_INET6){
1152
((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
1153
if(IN6_IS_ADDR_LINKLOCAL
1154
(&((struct sockaddr_in6 *)&to)->sin6_addr)){
1155
if(if_index == AVAHI_IF_UNSPEC){
1156
fprintf_plus(stderr, "An IPv6 link-local address is"
1157
" incomplete without a network interface\n");
1158
errno = EINVAL;
1159
goto mandos_end;
1160
}
1161
/* Set the network interface number as scope */
1162
((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
1163
}
1164
} else {
1165
((struct sockaddr_in *)&to)->sin_port = htons(port);
1166
}
1167
1168
if(quit_now){
1169
errno = EINTR;
1170
goto mandos_end;
1171
}
1172
1173
if(debug){
1174
if(af == AF_INET6 and if_index != AVAHI_IF_UNSPEC){
1175
char interface[IF_NAMESIZE];
1176
if(if_indextoname((unsigned int)if_index, interface) == NULL){
1177
perror_plus("if_indextoname");
1178
} else {
1179
fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIuMAX
1180
"\n", ip, interface, (uintmax_t)port);
1181
}
1182
} else {
1183
fprintf_plus(stderr, "Connection to: %s, port %" PRIuMAX "\n",
1184
ip, (uintmax_t)port);
1185
}
1186
char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
1187
INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
1188
if(af == AF_INET6){
1189
ret = getnameinfo((struct sockaddr *)&to,
1190
sizeof(struct sockaddr_in6),
1191
addrstr, sizeof(addrstr), NULL, 0,
1192
NI_NUMERICHOST);
1193
} else {
1194
ret = getnameinfo((struct sockaddr *)&to,
1195
sizeof(struct sockaddr_in),
1196
addrstr, sizeof(addrstr), NULL, 0,
1197
NI_NUMERICHOST);
1198
}
1199
if(ret == EAI_SYSTEM){
1200
perror_plus("getnameinfo");
1201
} else if(ret != 0) {
1202
fprintf_plus(stderr, "getnameinfo: %s", gai_strerror(ret));
1203
} else if(strcmp(addrstr, ip) != 0){
1204
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
1205
}
1206
}
1207
1208
if(quit_now){
1209
errno = EINTR;
1210
goto mandos_end;
1211
}
1212
1213
while(true){
1214
if(af == AF_INET6){
1215
ret = connect(tcp_sd, (struct sockaddr *)&to,
1216
sizeof(struct sockaddr_in6));
1217
} else {
1218
ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
1219
sizeof(struct sockaddr_in));
1220
}
1221
if(ret < 0){
1222
if(((errno == ENETUNREACH) or (errno == EHOSTUNREACH))
1223
and if_index != AVAHI_IF_UNSPEC
1224
and connect_to == NULL
1225
and not route_added and
1226
((af == AF_INET6 and not
1227
IN6_IS_ADDR_LINKLOCAL(&(((struct sockaddr_in6 *)
1228
&to)->sin6_addr)))
1229
or (af == AF_INET and
1230
/* Not a a IPv4LL address */
1231
(ntohl(((struct sockaddr_in *)&to)->sin_addr.s_addr)
1232
& 0xFFFF0000L) != 0xA9FE0000L))){
1233
/* Work around Avahi bug - Avahi does not announce link-local
1234
addresses if it has a global address, so local hosts with
1235
*only* a link-local address (e.g. Mandos clients) cannot
1236
connect to a Mandos server announced by Avahi on a server
1237
host with a global address. Work around this by retrying
1238
with an explicit route added with the server's address.
1239
1240
Avahi bug reference:
1241
https://lists.freedesktop.org/archives/avahi/2010-February/001833.html
1242
https://bugs.debian.org/587961
1243
*/
1244
if(debug){
1245
fprintf_plus(stderr, "Mandos server unreachable, trying"
1246
" direct route\n");
1247
}
1248
int e = errno;
1249
route_added = add_local_route(ip, if_index);
1250
if(route_added){
1251
continue;
1252
}
1253
errno = e;
1254
}
1255
if(errno != ECONNREFUSED or debug){
1256
int e = errno;
1257
perror_plus("connect");
1258
errno = e;
1259
}
1260
goto mandos_end;
1261
}
1262
1263
if(quit_now){
1264
errno = EINTR;
1265
goto mandos_end;
1266
}
1267
break;
1268
}
1269
1270
const char *out = mandos_protocol_version;
1271
written = 0;
1272
while(true){
1273
size_t out_size = strlen(out);
1274
ret = (int)TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
1275
out_size - written));
1276
if(ret == -1){
1277
int e = errno;
1278
perror_plus("write");
1279
errno = e;
1280
goto mandos_end;
1281
}
1282
written += (size_t)ret;
1283
if(written < out_size){
1284
continue;
1285
} else {
1286
if(out == mandos_protocol_version){
1287
written = 0;
1288
out = "\r\n";
1289
} else {
1290
break;
1291
}
1292
}
1293
1294
if(quit_now){
1295
errno = EINTR;
1296
goto mandos_end;
1297
}
1298
}
1299
1300
if(debug){
1301
fprintf_plus(stderr, "Establishing TLS session with %s\n", ip);
1302
}
1303
1304
if(quit_now){
1305
errno = EINTR;
1306
goto mandos_end;
1307
}
1308
1309
/* This casting via intptr_t is to eliminate warning about casting
1310
an int to a pointer type. This is exactly how the GnuTLS Guile
1311
function "set-session-transport-fd!" does it. */
1312
gnutls_transport_set_ptr(session,
1313
(gnutls_transport_ptr_t)(intptr_t)tcp_sd);
1314
1315
if(quit_now){
1316
errno = EINTR;
1317
goto mandos_end;
1318
}
1319
1320
do {
1321
ret = gnutls_handshake(session);
1322
if(quit_now){
1323
errno = EINTR;
1324
goto mandos_end;
1325
}
1326
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
1327
1328
if(ret != GNUTLS_E_SUCCESS){
1329
if(debug){
1330
fprintf_plus(stderr, "*** GnuTLS Handshake failed ***\n");
1331
gnutls_perror(ret);
1332
}
1333
errno = EPROTO;
1334
goto mandos_end;
1335
}
1336
1337
/* Read OpenPGP packet that contains the wanted password */
1338
1339
if(debug){
1340
fprintf_plus(stderr, "Retrieving OpenPGP encrypted password from"
1341
" %s\n", ip);
1342
}
1343
1344
while(true){
1345
1346
if(quit_now){
1347
errno = EINTR;
1348
goto mandos_end;
1349
}
1350
1351
buffer_capacity = incbuffer(&buffer, buffer_length,
1352
buffer_capacity);
1353
if(buffer_capacity == 0){
1354
int e = errno;
1355
perror_plus("incbuffer");
1356
errno = e;
1357
goto mandos_end;
1358
}
1359
1360
if(quit_now){
1361
errno = EINTR;
1362
goto mandos_end;
1363
}
1364
1365
sret = gnutls_record_recv(session, buffer+buffer_length,
1366
BUFFER_SIZE);
1367
if(sret == 0){
1368
break;
1369
}
1370
if(sret < 0){
1371
switch(sret){
1372
case GNUTLS_E_INTERRUPTED:
1373
case GNUTLS_E_AGAIN:
1374
break;
1375
case GNUTLS_E_REHANDSHAKE:
1376
do {
1377
ret = gnutls_handshake(session);
1378
1379
if(quit_now){
1380
errno = EINTR;
1381
goto mandos_end;
1382
}
1383
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
1384
if(ret < 0){
1385
fprintf_plus(stderr, "*** GnuTLS Re-handshake failed "
1386
"***\n");
1387
gnutls_perror(ret);
1388
errno = EPROTO;
1389
goto mandos_end;
1390
}
1391
break;
1392
default:
1393
fprintf_plus(stderr, "Unknown error while reading data from"
1394
" encrypted session with Mandos server\n");
1395
gnutls_bye(session, GNUTLS_SHUT_RDWR);
1396
errno = EIO;
1397
goto mandos_end;
1398
}
1399
} else {
1400
buffer_length += (size_t) sret;
1401
}
1402
}
1403
1404
if(debug){
1405
fprintf_plus(stderr, "Closing TLS session\n");
1406
}
1407
1408
if(quit_now){
1409
errno = EINTR;
1410
goto mandos_end;
1411
}
1412
1413
do {
1414
ret = gnutls_bye(session, GNUTLS_SHUT_RDWR);
1415
if(quit_now){
1416
errno = EINTR;
1417
goto mandos_end;
1418
}
1419
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
1420
1421
if(buffer_length > 0){
1422
ssize_t decrypted_buffer_size;
1423
decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
1424
&decrypted_buffer, mc);
1425
if(decrypted_buffer_size >= 0){
1426
1427
clearerr(stdout);
1428
written = 0;
1429
while(written < (size_t) decrypted_buffer_size){
1430
if(quit_now){
1431
errno = EINTR;
1432
goto mandos_end;
1433
}
1434
1435
ret = (int)fwrite(decrypted_buffer + written, 1,
1436
(size_t)decrypted_buffer_size - written,
1437
stdout);
1438
if(ret == 0 and ferror(stdout)){
1439
int e = errno;
1440
if(debug){
1441
fprintf_plus(stderr, "Error writing encrypted data: %s\n",
1442
strerror(errno));
1443
}
1444
errno = e;
1445
goto mandos_end;
1446
}
1447
written += (size_t)ret;
1448
}
1449
ret = fflush(stdout);
1450
if(ret != 0){
1451
int e = errno;
1452
if(debug){
1453
fprintf_plus(stderr, "Error writing encrypted data: %s\n",
1454
strerror(errno));
1455
}
1456
errno = e;
1457
goto mandos_end;
1458
}
1459
retval = 0;
1460
}
1461
}
1462
1463
/* Shutdown procedure */
1464
1465
mandos_end:
1466
{
1467
if(route_added){
1468
if(not delete_local_route(ip, if_index)){
1469
fprintf_plus(stderr, "Failed to delete local route to %s on"
1470
" interface %d", ip, if_index);
1471
}
1472
}
1473
int e = errno;
1474
free(decrypted_buffer);
1475
free(buffer);
1476
if(tcp_sd >= 0){
1477
ret = close(tcp_sd);
1478
}
1479
if(ret == -1){
1480
if(e == 0){
1481
e = errno;
1482
}
1483
perror_plus("close");
1484
}
1485
gnutls_deinit(session);
1486
errno = e;
1487
if(quit_now){
1488
errno = EINTR;
1489
retval = -1;
1490
}
1491
}
1492
return retval;
1493
}
1494
1495
__attribute__((nonnull))
1496
static void resolve_callback(AvahiSServiceResolver *r,
1497
AvahiIfIndex interface,
1498
AvahiProtocol proto,
1499
AvahiResolverEvent event,
1500
const char *name,
1501
const char *type,
1502
const char *domain,
1503
const char *host_name,
1504
const AvahiAddress *address,
1505
uint16_t port,
1506
AVAHI_GCC_UNUSED AvahiStringList *txt,
1507
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1508
flags,
1509
void *mc){
1510
if(r == NULL){
1511
return;
1512
}
1513
1514
/* Called whenever a service has been resolved successfully or
1515
timed out */
1516
1517
if(quit_now){
1518
avahi_s_service_resolver_free(r);
1519
return;
1520
}
1521
1522
switch(event){
1523
default:
1524
case AVAHI_RESOLVER_FAILURE:
1525
fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
1526
"'%s' of type '%s' in domain '%s': %s\n", name, type,
1527
domain,
1528
avahi_strerror(avahi_server_errno
1529
(((mandos_context*)mc)->server)));
1530
break;
1531
1532
case AVAHI_RESOLVER_FOUND:
1533
{
1534
char ip[AVAHI_ADDRESS_STR_MAX];
1535
avahi_address_snprint(ip, sizeof(ip), address);
1536
if(debug){
1537
fprintf_plus(stderr, "Mandos server \"%s\" found on %s (%s, %"
1538
PRIdMAX ") on port %" PRIu16 "\n", name,
1539
host_name, ip, (intmax_t)interface, port);
1540
}
1541
int ret = start_mandos_communication(ip, (in_port_t)port,
1542
interface,
1543
avahi_proto_to_af(proto),
1544
mc);
1545
if(ret == 0){
1546
avahi_simple_poll_quit(simple_poll);
1547
} else {
1548
if(not add_server(ip, (in_port_t)port, interface,
1549
avahi_proto_to_af(proto),
1550
&((mandos_context*)mc)->current_server)){
1551
fprintf_plus(stderr, "Failed to add server \"%s\" to server"
1552
" list\n", name);
1553
}
1554
}
1555
}
1556
}
1557
avahi_s_service_resolver_free(r);
1558
}
1559
1560
static void browse_callback(AvahiSServiceBrowser *b,
1561
AvahiIfIndex interface,
1562
AvahiProtocol protocol,
1563
AvahiBrowserEvent event,
1564
const char *name,
1565
const char *type,
1566
const char *domain,
1567
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1568
flags,
1569
void *mc){
1570
if(b == NULL){
1571
return;
1572
}
1573
1574
/* Called whenever a new services becomes available on the LAN or
1575
is removed from the LAN */
1576
1577
if(quit_now){
1578
return;
1579
}
1580
1581
switch(event){
1582
default:
1583
case AVAHI_BROWSER_FAILURE:
1584
1585
fprintf_plus(stderr, "(Avahi browser) %s\n",
1586
avahi_strerror(avahi_server_errno
1587
(((mandos_context*)mc)->server)));
1588
avahi_simple_poll_quit(simple_poll);
1589
return;
1590
1591
case AVAHI_BROWSER_NEW:
1592
/* We ignore the returned Avahi resolver object. In the callback
1593
function we free it. If the Avahi server is terminated before
1594
the callback function is called the Avahi server will free the
1595
resolver for us. */
1596
1597
if(avahi_s_service_resolver_new(((mandos_context*)mc)->server,
1598
interface, protocol, name, type,
1599
domain, protocol, 0,
1600
resolve_callback, mc) == NULL)
1601
fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
1602
" %s\n", name,
1603
avahi_strerror(avahi_server_errno
1604
(((mandos_context*)mc)->server)));
1605
break;
1606
1607
case AVAHI_BROWSER_REMOVE:
1608
break;
1609
1610
case AVAHI_BROWSER_ALL_FOR_NOW:
1611
case AVAHI_BROWSER_CACHE_EXHAUSTED:
1612
if(debug){
1613
fprintf_plus(stderr, "No Mandos server found, still"
1614
" searching...\n");
1615
}
1616
break;
1617
}
1618
}
1619
1620
/* Signal handler that stops main loop after SIGTERM */
1621
static void handle_sigterm(int sig){
1622
if(quit_now){
1623
return;
1624
}
1625
quit_now = 1;
1626
signal_received = sig;
1627
int old_errno = errno;
1628
/* set main loop to exit */
1629
if(simple_poll != NULL){
1630
avahi_simple_poll_quit(simple_poll);
1631
}
1632
errno = old_errno;
1633
}
1634
1635
__attribute__((nonnull, warn_unused_result))
1636
bool get_flags(const char *ifname, struct ifreq *ifr){
1637
int ret;
1638
int old_errno;
1639
1640
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1641
if(s < 0){
1642
old_errno = errno;
1643
perror_plus("socket");
1644
errno = old_errno;
1645
return false;
1646
}
1647
strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
1648
ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
1649
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1650
if(ret == -1){
1651
if(debug){
1652
old_errno = errno;
1653
perror_plus("ioctl SIOCGIFFLAGS");
1654
errno = old_errno;
1655
}
1656
return false;
1657
}
1658
return true;
1659
}
1660
1661
__attribute__((nonnull, warn_unused_result))
1662
bool good_flags(const char *ifname, const struct ifreq *ifr){
1663
1664
/* Reject the loopback device */
1665
if(ifr->ifr_flags & IFF_LOOPBACK){
1666
if(debug){
1667
fprintf_plus(stderr, "Rejecting loopback interface \"%s\"\n",
1668
ifname);
1669
}
1670
return false;
1671
}
1672
/* Accept point-to-point devices only if connect_to is specified */
1673
if(connect_to != NULL and (ifr->ifr_flags & IFF_POINTOPOINT)){
1674
if(debug){
1675
fprintf_plus(stderr, "Accepting point-to-point interface"
1676
" \"%s\"\n", ifname);
1677
}
1678
return true;
1679
}
1680
/* Otherwise, reject non-broadcast-capable devices */
1681
if(not (ifr->ifr_flags & IFF_BROADCAST)){
1682
if(debug){
1683
fprintf_plus(stderr, "Rejecting non-broadcast interface"
1684
" \"%s\"\n", ifname);
1685
}
1686
return false;
1687
}
1688
/* Reject non-ARP interfaces (including dummy interfaces) */
1689
if(ifr->ifr_flags & IFF_NOARP){
1690
if(debug){
1691
fprintf_plus(stderr, "Rejecting non-ARP interface \"%s\"\n",
1692
ifname);
1693
}
1694
return false;
1695
}
1696
1697
/* Accept this device */
1698
if(debug){
1699
fprintf_plus(stderr, "Interface \"%s\" is good\n", ifname);
1700
}
1701
return true;
1702
}
1703
1704
/*
1705
* This function determines if a directory entry in /sys/class/net
1706
* corresponds to an acceptable network device.
1707
* (This function is passed to scandir(3) as a filter function.)
1708
*/
1709
__attribute__((nonnull, warn_unused_result))
1710
int good_interface(const struct dirent *if_entry){
1711
if(if_entry->d_name[0] == '.'){
1712
return 0;
1713
}
1714
1715
struct ifreq ifr;
1716
if(not get_flags(if_entry->d_name, &ifr)){
1717
if(debug){
1718
fprintf_plus(stderr, "Failed to get flags for interface "
1719
"\"%s\"\n", if_entry->d_name);
1720
}
1721
return 0;
1722
}
1723
1724
if(not good_flags(if_entry->d_name, &ifr)){
1725
return 0;
1726
}
1727
return 1;
1728
}
1729
1730
/*
1731
* This function determines if a network interface is up.
1732
*/
1733
__attribute__((nonnull, warn_unused_result))
1734
bool interface_is_up(const char *interface){
1735
struct ifreq ifr;
1736
if(not get_flags(interface, &ifr)){
1737
if(debug){
1738
fprintf_plus(stderr, "Failed to get flags for interface "
1739
"\"%s\"\n", interface);
1740
}
1741
return false;
1742
}
1743
1744
return (bool)(ifr.ifr_flags & IFF_UP);
1745
}
1746
1747
/*
1748
* This function determines if a network interface is running
1749
*/
1750
__attribute__((nonnull, warn_unused_result))
1751
bool interface_is_running(const char *interface){
1752
struct ifreq ifr;
1753
if(not get_flags(interface, &ifr)){
1754
if(debug){
1755
fprintf_plus(stderr, "Failed to get flags for interface "
1756
"\"%s\"\n", interface);
1757
}
1758
return false;
1759
}
1760
1761
return (bool)(ifr.ifr_flags & IFF_RUNNING);
1762
}
1763
1764
__attribute__((nonnull, pure, warn_unused_result))
1765
int notdotentries(const struct dirent *direntry){
1766
/* Skip "." and ".." */
1767
if(direntry->d_name[0] == '.'
1768
and (direntry->d_name[1] == '\0'
1769
or (direntry->d_name[1] == '.'
1770
and direntry->d_name[2] == '\0'))){
1771
return 0;
1772
}
1773
return 1;
1774
}
1775
1776
/* Is this directory entry a runnable program? */
1777
__attribute__((nonnull, warn_unused_result))
1778
int runnable_hook(const struct dirent *direntry){
1779
int ret;
1780
size_t sret;
1781
struct stat st;
1782
1783
if((direntry->d_name)[0] == '\0'){
1784
/* Empty name? */
1785
return 0;
1786
}
1787
1788
sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1789
"abcdefghijklmnopqrstuvwxyz"
1790
"0123456789"
1791
"_.-");
1792
if((direntry->d_name)[sret] != '\0'){
1793
/* Contains non-allowed characters */
1794
if(debug){
1795
fprintf_plus(stderr, "Ignoring hook \"%s\" with bad name\n",
1796
direntry->d_name);
1797
}
1798
return 0;
1799
}
1800
1801
ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1802
if(ret == -1){
1803
if(debug){
1804
perror_plus("Could not stat hook");
1805
}
1806
return 0;
1807
}
1808
if(not (S_ISREG(st.st_mode))){
1809
/* Not a regular file */
1810
if(debug){
1811
fprintf_plus(stderr, "Ignoring hook \"%s\" - not a file\n",
1812
direntry->d_name);
1813
}
1814
return 0;
1815
}
1816
if(not (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))){
1817
/* Not executable */
1818
if(debug){
1819
fprintf_plus(stderr, "Ignoring hook \"%s\" - not executable\n",
1820
direntry->d_name);
1821
}
1822
return 0;
1823
}
1824
if(debug){
1825
fprintf_plus(stderr, "Hook \"%s\" is acceptable\n",
1826
direntry->d_name);
1827
}
1828
return 1;
1829
}
1830
1831
__attribute__((nonnull, warn_unused_result))
1832
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
1833
mandos_context *mc){
1834
int ret;
1835
struct timespec now;
1836
struct timespec waited_time;
1837
intmax_t block_time;
1838
1839
while(true){
1840
if(mc->current_server == NULL){
1841
if(debug){
1842
fprintf_plus(stderr, "Wait until first server is found."
1843
" No timeout!\n");
1844
}
1845
ret = avahi_simple_poll_iterate(s, -1);
1846
} else {
1847
if(debug){
1848
fprintf_plus(stderr, "Check current_server if we should run"
1849
" it, or wait\n");
1850
}
1851
/* the current time */
1852
ret = clock_gettime(CLOCK_MONOTONIC, &now);
1853
if(ret == -1){
1854
perror_plus("clock_gettime");
1855
return -1;
1856
}
1857
/* Calculating in ms how long time between now and server
1858
who we visted longest time ago. Now - last seen. */
1859
waited_time.tv_sec = (now.tv_sec
1860
- mc->current_server->last_seen.tv_sec);
1861
waited_time.tv_nsec = (now.tv_nsec
1862
- mc->current_server->last_seen.tv_nsec);
1863
/* total time is 10s/10,000ms.
1864
Converting to s from ms by dividing by 1,000,
1865
and ns to ms by dividing by 1,000,000. */
1866
block_time = ((retry_interval
1867
- ((intmax_t)waited_time.tv_sec * 1000))
1868
- ((intmax_t)waited_time.tv_nsec / 1000000));
1869
1870
if(debug){
1871
fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1872
block_time);
1873
}
1874
1875
if(block_time <= 0){
1876
ret = start_mandos_communication(mc->current_server->ip,
1877
mc->current_server->port,
1878
mc->current_server->if_index,
1879
mc->current_server->af, mc);
1880
if(ret == 0){
1881
avahi_simple_poll_quit(s);
1882
return 0;
1883
}
1884
ret = clock_gettime(CLOCK_MONOTONIC,
1885
&mc->current_server->last_seen);
1886
if(ret == -1){
1887
perror_plus("clock_gettime");
1888
return -1;
1889
}
1890
mc->current_server = mc->current_server->next;
1891
block_time = 0; /* Call avahi to find new Mandos
1892
servers, but don't block */
1893
}
1894
1895
ret = avahi_simple_poll_iterate(s, (int)block_time);
1896
}
1897
if(ret != 0){
1898
if(ret > 0 or errno != EINTR){
1899
return (ret != 1) ? ret : 0;
1900
}
1901
}
1902
}
1903
}
1904
1905
__attribute__((nonnull))
1906
void run_network_hooks(const char *mode, const char *interface,
1907
const float delay){
1908
struct dirent **direntries = NULL;
1909
if(hookdir_fd == -1){
1910
hookdir_fd = open(hookdir, O_RDONLY | O_DIRECTORY | O_PATH
1911
| O_CLOEXEC);
1912
if(hookdir_fd == -1){
1913
if(errno == ENOENT){
1914
if(debug){
1915
fprintf_plus(stderr, "Network hook directory \"%s\" not"
1916
" found\n", hookdir);
1917
}
1918
} else {
1919
perror_plus("open");
1920
}
1921
return;
1922
}
1923
}
1924
int numhooks = scandirat(hookdir_fd, ".", &direntries,
1925
runnable_hook, alphasort);
1926
if(numhooks == -1){
1927
perror_plus("scandir");
1928
return;
1929
}
1930
struct dirent *direntry;
1931
int ret;
1932
int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
1933
if(devnull == -1){
1934
perror_plus("open(\"/dev/null\", O_RDONLY)");
1935
return;
1936
}
1937
for(int i = 0; i < numhooks; i++){
1938
direntry = direntries[i];
1939
if(debug){
1940
fprintf_plus(stderr, "Running network hook \"%s\"\n",
1941
direntry->d_name);
1942
}
1943
pid_t hook_pid = fork();
1944
if(hook_pid == 0){
1945
/* Child */
1946
/* Raise privileges */
1947
errno = raise_privileges_permanently();
1948
if(errno != 0){
1949
perror_plus("Failed to raise privileges");
1950
_exit(EX_NOPERM);
1951
}
1952
/* Set group */
1953
errno = 0;
1954
ret = setgid(0);
1955
if(ret == -1){
1956
perror_plus("setgid");
1957
_exit(EX_NOPERM);
1958
}
1959
/* Reset supplementary groups */
1960
errno = 0;
1961
ret = setgroups(0, NULL);
1962
if(ret == -1){
1963
perror_plus("setgroups");
1964
_exit(EX_NOPERM);
1965
}
1966
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1967
if(ret == -1){
1968
perror_plus("setenv");
1969
_exit(EX_OSERR);
1970
}
1971
ret = setenv("DEVICE", interface, 1);
1972
if(ret == -1){
1973
perror_plus("setenv");
1974
_exit(EX_OSERR);
1975
}
1976
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
1977
if(ret == -1){
1978
perror_plus("setenv");
1979
_exit(EX_OSERR);
1980
}
1981
ret = setenv("MODE", mode, 1);
1982
if(ret == -1){
1983
perror_plus("setenv");
1984
_exit(EX_OSERR);
1985
}
1986
char *delaystring;
1987
ret = asprintf(&delaystring, "%f", (double)delay);
1988
if(ret == -1){
1989
perror_plus("asprintf");
1990
_exit(EX_OSERR);
1991
}
1992
ret = setenv("DELAY", delaystring, 1);
1993
if(ret == -1){
1994
free(delaystring);
1995
perror_plus("setenv");
1996
_exit(EX_OSERR);
1997
}
1998
free(delaystring);
1999
if(connect_to != NULL){
2000
ret = setenv("CONNECT", connect_to, 1);
2001
if(ret == -1){
2002
perror_plus("setenv");
2003
_exit(EX_OSERR);
2004
}
2005
}
2006
int hook_fd = (int)TEMP_FAILURE_RETRY(openat(hookdir_fd,
2007
direntry->d_name,
2008
O_RDONLY));
2009
if(hook_fd == -1){
2010
perror_plus("openat");
2011
_exit(EXIT_FAILURE);
2012
}
2013
if(close(hookdir_fd) == -1){
2014
perror_plus("close");
2015
_exit(EXIT_FAILURE);
2016
}
2017
ret = dup2(devnull, STDIN_FILENO);
2018
if(ret == -1){
2019
perror_plus("dup2(devnull, STDIN_FILENO)");
2020
_exit(EX_OSERR);
2021
}
2022
ret = close(devnull);
2023
if(ret == -1){
2024
perror_plus("close");
2025
_exit(EX_OSERR);
2026
}
2027
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
2028
if(ret == -1){
2029
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
2030
_exit(EX_OSERR);
2031
}
2032
if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
2033
environ) == -1){
2034
perror_plus("fexecve");
2035
_exit(EXIT_FAILURE);
2036
}
2037
} else {
2038
if(hook_pid == -1){
2039
perror_plus("fork");
2040
free(direntry);
2041
continue;
2042
}
2043
int status;
2044
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
2045
perror_plus("waitpid");
2046
free(direntry);
2047
continue;
2048
}
2049
if(WIFEXITED(status)){
2050
if(WEXITSTATUS(status) != 0){
2051
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
2052
" with status %d\n", direntry->d_name,
2053
WEXITSTATUS(status));
2054
free(direntry);
2055
continue;
2056
}
2057
} else if(WIFSIGNALED(status)){
2058
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
2059
" signal %d\n", direntry->d_name,
2060
WTERMSIG(status));
2061
free(direntry);
2062
continue;
2063
} else {
2064
fprintf_plus(stderr, "Warning: network hook \"%s\""
2065
" crashed\n", direntry->d_name);
2066
free(direntry);
2067
continue;
2068
}
2069
}
2070
if(debug){
2071
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
2072
direntry->d_name);
2073
}
2074
free(direntry);
2075
}
2076
free(direntries);
2077
if(close(hookdir_fd) == -1){
2078
perror_plus("close");
2079
} else {
2080
hookdir_fd = -1;
2081
}
2082
close(devnull);
2083
}
2084
2085
__attribute__((nonnull, warn_unused_result))
2086
int bring_up_interface(const char *const interface,
2087
const float delay){
2088
int old_errno = errno;
2089
int ret;
2090
struct ifreq network;
2091
unsigned int if_index = if_nametoindex(interface);
2092
if(if_index == 0){
2093
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
2094
errno = old_errno;
2095
return ENXIO;
2096
}
2097
2098
if(quit_now){
2099
errno = old_errno;
2100
return EINTR;
2101
}
2102
2103
if(not interface_is_up(interface)){
2104
int ret_errno = 0;
2105
int ioctl_errno = 0;
2106
if(not get_flags(interface, &network)){
2107
ret_errno = errno;
2108
fprintf_plus(stderr, "Failed to get flags for interface "
2109
"\"%s\"\n", interface);
2110
errno = old_errno;
2111
return ret_errno;
2112
}
2113
network.ifr_flags |= IFF_UP; /* set flag */
2114
2115
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
2116
if(sd == -1){
2117
ret_errno = errno;
2118
perror_plus("socket");
2119
errno = old_errno;
2120
return ret_errno;
2121
}
2122
2123
if(quit_now){
2124
ret = close(sd);
2125
if(ret == -1){
2126
perror_plus("close");
2127
}
2128
errno = old_errno;
2129
return EINTR;
2130
}
2131
2132
if(debug){
2133
fprintf_plus(stderr, "Bringing up interface \"%s\"\n",
2134
interface);
2135
}
2136
2137
/* Raise privileges */
2138
ret_errno = raise_privileges();
2139
if(ret_errno != 0){
2140
errno = ret_errno;
2141
perror_plus("Failed to raise privileges");
2142
}
2143
2144
#ifdef __linux__
2145
int ret_linux;
2146
bool restore_loglevel = false;
2147
if(ret_errno == 0){
2148
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
2149
messages about the network interface to mess up the prompt */
2150
ret_linux = klogctl(8, NULL, 5);
2151
if(ret_linux == -1){
2152
perror_plus("klogctl");
2153
} else {
2154
restore_loglevel = true;
2155
}
2156
}
2157
#endif /* __linux__ */
2158
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
2159
ioctl_errno = errno;
2160
#ifdef __linux__
2161
if(restore_loglevel){
2162
ret_linux = klogctl(7, NULL, 0);
2163
if(ret_linux == -1){
2164
perror_plus("klogctl");
2165
}
2166
}
2167
#endif /* __linux__ */
2168
2169
/* If raise_privileges() succeeded above */
2170
if(ret_errno == 0){
2171
/* Lower privileges */
2172
ret_errno = lower_privileges();
2173
if(ret_errno != 0){
2174
errno = ret_errno;
2175
perror_plus("Failed to lower privileges");
2176
}
2177
}
2178
2179
/* Close the socket */
2180
ret = close(sd);
2181
if(ret == -1){
2182
perror_plus("close");
2183
}
2184
2185
if(ret_setflags == -1){
2186
errno = ioctl_errno;
2187
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
2188
errno = old_errno;
2189
return ioctl_errno;
2190
}
2191
} else if(debug){
2192
fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
2193
interface);
2194
}
2195
2196
/* Sleep checking until interface is running.
2197
Check every 0.25s, up to total time of delay */
2198
for(int i=0; i < delay * 4; i++){
2199
if(interface_is_running(interface)){
2200
break;
2201
}
2202
struct timespec sleeptime = { .tv_nsec = 250000000 };
2203
ret = nanosleep(&sleeptime, NULL);
2204
if(ret == -1 and errno != EINTR){
2205
perror_plus("nanosleep");
2206
}
2207
}
2208
2209
errno = old_errno;
2210
return 0;
2211
}
2212
2213
__attribute__((nonnull, warn_unused_result))
2214
int take_down_interface(const char *const interface){
2215
int old_errno = errno;
2216
struct ifreq network;
2217
unsigned int if_index = if_nametoindex(interface);
2218
if(if_index == 0){
2219
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
2220
errno = old_errno;
2221
return ENXIO;
2222
}
2223
if(interface_is_up(interface)){
2224
int ret_errno = 0;
2225
int ioctl_errno = 0;
2226
if(not get_flags(interface, &network) and debug){
2227
ret_errno = errno;
2228
fprintf_plus(stderr, "Failed to get flags for interface "
2229
"\"%s\"\n", interface);
2230
errno = old_errno;
2231
return ret_errno;
2232
}
2233
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
2234
2235
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
2236
if(sd == -1){
2237
ret_errno = errno;
2238
perror_plus("socket");
2239
errno = old_errno;
2240
return ret_errno;
2241
}
2242
2243
if(debug){
2244
fprintf_plus(stderr, "Taking down interface \"%s\"\n",
2245
interface);
2246
}
2247
2248
/* Raise privileges */
2249
ret_errno = raise_privileges();
2250
if(ret_errno != 0){
2251
errno = ret_errno;
2252
perror_plus("Failed to raise privileges");
2253
}
2254
2255
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
2256
ioctl_errno = errno;
2257
2258
/* If raise_privileges() succeeded above */
2259
if(ret_errno == 0){
2260
/* Lower privileges */
2261
ret_errno = lower_privileges();
2262
if(ret_errno != 0){
2263
errno = ret_errno;
2264
perror_plus("Failed to lower privileges");
2265
}
2266
}
2267
2268
/* Close the socket */
2269
int ret = close(sd);
2270
if(ret == -1){
2271
perror_plus("close");
2272
}
2273
2274
if(ret_setflags == -1){
2275
errno = ioctl_errno;
2276
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
2277
errno = old_errno;
2278
return ioctl_errno;
2279
}
2280
} else if(debug){
2281
fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
2282
interface);
2283
}
2284
2285
errno = old_errno;
2286
return 0;
2287
}
2288
2289
int main(int argc, char *argv[]){
2290
mandos_context mc = { .server = NULL, .dh_bits = 0,
2291
.priority = "SECURE256:!CTYPE-X.509"
2292
":+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256",
2293
.current_server = NULL, .interfaces = NULL,
2294
.interfaces_size = 0 };
2295
AvahiSServiceBrowser *sb = NULL;
2296
error_t ret_errno;
2297
int ret;
2298
intmax_t tmpmax;
2299
char *tmp;
2300
int exitcode = EXIT_SUCCESS;
2301
char *interfaces_to_take_down = NULL;
2302
size_t interfaces_to_take_down_size = 0;
2303
char run_tempdir[] = "/run/tmp/mandosXXXXXX";
2304
char old_tempdir[] = "/tmp/mandosXXXXXX";
2305
char *tempdir = NULL;
2306
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
2307
const char *seckey = PATHDIR "/" SECKEY;
2308
const char *pubkey = PATHDIR "/" PUBKEY;
2309
const char *dh_params_file = NULL;
2310
char *interfaces_hooks = NULL;
2311
2312
bool gnutls_initialized = false;
2313
bool gpgme_initialized = false;
2314
float delay = 2.5f;
2315
double retry_interval = 10; /* 10s between trying a server and
2316
retrying the same server again */
2317
2318
struct sigaction old_sigterm_action = { .sa_handler = SIG_DFL };
2319
struct sigaction sigterm_action = { .sa_handler = handle_sigterm };
2320
2321
uid = getuid();
2322
gid = getgid();
2323
2324
/* Lower any group privileges we might have, just to be safe */
2325
errno = 0;
2326
ret = setgid(gid);
2327
if(ret == -1){
2328
perror_plus("setgid");
2329
}
2330
2331
/* Lower user privileges (temporarily) */
2332
errno = 0;
2333
ret = seteuid(uid);
2334
if(ret == -1){
2335
perror_plus("seteuid");
2336
}
2337
2338
if(quit_now){
2339
goto end;
2340
}
2341
2342
{
2343
struct argp_option options[] = {
2344
{ .name = "debug", .key = 128,
2345
.doc = "Debug mode", .group = 3 },
2346
{ .name = "connect", .key = 'c',
2347
.arg = "ADDRESS:PORT",
2348
.doc = "Connect directly to a specific Mandos server",
2349
.group = 1 },
2350
{ .name = "interface", .key = 'i',
2351
.arg = "NAME",
2352
.doc = "Network interface that will be used to search for"
2353
" Mandos servers",
2354
.group = 1 },
2355
{ .name = "seckey", .key = 's',
2356
.arg = "FILE",
2357
.doc = "OpenPGP secret key file base name",
2358
.group = 1 },
2359
{ .name = "pubkey", .key = 'p',
2360
.arg = "FILE",
2361
.doc = "OpenPGP public key file base name",
2362
.group = 2 },
2363
{ .name = "dh-bits", .key = 129,
2364
.arg = "BITS",
2365
.doc = "Bit length of the prime number used in the"
2366
" Diffie-Hellman key exchange",
2367
.group = 2 },
2368
{ .name = "dh-params", .key = 134,
2369
.arg = "FILE",
2370
.doc = "PEM-encoded PKCS#3 file with pre-generated parameters"
2371
" for the Diffie-Hellman key exchange",
2372
.group = 2 },
2373
{ .name = "priority", .key = 130,
2374
.arg = "STRING",
2375
.doc = "GnuTLS priority string for the TLS handshake",
2376
.group = 1 },
2377
{ .name = "delay", .key = 131,
2378
.arg = "SECONDS",
2379
.doc = "Maximum delay to wait for interface startup",
2380
.group = 2 },
2381
{ .name = "retry", .key = 132,
2382
.arg = "SECONDS",
2383
.doc = "Retry interval used when denied by the Mandos server",
2384
.group = 2 },
2385
{ .name = "network-hook-dir", .key = 133,
2386
.arg = "DIR",
2387
.doc = "Directory where network hooks are located",
2388
.group = 2 },
2389
/*
2390
* These reproduce what we would get without ARGP_NO_HELP
2391
*/
2392
{ .name = "help", .key = '?',
2393
.doc = "Give this help list", .group = -1 },
2394
{ .name = "usage", .key = -3,
2395
.doc = "Give a short usage message", .group = -1 },
2396
{ .name = "version", .key = 'V',
2397
.doc = "Print program version", .group = -1 },
2398
{ .name = NULL }
2399
};
2400
2401
error_t parse_opt(int key, char *arg,
2402
struct argp_state *state){
2403
errno = 0;
2404
switch(key){
2405
case 128: /* --debug */
2406
debug = true;
2407
break;
2408
case 'c': /* --connect */
2409
connect_to = arg;
2410
break;
2411
case 'i': /* --interface */
2412
ret_errno = argz_add_sep(&mc.interfaces, &mc.interfaces_size,
2413
arg, (int)',');
2414
if(ret_errno != 0){
2415
argp_error(state, "%s", strerror(ret_errno));
2416
}
2417
break;
2418
case 's': /* --seckey */
2419
seckey = arg;
2420
break;
2421
case 'p': /* --pubkey */
2422
pubkey = arg;
2423
break;
2424
case 129: /* --dh-bits */
2425
errno = 0;
2426
tmpmax = strtoimax(arg, &tmp, 10);
2427
if(errno != 0 or tmp == arg or *tmp != '\0'
2428
or tmpmax != (typeof(mc.dh_bits))tmpmax){
2429
argp_error(state, "Bad number of DH bits");
2430
}
2431
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
2432
break;
2433
case 134: /* --dh-params */
2434
dh_params_file = arg;
2435
break;
2436
case 130: /* --priority */
2437
mc.priority = arg;
2438
break;
2439
case 131: /* --delay */
2440
errno = 0;
2441
delay = strtof(arg, &tmp);
2442
if(errno != 0 or tmp == arg or *tmp != '\0'){
2443
argp_error(state, "Bad delay");
2444
}
2445
case 132: /* --retry */
2446
errno = 0;
2447
retry_interval = strtod(arg, &tmp);
2448
if(errno != 0 or tmp == arg or *tmp != '\0'
2449
or (retry_interval * 1000) > INT_MAX
2450
or retry_interval < 0){
2451
argp_error(state, "Bad retry interval");
2452
}
2453
break;
2454
case 133: /* --network-hook-dir */
2455
hookdir = arg;
2456
break;
2457
/*
2458
* These reproduce what we would get without ARGP_NO_HELP
2459
*/
2460
case '?': /* --help */
2461
argp_state_help(state, state->out_stream,
2462
(ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
2463
& ~(unsigned int)ARGP_HELP_EXIT_OK);
2464
case -3: /* --usage */
2465
argp_state_help(state, state->out_stream,
2466
ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
2467
case 'V': /* --version */
2468
fprintf_plus(state->out_stream, "%s\n", argp_program_version);
2469
exit(argp_err_exit_status);
2470
break;
2471
default:
2472
return ARGP_ERR_UNKNOWN;
2473
}
2474
return errno;
2475
}
2476
2477
struct argp argp = { .options = options, .parser = parse_opt,
2478
.args_doc = "",
2479
.doc = "Mandos client -- Get and decrypt"
2480
" passwords from a Mandos server" };
2481
ret_errno = argp_parse(&argp, argc, argv,
2482
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2483
switch(ret_errno){
2484
case 0:
2485
break;
2486
case ENOMEM:
2487
default:
2488
errno = ret_errno;
2489
perror_plus("argp_parse");
2490
exitcode = EX_OSERR;
2491
goto end;
2492
case EINVAL:
2493
exitcode = EX_USAGE;
2494
goto end;
2495
}
2496
}
2497
2498
{
2499
/* Work around Debian bug #633582:
2500
<https://bugs.debian.org/633582> */
2501
2502
/* Re-raise privileges */
2503
ret = raise_privileges();
2504
if(ret != 0){
2505
errno = ret;
2506
perror_plus("Failed to raise privileges");
2507
} else {
2508
struct stat st;
2509
2510
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
2511
int seckey_fd = open(seckey, O_RDONLY);
2512
if(seckey_fd == -1){
2513
perror_plus("open");
2514
} else {
2515
ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
2516
if(ret == -1){
2517
perror_plus("fstat");
2518
} else {
2519
if(S_ISREG(st.st_mode)
2520
and st.st_uid == 0 and st.st_gid == 0){
2521
ret = fchown(seckey_fd, uid, gid);
2522
if(ret == -1){
2523
perror_plus("fchown");
2524
}
2525
}
2526
}
2527
close(seckey_fd);
2528
}
2529
}
2530
2531
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2532
int pubkey_fd = open(pubkey, O_RDONLY);
2533
if(pubkey_fd == -1){
2534
perror_plus("open");
2535
} else {
2536
ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
2537
if(ret == -1){
2538
perror_plus("fstat");
2539
} else {
2540
if(S_ISREG(st.st_mode)
2541
and st.st_uid == 0 and st.st_gid == 0){
2542
ret = fchown(pubkey_fd, uid, gid);
2543
if(ret == -1){
2544
perror_plus("fchown");
2545
}
2546
}
2547
}
2548
close(pubkey_fd);
2549
}
2550
}
2551
2552
if(dh_params_file != NULL
2553
and strcmp(dh_params_file, PATHDIR "/dhparams.pem" ) == 0){
2554
int dhparams_fd = open(dh_params_file, O_RDONLY);
2555
if(dhparams_fd == -1){
2556
perror_plus("open");
2557
} else {
2558
ret = (int)TEMP_FAILURE_RETRY(fstat(dhparams_fd, &st));
2559
if(ret == -1){
2560
perror_plus("fstat");
2561
} else {
2562
if(S_ISREG(st.st_mode)
2563
and st.st_uid == 0 and st.st_gid == 0){
2564
ret = fchown(dhparams_fd, uid, gid);
2565
if(ret == -1){
2566
perror_plus("fchown");
2567
}
2568
}
2569
}
2570
close(dhparams_fd);
2571
}
2572
}
2573
2574
/* Lower privileges */
2575
ret = lower_privileges();
2576
if(ret != 0){
2577
errno = ret;
2578
perror_plus("Failed to lower privileges");
2579
}
2580
}
2581
}
2582
2583
/* Remove invalid interface names (except "none") */
2584
{
2585
char *interface = NULL;
2586
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2587
interface))){
2588
if(strcmp(interface, "none") != 0
2589
and if_nametoindex(interface) == 0){
2590
if(interface[0] != '\0'){
2591
fprintf_plus(stderr, "Not using nonexisting interface"
2592
" \"%s\"\n", interface);
2593
}
2594
argz_delete(&mc.interfaces, &mc.interfaces_size, interface);
2595
interface = NULL;
2596
}
2597
}
2598
}
2599
2600
/* Run network hooks */
2601
{
2602
if(mc.interfaces != NULL){
2603
interfaces_hooks = malloc(mc.interfaces_size);
2604
if(interfaces_hooks == NULL){
2605
perror_plus("malloc");
2606
goto end;
2607
}
2608
memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
2609
argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
2610
}
2611
run_network_hooks("start", interfaces_hooks != NULL ?
2612
interfaces_hooks : "", delay);
2613
}
2614
2615
if(not debug){
2616
avahi_set_log_function(empty_log);
2617
}
2618
2619
/* Initialize Avahi early so avahi_simple_poll_quit() can be called
2620
from the signal handler */
2621
/* Initialize the pseudo-RNG for Avahi */
2622
srand((unsigned int) time(NULL));
2623
simple_poll = avahi_simple_poll_new();
2624
if(simple_poll == NULL){
2625
fprintf_plus(stderr,
2626
"Avahi: Failed to create simple poll object.\n");
2627
exitcode = EX_UNAVAILABLE;
2628
goto end;
2629
}
2630
2631
sigemptyset(&sigterm_action.sa_mask);
2632
ret = sigaddset(&sigterm_action.sa_mask, SIGINT);
2633
if(ret == -1){
2634
perror_plus("sigaddset");
2635
exitcode = EX_OSERR;
2636
goto end;
2637
}
2638
ret = sigaddset(&sigterm_action.sa_mask, SIGHUP);
2639
if(ret == -1){
2640
perror_plus("sigaddset");
2641
exitcode = EX_OSERR;
2642
goto end;
2643
}
2644
ret = sigaddset(&sigterm_action.sa_mask, SIGTERM);
2645
if(ret == -1){
2646
perror_plus("sigaddset");
2647
exitcode = EX_OSERR;
2648
goto end;
2649
}
2650
/* Need to check if the handler is SIG_IGN before handling:
2651
| [[info:libc:Initial Signal Actions]] |
2652
| [[info:libc:Basic Signal Handling]] |
2653
*/
2654
ret = sigaction(SIGINT, NULL, &old_sigterm_action);
2655
if(ret == -1){
2656
perror_plus("sigaction");
2657
return EX_OSERR;
2658
}
2659
if(old_sigterm_action.sa_handler != SIG_IGN){
2660
ret = sigaction(SIGINT, &sigterm_action, NULL);
2661
if(ret == -1){
2662
perror_plus("sigaction");
2663
exitcode = EX_OSERR;
2664
goto end;
2665
}
2666
}
2667
ret = sigaction(SIGHUP, NULL, &old_sigterm_action);
2668
if(ret == -1){
2669
perror_plus("sigaction");
2670
return EX_OSERR;
2671
}
2672
if(old_sigterm_action.sa_handler != SIG_IGN){
2673
ret = sigaction(SIGHUP, &sigterm_action, NULL);
2674
if(ret == -1){
2675
perror_plus("sigaction");
2676
exitcode = EX_OSERR;
2677
goto end;
2678
}
2679
}
2680
ret = sigaction(SIGTERM, NULL, &old_sigterm_action);
2681
if(ret == -1){
2682
perror_plus("sigaction");
2683
return EX_OSERR;
2684
}
2685
if(old_sigterm_action.sa_handler != SIG_IGN){
2686
ret = sigaction(SIGTERM, &sigterm_action, NULL);
2687
if(ret == -1){
2688
perror_plus("sigaction");
2689
exitcode = EX_OSERR;
2690
goto end;
2691
}
2692
}
2693
2694
/* If no interfaces were specified, make a list */
2695
if(mc.interfaces == NULL){
2696
struct dirent **direntries = NULL;
2697
/* Look for any good interfaces */
2698
ret = scandir(sys_class_net, &direntries, good_interface,
2699
alphasort);
2700
if(ret >= 1){
2701
/* Add all found interfaces to interfaces list */
2702
for(int i = 0; i < ret; ++i){
2703
ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
2704
direntries[i]->d_name);
2705
if(ret_errno != 0){
2706
errno = ret_errno;
2707
perror_plus("argz_add");
2708
free(direntries[i]);
2709
continue;
2710
}
2711
if(debug){
2712
fprintf_plus(stderr, "Will use interface \"%s\"\n",
2713
direntries[i]->d_name);
2714
}
2715
free(direntries[i]);
2716
}
2717
free(direntries);
2718
} else {
2719
if(ret == 0){
2720
free(direntries);
2721
}
2722
fprintf_plus(stderr, "Could not find a network interface\n");
2723
exitcode = EXIT_FAILURE;
2724
goto end;
2725
}
2726
}
2727
2728
/* Bring up interfaces which are down, and remove any "none"s */
2729
{
2730
char *interface = NULL;
2731
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2732
interface))){
2733
/* If interface name is "none", stop bringing up interfaces.
2734
Also remove all instances of "none" from the list */
2735
if(strcmp(interface, "none") == 0){
2736
argz_delete(&mc.interfaces, &mc.interfaces_size,
2737
interface);
2738
interface = NULL;
2739
while((interface = argz_next(mc.interfaces,
2740
mc.interfaces_size, interface))){
2741
if(strcmp(interface, "none") == 0){
2742
argz_delete(&mc.interfaces, &mc.interfaces_size,
2743
interface);
2744
interface = NULL;
2745
}
2746
}
2747
break;
2748
}
2749
bool interface_was_up = interface_is_up(interface);
2750
errno = bring_up_interface(interface, delay);
2751
if(not interface_was_up){
2752
if(errno != 0){
2753
fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
2754
" %s\n", interface, strerror(errno));
2755
} else {
2756
errno = argz_add(&interfaces_to_take_down,
2757
&interfaces_to_take_down_size,
2758
interface);
2759
if(errno != 0){
2760
perror_plus("argz_add");
2761
}
2762
}
2763
}
2764
}
2765
if(debug and (interfaces_to_take_down == NULL)){
2766
fprintf_plus(stderr, "No interfaces were brought up\n");
2767
}
2768
}
2769
2770
/* If we only got one interface, explicitly use only that one */
2771
if(argz_count(mc.interfaces, mc.interfaces_size) == 1){
2772
if(debug){
2773
fprintf_plus(stderr, "Using only interface \"%s\"\n",
2774
mc.interfaces);
2775
}
2776
if_index = (AvahiIfIndex)if_nametoindex(mc.interfaces);
2777
}
2778
2779
if(quit_now){
2780
goto end;
2781
}
2782
2783
ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
2784
if(ret == -1){
2785
fprintf_plus(stderr, "init_gnutls_global failed\n");
2786
exitcode = EX_UNAVAILABLE;
2787
goto end;
2788
} else {
2789
gnutls_initialized = true;
2790
}
2791
2792
if(quit_now){
2793
goto end;
2794
}
2795
2796
/* Try /run/tmp before /tmp */
2797
tempdir = mkdtemp(run_tempdir);
2798
if(tempdir == NULL and errno == ENOENT){
2799
if(debug){
2800
fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
2801
run_tempdir, old_tempdir);
2802
}
2803
tempdir = mkdtemp(old_tempdir);
2804
}
2805
if(tempdir == NULL){
2806
perror_plus("mkdtemp");
2807
goto end;
2808
}
2809
2810
if(quit_now){
2811
goto end;
2812
}
2813
2814
if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
2815
fprintf_plus(stderr, "init_gpgme failed\n");
2816
exitcode = EX_UNAVAILABLE;
2817
goto end;
2818
} else {
2819
gpgme_initialized = true;
2820
}
2821
2822
if(quit_now){
2823
goto end;
2824
}
2825
2826
if(connect_to != NULL){
2827
/* Connect directly, do not use Zeroconf */
2828
/* (Mainly meant for debugging) */
2829
char *address = strrchr(connect_to, ':');
2830
2831
if(address == NULL){
2832
fprintf_plus(stderr, "No colon in address\n");
2833
exitcode = EX_USAGE;
2834
goto end;
2835
}
2836
2837
if(quit_now){
2838
goto end;
2839
}
2840
2841
in_port_t port;
2842
errno = 0;
2843
tmpmax = strtoimax(address+1, &tmp, 10);
2844
if(errno != 0 or tmp == address+1 or *tmp != '\0'
2845
or tmpmax != (in_port_t)tmpmax){
2846
fprintf_plus(stderr, "Bad port number\n");
2847
exitcode = EX_USAGE;
2848
goto end;
2849
}
2850
2851
if(quit_now){
2852
goto end;
2853
}
2854
2855
port = (in_port_t)tmpmax;
2856
*address = '\0';
2857
/* Colon in address indicates IPv6 */
2858
int af;
2859
if(strchr(connect_to, ':') != NULL){
2860
af = AF_INET6;
2861
/* Accept [] around IPv6 address - see RFC 5952 */
2862
if(connect_to[0] == '[' and address[-1] == ']')
2863
{
2864
connect_to++;
2865
address[-1] = '\0';
2866
}
2867
} else {
2868
af = AF_INET;
2869
}
2870
address = connect_to;
2871
2872
if(quit_now){
2873
goto end;
2874
}
2875
2876
while(not quit_now){
2877
ret = start_mandos_communication(address, port, if_index, af,
2878
&mc);
2879
if(quit_now or ret == 0){
2880
break;
2881
}
2882
if(debug){
2883
fprintf_plus(stderr, "Retrying in %d seconds\n",
2884
(int)retry_interval);
2885
}
2886
sleep((unsigned int)retry_interval);
2887
}
2888
2889
if(not quit_now){
2890
exitcode = EXIT_SUCCESS;
2891
}
2892
2893
goto end;
2894
}
2895
2896
if(quit_now){
2897
goto end;
2898
}
2899
2900
{
2901
AvahiServerConfig config;
2902
/* Do not publish any local Zeroconf records */
2903
avahi_server_config_init(&config);
2904
config.publish_hinfo = 0;
2905
config.publish_addresses = 0;
2906
config.publish_workstation = 0;
2907
config.publish_domain = 0;
2908
2909
/* Allocate a new server */
2910
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
2911
&config, NULL, NULL, &ret);
2912
2913
/* Free the Avahi configuration data */
2914
avahi_server_config_free(&config);
2915
}
2916
2917
/* Check if creating the Avahi server object succeeded */
2918
if(mc.server == NULL){
2919
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2920
avahi_strerror(ret));
2921
exitcode = EX_UNAVAILABLE;
2922
goto end;
2923
}
2924
2925
if(quit_now){
2926
goto end;
2927
}
2928
2929
/* Create the Avahi service browser */
2930
sb = avahi_s_service_browser_new(mc.server, if_index,
2931
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
2932
NULL, 0, browse_callback,
2933
(void *)&mc);
2934
if(sb == NULL){
2935
fprintf_plus(stderr, "Failed to create service browser: %s\n",
2936
avahi_strerror(avahi_server_errno(mc.server)));
2937
exitcode = EX_UNAVAILABLE;
2938
goto end;
2939
}
2940
2941
if(quit_now){
2942
goto end;
2943
}
2944
2945
/* Run the main loop */
2946
2947
if(debug){
2948
fprintf_plus(stderr, "Starting Avahi loop search\n");
2949
}
2950
2951
ret = avahi_loop_with_timeout(simple_poll,
2952
(int)(retry_interval * 1000), &mc);
2953
if(debug){
2954
fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
2955
(ret == 0) ? "successfully" : "with error");
2956
}
2957
2958
end:
2959
2960
if(debug){
2961
if(signal_received){
2962
fprintf_plus(stderr, "%s exiting due to signal %d: %s\n",
2963
argv[0], signal_received,
2964
strsignal(signal_received));
2965
} else {
2966
fprintf_plus(stderr, "%s exiting\n", argv[0]);
2967
}
2968
}
2969
2970
/* Cleanup things */
2971
free(mc.interfaces);
2972
2973
if(sb != NULL)
2974
avahi_s_service_browser_free(sb);
2975
2976
if(mc.server != NULL)
2977
avahi_server_free(mc.server);
2978
2979
if(simple_poll != NULL)
2980
avahi_simple_poll_free(simple_poll);
2981
2982
if(gnutls_initialized){
2983
gnutls_certificate_free_credentials(mc.cred);
2984
gnutls_dh_params_deinit(mc.dh_params);
2985
}
2986
2987
if(gpgme_initialized){
2988
gpgme_release(mc.ctx);
2989
}
2990
2991
/* Cleans up the circular linked list of Mandos servers the client
2992
has seen */
2993
if(mc.current_server != NULL){
2994
mc.current_server->prev->next = NULL;
2995
while(mc.current_server != NULL){
2996
server *next = mc.current_server->next;
2997
#ifdef __GNUC__
2998
#pragma GCC diagnostic push
2999
#pragma GCC diagnostic ignored "-Wcast-qual"
3000
#endif
3001
free((char *)(mc.current_server->ip));
3002
#ifdef __GNUC__
3003
#pragma GCC diagnostic pop
3004
#endif
3005
free(mc.current_server);
3006
mc.current_server = next;
3007
}
3008
}
3009
3010
/* Re-raise privileges */
3011
{
3012
ret = raise_privileges();
3013
if(ret != 0){
3014
errno = ret;
3015
perror_plus("Failed to raise privileges");
3016
} else {
3017
3018
/* Run network hooks */
3019
run_network_hooks("stop", interfaces_hooks != NULL ?
3020
interfaces_hooks : "", delay);
3021
3022
/* Take down the network interfaces which were brought up */
3023
{
3024
char *interface = NULL;
3025
while((interface=argz_next(interfaces_to_take_down,
3026
interfaces_to_take_down_size,
3027
interface))){
3028
ret = take_down_interface(interface);
3029
if(ret != 0){
3030
errno = ret;
3031
perror_plus("Failed to take down interface");
3032
}
3033
}
3034
if(debug and (interfaces_to_take_down == NULL)){
3035
fprintf_plus(stderr, "No interfaces needed to be taken"
3036
" down\n");
3037
}
3038
}
3039
}
3040
3041
ret = lower_privileges_permanently();
3042
if(ret != 0){
3043
errno = ret;
3044
perror_plus("Failed to lower privileges permanently");
3045
}
3046
}
3047
3048
free(interfaces_to_take_down);
3049
free(interfaces_hooks);
3050
3051
void clean_dir_at(int base, const char * const dirname,
3052
uintmax_t level){
3053
struct dirent **direntries = NULL;
3054
int dret;
3055
int dir_fd = (int)TEMP_FAILURE_RETRY(openat(base, dirname,
3056
O_RDONLY
3057
| O_NOFOLLOW
3058
| O_DIRECTORY
3059
| O_PATH));
3060
if(dir_fd == -1){
3061
perror_plus("open");
3062
}
3063
int numentries = scandirat(dir_fd, ".", &direntries,
3064
notdotentries, alphasort);
3065
if(numentries >= 0){
3066
for(int i = 0; i < numentries; i++){
3067
if(debug){
3068
fprintf_plus(stderr, "Unlinking \"%s/%s\"\n",
3069
dirname, direntries[i]->d_name);
3070
}
3071
dret = unlinkat(dir_fd, direntries[i]->d_name, 0);
3072
if(dret == -1){
3073
if(errno == EISDIR){
3074
dret = unlinkat(dir_fd, direntries[i]->d_name,
3075
AT_REMOVEDIR);
3076
}
3077
if((dret == -1) and (errno == ENOTEMPTY)
3078
and (strcmp(direntries[i]->d_name, "private-keys-v1.d")
3079
== 0) and (level == 0)){
3080
/* Recurse only in this special case */
3081
clean_dir_at(dir_fd, direntries[i]->d_name, level+1);
3082
dret = 0;
3083
}
3084
if(dret == -1){
3085
fprintf_plus(stderr, "unlink(\"%s/%s\"): %s\n", dirname,
3086
direntries[i]->d_name, strerror(errno));
3087
}
3088
}
3089
free(direntries[i]);
3090
}
3091
3092
/* need to clean even if 0 because man page doesn't specify */
3093
free(direntries);
3094
if(numentries == -1){
3095
perror_plus("scandirat");
3096
}
3097
dret = unlinkat(base, dirname, AT_REMOVEDIR);
3098
if(dret == -1 and errno != ENOENT){
3099
perror_plus("rmdir");
3100
}
3101
} else {
3102
perror_plus("scandirat");
3103
}
3104
close(dir_fd);
3105
}
3106
3107
/* Removes the GPGME temp directory and all files inside */
3108
if(tempdir != NULL){
3109
clean_dir_at(-1, tempdir, 0);
3110
}
3111
3112
if(quit_now){
3113
sigemptyset(&old_sigterm_action.sa_mask);
3114
old_sigterm_action.sa_handler = SIG_DFL;
3115
ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
3116
&old_sigterm_action,
3117
NULL));
3118
if(ret == -1){
3119
perror_plus("sigaction");
3120
}
3121
do {
3122
ret = raise(signal_received);
3123
} while(ret != 0 and errno == EINTR);
3124
if(ret != 0){
3125
perror_plus("raise");
3126
abort();
3127
}
3128
TEMP_FAILURE_RETRY(pause());
3129
}
3130
3131
return exitcode;
3132
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0