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