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