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