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