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