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 1131
- compare with another revision
- download diff
- download tarball
- view history from revision 1131
- Committer: Teddy Hogeborn
- Date: 2019-07-29 16:35:53 UTC
- Revision ID: teddy@recompile.se-20190729163553-1i442i2cbx64c537
Make tests and man page examples match
Make the tests test_manual_page_example[1-5] match exactly what is
written in the manual page, and add comments to manual page as
reminders to keep tests and manual page examples in sync.
* mandos-ctl (Test_commands_from_options.test_manual_page_example_1):
Remove "--verbose" option, since the manual does not have it as the
first example, and change assertion to match.
* mandos-ctl.xml (EXAMPLE): Add comments to all examples documenting
which test function they correspond to. Also remove unnecessary
quotes from option arguments in fourth example, and clarify language
slightly in fifth example.
Make the tests test_manual_page_example[1-5] match exactly what is
written in the manual page, and add comments to manual page as
reminders to keep tests and manual page examples in sync.
* mandos-ctl (Test_commands_from_options.test_manual_page_example_1):
Remove "--verbose" option, since the manual does not have it as the
first example, and change assertion to match.
* mandos-ctl.xml (EXAMPLE): Add comments to all examples documenting
which test function they correspond to. Also remove unnecessary
quotes from option arguments in fourth example, and clarify language
slightly in fifth example.
- files added:
- bugs.xml
- debian/tests
- debian/upstream
- dracut-module
- plugin-helpers
- files removed:
- initramfs-tools-hook-conf
- files modified:
- .bzrignore
added
removed
plugins.d/mandos-client.c
9
9
* "browse_callback", and parts of "main".
10
10
*
11
11
* Everything else is
12
* Copyright © 2008-2011 Teddy Hogeborn
13
* Copyright © 2008-2011 Björn Påhlsson
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-2019 Teddy Hogeborn
13
* Copyright © 2008-2019 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
#include <stdint.h> /* uint16_t, uint32_t */
44
stdout, ferror() */
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 <assert.h> /* assert() */
65
#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,
66
72
program_invocation_short_name */
67
73
#include <time.h> /* nanosleep(), time(), sleep() */
68
74
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
73
79
*/
74
80
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
75
81
getuid(), getgid(), seteuid(),
76
setgid(), pause(), _exit() */
77
#include <arpa/inet.h> /* inet_pton(), htons, inet_ntop() */
82
setgid(), pause(), _exit(),
83
unlinkat() */
84
#include <arpa/inet.h> /* inet_pton(), htons() */
78
85
#include <iso646.h> /* not, or, and */
79
86
#include <argp.h> /* struct argp_option, error_t, struct
80
87
argp_state, struct argp,
88
95
#include <sys/wait.h> /* waitpid(), WIFEXITED(),
89
96
WEXITSTATUS(), WTERMSIG() */
90
97
#include <grp.h> /* setgroups() */
98
#include <argz.h> /* argz_add_sep(), argz_next(),
99
argz_delete(), argz_append(),
100
argz_stringify(), argz_add(),
101
argz_count() */
102
#include <netdb.h> /* getnameinfo(), NI_NUMERICHOST,
103
EAI_SYSTEM, gai_strerror() */
91
104
92
105
#ifdef __linux__
93
106
#include <sys/klog.h> /* klogctl() */
110
123
gnutls_*
111
124
init_gnutls_session(),
112
125
GNUTLS_* */
126
#if GNUTLS_VERSION_NUMBER < 0x030600
113
127
#include <gnutls/openpgp.h>
114
128
/* gnutls_certificate_set_openpgp_key_file(),
115
129
GNUTLS_OPENPGP_FMT_BASE64 */
130
#elif GNUTLS_VERSION_NUMBER >= 0x030606
131
#include <gnutls/x509.h> /* gnutls_pkcs_encrypt_flags_t,
132
GNUTLS_PKCS_PLAIN,
133
GNUTLS_PKCS_NULL_PASSWORD */
134
#endif
116
135
117
136
/* GPGME */
118
137
#include <gpgme.h> /* All GPGME types, constants and
126
145
#define PATHDIR "/conf/conf.d/mandos"
127
146
#define SECKEY "seckey.txt"
128
147
#define PUBKEY "pubkey.txt"
148
#define TLS_PRIVKEY "tls-privkey.pem"
149
#define TLS_PUBKEY "tls-pubkey.pem"
129
150
#define HOOKDIR "/lib/mandos/network-hooks.d"
130
151
131
152
bool debug = false;
135
156
static const char sys_class_net[] = "/sys/class/net";
136
157
char *connect_to = NULL;
137
158
const char *hookdir = HOOKDIR;
159
int hookdir_fd = -1;
160
uid_t uid = 65534;
161
gid_t gid = 65534;
138
162
139
163
/* Doubly linked list that need to be circularly linked when used */
140
164
typedef struct server{
141
165
const char *ip;
142
uint16_t port;
166
in_port_t port;
143
167
AvahiIfIndex if_index;
144
168
int af;
145
169
struct timespec last_seen;
149
173
150
174
/* Used for passing in values through the Avahi callback functions */
151
175
typedef struct {
152
AvahiSimplePoll *simple_poll;
153
176
AvahiServer *server;
154
177
gnutls_certificate_credentials_t cred;
155
178
unsigned int dh_bits;
157
180
const char *priority;
158
181
gpgme_ctx_t ctx;
159
182
server *current_server;
183
char *interfaces;
184
size_t interfaces_size;
160
185
} mandos_context;
161
186
162
/* global context so signal handler can reach it*/
163
mandos_context mc = { .simple_poll = NULL, .server = NULL,
164
.dh_bits = 1024, .priority = "SECURE256"
165
":!CTYPE-X.509:+CTYPE-OPENPGP",
166
.current_server = NULL };
187
/* global so signal handler can reach it*/
188
AvahiSimplePoll *simple_poll;
167
189
168
190
sig_atomic_t quit_now = 0;
169
191
int signal_received = 0;
170
192
171
193
/* Function to use when printing errors */
172
194
void perror_plus(const char *print_text){
195
int e = errno;
173
196
fprintf(stderr, "Mandos plugin %s: ",
174
197
program_invocation_short_name);
198
errno = e;
175
199
perror(print_text);
176
200
}
177
201
202
__attribute__((format (gnu_printf, 2, 3), nonnull))
178
203
int fprintf_plus(FILE *stream, const char *format, ...){
179
204
va_list ap;
180
205
va_start (ap, format);
181
206
182
207
TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
183
208
program_invocation_short_name));
184
return TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
209
return (int)TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
185
210
}
186
211
187
212
/*
189
214
* bytes. "buffer_capacity" is how much is currently allocated,
190
215
* "buffer_length" is how much is already used.
191
216
*/
217
__attribute__((nonnull, warn_unused_result))
192
218
size_t incbuffer(char **buffer, size_t buffer_length,
193
219
size_t buffer_capacity){
194
220
if(buffer_length + BUFFER_SIZE > buffer_capacity){
195
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
196
if(buffer == NULL){
221
char *new_buf = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
222
if(new_buf == NULL){
223
int old_errno = errno;
224
free(*buffer);
225
errno = old_errno;
226
*buffer = NULL;
197
227
return 0;
198
228
}
229
*buffer = new_buf;
199
230
buffer_capacity += BUFFER_SIZE;
200
231
}
201
232
return buffer_capacity;
202
233
}
203
234
204
235
/* Add server to set of servers to retry periodically */
205
bool add_server(const char *ip, uint16_t port, AvahiIfIndex if_index,
206
int af){
236
__attribute__((nonnull, warn_unused_result))
237
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
238
int af, server **current_server){
207
239
int ret;
208
240
server *new_server = malloc(sizeof(server));
209
241
if(new_server == NULL){
216
248
.af = af };
217
249
if(new_server->ip == NULL){
218
250
perror_plus("strdup");
251
free(new_server);
252
return false;
253
}
254
ret = clock_gettime(CLOCK_MONOTONIC, &(new_server->last_seen));
255
if(ret == -1){
256
perror_plus("clock_gettime");
257
#ifdef __GNUC__
258
#pragma GCC diagnostic push
259
#pragma GCC diagnostic ignored "-Wcast-qual"
260
#endif
261
free((char *)(new_server->ip));
262
#ifdef __GNUC__
263
#pragma GCC diagnostic pop
264
#endif
265
free(new_server);
219
266
return false;
220
267
}
221
268
/* Special case of first server */
222
if (mc.current_server == NULL){
269
if(*current_server == NULL){
223
270
new_server->next = new_server;
224
271
new_server->prev = new_server;
225
mc.current_server = new_server;
226
/* Place the new server last in the list */
272
*current_server = new_server;
227
273
} else {
228
new_server->next = mc.current_server;
229
new_server->prev = mc.current_server->prev;
274
/* Place the new server last in the list */
275
new_server->next = *current_server;
276
new_server->prev = (*current_server)->prev;
230
277
new_server->prev->next = new_server;
231
mc.current_server->prev = new_server;
232
}
233
ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);
234
if(ret == -1){
235
perror_plus("clock_gettime");
236
return false;
278
(*current_server)->prev = new_server;
237
279
}
238
280
return true;
239
281
}
240
282
283
/* Set effective uid to 0, return errno */
284
__attribute__((warn_unused_result))
285
int raise_privileges(void){
286
int old_errno = errno;
287
int ret = 0;
288
if(seteuid(0) == -1){
289
ret = errno;
290
}
291
errno = old_errno;
292
return ret;
293
}
294
295
/* Set effective and real user ID to 0. Return errno. */
296
__attribute__((warn_unused_result))
297
int raise_privileges_permanently(void){
298
int old_errno = errno;
299
int ret = raise_privileges();
300
if(ret != 0){
301
errno = old_errno;
302
return ret;
303
}
304
if(setuid(0) == -1){
305
ret = errno;
306
}
307
errno = old_errno;
308
return ret;
309
}
310
311
/* Set effective user ID to unprivileged saved user ID */
312
__attribute__((warn_unused_result))
313
int lower_privileges(void){
314
int old_errno = errno;
315
int ret = 0;
316
if(seteuid(uid) == -1){
317
ret = errno;
318
}
319
errno = old_errno;
320
return ret;
321
}
322
323
/* Lower privileges permanently */
324
__attribute__((warn_unused_result))
325
int lower_privileges_permanently(void){
326
int old_errno = errno;
327
int ret = 0;
328
if(setuid(uid) == -1){
329
ret = errno;
330
}
331
errno = old_errno;
332
return ret;
333
}
334
241
335
/*
242
336
* Initialize GPGME.
243
337
*/
244
static bool init_gpgme(const char *seckey, const char *pubkey,
245
const char *tempdir){
338
__attribute__((nonnull, warn_unused_result))
339
static bool init_gpgme(const char * const seckey,
340
const char * const pubkey,
341
const char * const tempdir,
342
mandos_context *mc){
246
343
gpgme_error_t rc;
247
344
gpgme_engine_info_t engine_info;
248
345
249
250
346
/*
251
347
* Helper function to insert pub and seckey to the engine keyring.
252
348
*/
253
bool import_key(const char *filename){
349
bool import_key(const char * const filename){
254
350
int ret;
255
351
int fd;
256
352
gpgme_data_t pgp_data;
261
357
return false;
262
358
}
263
359
360
/* Workaround for systems without a real-time clock; see also
361
Debian bug #894495: <https://bugs.debian.org/894495> */
362
do {
363
{
364
time_t currtime = time(NULL);
365
if(currtime != (time_t)-1){
366
struct tm tm;
367
if(gmtime_r(&currtime, &tm) == NULL) {
368
perror_plus("gmtime_r");
369
break;
370
}
371
if(tm.tm_year != 70 or tm.tm_mon != 0){
372
break;
373
}
374
if(debug){
375
fprintf_plus(stderr, "System clock is January 1970");
376
}
377
} else {
378
if(debug){
379
fprintf_plus(stderr, "System clock is invalid");
380
}
381
}
382
}
383
struct stat keystat;
384
ret = fstat(fd, &keystat);
385
if(ret != 0){
386
perror_plus("fstat");
387
break;
388
}
389
ret = raise_privileges();
390
if(ret != 0){
391
errno = ret;
392
perror_plus("Failed to raise privileges");
393
break;
394
}
395
if(debug){
396
fprintf_plus(stderr,
397
"Setting system clock to key file mtime");
398
}
399
time_t keytime = keystat.st_mtim.tv_sec;
400
if(stime(&keytime) != 0){
401
perror_plus("stime");
402
}
403
ret = lower_privileges();
404
if(ret != 0){
405
errno = ret;
406
perror_plus("Failed to lower privileges");
407
}
408
} while(false);
409
264
410
rc = gpgme_data_new_from_fd(&pgp_data, fd);
265
411
if(rc != GPG_ERR_NO_ERROR){
266
412
fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
268
414
return false;
269
415
}
270
416
271
rc = gpgme_op_import(mc.ctx, pgp_data);
417
rc = gpgme_op_import(mc->ctx, pgp_data);
272
418
if(rc != GPG_ERR_NO_ERROR){
273
419
fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
274
420
gpgme_strsource(rc), gpgme_strerror(rc));
275
421
return false;
276
422
}
423
{
424
gpgme_import_result_t import_result
425
= gpgme_op_import_result(mc->ctx);
426
if((import_result->imported < 1
427
or import_result->not_imported > 0)
428
and import_result->unchanged == 0){
429
fprintf_plus(stderr, "bad gpgme_op_import_results:\n");
430
fprintf_plus(stderr,
431
"The total number of considered keys: %d\n",
432
import_result->considered);
433
fprintf_plus(stderr,
434
"The number of keys without user ID: %d\n",
435
import_result->no_user_id);
436
fprintf_plus(stderr,
437
"The total number of imported keys: %d\n",
438
import_result->imported);
439
fprintf_plus(stderr, "The number of imported RSA keys: %d\n",
440
import_result->imported_rsa);
441
fprintf_plus(stderr, "The number of unchanged keys: %d\n",
442
import_result->unchanged);
443
fprintf_plus(stderr, "The number of new user IDs: %d\n",
444
import_result->new_user_ids);
445
fprintf_plus(stderr, "The number of new sub keys: %d\n",
446
import_result->new_sub_keys);
447
fprintf_plus(stderr, "The number of new signatures: %d\n",
448
import_result->new_signatures);
449
fprintf_plus(stderr, "The number of new revocations: %d\n",
450
import_result->new_revocations);
451
fprintf_plus(stderr,
452
"The total number of secret keys read: %d\n",
453
import_result->secret_read);
454
fprintf_plus(stderr,
455
"The number of imported secret keys: %d\n",
456
import_result->secret_imported);
457
fprintf_plus(stderr,
458
"The number of unchanged secret keys: %d\n",
459
import_result->secret_unchanged);
460
fprintf_plus(stderr, "The number of keys not imported: %d\n",
461
import_result->not_imported);
462
for(gpgme_import_status_t import_status
463
= import_result->imports;
464
import_status != NULL;
465
import_status = import_status->next){
466
fprintf_plus(stderr, "Import status for key: %s\n",
467
import_status->fpr);
468
if(import_status->result != GPG_ERR_NO_ERROR){
469
fprintf_plus(stderr, "Import result: %s: %s\n",
470
gpgme_strsource(import_status->result),
471
gpgme_strerror(import_status->result));
472
}
473
fprintf_plus(stderr, "Key status:\n");
474
fprintf_plus(stderr,
475
import_status->status & GPGME_IMPORT_NEW
476
? "The key was new.\n"
477
: "The key was not new.\n");
478
fprintf_plus(stderr,
479
import_status->status & GPGME_IMPORT_UID
480
? "The key contained new user IDs.\n"
481
: "The key did not contain new user IDs.\n");
482
fprintf_plus(stderr,
483
import_status->status & GPGME_IMPORT_SIG
484
? "The key contained new signatures.\n"
485
: "The key did not contain new signatures.\n");
486
fprintf_plus(stderr,
487
import_status->status & GPGME_IMPORT_SUBKEY
488
? "The key contained new sub keys.\n"
489
: "The key did not contain new sub keys.\n");
490
fprintf_plus(stderr,
491
import_status->status & GPGME_IMPORT_SECRET
492
? "The key contained a secret key.\n"
493
: "The key did not contain a secret key.\n");
494
}
495
return false;
496
}
497
}
277
498
278
ret = (int)TEMP_FAILURE_RETRY(close(fd));
499
ret = close(fd);
279
500
if(ret == -1){
280
501
perror_plus("close");
281
502
}
318
539
}
319
540
320
541
/* Create new GPGME "context" */
321
rc = gpgme_new(&(mc.ctx));
542
rc = gpgme_new(&(mc->ctx));
322
543
if(rc != GPG_ERR_NO_ERROR){
323
fprintf_plus(stderr, "Mandos plugin mandos-client: "
324
"bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
325
gpgme_strerror(rc));
544
fprintf_plus(stderr, "bad gpgme_new: %s: %s\n",
545
gpgme_strsource(rc), gpgme_strerror(rc));
326
546
return false;
327
547
}
328
548
337
557
* Decrypt OpenPGP data.
338
558
* Returns -1 on error
339
559
*/
560
__attribute__((nonnull, warn_unused_result))
340
561
static ssize_t pgp_packet_decrypt(const char *cryptotext,
341
562
size_t crypto_size,
342
char **plaintext){
563
char **plaintext,
564
mandos_context *mc){
343
565
gpgme_data_t dh_crypto, dh_plain;
344
566
gpgme_error_t rc;
345
567
ssize_t ret;
362
584
/* Create new empty GPGME data buffer for the plaintext */
363
585
rc = gpgme_data_new(&dh_plain);
364
586
if(rc != GPG_ERR_NO_ERROR){
365
fprintf_plus(stderr, "Mandos plugin mandos-client: "
366
"bad gpgme_data_new: %s: %s\n",
587
fprintf_plus(stderr, "bad gpgme_data_new: %s: %s\n",
367
588
gpgme_strsource(rc), gpgme_strerror(rc));
368
589
gpgme_data_release(dh_crypto);
369
590
return -1;
371
592
372
593
/* Decrypt data from the cryptotext data buffer to the plaintext
373
594
data buffer */
374
rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
595
rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
375
596
if(rc != GPG_ERR_NO_ERROR){
376
597
fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
377
598
gpgme_strsource(rc), gpgme_strerror(rc));
378
599
plaintext_length = -1;
379
600
if(debug){
380
601
gpgme_decrypt_result_t result;
381
result = gpgme_op_decrypt_result(mc.ctx);
602
result = gpgme_op_decrypt_result(mc->ctx);
382
603
if(result == NULL){
383
604
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
384
605
} else {
385
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
386
result->unsupported_algorithm);
387
fprintf_plus(stderr, "Wrong key usage: %u\n",
388
result->wrong_key_usage);
606
if(result->unsupported_algorithm != NULL) {
607
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
608
result->unsupported_algorithm);
609
}
610
fprintf_plus(stderr, "Wrong key usage: %s\n",
611
result->wrong_key_usage ? "Yes" : "No");
389
612
if(result->file_name != NULL){
390
613
fprintf_plus(stderr, "File name: %s\n", result->file_name);
391
614
}
392
gpgme_recipient_t recipient;
393
recipient = result->recipients;
394
while(recipient != NULL){
615
616
for(gpgme_recipient_t r = result->recipients; r != NULL;
617
r = r->next){
395
618
fprintf_plus(stderr, "Public key algorithm: %s\n",
396
gpgme_pubkey_algo_name
397
(recipient->pubkey_algo));
398
fprintf_plus(stderr, "Key ID: %s\n", recipient->keyid);
619
gpgme_pubkey_algo_name(r->pubkey_algo));
620
fprintf_plus(stderr, "Key ID: %s\n", r->keyid);
399
621
fprintf_plus(stderr, "Secret key available: %s\n",
400
recipient->status == GPG_ERR_NO_SECKEY
401
? "No" : "Yes");
402
recipient = recipient->next;
622
r->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
403
623
}
404
624
}
405
625
}
461
681
return plaintext_length;
462
682
}
463
683
464
static const char * safer_gnutls_strerror(int value){
465
const char *ret = gnutls_strerror(value); /* Spurious warning from
466
-Wunreachable-code */
467
if(ret == NULL)
468
ret = "(unknown)";
469
return ret;
684
__attribute__((warn_unused_result, const))
685
static const char *safe_string(const char *str){
686
if(str == NULL)
687
return "(unknown)";
688
return str;
689
}
690
691
__attribute__((warn_unused_result))
692
static const char *safer_gnutls_strerror(int value){
693
const char *ret = gnutls_strerror(value);
694
return safe_string(ret);
470
695
}
471
696
472
697
/* GnuTLS log function callback */
698
__attribute__((nonnull))
473
699
static void debuggnutls(__attribute__((unused)) int level,
474
700
const char* string){
475
701
fprintf_plus(stderr, "GnuTLS: %s", string);
476
702
}
477
703
704
__attribute__((nonnull(1, 2, 4), warn_unused_result))
478
705
static int init_gnutls_global(const char *pubkeyfilename,
479
const char *seckeyfilename){
706
const char *seckeyfilename,
707
const char *dhparamsfilename,
708
mandos_context *mc){
480
709
int ret;
481
710
482
711
if(debug){
483
712
fprintf_plus(stderr, "Initializing GnuTLS\n");
484
713
}
485
714
486
ret = gnutls_global_init();
487
if(ret != GNUTLS_E_SUCCESS){
488
fprintf_plus(stderr, "GnuTLS global_init: %s\n",
489
safer_gnutls_strerror(ret));
490
return -1;
491
}
492
493
715
if(debug){
494
716
/* "Use a log level over 10 to enable all debugging options."
495
717
* - GnuTLS manual
499
721
}
500
722
501
723
/* OpenPGP credentials */
502
ret = gnutls_certificate_allocate_credentials(&mc.cred);
724
ret = gnutls_certificate_allocate_credentials(&mc->cred);
503
725
if(ret != GNUTLS_E_SUCCESS){
504
726
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
505
727
safer_gnutls_strerror(ret));
506
gnutls_global_deinit();
507
728
return -1;
508
729
}
509
730
510
731
if(debug){
511
fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
512
" secret key %s as GnuTLS credentials\n",
732
fprintf_plus(stderr, "Attempting to use public key %s and"
733
" private key %s as GnuTLS credentials\n",
513
734
pubkeyfilename,
514
735
seckeyfilename);
515
736
}
516
737
738
#if GNUTLS_VERSION_NUMBER >= 0x030606
739
ret = gnutls_certificate_set_rawpk_key_file
740
(mc->cred, pubkeyfilename, seckeyfilename,
741
GNUTLS_X509_FMT_PEM, /* format */
742
NULL, /* pass */
743
/* key_usage */
744
GNUTLS_KEY_DIGITAL_SIGNATURE | GNUTLS_KEY_KEY_ENCIPHERMENT,
745
NULL, /* names */
746
0, /* names_length */
747
/* privkey_flags */
748
GNUTLS_PKCS_PLAIN | GNUTLS_PKCS_NULL_PASSWORD,
749
0); /* pkcs11_flags */
750
#elif GNUTLS_VERSION_NUMBER < 0x030600
517
751
ret = gnutls_certificate_set_openpgp_key_file
518
(mc.cred, pubkeyfilename, seckeyfilename,
752
(mc->cred, pubkeyfilename, seckeyfilename,
519
753
GNUTLS_OPENPGP_FMT_BASE64);
754
#else
755
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
756
#endif
520
757
if(ret != GNUTLS_E_SUCCESS){
521
758
fprintf_plus(stderr,
522
"Error[%d] while reading the OpenPGP key pair ('%s',"
759
"Error[%d] while reading the key pair ('%s',"
523
760
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
524
761
fprintf_plus(stderr, "The GnuTLS error is: %s\n",
525
762
safer_gnutls_strerror(ret));
527
764
}
528
765
529
766
/* GnuTLS server initialization */
530
ret = gnutls_dh_params_init(&mc.dh_params);
767
ret = gnutls_dh_params_init(&mc->dh_params);
531
768
if(ret != GNUTLS_E_SUCCESS){
532
769
fprintf_plus(stderr, "Error in GnuTLS DH parameter"
533
770
" initialization: %s\n",
534
771
safer_gnutls_strerror(ret));
535
772
goto globalfail;
536
773
}
537
ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
538
if(ret != GNUTLS_E_SUCCESS){
539
fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
540
safer_gnutls_strerror(ret));
541
goto globalfail;
542
}
543
544
gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
774
/* If a Diffie-Hellman parameters file was given, try to use it */
775
if(dhparamsfilename != NULL){
776
gnutls_datum_t params = { .data = NULL, .size = 0 };
777
do {
778
int dhpfile = open(dhparamsfilename, O_RDONLY);
779
if(dhpfile == -1){
780
perror_plus("open");
781
dhparamsfilename = NULL;
782
break;
783
}
784
size_t params_capacity = 0;
785
while(true){
786
params_capacity = incbuffer((char **)¶ms.data,
787
(size_t)params.size,
788
(size_t)params_capacity);
789
if(params_capacity == 0){
790
perror_plus("incbuffer");
791
free(params.data);
792
params.data = NULL;
793
dhparamsfilename = NULL;
794
break;
795
}
796
ssize_t bytes_read = read(dhpfile,
797
params.data + params.size,
798
BUFFER_SIZE);
799
/* EOF */
800
if(bytes_read == 0){
801
break;
802
}
803
/* check bytes_read for failure */
804
if(bytes_read < 0){
805
perror_plus("read");
806
free(params.data);
807
params.data = NULL;
808
dhparamsfilename = NULL;
809
break;
810
}
811
params.size += (unsigned int)bytes_read;
812
}
813
ret = close(dhpfile);
814
if(ret == -1){
815
perror_plus("close");
816
}
817
if(params.data == NULL){
818
dhparamsfilename = NULL;
819
}
820
if(dhparamsfilename == NULL){
821
break;
822
}
823
ret = gnutls_dh_params_import_pkcs3(mc->dh_params, ¶ms,
824
GNUTLS_X509_FMT_PEM);
825
if(ret != GNUTLS_E_SUCCESS){
826
fprintf_plus(stderr, "Failed to parse DH parameters in file"
827
" \"%s\": %s\n", dhparamsfilename,
828
safer_gnutls_strerror(ret));
829
dhparamsfilename = NULL;
830
}
831
free(params.data);
832
} while(false);
833
}
834
if(dhparamsfilename == NULL){
835
if(mc->dh_bits == 0){
836
#if GNUTLS_VERSION_NUMBER < 0x030600
837
/* Find out the optimal number of DH bits */
838
/* Try to read the private key file */
839
gnutls_datum_t buffer = { .data = NULL, .size = 0 };
840
do {
841
int secfile = open(seckeyfilename, O_RDONLY);
842
if(secfile == -1){
843
perror_plus("open");
844
break;
845
}
846
size_t buffer_capacity = 0;
847
while(true){
848
buffer_capacity = incbuffer((char **)&buffer.data,
849
(size_t)buffer.size,
850
(size_t)buffer_capacity);
851
if(buffer_capacity == 0){
852
perror_plus("incbuffer");
853
free(buffer.data);
854
buffer.data = NULL;
855
break;
856
}
857
ssize_t bytes_read = read(secfile,
858
buffer.data + buffer.size,
859
BUFFER_SIZE);
860
/* EOF */
861
if(bytes_read == 0){
862
break;
863
}
864
/* check bytes_read for failure */
865
if(bytes_read < 0){
866
perror_plus("read");
867
free(buffer.data);
868
buffer.data = NULL;
869
break;
870
}
871
buffer.size += (unsigned int)bytes_read;
872
}
873
close(secfile);
874
} while(false);
875
/* If successful, use buffer to parse private key */
876
gnutls_sec_param_t sec_param = GNUTLS_SEC_PARAM_ULTRA;
877
if(buffer.data != NULL){
878
{
879
gnutls_openpgp_privkey_t privkey = NULL;
880
ret = gnutls_openpgp_privkey_init(&privkey);
881
if(ret != GNUTLS_E_SUCCESS){
882
fprintf_plus(stderr, "Error initializing OpenPGP key"
883
" structure: %s",
884
safer_gnutls_strerror(ret));
885
free(buffer.data);
886
buffer.data = NULL;
887
} else {
888
ret = gnutls_openpgp_privkey_import
889
(privkey, &buffer, GNUTLS_OPENPGP_FMT_BASE64, "", 0);
890
if(ret != GNUTLS_E_SUCCESS){
891
fprintf_plus(stderr, "Error importing OpenPGP key : %s",
892
safer_gnutls_strerror(ret));
893
privkey = NULL;
894
}
895
free(buffer.data);
896
buffer.data = NULL;
897
if(privkey != NULL){
898
/* Use private key to suggest an appropriate
899
sec_param */
900
sec_param = gnutls_openpgp_privkey_sec_param(privkey);
901
gnutls_openpgp_privkey_deinit(privkey);
902
if(debug){
903
fprintf_plus(stderr, "This OpenPGP key implies using"
904
" a GnuTLS security parameter \"%s\".\n",
905
safe_string(gnutls_sec_param_get_name
906
(sec_param)));
907
}
908
}
909
}
910
}
911
if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
912
/* Err on the side of caution */
913
sec_param = GNUTLS_SEC_PARAM_ULTRA;
914
if(debug){
915
fprintf_plus(stderr, "Falling back to security parameter"
916
" \"%s\"\n",
917
safe_string(gnutls_sec_param_get_name
918
(sec_param)));
919
}
920
}
921
}
922
unsigned int uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
923
if(uret != 0){
924
mc->dh_bits = uret;
925
if(debug){
926
fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
927
" implies %u DH bits; using that.\n",
928
safe_string(gnutls_sec_param_get_name
929
(sec_param)),
930
mc->dh_bits);
931
}
932
} else {
933
fprintf_plus(stderr, "Failed to get implied number of DH"
934
" bits for security parameter \"%s\"): %s\n",
935
safe_string(gnutls_sec_param_get_name
936
(sec_param)),
937
safer_gnutls_strerror(ret));
938
goto globalfail;
939
}
940
#endif
941
} else { /* dh_bits != 0 */
942
if(debug){
943
fprintf_plus(stderr, "DH bits explicitly set to %u\n",
944
mc->dh_bits);
945
}
946
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
947
if(ret != GNUTLS_E_SUCCESS){
948
fprintf_plus(stderr, "Error in GnuTLS prime generation (%u"
949
" bits): %s\n", mc->dh_bits,
950
safer_gnutls_strerror(ret));
951
goto globalfail;
952
}
953
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
954
}
955
}
545
956
546
957
return 0;
547
958
548
959
globalfail:
549
960
550
gnutls_certificate_free_credentials(mc.cred);
551
gnutls_global_deinit();
552
gnutls_dh_params_deinit(mc.dh_params);
961
gnutls_certificate_free_credentials(mc->cred);
962
gnutls_dh_params_deinit(mc->dh_params);
553
963
return -1;
554
964
}
555
965
556
static int init_gnutls_session(gnutls_session_t *session){
966
__attribute__((nonnull, warn_unused_result))
967
static int init_gnutls_session(gnutls_session_t *session,
968
mandos_context *mc){
557
969
int ret;
558
970
/* GnuTLS session creation */
559
971
do {
560
ret = gnutls_init(session, GNUTLS_SERVER);
972
ret = gnutls_init(session, (GNUTLS_SERVER
973
#if GNUTLS_VERSION_NUMBER >= 0x030506
974
| GNUTLS_NO_TICKETS
975
#endif
976
#if GNUTLS_VERSION_NUMBER >= 0x030606
977
| GNUTLS_ENABLE_RAWPK
978
#endif
979
));
561
980
if(quit_now){
562
981
return -1;
563
982
}
571
990
{
572
991
const char *err;
573
992
do {
574
ret = gnutls_priority_set_direct(*session, mc.priority, &err);
993
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
575
994
if(quit_now){
576
995
gnutls_deinit(*session);
577
996
return -1;
588
1007
589
1008
do {
590
1009
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
591
mc.cred);
1010
mc->cred);
592
1011
if(quit_now){
593
1012
gnutls_deinit(*session);
594
1013
return -1;
604
1023
/* ignore client certificate if any. */
605
1024
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
606
1025
607
gnutls_dh_set_prime_bits(*session, mc.dh_bits);
608
609
1026
return 0;
610
1027
}
611
1028
613
1030
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
614
1031
__attribute__((unused)) const char *txt){}
615
1032
1033
/* Helper function to add_local_route() and delete_local_route() */
1034
__attribute__((nonnull, warn_unused_result))
1035
static bool add_delete_local_route(const bool add,
1036
const char *address,
1037
AvahiIfIndex if_index){
1038
int ret;
1039
char helper[] = "mandos-client-iprouteadddel";
1040
char add_arg[] = "add";
1041
char delete_arg[] = "delete";
1042
char debug_flag[] = "--debug";
1043
char *pluginhelperdir = getenv("MANDOSPLUGINHELPERDIR");
1044
if(pluginhelperdir == NULL){
1045
if(debug){
1046
fprintf_plus(stderr, "MANDOSPLUGINHELPERDIR environment"
1047
" variable not set; cannot run helper\n");
1048
}
1049
return false;
1050
}
1051
1052
char interface[IF_NAMESIZE];
1053
if(if_indextoname((unsigned int)if_index, interface) == NULL){
1054
perror_plus("if_indextoname");
1055
return false;
1056
}
1057
1058
int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
1059
if(devnull == -1){
1060
perror_plus("open(\"/dev/null\", O_RDONLY)");
1061
return false;
1062
}
1063
pid_t pid = fork();
1064
if(pid == 0){
1065
/* Child */
1066
/* Raise privileges */
1067
errno = raise_privileges_permanently();
1068
if(errno != 0){
1069
perror_plus("Failed to raise privileges");
1070
/* _exit(EX_NOPERM); */
1071
} else {
1072
/* Set group */
1073
errno = 0;
1074
ret = setgid(0);
1075
if(ret == -1){
1076
perror_plus("setgid");
1077
_exit(EX_NOPERM);
1078
}
1079
/* Reset supplementary groups */
1080
errno = 0;
1081
ret = setgroups(0, NULL);
1082
if(ret == -1){
1083
perror_plus("setgroups");
1084
_exit(EX_NOPERM);
1085
}
1086
}
1087
ret = dup2(devnull, STDIN_FILENO);
1088
if(ret == -1){
1089
perror_plus("dup2(devnull, STDIN_FILENO)");
1090
_exit(EX_OSERR);
1091
}
1092
ret = close(devnull);
1093
if(ret == -1){
1094
perror_plus("close");
1095
_exit(EX_OSERR);
1096
}
1097
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
1098
if(ret == -1){
1099
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
1100
_exit(EX_OSERR);
1101
}
1102
int helperdir_fd = (int)TEMP_FAILURE_RETRY(open(pluginhelperdir,
1103
O_RDONLY
1104
| O_DIRECTORY
1105
| O_PATH
1106
| O_CLOEXEC));
1107
if(helperdir_fd == -1){
1108
perror_plus("open");
1109
_exit(EX_UNAVAILABLE);
1110
}
1111
int helper_fd = (int)TEMP_FAILURE_RETRY(openat(helperdir_fd,
1112
helper, O_RDONLY));
1113
if(helper_fd == -1){
1114
perror_plus("openat");
1115
close(helperdir_fd);
1116
_exit(EX_UNAVAILABLE);
1117
}
1118
close(helperdir_fd);
1119
#ifdef __GNUC__
1120
#pragma GCC diagnostic push
1121
#pragma GCC diagnostic ignored "-Wcast-qual"
1122
#endif
1123
if(fexecve(helper_fd, (char *const [])
1124
{ helper, add ? add_arg : delete_arg, (char *)address,
1125
interface, debug ? debug_flag : NULL, NULL },
1126
environ) == -1){
1127
#ifdef __GNUC__
1128
#pragma GCC diagnostic pop
1129
#endif
1130
perror_plus("fexecve");
1131
_exit(EXIT_FAILURE);
1132
}
1133
}
1134
if(pid == -1){
1135
perror_plus("fork");
1136
return false;
1137
}
1138
int status;
1139
pid_t pret = -1;
1140
errno = 0;
1141
do {
1142
pret = waitpid(pid, &status, 0);
1143
if(pret == -1 and errno == EINTR and quit_now){
1144
int errno_raising = 0;
1145
if((errno = raise_privileges()) != 0){
1146
errno_raising = errno;
1147
perror_plus("Failed to raise privileges in order to"
1148
" kill helper program");
1149
}
1150
if(kill(pid, SIGTERM) == -1){
1151
perror_plus("kill");
1152
}
1153
if((errno_raising == 0) and (errno = lower_privileges()) != 0){
1154
perror_plus("Failed to lower privileges after killing"
1155
" helper program");
1156
}
1157
return false;
1158
}
1159
} while(pret == -1 and errno == EINTR);
1160
if(pret == -1){
1161
perror_plus("waitpid");
1162
return false;
1163
}
1164
if(WIFEXITED(status)){
1165
if(WEXITSTATUS(status) != 0){
1166
fprintf_plus(stderr, "Error: iprouteadddel exited"
1167
" with status %d\n", WEXITSTATUS(status));
1168
return false;
1169
}
1170
return true;
1171
}
1172
if(WIFSIGNALED(status)){
1173
fprintf_plus(stderr, "Error: iprouteadddel died by"
1174
" signal %d\n", WTERMSIG(status));
1175
return false;
1176
}
1177
fprintf_plus(stderr, "Error: iprouteadddel crashed\n");
1178
return false;
1179
}
1180
1181
__attribute__((nonnull, warn_unused_result))
1182
static bool add_local_route(const char *address,
1183
AvahiIfIndex if_index){
1184
if(debug){
1185
fprintf_plus(stderr, "Adding route to %s\n", address);
1186
}
1187
return add_delete_local_route(true, address, if_index);
1188
}
1189
1190
__attribute__((nonnull, warn_unused_result))
1191
static bool delete_local_route(const char *address,
1192
AvahiIfIndex if_index){
1193
if(debug){
1194
fprintf_plus(stderr, "Removing route to %s\n", address);
1195
}
1196
return add_delete_local_route(false, address, if_index);
1197
}
1198
616
1199
/* Called when a Mandos server is found */
617
static int start_mandos_communication(const char *ip, uint16_t port,
1200
__attribute__((nonnull, warn_unused_result))
1201
static int start_mandos_communication(const char *ip, in_port_t port,
618
1202
AvahiIfIndex if_index,
619
int af){
1203
int af, mandos_context *mc){
620
1204
int ret, tcp_sd = -1;
621
1205
ssize_t sret;
622
union {
623
struct sockaddr_in in;
624
struct sockaddr_in6 in6;
625
} to;
1206
struct sockaddr_storage to;
626
1207
char *buffer = NULL;
627
1208
char *decrypted_buffer = NULL;
628
1209
size_t buffer_length = 0;
631
1212
int retval = -1;
632
1213
gnutls_session_t session;
633
1214
int pf; /* Protocol family */
1215
bool route_added = false;
634
1216
635
1217
errno = 0;
636
1218
652
1234
return -1;
653
1235
}
654
1236
655
ret = init_gnutls_session(&session);
1237
/* If the interface is specified and we have a list of interfaces */
1238
if(if_index != AVAHI_IF_UNSPEC and mc->interfaces != NULL){
1239
/* Check if the interface is one of the interfaces we are using */
1240
bool match = false;
1241
{
1242
char *interface = NULL;
1243
while((interface = argz_next(mc->interfaces,
1244
mc->interfaces_size,
1245
interface))){
1246
if(if_nametoindex(interface) == (unsigned int)if_index){
1247
match = true;
1248
break;
1249
}
1250
}
1251
}
1252
if(not match){
1253
/* This interface does not match any in the list, so we don't
1254
connect to the server */
1255
if(debug){
1256
char interface[IF_NAMESIZE];
1257
if(if_indextoname((unsigned int)if_index, interface) == NULL){
1258
perror_plus("if_indextoname");
1259
} else {
1260
fprintf_plus(stderr, "Skipping server on non-used interface"
1261
" \"%s\"\n",
1262
if_indextoname((unsigned int)if_index,
1263
interface));
1264
}
1265
}
1266
return -1;
1267
}
1268
}
1269
1270
ret = init_gnutls_session(&session, mc);
656
1271
if(ret != 0){
657
1272
return -1;
658
1273
}
659
1274
660
1275
if(debug){
661
1276
fprintf_plus(stderr, "Setting up a TCP connection to %s, port %"
662
PRIu16 "\n", ip, port);
1277
PRIuMAX "\n", ip, (uintmax_t)port);
663
1278
}
664
1279
665
tcp_sd = socket(pf, SOCK_STREAM, 0);
1280
tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
666
1281
if(tcp_sd < 0){
667
1282
int e = errno;
668
1283
perror_plus("socket");
675
1290
goto mandos_end;
676
1291
}
677
1292
678
memset(&to, 0, sizeof(to));
679
1293
if(af == AF_INET6){
680
to.in6.sin6_family = (sa_family_t)af;
681
ret = inet_pton(af, ip, &to.in6.sin6_addr);
1294
struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)&to;
1295
*to6 = (struct sockaddr_in6){ .sin6_family = (sa_family_t)af };
1296
ret = inet_pton(af, ip, &to6->sin6_addr);
682
1297
} else { /* IPv4 */
683
to.in.sin_family = (sa_family_t)af;
684
ret = inet_pton(af, ip, &to.in.sin_addr);
1298
struct sockaddr_in *to4 = (struct sockaddr_in *)&to;
1299
*to4 = (struct sockaddr_in){ .sin_family = (sa_family_t)af };
1300
ret = inet_pton(af, ip, &to4->sin_addr);
685
1301
}
686
1302
if(ret < 0 ){
687
1303
int e = errno;
696
1312
goto mandos_end;
697
1313
}
698
1314
if(af == AF_INET6){
699
to.in6.sin6_port = htons(port); /* Spurious warnings from
700
-Wconversion and
701
-Wunreachable-code */
702
703
if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
704
(&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
705
-Wunreachable-code*/
1315
((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
1316
if(IN6_IS_ADDR_LINKLOCAL
1317
(&((struct sockaddr_in6 *)&to)->sin6_addr)){
706
1318
if(if_index == AVAHI_IF_UNSPEC){
707
1319
fprintf_plus(stderr, "An IPv6 link-local address is"
708
1320
" incomplete without a network interface\n");
710
1322
goto mandos_end;
711
1323
}
712
1324
/* Set the network interface number as scope */
713
to.in6.sin6_scope_id = (uint32_t)if_index;
1325
((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
714
1326
}
715
1327
} else {
716
to.in.sin_port = htons(port); /* Spurious warnings from
717
-Wconversion and
718
-Wunreachable-code */
1328
((struct sockaddr_in *)&to)->sin_port = htons(port);
719
1329
}
720
1330
721
1331
if(quit_now){
729
1339
if(if_indextoname((unsigned int)if_index, interface) == NULL){
730
1340
perror_plus("if_indextoname");
731
1341
} else {
732
fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIu16
733
"\n", ip, interface, port);
1342
fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIuMAX
1343
"\n", ip, interface, (uintmax_t)port);
734
1344
}
735
1345
} else {
736
fprintf_plus(stderr, "Connection to: %s, port %" PRIu16 "\n",
737
ip, port);
1346
fprintf_plus(stderr, "Connection to: %s, port %" PRIuMAX "\n",
1347
ip, (uintmax_t)port);
738
1348
}
739
1349
char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
740
1350
INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
741
const char *pcret;
742
if(af == AF_INET6){
743
pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
744
sizeof(addrstr));
745
} else {
746
pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
747
sizeof(addrstr));
748
}
749
if(pcret == NULL){
750
perror_plus("inet_ntop");
751
} else {
752
if(strcmp(addrstr, ip) != 0){
753
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
754
}
755
}
756
}
757
758
if(quit_now){
759
errno = EINTR;
760
goto mandos_end;
761
}
762
763
if(af == AF_INET6){
764
ret = connect(tcp_sd, &to.in6, sizeof(to));
765
} else {
766
ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
767
}
768
if(ret < 0){
769
if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
770
int e = errno;
771
perror_plus("connect");
772
errno = e;
773
}
774
goto mandos_end;
775
}
776
777
if(quit_now){
778
errno = EINTR;
779
goto mandos_end;
1351
if(af == AF_INET6){
1352
ret = getnameinfo((struct sockaddr *)&to,
1353
sizeof(struct sockaddr_in6),
1354
addrstr, sizeof(addrstr), NULL, 0,
1355
NI_NUMERICHOST);
1356
} else {
1357
ret = getnameinfo((struct sockaddr *)&to,
1358
sizeof(struct sockaddr_in),
1359
addrstr, sizeof(addrstr), NULL, 0,
1360
NI_NUMERICHOST);
1361
}
1362
if(ret == EAI_SYSTEM){
1363
perror_plus("getnameinfo");
1364
} else if(ret != 0) {
1365
fprintf_plus(stderr, "getnameinfo: %s", gai_strerror(ret));
1366
} else if(strcmp(addrstr, ip) != 0){
1367
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
1368
}
1369
}
1370
1371
if(quit_now){
1372
errno = EINTR;
1373
goto mandos_end;
1374
}
1375
1376
while(true){
1377
if(af == AF_INET6){
1378
ret = connect(tcp_sd, (struct sockaddr *)&to,
1379
sizeof(struct sockaddr_in6));
1380
} else {
1381
ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
1382
sizeof(struct sockaddr_in));
1383
}
1384
if(ret < 0){
1385
if(((errno == ENETUNREACH) or (errno == EHOSTUNREACH))
1386
and if_index != AVAHI_IF_UNSPEC
1387
and connect_to == NULL
1388
and not route_added and
1389
((af == AF_INET6 and not
1390
IN6_IS_ADDR_LINKLOCAL(&(((struct sockaddr_in6 *)
1391
&to)->sin6_addr)))
1392
or (af == AF_INET and
1393
/* Not a a IPv4LL address */
1394
(ntohl(((struct sockaddr_in *)&to)->sin_addr.s_addr)
1395
& 0xFFFF0000L) != 0xA9FE0000L))){
1396
/* Work around Avahi bug - Avahi does not announce link-local
1397
addresses if it has a global address, so local hosts with
1398
*only* a link-local address (e.g. Mandos clients) cannot
1399
connect to a Mandos server announced by Avahi on a server
1400
host with a global address. Work around this by retrying
1401
with an explicit route added with the server's address.
1402
1403
Avahi bug reference:
1404
https://lists.freedesktop.org/archives/avahi/2010-February/001833.html
1405
https://bugs.debian.org/587961
1406
*/
1407
if(debug){
1408
fprintf_plus(stderr, "Mandos server unreachable, trying"
1409
" direct route\n");
1410
}
1411
int e = errno;
1412
route_added = add_local_route(ip, if_index);
1413
if(route_added){
1414
continue;
1415
}
1416
errno = e;
1417
}
1418
if(errno != ECONNREFUSED or debug){
1419
int e = errno;
1420
perror_plus("connect");
1421
errno = e;
1422
}
1423
goto mandos_end;
1424
}
1425
1426
if(quit_now){
1427
errno = EINTR;
1428
goto mandos_end;
1429
}
1430
break;
780
1431
}
781
1432
782
1433
const char *out = mandos_protocol_version;
818
1469
goto mandos_end;
819
1470
}
820
1471
821
/* Spurious warning from -Wint-to-pointer-cast */
822
gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
1472
/* This casting via intptr_t is to eliminate warning about casting
1473
an int to a pointer type. This is exactly how the GnuTLS Guile
1474
function "set-session-transport-fd!" does it. */
1475
gnutls_transport_set_ptr(session,
1476
(gnutls_transport_ptr_t)(intptr_t)tcp_sd);
823
1477
824
1478
if(quit_now){
825
1479
errno = EINTR;
930
1584
if(buffer_length > 0){
931
1585
ssize_t decrypted_buffer_size;
932
1586
decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
933
&decrypted_buffer);
1587
&decrypted_buffer, mc);
934
1588
if(decrypted_buffer_size >= 0){
935
1589
1590
clearerr(stdout);
936
1591
written = 0;
937
1592
while(written < (size_t) decrypted_buffer_size){
938
1593
if(quit_now){
954
1609
}
955
1610
written += (size_t)ret;
956
1611
}
1612
ret = fflush(stdout);
1613
if(ret != 0){
1614
int e = errno;
1615
if(debug){
1616
fprintf_plus(stderr, "Error writing encrypted data: %s\n",
1617
strerror(errno));
1618
}
1619
errno = e;
1620
goto mandos_end;
1621
}
957
1622
retval = 0;
958
1623
}
959
1624
}
962
1627
963
1628
mandos_end:
964
1629
{
1630
if(route_added){
1631
if(not delete_local_route(ip, if_index)){
1632
fprintf_plus(stderr, "Failed to delete local route to %s on"
1633
" interface %d", ip, if_index);
1634
}
1635
}
965
1636
int e = errno;
966
1637
free(decrypted_buffer);
967
1638
free(buffer);
968
1639
if(tcp_sd >= 0){
969
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
1640
ret = close(tcp_sd);
970
1641
}
971
1642
if(ret == -1){
972
1643
if(e == 0){
997
1668
AVAHI_GCC_UNUSED AvahiStringList *txt,
998
1669
AVAHI_GCC_UNUSED AvahiLookupResultFlags
999
1670
flags,
1000
AVAHI_GCC_UNUSED void* userdata){
1001
assert(r);
1671
void *mc){
1672
if(r == NULL){
1673
return;
1674
}
1002
1675
1003
1676
/* Called whenever a service has been resolved successfully or
1004
1677
timed out */
1005
1678
1006
1679
if(quit_now){
1680
avahi_s_service_resolver_free(r);
1007
1681
return;
1008
1682
}
1009
1683
1013
1687
fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
1014
1688
"'%s' of type '%s' in domain '%s': %s\n", name, type,
1015
1689
domain,
1016
avahi_strerror(avahi_server_errno(mc.server)));
1690
avahi_strerror(avahi_server_errno
1691
(((mandos_context*)mc)->server)));
1017
1692
break;
1018
1693
1019
1694
case AVAHI_RESOLVER_FOUND:
1025
1700
PRIdMAX ") on port %" PRIu16 "\n", name,
1026
1701
host_name, ip, (intmax_t)interface, port);
1027
1702
}
1028
int ret = start_mandos_communication(ip, port, interface,
1029
avahi_proto_to_af(proto));
1703
int ret = start_mandos_communication(ip, (in_port_t)port,
1704
interface,
1705
avahi_proto_to_af(proto),
1706
mc);
1030
1707
if(ret == 0){
1031
avahi_simple_poll_quit(mc.simple_poll);
1708
avahi_simple_poll_quit(simple_poll);
1032
1709
} else {
1033
if(not add_server(ip, port, interface,
1034
avahi_proto_to_af(proto))){
1710
if(not add_server(ip, (in_port_t)port, interface,
1711
avahi_proto_to_af(proto),
1712
&((mandos_context*)mc)->current_server)){
1035
1713
fprintf_plus(stderr, "Failed to add server \"%s\" to server"
1036
1714
" list\n", name);
1037
1715
}
1050
1728
const char *domain,
1051
1729
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1052
1730
flags,
1053
AVAHI_GCC_UNUSED void* userdata){
1054
assert(b);
1731
void *mc){
1732
if(b == NULL){
1733
return;
1734
}
1055
1735
1056
1736
/* Called whenever a new services becomes available on the LAN or
1057
1737
is removed from the LAN */
1065
1745
case AVAHI_BROWSER_FAILURE:
1066
1746
1067
1747
fprintf_plus(stderr, "(Avahi browser) %s\n",
1068
avahi_strerror(avahi_server_errno(mc.server)));
1069
avahi_simple_poll_quit(mc.simple_poll);
1748
avahi_strerror(avahi_server_errno
1749
(((mandos_context*)mc)->server)));
1750
avahi_simple_poll_quit(simple_poll);
1070
1751
return;
1071
1752
1072
1753
case AVAHI_BROWSER_NEW:
1075
1756
the callback function is called the Avahi server will free the
1076
1757
resolver for us. */
1077
1758
1078
if(avahi_s_service_resolver_new(mc.server, interface, protocol,
1079
name, type, domain, protocol, 0,
1080
resolve_callback, NULL) == NULL)
1759
if(avahi_s_service_resolver_new(((mandos_context*)mc)->server,
1760
interface, protocol, name, type,
1761
domain, protocol, 0,
1762
resolve_callback, mc) == NULL)
1081
1763
fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
1082
1764
" %s\n", name,
1083
avahi_strerror(avahi_server_errno(mc.server)));
1765
avahi_strerror(avahi_server_errno
1766
(((mandos_context*)mc)->server)));
1084
1767
break;
1085
1768
1086
1769
case AVAHI_BROWSER_REMOVE:
1105
1788
signal_received = sig;
1106
1789
int old_errno = errno;
1107
1790
/* set main loop to exit */
1108
if(mc.simple_poll != NULL){
1109
avahi_simple_poll_quit(mc.simple_poll);
1791
if(simple_poll != NULL){
1792
avahi_simple_poll_quit(simple_poll);
1110
1793
}
1111
1794
errno = old_errno;
1112
1795
}
1113
1796
1797
__attribute__((nonnull, warn_unused_result))
1114
1798
bool get_flags(const char *ifname, struct ifreq *ifr){
1115
1799
int ret;
1800
int old_errno;
1116
1801
1117
1802
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1118
1803
if(s < 0){
1804
old_errno = errno;
1119
1805
perror_plus("socket");
1806
errno = old_errno;
1120
1807
return false;
1121
1808
}
1122
strcpy(ifr->ifr_name, ifname);
1809
strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
1810
ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
1123
1811
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1124
1812
if(ret == -1){
1125
1813
if(debug){
1814
old_errno = errno;
1126
1815
perror_plus("ioctl SIOCGIFFLAGS");
1816
errno = old_errno;
1817
}
1818
if((close(s) == -1) and debug){
1819
old_errno = errno;
1820
perror_plus("close");
1821
errno = old_errno;
1127
1822
}
1128
1823
return false;
1129
1824
}
1825
if((close(s) == -1) and debug){
1826
old_errno = errno;
1827
perror_plus("close");
1828
errno = old_errno;
1829
}
1130
1830
return true;
1131
1831
}
1132
1832
1833
__attribute__((nonnull, warn_unused_result))
1133
1834
bool good_flags(const char *ifname, const struct ifreq *ifr){
1134
1835
1135
1836
/* Reject the loopback device */
1177
1878
* corresponds to an acceptable network device.
1178
1879
* (This function is passed to scandir(3) as a filter function.)
1179
1880
*/
1881
__attribute__((nonnull, warn_unused_result))
1180
1882
int good_interface(const struct dirent *if_entry){
1181
1883
if(if_entry->d_name[0] == '.'){
1182
1884
return 0;
1198
1900
}
1199
1901
1200
1902
/*
1201
* This function determines if a directory entry in /sys/class/net
1202
* corresponds to an acceptable network device which is up.
1203
* (This function is passed to scandir(3) as a filter function.)
1204
*/
1205
int up_interface(const struct dirent *if_entry){
1206
if(if_entry->d_name[0] == '.'){
1207
return 0;
1208
}
1209
1210
struct ifreq ifr;
1211
if(not get_flags(if_entry->d_name, &ifr)){
1212
if(debug){
1213
fprintf_plus(stderr, "Failed to get flags for interface "
1214
"\"%s\"\n", if_entry->d_name);
1215
}
1216
return 0;
1217
}
1218
1219
/* Reject down interfaces */
1220
if(not (ifr.ifr_flags & IFF_UP)){
1221
if(debug){
1222
fprintf_plus(stderr, "Rejecting down interface \"%s\"\n",
1223
if_entry->d_name);
1224
}
1225
return 0;
1226
}
1227
1228
/* Reject non-running interfaces */
1229
if(not (ifr.ifr_flags & IFF_RUNNING)){
1230
if(debug){
1231
fprintf_plus(stderr, "Rejecting non-running interface \"%s\"\n",
1232
if_entry->d_name);
1233
}
1234
return 0;
1235
}
1236
1237
if(not good_flags(if_entry->d_name, &ifr)){
1238
return 0;
1239
}
1240
return 1;
1241
}
1242
1903
* This function determines if a network interface is up.
1904
*/
1905
__attribute__((nonnull, warn_unused_result))
1906
bool interface_is_up(const char *interface){
1907
struct ifreq ifr;
1908
if(not get_flags(interface, &ifr)){
1909
if(debug){
1910
fprintf_plus(stderr, "Failed to get flags for interface "
1911
"\"%s\"\n", interface);
1912
}
1913
return false;
1914
}
1915
1916
return (bool)(ifr.ifr_flags & IFF_UP);
1917
}
1918
1919
/*
1920
* This function determines if a network interface is running
1921
*/
1922
__attribute__((nonnull, warn_unused_result))
1923
bool interface_is_running(const char *interface){
1924
struct ifreq ifr;
1925
if(not get_flags(interface, &ifr)){
1926
if(debug){
1927
fprintf_plus(stderr, "Failed to get flags for interface "
1928
"\"%s\"\n", interface);
1929
}
1930
return false;
1931
}
1932
1933
return (bool)(ifr.ifr_flags & IFF_RUNNING);
1934
}
1935
1936
__attribute__((nonnull, pure, warn_unused_result))
1243
1937
int notdotentries(const struct dirent *direntry){
1244
1938
/* Skip "." and ".." */
1245
1939
if(direntry->d_name[0] == '.'
1252
1946
}
1253
1947
1254
1948
/* Is this directory entry a runnable program? */
1949
__attribute__((nonnull, warn_unused_result))
1255
1950
int runnable_hook(const struct dirent *direntry){
1256
1951
int ret;
1257
1952
size_t sret;
1265
1960
sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1266
1961
"abcdefghijklmnopqrstuvwxyz"
1267
1962
"0123456789"
1268
"_-");
1963
"_.-");
1269
1964
if((direntry->d_name)[sret] != '\0'){
1270
1965
/* Contains non-allowed characters */
1271
1966
if(debug){
1275
1970
return 0;
1276
1971
}
1277
1972
1278
char *fullname = NULL;
1279
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1280
if(ret < 0){
1281
perror_plus("asprintf");
1282
return 0;
1283
}
1284
1285
ret = stat(fullname, &st);
1973
ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1286
1974
if(ret == -1){
1287
1975
if(debug){
1288
1976
perror_plus("Could not stat hook");
1312
2000
return 1;
1313
2001
}
1314
2002
1315
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval){
2003
__attribute__((nonnull, warn_unused_result))
2004
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
2005
mandos_context *mc){
1316
2006
int ret;
1317
2007
struct timespec now;
1318
2008
struct timespec waited_time;
1319
2009
intmax_t block_time;
1320
2010
1321
2011
while(true){
1322
if(mc.current_server == NULL){
1323
if (debug){
2012
if(mc->current_server == NULL){
2013
if(debug){
1324
2014
fprintf_plus(stderr, "Wait until first server is found."
1325
2015
" No timeout!\n");
1326
2016
}
1327
2017
ret = avahi_simple_poll_iterate(s, -1);
1328
2018
} else {
1329
if (debug){
2019
if(debug){
1330
2020
fprintf_plus(stderr, "Check current_server if we should run"
1331
2021
" it, or wait\n");
1332
2022
}
1339
2029
/* Calculating in ms how long time between now and server
1340
2030
who we visted longest time ago. Now - last seen. */
1341
2031
waited_time.tv_sec = (now.tv_sec
1342
- mc.current_server->last_seen.tv_sec);
2032
- mc->current_server->last_seen.tv_sec);
1343
2033
waited_time.tv_nsec = (now.tv_nsec
1344
- mc.current_server->last_seen.tv_nsec);
2034
- mc->current_server->last_seen.tv_nsec);
1345
2035
/* total time is 10s/10,000ms.
1346
2036
Converting to s from ms by dividing by 1,000,
1347
2037
and ns to ms by dividing by 1,000,000. */
1349
2039
- ((intmax_t)waited_time.tv_sec * 1000))
1350
2040
- ((intmax_t)waited_time.tv_nsec / 1000000));
1351
2041
1352
if (debug){
2042
if(debug){
1353
2043
fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1354
2044
block_time);
1355
2045
}
1356
2046
1357
2047
if(block_time <= 0){
1358
ret = start_mandos_communication(mc.current_server->ip,
1359
mc.current_server->port,
1360
mc.current_server->if_index,
1361
mc.current_server->af);
2048
ret = start_mandos_communication(mc->current_server->ip,
2049
mc->current_server->port,
2050
mc->current_server->if_index,
2051
mc->current_server->af, mc);
1362
2052
if(ret == 0){
1363
avahi_simple_poll_quit(mc.simple_poll);
2053
avahi_simple_poll_quit(s);
1364
2054
return 0;
1365
2055
}
1366
2056
ret = clock_gettime(CLOCK_MONOTONIC,
1367
&mc.current_server->last_seen);
2057
&mc->current_server->last_seen);
1368
2058
if(ret == -1){
1369
2059
perror_plus("clock_gettime");
1370
2060
return -1;
1371
2061
}
1372
mc.current_server = mc.current_server->next;
2062
mc->current_server = mc->current_server->next;
1373
2063
block_time = 0; /* Call avahi to find new Mandos
1374
2064
servers, but don't block */
1375
2065
}
1377
2067
ret = avahi_simple_poll_iterate(s, (int)block_time);
1378
2068
}
1379
2069
if(ret != 0){
1380
if (ret > 0 or errno != EINTR){
2070
if(ret > 0 or errno != EINTR){
1381
2071
return (ret != 1) ? ret : 0;
1382
2072
}
1383
2073
}
1384
2074
}
1385
2075
}
1386
2076
1387
bool run_network_hooks(const char *mode, const char *interface,
2077
__attribute__((nonnull))
2078
void run_network_hooks(const char *mode, const char *interface,
1388
2079
const float delay){
1389
struct dirent **direntries;
1390
struct dirent *direntry;
1391
int ret;
1392
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1393
alphasort);
2080
struct dirent **direntries = NULL;
2081
if(hookdir_fd == -1){
2082
hookdir_fd = open(hookdir, O_RDONLY | O_DIRECTORY | O_PATH
2083
| O_CLOEXEC);
2084
if(hookdir_fd == -1){
2085
if(errno == ENOENT){
2086
if(debug){
2087
fprintf_plus(stderr, "Network hook directory \"%s\" not"
2088
" found\n", hookdir);
2089
}
2090
} else {
2091
perror_plus("open");
2092
}
2093
return;
2094
}
2095
}
2096
int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
2097
if(devnull == -1){
2098
perror_plus("open(\"/dev/null\", O_RDONLY)");
2099
return;
2100
}
2101
int numhooks = scandirat(hookdir_fd, ".", &direntries,
2102
runnable_hook, alphasort);
1394
2103
if(numhooks == -1){
1395
2104
perror_plus("scandir");
1396
} else {
1397
int devnull = open("/dev/null", O_RDONLY);
1398
for(int i = 0; i < numhooks; i++){
1399
direntry = direntries[i];
1400
char *fullname = NULL;
1401
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1402
if(ret < 0){
2105
close(devnull);
2106
return;
2107
}
2108
struct dirent *direntry;
2109
int ret;
2110
for(int i = 0; i < numhooks; i++){
2111
direntry = direntries[i];
2112
if(debug){
2113
fprintf_plus(stderr, "Running network hook \"%s\"\n",
2114
direntry->d_name);
2115
}
2116
pid_t hook_pid = fork();
2117
if(hook_pid == 0){
2118
/* Child */
2119
/* Raise privileges */
2120
errno = raise_privileges_permanently();
2121
if(errno != 0){
2122
perror_plus("Failed to raise privileges");
2123
_exit(EX_NOPERM);
2124
}
2125
/* Set group */
2126
errno = 0;
2127
ret = setgid(0);
2128
if(ret == -1){
2129
perror_plus("setgid");
2130
_exit(EX_NOPERM);
2131
}
2132
/* Reset supplementary groups */
2133
errno = 0;
2134
ret = setgroups(0, NULL);
2135
if(ret == -1){
2136
perror_plus("setgroups");
2137
_exit(EX_NOPERM);
2138
}
2139
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
2140
if(ret == -1){
2141
perror_plus("setenv");
2142
_exit(EX_OSERR);
2143
}
2144
ret = setenv("DEVICE", interface, 1);
2145
if(ret == -1){
2146
perror_plus("setenv");
2147
_exit(EX_OSERR);
2148
}
2149
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
2150
if(ret == -1){
2151
perror_plus("setenv");
2152
_exit(EX_OSERR);
2153
}
2154
ret = setenv("MODE", mode, 1);
2155
if(ret == -1){
2156
perror_plus("setenv");
2157
_exit(EX_OSERR);
2158
}
2159
char *delaystring;
2160
ret = asprintf(&delaystring, "%f", (double)delay);
2161
if(ret == -1){
1403
2162
perror_plus("asprintf");
1404
continue;
1405
}
1406
if(debug){
1407
fprintf_plus(stderr, "Running network hook \"%s\"\n",
1408
direntry->d_name);
1409
}
1410
pid_t hook_pid = fork();
1411
if(hook_pid == 0){
1412
/* Child */
1413
/* Raise privileges */
1414
errno = 0;
1415
ret = seteuid(0);
1416
if(ret == -1){
1417
perror_plus("seteuid");
1418
}
1419
/* Raise privileges even more */
1420
errno = 0;
1421
ret = setuid(0);
1422
if(ret == -1){
1423
perror_plus("setuid");
1424
}
1425
/* Set group */
1426
errno = 0;
1427
ret = setgid(0);
1428
if(ret == -1){
1429
perror_plus("setgid");
1430
}
1431
/* Reset supplementary groups */
1432
errno = 0;
1433
ret = setgroups(0, NULL);
1434
if(ret == -1){
1435
perror_plus("setgroups");
1436
}
1437
dup2(devnull, STDIN_FILENO);
1438
close(devnull);
1439
dup2(STDERR_FILENO, STDOUT_FILENO);
1440
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1441
if(ret == -1){
1442
perror_plus("setenv");
1443
_exit(EX_OSERR);
1444
}
1445
ret = setenv("DEVICE", interface, 1);
1446
if(ret == -1){
1447
perror_plus("setenv");
1448
_exit(EX_OSERR);
1449
}
1450
ret = setenv("VERBOSE", debug ? "1" : "0", 1);
1451
if(ret == -1){
1452
perror_plus("setenv");
1453
_exit(EX_OSERR);
1454
}
1455
ret = setenv("MODE", mode, 1);
1456
if(ret == -1){
1457
perror_plus("setenv");
1458
_exit(EX_OSERR);
1459
}
1460
char *delaystring;
1461
ret = asprintf(&delaystring, "%f", delay);
1462
if(ret == -1){
1463
perror_plus("asprintf");
1464
_exit(EX_OSERR);
1465
}
1466
ret = setenv("DELAY", delaystring, 1);
1467
if(ret == -1){
1468
free(delaystring);
1469
perror_plus("setenv");
1470
_exit(EX_OSERR);
1471
}
2163
_exit(EX_OSERR);
2164
}
2165
ret = setenv("DELAY", delaystring, 1);
2166
if(ret == -1){
1472
2167
free(delaystring);
1473
ret = execl(fullname, direntry->d_name, mode, NULL);
1474
perror_plus("execl");
1475
} else {
1476
int status;
1477
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1478
perror_plus("waitpid");
1479
free(fullname);
1480
continue;
1481
}
1482
if(WIFEXITED(status)){
1483
if(WEXITSTATUS(status) != 0){
1484
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1485
" with status %d\n", direntry->d_name,
1486
WEXITSTATUS(status));
1487
free(fullname);
1488
continue;
1489
}
1490
} else if(WIFSIGNALED(status)){
1491
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1492
" signal %d\n", direntry->d_name,
1493
WTERMSIG(status));
1494
free(fullname);
1495
continue;
1496
} else {
1497
fprintf_plus(stderr, "Warning: network hook \"%s\""
1498
" crashed\n", direntry->d_name);
1499
free(fullname);
1500
continue;
1501
}
1502
}
1503
free(fullname);
1504
if(debug){
1505
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1506
direntry->d_name);
1507
}
1508
}
1509
close(devnull);
1510
}
1511
return true;
2168
perror_plus("setenv");
2169
_exit(EX_OSERR);
2170
}
2171
free(delaystring);
2172
if(connect_to != NULL){
2173
ret = setenv("CONNECT", connect_to, 1);
2174
if(ret == -1){
2175
perror_plus("setenv");
2176
_exit(EX_OSERR);
2177
}
2178
}
2179
int hook_fd = (int)TEMP_FAILURE_RETRY(openat(hookdir_fd,
2180
direntry->d_name,
2181
O_RDONLY));
2182
if(hook_fd == -1){
2183
perror_plus("openat");
2184
_exit(EXIT_FAILURE);
2185
}
2186
if(close(hookdir_fd) == -1){
2187
perror_plus("close");
2188
_exit(EXIT_FAILURE);
2189
}
2190
ret = dup2(devnull, STDIN_FILENO);
2191
if(ret == -1){
2192
perror_plus("dup2(devnull, STDIN_FILENO)");
2193
_exit(EX_OSERR);
2194
}
2195
ret = close(devnull);
2196
if(ret == -1){
2197
perror_plus("close");
2198
_exit(EX_OSERR);
2199
}
2200
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
2201
if(ret == -1){
2202
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
2203
_exit(EX_OSERR);
2204
}
2205
if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
2206
environ) == -1){
2207
perror_plus("fexecve");
2208
_exit(EXIT_FAILURE);
2209
}
2210
} else {
2211
if(hook_pid == -1){
2212
perror_plus("fork");
2213
free(direntry);
2214
continue;
2215
}
2216
int status;
2217
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
2218
perror_plus("waitpid");
2219
free(direntry);
2220
continue;
2221
}
2222
if(WIFEXITED(status)){
2223
if(WEXITSTATUS(status) != 0){
2224
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
2225
" with status %d\n", direntry->d_name,
2226
WEXITSTATUS(status));
2227
free(direntry);
2228
continue;
2229
}
2230
} else if(WIFSIGNALED(status)){
2231
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
2232
" signal %d\n", direntry->d_name,
2233
WTERMSIG(status));
2234
free(direntry);
2235
continue;
2236
} else {
2237
fprintf_plus(stderr, "Warning: network hook \"%s\""
2238
" crashed\n", direntry->d_name);
2239
free(direntry);
2240
continue;
2241
}
2242
}
2243
if(debug){
2244
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
2245
direntry->d_name);
2246
}
2247
free(direntry);
2248
}
2249
free(direntries);
2250
if(close(hookdir_fd) == -1){
2251
perror_plus("close");
2252
} else {
2253
hookdir_fd = -1;
2254
}
2255
close(devnull);
2256
}
2257
2258
__attribute__((nonnull, warn_unused_result))
2259
int bring_up_interface(const char *const interface,
2260
const float delay){
2261
int old_errno = errno;
2262
int ret;
2263
struct ifreq network;
2264
unsigned int if_index = if_nametoindex(interface);
2265
if(if_index == 0){
2266
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
2267
errno = old_errno;
2268
return ENXIO;
2269
}
2270
2271
if(quit_now){
2272
errno = old_errno;
2273
return EINTR;
2274
}
2275
2276
if(not interface_is_up(interface)){
2277
int ret_errno = 0;
2278
int ioctl_errno = 0;
2279
if(not get_flags(interface, &network)){
2280
ret_errno = errno;
2281
fprintf_plus(stderr, "Failed to get flags for interface "
2282
"\"%s\"\n", interface);
2283
errno = old_errno;
2284
return ret_errno;
2285
}
2286
network.ifr_flags |= IFF_UP; /* set flag */
2287
2288
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
2289
if(sd == -1){
2290
ret_errno = errno;
2291
perror_plus("socket");
2292
errno = old_errno;
2293
return ret_errno;
2294
}
2295
2296
if(quit_now){
2297
ret = close(sd);
2298
if(ret == -1){
2299
perror_plus("close");
2300
}
2301
errno = old_errno;
2302
return EINTR;
2303
}
2304
2305
if(debug){
2306
fprintf_plus(stderr, "Bringing up interface \"%s\"\n",
2307
interface);
2308
}
2309
2310
/* Raise privileges */
2311
ret_errno = raise_privileges();
2312
if(ret_errno != 0){
2313
errno = ret_errno;
2314
perror_plus("Failed to raise privileges");
2315
}
2316
2317
#ifdef __linux__
2318
int ret_linux;
2319
bool restore_loglevel = false;
2320
if(ret_errno == 0){
2321
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
2322
messages about the network interface to mess up the prompt */
2323
ret_linux = klogctl(8, NULL, 5);
2324
if(ret_linux == -1){
2325
perror_plus("klogctl");
2326
} else {
2327
restore_loglevel = true;
2328
}
2329
}
2330
#endif /* __linux__ */
2331
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
2332
ioctl_errno = errno;
2333
#ifdef __linux__
2334
if(restore_loglevel){
2335
ret_linux = klogctl(7, NULL, 0);
2336
if(ret_linux == -1){
2337
perror_plus("klogctl");
2338
}
2339
}
2340
#endif /* __linux__ */
2341
2342
/* If raise_privileges() succeeded above */
2343
if(ret_errno == 0){
2344
/* Lower privileges */
2345
ret_errno = lower_privileges();
2346
if(ret_errno != 0){
2347
errno = ret_errno;
2348
perror_plus("Failed to lower privileges");
2349
}
2350
}
2351
2352
/* Close the socket */
2353
ret = close(sd);
2354
if(ret == -1){
2355
perror_plus("close");
2356
}
2357
2358
if(ret_setflags == -1){
2359
errno = ioctl_errno;
2360
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
2361
errno = old_errno;
2362
return ioctl_errno;
2363
}
2364
} else if(debug){
2365
fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
2366
interface);
2367
}
2368
2369
/* Sleep checking until interface is running.
2370
Check every 0.25s, up to total time of delay */
2371
for(int i = 0; i < delay * 4; i++){
2372
if(interface_is_running(interface)){
2373
break;
2374
}
2375
struct timespec sleeptime = { .tv_nsec = 250000000 };
2376
ret = nanosleep(&sleeptime, NULL);
2377
if(ret == -1 and errno != EINTR){
2378
perror_plus("nanosleep");
2379
}
2380
}
2381
2382
errno = old_errno;
2383
return 0;
2384
}
2385
2386
__attribute__((nonnull, warn_unused_result))
2387
int take_down_interface(const char *const interface){
2388
int old_errno = errno;
2389
struct ifreq network;
2390
unsigned int if_index = if_nametoindex(interface);
2391
if(if_index == 0){
2392
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
2393
errno = old_errno;
2394
return ENXIO;
2395
}
2396
if(interface_is_up(interface)){
2397
int ret_errno = 0;
2398
int ioctl_errno = 0;
2399
if(not get_flags(interface, &network) and debug){
2400
ret_errno = errno;
2401
fprintf_plus(stderr, "Failed to get flags for interface "
2402
"\"%s\"\n", interface);
2403
errno = old_errno;
2404
return ret_errno;
2405
}
2406
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
2407
2408
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
2409
if(sd == -1){
2410
ret_errno = errno;
2411
perror_plus("socket");
2412
errno = old_errno;
2413
return ret_errno;
2414
}
2415
2416
if(debug){
2417
fprintf_plus(stderr, "Taking down interface \"%s\"\n",
2418
interface);
2419
}
2420
2421
/* Raise privileges */
2422
ret_errno = raise_privileges();
2423
if(ret_errno != 0){
2424
errno = ret_errno;
2425
perror_plus("Failed to raise privileges");
2426
}
2427
2428
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
2429
ioctl_errno = errno;
2430
2431
/* If raise_privileges() succeeded above */
2432
if(ret_errno == 0){
2433
/* Lower privileges */
2434
ret_errno = lower_privileges();
2435
if(ret_errno != 0){
2436
errno = ret_errno;
2437
perror_plus("Failed to lower privileges");
2438
}
2439
}
2440
2441
/* Close the socket */
2442
int ret = close(sd);
2443
if(ret == -1){
2444
perror_plus("close");
2445
}
2446
2447
if(ret_setflags == -1){
2448
errno = ioctl_errno;
2449
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
2450
errno = old_errno;
2451
return ioctl_errno;
2452
}
2453
} else if(debug){
2454
fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
2455
interface);
2456
}
2457
2458
errno = old_errno;
2459
return 0;
1512
2460
}
1513
2461
1514
2462
int main(int argc, char *argv[]){
2463
mandos_context mc = { .server = NULL, .dh_bits = 0,
2464
#if GNUTLS_VERSION_NUMBER >= 0x030606
2465
.priority = "SECURE128:!CTYPE-X.509"
2466
":+CTYPE-RAWPK:!RSA:!VERS-ALL:+VERS-TLS1.3"
2467
":%PROFILE_ULTRA",
2468
#elif GNUTLS_VERSION_NUMBER < 0x030600
2469
.priority = "SECURE256:!CTYPE-X.509"
2470
":+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256",
2471
#else
2472
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
2473
#endif
2474
.current_server = NULL, .interfaces = NULL,
2475
.interfaces_size = 0 };
1515
2476
AvahiSServiceBrowser *sb = NULL;
1516
int error;
2477
error_t ret_errno;
1517
2478
int ret;
1518
2479
intmax_t tmpmax;
1519
2480
char *tmp;
1520
2481
int exitcode = EXIT_SUCCESS;
1521
const char *interface = "";
1522
struct ifreq network;
1523
int sd = -1;
1524
bool take_down_interface = false;
1525
uid_t uid;
1526
gid_t gid;
1527
char tempdir[] = "/tmp/mandosXXXXXX";
1528
bool tempdir_created = false;
2482
char *interfaces_to_take_down = NULL;
2483
size_t interfaces_to_take_down_size = 0;
2484
char run_tempdir[] = "/run/tmp/mandosXXXXXX";
2485
char old_tempdir[] = "/tmp/mandosXXXXXX";
2486
char *tempdir = NULL;
1529
2487
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1530
2488
const char *seckey = PATHDIR "/" SECKEY;
1531
2489
const char *pubkey = PATHDIR "/" PUBKEY;
2490
#if GNUTLS_VERSION_NUMBER >= 0x030606
2491
const char *tls_privkey = PATHDIR "/" TLS_PRIVKEY;
2492
const char *tls_pubkey = PATHDIR "/" TLS_PUBKEY;
2493
#endif
2494
const char *dh_params_file = NULL;
2495
char *interfaces_hooks = NULL;
1532
2496
1533
2497
bool gnutls_initialized = false;
1534
2498
bool gpgme_initialized = false;
1580
2544
{ .name = "pubkey", .key = 'p',
1581
2545
.arg = "FILE",
1582
2546
.doc = "OpenPGP public key file base name",
1583
.group = 2 },
2547
.group = 1 },
2548
{ .name = "tls-privkey", .key = 't',
2549
.arg = "FILE",
2550
#if GNUTLS_VERSION_NUMBER >= 0x030606
2551
.doc = "TLS private key file base name",
2552
#else
2553
.doc = "Dummy; ignored (requires GnuTLS 3.6.6)",
2554
#endif
2555
.group = 1 },
2556
{ .name = "tls-pubkey", .key = 'T',
2557
.arg = "FILE",
2558
#if GNUTLS_VERSION_NUMBER >= 0x030606
2559
.doc = "TLS public key file base name",
2560
#else
2561
.doc = "Dummy; ignored (requires GnuTLS 3.6.6)",
2562
#endif
2563
.group = 1 },
1584
2564
{ .name = "dh-bits", .key = 129,
1585
2565
.arg = "BITS",
1586
2566
.doc = "Bit length of the prime number used in the"
1587
2567
" Diffie-Hellman key exchange",
1588
2568
.group = 2 },
2569
{ .name = "dh-params", .key = 134,
2570
.arg = "FILE",
2571
.doc = "PEM-encoded PKCS#3 file with pre-generated parameters"
2572
" for the Diffie-Hellman key exchange",
2573
.group = 2 },
1589
2574
{ .name = "priority", .key = 130,
1590
2575
.arg = "STRING",
1591
2576
.doc = "GnuTLS priority string for the TLS handshake",
1596
2581
.group = 2 },
1597
2582
{ .name = "retry", .key = 132,
1598
2583
.arg = "SECONDS",
1599
.doc = "Retry interval used when denied by the mandos server",
2584
.doc = "Retry interval used when denied by the Mandos server",
1600
2585
.group = 2 },
1601
2586
{ .name = "network-hook-dir", .key = 133,
1602
2587
.arg = "DIR",
1625
2610
connect_to = arg;
1626
2611
break;
1627
2612
case 'i': /* --interface */
1628
interface = arg;
2613
ret_errno = argz_add_sep(&mc.interfaces, &mc.interfaces_size,
2614
arg, (int)',');
2615
if(ret_errno != 0){
2616
argp_error(state, "%s", strerror(ret_errno));
2617
}
1629
2618
break;
1630
2619
case 's': /* --seckey */
1631
2620
seckey = arg;
1633
2622
case 'p': /* --pubkey */
1634
2623
pubkey = arg;
1635
2624
break;
2625
case 't': /* --tls-privkey */
2626
#if GNUTLS_VERSION_NUMBER >= 0x030606
2627
tls_privkey = arg;
2628
#endif
2629
break;
2630
case 'T': /* --tls-pubkey */
2631
#if GNUTLS_VERSION_NUMBER >= 0x030606
2632
tls_pubkey = arg;
2633
#endif
2634
break;
1636
2635
case 129: /* --dh-bits */
1637
2636
errno = 0;
1638
2637
tmpmax = strtoimax(arg, &tmp, 10);
1642
2641
}
1643
2642
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
1644
2643
break;
2644
case 134: /* --dh-params */
2645
dh_params_file = arg;
2646
break;
1645
2647
case 130: /* --priority */
1646
2648
mc.priority = arg;
1647
2649
break;
1670
2672
argp_state_help(state, state->out_stream,
1671
2673
(ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
1672
2674
& ~(unsigned int)ARGP_HELP_EXIT_OK);
2675
__builtin_unreachable();
1673
2676
case -3: /* --usage */
1674
2677
argp_state_help(state, state->out_stream,
1675
2678
ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
2679
__builtin_unreachable();
1676
2680
case 'V': /* --version */
1677
2681
fprintf_plus(state->out_stream, "%s\n", argp_program_version);
1678
2682
exit(argp_err_exit_status);
1687
2691
.args_doc = "",
1688
2692
.doc = "Mandos client -- Get and decrypt"
1689
2693
" passwords from a Mandos server" };
1690
ret = argp_parse(&argp, argc, argv,
1691
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
1692
switch(ret){
2694
ret_errno = argp_parse(&argp, argc, argv,
2695
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2696
switch(ret_errno){
1693
2697
case 0:
1694
2698
break;
1695
2699
case ENOMEM:
1696
2700
default:
1697
errno = ret;
2701
errno = ret_errno;
1698
2702
perror_plus("argp_parse");
1699
2703
exitcode = EX_OSERR;
1700
2704
goto end;
1703
2707
goto end;
1704
2708
}
1705
2709
}
1706
2710
1707
2711
{
1708
2712
/* Work around Debian bug #633582:
1709
<http://bugs.debian.org/633582> */
2713
<https://bugs.debian.org/633582> */
1710
2714
1711
/* Re-raise priviliges */
1712
errno = 0;
1713
ret = seteuid(0);
1714
if(ret == -1){
1715
perror_plus("seteuid");
2715
/* Re-raise privileges */
2716
ret = raise_privileges();
2717
if(ret != 0){
2718
errno = ret;
2719
perror_plus("Failed to raise privileges");
1716
2720
} else {
1717
2721
struct stat st;
1718
2722
1733
2737
}
1734
2738
}
1735
2739
}
1736
TEMP_FAILURE_RETRY(close(seckey_fd));
2740
close(seckey_fd);
1737
2741
}
1738
2742
}
1739
2743
1740
2744
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
1741
2745
int pubkey_fd = open(pubkey, O_RDONLY);
1742
2746
if(pubkey_fd == -1){
1754
2758
}
1755
2759
}
1756
2760
}
1757
TEMP_FAILURE_RETRY(close(pubkey_fd));
1758
}
1759
}
1760
2761
close(pubkey_fd);
2762
}
2763
}
2764
2765
if(dh_params_file != NULL
2766
and strcmp(dh_params_file, PATHDIR "/dhparams.pem" ) == 0){
2767
int dhparams_fd = open(dh_params_file, O_RDONLY);
2768
if(dhparams_fd == -1){
2769
perror_plus("open");
2770
} else {
2771
ret = (int)TEMP_FAILURE_RETRY(fstat(dhparams_fd, &st));
2772
if(ret == -1){
2773
perror_plus("fstat");
2774
} else {
2775
if(S_ISREG(st.st_mode)
2776
and st.st_uid == 0 and st.st_gid == 0){
2777
ret = fchown(dhparams_fd, uid, gid);
2778
if(ret == -1){
2779
perror_plus("fchown");
2780
}
2781
}
2782
}
2783
close(dhparams_fd);
2784
}
2785
}
2786
1761
2787
/* Lower privileges */
1762
errno = 0;
1763
ret = seteuid(uid);
1764
if(ret == -1){
1765
perror_plus("seteuid");
2788
ret = lower_privileges();
2789
if(ret != 0){
2790
errno = ret;
2791
perror_plus("Failed to lower privileges");
2792
}
2793
}
2794
}
2795
2796
/* Remove invalid interface names (except "none") */
2797
{
2798
char *interface = NULL;
2799
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2800
interface))){
2801
if(strcmp(interface, "none") != 0
2802
and if_nametoindex(interface) == 0){
2803
if(interface[0] != '\0'){
2804
fprintf_plus(stderr, "Not using nonexisting interface"
2805
" \"%s\"\n", interface);
2806
}
2807
argz_delete(&mc.interfaces, &mc.interfaces_size, interface);
2808
interface = NULL;
1766
2809
}
1767
2810
}
1768
2811
}
1769
2812
1770
2813
/* Run network hooks */
1771
if(not run_network_hooks("start", interface, delay)){
1772
goto end;
2814
{
2815
if(mc.interfaces != NULL){
2816
interfaces_hooks = malloc(mc.interfaces_size);
2817
if(interfaces_hooks == NULL){
2818
perror_plus("malloc");
2819
goto end;
2820
}
2821
memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
2822
argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
2823
}
2824
run_network_hooks("start", interfaces_hooks != NULL ?
2825
interfaces_hooks : "", delay);
1773
2826
}
1774
2827
1775
2828
if(not debug){
1776
2829
avahi_set_log_function(empty_log);
1777
2830
}
1778
2831
1779
if(interface[0] == '\0'){
1780
struct dirent **direntries;
1781
/* First look for interfaces that are up */
1782
ret = scandir(sys_class_net, &direntries, up_interface,
1783
alphasort);
1784
if(ret == 0){
1785
/* No up interfaces, look for any good interfaces */
1786
free(direntries);
1787
ret = scandir(sys_class_net, &direntries, good_interface,
1788
alphasort);
1789
}
1790
if(ret >= 1){
1791
/* Pick the first interface returned */
1792
interface = strdup(direntries[0]->d_name);
1793
if(debug){
1794
fprintf_plus(stderr, "Using interface \"%s\"\n", interface);
1795
}
1796
if(interface == NULL){
1797
perror_plus("malloc");
1798
free(direntries);
1799
exitcode = EXIT_FAILURE;
1800
goto end;
1801
}
1802
free(direntries);
1803
} else {
1804
free(direntries);
1805
fprintf_plus(stderr, "Could not find a network interface\n");
1806
exitcode = EXIT_FAILURE;
1807
goto end;
1808
}
1809
}
1810
1811
2832
/* Initialize Avahi early so avahi_simple_poll_quit() can be called
1812
2833
from the signal handler */
1813
2834
/* Initialize the pseudo-RNG for Avahi */
1814
2835
srand((unsigned int) time(NULL));
1815
mc.simple_poll = avahi_simple_poll_new();
1816
if(mc.simple_poll == NULL){
2836
simple_poll = avahi_simple_poll_new();
2837
if(simple_poll == NULL){
1817
2838
fprintf_plus(stderr,
1818
2839
"Avahi: Failed to create simple poll object.\n");
1819
2840
exitcode = EX_UNAVAILABLE;
1883
2904
}
1884
2905
}
1885
2906
1886
/* If the interface is down, bring it up */
1887
if(strcmp(interface, "none") != 0){
1888
if_index = (AvahiIfIndex) if_nametoindex(interface);
1889
if(if_index == 0){
1890
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1891
exitcode = EX_UNAVAILABLE;
1892
goto end;
1893
}
1894
1895
if(quit_now){
1896
goto end;
1897
}
1898
1899
/* Re-raise priviliges */
1900
errno = 0;
1901
ret = seteuid(0);
1902
if(ret == -1){
1903
perror_plus("seteuid");
1904
}
1905
1906
#ifdef __linux__
1907
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1908
messages about the network interface to mess up the prompt */
1909
ret = klogctl(8, NULL, 5);
1910
bool restore_loglevel = true;
1911
if(ret == -1){
1912
restore_loglevel = false;
1913
perror_plus("klogctl");
1914
}
1915
#endif /* __linux__ */
1916
1917
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1918
if(sd < 0){
1919
perror_plus("socket");
1920
exitcode = EX_OSERR;
1921
#ifdef __linux__
1922
if(restore_loglevel){
1923
ret = klogctl(7, NULL, 0);
1924
if(ret == -1){
1925
perror_plus("klogctl");
1926
}
1927
}
1928
#endif /* __linux__ */
1929
/* Lower privileges */
1930
errno = 0;
1931
ret = seteuid(uid);
1932
if(ret == -1){
1933
perror_plus("seteuid");
1934
}
1935
goto end;
1936
}
1937
strcpy(network.ifr_name, interface);
1938
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1939
if(ret == -1){
1940
perror_plus("ioctl SIOCGIFFLAGS");
1941
#ifdef __linux__
1942
if(restore_loglevel){
1943
ret = klogctl(7, NULL, 0);
1944
if(ret == -1){
1945
perror_plus("klogctl");
1946
}
1947
}
1948
#endif /* __linux__ */
1949
exitcode = EX_OSERR;
1950
/* Lower privileges */
1951
errno = 0;
1952
ret = seteuid(uid);
1953
if(ret == -1){
1954
perror_plus("seteuid");
1955
}
1956
goto end;
1957
}
1958
if((network.ifr_flags & IFF_UP) == 0){
1959
network.ifr_flags |= IFF_UP;
1960
take_down_interface = true;
1961
ret = ioctl(sd, SIOCSIFFLAGS, &network);
1962
if(ret == -1){
1963
take_down_interface = false;
1964
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1965
exitcode = EX_OSERR;
1966
#ifdef __linux__
1967
if(restore_loglevel){
1968
ret = klogctl(7, NULL, 0);
1969
if(ret == -1){
1970
perror_plus("klogctl");
2907
/* If no interfaces were specified, make a list */
2908
if(mc.interfaces == NULL){
2909
struct dirent **direntries = NULL;
2910
/* Look for any good interfaces */
2911
ret = scandir(sys_class_net, &direntries, good_interface,
2912
alphasort);
2913
if(ret >= 1){
2914
/* Add all found interfaces to interfaces list */
2915
for(int i = 0; i < ret; ++i){
2916
ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
2917
direntries[i]->d_name);
2918
if(ret_errno != 0){
2919
errno = ret_errno;
2920
perror_plus("argz_add");
2921
free(direntries[i]);
2922
continue;
2923
}
2924
if(debug){
2925
fprintf_plus(stderr, "Will use interface \"%s\"\n",
2926
direntries[i]->d_name);
2927
}
2928
free(direntries[i]);
2929
}
2930
free(direntries);
2931
} else {
2932
if(ret == 0){
2933
free(direntries);
2934
}
2935
fprintf_plus(stderr, "Could not find a network interface\n");
2936
exitcode = EXIT_FAILURE;
2937
goto end;
2938
}
2939
}
2940
2941
/* Bring up interfaces which are down, and remove any "none"s */
2942
{
2943
char *interface = NULL;
2944
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2945
interface))){
2946
/* If interface name is "none", stop bringing up interfaces.
2947
Also remove all instances of "none" from the list */
2948
if(strcmp(interface, "none") == 0){
2949
argz_delete(&mc.interfaces, &mc.interfaces_size,
2950
interface);
2951
interface = NULL;
2952
while((interface = argz_next(mc.interfaces,
2953
mc.interfaces_size, interface))){
2954
if(strcmp(interface, "none") == 0){
2955
argz_delete(&mc.interfaces, &mc.interfaces_size,
2956
interface);
2957
interface = NULL;
1971
2958
}
1972
2959
}
1973
#endif /* __linux__ */
1974
/* Lower privileges */
1975
errno = 0;
1976
ret = seteuid(uid);
1977
if(ret == -1){
1978
perror_plus("seteuid");
1979
}
1980
goto end;
1981
}
1982
}
1983
/* Sleep checking until interface is running.
1984
Check every 0.25s, up to total time of delay */
1985
for(int i=0; i < delay * 4; i++){
1986
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1987
if(ret == -1){
1988
perror_plus("ioctl SIOCGIFFLAGS");
1989
} else if(network.ifr_flags & IFF_RUNNING){
1990
2960
break;
1991
2961
}
1992
struct timespec sleeptime = { .tv_nsec = 250000000 };
1993
ret = nanosleep(&sleeptime, NULL);
1994
if(ret == -1 and errno != EINTR){
1995
perror_plus("nanosleep");
1996
}
1997
}
1998
if(not take_down_interface){
1999
/* We won't need the socket anymore */
2000
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2001
if(ret == -1){
2002
perror_plus("close");
2003
}
2004
}
2005
#ifdef __linux__
2006
if(restore_loglevel){
2007
/* Restores kernel loglevel to default */
2008
ret = klogctl(7, NULL, 0);
2009
if(ret == -1){
2010
perror_plus("klogctl");
2011
}
2012
}
2013
#endif /* __linux__ */
2014
/* Lower privileges */
2015
errno = 0;
2016
/* Lower privileges */
2017
ret = seteuid(uid);
2018
if(ret == -1){
2019
perror_plus("seteuid");
2020
}
2962
bool interface_was_up = interface_is_up(interface);
2963
errno = bring_up_interface(interface, delay);
2964
if(not interface_was_up){
2965
if(errno != 0){
2966
fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
2967
" %s\n", interface, strerror(errno));
2968
} else {
2969
errno = argz_add(&interfaces_to_take_down,
2970
&interfaces_to_take_down_size,
2971
interface);
2972
if(errno != 0){
2973
perror_plus("argz_add");
2974
}
2975
}
2976
}
2977
}
2978
if(debug and (interfaces_to_take_down == NULL)){
2979
fprintf_plus(stderr, "No interfaces were brought up\n");
2980
}
2981
}
2982
2983
/* If we only got one interface, explicitly use only that one */
2984
if(argz_count(mc.interfaces, mc.interfaces_size) == 1){
2985
if(debug){
2986
fprintf_plus(stderr, "Using only interface \"%s\"\n",
2987
mc.interfaces);
2988
}
2989
if_index = (AvahiIfIndex)if_nametoindex(mc.interfaces);
2021
2990
}
2022
2991
2023
2992
if(quit_now){
2024
2993
goto end;
2025
2994
}
2026
2995
2027
ret = init_gnutls_global(pubkey, seckey);
2996
#if GNUTLS_VERSION_NUMBER >= 0x030606
2997
ret = init_gnutls_global(tls_pubkey, tls_privkey, dh_params_file, &mc);
2998
#elif GNUTLS_VERSION_NUMBER < 0x030600
2999
ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
3000
#else
3001
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
3002
#endif
2028
3003
if(ret == -1){
2029
3004
fprintf_plus(stderr, "init_gnutls_global failed\n");
2030
3005
exitcode = EX_UNAVAILABLE;
2037
3012
goto end;
2038
3013
}
2039
3014
2040
if(mkdtemp(tempdir) == NULL){
3015
/* Try /run/tmp before /tmp */
3016
tempdir = mkdtemp(run_tempdir);
3017
if(tempdir == NULL and errno == ENOENT){
3018
if(debug){
3019
fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
3020
run_tempdir, old_tempdir);
3021
}
3022
tempdir = mkdtemp(old_tempdir);
3023
}
3024
if(tempdir == NULL){
2041
3025
perror_plus("mkdtemp");
2042
3026
goto end;
2043
3027
}
2044
tempdir_created = true;
2045
3028
2046
3029
if(quit_now){
2047
3030
goto end;
2048
3031
}
2049
3032
2050
if(not init_gpgme(pubkey, seckey, tempdir)){
3033
if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
2051
3034
fprintf_plus(stderr, "init_gpgme failed\n");
2052
3035
exitcode = EX_UNAVAILABLE;
2053
3036
goto end;
2063
3046
/* Connect directly, do not use Zeroconf */
2064
3047
/* (Mainly meant for debugging) */
2065
3048
char *address = strrchr(connect_to, ':');
3049
2066
3050
if(address == NULL){
2067
3051
fprintf_plus(stderr, "No colon in address\n");
2068
3052
exitcode = EX_USAGE;
2073
3057
goto end;
2074
3058
}
2075
3059
2076
uint16_t port;
3060
in_port_t port;
2077
3061
errno = 0;
2078
3062
tmpmax = strtoimax(address+1, &tmp, 10);
2079
3063
if(errno != 0 or tmp == address+1 or *tmp != '\0'
2080
or tmpmax != (uint16_t)tmpmax){
3064
or tmpmax != (in_port_t)tmpmax){
2081
3065
fprintf_plus(stderr, "Bad port number\n");
2082
3066
exitcode = EX_USAGE;
2083
3067
goto end;
2084
3068
}
2085
3069
2086
3070
if(quit_now){
2087
3071
goto end;
2088
3072
}
2089
3073
2090
port = (uint16_t)tmpmax;
3074
port = (in_port_t)tmpmax;
2091
3075
*address = '\0';
2092
3076
/* Colon in address indicates IPv6 */
2093
3077
int af;
2109
3093
}
2110
3094
2111
3095
while(not quit_now){
2112
ret = start_mandos_communication(address, port, if_index, af);
3096
ret = start_mandos_communication(address, port, if_index, af,
3097
&mc);
2113
3098
if(quit_now or ret == 0){
2114
3099
break;
2115
3100
}
2117
3102
fprintf_plus(stderr, "Retrying in %d seconds\n",
2118
3103
(int)retry_interval);
2119
3104
}
2120
sleep((int)retry_interval);
3105
sleep((unsigned int)retry_interval);
2121
3106
}
2122
3107
2123
if (not quit_now){
3108
if(not quit_now){
2124
3109
exitcode = EXIT_SUCCESS;
2125
3110
}
2126
3111
2141
3126
config.publish_domain = 0;
2142
3127
2143
3128
/* Allocate a new server */
2144
mc.server = avahi_server_new(avahi_simple_poll_get
2145
(mc.simple_poll), &config, NULL,
2146
NULL, &error);
3129
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
3130
&config, NULL, NULL, &ret);
2147
3131
2148
3132
/* Free the Avahi configuration data */
2149
3133
avahi_server_config_free(&config);
2152
3136
/* Check if creating the Avahi server object succeeded */
2153
3137
if(mc.server == NULL){
2154
3138
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2155
avahi_strerror(error));
3139
avahi_strerror(ret));
2156
3140
exitcode = EX_UNAVAILABLE;
2157
3141
goto end;
2158
3142
}
2164
3148
/* Create the Avahi service browser */
2165
3149
sb = avahi_s_service_browser_new(mc.server, if_index,
2166
3150
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
2167
NULL, 0, browse_callback, NULL);
3151
NULL, 0, browse_callback,
3152
(void *)&mc);
2168
3153
if(sb == NULL){
2169
3154
fprintf_plus(stderr, "Failed to create service browser: %s\n",
2170
3155
avahi_strerror(avahi_server_errno(mc.server)));
2181
3166
if(debug){
2182
3167
fprintf_plus(stderr, "Starting Avahi loop search\n");
2183
3168
}
2184
2185
ret = avahi_loop_with_timeout(mc.simple_poll,
2186
(int)(retry_interval * 1000));
3169
3170
ret = avahi_loop_with_timeout(simple_poll,
3171
(int)(retry_interval * 1000), &mc);
2187
3172
if(debug){
2188
3173
fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
2189
3174
(ret == 0) ? "successfully" : "with error");
2192
3177
end:
2193
3178
2194
3179
if(debug){
2195
fprintf_plus(stderr, "%s exiting\n", argv[0]);
3180
if(signal_received){
3181
fprintf_plus(stderr, "%s exiting due to signal %d: %s\n",
3182
argv[0], signal_received,
3183
strsignal(signal_received));
3184
} else {
3185
fprintf_plus(stderr, "%s exiting\n", argv[0]);
3186
}
2196
3187
}
2197
3188
2198
3189
/* Cleanup things */
3190
free(mc.interfaces);
3191
2199
3192
if(sb != NULL)
2200
3193
avahi_s_service_browser_free(sb);
2201
3194
2202
3195
if(mc.server != NULL)
2203
3196
avahi_server_free(mc.server);
2204
3197
2205
if(mc.simple_poll != NULL)
2206
avahi_simple_poll_free(mc.simple_poll);
3198
if(simple_poll != NULL)
3199
avahi_simple_poll_free(simple_poll);
2207
3200
2208
3201
if(gnutls_initialized){
2209
3202
gnutls_certificate_free_credentials(mc.cred);
2210
gnutls_global_deinit();
2211
3203
gnutls_dh_params_deinit(mc.dh_params);
2212
3204
}
2213
3205
2221
3213
mc.current_server->prev->next = NULL;
2222
3214
while(mc.current_server != NULL){
2223
3215
server *next = mc.current_server->next;
3216
#ifdef __GNUC__
3217
#pragma GCC diagnostic push
3218
#pragma GCC diagnostic ignored "-Wcast-qual"
3219
#endif
3220
free((char *)(mc.current_server->ip));
3221
#ifdef __GNUC__
3222
#pragma GCC diagnostic pop
3223
#endif
2224
3224
free(mc.current_server);
2225
3225
mc.current_server = next;
2226
3226
}
2227
3227
}
2228
3228
2229
/* Run network hooks */
2230
run_network_hooks("stop", interface, delay);
2231
2232
/* Re-raise priviliges */
3229
/* Re-raise privileges */
2233
3230
{
2234
errno = 0;
2235
ret = seteuid(0);
2236
if(ret == -1){
2237
perror_plus("seteuid");
3231
ret = raise_privileges();
3232
if(ret != 0){
3233
errno = ret;
3234
perror_plus("Failed to raise privileges");
3235
} else {
3236
3237
/* Run network hooks */
3238
run_network_hooks("stop", interfaces_hooks != NULL ?
3239
interfaces_hooks : "", delay);
3240
3241
/* Take down the network interfaces which were brought up */
3242
{
3243
char *interface = NULL;
3244
while((interface = argz_next(interfaces_to_take_down,
3245
interfaces_to_take_down_size,
3246
interface))){
3247
ret = take_down_interface(interface);
3248
if(ret != 0){
3249
errno = ret;
3250
perror_plus("Failed to take down interface");
3251
}
3252
}
3253
if(debug and (interfaces_to_take_down == NULL)){
3254
fprintf_plus(stderr, "No interfaces needed to be taken"
3255
" down\n");
3256
}
3257
}
2238
3258
}
2239
3259
2240
/* Take down the network interface */
2241
if(take_down_interface and geteuid() == 0){
2242
ret = ioctl(sd, SIOCGIFFLAGS, &network);
2243
if(ret == -1){
2244
perror_plus("ioctl SIOCGIFFLAGS");
2245
} else if(network.ifr_flags & IFF_UP){
2246
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
2247
ret = ioctl(sd, SIOCSIFFLAGS, &network);
2248
if(ret == -1){
2249
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
2250
}
2251
}
2252
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2253
if(ret == -1){
2254
perror_plus("close");
2255
}
3260
ret = lower_privileges_permanently();
3261
if(ret != 0){
3262
errno = ret;
3263
perror_plus("Failed to lower privileges permanently");
2256
3264
}
2257
3265
}
2258
/* Lower privileges permanently */
2259
errno = 0;
2260
ret = setuid(uid);
2261
if(ret == -1){
2262
perror_plus("setuid");
3266
3267
free(interfaces_to_take_down);
3268
free(interfaces_hooks);
3269
3270
void clean_dir_at(int base, const char * const dirname,
3271
uintmax_t level){
3272
struct dirent **direntries = NULL;
3273
int dret;
3274
int dir_fd = (int)TEMP_FAILURE_RETRY(openat(base, dirname,
3275
O_RDONLY
3276
| O_NOFOLLOW
3277
| O_DIRECTORY
3278
| O_PATH));
3279
if(dir_fd == -1){
3280
perror_plus("open");
3281
return;
3282
}
3283
int numentries = scandirat(dir_fd, ".", &direntries,
3284
notdotentries, alphasort);
3285
if(numentries >= 0){
3286
for(int i = 0; i < numentries; i++){
3287
if(debug){
3288
fprintf_plus(stderr, "Unlinking \"%s/%s\"\n",
3289
dirname, direntries[i]->d_name);
3290
}
3291
dret = unlinkat(dir_fd, direntries[i]->d_name, 0);
3292
if(dret == -1){
3293
if(errno == EISDIR){
3294
dret = unlinkat(dir_fd, direntries[i]->d_name,
3295
AT_REMOVEDIR);
3296
}
3297
if((dret == -1) and (errno == ENOTEMPTY)
3298
and (strcmp(direntries[i]->d_name, "private-keys-v1.d")
3299
== 0) and (level == 0)){
3300
/* Recurse only in this special case */
3301
clean_dir_at(dir_fd, direntries[i]->d_name, level+1);
3302
dret = 0;
3303
}
3304
if((dret == -1) and (errno != ENOENT)){
3305
fprintf_plus(stderr, "unlink(\"%s/%s\"): %s\n", dirname,
3306
direntries[i]->d_name, strerror(errno));
3307
}
3308
}
3309
free(direntries[i]);
3310
}
3311
3312
/* need to clean even if 0 because man page doesn't specify */
3313
free(direntries);
3314
dret = unlinkat(base, dirname, AT_REMOVEDIR);
3315
if(dret == -1 and errno != ENOENT){
3316
perror_plus("rmdir");
3317
}
3318
} else {
3319
perror_plus("scandirat");
3320
}
3321
close(dir_fd);
2263
3322
}
2264
3323
2265
3324
/* Removes the GPGME temp directory and all files inside */
2266
if(tempdir_created){
2267
struct dirent **direntries = NULL;
2268
struct dirent *direntry = NULL;
2269
int numentries = scandir(tempdir, &direntries, notdotentries,
2270
alphasort);
2271
if (numentries > 0){
2272
for(int i = 0; i < numentries; i++){
2273
direntry = direntries[i];
2274
char *fullname = NULL;
2275
ret = asprintf(&fullname, "%s/%s", tempdir,
2276
direntry->d_name);
2277
if(ret < 0){
2278
perror_plus("asprintf");
2279
continue;
2280
}
2281
ret = remove(fullname);
2282
if(ret == -1){
2283
fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2284
strerror(errno));
2285
}
2286
free(fullname);
2287
}
2288
}
2289
2290
/* need to clean even if 0 because man page doesn't specify */
2291
free(direntries);
2292
if (numentries == -1){
2293
perror_plus("scandir");
2294
}
2295
ret = rmdir(tempdir);
2296
if(ret == -1 and errno != ENOENT){
2297
perror_plus("rmdir");
2298
}
3325
if(tempdir != NULL){
3326
clean_dir_at(-1, tempdir, 0);
2299
3327
}
2300
3328
2301
3329
if(quit_now){
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0