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 1229
- compare with another revision
- download diff
- download tarball
- view history from revision 1229
- Committer: teddy at recompile
- Date: 2020-12-03 20:30:45 UTC
- Revision ID: teddy@recompile.se-20201203203045-iqd6nq9y5nwalh1x
Minor fix of a test function
In dracut-module/password-agent, the test function
test_send_password_to_socket_EMSGSIZE() (which tests that the
send_password_to_socket() task function aborts properly when getting
EMSGSIZE when writing to the password socket), part of the test code
is supposed to find a message size which definitely does trigger
EMSGSIZE when send()ing to a socket. Without a "break" in the proper
place, however, the size given is always exactly 1024 bytes too large.
This is very probably not a problem, since a too large message will
still be too large if it is increased by 1024 bytes, and send(2) in
practice checks the size before reading the buffer. The biggest issue
would be if some version of send(2) would try to look at the last 1024
bytes of the message buffer before checking the message size; this
would then lead to a buffer over-read when running this test function.
(But even then there would be no security implications since the tests
are not run in the normal operation of the program.)
* dracut-module/password-agent.c
(test_send_password_to_socket_EMSGSIZE): Break out early when ssret
< 0 and errno == EMSGSIZE; don't allow loop to increase message_size
again.
In dracut-module/password-agent, the test function
test_send_password_to_socket_EMSGSIZE() (which tests that the
send_password_to_socket() task function aborts properly when getting
EMSGSIZE when writing to the password socket), part of the test code
is supposed to find a message size which definitely does trigger
EMSGSIZE when send()ing to a socket. Without a "break" in the proper
place, however, the size given is always exactly 1024 bytes too large.
This is very probably not a problem, since a too large message will
still be too large if it is increased by 1024 bytes, and send(2) in
practice checks the size before reading the buffer. The biggest issue
would be if some version of send(2) would try to look at the last 1024
bytes of the message buffer before checking the message size; this
would then lead to a buffer over-read when running this test function.
(But even then there would be no security implications since the tests
are not run in the normal operation of the program.)
* dracut-module/password-agent.c
(test_send_password_to_socket_EMSGSIZE): Break out early when ssret
< 0 and errno == EMSGSIZE; don't allow loop to increase message_size
again.
- files added:
- bugs.xml
- debian/tests
- debian/upstream
- dracut-module
- plugin-helpers
- files removed:
- initramfs-tools-hook-conf
- files modified:
- .bzrignore
added
removed
plugins.d/mandos-client.c
9
9
* "browse_callback", and parts of "main".
10
10
*
11
11
* Everything else is
12
* Copyright © 2008-2012 Teddy Hogeborn
13
* Copyright © 2008-2012 Björn Påhlsson
14
*
15
* This program is free software: you can redistribute it and/or
16
* modify it under the terms of the GNU General Public License as
17
* published by the Free Software Foundation, either version 3 of the
18
* License, or (at your option) any later version.
19
*
20
* This program is distributed in the hope that it will be useful, but
12
* Copyright © 2008-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
30
* Contact the authors at <mandos@recompile.se>.
30
31
*/
32
33
/* Needed by GPGME, specifically gpgme_data_seek() */
33
34
#ifndef _LARGEFILE_SOURCE
34
35
#define _LARGEFILE_SOURCE
35
#endif
36
#endif /* not _LARGEFILE_SOURCE */
36
37
#ifndef _FILE_OFFSET_BITS
37
38
#define _FILE_OFFSET_BITS 64
38
#endif
39
#endif /* not _FILE_OFFSET_BITS */
39
40
40
41
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
41
42
42
43
#include <stdio.h> /* fprintf(), stderr, fwrite(),
43
stdout, ferror(), remove() */
44
stdout, ferror() */
44
45
#include <stdint.h> /* uint16_t, uint32_t, intptr_t */
45
46
#include <stddef.h> /* NULL, size_t, ssize_t */
46
47
#include <stdlib.h> /* free(), EXIT_SUCCESS, srand(),
47
48
strtof(), abort() */
48
49
#include <stdbool.h> /* bool, false, true */
49
#include <string.h> /* memset(), strcmp(), strlen(),
50
strerror(), asprintf(), strcpy() */
50
#include <string.h> /* strcmp(), strlen(), strerror(),
51
asprintf(), strncpy(), strsignal()
52
*/
51
53
#include <sys/ioctl.h> /* ioctl */
52
54
#include <sys/types.h> /* socket(), inet_pton(), sockaddr,
53
55
sockaddr_in6, PF_INET6,
55
57
opendir(), DIR */
56
58
#include <sys/stat.h> /* open(), S_ISREG */
57
59
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
58
inet_pton(), connect() */
59
#include <fcntl.h> /* open() */
60
inet_pton(), connect(),
61
getnameinfo() */
62
#include <fcntl.h> /* open(), unlinkat(), AT_REMOVEDIR */
60
63
#include <dirent.h> /* opendir(), struct dirent, readdir()
61
64
*/
62
65
#include <inttypes.h> /* PRIu16, PRIdMAX, intmax_t,
63
66
strtoimax() */
64
#include <assert.h> /* assert() */
65
#include <errno.h> /* perror(), errno,
67
#include <errno.h> /* perror(), errno, EINTR, EINVAL,
68
EAI_SYSTEM, ENETUNREACH,
69
EHOSTUNREACH, ECONNREFUSED, EPROTO,
70
EIO, ENOENT, ENXIO, ENOMEM, EISDIR,
71
ENOTEMPTY,
66
72
program_invocation_short_name */
67
73
#include <time.h> /* nanosleep(), time(), sleep() */
68
74
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
73
79
*/
74
80
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
75
81
getuid(), getgid(), seteuid(),
76
setgid(), pause(), _exit() */
77
#include <arpa/inet.h> /* inet_pton(), htons, inet_ntop() */
82
setgid(), pause(), _exit(),
83
unlinkat() */
84
#include <arpa/inet.h> /* inet_pton(), htons() */
78
85
#include <iso646.h> /* not, or, and */
79
86
#include <argp.h> /* struct argp_option, error_t, struct
80
87
argp_state, struct argp,
88
95
#include <sys/wait.h> /* waitpid(), WIFEXITED(),
89
96
WEXITSTATUS(), WTERMSIG() */
90
97
#include <grp.h> /* setgroups() */
98
#include <argz.h> /* argz_add_sep(), argz_next(),
99
argz_delete(), argz_append(),
100
argz_stringify(), argz_add(),
101
argz_count() */
102
#include <netdb.h> /* getnameinfo(), NI_NUMERICHOST,
103
EAI_SYSTEM, gai_strerror() */
91
104
92
105
#ifdef __linux__
93
106
#include <sys/klog.h> /* klogctl() */
110
123
gnutls_*
111
124
init_gnutls_session(),
112
125
GNUTLS_* */
126
#if GNUTLS_VERSION_NUMBER < 0x030600
113
127
#include <gnutls/openpgp.h>
114
128
/* gnutls_certificate_set_openpgp_key_file(),
115
129
GNUTLS_OPENPGP_FMT_BASE64 */
130
#elif GNUTLS_VERSION_NUMBER >= 0x030606
131
#include <gnutls/x509.h> /* gnutls_pkcs_encrypt_flags_t,
132
GNUTLS_PKCS_PLAIN,
133
GNUTLS_PKCS_NULL_PASSWORD */
134
#endif
116
135
117
136
/* GPGME */
118
137
#include <gpgme.h> /* All GPGME types, constants and
126
145
#define PATHDIR "/conf/conf.d/mandos"
127
146
#define SECKEY "seckey.txt"
128
147
#define PUBKEY "pubkey.txt"
148
#define TLS_PRIVKEY "tls-privkey.pem"
149
#define TLS_PUBKEY "tls-pubkey.pem"
129
150
#define HOOKDIR "/lib/mandos/network-hooks.d"
130
151
131
152
bool debug = false;
135
156
static const char sys_class_net[] = "/sys/class/net";
136
157
char *connect_to = NULL;
137
158
const char *hookdir = HOOKDIR;
159
int hookdir_fd = -1;
138
160
uid_t uid = 65534;
139
161
gid_t gid = 65534;
140
162
141
163
/* Doubly linked list that need to be circularly linked when used */
142
164
typedef struct server{
143
165
const char *ip;
144
uint16_t port;
166
in_port_t port;
145
167
AvahiIfIndex if_index;
146
168
int af;
147
169
struct timespec last_seen;
151
173
152
174
/* Used for passing in values through the Avahi callback functions */
153
175
typedef struct {
154
AvahiSimplePoll *simple_poll;
155
176
AvahiServer *server;
156
177
gnutls_certificate_credentials_t cred;
157
178
unsigned int dh_bits;
159
180
const char *priority;
160
181
gpgme_ctx_t ctx;
161
182
server *current_server;
183
char *interfaces;
184
size_t interfaces_size;
162
185
} mandos_context;
163
186
164
/* global context so signal handler can reach it*/
165
mandos_context mc = { .simple_poll = NULL, .server = NULL,
166
.dh_bits = 1024, .priority = "SECURE256"
167
":!CTYPE-X.509:+CTYPE-OPENPGP",
168
.current_server = NULL };
187
/* global so signal handler can reach it*/
188
AvahiSimplePoll *simple_poll;
169
189
170
190
sig_atomic_t quit_now = 0;
171
191
int signal_received = 0;
179
199
perror(print_text);
180
200
}
181
201
182
__attribute__((format (gnu_printf, 2, 3)))
202
__attribute__((format (gnu_printf, 2, 3), nonnull))
183
203
int fprintf_plus(FILE *stream, const char *format, ...){
184
204
va_list ap;
185
205
va_start (ap, format);
186
206
187
207
TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
188
208
program_invocation_short_name));
189
return TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
209
return (int)TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
190
210
}
191
211
192
212
/*
194
214
* bytes. "buffer_capacity" is how much is currently allocated,
195
215
* "buffer_length" is how much is already used.
196
216
*/
217
__attribute__((nonnull, warn_unused_result))
197
218
size_t incbuffer(char **buffer, size_t buffer_length,
198
219
size_t buffer_capacity){
199
220
if(buffer_length + BUFFER_SIZE > buffer_capacity){
200
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
201
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;
202
227
return 0;
203
228
}
229
*buffer = new_buf;
204
230
buffer_capacity += BUFFER_SIZE;
205
231
}
206
232
return buffer_capacity;
207
233
}
208
234
209
235
/* Add server to set of servers to retry periodically */
210
bool add_server(const char *ip, uint16_t port, AvahiIfIndex if_index,
211
int af){
236
__attribute__((nonnull, warn_unused_result))
237
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
238
int af, server **current_server){
212
239
int ret;
213
240
server *new_server = malloc(sizeof(server));
214
241
if(new_server == NULL){
221
248
.af = af };
222
249
if(new_server->ip == NULL){
223
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);
224
266
return false;
225
267
}
226
268
/* Special case of first server */
227
if (mc.current_server == NULL){
269
if(*current_server == NULL){
228
270
new_server->next = new_server;
229
271
new_server->prev = new_server;
230
mc.current_server = new_server;
231
/* Place the new server last in the list */
272
*current_server = new_server;
232
273
} else {
233
new_server->next = mc.current_server;
234
new_server->prev = mc.current_server->prev;
274
/* Place the new server last in the list */
275
new_server->next = *current_server;
276
new_server->prev = (*current_server)->prev;
235
277
new_server->prev->next = new_server;
236
mc.current_server->prev = new_server;
237
}
238
ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);
239
if(ret == -1){
240
perror_plus("clock_gettime");
241
return false;
278
(*current_server)->prev = new_server;
242
279
}
243
280
return true;
244
281
}
245
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
246
335
/*
247
336
* Initialize GPGME.
248
337
*/
249
static bool init_gpgme(const char *seckey, const char *pubkey,
250
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){
251
343
gpgme_error_t rc;
252
344
gpgme_engine_info_t engine_info;
253
345
254
255
346
/*
256
347
* Helper function to insert pub and seckey to the engine keyring.
257
348
*/
258
bool import_key(const char *filename){
349
bool import_key(const char * const filename){
259
350
int ret;
260
351
int fd;
261
352
gpgme_data_t pgp_data;
266
357
return false;
267
358
}
268
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
269
409
rc = gpgme_data_new_from_fd(&pgp_data, fd);
270
410
if(rc != GPG_ERR_NO_ERROR){
271
411
fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
273
413
return false;
274
414
}
275
415
276
rc = gpgme_op_import(mc.ctx, pgp_data);
416
rc = gpgme_op_import(mc->ctx, pgp_data);
277
417
if(rc != GPG_ERR_NO_ERROR){
278
418
fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
279
419
gpgme_strsource(rc), gpgme_strerror(rc));
280
420
return false;
281
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
}
282
497
283
ret = (int)TEMP_FAILURE_RETRY(close(fd));
498
ret = close(fd);
284
499
if(ret == -1){
285
500
perror_plus("close");
286
501
}
323
538
}
324
539
325
540
/* Create new GPGME "context" */
326
rc = gpgme_new(&(mc.ctx));
541
rc = gpgme_new(&(mc->ctx));
327
542
if(rc != GPG_ERR_NO_ERROR){
328
fprintf_plus(stderr, "Mandos plugin mandos-client: "
329
"bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
330
gpgme_strerror(rc));
543
fprintf_plus(stderr, "bad gpgme_new: %s: %s\n",
544
gpgme_strsource(rc), gpgme_strerror(rc));
331
545
return false;
332
546
}
333
547
342
556
* Decrypt OpenPGP data.
343
557
* Returns -1 on error
344
558
*/
559
__attribute__((nonnull, warn_unused_result))
345
560
static ssize_t pgp_packet_decrypt(const char *cryptotext,
346
561
size_t crypto_size,
347
char **plaintext){
562
char **plaintext,
563
mandos_context *mc){
348
564
gpgme_data_t dh_crypto, dh_plain;
349
565
gpgme_error_t rc;
350
566
ssize_t ret;
367
583
/* Create new empty GPGME data buffer for the plaintext */
368
584
rc = gpgme_data_new(&dh_plain);
369
585
if(rc != GPG_ERR_NO_ERROR){
370
fprintf_plus(stderr, "Mandos plugin mandos-client: "
371
"bad gpgme_data_new: %s: %s\n",
586
fprintf_plus(stderr, "bad gpgme_data_new: %s: %s\n",
372
587
gpgme_strsource(rc), gpgme_strerror(rc));
373
588
gpgme_data_release(dh_crypto);
374
589
return -1;
376
591
377
592
/* Decrypt data from the cryptotext data buffer to the plaintext
378
593
data buffer */
379
rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
594
rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
380
595
if(rc != GPG_ERR_NO_ERROR){
381
596
fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
382
597
gpgme_strsource(rc), gpgme_strerror(rc));
383
598
plaintext_length = -1;
384
599
if(debug){
385
600
gpgme_decrypt_result_t result;
386
result = gpgme_op_decrypt_result(mc.ctx);
601
result = gpgme_op_decrypt_result(mc->ctx);
387
602
if(result == NULL){
388
603
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
389
604
} else {
390
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
391
result->unsupported_algorithm);
392
fprintf_plus(stderr, "Wrong key usage: %u\n",
393
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");
394
611
if(result->file_name != NULL){
395
612
fprintf_plus(stderr, "File name: %s\n", result->file_name);
396
613
}
397
gpgme_recipient_t recipient;
398
recipient = result->recipients;
399
while(recipient != NULL){
614
615
for(gpgme_recipient_t r = result->recipients; r != NULL;
616
r = r->next){
400
617
fprintf_plus(stderr, "Public key algorithm: %s\n",
401
gpgme_pubkey_algo_name
402
(recipient->pubkey_algo));
403
fprintf_plus(stderr, "Key ID: %s\n", recipient->keyid);
618
gpgme_pubkey_algo_name(r->pubkey_algo));
619
fprintf_plus(stderr, "Key ID: %s\n", r->keyid);
404
620
fprintf_plus(stderr, "Secret key available: %s\n",
405
recipient->status == GPG_ERR_NO_SECKEY
406
? "No" : "Yes");
407
recipient = recipient->next;
621
r->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
408
622
}
409
623
}
410
624
}
466
680
return plaintext_length;
467
681
}
468
682
469
static const char * safer_gnutls_strerror(int value){
470
const char *ret = gnutls_strerror(value); /* Spurious warning from
471
-Wunreachable-code */
472
if(ret == NULL)
473
ret = "(unknown)";
474
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);
475
694
}
476
695
477
696
/* GnuTLS log function callback */
697
__attribute__((nonnull))
478
698
static void debuggnutls(__attribute__((unused)) int level,
479
699
const char* string){
480
700
fprintf_plus(stderr, "GnuTLS: %s", string);
481
701
}
482
702
703
__attribute__((nonnull(1, 2, 4), warn_unused_result))
483
704
static int init_gnutls_global(const char *pubkeyfilename,
484
const char *seckeyfilename){
705
const char *seckeyfilename,
706
const char *dhparamsfilename,
707
mandos_context *mc){
485
708
int ret;
486
709
487
710
if(debug){
488
711
fprintf_plus(stderr, "Initializing GnuTLS\n");
489
712
}
490
713
491
ret = gnutls_global_init();
492
if(ret != GNUTLS_E_SUCCESS){
493
fprintf_plus(stderr, "GnuTLS global_init: %s\n",
494
safer_gnutls_strerror(ret));
495
return -1;
496
}
497
498
714
if(debug){
499
715
/* "Use a log level over 10 to enable all debugging options."
500
716
* - GnuTLS manual
504
720
}
505
721
506
722
/* OpenPGP credentials */
507
ret = gnutls_certificate_allocate_credentials(&mc.cred);
723
ret = gnutls_certificate_allocate_credentials(&mc->cred);
508
724
if(ret != GNUTLS_E_SUCCESS){
509
725
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
510
726
safer_gnutls_strerror(ret));
511
gnutls_global_deinit();
512
727
return -1;
513
728
}
514
729
515
730
if(debug){
516
fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
517
" secret key %s as GnuTLS credentials\n",
731
fprintf_plus(stderr, "Attempting to use public key %s and"
732
" private key %s as GnuTLS credentials\n",
518
733
pubkeyfilename,
519
734
seckeyfilename);
520
735
}
521
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
522
750
ret = gnutls_certificate_set_openpgp_key_file
523
(mc.cred, pubkeyfilename, seckeyfilename,
751
(mc->cred, pubkeyfilename, seckeyfilename,
524
752
GNUTLS_OPENPGP_FMT_BASE64);
753
#else
754
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
755
#endif
525
756
if(ret != GNUTLS_E_SUCCESS){
526
757
fprintf_plus(stderr,
527
"Error[%d] while reading the OpenPGP key pair ('%s',"
758
"Error[%d] while reading the key pair ('%s',"
528
759
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
529
760
fprintf_plus(stderr, "The GnuTLS error is: %s\n",
530
761
safer_gnutls_strerror(ret));
532
763
}
533
764
534
765
/* GnuTLS server initialization */
535
ret = gnutls_dh_params_init(&mc.dh_params);
766
ret = gnutls_dh_params_init(&mc->dh_params);
536
767
if(ret != GNUTLS_E_SUCCESS){
537
768
fprintf_plus(stderr, "Error in GnuTLS DH parameter"
538
769
" initialization: %s\n",
539
770
safer_gnutls_strerror(ret));
540
771
goto globalfail;
541
772
}
542
ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
543
if(ret != GNUTLS_E_SUCCESS){
544
fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
545
safer_gnutls_strerror(ret));
546
goto globalfail;
547
}
548
549
gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
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
}
550
955
551
956
return 0;
552
957
553
958
globalfail:
554
959
555
gnutls_certificate_free_credentials(mc.cred);
556
gnutls_global_deinit();
557
gnutls_dh_params_deinit(mc.dh_params);
960
gnutls_certificate_free_credentials(mc->cred);
961
gnutls_dh_params_deinit(mc->dh_params);
558
962
return -1;
559
963
}
560
964
561
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){
562
968
int ret;
563
969
/* GnuTLS session creation */
564
970
do {
565
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
));
566
979
if(quit_now){
567
980
return -1;
568
981
}
576
989
{
577
990
const char *err;
578
991
do {
579
ret = gnutls_priority_set_direct(*session, mc.priority, &err);
992
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
580
993
if(quit_now){
581
994
gnutls_deinit(*session);
582
995
return -1;
593
1006
594
1007
do {
595
1008
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
596
mc.cred);
1009
mc->cred);
597
1010
if(quit_now){
598
1011
gnutls_deinit(*session);
599
1012
return -1;
609
1022
/* ignore client certificate if any. */
610
1023
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
611
1024
612
gnutls_dh_set_prime_bits(*session, mc.dh_bits);
613
614
1025
return 0;
615
1026
}
616
1027
618
1029
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
619
1030
__attribute__((unused)) const char *txt){}
620
1031
1032
/* Helper function to add_local_route() and delete_local_route() */
1033
__attribute__((nonnull, warn_unused_result))
1034
static bool add_delete_local_route(const bool add,
1035
const char *address,
1036
AvahiIfIndex if_index){
1037
int ret;
1038
char helper[] = "mandos-client-iprouteadddel";
1039
char add_arg[] = "add";
1040
char delete_arg[] = "delete";
1041
char debug_flag[] = "--debug";
1042
char *pluginhelperdir = getenv("MANDOSPLUGINHELPERDIR");
1043
if(pluginhelperdir == NULL){
1044
if(debug){
1045
fprintf_plus(stderr, "MANDOSPLUGINHELPERDIR environment"
1046
" variable not set; cannot run helper\n");
1047
}
1048
return false;
1049
}
1050
1051
char interface[IF_NAMESIZE];
1052
if(if_indextoname((unsigned int)if_index, interface) == NULL){
1053
perror_plus("if_indextoname");
1054
return false;
1055
}
1056
1057
int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
1058
if(devnull == -1){
1059
perror_plus("open(\"/dev/null\", O_RDONLY)");
1060
return false;
1061
}
1062
pid_t pid = fork();
1063
if(pid == 0){
1064
/* Child */
1065
/* Raise privileges */
1066
errno = raise_privileges_permanently();
1067
if(errno != 0){
1068
perror_plus("Failed to raise privileges");
1069
/* _exit(EX_NOPERM); */
1070
} else {
1071
/* Set group */
1072
errno = 0;
1073
ret = setgid(0);
1074
if(ret == -1){
1075
perror_plus("setgid");
1076
close(devnull);
1077
_exit(EX_NOPERM);
1078
}
1079
/* Reset supplementary groups */
1080
errno = 0;
1081
ret = setgroups(0, NULL);
1082
if(ret == -1){
1083
perror_plus("setgroups");
1084
close(devnull);
1085
_exit(EX_NOPERM);
1086
}
1087
}
1088
ret = dup2(devnull, STDIN_FILENO);
1089
if(ret == -1){
1090
perror_plus("dup2(devnull, STDIN_FILENO)");
1091
close(devnull);
1092
_exit(EX_OSERR);
1093
}
1094
ret = close(devnull);
1095
if(ret == -1){
1096
perror_plus("close");
1097
}
1098
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
1099
if(ret == -1){
1100
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
1101
_exit(EX_OSERR);
1102
}
1103
int helperdir_fd = (int)TEMP_FAILURE_RETRY(open(pluginhelperdir,
1104
O_RDONLY
1105
| O_DIRECTORY
1106
| O_PATH
1107
| O_CLOEXEC));
1108
if(helperdir_fd == -1){
1109
perror_plus("open");
1110
_exit(EX_UNAVAILABLE);
1111
}
1112
int helper_fd = (int)TEMP_FAILURE_RETRY(openat(helperdir_fd,
1113
helper, O_RDONLY));
1114
if(helper_fd == -1){
1115
perror_plus("openat");
1116
close(helperdir_fd);
1117
_exit(EX_UNAVAILABLE);
1118
}
1119
close(helperdir_fd);
1120
#ifdef __GNUC__
1121
#pragma GCC diagnostic push
1122
#pragma GCC diagnostic ignored "-Wcast-qual"
1123
#endif
1124
if(fexecve(helper_fd, (char *const [])
1125
{ helper, add ? add_arg : delete_arg, (char *)address,
1126
interface, debug ? debug_flag : NULL, NULL },
1127
environ) == -1){
1128
#ifdef __GNUC__
1129
#pragma GCC diagnostic pop
1130
#endif
1131
perror_plus("fexecve");
1132
_exit(EXIT_FAILURE);
1133
}
1134
}
1135
if(pid == -1){
1136
perror_plus("fork");
1137
close(devnull);
1138
return false;
1139
}
1140
ret = close(devnull);
1141
if(ret == -1){
1142
perror_plus("close");
1143
}
1144
int status;
1145
pid_t pret = -1;
1146
errno = 0;
1147
do {
1148
pret = waitpid(pid, &status, 0);
1149
if(pret == -1 and errno == EINTR and quit_now){
1150
int errno_raising = 0;
1151
if((errno = raise_privileges()) != 0){
1152
errno_raising = errno;
1153
perror_plus("Failed to raise privileges in order to"
1154
" kill helper program");
1155
}
1156
if(kill(pid, SIGTERM) == -1){
1157
perror_plus("kill");
1158
}
1159
if((errno_raising == 0) and (errno = lower_privileges()) != 0){
1160
perror_plus("Failed to lower privileges after killing"
1161
" helper program");
1162
}
1163
return false;
1164
}
1165
} while(pret == -1 and errno == EINTR);
1166
if(pret == -1){
1167
perror_plus("waitpid");
1168
return false;
1169
}
1170
if(WIFEXITED(status)){
1171
if(WEXITSTATUS(status) != 0){
1172
fprintf_plus(stderr, "Error: iprouteadddel exited"
1173
" with status %d\n", WEXITSTATUS(status));
1174
return false;
1175
}
1176
return true;
1177
}
1178
if(WIFSIGNALED(status)){
1179
fprintf_plus(stderr, "Error: iprouteadddel died by"
1180
" signal %d\n", WTERMSIG(status));
1181
return false;
1182
}
1183
fprintf_plus(stderr, "Error: iprouteadddel crashed\n");
1184
return false;
1185
}
1186
1187
__attribute__((nonnull, warn_unused_result))
1188
static bool add_local_route(const char *address,
1189
AvahiIfIndex if_index){
1190
if(debug){
1191
fprintf_plus(stderr, "Adding route to %s\n", address);
1192
}
1193
return add_delete_local_route(true, address, if_index);
1194
}
1195
1196
__attribute__((nonnull, warn_unused_result))
1197
static bool delete_local_route(const char *address,
1198
AvahiIfIndex if_index){
1199
if(debug){
1200
fprintf_plus(stderr, "Removing route to %s\n", address);
1201
}
1202
return add_delete_local_route(false, address, if_index);
1203
}
1204
621
1205
/* Called when a Mandos server is found */
622
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,
623
1208
AvahiIfIndex if_index,
624
int af){
1209
int af, mandos_context *mc){
625
1210
int ret, tcp_sd = -1;
626
1211
ssize_t sret;
627
union {
628
struct sockaddr_in in;
629
struct sockaddr_in6 in6;
630
} to;
1212
struct sockaddr_storage to;
631
1213
char *buffer = NULL;
632
1214
char *decrypted_buffer = NULL;
633
1215
size_t buffer_length = 0;
636
1218
int retval = -1;
637
1219
gnutls_session_t session;
638
1220
int pf; /* Protocol family */
1221
bool route_added = false;
639
1222
640
1223
errno = 0;
641
1224
657
1240
return -1;
658
1241
}
659
1242
660
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);
661
1277
if(ret != 0){
662
1278
return -1;
663
1279
}
664
1280
665
1281
if(debug){
666
1282
fprintf_plus(stderr, "Setting up a TCP connection to %s, port %"
667
PRIu16 "\n", ip, port);
1283
PRIuMAX "\n", ip, (uintmax_t)port);
668
1284
}
669
1285
670
tcp_sd = socket(pf, SOCK_STREAM, 0);
1286
tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
671
1287
if(tcp_sd < 0){
672
1288
int e = errno;
673
1289
perror_plus("socket");
680
1296
goto mandos_end;
681
1297
}
682
1298
683
memset(&to, 0, sizeof(to));
684
1299
if(af == AF_INET6){
685
to.in6.sin6_family = (sa_family_t)af;
686
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);
687
1303
} else { /* IPv4 */
688
to.in.sin_family = (sa_family_t)af;
689
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);
690
1307
}
691
1308
if(ret < 0 ){
692
1309
int e = errno;
701
1318
goto mandos_end;
702
1319
}
703
1320
if(af == AF_INET6){
704
to.in6.sin6_port = htons(port); /* Spurious warnings from
705
-Wconversion and
706
-Wunreachable-code */
707
708
if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
709
(&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
710
-Wunreachable-code*/
1321
((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
1322
if(IN6_IS_ADDR_LINKLOCAL
1323
(&((struct sockaddr_in6 *)&to)->sin6_addr)){
711
1324
if(if_index == AVAHI_IF_UNSPEC){
712
1325
fprintf_plus(stderr, "An IPv6 link-local address is"
713
1326
" incomplete without a network interface\n");
715
1328
goto mandos_end;
716
1329
}
717
1330
/* Set the network interface number as scope */
718
to.in6.sin6_scope_id = (uint32_t)if_index;
1331
((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
719
1332
}
720
1333
} else {
721
to.in.sin_port = htons(port); /* Spurious warnings from
722
-Wconversion and
723
-Wunreachable-code */
1334
((struct sockaddr_in *)&to)->sin_port = htons(port);
724
1335
}
725
1336
726
1337
if(quit_now){
734
1345
if(if_indextoname((unsigned int)if_index, interface) == NULL){
735
1346
perror_plus("if_indextoname");
736
1347
} else {
737
fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIu16
738
"\n", ip, interface, port);
1348
fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIuMAX
1349
"\n", ip, interface, (uintmax_t)port);
739
1350
}
740
1351
} else {
741
fprintf_plus(stderr, "Connection to: %s, port %" PRIu16 "\n",
742
ip, port);
1352
fprintf_plus(stderr, "Connection to: %s, port %" PRIuMAX "\n",
1353
ip, (uintmax_t)port);
743
1354
}
744
1355
char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
745
1356
INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
746
const char *pcret;
747
if(af == AF_INET6){
748
pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
749
sizeof(addrstr));
750
} else {
751
pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
752
sizeof(addrstr));
753
}
754
if(pcret == NULL){
755
perror_plus("inet_ntop");
756
} else {
757
if(strcmp(addrstr, ip) != 0){
758
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
759
}
760
}
761
}
762
763
if(quit_now){
764
errno = EINTR;
765
goto mandos_end;
766
}
767
768
if(af == AF_INET6){
769
ret = connect(tcp_sd, &to.in6, sizeof(to));
770
} else {
771
ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
772
}
773
if(ret < 0){
774
if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
775
int e = errno;
776
perror_plus("connect");
777
errno = e;
778
}
779
goto mandos_end;
780
}
781
782
if(quit_now){
783
errno = EINTR;
784
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;
785
1437
}
786
1438
787
1439
const char *out = mandos_protocol_version;
938
1590
if(buffer_length > 0){
939
1591
ssize_t decrypted_buffer_size;
940
1592
decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
941
&decrypted_buffer);
1593
&decrypted_buffer, mc);
942
1594
if(decrypted_buffer_size >= 0){
943
1595
1596
clearerr(stdout);
944
1597
written = 0;
945
1598
while(written < (size_t) decrypted_buffer_size){
946
1599
if(quit_now){
962
1615
}
963
1616
written += (size_t)ret;
964
1617
}
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
}
965
1628
retval = 0;
966
1629
}
967
1630
}
970
1633
971
1634
mandos_end:
972
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
}
973
1642
int e = errno;
974
1643
free(decrypted_buffer);
975
1644
free(buffer);
976
1645
if(tcp_sd >= 0){
977
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
1646
ret = close(tcp_sd);
978
1647
}
979
1648
if(ret == -1){
980
1649
if(e == 0){
1005
1674
AVAHI_GCC_UNUSED AvahiStringList *txt,
1006
1675
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1007
1676
flags,
1008
AVAHI_GCC_UNUSED void* userdata){
1009
assert(r);
1677
void *mc){
1678
if(r == NULL){
1679
return;
1680
}
1010
1681
1011
1682
/* Called whenever a service has been resolved successfully or
1012
1683
timed out */
1013
1684
1014
1685
if(quit_now){
1686
avahi_s_service_resolver_free(r);
1015
1687
return;
1016
1688
}
1017
1689
1021
1693
fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
1022
1694
"'%s' of type '%s' in domain '%s': %s\n", name, type,
1023
1695
domain,
1024
avahi_strerror(avahi_server_errno(mc.server)));
1696
avahi_strerror(avahi_server_errno
1697
(((mandos_context*)mc)->server)));
1025
1698
break;
1026
1699
1027
1700
case AVAHI_RESOLVER_FOUND:
1033
1706
PRIdMAX ") on port %" PRIu16 "\n", name,
1034
1707
host_name, ip, (intmax_t)interface, port);
1035
1708
}
1036
int ret = start_mandos_communication(ip, port, interface,
1037
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);
1038
1713
if(ret == 0){
1039
avahi_simple_poll_quit(mc.simple_poll);
1714
avahi_simple_poll_quit(simple_poll);
1040
1715
} else {
1041
if(not add_server(ip, port, interface,
1042
avahi_proto_to_af(proto))){
1716
if(not add_server(ip, (in_port_t)port, interface,
1717
avahi_proto_to_af(proto),
1718
&((mandos_context*)mc)->current_server)){
1043
1719
fprintf_plus(stderr, "Failed to add server \"%s\" to server"
1044
1720
" list\n", name);
1045
1721
}
1058
1734
const char *domain,
1059
1735
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1060
1736
flags,
1061
AVAHI_GCC_UNUSED void* userdata){
1062
assert(b);
1737
void *mc){
1738
if(b == NULL){
1739
return;
1740
}
1063
1741
1064
1742
/* Called whenever a new services becomes available on the LAN or
1065
1743
is removed from the LAN */
1073
1751
case AVAHI_BROWSER_FAILURE:
1074
1752
1075
1753
fprintf_plus(stderr, "(Avahi browser) %s\n",
1076
avahi_strerror(avahi_server_errno(mc.server)));
1077
avahi_simple_poll_quit(mc.simple_poll);
1754
avahi_strerror(avahi_server_errno
1755
(((mandos_context*)mc)->server)));
1756
avahi_simple_poll_quit(simple_poll);
1078
1757
return;
1079
1758
1080
1759
case AVAHI_BROWSER_NEW:
1083
1762
the callback function is called the Avahi server will free the
1084
1763
resolver for us. */
1085
1764
1086
if(avahi_s_service_resolver_new(mc.server, interface, protocol,
1087
name, type, domain, protocol, 0,
1088
resolve_callback, NULL) == NULL)
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)
1089
1769
fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
1090
1770
" %s\n", name,
1091
avahi_strerror(avahi_server_errno(mc.server)));
1771
avahi_strerror(avahi_server_errno
1772
(((mandos_context*)mc)->server)));
1092
1773
break;
1093
1774
1094
1775
case AVAHI_BROWSER_REMOVE:
1113
1794
signal_received = sig;
1114
1795
int old_errno = errno;
1115
1796
/* set main loop to exit */
1116
if(mc.simple_poll != NULL){
1117
avahi_simple_poll_quit(mc.simple_poll);
1797
if(simple_poll != NULL){
1798
avahi_simple_poll_quit(simple_poll);
1118
1799
}
1119
1800
errno = old_errno;
1120
1801
}
1121
1802
1803
__attribute__((nonnull, warn_unused_result))
1122
1804
bool get_flags(const char *ifname, struct ifreq *ifr){
1123
1805
int ret;
1806
int old_errno;
1124
1807
1125
1808
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1126
1809
if(s < 0){
1810
old_errno = errno;
1127
1811
perror_plus("socket");
1812
errno = old_errno;
1128
1813
return false;
1129
1814
}
1130
strcpy(ifr->ifr_name, ifname);
1815
strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
1816
ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
1131
1817
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1132
1818
if(ret == -1){
1133
1819
if(debug){
1820
old_errno = errno;
1134
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;
1135
1828
}
1136
1829
return false;
1137
1830
}
1831
if((close(s) == -1) and debug){
1832
old_errno = errno;
1833
perror_plus("close");
1834
errno = old_errno;
1835
}
1138
1836
return true;
1139
1837
}
1140
1838
1839
__attribute__((nonnull, warn_unused_result))
1141
1840
bool good_flags(const char *ifname, const struct ifreq *ifr){
1142
1841
1143
1842
/* Reject the loopback device */
1185
1884
* corresponds to an acceptable network device.
1186
1885
* (This function is passed to scandir(3) as a filter function.)
1187
1886
*/
1887
__attribute__((nonnull, warn_unused_result))
1188
1888
int good_interface(const struct dirent *if_entry){
1189
1889
if(if_entry->d_name[0] == '.'){
1190
1890
return 0;
1206
1906
}
1207
1907
1208
1908
/*
1209
* This function determines if a directory entry in /sys/class/net
1210
* corresponds to an acceptable network device which is up.
1211
* (This function is passed to scandir(3) as a filter function.)
1212
*/
1213
int up_interface(const struct dirent *if_entry){
1214
if(if_entry->d_name[0] == '.'){
1215
return 0;
1216
}
1217
1218
struct ifreq ifr;
1219
if(not get_flags(if_entry->d_name, &ifr)){
1220
if(debug){
1221
fprintf_plus(stderr, "Failed to get flags for interface "
1222
"\"%s\"\n", if_entry->d_name);
1223
}
1224
return 0;
1225
}
1226
1227
/* Reject down interfaces */
1228
if(not (ifr.ifr_flags & IFF_UP)){
1229
if(debug){
1230
fprintf_plus(stderr, "Rejecting down interface \"%s\"\n",
1231
if_entry->d_name);
1232
}
1233
return 0;
1234
}
1235
1236
/* Reject non-running interfaces */
1237
if(not (ifr.ifr_flags & IFF_RUNNING)){
1238
if(debug){
1239
fprintf_plus(stderr, "Rejecting non-running interface \"%s\"\n",
1240
if_entry->d_name);
1241
}
1242
return 0;
1243
}
1244
1245
if(not good_flags(if_entry->d_name, &ifr)){
1246
return 0;
1247
}
1248
return 1;
1249
}
1250
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))
1251
1943
int notdotentries(const struct dirent *direntry){
1252
1944
/* Skip "." and ".." */
1253
1945
if(direntry->d_name[0] == '.'
1260
1952
}
1261
1953
1262
1954
/* Is this directory entry a runnable program? */
1955
__attribute__((nonnull, warn_unused_result))
1263
1956
int runnable_hook(const struct dirent *direntry){
1264
1957
int ret;
1265
1958
size_t sret;
1273
1966
sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1274
1967
"abcdefghijklmnopqrstuvwxyz"
1275
1968
"0123456789"
1276
"_-");
1969
"_.-");
1277
1970
if((direntry->d_name)[sret] != '\0'){
1278
1971
/* Contains non-allowed characters */
1279
1972
if(debug){
1283
1976
return 0;
1284
1977
}
1285
1978
1286
char *fullname = NULL;
1287
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1288
if(ret < 0){
1289
perror_plus("asprintf");
1290
return 0;
1291
}
1292
1293
ret = stat(fullname, &st);
1979
ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1294
1980
if(ret == -1){
1295
1981
if(debug){
1296
1982
perror_plus("Could not stat hook");
1320
2006
return 1;
1321
2007
}
1322
2008
1323
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval){
2009
__attribute__((nonnull, warn_unused_result))
2010
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
2011
mandos_context *mc){
1324
2012
int ret;
1325
2013
struct timespec now;
1326
2014
struct timespec waited_time;
1327
2015
intmax_t block_time;
1328
2016
1329
2017
while(true){
1330
if(mc.current_server == NULL){
1331
if (debug){
2018
if(mc->current_server == NULL){
2019
if(debug){
1332
2020
fprintf_plus(stderr, "Wait until first server is found."
1333
2021
" No timeout!\n");
1334
2022
}
1335
2023
ret = avahi_simple_poll_iterate(s, -1);
1336
2024
} else {
1337
if (debug){
2025
if(debug){
1338
2026
fprintf_plus(stderr, "Check current_server if we should run"
1339
2027
" it, or wait\n");
1340
2028
}
1347
2035
/* Calculating in ms how long time between now and server
1348
2036
who we visted longest time ago. Now - last seen. */
1349
2037
waited_time.tv_sec = (now.tv_sec
1350
- mc.current_server->last_seen.tv_sec);
2038
- mc->current_server->last_seen.tv_sec);
1351
2039
waited_time.tv_nsec = (now.tv_nsec
1352
- mc.current_server->last_seen.tv_nsec);
2040
- mc->current_server->last_seen.tv_nsec);
1353
2041
/* total time is 10s/10,000ms.
1354
2042
Converting to s from ms by dividing by 1,000,
1355
2043
and ns to ms by dividing by 1,000,000. */
1357
2045
- ((intmax_t)waited_time.tv_sec * 1000))
1358
2046
- ((intmax_t)waited_time.tv_nsec / 1000000));
1359
2047
1360
if (debug){
2048
if(debug){
1361
2049
fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1362
2050
block_time);
1363
2051
}
1364
2052
1365
2053
if(block_time <= 0){
1366
ret = start_mandos_communication(mc.current_server->ip,
1367
mc.current_server->port,
1368
mc.current_server->if_index,
1369
mc.current_server->af);
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);
1370
2058
if(ret == 0){
1371
avahi_simple_poll_quit(mc.simple_poll);
2059
avahi_simple_poll_quit(s);
1372
2060
return 0;
1373
2061
}
1374
2062
ret = clock_gettime(CLOCK_MONOTONIC,
1375
&mc.current_server->last_seen);
2063
&mc->current_server->last_seen);
1376
2064
if(ret == -1){
1377
2065
perror_plus("clock_gettime");
1378
2066
return -1;
1379
2067
}
1380
mc.current_server = mc.current_server->next;
2068
mc->current_server = mc->current_server->next;
1381
2069
block_time = 0; /* Call avahi to find new Mandos
1382
2070
servers, but don't block */
1383
2071
}
1385
2073
ret = avahi_simple_poll_iterate(s, (int)block_time);
1386
2074
}
1387
2075
if(ret != 0){
1388
if (ret > 0 or errno != EINTR){
2076
if(ret > 0 or errno != EINTR){
1389
2077
return (ret != 1) ? ret : 0;
1390
2078
}
1391
2079
}
1392
2080
}
1393
2081
}
1394
2082
1395
/* Set effective uid to 0, return errno */
1396
int raise_privileges(void){
1397
int old_errno = errno;
1398
int ret_errno = 0;
1399
errno = 0;
1400
if(seteuid(0) == -1){
1401
perror_plus("seteuid");
1402
}
1403
ret_errno = errno;
1404
errno = old_errno;
1405
return ret_errno;
1406
}
1407
1408
/* Set effective and real user ID to 0. Return errno. */
1409
int raise_privileges_permanently(void){
1410
int old_errno = errno;
1411
int ret_errno = raise_privileges();
1412
if(ret_errno != 0){
1413
errno = old_errno;
1414
return ret_errno;
1415
}
1416
errno = 0;
1417
if(setuid(0) == -1){
1418
perror_plus("seteuid");
1419
}
1420
ret_errno = errno;
1421
errno = old_errno;
1422
return ret_errno;
1423
}
1424
1425
/* Set effective user ID to unprivileged saved user ID */
1426
int lower_privileges(void){
1427
int old_errno = errno;
1428
int ret_errno = 0;
1429
errno = 0;
1430
if(seteuid(uid) == -1){
1431
perror_plus("seteuid");
1432
}
1433
ret_errno = errno;
1434
errno = old_errno;
1435
return ret_errno;
1436
}
1437
1438
bool run_network_hooks(const char *mode, const char *interface,
2083
__attribute__((nonnull))
2084
void run_network_hooks(const char *mode, const char *interface,
1439
2085
const float delay){
1440
struct dirent **direntries;
1441
struct dirent *direntry;
1442
int ret;
1443
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1444
alphasort);
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);
1445
2109
if(numhooks == -1){
1446
2110
perror_plus("scandir");
1447
} else {
1448
int devnull = open("/dev/null", O_RDONLY);
1449
for(int i = 0; i < numhooks; i++){
1450
direntry = direntries[i];
1451
char *fullname = NULL;
1452
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1453
if(ret < 0){
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){
1454
2168
perror_plus("asprintf");
1455
continue;
1456
}
1457
if(debug){
1458
fprintf_plus(stderr, "Running network hook \"%s\"\n",
1459
direntry->d_name);
1460
}
1461
pid_t hook_pid = fork();
1462
if(hook_pid == 0){
1463
/* Child */
1464
/* Raise privileges */
1465
raise_privileges_permanently();
1466
/* Set group */
1467
errno = 0;
1468
ret = setgid(0);
1469
if(ret == -1){
1470
perror_plus("setgid");
1471
}
1472
/* Reset supplementary groups */
1473
errno = 0;
1474
ret = setgroups(0, NULL);
1475
if(ret == -1){
1476
perror_plus("setgroups");
1477
}
1478
dup2(devnull, STDIN_FILENO);
1479
close(devnull);
1480
dup2(STDERR_FILENO, STDOUT_FILENO);
1481
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1482
if(ret == -1){
1483
perror_plus("setenv");
1484
_exit(EX_OSERR);
1485
}
1486
ret = setenv("DEVICE", interface, 1);
1487
if(ret == -1){
1488
perror_plus("setenv");
1489
_exit(EX_OSERR);
1490
}
1491
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
1492
if(ret == -1){
1493
perror_plus("setenv");
1494
_exit(EX_OSERR);
1495
}
1496
ret = setenv("MODE", mode, 1);
1497
if(ret == -1){
1498
perror_plus("setenv");
1499
_exit(EX_OSERR);
1500
}
1501
char *delaystring;
1502
ret = asprintf(&delaystring, "%f", delay);
1503
if(ret == -1){
1504
perror_plus("asprintf");
1505
_exit(EX_OSERR);
1506
}
1507
ret = setenv("DELAY", delaystring, 1);
1508
if(ret == -1){
1509
free(delaystring);
1510
perror_plus("setenv");
1511
_exit(EX_OSERR);
1512
}
2169
_exit(EX_OSERR);
2170
}
2171
ret = setenv("DELAY", delaystring, 1);
2172
if(ret == -1){
1513
2173
free(delaystring);
1514
if(connect_to != NULL){
1515
ret = setenv("CONNECT", connect_to, 1);
1516
if(ret == -1){
1517
perror_plus("setenv");
1518
_exit(EX_OSERR);
1519
}
1520
}
1521
if(execl(fullname, direntry->d_name, mode, NULL) == -1){
1522
perror_plus("execl");
1523
_exit(EXIT_FAILURE);
1524
}
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;
1525
2242
} else {
1526
int status;
1527
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1528
perror_plus("waitpid");
1529
free(fullname);
1530
continue;
1531
}
1532
if(WIFEXITED(status)){
1533
if(WEXITSTATUS(status) != 0){
1534
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1535
" with status %d\n", direntry->d_name,
1536
WEXITSTATUS(status));
1537
free(fullname);
1538
continue;
1539
}
1540
} else if(WIFSIGNALED(status)){
1541
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1542
" signal %d\n", direntry->d_name,
1543
WTERMSIG(status));
1544
free(fullname);
1545
continue;
1546
} else {
1547
fprintf_plus(stderr, "Warning: network hook \"%s\""
1548
" crashed\n", direntry->d_name);
1549
free(fullname);
1550
continue;
1551
}
1552
}
1553
free(fullname);
1554
if(debug){
1555
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1556
direntry->d_name);
1557
}
1558
}
1559
close(devnull);
1560
}
1561
return true;
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);
1562
2262
}
1563
2263
1564
int bring_up_interface(const char * const interface, const float delay){
1565
int sd = -1;
2264
__attribute__((nonnull, warn_unused_result))
2265
int bring_up_interface(const char *const interface,
2266
const float delay){
2267
int old_errno = errno;
1566
2268
int ret;
1567
2269
struct ifreq network;
1568
AvahiIfIndex if_index = (AvahiIfIndex)if_nametoindex(interface);
2270
unsigned int if_index = if_nametoindex(interface);
1569
2271
if(if_index == 0){
1570
2272
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1571
return EX_UNAVAILABLE;
2273
errno = old_errno;
2274
return ENXIO;
1572
2275
}
1573
2276
1574
2277
if(quit_now){
2278
errno = old_errno;
1575
2279
return EINTR;
1576
2280
}
1577
2281
1578
/* Re-raise priviliges */
1579
raise_privileges();
1580
1581
#ifdef __linux__
1582
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1583
messages about the network interface to mess up the prompt */
1584
ret = klogctl(8, NULL, 5);
1585
bool restore_loglevel = true;
1586
if(ret == -1){
1587
restore_loglevel = false;
1588
perror_plus("klogctl");
1589
}
1590
#endif /* __linux__ */
1591
1592
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1593
if(sd < 0){
1594
perror_plus("socket");
1595
#ifdef __linux__
1596
if(restore_loglevel){
1597
ret = klogctl(7, NULL, 0);
1598
if(ret == -1){
1599
perror_plus("klogctl");
1600
}
1601
}
1602
#endif /* __linux__ */
1603
/* Lower privileges */
1604
lower_privileges();
1605
return EX_OSERR;
1606
;
1607
}
1608
strcpy(network.ifr_name, interface);
1609
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1610
if(ret == -1){
1611
perror_plus("ioctl SIOCGIFFLAGS");
1612
#ifdef __linux__
1613
if(restore_loglevel){
1614
ret = klogctl(7, NULL, 0);
1615
if(ret == -1){
1616
perror_plus("klogctl");
1617
}
1618
}
1619
#endif /* __linux__ */
1620
/* Lower privileges */
1621
lower_privileges();
1622
return EX_OSERR;
1623
}
1624
if((network.ifr_flags & IFF_UP) == 0){
1625
network.ifr_flags |= IFF_UP;
1626
ret = ioctl(sd, SIOCSIFFLAGS, &network);
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);
1627
2360
if(ret == -1){
2361
perror_plus("close");
2362
}
2363
2364
if(ret_setflags == -1){
2365
errno = ioctl_errno;
1628
2366
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1629
#ifdef __linux__
1630
if(restore_loglevel){
1631
ret = klogctl(7, NULL, 0);
1632
if(ret == -1){
1633
perror_plus("klogctl");
1634
}
1635
}
1636
#endif /* __linux__ */
1637
/* Lower privileges */
1638
lower_privileges();
1639
return EX_OSERR;
2367
errno = old_errno;
2368
return ioctl_errno;
1640
2369
}
2370
} else if(debug){
2371
fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
2372
interface);
1641
2373
}
2374
1642
2375
/* Sleep checking until interface is running.
1643
2376
Check every 0.25s, up to total time of delay */
1644
for(int i=0; i < delay * 4; i++){
1645
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1646
if(ret == -1){
1647
perror_plus("ioctl SIOCGIFFLAGS");
1648
} else if(network.ifr_flags & IFF_RUNNING){
2377
for(int i = 0; i < delay * 4; i++){
2378
if(interface_is_running(interface)){
1649
2379
break;
1650
2380
}
1651
2381
struct timespec sleeptime = { .tv_nsec = 250000000 };
1654
2384
perror_plus("nanosleep");
1655
2385
}
1656
2386
}
1657
/* Close the socket */
1658
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1659
if(ret == -1){
1660
perror_plus("close");
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;
1661
2401
}
1662
#ifdef __linux__
1663
if(restore_loglevel){
1664
/* Restores kernel loglevel to default */
1665
ret = klogctl(7, NULL, 0);
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);
1666
2449
if(ret == -1){
1667
perror_plus("klogctl");
1668
}
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);
1669
2462
}
1670
#endif /* __linux__ */
1671
/* Lower privileges */
1672
lower_privileges();
1673
return errno;
2463
2464
errno = old_errno;
2465
return 0;
1674
2466
}
1675
2467
1676
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 };
1677
2482
AvahiSServiceBrowser *sb = NULL;
1678
int error;
2483
error_t ret_errno;
1679
2484
int ret;
1680
2485
intmax_t tmpmax;
1681
2486
char *tmp;
1682
2487
int exitcode = EXIT_SUCCESS;
1683
const char *interface = "";
1684
struct ifreq network;
1685
int sd = -1;
1686
bool take_down_interface = false;
1687
char tempdir[] = "/tmp/mandosXXXXXX";
1688
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;
1689
2493
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1690
2494
const char *seckey = PATHDIR "/" SECKEY;
1691
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;
1692
2502
1693
2503
bool gnutls_initialized = false;
1694
2504
bool gpgme_initialized = false;
1740
2550
{ .name = "pubkey", .key = 'p',
1741
2551
.arg = "FILE",
1742
2552
.doc = "OpenPGP public key file base name",
1743
.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 },
1744
2570
{ .name = "dh-bits", .key = 129,
1745
2571
.arg = "BITS",
1746
2572
.doc = "Bit length of the prime number used in the"
1747
2573
" Diffie-Hellman key exchange",
1748
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 },
1749
2580
{ .name = "priority", .key = 130,
1750
2581
.arg = "STRING",
1751
2582
.doc = "GnuTLS priority string for the TLS handshake",
1785
2616
connect_to = arg;
1786
2617
break;
1787
2618
case 'i': /* --interface */
1788
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
}
1789
2624
break;
1790
2625
case 's': /* --seckey */
1791
2626
seckey = arg;
1793
2628
case 'p': /* --pubkey */
1794
2629
pubkey = arg;
1795
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;
1796
2641
case 129: /* --dh-bits */
1797
2642
errno = 0;
1798
2643
tmpmax = strtoimax(arg, &tmp, 10);
1802
2647
}
1803
2648
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
1804
2649
break;
2650
case 134: /* --dh-params */
2651
dh_params_file = arg;
2652
break;
1805
2653
case 130: /* --priority */
1806
2654
mc.priority = arg;
1807
2655
break;
1830
2678
argp_state_help(state, state->out_stream,
1831
2679
(ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
1832
2680
& ~(unsigned int)ARGP_HELP_EXIT_OK);
2681
__builtin_unreachable();
1833
2682
case -3: /* --usage */
1834
2683
argp_state_help(state, state->out_stream,
1835
2684
ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
2685
__builtin_unreachable();
1836
2686
case 'V': /* --version */
1837
2687
fprintf_plus(state->out_stream, "%s\n", argp_program_version);
1838
2688
exit(argp_err_exit_status);
1847
2697
.args_doc = "",
1848
2698
.doc = "Mandos client -- Get and decrypt"
1849
2699
" passwords from a Mandos server" };
1850
ret = argp_parse(&argp, argc, argv,
1851
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
1852
switch(ret){
2700
ret_errno = argp_parse(&argp, argc, argv,
2701
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2702
switch(ret_errno){
1853
2703
case 0:
1854
2704
break;
1855
2705
case ENOMEM:
1856
2706
default:
1857
errno = ret;
2707
errno = ret_errno;
1858
2708
perror_plus("argp_parse");
1859
2709
exitcode = EX_OSERR;
1860
2710
goto end;
1863
2713
goto end;
1864
2714
}
1865
2715
}
1866
2716
1867
2717
{
1868
2718
/* Work around Debian bug #633582:
1869
<http://bugs.debian.org/633582> */
2719
<https://bugs.debian.org/633582> */
1870
2720
1871
/* Re-raise priviliges */
1872
if(raise_privileges() == 0){
2721
/* Re-raise privileges */
2722
ret = raise_privileges();
2723
if(ret != 0){
2724
errno = ret;
2725
perror_plus("Failed to raise privileges");
2726
} else {
1873
2727
struct stat st;
1874
2728
1875
2729
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
1889
2743
}
1890
2744
}
1891
2745
}
1892
TEMP_FAILURE_RETRY(close(seckey_fd));
2746
close(seckey_fd);
1893
2747
}
1894
2748
}
1895
2749
1896
2750
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
1897
2751
int pubkey_fd = open(pubkey, O_RDONLY);
1898
2752
if(pubkey_fd == -1){
1910
2764
}
1911
2765
}
1912
2766
}
1913
TEMP_FAILURE_RETRY(close(pubkey_fd));
1914
}
1915
}
1916
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
1917
2793
/* Lower privileges */
1918
errno = 0;
1919
ret = seteuid(uid);
1920
if(ret == -1){
1921
perror_plus("seteuid");
2794
ret = lower_privileges();
2795
if(ret != 0){
2796
errno = ret;
2797
perror_plus("Failed to lower privileges");
2798
}
2799
}
2800
}
2801
2802
/* Remove invalid interface names (except "none") */
2803
{
2804
char *interface = NULL;
2805
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2806
interface))){
2807
if(strcmp(interface, "none") != 0
2808
and if_nametoindex(interface) == 0){
2809
if(interface[0] != '\0'){
2810
fprintf_plus(stderr, "Not using nonexisting interface"
2811
" \"%s\"\n", interface);
2812
}
2813
argz_delete(&mc.interfaces, &mc.interfaces_size, interface);
2814
interface = NULL;
1922
2815
}
1923
2816
}
1924
2817
}
1925
2818
1926
2819
/* Run network hooks */
1927
if(not run_network_hooks("start", interface, delay)){
1928
goto end;
2820
{
2821
if(mc.interfaces != NULL){
2822
interfaces_hooks = malloc(mc.interfaces_size);
2823
if(interfaces_hooks == NULL){
2824
perror_plus("malloc");
2825
goto end;
2826
}
2827
memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
2828
argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
2829
}
2830
run_network_hooks("start", interfaces_hooks != NULL ?
2831
interfaces_hooks : "", delay);
1929
2832
}
1930
2833
1931
2834
if(not debug){
1932
2835
avahi_set_log_function(empty_log);
1933
2836
}
1934
2837
1935
if(interface[0] == '\0'){
1936
struct dirent **direntries;
1937
/* First look for interfaces that are up */
1938
ret = scandir(sys_class_net, &direntries, up_interface,
1939
alphasort);
1940
if(ret == 0){
1941
/* No up interfaces, look for any good interfaces */
1942
free(direntries);
1943
ret = scandir(sys_class_net, &direntries, good_interface,
1944
alphasort);
1945
}
1946
if(ret >= 1){
1947
/* Pick the first interface returned */
1948
interface = strdup(direntries[0]->d_name);
1949
if(debug){
1950
fprintf_plus(stderr, "Using interface \"%s\"\n", interface);
1951
}
1952
if(interface == NULL){
1953
perror_plus("malloc");
1954
free(direntries);
1955
exitcode = EXIT_FAILURE;
1956
goto end;
1957
}
1958
free(direntries);
1959
} else {
1960
free(direntries);
1961
fprintf_plus(stderr, "Could not find a network interface\n");
1962
exitcode = EXIT_FAILURE;
1963
goto end;
1964
}
1965
}
1966
1967
2838
/* Initialize Avahi early so avahi_simple_poll_quit() can be called
1968
2839
from the signal handler */
1969
2840
/* Initialize the pseudo-RNG for Avahi */
1970
2841
srand((unsigned int) time(NULL));
1971
mc.simple_poll = avahi_simple_poll_new();
1972
if(mc.simple_poll == NULL){
2842
simple_poll = avahi_simple_poll_new();
2843
if(simple_poll == NULL){
1973
2844
fprintf_plus(stderr,
1974
2845
"Avahi: Failed to create simple poll object.\n");
1975
2846
exitcode = EX_UNAVAILABLE;
2039
2910
}
2040
2911
}
2041
2912
2042
/* If the interface is down, bring it up */
2043
if((interface[0] != '\0') and (strcmp(interface, "none") != 0)){
2044
ret = bring_up_interface(interface, delay);
2045
if(ret){
2046
errno = ret;
2047
perror_plus("Failed to bring up interface");
2048
}
2913
/* If no interfaces were specified, make a list */
2914
if(mc.interfaces == NULL){
2915
struct dirent **direntries = NULL;
2916
/* Look for any good interfaces */
2917
ret = scandir(sys_class_net, &direntries, good_interface,
2918
alphasort);
2919
if(ret >= 1){
2920
/* Add all found interfaces to interfaces list */
2921
for(int i = 0; i < ret; ++i){
2922
ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
2923
direntries[i]->d_name);
2924
if(ret_errno != 0){
2925
errno = ret_errno;
2926
perror_plus("argz_add");
2927
free(direntries[i]);
2928
continue;
2929
}
2930
if(debug){
2931
fprintf_plus(stderr, "Will use interface \"%s\"\n",
2932
direntries[i]->d_name);
2933
}
2934
free(direntries[i]);
2935
}
2936
free(direntries);
2937
} else {
2938
if(ret == 0){
2939
free(direntries);
2940
}
2941
fprintf_plus(stderr, "Could not find a network interface\n");
2942
exitcode = EXIT_FAILURE;
2943
goto end;
2944
}
2945
}
2946
2947
/* Bring up interfaces which are down, and remove any "none"s */
2948
{
2949
char *interface = NULL;
2950
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2951
interface))){
2952
/* If interface name is "none", stop bringing up interfaces.
2953
Also remove all instances of "none" from the list */
2954
if(strcmp(interface, "none") == 0){
2955
argz_delete(&mc.interfaces, &mc.interfaces_size,
2956
interface);
2957
interface = NULL;
2958
while((interface = argz_next(mc.interfaces,
2959
mc.interfaces_size, interface))){
2960
if(strcmp(interface, "none") == 0){
2961
argz_delete(&mc.interfaces, &mc.interfaces_size,
2962
interface);
2963
interface = NULL;
2964
}
2965
}
2966
break;
2967
}
2968
bool interface_was_up = interface_is_up(interface);
2969
errno = bring_up_interface(interface, delay);
2970
if(not interface_was_up){
2971
if(errno != 0){
2972
fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
2973
" %s\n", interface, strerror(errno));
2974
} else {
2975
errno = argz_add(&interfaces_to_take_down,
2976
&interfaces_to_take_down_size,
2977
interface);
2978
if(errno != 0){
2979
perror_plus("argz_add");
2980
}
2981
}
2982
}
2983
}
2984
if(debug and (interfaces_to_take_down == NULL)){
2985
fprintf_plus(stderr, "No interfaces were brought up\n");
2986
}
2987
}
2988
2989
/* If we only got one interface, explicitly use only that one */
2990
if(argz_count(mc.interfaces, mc.interfaces_size) == 1){
2991
if(debug){
2992
fprintf_plus(stderr, "Using only interface \"%s\"\n",
2993
mc.interfaces);
2994
}
2995
if_index = (AvahiIfIndex)if_nametoindex(mc.interfaces);
2049
2996
}
2050
2997
2051
2998
if(quit_now){
2052
2999
goto end;
2053
3000
}
2054
3001
2055
ret = init_gnutls_global(pubkey, seckey);
3002
#if GNUTLS_VERSION_NUMBER >= 0x030606
3003
ret = init_gnutls_global(tls_pubkey, tls_privkey, dh_params_file, &mc);
3004
#elif GNUTLS_VERSION_NUMBER < 0x030600
3005
ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
3006
#else
3007
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
3008
#endif
2056
3009
if(ret == -1){
2057
3010
fprintf_plus(stderr, "init_gnutls_global failed\n");
2058
3011
exitcode = EX_UNAVAILABLE;
2065
3018
goto end;
2066
3019
}
2067
3020
2068
if(mkdtemp(tempdir) == NULL){
3021
/* Try /run/tmp before /tmp */
3022
tempdir = mkdtemp(run_tempdir);
3023
if(tempdir == NULL and errno == ENOENT){
3024
if(debug){
3025
fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
3026
run_tempdir, old_tempdir);
3027
}
3028
tempdir = mkdtemp(old_tempdir);
3029
}
3030
if(tempdir == NULL){
2069
3031
perror_plus("mkdtemp");
2070
3032
goto end;
2071
3033
}
2072
tempdir_created = true;
2073
3034
2074
3035
if(quit_now){
2075
3036
goto end;
2076
3037
}
2077
3038
2078
if(not init_gpgme(pubkey, seckey, tempdir)){
3039
if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
2079
3040
fprintf_plus(stderr, "init_gpgme failed\n");
2080
3041
exitcode = EX_UNAVAILABLE;
2081
3042
goto end;
2102
3063
goto end;
2103
3064
}
2104
3065
2105
uint16_t port;
3066
in_port_t port;
2106
3067
errno = 0;
2107
3068
tmpmax = strtoimax(address+1, &tmp, 10);
2108
3069
if(errno != 0 or tmp == address+1 or *tmp != '\0'
2109
or tmpmax != (uint16_t)tmpmax){
3070
or tmpmax != (in_port_t)tmpmax){
2110
3071
fprintf_plus(stderr, "Bad port number\n");
2111
3072
exitcode = EX_USAGE;
2112
3073
goto end;
2113
3074
}
2114
3075
2115
3076
if(quit_now){
2116
3077
goto end;
2117
3078
}
2118
3079
2119
port = (uint16_t)tmpmax;
3080
port = (in_port_t)tmpmax;
2120
3081
*address = '\0';
2121
3082
/* Colon in address indicates IPv6 */
2122
3083
int af;
2138
3099
}
2139
3100
2140
3101
while(not quit_now){
2141
ret = start_mandos_communication(address, port, if_index, af);
3102
ret = start_mandos_communication(address, port, if_index, af,
3103
&mc);
2142
3104
if(quit_now or ret == 0){
2143
3105
break;
2144
3106
}
2146
3108
fprintf_plus(stderr, "Retrying in %d seconds\n",
2147
3109
(int)retry_interval);
2148
3110
}
2149
sleep((int)retry_interval);
3111
sleep((unsigned int)retry_interval);
2150
3112
}
2151
3113
2152
if (not quit_now){
3114
if(not quit_now){
2153
3115
exitcode = EXIT_SUCCESS;
2154
3116
}
2155
3117
2170
3132
config.publish_domain = 0;
2171
3133
2172
3134
/* Allocate a new server */
2173
mc.server = avahi_server_new(avahi_simple_poll_get
2174
(mc.simple_poll), &config, NULL,
2175
NULL, &error);
3135
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
3136
&config, NULL, NULL, &ret);
2176
3137
2177
3138
/* Free the Avahi configuration data */
2178
3139
avahi_server_config_free(&config);
2181
3142
/* Check if creating the Avahi server object succeeded */
2182
3143
if(mc.server == NULL){
2183
3144
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2184
avahi_strerror(error));
3145
avahi_strerror(ret));
2185
3146
exitcode = EX_UNAVAILABLE;
2186
3147
goto end;
2187
3148
}
2193
3154
/* Create the Avahi service browser */
2194
3155
sb = avahi_s_service_browser_new(mc.server, if_index,
2195
3156
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
2196
NULL, 0, browse_callback, NULL);
3157
NULL, 0, browse_callback,
3158
(void *)&mc);
2197
3159
if(sb == NULL){
2198
3160
fprintf_plus(stderr, "Failed to create service browser: %s\n",
2199
3161
avahi_strerror(avahi_server_errno(mc.server)));
2210
3172
if(debug){
2211
3173
fprintf_plus(stderr, "Starting Avahi loop search\n");
2212
3174
}
2213
2214
ret = avahi_loop_with_timeout(mc.simple_poll,
2215
(int)(retry_interval * 1000));
3175
3176
ret = avahi_loop_with_timeout(simple_poll,
3177
(int)(retry_interval * 1000), &mc);
2216
3178
if(debug){
2217
3179
fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
2218
3180
(ret == 0) ? "successfully" : "with error");
2221
3183
end:
2222
3184
2223
3185
if(debug){
2224
fprintf_plus(stderr, "%s exiting\n", argv[0]);
3186
if(signal_received){
3187
fprintf_plus(stderr, "%s exiting due to signal %d: %s\n",
3188
argv[0], signal_received,
3189
strsignal(signal_received));
3190
} else {
3191
fprintf_plus(stderr, "%s exiting\n", argv[0]);
3192
}
2225
3193
}
2226
3194
2227
3195
/* Cleanup things */
3196
free(mc.interfaces);
3197
2228
3198
if(sb != NULL)
2229
3199
avahi_s_service_browser_free(sb);
2230
3200
2231
3201
if(mc.server != NULL)
2232
3202
avahi_server_free(mc.server);
2233
3203
2234
if(mc.simple_poll != NULL)
2235
avahi_simple_poll_free(mc.simple_poll);
3204
if(simple_poll != NULL)
3205
avahi_simple_poll_free(simple_poll);
2236
3206
2237
3207
if(gnutls_initialized){
2238
3208
gnutls_certificate_free_credentials(mc.cred);
2239
gnutls_global_deinit();
2240
3209
gnutls_dh_params_deinit(mc.dh_params);
2241
3210
}
2242
3211
2250
3219
mc.current_server->prev->next = NULL;
2251
3220
while(mc.current_server != NULL){
2252
3221
server *next = mc.current_server->next;
3222
#ifdef __GNUC__
3223
#pragma GCC diagnostic push
3224
#pragma GCC diagnostic ignored "-Wcast-qual"
3225
#endif
3226
free((char *)(mc.current_server->ip));
3227
#ifdef __GNUC__
3228
#pragma GCC diagnostic pop
3229
#endif
2253
3230
free(mc.current_server);
2254
3231
mc.current_server = next;
2255
3232
}
2256
3233
}
2257
3234
2258
/* Run network hooks */
2259
run_network_hooks("stop", interface, delay);
2260
2261
/* Re-raise priviliges */
3235
/* Re-raise privileges */
2262
3236
{
2263
raise_privileges();
3237
ret = raise_privileges();
3238
if(ret != 0){
3239
errno = ret;
3240
perror_plus("Failed to raise privileges");
3241
} else {
3242
3243
/* Run network hooks */
3244
run_network_hooks("stop", interfaces_hooks != NULL ?
3245
interfaces_hooks : "", delay);
3246
3247
/* Take down the network interfaces which were brought up */
3248
{
3249
char *interface = NULL;
3250
while((interface = argz_next(interfaces_to_take_down,
3251
interfaces_to_take_down_size,
3252
interface))){
3253
ret = take_down_interface(interface);
3254
if(ret != 0){
3255
errno = ret;
3256
perror_plus("Failed to take down interface");
3257
}
3258
}
3259
if(debug and (interfaces_to_take_down == NULL)){
3260
fprintf_plus(stderr, "No interfaces needed to be taken"
3261
" down\n");
3262
}
3263
}
3264
}
2264
3265
2265
/* Take down the network interface */
2266
if(take_down_interface and geteuid() == 0){
2267
ret = ioctl(sd, SIOCGIFFLAGS, &network);
2268
if(ret == -1){
2269
perror_plus("ioctl SIOCGIFFLAGS");
2270
} else if(network.ifr_flags & IFF_UP){
2271
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
2272
ret = ioctl(sd, SIOCSIFFLAGS, &network);
2273
if(ret == -1){
2274
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
2275
}
2276
}
2277
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2278
if(ret == -1){
2279
perror_plus("close");
2280
}
3266
ret = lower_privileges_permanently();
3267
if(ret != 0){
3268
errno = ret;
3269
perror_plus("Failed to lower privileges permanently");
2281
3270
}
2282
3271
}
2283
/* Lower privileges permanently */
2284
errno = 0;
2285
ret = setuid(uid);
2286
if(ret == -1){
2287
perror_plus("setuid");
3272
3273
free(interfaces_to_take_down);
3274
free(interfaces_hooks);
3275
3276
void clean_dir_at(int base, const char * const dirname,
3277
uintmax_t level){
3278
struct dirent **direntries = NULL;
3279
int dret;
3280
int dir_fd = (int)TEMP_FAILURE_RETRY(openat(base, dirname,
3281
O_RDONLY
3282
| O_NOFOLLOW
3283
| O_DIRECTORY
3284
| O_PATH));
3285
if(dir_fd == -1){
3286
perror_plus("open");
3287
return;
3288
}
3289
int numentries = scandirat(dir_fd, ".", &direntries,
3290
notdotentries, alphasort);
3291
if(numentries >= 0){
3292
for(int i = 0; i < numentries; i++){
3293
if(debug){
3294
fprintf_plus(stderr, "Unlinking \"%s/%s\"\n",
3295
dirname, direntries[i]->d_name);
3296
}
3297
dret = unlinkat(dir_fd, direntries[i]->d_name, 0);
3298
if(dret == -1){
3299
if(errno == EISDIR){
3300
dret = unlinkat(dir_fd, direntries[i]->d_name,
3301
AT_REMOVEDIR);
3302
}
3303
if((dret == -1) and (errno == ENOTEMPTY)
3304
and (strcmp(direntries[i]->d_name, "private-keys-v1.d")
3305
== 0) and (level == 0)){
3306
/* Recurse only in this special case */
3307
clean_dir_at(dir_fd, direntries[i]->d_name, level+1);
3308
dret = 0;
3309
}
3310
if((dret == -1) and (errno != ENOENT)){
3311
fprintf_plus(stderr, "unlink(\"%s/%s\"): %s\n", dirname,
3312
direntries[i]->d_name, strerror(errno));
3313
}
3314
}
3315
free(direntries[i]);
3316
}
3317
3318
/* need to clean even if 0 because man page doesn't specify */
3319
free(direntries);
3320
dret = unlinkat(base, dirname, AT_REMOVEDIR);
3321
if(dret == -1 and errno != ENOENT){
3322
perror_plus("rmdir");
3323
}
3324
} else {
3325
perror_plus("scandirat");
3326
}
3327
close(dir_fd);
2288
3328
}
2289
3329
2290
3330
/* Removes the GPGME temp directory and all files inside */
2291
if(tempdir_created){
2292
struct dirent **direntries = NULL;
2293
struct dirent *direntry = NULL;
2294
int numentries = scandir(tempdir, &direntries, notdotentries,
2295
alphasort);
2296
if (numentries > 0){
2297
for(int i = 0; i < numentries; i++){
2298
direntry = direntries[i];
2299
char *fullname = NULL;
2300
ret = asprintf(&fullname, "%s/%s", tempdir,
2301
direntry->d_name);
2302
if(ret < 0){
2303
perror_plus("asprintf");
2304
continue;
2305
}
2306
ret = remove(fullname);
2307
if(ret == -1){
2308
fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2309
strerror(errno));
2310
}
2311
free(fullname);
2312
}
2313
}
2314
2315
/* need to clean even if 0 because man page doesn't specify */
2316
free(direntries);
2317
if (numentries == -1){
2318
perror_plus("scandir");
2319
}
2320
ret = rmdir(tempdir);
2321
if(ret == -1 and errno != ENOENT){
2322
perror_plus("rmdir");
2323
}
3331
if(tempdir != NULL){
3332
clean_dir_at(-1, tempdir, 0);
2324
3333
}
2325
3334
2326
3335
if(quit_now){
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0