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 951
- compare with another revision
- download diff
- download tarball
- view history from revision 951
- Committer: Teddy Hogeborn
- Date: 2018-08-15 09:26:02 UTC
- Revision ID: teddy@recompile.se-20180815092602-xoyb5s6gf8376i7u
mandos-client: Set system clock if necessary
* plugins.d/mandos-client.c (init_gpgme/import_key): If the system
clock is not set, or set to january 1970, set the system clock to
the more plausible value that is the mtime of the key file. This is
required by GnuPG to be able to import the keys. (We can't pass the
--ignore-time-conflict or the --ignore-valid-from options though
GPGME.)
* plugins.d/mandos-client.c (init_gpgme/import_key): If the system
clock is not set, or set to january 1970, set the system clock to
the more plausible value that is the mtime of the key file. This is
required by GnuPG to be able to import the keys. (We can't pass the
--ignore-time-conflict or the --ignore-valid-from options though
GPGME.)
added
removed
plugins.d/mandos-client.c
9
9
* "browse_callback", and parts of "main".
10
10
*
11
11
* Everything else is
12
* Copyright © 2008-2012 Teddy Hogeborn
13
* Copyright © 2008-2012 Björn Påhlsson
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
12
* Copyright © 2008-2018 Teddy Hogeborn
13
* Copyright © 2008-2018 Björn Påhlsson
14
*
15
* This file is part of Mandos.
16
*
17
* Mandos is free software: you can redistribute it and/or modify it
18
* under the terms of the GNU General Public License as published by
19
* the Free Software Foundation, either version 3 of the License, or
20
* (at your option) any later version.
21
*
22
* Mandos is distributed in the hope that it will be useful, but
21
23
* WITHOUT ANY WARRANTY; without even the implied warranty of
22
24
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23
25
* General Public License for more details.
24
26
*
25
27
* 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
* along with Mandos. If not, see <http://www.gnu.org/licenses/>.
28
29
*
29
30
* Contact the authors at <mandos@recompile.se>.
30
31
*/
32
33
/* Needed by GPGME, specifically gpgme_data_seek() */
33
34
#ifndef _LARGEFILE_SOURCE
34
35
#define _LARGEFILE_SOURCE
35
#endif
36
#endif /* not _LARGEFILE_SOURCE */
36
37
#ifndef _FILE_OFFSET_BITS
37
38
#define _FILE_OFFSET_BITS 64
38
#endif
39
#endif /* not _FILE_OFFSET_BITS */
39
40
40
41
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
41
42
42
43
#include <stdio.h> /* fprintf(), stderr, fwrite(),
43
stdout, ferror(), remove() */
44
stdout, ferror() */
44
45
#include <stdint.h> /* uint16_t, uint32_t, intptr_t */
45
46
#include <stddef.h> /* NULL, size_t, ssize_t */
46
47
#include <stdlib.h> /* free(), EXIT_SUCCESS, srand(),
47
48
strtof(), abort() */
48
49
#include <stdbool.h> /* bool, false, true */
49
#include <string.h> /* memset(), strcmp(), strlen(),
50
strerror(), asprintf(), strcpy() */
50
#include <string.h> /* strcmp(), strlen(), strerror(),
51
asprintf(), strncpy(), strsignal()
52
*/
51
53
#include <sys/ioctl.h> /* ioctl */
52
54
#include <sys/types.h> /* socket(), inet_pton(), sockaddr,
53
55
sockaddr_in6, PF_INET6,
55
57
opendir(), DIR */
56
58
#include <sys/stat.h> /* open(), S_ISREG */
57
59
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
58
inet_pton(), connect() */
59
#include <fcntl.h> /* open() */
60
inet_pton(), connect(),
61
getnameinfo() */
62
#include <fcntl.h> /* open(), unlinkat(), AT_REMOVEDIR */
60
63
#include <dirent.h> /* opendir(), struct dirent, readdir()
61
64
*/
62
65
#include <inttypes.h> /* PRIu16, PRIdMAX, intmax_t,
63
66
strtoimax() */
64
#include <errno.h> /* perror(), errno,
67
#include <errno.h> /* perror(), errno, EINTR, EINVAL,
68
EAI_SYSTEM, ENETUNREACH,
69
EHOSTUNREACH, ECONNREFUSED, EPROTO,
70
EIO, ENOENT, ENXIO, ENOMEM, EISDIR,
71
ENOTEMPTY,
65
72
program_invocation_short_name */
66
73
#include <time.h> /* nanosleep(), time(), sleep() */
67
74
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
72
79
*/
73
80
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
74
81
getuid(), getgid(), seteuid(),
75
setgid(), pause(), _exit() */
76
#include <arpa/inet.h> /* inet_pton(), htons, inet_ntop() */
82
setgid(), pause(), _exit(),
83
unlinkat() */
84
#include <arpa/inet.h> /* inet_pton(), htons() */
77
85
#include <iso646.h> /* not, or, and */
78
86
#include <argp.h> /* struct argp_option, error_t, struct
79
87
argp_state, struct argp,
91
99
argz_delete(), argz_append(),
92
100
argz_stringify(), argz_add(),
93
101
argz_count() */
102
#include <netdb.h> /* getnameinfo(), NI_NUMERICHOST,
103
EAI_SYSTEM, gai_strerror() */
94
104
95
105
#ifdef __linux__
96
106
#include <sys/klog.h> /* klogctl() */
138
148
static const char sys_class_net[] = "/sys/class/net";
139
149
char *connect_to = NULL;
140
150
const char *hookdir = HOOKDIR;
151
int hookdir_fd = -1;
141
152
uid_t uid = 65534;
142
153
gid_t gid = 65534;
143
154
161
172
const char *priority;
162
173
gpgme_ctx_t ctx;
163
174
server *current_server;
175
char *interfaces;
176
size_t interfaces_size;
164
177
} mandos_context;
165
178
166
179
/* global so signal handler can reach it*/
167
180
AvahiSimplePoll *simple_poll;
168
mandos_context mc = { .server = NULL, .dh_bits = 1024,
169
.priority = "SECURE256:!CTYPE-X.509:"
170
"+CTYPE-OPENPGP", .current_server = NULL };
171
181
172
182
sig_atomic_t quit_now = 0;
173
183
int signal_received = 0;
181
191
perror(print_text);
182
192
}
183
193
184
__attribute__((format (gnu_printf, 2, 3)))
194
__attribute__((format (gnu_printf, 2, 3), nonnull))
185
195
int fprintf_plus(FILE *stream, const char *format, ...){
186
196
va_list ap;
187
197
va_start (ap, format);
188
198
189
199
TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
190
200
program_invocation_short_name));
191
return TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
201
return (int)TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
192
202
}
193
203
194
204
/*
196
206
* bytes. "buffer_capacity" is how much is currently allocated,
197
207
* "buffer_length" is how much is already used.
198
208
*/
209
__attribute__((nonnull, warn_unused_result))
199
210
size_t incbuffer(char **buffer, size_t buffer_length,
200
211
size_t buffer_capacity){
201
212
if(buffer_length + BUFFER_SIZE > buffer_capacity){
202
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
203
if(buffer == NULL){
213
char *new_buf = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
214
if(new_buf == NULL){
215
int old_errno = errno;
216
free(*buffer);
217
errno = old_errno;
218
*buffer = NULL;
204
219
return 0;
205
220
}
221
*buffer = new_buf;
206
222
buffer_capacity += BUFFER_SIZE;
207
223
}
208
224
return buffer_capacity;
209
225
}
210
226
211
227
/* Add server to set of servers to retry periodically */
228
__attribute__((nonnull, warn_unused_result))
212
229
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
213
int af){
230
int af, server **current_server){
214
231
int ret;
215
232
server *new_server = malloc(sizeof(server));
216
233
if(new_server == NULL){
223
240
.af = af };
224
241
if(new_server->ip == NULL){
225
242
perror_plus("strdup");
243
free(new_server);
244
return false;
245
}
246
ret = clock_gettime(CLOCK_MONOTONIC, &(new_server->last_seen));
247
if(ret == -1){
248
perror_plus("clock_gettime");
249
#ifdef __GNUC__
250
#pragma GCC diagnostic push
251
#pragma GCC diagnostic ignored "-Wcast-qual"
252
#endif
253
free((char *)(new_server->ip));
254
#ifdef __GNUC__
255
#pragma GCC diagnostic pop
256
#endif
257
free(new_server);
226
258
return false;
227
259
}
228
260
/* Special case of first server */
229
if (mc.current_server == NULL){
261
if(*current_server == NULL){
230
262
new_server->next = new_server;
231
263
new_server->prev = new_server;
232
mc.current_server = new_server;
233
/* Place the new server last in the list */
264
*current_server = new_server;
234
265
} else {
235
new_server->next = mc.current_server;
236
new_server->prev = mc.current_server->prev;
266
/* Place the new server last in the list */
267
new_server->next = *current_server;
268
new_server->prev = (*current_server)->prev;
237
269
new_server->prev->next = new_server;
238
mc.current_server->prev = new_server;
239
}
240
ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);
241
if(ret == -1){
242
perror_plus("clock_gettime");
243
return false;
270
(*current_server)->prev = new_server;
244
271
}
245
272
return true;
246
273
}
247
274
275
/* Set effective uid to 0, return errno */
276
__attribute__((warn_unused_result))
277
int raise_privileges(void){
278
int old_errno = errno;
279
int ret = 0;
280
if(seteuid(0) == -1){
281
ret = errno;
282
}
283
errno = old_errno;
284
return ret;
285
}
286
287
/* Set effective and real user ID to 0. Return errno. */
288
__attribute__((warn_unused_result))
289
int raise_privileges_permanently(void){
290
int old_errno = errno;
291
int ret = raise_privileges();
292
if(ret != 0){
293
errno = old_errno;
294
return ret;
295
}
296
if(setuid(0) == -1){
297
ret = errno;
298
}
299
errno = old_errno;
300
return ret;
301
}
302
303
/* Set effective user ID to unprivileged saved user ID */
304
__attribute__((warn_unused_result))
305
int lower_privileges(void){
306
int old_errno = errno;
307
int ret = 0;
308
if(seteuid(uid) == -1){
309
ret = errno;
310
}
311
errno = old_errno;
312
return ret;
313
}
314
315
/* Lower privileges permanently */
316
__attribute__((warn_unused_result))
317
int lower_privileges_permanently(void){
318
int old_errno = errno;
319
int ret = 0;
320
if(setuid(uid) == -1){
321
ret = errno;
322
}
323
errno = old_errno;
324
return ret;
325
}
326
248
327
/*
249
328
* Initialize GPGME.
250
329
*/
251
static bool init_gpgme(const char *seckey, const char *pubkey,
252
const char *tempdir){
330
__attribute__((nonnull, warn_unused_result))
331
static bool init_gpgme(const char * const seckey,
332
const char * const pubkey,
333
const char * const tempdir,
334
mandos_context *mc){
253
335
gpgme_error_t rc;
254
336
gpgme_engine_info_t engine_info;
255
337
256
338
/*
257
339
* Helper function to insert pub and seckey to the engine keyring.
258
340
*/
259
bool import_key(const char *filename){
341
bool import_key(const char * const filename){
260
342
int ret;
261
343
int fd;
262
344
gpgme_data_t pgp_data;
267
349
return false;
268
350
}
269
351
352
/* Workaround for systems without a real-time clock; see also
353
Debian bug #894495: <https://bugs.debian.org/894495> */
354
do {
355
{
356
time_t currtime = time(NULL);
357
if(currtime != (time_t)-1){
358
struct tm tm;
359
if(gmtime_r(&currtime, &tm) == NULL) {
360
perror_plus("gmtime_r");
361
break;
362
}
363
if(tm.tm_year != 70 or tm.tm_mon != 0){
364
break;
365
}
366
if(debug){
367
fprintf_plus(stderr, "System clock is January 1970");
368
}
369
} else {
370
if(debug){
371
fprintf_plus(stderr, "System clock is invalid");
372
}
373
}
374
}
375
struct stat keystat;
376
ret = fstat(fd, &keystat);
377
if(ret != 0){
378
perror_plus("fstat");
379
break;
380
}
381
ret = raise_privileges();
382
if(ret != 0){
383
errno = ret;
384
perror_plus("Failed to raise privileges");
385
break;
386
}
387
if(debug){
388
fprintf_plus(stderr,
389
"Setting system clock to key file mtime");
390
}
391
time_t keytime = keystat.st_mtim.tv_sec;
392
if(stime(&keytime) != 0){
393
perror_plus("stime");
394
}
395
ret = lower_privileges();
396
if(ret != 0){
397
errno = ret;
398
perror_plus("Failed to lower privileges");
399
}
400
} while(false);
401
270
402
rc = gpgme_data_new_from_fd(&pgp_data, fd);
271
403
if(rc != GPG_ERR_NO_ERROR){
272
404
fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
274
406
return false;
275
407
}
276
408
277
rc = gpgme_op_import(mc.ctx, pgp_data);
409
rc = gpgme_op_import(mc->ctx, pgp_data);
278
410
if(rc != GPG_ERR_NO_ERROR){
279
411
fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
280
412
gpgme_strsource(rc), gpgme_strerror(rc));
281
413
return false;
282
414
}
415
{
416
gpgme_import_result_t import_result
417
= gpgme_op_import_result(mc->ctx);
418
if((import_result->imported < 1
419
or import_result->not_imported > 0)
420
and import_result->unchanged == 0){
421
fprintf_plus(stderr, "bad gpgme_op_import_results:\n");
422
fprintf_plus(stderr,
423
"The total number of considered keys: %d\n",
424
import_result->considered);
425
fprintf_plus(stderr,
426
"The number of keys without user ID: %d\n",
427
import_result->no_user_id);
428
fprintf_plus(stderr,
429
"The total number of imported keys: %d\n",
430
import_result->imported);
431
fprintf_plus(stderr, "The number of imported RSA keys: %d\n",
432
import_result->imported_rsa);
433
fprintf_plus(stderr, "The number of unchanged keys: %d\n",
434
import_result->unchanged);
435
fprintf_plus(stderr, "The number of new user IDs: %d\n",
436
import_result->new_user_ids);
437
fprintf_plus(stderr, "The number of new sub keys: %d\n",
438
import_result->new_sub_keys);
439
fprintf_plus(stderr, "The number of new signatures: %d\n",
440
import_result->new_signatures);
441
fprintf_plus(stderr, "The number of new revocations: %d\n",
442
import_result->new_revocations);
443
fprintf_plus(stderr,
444
"The total number of secret keys read: %d\n",
445
import_result->secret_read);
446
fprintf_plus(stderr,
447
"The number of imported secret keys: %d\n",
448
import_result->secret_imported);
449
fprintf_plus(stderr,
450
"The number of unchanged secret keys: %d\n",
451
import_result->secret_unchanged);
452
fprintf_plus(stderr, "The number of keys not imported: %d\n",
453
import_result->not_imported);
454
for(gpgme_import_status_t import_status
455
= import_result->imports;
456
import_status != NULL;
457
import_status = import_status->next){
458
fprintf_plus(stderr, "Import status for key: %s\n",
459
import_status->fpr);
460
if(import_status->result != GPG_ERR_NO_ERROR){
461
fprintf_plus(stderr, "Import result: %s: %s\n",
462
gpgme_strsource(import_status->result),
463
gpgme_strerror(import_status->result));
464
}
465
fprintf_plus(stderr, "Key status:\n");
466
fprintf_plus(stderr,
467
import_status->status & GPGME_IMPORT_NEW
468
? "The key was new.\n"
469
: "The key was not new.\n");
470
fprintf_plus(stderr,
471
import_status->status & GPGME_IMPORT_UID
472
? "The key contained new user IDs.\n"
473
: "The key did not contain new user IDs.\n");
474
fprintf_plus(stderr,
475
import_status->status & GPGME_IMPORT_SIG
476
? "The key contained new signatures.\n"
477
: "The key did not contain new signatures.\n");
478
fprintf_plus(stderr,
479
import_status->status & GPGME_IMPORT_SUBKEY
480
? "The key contained new sub keys.\n"
481
: "The key did not contain new sub keys.\n");
482
fprintf_plus(stderr,
483
import_status->status & GPGME_IMPORT_SECRET
484
? "The key contained a secret key.\n"
485
: "The key did not contain a secret key.\n");
486
}
487
return false;
488
}
489
}
283
490
284
ret = (int)TEMP_FAILURE_RETRY(close(fd));
491
ret = close(fd);
285
492
if(ret == -1){
286
493
perror_plus("close");
287
494
}
324
531
}
325
532
326
533
/* Create new GPGME "context" */
327
rc = gpgme_new(&(mc.ctx));
534
rc = gpgme_new(&(mc->ctx));
328
535
if(rc != GPG_ERR_NO_ERROR){
329
fprintf_plus(stderr, "Mandos plugin mandos-client: "
330
"bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
331
gpgme_strerror(rc));
536
fprintf_plus(stderr, "bad gpgme_new: %s: %s\n",
537
gpgme_strsource(rc), gpgme_strerror(rc));
332
538
return false;
333
539
}
334
540
343
549
* Decrypt OpenPGP data.
344
550
* Returns -1 on error
345
551
*/
552
__attribute__((nonnull, warn_unused_result))
346
553
static ssize_t pgp_packet_decrypt(const char *cryptotext,
347
554
size_t crypto_size,
348
char **plaintext){
555
char **plaintext,
556
mandos_context *mc){
349
557
gpgme_data_t dh_crypto, dh_plain;
350
558
gpgme_error_t rc;
351
559
ssize_t ret;
368
576
/* Create new empty GPGME data buffer for the plaintext */
369
577
rc = gpgme_data_new(&dh_plain);
370
578
if(rc != GPG_ERR_NO_ERROR){
371
fprintf_plus(stderr, "Mandos plugin mandos-client: "
372
"bad gpgme_data_new: %s: %s\n",
579
fprintf_plus(stderr, "bad gpgme_data_new: %s: %s\n",
373
580
gpgme_strsource(rc), gpgme_strerror(rc));
374
581
gpgme_data_release(dh_crypto);
375
582
return -1;
377
584
378
585
/* Decrypt data from the cryptotext data buffer to the plaintext
379
586
data buffer */
380
rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
587
rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
381
588
if(rc != GPG_ERR_NO_ERROR){
382
589
fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
383
590
gpgme_strsource(rc), gpgme_strerror(rc));
384
591
plaintext_length = -1;
385
592
if(debug){
386
593
gpgme_decrypt_result_t result;
387
result = gpgme_op_decrypt_result(mc.ctx);
594
result = gpgme_op_decrypt_result(mc->ctx);
388
595
if(result == NULL){
389
596
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
390
597
} else {
391
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
392
result->unsupported_algorithm);
393
fprintf_plus(stderr, "Wrong key usage: %u\n",
394
result->wrong_key_usage);
598
if(result->unsupported_algorithm != NULL) {
599
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
600
result->unsupported_algorithm);
601
}
602
fprintf_plus(stderr, "Wrong key usage: %s\n",
603
result->wrong_key_usage ? "Yes" : "No");
395
604
if(result->file_name != NULL){
396
605
fprintf_plus(stderr, "File name: %s\n", result->file_name);
397
606
}
398
gpgme_recipient_t recipient;
399
recipient = result->recipients;
400
while(recipient != NULL){
607
608
for(gpgme_recipient_t r = result->recipients; r != NULL;
609
r = r->next){
401
610
fprintf_plus(stderr, "Public key algorithm: %s\n",
402
gpgme_pubkey_algo_name
403
(recipient->pubkey_algo));
404
fprintf_plus(stderr, "Key ID: %s\n", recipient->keyid);
611
gpgme_pubkey_algo_name(r->pubkey_algo));
612
fprintf_plus(stderr, "Key ID: %s\n", r->keyid);
405
613
fprintf_plus(stderr, "Secret key available: %s\n",
406
recipient->status == GPG_ERR_NO_SECKEY
407
? "No" : "Yes");
408
recipient = recipient->next;
614
r->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
409
615
}
410
616
}
411
617
}
467
673
return plaintext_length;
468
674
}
469
675
470
static const char * safer_gnutls_strerror(int value){
676
__attribute__((warn_unused_result, const))
677
static const char *safe_string(const char *str){
678
if(str == NULL)
679
return "(unknown)";
680
return str;
681
}
682
683
__attribute__((warn_unused_result))
684
static const char *safer_gnutls_strerror(int value){
471
685
const char *ret = gnutls_strerror(value);
472
if(ret == NULL)
473
ret = "(unknown)";
474
return ret;
686
return safe_string(ret);
475
687
}
476
688
477
689
/* GnuTLS log function callback */
690
__attribute__((nonnull))
478
691
static void debuggnutls(__attribute__((unused)) int level,
479
692
const char* string){
480
693
fprintf_plus(stderr, "GnuTLS: %s", string);
481
694
}
482
695
696
__attribute__((nonnull(1, 2, 4), warn_unused_result))
483
697
static int init_gnutls_global(const char *pubkeyfilename,
484
const char *seckeyfilename){
698
const char *seckeyfilename,
699
const char *dhparamsfilename,
700
mandos_context *mc){
485
701
int ret;
702
unsigned int uret;
486
703
487
704
if(debug){
488
705
fprintf_plus(stderr, "Initializing GnuTLS\n");
489
706
}
490
707
491
ret = gnutls_global_init();
492
if(ret != GNUTLS_E_SUCCESS){
493
fprintf_plus(stderr, "GnuTLS global_init: %s\n",
494
safer_gnutls_strerror(ret));
495
return -1;
496
}
497
498
708
if(debug){
499
709
/* "Use a log level over 10 to enable all debugging options."
500
710
* - GnuTLS manual
504
714
}
505
715
506
716
/* OpenPGP credentials */
507
ret = gnutls_certificate_allocate_credentials(&mc.cred);
717
ret = gnutls_certificate_allocate_credentials(&mc->cred);
508
718
if(ret != GNUTLS_E_SUCCESS){
509
719
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
510
720
safer_gnutls_strerror(ret));
511
gnutls_global_deinit();
512
721
return -1;
513
722
}
514
723
520
729
}
521
730
522
731
ret = gnutls_certificate_set_openpgp_key_file
523
(mc.cred, pubkeyfilename, seckeyfilename,
732
(mc->cred, pubkeyfilename, seckeyfilename,
524
733
GNUTLS_OPENPGP_FMT_BASE64);
525
734
if(ret != GNUTLS_E_SUCCESS){
526
735
fprintf_plus(stderr,
532
741
}
533
742
534
743
/* GnuTLS server initialization */
535
ret = gnutls_dh_params_init(&mc.dh_params);
744
ret = gnutls_dh_params_init(&mc->dh_params);
536
745
if(ret != GNUTLS_E_SUCCESS){
537
746
fprintf_plus(stderr, "Error in GnuTLS DH parameter"
538
747
" initialization: %s\n",
539
748
safer_gnutls_strerror(ret));
540
749
goto globalfail;
541
750
}
542
ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
543
if(ret != GNUTLS_E_SUCCESS){
544
fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
545
safer_gnutls_strerror(ret));
546
goto globalfail;
547
}
548
549
gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
751
/* If a Diffie-Hellman parameters file was given, try to use it */
752
if(dhparamsfilename != NULL){
753
gnutls_datum_t params = { .data = NULL, .size = 0 };
754
do {
755
int dhpfile = open(dhparamsfilename, O_RDONLY);
756
if(dhpfile == -1){
757
perror_plus("open");
758
dhparamsfilename = NULL;
759
break;
760
}
761
size_t params_capacity = 0;
762
while(true){
763
params_capacity = incbuffer((char **)¶ms.data,
764
(size_t)params.size,
765
(size_t)params_capacity);
766
if(params_capacity == 0){
767
perror_plus("incbuffer");
768
free(params.data);
769
params.data = NULL;
770
dhparamsfilename = NULL;
771
break;
772
}
773
ssize_t bytes_read = read(dhpfile,
774
params.data + params.size,
775
BUFFER_SIZE);
776
/* EOF */
777
if(bytes_read == 0){
778
break;
779
}
780
/* check bytes_read for failure */
781
if(bytes_read < 0){
782
perror_plus("read");
783
free(params.data);
784
params.data = NULL;
785
dhparamsfilename = NULL;
786
break;
787
}
788
params.size += (unsigned int)bytes_read;
789
}
790
ret = close(dhpfile);
791
if(ret == -1){
792
perror_plus("close");
793
}
794
if(params.data == NULL){
795
dhparamsfilename = NULL;
796
}
797
if(dhparamsfilename == NULL){
798
break;
799
}
800
ret = gnutls_dh_params_import_pkcs3(mc->dh_params, ¶ms,
801
GNUTLS_X509_FMT_PEM);
802
if(ret != GNUTLS_E_SUCCESS){
803
fprintf_plus(stderr, "Failed to parse DH parameters in file"
804
" \"%s\": %s\n", dhparamsfilename,
805
safer_gnutls_strerror(ret));
806
dhparamsfilename = NULL;
807
}
808
free(params.data);
809
} while(false);
810
}
811
if(dhparamsfilename == NULL){
812
if(mc->dh_bits == 0){
813
/* Find out the optimal number of DH bits */
814
/* Try to read the private key file */
815
gnutls_datum_t buffer = { .data = NULL, .size = 0 };
816
do {
817
int secfile = open(seckeyfilename, O_RDONLY);
818
if(secfile == -1){
819
perror_plus("open");
820
break;
821
}
822
size_t buffer_capacity = 0;
823
while(true){
824
buffer_capacity = incbuffer((char **)&buffer.data,
825
(size_t)buffer.size,
826
(size_t)buffer_capacity);
827
if(buffer_capacity == 0){
828
perror_plus("incbuffer");
829
free(buffer.data);
830
buffer.data = NULL;
831
break;
832
}
833
ssize_t bytes_read = read(secfile,
834
buffer.data + buffer.size,
835
BUFFER_SIZE);
836
/* EOF */
837
if(bytes_read == 0){
838
break;
839
}
840
/* check bytes_read for failure */
841
if(bytes_read < 0){
842
perror_plus("read");
843
free(buffer.data);
844
buffer.data = NULL;
845
break;
846
}
847
buffer.size += (unsigned int)bytes_read;
848
}
849
close(secfile);
850
} while(false);
851
/* If successful, use buffer to parse private key */
852
gnutls_sec_param_t sec_param = GNUTLS_SEC_PARAM_ULTRA;
853
if(buffer.data != NULL){
854
{
855
gnutls_openpgp_privkey_t privkey = NULL;
856
ret = gnutls_openpgp_privkey_init(&privkey);
857
if(ret != GNUTLS_E_SUCCESS){
858
fprintf_plus(stderr, "Error initializing OpenPGP key"
859
" structure: %s",
860
safer_gnutls_strerror(ret));
861
free(buffer.data);
862
buffer.data = NULL;
863
} else {
864
ret = gnutls_openpgp_privkey_import
865
(privkey, &buffer, GNUTLS_OPENPGP_FMT_BASE64, "", 0);
866
if(ret != GNUTLS_E_SUCCESS){
867
fprintf_plus(stderr, "Error importing OpenPGP key : %s",
868
safer_gnutls_strerror(ret));
869
privkey = NULL;
870
}
871
free(buffer.data);
872
buffer.data = NULL;
873
if(privkey != NULL){
874
/* Use private key to suggest an appropriate
875
sec_param */
876
sec_param = gnutls_openpgp_privkey_sec_param(privkey);
877
gnutls_openpgp_privkey_deinit(privkey);
878
if(debug){
879
fprintf_plus(stderr, "This OpenPGP key implies using"
880
" a GnuTLS security parameter \"%s\".\n",
881
safe_string(gnutls_sec_param_get_name
882
(sec_param)));
883
}
884
}
885
}
886
}
887
if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
888
/* Err on the side of caution */
889
sec_param = GNUTLS_SEC_PARAM_ULTRA;
890
if(debug){
891
fprintf_plus(stderr, "Falling back to security parameter"
892
" \"%s\"\n",
893
safe_string(gnutls_sec_param_get_name
894
(sec_param)));
895
}
896
}
897
}
898
uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
899
if(uret != 0){
900
mc->dh_bits = uret;
901
if(debug){
902
fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
903
" implies %u DH bits; using that.\n",
904
safe_string(gnutls_sec_param_get_name
905
(sec_param)),
906
mc->dh_bits);
907
}
908
} else {
909
fprintf_plus(stderr, "Failed to get implied number of DH"
910
" bits for security parameter \"%s\"): %s\n",
911
safe_string(gnutls_sec_param_get_name
912
(sec_param)),
913
safer_gnutls_strerror(ret));
914
goto globalfail;
915
}
916
} else if(debug){
917
fprintf_plus(stderr, "DH bits explicitly set to %u\n",
918
mc->dh_bits);
919
}
920
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
921
if(ret != GNUTLS_E_SUCCESS){
922
fprintf_plus(stderr, "Error in GnuTLS prime generation (%u"
923
" bits): %s\n", mc->dh_bits,
924
safer_gnutls_strerror(ret));
925
goto globalfail;
926
}
927
}
928
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
550
929
551
930
return 0;
552
931
553
932
globalfail:
554
933
555
gnutls_certificate_free_credentials(mc.cred);
556
gnutls_global_deinit();
557
gnutls_dh_params_deinit(mc.dh_params);
934
gnutls_certificate_free_credentials(mc->cred);
935
gnutls_dh_params_deinit(mc->dh_params);
558
936
return -1;
559
937
}
560
938
561
static int init_gnutls_session(gnutls_session_t *session){
939
__attribute__((nonnull, warn_unused_result))
940
static int init_gnutls_session(gnutls_session_t *session,
941
mandos_context *mc){
562
942
int ret;
563
943
/* GnuTLS session creation */
564
944
do {
576
956
{
577
957
const char *err;
578
958
do {
579
ret = gnutls_priority_set_direct(*session, mc.priority, &err);
959
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
580
960
if(quit_now){
581
961
gnutls_deinit(*session);
582
962
return -1;
593
973
594
974
do {
595
975
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
596
mc.cred);
976
mc->cred);
597
977
if(quit_now){
598
978
gnutls_deinit(*session);
599
979
return -1;
609
989
/* ignore client certificate if any. */
610
990
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
611
991
612
gnutls_dh_set_prime_bits(*session, mc.dh_bits);
613
614
992
return 0;
615
993
}
616
994
618
996
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
619
997
__attribute__((unused)) const char *txt){}
620
998
999
/* Helper function to add_local_route() and delete_local_route() */
1000
__attribute__((nonnull, warn_unused_result))
1001
static bool add_delete_local_route(const bool add,
1002
const char *address,
1003
AvahiIfIndex if_index){
1004
int ret;
1005
char helper[] = "mandos-client-iprouteadddel";
1006
char add_arg[] = "add";
1007
char delete_arg[] = "delete";
1008
char debug_flag[] = "--debug";
1009
char *pluginhelperdir = getenv("MANDOSPLUGINHELPERDIR");
1010
if(pluginhelperdir == NULL){
1011
if(debug){
1012
fprintf_plus(stderr, "MANDOSPLUGINHELPERDIR environment"
1013
" variable not set; cannot run helper\n");
1014
}
1015
return false;
1016
}
1017
1018
char interface[IF_NAMESIZE];
1019
if(if_indextoname((unsigned int)if_index, interface) == NULL){
1020
perror_plus("if_indextoname");
1021
return false;
1022
}
1023
1024
int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
1025
if(devnull == -1){
1026
perror_plus("open(\"/dev/null\", O_RDONLY)");
1027
return false;
1028
}
1029
pid_t pid = fork();
1030
if(pid == 0){
1031
/* Child */
1032
/* Raise privileges */
1033
errno = raise_privileges_permanently();
1034
if(errno != 0){
1035
perror_plus("Failed to raise privileges");
1036
/* _exit(EX_NOPERM); */
1037
} else {
1038
/* Set group */
1039
errno = 0;
1040
ret = setgid(0);
1041
if(ret == -1){
1042
perror_plus("setgid");
1043
_exit(EX_NOPERM);
1044
}
1045
/* Reset supplementary groups */
1046
errno = 0;
1047
ret = setgroups(0, NULL);
1048
if(ret == -1){
1049
perror_plus("setgroups");
1050
_exit(EX_NOPERM);
1051
}
1052
}
1053
ret = dup2(devnull, STDIN_FILENO);
1054
if(ret == -1){
1055
perror_plus("dup2(devnull, STDIN_FILENO)");
1056
_exit(EX_OSERR);
1057
}
1058
ret = close(devnull);
1059
if(ret == -1){
1060
perror_plus("close");
1061
_exit(EX_OSERR);
1062
}
1063
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
1064
if(ret == -1){
1065
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
1066
_exit(EX_OSERR);
1067
}
1068
int helperdir_fd = (int)TEMP_FAILURE_RETRY(open(pluginhelperdir,
1069
O_RDONLY
1070
| O_DIRECTORY
1071
| O_PATH
1072
| O_CLOEXEC));
1073
if(helperdir_fd == -1){
1074
perror_plus("open");
1075
_exit(EX_UNAVAILABLE);
1076
}
1077
int helper_fd = (int)TEMP_FAILURE_RETRY(openat(helperdir_fd,
1078
helper, O_RDONLY));
1079
if(helper_fd == -1){
1080
perror_plus("openat");
1081
close(helperdir_fd);
1082
_exit(EX_UNAVAILABLE);
1083
}
1084
close(helperdir_fd);
1085
#ifdef __GNUC__
1086
#pragma GCC diagnostic push
1087
#pragma GCC diagnostic ignored "-Wcast-qual"
1088
#endif
1089
if(fexecve(helper_fd, (char *const [])
1090
{ helper, add ? add_arg : delete_arg, (char *)address,
1091
interface, debug ? debug_flag : NULL, NULL },
1092
environ) == -1){
1093
#ifdef __GNUC__
1094
#pragma GCC diagnostic pop
1095
#endif
1096
perror_plus("fexecve");
1097
_exit(EXIT_FAILURE);
1098
}
1099
}
1100
if(pid == -1){
1101
perror_plus("fork");
1102
return false;
1103
}
1104
int status;
1105
pid_t pret = -1;
1106
errno = 0;
1107
do {
1108
pret = waitpid(pid, &status, 0);
1109
if(pret == -1 and errno == EINTR and quit_now){
1110
int errno_raising = 0;
1111
if((errno = raise_privileges()) != 0){
1112
errno_raising = errno;
1113
perror_plus("Failed to raise privileges in order to"
1114
" kill helper program");
1115
}
1116
if(kill(pid, SIGTERM) == -1){
1117
perror_plus("kill");
1118
}
1119
if((errno_raising == 0) and (errno = lower_privileges()) != 0){
1120
perror_plus("Failed to lower privileges after killing"
1121
" helper program");
1122
}
1123
return false;
1124
}
1125
} while(pret == -1 and errno == EINTR);
1126
if(pret == -1){
1127
perror_plus("waitpid");
1128
return false;
1129
}
1130
if(WIFEXITED(status)){
1131
if(WEXITSTATUS(status) != 0){
1132
fprintf_plus(stderr, "Error: iprouteadddel exited"
1133
" with status %d\n", WEXITSTATUS(status));
1134
return false;
1135
}
1136
return true;
1137
}
1138
if(WIFSIGNALED(status)){
1139
fprintf_plus(stderr, "Error: iprouteadddel died by"
1140
" signal %d\n", WTERMSIG(status));
1141
return false;
1142
}
1143
fprintf_plus(stderr, "Error: iprouteadddel crashed\n");
1144
return false;
1145
}
1146
1147
__attribute__((nonnull, warn_unused_result))
1148
static bool add_local_route(const char *address,
1149
AvahiIfIndex if_index){
1150
if(debug){
1151
fprintf_plus(stderr, "Adding route to %s\n", address);
1152
}
1153
return add_delete_local_route(true, address, if_index);
1154
}
1155
1156
__attribute__((nonnull, warn_unused_result))
1157
static bool delete_local_route(const char *address,
1158
AvahiIfIndex if_index){
1159
if(debug){
1160
fprintf_plus(stderr, "Removing route to %s\n", address);
1161
}
1162
return add_delete_local_route(false, address, if_index);
1163
}
1164
621
1165
/* Called when a Mandos server is found */
1166
__attribute__((nonnull, warn_unused_result))
622
1167
static int start_mandos_communication(const char *ip, in_port_t port,
623
1168
AvahiIfIndex if_index,
624
int af){
1169
int af, mandos_context *mc){
625
1170
int ret, tcp_sd = -1;
626
1171
ssize_t sret;
627
union {
628
struct sockaddr_in in;
629
struct sockaddr_in6 in6;
630
} to;
1172
struct sockaddr_storage to;
631
1173
char *buffer = NULL;
632
1174
char *decrypted_buffer = NULL;
633
1175
size_t buffer_length = 0;
636
1178
int retval = -1;
637
1179
gnutls_session_t session;
638
1180
int pf; /* Protocol family */
1181
bool route_added = false;
639
1182
640
1183
errno = 0;
641
1184
657
1200
return -1;
658
1201
}
659
1202
660
ret = init_gnutls_session(&session);
1203
/* If the interface is specified and we have a list of interfaces */
1204
if(if_index != AVAHI_IF_UNSPEC and mc->interfaces != NULL){
1205
/* Check if the interface is one of the interfaces we are using */
1206
bool match = false;
1207
{
1208
char *interface = NULL;
1209
while((interface = argz_next(mc->interfaces,
1210
mc->interfaces_size,
1211
interface))){
1212
if(if_nametoindex(interface) == (unsigned int)if_index){
1213
match = true;
1214
break;
1215
}
1216
}
1217
}
1218
if(not match){
1219
/* This interface does not match any in the list, so we don't
1220
connect to the server */
1221
if(debug){
1222
char interface[IF_NAMESIZE];
1223
if(if_indextoname((unsigned int)if_index, interface) == NULL){
1224
perror_plus("if_indextoname");
1225
} else {
1226
fprintf_plus(stderr, "Skipping server on non-used interface"
1227
" \"%s\"\n",
1228
if_indextoname((unsigned int)if_index,
1229
interface));
1230
}
1231
}
1232
return -1;
1233
}
1234
}
1235
1236
ret = init_gnutls_session(&session, mc);
661
1237
if(ret != 0){
662
1238
return -1;
663
1239
}
667
1243
PRIuMAX "\n", ip, (uintmax_t)port);
668
1244
}
669
1245
670
tcp_sd = socket(pf, SOCK_STREAM, 0);
1246
tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
671
1247
if(tcp_sd < 0){
672
1248
int e = errno;
673
1249
perror_plus("socket");
680
1256
goto mandos_end;
681
1257
}
682
1258
683
memset(&to, 0, sizeof(to));
684
1259
if(af == AF_INET6){
685
to.in6.sin6_family = (sa_family_t)af;
686
ret = inet_pton(af, ip, &to.in6.sin6_addr);
1260
struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)&to;
1261
*to6 = (struct sockaddr_in6){ .sin6_family = (sa_family_t)af };
1262
ret = inet_pton(af, ip, &to6->sin6_addr);
687
1263
} else { /* IPv4 */
688
to.in.sin_family = (sa_family_t)af;
689
ret = inet_pton(af, ip, &to.in.sin_addr);
1264
struct sockaddr_in *to4 = (struct sockaddr_in *)&to;
1265
*to4 = (struct sockaddr_in){ .sin_family = (sa_family_t)af };
1266
ret = inet_pton(af, ip, &to4->sin_addr);
690
1267
}
691
1268
if(ret < 0 ){
692
1269
int e = errno;
701
1278
goto mandos_end;
702
1279
}
703
1280
if(af == AF_INET6){
704
to.in6.sin6_port = htons(port);
705
if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
706
(&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
707
-Wunreachable-code*/
1281
((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
1282
if(IN6_IS_ADDR_LINKLOCAL
1283
(&((struct sockaddr_in6 *)&to)->sin6_addr)){
708
1284
if(if_index == AVAHI_IF_UNSPEC){
709
1285
fprintf_plus(stderr, "An IPv6 link-local address is"
710
1286
" incomplete without a network interface\n");
712
1288
goto mandos_end;
713
1289
}
714
1290
/* Set the network interface number as scope */
715
to.in6.sin6_scope_id = (uint32_t)if_index;
1291
((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
716
1292
}
717
1293
} else {
718
to.in.sin_port = htons(port); /* Spurious warnings from
719
-Wconversion and
720
-Wunreachable-code */
1294
((struct sockaddr_in *)&to)->sin_port = htons(port);
721
1295
}
722
1296
723
1297
if(quit_now){
740
1314
}
741
1315
char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
742
1316
INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
743
const char *pcret;
744
if(af == AF_INET6){
745
pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
746
sizeof(addrstr));
747
} else {
748
pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
749
sizeof(addrstr));
750
}
751
if(pcret == NULL){
752
perror_plus("inet_ntop");
753
} else {
754
if(strcmp(addrstr, ip) != 0){
755
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
756
}
757
}
758
}
759
760
if(quit_now){
761
errno = EINTR;
762
goto mandos_end;
763
}
764
765
if(af == AF_INET6){
766
ret = connect(tcp_sd, &to.in6, sizeof(to));
767
} else {
768
ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
769
}
770
if(ret < 0){
771
if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
772
int e = errno;
773
perror_plus("connect");
774
errno = e;
775
}
776
goto mandos_end;
777
}
778
779
if(quit_now){
780
errno = EINTR;
781
goto mandos_end;
1317
if(af == AF_INET6){
1318
ret = getnameinfo((struct sockaddr *)&to,
1319
sizeof(struct sockaddr_in6),
1320
addrstr, sizeof(addrstr), NULL, 0,
1321
NI_NUMERICHOST);
1322
} else {
1323
ret = getnameinfo((struct sockaddr *)&to,
1324
sizeof(struct sockaddr_in),
1325
addrstr, sizeof(addrstr), NULL, 0,
1326
NI_NUMERICHOST);
1327
}
1328
if(ret == EAI_SYSTEM){
1329
perror_plus("getnameinfo");
1330
} else if(ret != 0) {
1331
fprintf_plus(stderr, "getnameinfo: %s", gai_strerror(ret));
1332
} else if(strcmp(addrstr, ip) != 0){
1333
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
1334
}
1335
}
1336
1337
if(quit_now){
1338
errno = EINTR;
1339
goto mandos_end;
1340
}
1341
1342
while(true){
1343
if(af == AF_INET6){
1344
ret = connect(tcp_sd, (struct sockaddr *)&to,
1345
sizeof(struct sockaddr_in6));
1346
} else {
1347
ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
1348
sizeof(struct sockaddr_in));
1349
}
1350
if(ret < 0){
1351
if(((errno == ENETUNREACH) or (errno == EHOSTUNREACH))
1352
and if_index != AVAHI_IF_UNSPEC
1353
and connect_to == NULL
1354
and not route_added and
1355
((af == AF_INET6 and not
1356
IN6_IS_ADDR_LINKLOCAL(&(((struct sockaddr_in6 *)
1357
&to)->sin6_addr)))
1358
or (af == AF_INET and
1359
/* Not a a IPv4LL address */
1360
(ntohl(((struct sockaddr_in *)&to)->sin_addr.s_addr)
1361
& 0xFFFF0000L) != 0xA9FE0000L))){
1362
/* Work around Avahi bug - Avahi does not announce link-local
1363
addresses if it has a global address, so local hosts with
1364
*only* a link-local address (e.g. Mandos clients) cannot
1365
connect to a Mandos server announced by Avahi on a server
1366
host with a global address. Work around this by retrying
1367
with an explicit route added with the server's address.
1368
1369
Avahi bug reference:
1370
https://lists.freedesktop.org/archives/avahi/2010-February/001833.html
1371
https://bugs.debian.org/587961
1372
*/
1373
if(debug){
1374
fprintf_plus(stderr, "Mandos server unreachable, trying"
1375
" direct route\n");
1376
}
1377
int e = errno;
1378
route_added = add_local_route(ip, if_index);
1379
if(route_added){
1380
continue;
1381
}
1382
errno = e;
1383
}
1384
if(errno != ECONNREFUSED or debug){
1385
int e = errno;
1386
perror_plus("connect");
1387
errno = e;
1388
}
1389
goto mandos_end;
1390
}
1391
1392
if(quit_now){
1393
errno = EINTR;
1394
goto mandos_end;
1395
}
1396
break;
782
1397
}
783
1398
784
1399
const char *out = mandos_protocol_version;
935
1550
if(buffer_length > 0){
936
1551
ssize_t decrypted_buffer_size;
937
1552
decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
938
&decrypted_buffer);
1553
&decrypted_buffer, mc);
939
1554
if(decrypted_buffer_size >= 0){
940
1555
1556
clearerr(stdout);
941
1557
written = 0;
942
1558
while(written < (size_t) decrypted_buffer_size){
943
1559
if(quit_now){
959
1575
}
960
1576
written += (size_t)ret;
961
1577
}
1578
ret = fflush(stdout);
1579
if(ret != 0){
1580
int e = errno;
1581
if(debug){
1582
fprintf_plus(stderr, "Error writing encrypted data: %s\n",
1583
strerror(errno));
1584
}
1585
errno = e;
1586
goto mandos_end;
1587
}
962
1588
retval = 0;
963
1589
}
964
1590
}
967
1593
968
1594
mandos_end:
969
1595
{
1596
if(route_added){
1597
if(not delete_local_route(ip, if_index)){
1598
fprintf_plus(stderr, "Failed to delete local route to %s on"
1599
" interface %d", ip, if_index);
1600
}
1601
}
970
1602
int e = errno;
971
1603
free(decrypted_buffer);
972
1604
free(buffer);
973
1605
if(tcp_sd >= 0){
974
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
1606
ret = close(tcp_sd);
975
1607
}
976
1608
if(ret == -1){
977
1609
if(e == 0){
1002
1634
AVAHI_GCC_UNUSED AvahiStringList *txt,
1003
1635
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1004
1636
flags,
1005
AVAHI_GCC_UNUSED void* userdata){
1637
void *mc){
1006
1638
if(r == NULL){
1007
1639
return;
1008
1640
}
1011
1643
timed out */
1012
1644
1013
1645
if(quit_now){
1646
avahi_s_service_resolver_free(r);
1014
1647
return;
1015
1648
}
1016
1649
1020
1653
fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
1021
1654
"'%s' of type '%s' in domain '%s': %s\n", name, type,
1022
1655
domain,
1023
avahi_strerror(avahi_server_errno(mc.server)));
1656
avahi_strerror(avahi_server_errno
1657
(((mandos_context*)mc)->server)));
1024
1658
break;
1025
1659
1026
1660
case AVAHI_RESOLVER_FOUND:
1034
1668
}
1035
1669
int ret = start_mandos_communication(ip, (in_port_t)port,
1036
1670
interface,
1037
avahi_proto_to_af(proto));
1671
avahi_proto_to_af(proto),
1672
mc);
1038
1673
if(ret == 0){
1039
1674
avahi_simple_poll_quit(simple_poll);
1040
1675
} else {
1041
1676
if(not add_server(ip, (in_port_t)port, interface,
1042
avahi_proto_to_af(proto))){
1677
avahi_proto_to_af(proto),
1678
&((mandos_context*)mc)->current_server)){
1043
1679
fprintf_plus(stderr, "Failed to add server \"%s\" to server"
1044
1680
" list\n", name);
1045
1681
}
1058
1694
const char *domain,
1059
1695
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1060
1696
flags,
1061
AVAHI_GCC_UNUSED void* userdata){
1697
void *mc){
1062
1698
if(b == NULL){
1063
1699
return;
1064
1700
}
1075
1711
case AVAHI_BROWSER_FAILURE:
1076
1712
1077
1713
fprintf_plus(stderr, "(Avahi browser) %s\n",
1078
avahi_strerror(avahi_server_errno(mc.server)));
1714
avahi_strerror(avahi_server_errno
1715
(((mandos_context*)mc)->server)));
1079
1716
avahi_simple_poll_quit(simple_poll);
1080
1717
return;
1081
1718
1085
1722
the callback function is called the Avahi server will free the
1086
1723
resolver for us. */
1087
1724
1088
if(avahi_s_service_resolver_new(mc.server, interface, protocol,
1089
name, type, domain, protocol, 0,
1090
resolve_callback, NULL) == NULL)
1725
if(avahi_s_service_resolver_new(((mandos_context*)mc)->server,
1726
interface, protocol, name, type,
1727
domain, protocol, 0,
1728
resolve_callback, mc) == NULL)
1091
1729
fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
1092
1730
" %s\n", name,
1093
avahi_strerror(avahi_server_errno(mc.server)));
1731
avahi_strerror(avahi_server_errno
1732
(((mandos_context*)mc)->server)));
1094
1733
break;
1095
1734
1096
1735
case AVAHI_BROWSER_REMOVE:
1121
1760
errno = old_errno;
1122
1761
}
1123
1762
1763
__attribute__((nonnull, warn_unused_result))
1124
1764
bool get_flags(const char *ifname, struct ifreq *ifr){
1125
1765
int ret;
1126
error_t ret_errno;
1766
int old_errno;
1127
1767
1128
1768
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1129
1769
if(s < 0){
1130
ret_errno = errno;
1770
old_errno = errno;
1131
1771
perror_plus("socket");
1132
errno = ret_errno;
1772
errno = old_errno;
1133
1773
return false;
1134
1774
}
1135
strcpy(ifr->ifr_name, ifname);
1775
strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
1776
ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
1136
1777
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1137
1778
if(ret == -1){
1138
1779
if(debug){
1139
ret_errno = errno;
1780
old_errno = errno;
1140
1781
perror_plus("ioctl SIOCGIFFLAGS");
1141
errno = ret_errno;
1782
errno = old_errno;
1783
}
1784
if((close(s) == -1) and debug){
1785
old_errno = errno;
1786
perror_plus("close");
1787
errno = old_errno;
1142
1788
}
1143
1789
return false;
1144
1790
}
1791
if((close(s) == -1) and debug){
1792
old_errno = errno;
1793
perror_plus("close");
1794
errno = old_errno;
1795
}
1145
1796
return true;
1146
1797
}
1147
1798
1799
__attribute__((nonnull, warn_unused_result))
1148
1800
bool good_flags(const char *ifname, const struct ifreq *ifr){
1149
1801
1150
1802
/* Reject the loopback device */
1192
1844
* corresponds to an acceptable network device.
1193
1845
* (This function is passed to scandir(3) as a filter function.)
1194
1846
*/
1847
__attribute__((nonnull, warn_unused_result))
1195
1848
int good_interface(const struct dirent *if_entry){
1196
1849
if(if_entry->d_name[0] == '.'){
1197
1850
return 0;
1215
1868
/*
1216
1869
* This function determines if a network interface is up.
1217
1870
*/
1871
__attribute__((nonnull, warn_unused_result))
1218
1872
bool interface_is_up(const char *interface){
1219
1873
struct ifreq ifr;
1220
1874
if(not get_flags(interface, &ifr)){
1231
1885
/*
1232
1886
* This function determines if a network interface is running
1233
1887
*/
1888
__attribute__((nonnull, warn_unused_result))
1234
1889
bool interface_is_running(const char *interface){
1235
1890
struct ifreq ifr;
1236
1891
if(not get_flags(interface, &ifr)){
1244
1899
return (bool)(ifr.ifr_flags & IFF_RUNNING);
1245
1900
}
1246
1901
1902
__attribute__((nonnull, pure, warn_unused_result))
1247
1903
int notdotentries(const struct dirent *direntry){
1248
1904
/* Skip "." and ".." */
1249
1905
if(direntry->d_name[0] == '.'
1256
1912
}
1257
1913
1258
1914
/* Is this directory entry a runnable program? */
1915
__attribute__((nonnull, warn_unused_result))
1259
1916
int runnable_hook(const struct dirent *direntry){
1260
1917
int ret;
1261
1918
size_t sret;
1269
1926
sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1270
1927
"abcdefghijklmnopqrstuvwxyz"
1271
1928
"0123456789"
1272
"_-");
1929
"_.-");
1273
1930
if((direntry->d_name)[sret] != '\0'){
1274
1931
/* Contains non-allowed characters */
1275
1932
if(debug){
1279
1936
return 0;
1280
1937
}
1281
1938
1282
char *fullname = NULL;
1283
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1284
if(ret < 0){
1285
perror_plus("asprintf");
1286
return 0;
1287
}
1288
1289
ret = stat(fullname, &st);
1939
ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1290
1940
if(ret == -1){
1291
1941
if(debug){
1292
1942
perror_plus("Could not stat hook");
1316
1966
return 1;
1317
1967
}
1318
1968
1319
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval){
1969
__attribute__((nonnull, warn_unused_result))
1970
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
1971
mandos_context *mc){
1320
1972
int ret;
1321
1973
struct timespec now;
1322
1974
struct timespec waited_time;
1323
1975
intmax_t block_time;
1324
1976
1325
1977
while(true){
1326
if(mc.current_server == NULL){
1327
if (debug){
1978
if(mc->current_server == NULL){
1979
if(debug){
1328
1980
fprintf_plus(stderr, "Wait until first server is found."
1329
1981
" No timeout!\n");
1330
1982
}
1331
1983
ret = avahi_simple_poll_iterate(s, -1);
1332
1984
} else {
1333
if (debug){
1985
if(debug){
1334
1986
fprintf_plus(stderr, "Check current_server if we should run"
1335
1987
" it, or wait\n");
1336
1988
}
1343
1995
/* Calculating in ms how long time between now and server
1344
1996
who we visted longest time ago. Now - last seen. */
1345
1997
waited_time.tv_sec = (now.tv_sec
1346
- mc.current_server->last_seen.tv_sec);
1998
- mc->current_server->last_seen.tv_sec);
1347
1999
waited_time.tv_nsec = (now.tv_nsec
1348
- mc.current_server->last_seen.tv_nsec);
2000
- mc->current_server->last_seen.tv_nsec);
1349
2001
/* total time is 10s/10,000ms.
1350
2002
Converting to s from ms by dividing by 1,000,
1351
2003
and ns to ms by dividing by 1,000,000. */
1353
2005
- ((intmax_t)waited_time.tv_sec * 1000))
1354
2006
- ((intmax_t)waited_time.tv_nsec / 1000000));
1355
2007
1356
if (debug){
2008
if(debug){
1357
2009
fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1358
2010
block_time);
1359
2011
}
1360
2012
1361
2013
if(block_time <= 0){
1362
ret = start_mandos_communication(mc.current_server->ip,
1363
mc.current_server->port,
1364
mc.current_server->if_index,
1365
mc.current_server->af);
2014
ret = start_mandos_communication(mc->current_server->ip,
2015
mc->current_server->port,
2016
mc->current_server->if_index,
2017
mc->current_server->af, mc);
1366
2018
if(ret == 0){
1367
avahi_simple_poll_quit(simple_poll);
2019
avahi_simple_poll_quit(s);
1368
2020
return 0;
1369
2021
}
1370
2022
ret = clock_gettime(CLOCK_MONOTONIC,
1371
&mc.current_server->last_seen);
2023
&mc->current_server->last_seen);
1372
2024
if(ret == -1){
1373
2025
perror_plus("clock_gettime");
1374
2026
return -1;
1375
2027
}
1376
mc.current_server = mc.current_server->next;
2028
mc->current_server = mc->current_server->next;
1377
2029
block_time = 0; /* Call avahi to find new Mandos
1378
2030
servers, but don't block */
1379
2031
}
1381
2033
ret = avahi_simple_poll_iterate(s, (int)block_time);
1382
2034
}
1383
2035
if(ret != 0){
1384
if (ret > 0 or errno != EINTR){
2036
if(ret > 0 or errno != EINTR){
1385
2037
return (ret != 1) ? ret : 0;
1386
2038
}
1387
2039
}
1388
2040
}
1389
2041
}
1390
2042
1391
/* Set effective uid to 0, return errno */
1392
error_t raise_privileges(void){
1393
error_t old_errno = errno;
1394
error_t ret_errno = 0;
1395
if(seteuid(0) == -1){
1396
ret_errno = errno;
1397
perror_plus("seteuid");
1398
}
1399
errno = old_errno;
1400
return ret_errno;
1401
}
1402
1403
/* Set effective and real user ID to 0. Return errno. */
1404
error_t raise_privileges_permanently(void){
1405
error_t old_errno = errno;
1406
error_t ret_errno = raise_privileges();
1407
if(ret_errno != 0){
1408
errno = old_errno;
1409
return ret_errno;
1410
}
1411
if(setuid(0) == -1){
1412
ret_errno = errno;
1413
perror_plus("seteuid");
1414
}
1415
errno = old_errno;
1416
return ret_errno;
1417
}
1418
1419
/* Set effective user ID to unprivileged saved user ID */
1420
error_t lower_privileges(void){
1421
error_t old_errno = errno;
1422
error_t ret_errno = 0;
1423
if(seteuid(uid) == -1){
1424
ret_errno = errno;
1425
perror_plus("seteuid");
1426
}
1427
errno = old_errno;
1428
return ret_errno;
1429
}
1430
1431
/* Lower privileges permanently */
1432
error_t lower_privileges_permanently(void){
1433
error_t old_errno = errno;
1434
error_t ret_errno = 0;
1435
if(setuid(uid) == -1){
1436
ret_errno = errno;
1437
perror_plus("setuid");
1438
}
1439
errno = old_errno;
1440
return ret_errno;
1441
}
1442
1443
bool run_network_hooks(const char *mode, const char *interface,
2043
__attribute__((nonnull))
2044
void run_network_hooks(const char *mode, const char *interface,
1444
2045
const float delay){
1445
struct dirent **direntries;
2046
struct dirent **direntries = NULL;
2047
if(hookdir_fd == -1){
2048
hookdir_fd = open(hookdir, O_RDONLY | O_DIRECTORY | O_PATH
2049
| O_CLOEXEC);
2050
if(hookdir_fd == -1){
2051
if(errno == ENOENT){
2052
if(debug){
2053
fprintf_plus(stderr, "Network hook directory \"%s\" not"
2054
" found\n", hookdir);
2055
}
2056
} else {
2057
perror_plus("open");
2058
}
2059
return;
2060
}
2061
}
2062
int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
2063
if(devnull == -1){
2064
perror_plus("open(\"/dev/null\", O_RDONLY)");
2065
return;
2066
}
2067
int numhooks = scandirat(hookdir_fd, ".", &direntries,
2068
runnable_hook, alphasort);
2069
if(numhooks == -1){
2070
perror_plus("scandir");
2071
close(devnull);
2072
return;
2073
}
1446
2074
struct dirent *direntry;
1447
2075
int ret;
1448
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1449
alphasort);
1450
if(numhooks == -1){
1451
if(errno == ENOENT){
1452
if(debug){
1453
fprintf_plus(stderr, "Network hook directory \"%s\" not"
1454
" found\n", hookdir);
1455
}
1456
} else {
1457
perror_plus("scandir");
2076
for(int i = 0; i < numhooks; i++){
2077
direntry = direntries[i];
2078
if(debug){
2079
fprintf_plus(stderr, "Running network hook \"%s\"\n",
2080
direntry->d_name);
1458
2081
}
1459
} else {
1460
int devnull = open("/dev/null", O_RDONLY);
1461
for(int i = 0; i < numhooks; i++){
1462
direntry = direntries[i];
1463
char *fullname = NULL;
1464
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1465
if(ret < 0){
2082
pid_t hook_pid = fork();
2083
if(hook_pid == 0){
2084
/* Child */
2085
/* Raise privileges */
2086
errno = raise_privileges_permanently();
2087
if(errno != 0){
2088
perror_plus("Failed to raise privileges");
2089
_exit(EX_NOPERM);
2090
}
2091
/* Set group */
2092
errno = 0;
2093
ret = setgid(0);
2094
if(ret == -1){
2095
perror_plus("setgid");
2096
_exit(EX_NOPERM);
2097
}
2098
/* Reset supplementary groups */
2099
errno = 0;
2100
ret = setgroups(0, NULL);
2101
if(ret == -1){
2102
perror_plus("setgroups");
2103
_exit(EX_NOPERM);
2104
}
2105
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
2106
if(ret == -1){
2107
perror_plus("setenv");
2108
_exit(EX_OSERR);
2109
}
2110
ret = setenv("DEVICE", interface, 1);
2111
if(ret == -1){
2112
perror_plus("setenv");
2113
_exit(EX_OSERR);
2114
}
2115
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
2116
if(ret == -1){
2117
perror_plus("setenv");
2118
_exit(EX_OSERR);
2119
}
2120
ret = setenv("MODE", mode, 1);
2121
if(ret == -1){
2122
perror_plus("setenv");
2123
_exit(EX_OSERR);
2124
}
2125
char *delaystring;
2126
ret = asprintf(&delaystring, "%f", (double)delay);
2127
if(ret == -1){
1466
2128
perror_plus("asprintf");
1467
continue;
1468
}
1469
if(debug){
1470
fprintf_plus(stderr, "Running network hook \"%s\"\n",
1471
direntry->d_name);
1472
}
1473
pid_t hook_pid = fork();
1474
if(hook_pid == 0){
1475
/* Child */
1476
/* Raise privileges */
1477
raise_privileges_permanently();
1478
/* Set group */
1479
errno = 0;
1480
ret = setgid(0);
1481
if(ret == -1){
1482
perror_plus("setgid");
1483
}
1484
/* Reset supplementary groups */
1485
errno = 0;
1486
ret = setgroups(0, NULL);
1487
if(ret == -1){
1488
perror_plus("setgroups");
1489
}
1490
dup2(devnull, STDIN_FILENO);
1491
close(devnull);
1492
dup2(STDERR_FILENO, STDOUT_FILENO);
1493
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1494
if(ret == -1){
1495
perror_plus("setenv");
1496
_exit(EX_OSERR);
1497
}
1498
ret = setenv("DEVICE", interface, 1);
1499
if(ret == -1){
1500
perror_plus("setenv");
1501
_exit(EX_OSERR);
1502
}
1503
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
1504
if(ret == -1){
1505
perror_plus("setenv");
1506
_exit(EX_OSERR);
1507
}
1508
ret = setenv("MODE", mode, 1);
1509
if(ret == -1){
1510
perror_plus("setenv");
1511
_exit(EX_OSERR);
1512
}
1513
char *delaystring;
1514
ret = asprintf(&delaystring, "%f", delay);
1515
if(ret == -1){
1516
perror_plus("asprintf");
1517
_exit(EX_OSERR);
1518
}
1519
ret = setenv("DELAY", delaystring, 1);
1520
if(ret == -1){
1521
free(delaystring);
1522
perror_plus("setenv");
1523
_exit(EX_OSERR);
1524
}
2129
_exit(EX_OSERR);
2130
}
2131
ret = setenv("DELAY", delaystring, 1);
2132
if(ret == -1){
1525
2133
free(delaystring);
1526
if(connect_to != NULL){
1527
ret = setenv("CONNECT", connect_to, 1);
1528
if(ret == -1){
1529
perror_plus("setenv");
1530
_exit(EX_OSERR);
1531
}
1532
}
1533
if(execl(fullname, direntry->d_name, mode, NULL) == -1){
1534
perror_plus("execl");
1535
_exit(EXIT_FAILURE);
1536
}
2134
perror_plus("setenv");
2135
_exit(EX_OSERR);
2136
}
2137
free(delaystring);
2138
if(connect_to != NULL){
2139
ret = setenv("CONNECT", connect_to, 1);
2140
if(ret == -1){
2141
perror_plus("setenv");
2142
_exit(EX_OSERR);
2143
}
2144
}
2145
int hook_fd = (int)TEMP_FAILURE_RETRY(openat(hookdir_fd,
2146
direntry->d_name,
2147
O_RDONLY));
2148
if(hook_fd == -1){
2149
perror_plus("openat");
2150
_exit(EXIT_FAILURE);
2151
}
2152
if(close(hookdir_fd) == -1){
2153
perror_plus("close");
2154
_exit(EXIT_FAILURE);
2155
}
2156
ret = dup2(devnull, STDIN_FILENO);
2157
if(ret == -1){
2158
perror_plus("dup2(devnull, STDIN_FILENO)");
2159
_exit(EX_OSERR);
2160
}
2161
ret = close(devnull);
2162
if(ret == -1){
2163
perror_plus("close");
2164
_exit(EX_OSERR);
2165
}
2166
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
2167
if(ret == -1){
2168
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
2169
_exit(EX_OSERR);
2170
}
2171
if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
2172
environ) == -1){
2173
perror_plus("fexecve");
2174
_exit(EXIT_FAILURE);
2175
}
2176
} else {
2177
if(hook_pid == -1){
2178
perror_plus("fork");
2179
free(direntry);
2180
continue;
2181
}
2182
int status;
2183
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
2184
perror_plus("waitpid");
2185
free(direntry);
2186
continue;
2187
}
2188
if(WIFEXITED(status)){
2189
if(WEXITSTATUS(status) != 0){
2190
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
2191
" with status %d\n", direntry->d_name,
2192
WEXITSTATUS(status));
2193
free(direntry);
2194
continue;
2195
}
2196
} else if(WIFSIGNALED(status)){
2197
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
2198
" signal %d\n", direntry->d_name,
2199
WTERMSIG(status));
2200
free(direntry);
2201
continue;
1537
2202
} else {
1538
int status;
1539
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1540
perror_plus("waitpid");
1541
free(fullname);
1542
continue;
1543
}
1544
if(WIFEXITED(status)){
1545
if(WEXITSTATUS(status) != 0){
1546
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1547
" with status %d\n", direntry->d_name,
1548
WEXITSTATUS(status));
1549
free(fullname);
1550
continue;
1551
}
1552
} else if(WIFSIGNALED(status)){
1553
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1554
" signal %d\n", direntry->d_name,
1555
WTERMSIG(status));
1556
free(fullname);
1557
continue;
1558
} else {
1559
fprintf_plus(stderr, "Warning: network hook \"%s\""
1560
" crashed\n", direntry->d_name);
1561
free(fullname);
1562
continue;
1563
}
1564
}
1565
free(fullname);
1566
if(debug){
1567
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1568
direntry->d_name);
1569
}
1570
}
1571
close(devnull);
1572
}
1573
return true;
2203
fprintf_plus(stderr, "Warning: network hook \"%s\""
2204
" crashed\n", direntry->d_name);
2205
free(direntry);
2206
continue;
2207
}
2208
}
2209
if(debug){
2210
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
2211
direntry->d_name);
2212
}
2213
free(direntry);
2214
}
2215
free(direntries);
2216
if(close(hookdir_fd) == -1){
2217
perror_plus("close");
2218
} else {
2219
hookdir_fd = -1;
2220
}
2221
close(devnull);
1574
2222
}
1575
2223
1576
error_t bring_up_interface(const char *const interface,
1577
const float delay){
1578
int sd = -1;
1579
error_t old_errno = errno;
1580
error_t ret_errno = 0;
1581
int ret, ret_setflags;
2224
__attribute__((nonnull, warn_unused_result))
2225
int bring_up_interface(const char *const interface,
2226
const float delay){
2227
int old_errno = errno;
2228
int ret;
1582
2229
struct ifreq network;
1583
2230
unsigned int if_index = if_nametoindex(interface);
1584
2231
if(if_index == 0){
1593
2240
}
1594
2241
1595
2242
if(not interface_is_up(interface)){
1596
if(not get_flags(interface, &network) and debug){
2243
int ret_errno = 0;
2244
int ioctl_errno = 0;
2245
if(not get_flags(interface, &network)){
1597
2246
ret_errno = errno;
1598
2247
fprintf_plus(stderr, "Failed to get flags for interface "
1599
2248
"\"%s\"\n", interface);
2249
errno = old_errno;
1600
2250
return ret_errno;
1601
2251
}
1602
network.ifr_flags |= IFF_UP;
2252
network.ifr_flags |= IFF_UP; /* set flag */
1603
2253
1604
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1605
if(sd < 0){
2254
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
2255
if(sd == -1){
1606
2256
ret_errno = errno;
1607
2257
perror_plus("socket");
1608
2258
errno = old_errno;
1609
2259
return ret_errno;
1610
2260
}
1611
2261
1612
2262
if(quit_now){
1613
close(sd);
2263
ret = close(sd);
2264
if(ret == -1){
2265
perror_plus("close");
2266
}
1614
2267
errno = old_errno;
1615
2268
return EINTR;
1616
2269
}
1620
2273
interface);
1621
2274
}
1622
2275
1623
/* Raise priviliges */
1624
raise_privileges();
2276
/* Raise privileges */
2277
ret_errno = raise_privileges();
2278
if(ret_errno != 0){
2279
errno = ret_errno;
2280
perror_plus("Failed to raise privileges");
2281
}
1625
2282
1626
2283
#ifdef __linux__
1627
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1628
messages about the network interface to mess up the prompt */
1629
int ret_linux = klogctl(8, NULL, 5);
1630
bool restore_loglevel = true;
1631
if(ret_linux == -1){
1632
restore_loglevel = false;
1633
perror_plus("klogctl");
2284
int ret_linux;
2285
bool restore_loglevel = false;
2286
if(ret_errno == 0){
2287
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
2288
messages about the network interface to mess up the prompt */
2289
ret_linux = klogctl(8, NULL, 5);
2290
if(ret_linux == -1){
2291
perror_plus("klogctl");
2292
} else {
2293
restore_loglevel = true;
2294
}
1634
2295
}
1635
2296
#endif /* __linux__ */
1636
ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1637
ret_errno = errno;
2297
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
2298
ioctl_errno = errno;
1638
2299
#ifdef __linux__
1639
2300
if(restore_loglevel){
1640
2301
ret_linux = klogctl(7, NULL, 0);
1644
2305
}
1645
2306
#endif /* __linux__ */
1646
2307
1647
/* Lower privileges */
1648
lower_privileges();
2308
/* If raise_privileges() succeeded above */
2309
if(ret_errno == 0){
2310
/* Lower privileges */
2311
ret_errno = lower_privileges();
2312
if(ret_errno != 0){
2313
errno = ret_errno;
2314
perror_plus("Failed to lower privileges");
2315
}
2316
}
1649
2317
1650
2318
/* Close the socket */
1651
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2319
ret = close(sd);
1652
2320
if(ret == -1){
1653
2321
perror_plus("close");
1654
2322
}
1655
2323
1656
2324
if(ret_setflags == -1){
1657
errno = ret_errno;
2325
errno = ioctl_errno;
1658
2326
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1659
2327
errno = old_errno;
1660
return ret_errno;
2328
return ioctl_errno;
1661
2329
}
1662
2330
} else if(debug){
1663
2331
fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
1666
2334
1667
2335
/* Sleep checking until interface is running.
1668
2336
Check every 0.25s, up to total time of delay */
1669
for(int i=0; i < delay * 4; i++){
2337
for(int i = 0; i < delay * 4; i++){
1670
2338
if(interface_is_running(interface)){
1671
2339
break;
1672
2340
}
1681
2349
return 0;
1682
2350
}
1683
2351
1684
error_t take_down_interface(const char *const interface){
1685
int sd = -1;
1686
error_t old_errno = errno;
1687
error_t ret_errno = 0;
1688
int ret, ret_setflags;
2352
__attribute__((nonnull, warn_unused_result))
2353
int take_down_interface(const char *const interface){
2354
int old_errno = errno;
1689
2355
struct ifreq network;
1690
2356
unsigned int if_index = if_nametoindex(interface);
1691
2357
if(if_index == 0){
1694
2360
return ENXIO;
1695
2361
}
1696
2362
if(interface_is_up(interface)){
2363
int ret_errno = 0;
2364
int ioctl_errno = 0;
1697
2365
if(not get_flags(interface, &network) and debug){
1698
2366
ret_errno = errno;
1699
2367
fprintf_plus(stderr, "Failed to get flags for interface "
1700
2368
"\"%s\"\n", interface);
2369
errno = old_errno;
1701
2370
return ret_errno;
1702
2371
}
1703
2372
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
1704
2373
1705
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1706
if(sd < 0){
2374
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
2375
if(sd == -1){
1707
2376
ret_errno = errno;
1708
2377
perror_plus("socket");
1709
2378
errno = old_errno;
1715
2384
interface);
1716
2385
}
1717
2386
1718
/* Raise priviliges */
1719
raise_privileges();
1720
1721
ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1722
ret_errno = errno;
1723
1724
/* Lower privileges */
1725
lower_privileges();
2387
/* Raise privileges */
2388
ret_errno = raise_privileges();
2389
if(ret_errno != 0){
2390
errno = ret_errno;
2391
perror_plus("Failed to raise privileges");
2392
}
2393
2394
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
2395
ioctl_errno = errno;
2396
2397
/* If raise_privileges() succeeded above */
2398
if(ret_errno == 0){
2399
/* Lower privileges */
2400
ret_errno = lower_privileges();
2401
if(ret_errno != 0){
2402
errno = ret_errno;
2403
perror_plus("Failed to lower privileges");
2404
}
2405
}
1726
2406
1727
2407
/* Close the socket */
1728
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2408
int ret = close(sd);
1729
2409
if(ret == -1){
1730
2410
perror_plus("close");
1731
2411
}
1732
2412
1733
2413
if(ret_setflags == -1){
1734
errno = ret_errno;
2414
errno = ioctl_errno;
1735
2415
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
1736
2416
errno = old_errno;
1737
return ret_errno;
2417
return ioctl_errno;
1738
2418
}
1739
2419
} else if(debug){
1740
2420
fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
1746
2426
}
1747
2427
1748
2428
int main(int argc, char *argv[]){
2429
mandos_context mc = { .server = NULL, .dh_bits = 0,
2430
.priority = "SECURE256:!CTYPE-X.509"
2431
":+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256",
2432
.current_server = NULL, .interfaces = NULL,
2433
.interfaces_size = 0 };
1749
2434
AvahiSServiceBrowser *sb = NULL;
1750
2435
error_t ret_errno;
1751
2436
int ret;
1752
2437
intmax_t tmpmax;
1753
2438
char *tmp;
1754
2439
int exitcode = EXIT_SUCCESS;
1755
char *interfaces = NULL;
1756
size_t interfaces_size = 0;
1757
2440
char *interfaces_to_take_down = NULL;
1758
2441
size_t interfaces_to_take_down_size = 0;
1759
char tempdir[] = "/tmp/mandosXXXXXX";
1760
bool tempdir_created = false;
2442
char run_tempdir[] = "/run/tmp/mandosXXXXXX";
2443
char old_tempdir[] = "/tmp/mandosXXXXXX";
2444
char *tempdir = NULL;
1761
2445
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1762
2446
const char *seckey = PATHDIR "/" SECKEY;
1763
2447
const char *pubkey = PATHDIR "/" PUBKEY;
2448
const char *dh_params_file = NULL;
1764
2449
char *interfaces_hooks = NULL;
1765
size_t interfaces_hooks_size = 0;
1766
2450
1767
2451
bool gnutls_initialized = false;
1768
2452
bool gpgme_initialized = false;
1820
2504
.doc = "Bit length of the prime number used in the"
1821
2505
" Diffie-Hellman key exchange",
1822
2506
.group = 2 },
2507
{ .name = "dh-params", .key = 134,
2508
.arg = "FILE",
2509
.doc = "PEM-encoded PKCS#3 file with pre-generated parameters"
2510
" for the Diffie-Hellman key exchange",
2511
.group = 2 },
1823
2512
{ .name = "priority", .key = 130,
1824
2513
.arg = "STRING",
1825
2514
.doc = "GnuTLS priority string for the TLS handshake",
1859
2548
connect_to = arg;
1860
2549
break;
1861
2550
case 'i': /* --interface */
1862
ret_errno = argz_add_sep(&interfaces, &interfaces_size, arg,
1863
(int)',');
2551
ret_errno = argz_add_sep(&mc.interfaces, &mc.interfaces_size,
2552
arg, (int)',');
1864
2553
if(ret_errno != 0){
1865
2554
argp_error(state, "%s", strerror(ret_errno));
1866
2555
}
1880
2569
}
1881
2570
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
1882
2571
break;
2572
case 134: /* --dh-params */
2573
dh_params_file = arg;
2574
break;
1883
2575
case 130: /* --priority */
1884
2576
mc.priority = arg;
1885
2577
break;
1925
2617
.args_doc = "",
1926
2618
.doc = "Mandos client -- Get and decrypt"
1927
2619
" passwords from a Mandos server" };
1928
ret = argp_parse(&argp, argc, argv,
1929
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
1930
switch(ret){
2620
ret_errno = argp_parse(&argp, argc, argv,
2621
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2622
switch(ret_errno){
1931
2623
case 0:
1932
2624
break;
1933
2625
case ENOMEM:
1934
2626
default:
1935
errno = ret;
2627
errno = ret_errno;
1936
2628
perror_plus("argp_parse");
1937
2629
exitcode = EX_OSERR;
1938
2630
goto end;
1941
2633
goto end;
1942
2634
}
1943
2635
}
1944
2636
1945
2637
{
1946
2638
/* Work around Debian bug #633582:
1947
<http://bugs.debian.org/633582> */
2639
<https://bugs.debian.org/633582> */
1948
2640
1949
/* Re-raise priviliges */
1950
if(raise_privileges() == 0){
2641
/* Re-raise privileges */
2642
ret = raise_privileges();
2643
if(ret != 0){
2644
errno = ret;
2645
perror_plus("Failed to raise privileges");
2646
} else {
1951
2647
struct stat st;
1952
2648
1953
2649
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
1967
2663
}
1968
2664
}
1969
2665
}
1970
TEMP_FAILURE_RETRY(close(seckey_fd));
2666
close(seckey_fd);
1971
2667
}
1972
2668
}
1973
2669
1974
2670
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
1975
2671
int pubkey_fd = open(pubkey, O_RDONLY);
1976
2672
if(pubkey_fd == -1){
1988
2684
}
1989
2685
}
1990
2686
}
1991
TEMP_FAILURE_RETRY(close(pubkey_fd));
1992
}
1993
}
1994
2687
close(pubkey_fd);
2688
}
2689
}
2690
2691
if(dh_params_file != NULL
2692
and strcmp(dh_params_file, PATHDIR "/dhparams.pem" ) == 0){
2693
int dhparams_fd = open(dh_params_file, O_RDONLY);
2694
if(dhparams_fd == -1){
2695
perror_plus("open");
2696
} else {
2697
ret = (int)TEMP_FAILURE_RETRY(fstat(dhparams_fd, &st));
2698
if(ret == -1){
2699
perror_plus("fstat");
2700
} else {
2701
if(S_ISREG(st.st_mode)
2702
and st.st_uid == 0 and st.st_gid == 0){
2703
ret = fchown(dhparams_fd, uid, gid);
2704
if(ret == -1){
2705
perror_plus("fchown");
2706
}
2707
}
2708
}
2709
close(dhparams_fd);
2710
}
2711
}
2712
1995
2713
/* Lower privileges */
1996
errno = 0;
1997
ret = seteuid(uid);
1998
if(ret == -1){
1999
perror_plus("seteuid");
2714
ret = lower_privileges();
2715
if(ret != 0){
2716
errno = ret;
2717
perror_plus("Failed to lower privileges");
2000
2718
}
2001
2719
}
2002
2720
}
2003
2721
2004
/* Remove empty interface names */
2722
/* Remove invalid interface names (except "none") */
2005
2723
{
2006
2724
char *interface = NULL;
2007
while((interface = argz_next(interfaces, interfaces_size,
2725
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2008
2726
interface))){
2009
if(if_nametoindex(interface) == 0){
2010
if(interface[0] != '\0' and strcmp(interface, "none") != 0){
2727
if(strcmp(interface, "none") != 0
2728
and if_nametoindex(interface) == 0){
2729
if(interface[0] != '\0'){
2011
2730
fprintf_plus(stderr, "Not using nonexisting interface"
2012
2731
" \"%s\"\n", interface);
2013
2732
}
2014
argz_delete(&interfaces, &interfaces_size, interface);
2733
argz_delete(&mc.interfaces, &mc.interfaces_size, interface);
2015
2734
interface = NULL;
2016
2735
}
2017
2736
}
2019
2738
2020
2739
/* Run network hooks */
2021
2740
{
2022
2023
if(interfaces != NULL){
2024
interfaces_hooks = malloc(interfaces_size);
2741
if(mc.interfaces != NULL){
2742
interfaces_hooks = malloc(mc.interfaces_size);
2025
2743
if(interfaces_hooks == NULL){
2026
2744
perror_plus("malloc");
2027
2745
goto end;
2028
2746
}
2029
memcpy(interfaces_hooks, interfaces, interfaces_size);
2030
interfaces_hooks_size = interfaces_size;
2031
argz_stringify(interfaces_hooks, interfaces_hooks_size,
2032
(int)',');
2033
}
2034
if(not run_network_hooks("start", interfaces_hooks != NULL ?
2035
interfaces_hooks : "", delay)){
2036
goto end;
2037
}
2747
memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
2748
argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
2749
}
2750
run_network_hooks("start", interfaces_hooks != NULL ?
2751
interfaces_hooks : "", delay);
2038
2752
}
2039
2753
2040
2754
if(not debug){
2117
2831
}
2118
2832
2119
2833
/* If no interfaces were specified, make a list */
2120
if(interfaces == NULL){
2121
struct dirent **direntries;
2834
if(mc.interfaces == NULL){
2835
struct dirent **direntries = NULL;
2122
2836
/* Look for any good interfaces */
2123
2837
ret = scandir(sys_class_net, &direntries, good_interface,
2124
2838
alphasort);
2125
2839
if(ret >= 1){
2126
2840
/* Add all found interfaces to interfaces list */
2127
2841
for(int i = 0; i < ret; ++i){
2128
ret_errno = argz_add(&interfaces, &interfaces_size,
2842
ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
2129
2843
direntries[i]->d_name);
2130
2844
if(ret_errno != 0){
2845
errno = ret_errno;
2131
2846
perror_plus("argz_add");
2847
free(direntries[i]);
2132
2848
continue;
2133
2849
}
2134
2850
if(debug){
2135
2851
fprintf_plus(stderr, "Will use interface \"%s\"\n",
2136
2852
direntries[i]->d_name);
2137
2853
}
2854
free(direntries[i]);
2138
2855
}
2139
2856
free(direntries);
2140
2857
} else {
2141
free(direntries);
2858
if(ret == 0){
2859
free(direntries);
2860
}
2142
2861
fprintf_plus(stderr, "Could not find a network interface\n");
2143
2862
exitcode = EXIT_FAILURE;
2144
2863
goto end;
2145
2864
}
2146
2865
}
2147
2866
2148
/* If we only got one interface, explicitly use only that one */
2149
if(argz_count(interfaces, interfaces_size) == 1){
2150
if(debug){
2151
fprintf_plus(stderr, "Using only interface \"%s\"\n",
2152
interfaces);
2153
}
2154
if_index = (AvahiIfIndex)if_nametoindex(interfaces);
2155
}
2156
2157
/* Bring up interfaces which are down */
2158
if(not (argz_count(interfaces, interfaces_size) == 1
2159
and strcmp(interfaces, "none") == 0)){
2867
/* Bring up interfaces which are down, and remove any "none"s */
2868
{
2160
2869
char *interface = NULL;
2161
while((interface = argz_next(interfaces, interfaces_size,
2870
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2162
2871
interface))){
2872
/* If interface name is "none", stop bringing up interfaces.
2873
Also remove all instances of "none" from the list */
2874
if(strcmp(interface, "none") == 0){
2875
argz_delete(&mc.interfaces, &mc.interfaces_size,
2876
interface);
2877
interface = NULL;
2878
while((interface = argz_next(mc.interfaces,
2879
mc.interfaces_size, interface))){
2880
if(strcmp(interface, "none") == 0){
2881
argz_delete(&mc.interfaces, &mc.interfaces_size,
2882
interface);
2883
interface = NULL;
2884
}
2885
}
2886
break;
2887
}
2163
2888
bool interface_was_up = interface_is_up(interface);
2164
ret = bring_up_interface(interface, delay);
2889
errno = bring_up_interface(interface, delay);
2165
2890
if(not interface_was_up){
2166
if(ret != 0){
2167
errno = ret;
2168
perror_plus("Failed to bring up interface");
2891
if(errno != 0){
2892
fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
2893
" %s\n", interface, strerror(errno));
2169
2894
} else {
2170
ret_errno = argz_add(&interfaces_to_take_down,
2171
&interfaces_to_take_down_size,
2172
interface);
2895
errno = argz_add(&interfaces_to_take_down,
2896
&interfaces_to_take_down_size,
2897
interface);
2898
if(errno != 0){
2899
perror_plus("argz_add");
2900
}
2173
2901
}
2174
2902
}
2175
2903
}
2176
free(interfaces);
2177
interfaces = NULL;
2178
interfaces_size = 0;
2179
2904
if(debug and (interfaces_to_take_down == NULL)){
2180
2905
fprintf_plus(stderr, "No interfaces were brought up\n");
2181
2906
}
2182
2907
}
2183
2908
2909
/* If we only got one interface, explicitly use only that one */
2910
if(argz_count(mc.interfaces, mc.interfaces_size) == 1){
2911
if(debug){
2912
fprintf_plus(stderr, "Using only interface \"%s\"\n",
2913
mc.interfaces);
2914
}
2915
if_index = (AvahiIfIndex)if_nametoindex(mc.interfaces);
2916
}
2917
2184
2918
if(quit_now){
2185
2919
goto end;
2186
2920
}
2187
2921
2188
ret = init_gnutls_global(pubkey, seckey);
2922
ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
2189
2923
if(ret == -1){
2190
2924
fprintf_plus(stderr, "init_gnutls_global failed\n");
2191
2925
exitcode = EX_UNAVAILABLE;
2198
2932
goto end;
2199
2933
}
2200
2934
2201
if(mkdtemp(tempdir) == NULL){
2935
/* Try /run/tmp before /tmp */
2936
tempdir = mkdtemp(run_tempdir);
2937
if(tempdir == NULL and errno == ENOENT){
2938
if(debug){
2939
fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
2940
run_tempdir, old_tempdir);
2941
}
2942
tempdir = mkdtemp(old_tempdir);
2943
}
2944
if(tempdir == NULL){
2202
2945
perror_plus("mkdtemp");
2203
2946
goto end;
2204
2947
}
2205
tempdir_created = true;
2206
2948
2207
2949
if(quit_now){
2208
2950
goto end;
2209
2951
}
2210
2952
2211
if(not init_gpgme(pubkey, seckey, tempdir)){
2953
if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
2212
2954
fprintf_plus(stderr, "init_gpgme failed\n");
2213
2955
exitcode = EX_UNAVAILABLE;
2214
2956
goto end;
2244
2986
exitcode = EX_USAGE;
2245
2987
goto end;
2246
2988
}
2247
2989
2248
2990
if(quit_now){
2249
2991
goto end;
2250
2992
}
2271
3013
}
2272
3014
2273
3015
while(not quit_now){
2274
ret = start_mandos_communication(address, port, if_index, af);
3016
ret = start_mandos_communication(address, port, if_index, af,
3017
&mc);
2275
3018
if(quit_now or ret == 0){
2276
3019
break;
2277
3020
}
2279
3022
fprintf_plus(stderr, "Retrying in %d seconds\n",
2280
3023
(int)retry_interval);
2281
3024
}
2282
sleep((int)retry_interval);
3025
sleep((unsigned int)retry_interval);
2283
3026
}
2284
3027
2285
if (not quit_now){
3028
if(not quit_now){
2286
3029
exitcode = EXIT_SUCCESS;
2287
3030
}
2288
3031
2304
3047
2305
3048
/* Allocate a new server */
2306
3049
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
2307
&config, NULL, NULL, &ret_errno);
3050
&config, NULL, NULL, &ret);
2308
3051
2309
3052
/* Free the Avahi configuration data */
2310
3053
avahi_server_config_free(&config);
2313
3056
/* Check if creating the Avahi server object succeeded */
2314
3057
if(mc.server == NULL){
2315
3058
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2316
avahi_strerror(ret_errno));
3059
avahi_strerror(ret));
2317
3060
exitcode = EX_UNAVAILABLE;
2318
3061
goto end;
2319
3062
}
2325
3068
/* Create the Avahi service browser */
2326
3069
sb = avahi_s_service_browser_new(mc.server, if_index,
2327
3070
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
2328
NULL, 0, browse_callback, NULL);
3071
NULL, 0, browse_callback,
3072
(void *)&mc);
2329
3073
if(sb == NULL){
2330
3074
fprintf_plus(stderr, "Failed to create service browser: %s\n",
2331
3075
avahi_strerror(avahi_server_errno(mc.server)));
2342
3086
if(debug){
2343
3087
fprintf_plus(stderr, "Starting Avahi loop search\n");
2344
3088
}
2345
3089
2346
3090
ret = avahi_loop_with_timeout(simple_poll,
2347
(int)(retry_interval * 1000));
3091
(int)(retry_interval * 1000), &mc);
2348
3092
if(debug){
2349
3093
fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
2350
3094
(ret == 0) ? "successfully" : "with error");
2353
3097
end:
2354
3098
2355
3099
if(debug){
2356
fprintf_plus(stderr, "%s exiting\n", argv[0]);
3100
if(signal_received){
3101
fprintf_plus(stderr, "%s exiting due to signal %d: %s\n",
3102
argv[0], signal_received,
3103
strsignal(signal_received));
3104
} else {
3105
fprintf_plus(stderr, "%s exiting\n", argv[0]);
3106
}
2357
3107
}
2358
3108
2359
3109
/* Cleanup things */
3110
free(mc.interfaces);
3111
2360
3112
if(sb != NULL)
2361
3113
avahi_s_service_browser_free(sb);
2362
3114
2368
3120
2369
3121
if(gnutls_initialized){
2370
3122
gnutls_certificate_free_credentials(mc.cred);
2371
gnutls_global_deinit();
2372
3123
gnutls_dh_params_deinit(mc.dh_params);
2373
3124
}
2374
3125
2382
3133
mc.current_server->prev->next = NULL;
2383
3134
while(mc.current_server != NULL){
2384
3135
server *next = mc.current_server->next;
3136
#ifdef __GNUC__
3137
#pragma GCC diagnostic push
3138
#pragma GCC diagnostic ignored "-Wcast-qual"
3139
#endif
3140
free((char *)(mc.current_server->ip));
3141
#ifdef __GNUC__
3142
#pragma GCC diagnostic pop
3143
#endif
2385
3144
free(mc.current_server);
2386
3145
mc.current_server = next;
2387
3146
}
2388
3147
}
2389
3148
2390
/* Re-raise priviliges */
3149
/* Re-raise privileges */
2391
3150
{
2392
raise_privileges();
2393
2394
/* Run network hooks */
2395
run_network_hooks("stop", interfaces_hooks != NULL ?
2396
interfaces_hooks : "", delay);
2397
2398
/* Take down the network interfaces which were brought up */
2399
{
2400
char *interface = NULL;
2401
while((interface=argz_next(interfaces_to_take_down,
2402
interfaces_to_take_down_size,
2403
interface))){
2404
ret_errno = take_down_interface(interface);
2405
if(ret_errno != 0){
2406
errno = ret_errno;
2407
perror_plus("Failed to take down interface");
2408
}
2409
}
2410
if(debug and (interfaces_to_take_down == NULL)){
2411
fprintf_plus(stderr, "No interfaces needed to be taken"
2412
" down\n");
2413
}
2414
}
2415
2416
lower_privileges_permanently();
3151
ret = raise_privileges();
3152
if(ret != 0){
3153
errno = ret;
3154
perror_plus("Failed to raise privileges");
3155
} else {
3156
3157
/* Run network hooks */
3158
run_network_hooks("stop", interfaces_hooks != NULL ?
3159
interfaces_hooks : "", delay);
3160
3161
/* Take down the network interfaces which were brought up */
3162
{
3163
char *interface = NULL;
3164
while((interface = argz_next(interfaces_to_take_down,
3165
interfaces_to_take_down_size,
3166
interface))){
3167
ret = take_down_interface(interface);
3168
if(ret != 0){
3169
errno = ret;
3170
perror_plus("Failed to take down interface");
3171
}
3172
}
3173
if(debug and (interfaces_to_take_down == NULL)){
3174
fprintf_plus(stderr, "No interfaces needed to be taken"
3175
" down\n");
3176
}
3177
}
3178
}
3179
3180
ret = lower_privileges_permanently();
3181
if(ret != 0){
3182
errno = ret;
3183
perror_plus("Failed to lower privileges permanently");
3184
}
2417
3185
}
2418
3186
2419
3187
free(interfaces_to_take_down);
2420
3188
free(interfaces_hooks);
2421
3189
3190
void clean_dir_at(int base, const char * const dirname,
3191
uintmax_t level){
3192
struct dirent **direntries = NULL;
3193
int dret;
3194
int dir_fd = (int)TEMP_FAILURE_RETRY(openat(base, dirname,
3195
O_RDONLY
3196
| O_NOFOLLOW
3197
| O_DIRECTORY
3198
| O_PATH));
3199
if(dir_fd == -1){
3200
perror_plus("open");
3201
return;
3202
}
3203
int numentries = scandirat(dir_fd, ".", &direntries,
3204
notdotentries, alphasort);
3205
if(numentries >= 0){
3206
for(int i = 0; i < numentries; i++){
3207
if(debug){
3208
fprintf_plus(stderr, "Unlinking \"%s/%s\"\n",
3209
dirname, direntries[i]->d_name);
3210
}
3211
dret = unlinkat(dir_fd, direntries[i]->d_name, 0);
3212
if(dret == -1){
3213
if(errno == EISDIR){
3214
dret = unlinkat(dir_fd, direntries[i]->d_name,
3215
AT_REMOVEDIR);
3216
}
3217
if((dret == -1) and (errno == ENOTEMPTY)
3218
and (strcmp(direntries[i]->d_name, "private-keys-v1.d")
3219
== 0) and (level == 0)){
3220
/* Recurse only in this special case */
3221
clean_dir_at(dir_fd, direntries[i]->d_name, level+1);
3222
dret = 0;
3223
}
3224
if((dret == -1) and (errno != ENOENT)){
3225
fprintf_plus(stderr, "unlink(\"%s/%s\"): %s\n", dirname,
3226
direntries[i]->d_name, strerror(errno));
3227
}
3228
}
3229
free(direntries[i]);
3230
}
3231
3232
/* need to clean even if 0 because man page doesn't specify */
3233
free(direntries);
3234
dret = unlinkat(base, dirname, AT_REMOVEDIR);
3235
if(dret == -1 and errno != ENOENT){
3236
perror_plus("rmdir");
3237
}
3238
} else {
3239
perror_plus("scandirat");
3240
}
3241
close(dir_fd);
3242
}
3243
2422
3244
/* Removes the GPGME temp directory and all files inside */
2423
if(tempdir_created){
2424
struct dirent **direntries = NULL;
2425
struct dirent *direntry = NULL;
2426
int numentries = scandir(tempdir, &direntries, notdotentries,
2427
alphasort);
2428
if (numentries > 0){
2429
for(int i = 0; i < numentries; i++){
2430
direntry = direntries[i];
2431
char *fullname = NULL;
2432
ret = asprintf(&fullname, "%s/%s", tempdir,
2433
direntry->d_name);
2434
if(ret < 0){
2435
perror_plus("asprintf");
2436
continue;
2437
}
2438
ret = remove(fullname);
2439
if(ret == -1){
2440
fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2441
strerror(errno));
2442
}
2443
free(fullname);
2444
}
2445
}
2446
2447
/* need to clean even if 0 because man page doesn't specify */
2448
free(direntries);
2449
if (numentries == -1){
2450
perror_plus("scandir");
2451
}
2452
ret = rmdir(tempdir);
2453
if(ret == -1 and errno != ENOENT){
2454
perror_plus("rmdir");
2455
}
3245
if(tempdir != NULL){
3246
clean_dir_at(-1, tempdir, 0);
2456
3247
}
2457
3248
2458
3249
if(quit_now){
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0