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 749.1.1
- compare with another revision
- download diff
- download tarball
- view history from revision 749.1.1
- Committer: Teddy Hogeborn
- Date: 2015-05-23 20:18:34 UTC
- mto: This revision was merged to the branch mainline in revision 756.
- Revision ID: teddy@recompile.se-20150523201834-e89ex4ito93yni8x
mandos: Use multiprocessing module to run checkers.
For a long time, the Mandos server has occasionally logged the message
"ERROR: Child process vanished". This was never a fatal error, but it
has been annoying and slightly worrying, since a definite cause was
not found. One potential cause could be the "multiprocessing" and
"subprocess" modules conflicting w.r.t. SIGCHLD. To avoid this,
change the running of checkers from using subprocess.Popen
asynchronously to instead first create a multiprocessing.Process()
(which is asynchronous) calling a function, and have that function
then call subprocess.call() (which is synchronous). In this way, the
only thing using any asynchronous subprocesses is the multiprocessing
module.
This makes it necessary to change one small thing in the D-Bus API,
since the subprocesses.call() function does not expose the raw wait(2)
status value.
DBUS-API (CheckerCompleted): Change the second value provided by this
D-Bus signal from the raw wait(2) status
to the actual terminating signal number.
mandos (subprocess_call_pipe): New function to be called by
multiprocessing.Process (starting a
separate process).
(Client.last_checker signal): New attribute for signal which
terminated last checker. Like
last_checker_status, only not accessible
via D-Bus.
(Client.checker_callback): Take new "connection" argument and use it
to get returncode; set last_checker_signal.
Return False so gobject does not call this
callback again.
(Client.start_checker): Start checker using a multiprocessing.Process
instead of a subprocess.Popen.
(ClientDBus.checker_callback): Take new "connection" argument. Call
Client.checker_callback early to have
it set last_checker_status and
last_checker_signal; use those. Change
second value provided to D-Bus signal
CheckerCompleted to use
last_checker_signal if checker was
terminated by signal.
mandos-monitor: Update to reflect DBus API change.
(MandosClientWidget.checker_completed): Take "signal" instead of
"condition" argument. Use it
accordingly. Remove dead code
(os.WCOREDUMP case).
For a long time, the Mandos server has occasionally logged the message
"ERROR: Child process vanished". This was never a fatal error, but it
has been annoying and slightly worrying, since a definite cause was
not found. One potential cause could be the "multiprocessing" and
"subprocess" modules conflicting w.r.t. SIGCHLD. To avoid this,
change the running of checkers from using subprocess.Popen
asynchronously to instead first create a multiprocessing.Process()
(which is asynchronous) calling a function, and have that function
then call subprocess.call() (which is synchronous). In this way, the
only thing using any asynchronous subprocesses is the multiprocessing
module.
This makes it necessary to change one small thing in the D-Bus API,
since the subprocesses.call() function does not expose the raw wait(2)
status value.
DBUS-API (CheckerCompleted): Change the second value provided by this
D-Bus signal from the raw wait(2) status
to the actual terminating signal number.
mandos (subprocess_call_pipe): New function to be called by
multiprocessing.Process (starting a
separate process).
(Client.last_checker signal): New attribute for signal which
terminated last checker. Like
last_checker_status, only not accessible
via D-Bus.
(Client.checker_callback): Take new "connection" argument and use it
to get returncode; set last_checker_signal.
Return False so gobject does not call this
callback again.
(Client.start_checker): Start checker using a multiprocessing.Process
instead of a subprocess.Popen.
(ClientDBus.checker_callback): Take new "connection" argument. Call
Client.checker_callback early to have
it set last_checker_status and
last_checker_signal; use those. Change
second value provided to D-Bus signal
CheckerCompleted to use
last_checker_signal if checker was
terminated by signal.
mandos-monitor: Update to reflect DBus API change.
(MandosClientWidget.checker_completed): Take "signal" instead of
"condition" argument. Use it
accordingly. Remove dead code
(os.WCOREDUMP case).
- files added:
- debian/mandos-client.examples
- debian/upstream
- network-hooks.d
- 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-2014 Teddy Hogeborn
13
* Copyright © 2008-2014 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() */
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))
189
int fprintf_plus(FILE *stream, const char *format, ...){
190
va_list ap;
191
va_start (ap, format);
192
193
TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
194
program_invocation_short_name));
195
return (int)TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
196
}
197
177
198
/*
178
199
* Make additional room in "buffer" for at least BUFFER_SIZE more
179
200
* bytes. "buffer_capacity" is how much is currently allocated,
180
201
* "buffer_length" is how much is already used.
181
202
*/
203
__attribute__((nonnull, warn_unused_result))
182
204
size_t incbuffer(char **buffer, size_t buffer_length,
183
205
size_t buffer_capacity){
184
206
if(buffer_length + BUFFER_SIZE > buffer_capacity){
185
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
186
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;
187
213
return 0;
188
214
}
215
*buffer = new_buf;
189
216
buffer_capacity += BUFFER_SIZE;
190
217
}
191
218
return buffer_capacity;
192
219
}
193
220
194
221
/* Add server to set of servers to retry periodically */
195
int add_server(const char *ip, uint16_t port, AvahiIfIndex if_index,
196
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){
197
225
int ret;
198
226
server *new_server = malloc(sizeof(server));
199
227
if(new_server == NULL){
200
228
perror_plus("malloc");
201
return -1;
229
return false;
202
230
}
203
231
*new_server = (server){ .ip = strdup(ip),
204
232
.port = port,
206
234
.af = af };
207
235
if(new_server->ip == NULL){
208
236
perror_plus("strdup");
209
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;
210
253
}
211
254
/* Special case of first server */
212
if (mc.current_server == NULL){
255
if(*current_server == NULL){
213
256
new_server->next = new_server;
214
257
new_server->prev = new_server;
215
mc.current_server = new_server;
216
/* Place the new server last in the list */
258
*current_server = new_server;
217
259
} else {
218
new_server->next = mc.current_server;
219
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;
220
263
new_server->prev->next = new_server;
221
mc.current_server->prev = new_server;
222
}
223
ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);
224
if(ret == -1){
225
perror_plus("clock_gettime");
226
return -1;
227
}
228
return 0;
264
(*current_server)->prev = new_server;
265
}
266
return true;
229
267
}
230
268
231
269
/*
232
270
* Initialize GPGME.
233
271
*/
234
static bool init_gpgme(const char *seckey, const char *pubkey,
235
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){
236
277
gpgme_error_t rc;
237
278
gpgme_engine_info_t engine_info;
238
279
239
240
280
/*
241
281
* Helper function to insert pub and seckey to the engine keyring.
242
282
*/
243
bool import_key(const char *filename){
283
bool import_key(const char * const filename){
244
284
int ret;
245
285
int fd;
246
286
gpgme_data_t pgp_data;
253
293
254
294
rc = gpgme_data_new_from_fd(&pgp_data, fd);
255
295
if(rc != GPG_ERR_NO_ERROR){
256
fprintf(stderr, "Mandos plugin mandos-client: "
257
"bad gpgme_data_new_from_fd: %s: %s\n",
258
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));
259
298
return false;
260
299
}
261
300
262
rc = gpgme_op_import(mc.ctx, pgp_data);
301
rc = gpgme_op_import(mc->ctx, pgp_data);
263
302
if(rc != GPG_ERR_NO_ERROR){
264
fprintf(stderr, "Mandos plugin mandos-client: "
265
"bad gpgme_op_import: %s: %s\n",
266
gpgme_strsource(rc), gpgme_strerror(rc));
303
fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
304
gpgme_strsource(rc), gpgme_strerror(rc));
267
305
return false;
268
306
}
269
307
276
314
}
277
315
278
316
if(debug){
279
fprintf(stderr, "Mandos plugin mandos-client: "
280
"Initializing GPGME\n");
317
fprintf_plus(stderr, "Initializing GPGME\n");
281
318
}
282
319
283
320
/* Init GPGME */
284
321
gpgme_check_version(NULL);
285
322
rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
286
323
if(rc != GPG_ERR_NO_ERROR){
287
fprintf(stderr, "Mandos plugin mandos-client: "
288
"bad gpgme_engine_check_version: %s: %s\n",
289
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));
290
326
return false;
291
327
}
292
328
293
329
/* Set GPGME home directory for the OpenPGP engine only */
294
330
rc = gpgme_get_engine_info(&engine_info);
295
331
if(rc != GPG_ERR_NO_ERROR){
296
fprintf(stderr, "Mandos plugin mandos-client: "
297
"bad gpgme_get_engine_info: %s: %s\n",
298
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));
299
334
return false;
300
335
}
301
336
while(engine_info != NULL){
307
342
engine_info = engine_info->next;
308
343
}
309
344
if(engine_info == NULL){
310
fprintf(stderr, "Mandos plugin mandos-client: "
311
"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);
312
347
return false;
313
348
}
314
349
315
350
/* Create new GPGME "context" */
316
rc = gpgme_new(&(mc.ctx));
351
rc = gpgme_new(&(mc->ctx));
317
352
if(rc != GPG_ERR_NO_ERROR){
318
fprintf(stderr, "Mandos plugin mandos-client: "
319
"bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
320
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));
321
356
return false;
322
357
}
323
358
332
367
* Decrypt OpenPGP data.
333
368
* Returns -1 on error
334
369
*/
370
__attribute__((nonnull, warn_unused_result))
335
371
static ssize_t pgp_packet_decrypt(const char *cryptotext,
336
372
size_t crypto_size,
337
char **plaintext){
373
char **plaintext,
374
mandos_context *mc){
338
375
gpgme_data_t dh_crypto, dh_plain;
339
376
gpgme_error_t rc;
340
377
ssize_t ret;
342
379
ssize_t plaintext_length = 0;
343
380
344
381
if(debug){
345
fprintf(stderr, "Mandos plugin mandos-client: "
346
"Trying to decrypt OpenPGP data\n");
382
fprintf_plus(stderr, "Trying to decrypt OpenPGP data\n");
347
383
}
348
384
349
385
/* Create new GPGME data buffer from memory cryptotext */
350
386
rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
351
387
0);
352
388
if(rc != GPG_ERR_NO_ERROR){
353
fprintf(stderr, "Mandos plugin mandos-client: "
354
"bad gpgme_data_new_from_mem: %s: %s\n",
355
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));
356
391
return -1;
357
392
}
358
393
359
394
/* Create new empty GPGME data buffer for the plaintext */
360
395
rc = gpgme_data_new(&dh_plain);
361
396
if(rc != GPG_ERR_NO_ERROR){
362
fprintf(stderr, "Mandos plugin mandos-client: "
363
"bad gpgme_data_new: %s: %s\n",
364
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));
365
400
gpgme_data_release(dh_crypto);
366
401
return -1;
367
402
}
368
403
369
404
/* Decrypt data from the cryptotext data buffer to the plaintext
370
405
data buffer */
371
rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
406
rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
372
407
if(rc != GPG_ERR_NO_ERROR){
373
fprintf(stderr, "Mandos plugin mandos-client: "
374
"bad gpgme_op_decrypt: %s: %s\n",
375
gpgme_strsource(rc), gpgme_strerror(rc));
408
fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
409
gpgme_strsource(rc), gpgme_strerror(rc));
376
410
plaintext_length = -1;
377
411
if(debug){
378
412
gpgme_decrypt_result_t result;
379
result = gpgme_op_decrypt_result(mc.ctx);
413
result = gpgme_op_decrypt_result(mc->ctx);
380
414
if(result == NULL){
381
fprintf(stderr, "Mandos plugin mandos-client: "
382
"gpgme_op_decrypt_result failed\n");
415
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
383
416
} else {
384
fprintf(stderr, "Mandos plugin mandos-client: "
385
"Unsupported algorithm: %s\n",
386
result->unsupported_algorithm);
387
fprintf(stderr, "Mandos plugin mandos-client: "
388
"Wrong key usage: %u\n",
389
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);
390
421
if(result->file_name != NULL){
391
fprintf(stderr, "Mandos plugin mandos-client: "
392
"File name: %s\n", result->file_name);
422
fprintf_plus(stderr, "File name: %s\n", result->file_name);
393
423
}
394
424
gpgme_recipient_t recipient;
395
425
recipient = result->recipients;
396
426
while(recipient != NULL){
397
fprintf(stderr, "Mandos plugin mandos-client: "
398
"Public key algorithm: %s\n",
399
gpgme_pubkey_algo_name(recipient->pubkey_algo));
400
fprintf(stderr, "Mandos plugin mandos-client: "
401
"Key ID: %s\n", recipient->keyid);
402
fprintf(stderr, "Mandos plugin mandos-client: "
403
"Secret key available: %s\n",
404
recipient->status == GPG_ERR_NO_SECKEY
405
? "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");
406
434
recipient = recipient->next;
407
435
}
408
436
}
411
439
}
412
440
413
441
if(debug){
414
fprintf(stderr, "Mandos plugin mandos-client: "
415
"Decryption of OpenPGP data succeeded\n");
442
fprintf_plus(stderr, "Decryption of OpenPGP data succeeded\n");
416
443
}
417
444
418
445
/* Seek back to the beginning of the GPGME plaintext data buffer */
449
476
}
450
477
451
478
if(debug){
452
fprintf(stderr, "Mandos plugin mandos-client: "
453
"Decrypted password is: ");
479
fprintf_plus(stderr, "Decrypted password is: ");
454
480
for(ssize_t i = 0; i < plaintext_length; i++){
455
481
fprintf(stderr, "%02hhX ", (*plaintext)[i]);
456
482
}
467
493
return plaintext_length;
468
494
}
469
495
470
static const char * safer_gnutls_strerror(int value){
471
const char *ret = gnutls_strerror(value); /* Spurious warning from
472
-Wunreachable-code */
473
if(ret == NULL)
474
ret = "(unknown)";
475
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);
476
507
}
477
508
478
509
/* GnuTLS log function callback */
510
__attribute__((nonnull))
479
511
static void debuggnutls(__attribute__((unused)) int level,
480
512
const char* string){
481
fprintf(stderr, "Mandos plugin mandos-client: GnuTLS: %s", string);
513
fprintf_plus(stderr, "GnuTLS: %s", string);
482
514
}
483
515
516
__attribute__((nonnull, warn_unused_result))
484
517
static int init_gnutls_global(const char *pubkeyfilename,
485
const char *seckeyfilename){
518
const char *seckeyfilename,
519
mandos_context *mc){
486
520
int ret;
521
unsigned int uret;
487
522
488
523
if(debug){
489
fprintf(stderr, "Mandos plugin mandos-client: "
490
"Initializing GnuTLS\n");
524
fprintf_plus(stderr, "Initializing GnuTLS\n");
491
525
}
492
526
493
527
ret = gnutls_global_init();
494
528
if(ret != GNUTLS_E_SUCCESS){
495
fprintf(stderr, "Mandos plugin mandos-client: "
496
"GnuTLS global_init: %s\n", safer_gnutls_strerror(ret));
529
fprintf_plus(stderr, "GnuTLS global_init: %s\n",
530
safer_gnutls_strerror(ret));
497
531
return -1;
498
532
}
499
533
506
540
}
507
541
508
542
/* OpenPGP credentials */
509
ret = gnutls_certificate_allocate_credentials(&mc.cred);
543
ret = gnutls_certificate_allocate_credentials(&mc->cred);
510
544
if(ret != GNUTLS_E_SUCCESS){
511
fprintf(stderr, "Mandos plugin mandos-client: "
512
"GnuTLS memory error: %s\n", safer_gnutls_strerror(ret));
545
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
546
safer_gnutls_strerror(ret));
513
547
gnutls_global_deinit();
514
548
return -1;
515
549
}
516
550
517
551
if(debug){
518
fprintf(stderr, "Mandos plugin mandos-client: "
519
"Attempting to use OpenPGP public key %s and"
520
" secret key %s as GnuTLS credentials\n", pubkeyfilename,
521
seckeyfilename);
552
fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
553
" secret key %s as GnuTLS credentials\n",
554
pubkeyfilename,
555
seckeyfilename);
522
556
}
523
557
524
558
ret = gnutls_certificate_set_openpgp_key_file
525
(mc.cred, pubkeyfilename, seckeyfilename,
559
(mc->cred, pubkeyfilename, seckeyfilename,
526
560
GNUTLS_OPENPGP_FMT_BASE64);
527
561
if(ret != GNUTLS_E_SUCCESS){
528
fprintf(stderr,
529
"Mandos plugin mandos-client: "
530
"Error[%d] while reading the OpenPGP key pair ('%s',"
531
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
532
fprintf(stderr, "Mandos plugin mandos-client: "
533
"The GnuTLS error is: %s\n", safer_gnutls_strerror(ret));
562
fprintf_plus(stderr,
563
"Error[%d] while reading the OpenPGP key pair ('%s',"
564
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
565
fprintf_plus(stderr, "The GnuTLS error is: %s\n",
566
safer_gnutls_strerror(ret));
534
567
goto globalfail;
535
568
}
536
569
537
570
/* GnuTLS server initialization */
538
ret = gnutls_dh_params_init(&mc.dh_params);
571
ret = gnutls_dh_params_init(&mc->dh_params);
539
572
if(ret != GNUTLS_E_SUCCESS){
540
fprintf(stderr, "Mandos plugin mandos-client: "
541
"Error in GnuTLS DH parameter initialization:"
542
" %s\n", safer_gnutls_strerror(ret));
573
fprintf_plus(stderr, "Error in GnuTLS DH parameter"
574
" initialization: %s\n",
575
safer_gnutls_strerror(ret));
543
576
goto globalfail;
544
577
}
545
ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
578
if(mc->dh_bits == 0){
579
/* Find out the optimal number of DH bits */
580
/* Try to read the private key file */
581
gnutls_datum_t buffer = { .data = NULL, .size = 0 };
582
{
583
int secfile = open(seckeyfilename, O_RDONLY);
584
size_t buffer_capacity = 0;
585
while(true){
586
buffer_capacity = incbuffer((char **)&buffer.data,
587
(size_t)buffer.size,
588
(size_t)buffer_capacity);
589
if(buffer_capacity == 0){
590
perror_plus("incbuffer");
591
free(buffer.data);
592
buffer.data = NULL;
593
break;
594
}
595
ssize_t bytes_read = read(secfile, buffer.data + buffer.size,
596
BUFFER_SIZE);
597
/* EOF */
598
if(bytes_read == 0){
599
break;
600
}
601
/* check bytes_read for failure */
602
if(bytes_read < 0){
603
perror_plus("read");
604
free(buffer.data);
605
buffer.data = NULL;
606
break;
607
}
608
buffer.size += (unsigned int)bytes_read;
609
}
610
close(secfile);
611
}
612
/* If successful, use buffer to parse private key */
613
gnutls_sec_param_t sec_param = GNUTLS_SEC_PARAM_ULTRA;
614
if(buffer.data != NULL){
615
{
616
gnutls_openpgp_privkey_t privkey = NULL;
617
ret = gnutls_openpgp_privkey_init(&privkey);
618
if(ret != GNUTLS_E_SUCCESS){
619
fprintf_plus(stderr, "Error initializing OpenPGP key"
620
" structure: %s", safer_gnutls_strerror(ret));
621
free(buffer.data);
622
buffer.data = NULL;
623
} else {
624
ret = gnutls_openpgp_privkey_import(privkey, &buffer,
625
GNUTLS_OPENPGP_FMT_BASE64,
626
"", 0);
627
if(ret != GNUTLS_E_SUCCESS){
628
fprintf_plus(stderr, "Error importing OpenPGP key : %s",
629
safer_gnutls_strerror(ret));
630
privkey = NULL;
631
}
632
free(buffer.data);
633
buffer.data = NULL;
634
if(privkey != NULL){
635
/* Use private key to suggest an appropriate sec_param */
636
sec_param = gnutls_openpgp_privkey_sec_param(privkey);
637
gnutls_openpgp_privkey_deinit(privkey);
638
if(debug){
639
fprintf_plus(stderr, "This OpenPGP key implies using a"
640
" GnuTLS security parameter \"%s\".\n",
641
safe_string(gnutls_sec_param_get_name
642
(sec_param)));
643
}
644
}
645
}
646
}
647
if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
648
/* Err on the side of caution */
649
sec_param = GNUTLS_SEC_PARAM_ULTRA;
650
if(debug){
651
fprintf_plus(stderr, "Falling back to security parameter"
652
" \"%s\"\n",
653
safe_string(gnutls_sec_param_get_name
654
(sec_param)));
655
}
656
}
657
}
658
uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
659
if(uret != 0){
660
mc->dh_bits = uret;
661
if(debug){
662
fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
663
" implies %u DH bits; using that.\n",
664
safe_string(gnutls_sec_param_get_name
665
(sec_param)),
666
mc->dh_bits);
667
}
668
} else {
669
fprintf_plus(stderr, "Failed to get implied number of DH"
670
" bits for security parameter \"%s\"): %s\n",
671
safe_string(gnutls_sec_param_get_name(sec_param)),
672
safer_gnutls_strerror(ret));
673
goto globalfail;
674
}
675
} else if(debug){
676
fprintf_plus(stderr, "DH bits explicitly set to %u\n",
677
mc->dh_bits);
678
}
679
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
546
680
if(ret != GNUTLS_E_SUCCESS){
547
fprintf(stderr, "Mandos plugin mandos-client: "
548
"Error in GnuTLS prime generation: %s\n",
549
safer_gnutls_strerror(ret));
681
fprintf_plus(stderr, "Error in GnuTLS prime generation (%u bits):"
682
" %s\n", mc->dh_bits, safer_gnutls_strerror(ret));
550
683
goto globalfail;
551
684
}
552
685
553
gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
686
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
554
687
555
688
return 0;
556
689
557
690
globalfail:
558
691
559
gnutls_certificate_free_credentials(mc.cred);
692
gnutls_certificate_free_credentials(mc->cred);
560
693
gnutls_global_deinit();
561
gnutls_dh_params_deinit(mc.dh_params);
694
gnutls_dh_params_deinit(mc->dh_params);
562
695
return -1;
563
696
}
564
697
565
static int init_gnutls_session(gnutls_session_t *session){
698
__attribute__((nonnull, warn_unused_result))
699
static int init_gnutls_session(gnutls_session_t *session,
700
mandos_context *mc){
566
701
int ret;
567
702
/* GnuTLS session creation */
568
703
do {
572
707
}
573
708
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
574
709
if(ret != GNUTLS_E_SUCCESS){
575
fprintf(stderr, "Mandos plugin mandos-client: "
576
"Error in GnuTLS session initialization: %s\n",
577
safer_gnutls_strerror(ret));
710
fprintf_plus(stderr,
711
"Error in GnuTLS session initialization: %s\n",
712
safer_gnutls_strerror(ret));
578
713
}
579
714
580
715
{
581
716
const char *err;
582
717
do {
583
ret = gnutls_priority_set_direct(*session, mc.priority, &err);
718
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
584
719
if(quit_now){
585
720
gnutls_deinit(*session);
586
721
return -1;
587
722
}
588
723
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
589
724
if(ret != GNUTLS_E_SUCCESS){
590
fprintf(stderr, "Mandos plugin mandos-client: "
591
"Syntax error at: %s\n", err);
592
fprintf(stderr, "Mandos plugin mandos-client: "
593
"GnuTLS error: %s\n", safer_gnutls_strerror(ret));
725
fprintf_plus(stderr, "Syntax error at: %s\n", err);
726
fprintf_plus(stderr, "GnuTLS error: %s\n",
727
safer_gnutls_strerror(ret));
594
728
gnutls_deinit(*session);
595
729
return -1;
596
730
}
598
732
599
733
do {
600
734
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
601
mc.cred);
735
mc->cred);
602
736
if(quit_now){
603
737
gnutls_deinit(*session);
604
738
return -1;
605
739
}
606
740
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
607
741
if(ret != GNUTLS_E_SUCCESS){
608
fprintf(stderr, "Mandos plugin mandos-client: "
609
"Error setting GnuTLS credentials: %s\n",
610
safer_gnutls_strerror(ret));
742
fprintf_plus(stderr, "Error setting GnuTLS credentials: %s\n",
743
safer_gnutls_strerror(ret));
611
744
gnutls_deinit(*session);
612
745
return -1;
613
746
}
615
748
/* ignore client certificate if any. */
616
749
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
617
750
618
gnutls_dh_set_prime_bits(*session, mc.dh_bits);
751
gnutls_dh_set_prime_bits(*session, mc->dh_bits);
619
752
620
753
return 0;
621
754
}
625
758
__attribute__((unused)) const char *txt){}
626
759
627
760
/* Called when a Mandos server is found */
628
static int start_mandos_communication(const char *ip, uint16_t port,
761
__attribute__((nonnull, warn_unused_result))
762
static int start_mandos_communication(const char *ip, in_port_t port,
629
763
AvahiIfIndex if_index,
630
int af){
764
int af, mandos_context *mc){
631
765
int ret, tcp_sd = -1;
632
766
ssize_t sret;
633
union {
634
struct sockaddr_in in;
635
struct sockaddr_in6 in6;
636
} to;
767
struct sockaddr_storage to;
637
768
char *buffer = NULL;
638
769
char *decrypted_buffer = NULL;
639
770
size_t buffer_length = 0;
658
789
pf = PF_INET;
659
790
break;
660
791
default:
661
fprintf(stderr, "Mandos plugin mandos-client: "
662
"Bad address family: %d\n", af);
792
fprintf_plus(stderr, "Bad address family: %d\n", af);
663
793
errno = EINVAL;
664
794
return -1;
665
795
}
666
796
667
ret = init_gnutls_session(&session);
797
/* If the interface is specified and we have a list of interfaces */
798
if(if_index != AVAHI_IF_UNSPEC and mc->interfaces != NULL){
799
/* Check if the interface is one of the interfaces we are using */
800
bool match = false;
801
{
802
char *interface = NULL;
803
while((interface=argz_next(mc->interfaces, mc->interfaces_size,
804
interface))){
805
if(if_nametoindex(interface) == (unsigned int)if_index){
806
match = true;
807
break;
808
}
809
}
810
}
811
if(not match){
812
/* This interface does not match any in the list, so we don't
813
connect to the server */
814
if(debug){
815
char interface[IF_NAMESIZE];
816
if(if_indextoname((unsigned int)if_index, interface) == NULL){
817
perror_plus("if_indextoname");
818
} else {
819
fprintf_plus(stderr, "Skipping server on non-used interface"
820
" \"%s\"\n",
821
if_indextoname((unsigned int)if_index,
822
interface));
823
}
824
}
825
return -1;
826
}
827
}
828
829
ret = init_gnutls_session(&session, mc);
668
830
if(ret != 0){
669
831
return -1;
670
832
}
671
833
672
834
if(debug){
673
fprintf(stderr, "Mandos plugin mandos-client: "
674
"Setting up a TCP connection to %s, port %" PRIu16
675
"\n", ip, port);
835
fprintf_plus(stderr, "Setting up a TCP connection to %s, port %"
836
PRIuMAX "\n", ip, (uintmax_t)port);
676
837
}
677
838
678
839
tcp_sd = socket(pf, SOCK_STREAM, 0);
690
851
691
852
memset(&to, 0, sizeof(to));
692
853
if(af == AF_INET6){
693
to.in6.sin6_family = (sa_family_t)af;
694
ret = inet_pton(af, ip, &to.in6.sin6_addr);
854
((struct sockaddr_in6 *)&to)->sin6_family = (sa_family_t)af;
855
ret = inet_pton(af, ip, &((struct sockaddr_in6 *)&to)->sin6_addr);
695
856
} else { /* IPv4 */
696
to.in.sin_family = (sa_family_t)af;
697
ret = inet_pton(af, ip, &to.in.sin_addr);
857
((struct sockaddr_in *)&to)->sin_family = (sa_family_t)af;
858
ret = inet_pton(af, ip, &((struct sockaddr_in *)&to)->sin_addr);
698
859
}
699
860
if(ret < 0 ){
700
861
int e = errno;
704
865
}
705
866
if(ret == 0){
706
867
int e = errno;
707
fprintf(stderr, "Mandos plugin mandos-client: "
708
"Bad address: %s\n", ip);
868
fprintf_plus(stderr, "Bad address: %s\n", ip);
709
869
errno = e;
710
870
goto mandos_end;
711
871
}
712
872
if(af == AF_INET6){
713
to.in6.sin6_port = htons(port); /* Spurious warnings from
714
-Wconversion and
715
-Wunreachable-code */
716
717
if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
718
(&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
719
-Wunreachable-code*/
873
((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
874
if(IN6_IS_ADDR_LINKLOCAL
875
(&((struct sockaddr_in6 *)&to)->sin6_addr)){
720
876
if(if_index == AVAHI_IF_UNSPEC){
721
fprintf(stderr, "Mandos plugin mandos-client: "
722
"An IPv6 link-local address is incomplete"
723
" without a network interface\n");
877
fprintf_plus(stderr, "An IPv6 link-local address is"
878
" incomplete without a network interface\n");
724
879
errno = EINVAL;
725
880
goto mandos_end;
726
881
}
727
882
/* Set the network interface number as scope */
728
to.in6.sin6_scope_id = (uint32_t)if_index;
883
((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
729
884
}
730
885
} else {
731
to.in.sin_port = htons(port); /* Spurious warnings from
732
-Wconversion and
733
-Wunreachable-code */
886
((struct sockaddr_in *)&to)->sin_port = htons(port);
734
887
}
735
888
736
889
if(quit_now){
744
897
if(if_indextoname((unsigned int)if_index, interface) == NULL){
745
898
perror_plus("if_indextoname");
746
899
} else {
747
fprintf(stderr, "Mandos plugin mandos-client: "
748
"Connection to: %s%%%s, port %" PRIu16 "\n",
749
ip, interface, port);
900
fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIuMAX
901
"\n", ip, interface, (uintmax_t)port);
750
902
}
751
903
} else {
752
fprintf(stderr, "Mandos plugin mandos-client: "
753
"Connection to: %s, port %" PRIu16 "\n", ip, port);
904
fprintf_plus(stderr, "Connection to: %s, port %" PRIuMAX "\n",
905
ip, (uintmax_t)port);
754
906
}
755
907
char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
756
908
INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
757
const char *pcret;
758
909
if(af == AF_INET6){
759
pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
760
sizeof(addrstr));
910
ret = getnameinfo((struct sockaddr *)&to,
911
sizeof(struct sockaddr_in6),
912
addrstr, sizeof(addrstr), NULL, 0,
913
NI_NUMERICHOST);
761
914
} else {
762
pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
763
sizeof(addrstr));
915
ret = getnameinfo((struct sockaddr *)&to,
916
sizeof(struct sockaddr_in),
917
addrstr, sizeof(addrstr), NULL, 0,
918
NI_NUMERICHOST);
764
919
}
765
if(pcret == NULL){
766
perror_plus("inet_ntop");
767
} else {
768
if(strcmp(addrstr, ip) != 0){
769
fprintf(stderr, "Mandos plugin mandos-client: "
770
"Canonical address form: %s\n", addrstr);
771
}
920
if(ret == EAI_SYSTEM){
921
perror_plus("getnameinfo");
922
} else if(ret != 0) {
923
fprintf_plus(stderr, "getnameinfo: %s", gai_strerror(ret));
924
} else if(strcmp(addrstr, ip) != 0){
925
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
772
926
}
773
927
}
774
928
778
932
}
779
933
780
934
if(af == AF_INET6){
781
ret = connect(tcp_sd, &to.in6, sizeof(to));
935
ret = connect(tcp_sd, (struct sockaddr *)&to,
936
sizeof(struct sockaddr_in6));
782
937
} else {
783
ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
938
ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
939
sizeof(struct sockaddr_in));
784
940
}
785
941
if(ret < 0){
786
if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
942
if((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
787
943
int e = errno;
788
944
perror_plus("connect");
789
945
errno = e;
827
983
}
828
984
829
985
if(debug){
830
fprintf(stderr, "Mandos plugin mandos-client: "
831
"Establishing TLS session with %s\n", ip);
986
fprintf_plus(stderr, "Establishing TLS session with %s\n", ip);
832
987
}
833
988
834
989
if(quit_now){
836
991
goto mandos_end;
837
992
}
838
993
839
/* Spurious warning from -Wint-to-pointer-cast */
840
gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
994
/* This casting via intptr_t is to eliminate warning about casting
995
an int to a pointer type. This is exactly how the GnuTLS Guile
996
function "set-session-transport-fd!" does it. */
997
gnutls_transport_set_ptr(session,
998
(gnutls_transport_ptr_t)(intptr_t)tcp_sd);
841
999
842
1000
if(quit_now){
843
1001
errno = EINTR;
854
1012
855
1013
if(ret != GNUTLS_E_SUCCESS){
856
1014
if(debug){
857
fprintf(stderr, "Mandos plugin mandos-client: "
858
"*** GnuTLS Handshake failed ***\n");
1015
fprintf_plus(stderr, "*** GnuTLS Handshake failed ***\n");
859
1016
gnutls_perror(ret);
860
1017
}
861
1018
errno = EPROTO;
865
1022
/* Read OpenPGP packet that contains the wanted password */
866
1023
867
1024
if(debug){
868
fprintf(stderr, "Mandos plugin mandos-client: "
869
"Retrieving OpenPGP encrypted password from %s\n", ip);
1025
fprintf_plus(stderr, "Retrieving OpenPGP encrypted password from"
1026
" %s\n", ip);
870
1027
}
871
1028
872
1029
while(true){
910
1067
}
911
1068
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
912
1069
if(ret < 0){
913
fprintf(stderr, "Mandos plugin mandos-client: "
914
"*** GnuTLS Re-handshake failed ***\n");
1070
fprintf_plus(stderr, "*** GnuTLS Re-handshake failed "
1071
"***\n");
915
1072
gnutls_perror(ret);
916
1073
errno = EPROTO;
917
1074
goto mandos_end;
918
1075
}
919
1076
break;
920
1077
default:
921
fprintf(stderr, "Mandos plugin mandos-client: "
922
"Unknown error while reading data from"
923
" encrypted session with Mandos server\n");
1078
fprintf_plus(stderr, "Unknown error while reading data from"
1079
" encrypted session with Mandos server\n");
924
1080
gnutls_bye(session, GNUTLS_SHUT_RDWR);
925
1081
errno = EIO;
926
1082
goto mandos_end;
931
1087
}
932
1088
933
1089
if(debug){
934
fprintf(stderr, "Mandos plugin mandos-client: "
935
"Closing TLS session\n");
1090
fprintf_plus(stderr, "Closing TLS session\n");
936
1091
}
937
1092
938
1093
if(quit_now){
951
1106
if(buffer_length > 0){
952
1107
ssize_t decrypted_buffer_size;
953
1108
decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
954
&decrypted_buffer);
1109
&decrypted_buffer, mc);
955
1110
if(decrypted_buffer_size >= 0){
956
1111
957
1112
written = 0;
967
1122
if(ret == 0 and ferror(stdout)){
968
1123
int e = errno;
969
1124
if(debug){
970
fprintf(stderr, "Mandos plugin mandos-client: "
971
"Error writing encrypted data: %s\n",
972
strerror(errno));
1125
fprintf_plus(stderr, "Error writing encrypted data: %s\n",
1126
strerror(errno));
973
1127
}
974
1128
errno = e;
975
1129
goto mandos_end;
1006
1160
return retval;
1007
1161
}
1008
1162
1163
__attribute__((nonnull))
1009
1164
static void resolve_callback(AvahiSServiceResolver *r,
1010
1165
AvahiIfIndex interface,
1011
1166
AvahiProtocol proto,
1019
1174
AVAHI_GCC_UNUSED AvahiStringList *txt,
1020
1175
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1021
1176
flags,
1022
AVAHI_GCC_UNUSED void* userdata){
1023
assert(r);
1177
void *mc){
1178
if(r == NULL){
1179
return;
1180
}
1024
1181
1025
1182
/* Called whenever a service has been resolved successfully or
1026
1183
timed out */
1027
1184
1028
1185
if(quit_now){
1186
avahi_s_service_resolver_free(r);
1029
1187
return;
1030
1188
}
1031
1189
1032
1190
switch(event){
1033
1191
default:
1034
1192
case AVAHI_RESOLVER_FAILURE:
1035
fprintf(stderr, "Mandos plugin mandos-client: "
1036
"(Avahi Resolver) Failed to resolve service '%s'"
1037
" of type '%s' in domain '%s': %s\n", name, type, domain,
1038
avahi_strerror(avahi_server_errno(mc.server)));
1193
fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
1194
"'%s' of type '%s' in domain '%s': %s\n", name, type,
1195
domain,
1196
avahi_strerror(avahi_server_errno
1197
(((mandos_context*)mc)->server)));
1039
1198
break;
1040
1199
1041
1200
case AVAHI_RESOLVER_FOUND:
1043
1202
char ip[AVAHI_ADDRESS_STR_MAX];
1044
1203
avahi_address_snprint(ip, sizeof(ip), address);
1045
1204
if(debug){
1046
fprintf(stderr, "Mandos plugin mandos-client: "
1047
"Mandos server \"%s\" found on %s (%s, %"
1048
PRIdMAX ") on port %" PRIu16 "\n", name, host_name,
1049
ip, (intmax_t)interface, port);
1205
fprintf_plus(stderr, "Mandos server \"%s\" found on %s (%s, %"
1206
PRIdMAX ") on port %" PRIu16 "\n", name,
1207
host_name, ip, (intmax_t)interface, port);
1050
1208
}
1051
int ret = start_mandos_communication(ip, port, interface,
1052
avahi_proto_to_af(proto));
1209
int ret = start_mandos_communication(ip, (in_port_t)port,
1210
interface,
1211
avahi_proto_to_af(proto),
1212
mc);
1053
1213
if(ret == 0){
1054
avahi_simple_poll_quit(mc.simple_poll);
1214
avahi_simple_poll_quit(simple_poll);
1055
1215
} else {
1056
ret = add_server(ip, port, interface,
1057
avahi_proto_to_af(proto));
1216
if(not add_server(ip, (in_port_t)port, interface,
1217
avahi_proto_to_af(proto),
1218
&((mandos_context*)mc)->current_server)){
1219
fprintf_plus(stderr, "Failed to add server \"%s\" to server"
1220
" list\n", name);
1221
}
1058
1222
}
1059
1223
}
1060
1224
}
1070
1234
const char *domain,
1071
1235
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1072
1236
flags,
1073
AVAHI_GCC_UNUSED void* userdata){
1074
assert(b);
1237
void *mc){
1238
if(b == NULL){
1239
return;
1240
}
1075
1241
1076
1242
/* Called whenever a new services becomes available on the LAN or
1077
1243
is removed from the LAN */
1084
1250
default:
1085
1251
case AVAHI_BROWSER_FAILURE:
1086
1252
1087
fprintf(stderr, "Mandos plugin mandos-client: "
1088
"(Avahi browser) %s\n",
1089
avahi_strerror(avahi_server_errno(mc.server)));
1090
avahi_simple_poll_quit(mc.simple_poll);
1253
fprintf_plus(stderr, "(Avahi browser) %s\n",
1254
avahi_strerror(avahi_server_errno
1255
(((mandos_context*)mc)->server)));
1256
avahi_simple_poll_quit(simple_poll);
1091
1257
return;
1092
1258
1093
1259
case AVAHI_BROWSER_NEW:
1096
1262
the callback function is called the Avahi server will free the
1097
1263
resolver for us. */
1098
1264
1099
if(avahi_s_service_resolver_new(mc.server, interface, protocol,
1100
name, type, domain, protocol, 0,
1101
resolve_callback, NULL) == NULL)
1102
fprintf(stderr, "Mandos plugin mandos-client: "
1103
"Avahi: Failed to resolve service '%s': %s\n",
1104
name, avahi_strerror(avahi_server_errno(mc.server)));
1265
if(avahi_s_service_resolver_new(((mandos_context*)mc)->server,
1266
interface, protocol, name, type,
1267
domain, protocol, 0,
1268
resolve_callback, mc) == NULL)
1269
fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
1270
" %s\n", name,
1271
avahi_strerror(avahi_server_errno
1272
(((mandos_context*)mc)->server)));
1105
1273
break;
1106
1274
1107
1275
case AVAHI_BROWSER_REMOVE:
1110
1278
case AVAHI_BROWSER_ALL_FOR_NOW:
1111
1279
case AVAHI_BROWSER_CACHE_EXHAUSTED:
1112
1280
if(debug){
1113
fprintf(stderr, "Mandos plugin mandos-client: "
1114
"No Mandos server found, still searching...\n");
1281
fprintf_plus(stderr, "No Mandos server found, still"
1282
" searching...\n");
1115
1283
}
1116
1284
break;
1117
1285
}
1126
1294
signal_received = sig;
1127
1295
int old_errno = errno;
1128
1296
/* set main loop to exit */
1129
if(mc.simple_poll != NULL){
1130
avahi_simple_poll_quit(mc.simple_poll);
1297
if(simple_poll != NULL){
1298
avahi_simple_poll_quit(simple_poll);
1131
1299
}
1132
1300
errno = old_errno;
1133
1301
}
1134
1302
1303
__attribute__((nonnull, warn_unused_result))
1135
1304
bool get_flags(const char *ifname, struct ifreq *ifr){
1136
1305
int ret;
1306
error_t ret_errno;
1137
1307
1138
1308
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1139
1309
if(s < 0){
1310
ret_errno = errno;
1140
1311
perror_plus("socket");
1312
errno = ret_errno;
1141
1313
return false;
1142
1314
}
1143
1315
strcpy(ifr->ifr_name, ifname);
1144
1316
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1145
1317
if(ret == -1){
1146
1318
if(debug){
1319
ret_errno = errno;
1147
1320
perror_plus("ioctl SIOCGIFFLAGS");
1321
errno = ret_errno;
1148
1322
}
1149
1323
return false;
1150
1324
}
1151
1325
return true;
1152
1326
}
1153
1327
1328
__attribute__((nonnull, warn_unused_result))
1154
1329
bool good_flags(const char *ifname, const struct ifreq *ifr){
1155
1330
1156
1331
/* Reject the loopback device */
1157
1332
if(ifr->ifr_flags & IFF_LOOPBACK){
1158
1333
if(debug){
1159
fprintf(stderr, "Mandos plugin mandos-client: "
1160
"Rejecting loopback interface \"%s\"\n", ifname);
1334
fprintf_plus(stderr, "Rejecting loopback interface \"%s\"\n",
1335
ifname);
1161
1336
}
1162
1337
return false;
1163
1338
}
1164
1339
/* Accept point-to-point devices only if connect_to is specified */
1165
1340
if(connect_to != NULL and (ifr->ifr_flags & IFF_POINTOPOINT)){
1166
1341
if(debug){
1167
fprintf(stderr, "Mandos plugin mandos-client: "
1168
"Accepting point-to-point interface \"%s\"\n", ifname);
1342
fprintf_plus(stderr, "Accepting point-to-point interface"
1343
" \"%s\"\n", ifname);
1169
1344
}
1170
1345
return true;
1171
1346
}
1172
1347
/* Otherwise, reject non-broadcast-capable devices */
1173
1348
if(not (ifr->ifr_flags & IFF_BROADCAST)){
1174
1349
if(debug){
1175
fprintf(stderr, "Mandos plugin mandos-client: "
1176
"Rejecting non-broadcast interface \"%s\"\n", ifname);
1350
fprintf_plus(stderr, "Rejecting non-broadcast interface"
1351
" \"%s\"\n", ifname);
1177
1352
}
1178
1353
return false;
1179
1354
}
1180
1355
/* Reject non-ARP interfaces (including dummy interfaces) */
1181
1356
if(ifr->ifr_flags & IFF_NOARP){
1182
1357
if(debug){
1183
fprintf(stderr, "Mandos plugin mandos-client: "
1184
"Rejecting non-ARP interface \"%s\"\n", ifname);
1358
fprintf_plus(stderr, "Rejecting non-ARP interface \"%s\"\n",
1359
ifname);
1185
1360
}
1186
1361
return false;
1187
1362
}
1188
1363
1189
1364
/* Accept this device */
1190
1365
if(debug){
1191
fprintf(stderr, "Mandos plugin mandos-client: "
1192
"Interface \"%s\" is good\n", ifname);
1366
fprintf_plus(stderr, "Interface \"%s\" is good\n", ifname);
1193
1367
}
1194
1368
return true;
1195
1369
}
1199
1373
* corresponds to an acceptable network device.
1200
1374
* (This function is passed to scandir(3) as a filter function.)
1201
1375
*/
1376
__attribute__((nonnull, warn_unused_result))
1202
1377
int good_interface(const struct dirent *if_entry){
1203
1378
if(if_entry->d_name[0] == '.'){
1204
1379
return 0;
1207
1382
struct ifreq ifr;
1208
1383
if(not get_flags(if_entry->d_name, &ifr)){
1209
1384
if(debug){
1210
fprintf(stderr, "Mandos plugin mandos-client: "
1211
"Failed to get flags for interface \"%s\"\n",
1212
if_entry->d_name);
1213
}
1214
return 0;
1215
}
1216
1217
if(not good_flags(if_entry->d_name, &ifr)){
1218
return 0;
1219
}
1220
return 1;
1221
}
1222
1223
/*
1224
* This function determines if a directory entry in /sys/class/net
1225
* corresponds to an acceptable network device which is up.
1226
* (This function is passed to scandir(3) as a filter function.)
1227
*/
1228
int up_interface(const struct dirent *if_entry){
1229
if(if_entry->d_name[0] == '.'){
1230
return 0;
1231
}
1232
1233
struct ifreq ifr;
1234
if(not get_flags(if_entry->d_name, &ifr)){
1235
if(debug){
1236
fprintf(stderr, "Mandos plugin mandos-client: "
1237
"Failed to get flags for interface \"%s\"\n",
1238
if_entry->d_name);
1239
}
1240
return 0;
1241
}
1242
1243
/* Reject down interfaces */
1244
if(not (ifr.ifr_flags & IFF_UP)){
1245
if(debug){
1246
fprintf(stderr, "Mandos plugin mandos-client: "
1247
"Rejecting down interface \"%s\"\n",
1248
if_entry->d_name);
1249
}
1250
return 0;
1251
}
1252
1253
/* Reject non-running interfaces */
1254
if(not (ifr.ifr_flags & IFF_RUNNING)){
1255
if(debug){
1256
fprintf(stderr, "Mandos plugin mandos-client: "
1257
"Rejecting non-running interface \"%s\"\n",
1258
if_entry->d_name);
1259
}
1260
return 0;
1261
}
1262
1263
if(not good_flags(if_entry->d_name, &ifr)){
1264
return 0;
1265
}
1266
return 1;
1267
}
1268
1385
fprintf_plus(stderr, "Failed to get flags for interface "
1386
"\"%s\"\n", if_entry->d_name);
1387
}
1388
return 0;
1389
}
1390
1391
if(not good_flags(if_entry->d_name, &ifr)){
1392
return 0;
1393
}
1394
return 1;
1395
}
1396
1397
/*
1398
* This function determines if a network interface is up.
1399
*/
1400
__attribute__((nonnull, warn_unused_result))
1401
bool interface_is_up(const char *interface){
1402
struct ifreq ifr;
1403
if(not get_flags(interface, &ifr)){
1404
if(debug){
1405
fprintf_plus(stderr, "Failed to get flags for interface "
1406
"\"%s\"\n", interface);
1407
}
1408
return false;
1409
}
1410
1411
return (bool)(ifr.ifr_flags & IFF_UP);
1412
}
1413
1414
/*
1415
* This function determines if a network interface is running
1416
*/
1417
__attribute__((nonnull, warn_unused_result))
1418
bool interface_is_running(const char *interface){
1419
struct ifreq ifr;
1420
if(not get_flags(interface, &ifr)){
1421
if(debug){
1422
fprintf_plus(stderr, "Failed to get flags for interface "
1423
"\"%s\"\n", interface);
1424
}
1425
return false;
1426
}
1427
1428
return (bool)(ifr.ifr_flags & IFF_RUNNING);
1429
}
1430
1431
__attribute__((nonnull, pure, warn_unused_result))
1269
1432
int notdotentries(const struct dirent *direntry){
1270
1433
/* Skip "." and ".." */
1271
1434
if(direntry->d_name[0] == '.'
1278
1441
}
1279
1442
1280
1443
/* Is this directory entry a runnable program? */
1444
__attribute__((nonnull, warn_unused_result))
1281
1445
int runnable_hook(const struct dirent *direntry){
1282
1446
int ret;
1283
1447
size_t sret;
1291
1455
sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1292
1456
"abcdefghijklmnopqrstuvwxyz"
1293
1457
"0123456789"
1294
"_-");
1458
"_.-");
1295
1459
if((direntry->d_name)[sret] != '\0'){
1296
1460
/* Contains non-allowed characters */
1297
1461
if(debug){
1298
fprintf(stderr, "Mandos plugin mandos-client: "
1299
"Ignoring hook \"%s\" with bad name\n",
1300
direntry->d_name);
1462
fprintf_plus(stderr, "Ignoring hook \"%s\" with bad name\n",
1463
direntry->d_name);
1301
1464
}
1302
1465
return 0;
1303
1466
}
1304
1467
1305
char *fullname = NULL;
1306
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1307
if(ret < 0){
1308
perror_plus("asprintf");
1309
return 0;
1310
}
1311
1312
ret = stat(fullname, &st);
1468
ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1313
1469
if(ret == -1){
1314
1470
if(debug){
1315
1471
perror_plus("Could not stat hook");
1319
1475
if(not (S_ISREG(st.st_mode))){
1320
1476
/* Not a regular file */
1321
1477
if(debug){
1322
fprintf(stderr, "Mandos plugin mandos-client: "
1323
"Ignoring hook \"%s\" - not a file\n",
1324
direntry->d_name);
1478
fprintf_plus(stderr, "Ignoring hook \"%s\" - not a file\n",
1479
direntry->d_name);
1325
1480
}
1326
1481
return 0;
1327
1482
}
1328
1483
if(not (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))){
1329
1484
/* Not executable */
1330
1485
if(debug){
1331
fprintf(stderr, "Mandos plugin mandos-client: "
1332
"Ignoring hook \"%s\" - not executable\n",
1333
direntry->d_name);
1486
fprintf_plus(stderr, "Ignoring hook \"%s\" - not executable\n",
1487
direntry->d_name);
1334
1488
}
1335
1489
return 0;
1336
1490
}
1491
if(debug){
1492
fprintf_plus(stderr, "Hook \"%s\" is acceptable\n",
1493
direntry->d_name);
1494
}
1337
1495
return 1;
1338
1496
}
1339
1497
1340
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval){
1498
__attribute__((nonnull, warn_unused_result))
1499
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
1500
mandos_context *mc){
1341
1501
int ret;
1342
1502
struct timespec now;
1343
1503
struct timespec waited_time;
1344
1504
intmax_t block_time;
1345
1505
1346
1506
while(true){
1347
if(mc.current_server == NULL){
1348
if (debug){
1349
fprintf(stderr, "Mandos plugin mandos-client: "
1350
"Wait until first server is found. No timeout!\n");
1507
if(mc->current_server == NULL){
1508
if(debug){
1509
fprintf_plus(stderr, "Wait until first server is found."
1510
" No timeout!\n");
1351
1511
}
1352
1512
ret = avahi_simple_poll_iterate(s, -1);
1353
1513
} else {
1354
if (debug){
1355
fprintf(stderr, "Mandos plugin mandos-client: "
1356
"Check current_server if we should run it,"
1357
" or wait\n");
1514
if(debug){
1515
fprintf_plus(stderr, "Check current_server if we should run"
1516
" it, or wait\n");
1358
1517
}
1359
1518
/* the current time */
1360
1519
ret = clock_gettime(CLOCK_MONOTONIC, &now);
1365
1524
/* Calculating in ms how long time between now and server
1366
1525
who we visted longest time ago. Now - last seen. */
1367
1526
waited_time.tv_sec = (now.tv_sec
1368
- mc.current_server->last_seen.tv_sec);
1527
- mc->current_server->last_seen.tv_sec);
1369
1528
waited_time.tv_nsec = (now.tv_nsec
1370
- mc.current_server->last_seen.tv_nsec);
1529
- mc->current_server->last_seen.tv_nsec);
1371
1530
/* total time is 10s/10,000ms.
1372
1531
Converting to s from ms by dividing by 1,000,
1373
1532
and ns to ms by dividing by 1,000,000. */
1375
1534
- ((intmax_t)waited_time.tv_sec * 1000))
1376
1535
- ((intmax_t)waited_time.tv_nsec / 1000000));
1377
1536
1378
if (debug){
1379
fprintf(stderr, "Mandos plugin mandos-client: "
1380
"Blocking for %" PRIdMAX " ms\n", block_time);
1537
if(debug){
1538
fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1539
block_time);
1381
1540
}
1382
1541
1383
1542
if(block_time <= 0){
1384
ret = start_mandos_communication(mc.current_server->ip,
1385
mc.current_server->port,
1386
mc.current_server->if_index,
1387
mc.current_server->af);
1543
ret = start_mandos_communication(mc->current_server->ip,
1544
mc->current_server->port,
1545
mc->current_server->if_index,
1546
mc->current_server->af, mc);
1388
1547
if(ret == 0){
1389
avahi_simple_poll_quit(mc.simple_poll);
1548
avahi_simple_poll_quit(s);
1390
1549
return 0;
1391
1550
}
1392
1551
ret = clock_gettime(CLOCK_MONOTONIC,
1393
&mc.current_server->last_seen);
1552
&mc->current_server->last_seen);
1394
1553
if(ret == -1){
1395
1554
perror_plus("clock_gettime");
1396
1555
return -1;
1397
1556
}
1398
mc.current_server = mc.current_server->next;
1557
mc->current_server = mc->current_server->next;
1399
1558
block_time = 0; /* Call avahi to find new Mandos
1400
1559
servers, but don't block */
1401
1560
}
1403
1562
ret = avahi_simple_poll_iterate(s, (int)block_time);
1404
1563
}
1405
1564
if(ret != 0){
1406
if (ret > 0 or errno != EINTR){
1565
if(ret > 0 or errno != EINTR){
1407
1566
return (ret != 1) ? ret : 0;
1408
1567
}
1409
1568
}
1410
1569
}
1411
1570
}
1412
1571
1413
bool run_network_hooks(const char *mode, const char *interface,
1572
/* Set effective uid to 0, return errno */
1573
__attribute__((warn_unused_result))
1574
error_t raise_privileges(void){
1575
error_t old_errno = errno;
1576
error_t ret_errno = 0;
1577
if(seteuid(0) == -1){
1578
ret_errno = errno;
1579
}
1580
errno = old_errno;
1581
return ret_errno;
1582
}
1583
1584
/* Set effective and real user ID to 0. Return errno. */
1585
__attribute__((warn_unused_result))
1586
error_t raise_privileges_permanently(void){
1587
error_t old_errno = errno;
1588
error_t ret_errno = raise_privileges();
1589
if(ret_errno != 0){
1590
errno = old_errno;
1591
return ret_errno;
1592
}
1593
if(setuid(0) == -1){
1594
ret_errno = errno;
1595
}
1596
errno = old_errno;
1597
return ret_errno;
1598
}
1599
1600
/* Set effective user ID to unprivileged saved user ID */
1601
__attribute__((warn_unused_result))
1602
error_t lower_privileges(void){
1603
error_t old_errno = errno;
1604
error_t ret_errno = 0;
1605
if(seteuid(uid) == -1){
1606
ret_errno = errno;
1607
}
1608
errno = old_errno;
1609
return ret_errno;
1610
}
1611
1612
/* Lower privileges permanently */
1613
__attribute__((warn_unused_result))
1614
error_t lower_privileges_permanently(void){
1615
error_t old_errno = errno;
1616
error_t ret_errno = 0;
1617
if(setuid(uid) == -1){
1618
ret_errno = errno;
1619
}
1620
errno = old_errno;
1621
return ret_errno;
1622
}
1623
1624
__attribute__((nonnull))
1625
void run_network_hooks(const char *mode, const char *interface,
1414
1626
const float delay){
1415
struct dirent **direntries;
1416
struct dirent *direntry;
1417
int ret;
1418
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1419
alphasort);
1627
struct dirent **direntries = NULL;
1628
if(hookdir_fd == -1){
1629
hookdir_fd = open(hookdir, O_RDONLY);
1630
if(hookdir_fd == -1){
1631
if(errno == ENOENT){
1632
if(debug){
1633
fprintf_plus(stderr, "Network hook directory \"%s\" not"
1634
" found\n", hookdir);
1635
}
1636
} else {
1637
perror_plus("open");
1638
}
1639
return;
1640
}
1641
}
1642
#ifdef __GLIBC__
1643
#if __GLIBC_PREREQ(2, 15)
1644
int numhooks = scandirat(hookdir_fd, ".", &direntries,
1645
runnable_hook, alphasort);
1646
#else /* not __GLIBC_PREREQ(2, 15) */
1647
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1648
alphasort);
1649
#endif /* not __GLIBC_PREREQ(2, 15) */
1650
#else /* not __GLIBC__ */
1651
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1652
alphasort);
1653
#endif /* not __GLIBC__ */
1420
1654
if(numhooks == -1){
1421
1655
perror_plus("scandir");
1422
} else {
1423
int devnull = open("/dev/null", O_RDONLY);
1424
for(int i = 0; i < numhooks; i++){
1425
direntry = direntries[0];
1426
char *fullname = NULL;
1427
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1428
if(ret < 0){
1656
return;
1657
}
1658
struct dirent *direntry;
1659
int ret;
1660
int devnull = open("/dev/null", O_RDONLY);
1661
for(int i = 0; i < numhooks; i++){
1662
direntry = direntries[i];
1663
if(debug){
1664
fprintf_plus(stderr, "Running network hook \"%s\"\n",
1665
direntry->d_name);
1666
}
1667
pid_t hook_pid = fork();
1668
if(hook_pid == 0){
1669
/* Child */
1670
/* Raise privileges */
1671
errno = raise_privileges_permanently();
1672
if(errno != 0){
1673
perror_plus("Failed to raise privileges");
1674
_exit(EX_NOPERM);
1675
}
1676
/* Set group */
1677
errno = 0;
1678
ret = setgid(0);
1679
if(ret == -1){
1680
perror_plus("setgid");
1681
_exit(EX_NOPERM);
1682
}
1683
/* Reset supplementary groups */
1684
errno = 0;
1685
ret = setgroups(0, NULL);
1686
if(ret == -1){
1687
perror_plus("setgroups");
1688
_exit(EX_NOPERM);
1689
}
1690
ret = dup2(devnull, STDIN_FILENO);
1691
if(ret == -1){
1692
perror_plus("dup2(devnull, STDIN_FILENO)");
1693
_exit(EX_OSERR);
1694
}
1695
ret = close(devnull);
1696
if(ret == -1){
1697
perror_plus("close");
1698
_exit(EX_OSERR);
1699
}
1700
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
1701
if(ret == -1){
1702
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
1703
_exit(EX_OSERR);
1704
}
1705
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1706
if(ret == -1){
1707
perror_plus("setenv");
1708
_exit(EX_OSERR);
1709
}
1710
ret = setenv("DEVICE", interface, 1);
1711
if(ret == -1){
1712
perror_plus("setenv");
1713
_exit(EX_OSERR);
1714
}
1715
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
1716
if(ret == -1){
1717
perror_plus("setenv");
1718
_exit(EX_OSERR);
1719
}
1720
ret = setenv("MODE", mode, 1);
1721
if(ret == -1){
1722
perror_plus("setenv");
1723
_exit(EX_OSERR);
1724
}
1725
char *delaystring;
1726
ret = asprintf(&delaystring, "%f", (double)delay);
1727
if(ret == -1){
1429
1728
perror_plus("asprintf");
1430
continue;
1729
_exit(EX_OSERR);
1431
1730
}
1432
pid_t hook_pid = fork();
1433
if(hook_pid == 0){
1434
/* Child */
1435
dup2(devnull, STDIN_FILENO);
1436
close(devnull);
1437
dup2(STDERR_FILENO, STDOUT_FILENO);
1438
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1439
if(ret == -1){
1440
perror_plus("setenv");
1441
return false;
1442
}
1443
ret = setenv("DEVICE", interface, 1);
1444
if(ret == -1){
1445
perror_plus("setenv");
1446
return false;
1447
}
1448
ret = setenv("VERBOSE", debug ? "1" : "0", 1);
1449
if(ret == -1){
1450
perror_plus("setenv");
1451
return false;
1452
}
1453
ret = setenv("MODE", mode, 1);
1454
if(ret == -1){
1455
perror_plus("setenv");
1456
return false;
1457
}
1458
char *delaystring;
1459
ret = asprintf(&delaystring, "%f", delay);
1460
if(ret == -1){
1461
perror_plus("asprintf");
1462
return false;
1463
}
1464
ret = setenv("DELAY", delaystring, 1);
1465
if(ret == -1){
1466
free(delaystring);
1467
perror_plus("setenv");
1468
return false;
1469
}
1731
ret = setenv("DELAY", delaystring, 1);
1732
if(ret == -1){
1470
1733
free(delaystring);
1471
ret = execl(fullname, direntry->d_name, mode, NULL);
1472
perror_plus("execl");
1473
} else {
1474
int status;
1475
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1476
perror_plus("waitpid");
1477
free(fullname);
1478
continue;
1479
}
1480
if(WIFEXITED(status)){
1481
if(WEXITSTATUS(status) != 0){
1482
fprintf(stderr, "Mandos plugin mandos-client: "
1483
"Warning: network hook \"%s\" exited"
1484
" with status %d\n", direntry->d_name,
1485
WEXITSTATUS(status));
1486
free(fullname);
1487
continue;
1488
}
1489
} else if(WIFSIGNALED(status)){
1490
fprintf(stderr, "Mandos plugin mandos-client: "
1491
"Warning: network hook \"%s\" died by"
1492
" signal %d\n", direntry->d_name,
1493
WTERMSIG(status));
1494
free(fullname);
1495
continue;
1496
} else {
1497
fprintf(stderr, "Mandos plugin mandos-client: "
1498
"Warning: network hook \"%s\" crashed\n",
1499
direntry->d_name);
1500
free(fullname);
1501
continue;
1502
}
1503
}
1504
free(fullname);
1505
if(quit_now){
1506
break;
1507
}
1508
}
1509
close(devnull);
1510
}
1511
return true;
1734
perror_plus("setenv");
1735
_exit(EX_OSERR);
1736
}
1737
free(delaystring);
1738
if(connect_to != NULL){
1739
ret = setenv("CONNECT", connect_to, 1);
1740
if(ret == -1){
1741
perror_plus("setenv");
1742
_exit(EX_OSERR);
1743
}
1744
}
1745
int hook_fd = openat(hookdir_fd, direntry->d_name, O_RDONLY);
1746
if(hook_fd == -1){
1747
perror_plus("openat");
1748
_exit(EXIT_FAILURE);
1749
}
1750
if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
1751
perror_plus("close");
1752
_exit(EXIT_FAILURE);
1753
}
1754
if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
1755
environ) == -1){
1756
perror_plus("fexecve");
1757
_exit(EXIT_FAILURE);
1758
}
1759
} else {
1760
if(hook_pid == -1){
1761
perror_plus("fork");
1762
free(direntry);
1763
continue;
1764
}
1765
int status;
1766
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1767
perror_plus("waitpid");
1768
free(direntry);
1769
continue;
1770
}
1771
if(WIFEXITED(status)){
1772
if(WEXITSTATUS(status) != 0){
1773
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1774
" with status %d\n", direntry->d_name,
1775
WEXITSTATUS(status));
1776
free(direntry);
1777
continue;
1778
}
1779
} else if(WIFSIGNALED(status)){
1780
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1781
" signal %d\n", direntry->d_name,
1782
WTERMSIG(status));
1783
free(direntry);
1784
continue;
1785
} else {
1786
fprintf_plus(stderr, "Warning: network hook \"%s\""
1787
" crashed\n", direntry->d_name);
1788
free(direntry);
1789
continue;
1790
}
1791
}
1792
if(debug){
1793
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1794
direntry->d_name);
1795
}
1796
free(direntry);
1797
}
1798
free(direntries);
1799
if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
1800
perror_plus("close");
1801
} else {
1802
hookdir_fd = -1;
1803
}
1804
close(devnull);
1805
}
1806
1807
__attribute__((nonnull, warn_unused_result))
1808
error_t bring_up_interface(const char *const interface,
1809
const float delay){
1810
error_t old_errno = errno;
1811
int ret;
1812
struct ifreq network;
1813
unsigned int if_index = if_nametoindex(interface);
1814
if(if_index == 0){
1815
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1816
errno = old_errno;
1817
return ENXIO;
1818
}
1819
1820
if(quit_now){
1821
errno = old_errno;
1822
return EINTR;
1823
}
1824
1825
if(not interface_is_up(interface)){
1826
error_t ret_errno = 0, ioctl_errno = 0;
1827
if(not get_flags(interface, &network)){
1828
ret_errno = errno;
1829
fprintf_plus(stderr, "Failed to get flags for interface "
1830
"\"%s\"\n", interface);
1831
errno = old_errno;
1832
return ret_errno;
1833
}
1834
network.ifr_flags |= IFF_UP; /* set flag */
1835
1836
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1837
if(sd == -1){
1838
ret_errno = errno;
1839
perror_plus("socket");
1840
errno = old_errno;
1841
return ret_errno;
1842
}
1843
1844
if(quit_now){
1845
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1846
if(ret == -1){
1847
perror_plus("close");
1848
}
1849
errno = old_errno;
1850
return EINTR;
1851
}
1852
1853
if(debug){
1854
fprintf_plus(stderr, "Bringing up interface \"%s\"\n",
1855
interface);
1856
}
1857
1858
/* Raise privileges */
1859
ret_errno = raise_privileges();
1860
if(ret_errno != 0){
1861
errno = ret_errno;
1862
perror_plus("Failed to raise privileges");
1863
}
1864
1865
#ifdef __linux__
1866
int ret_linux;
1867
bool restore_loglevel = false;
1868
if(ret_errno == 0){
1869
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1870
messages about the network interface to mess up the prompt */
1871
ret_linux = klogctl(8, NULL, 5);
1872
if(ret_linux == -1){
1873
perror_plus("klogctl");
1874
} else {
1875
restore_loglevel = true;
1876
}
1877
}
1878
#endif /* __linux__ */
1879
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1880
ioctl_errno = errno;
1881
#ifdef __linux__
1882
if(restore_loglevel){
1883
ret_linux = klogctl(7, NULL, 0);
1884
if(ret_linux == -1){
1885
perror_plus("klogctl");
1886
}
1887
}
1888
#endif /* __linux__ */
1889
1890
/* If raise_privileges() succeeded above */
1891
if(ret_errno == 0){
1892
/* Lower privileges */
1893
ret_errno = lower_privileges();
1894
if(ret_errno != 0){
1895
errno = ret_errno;
1896
perror_plus("Failed to lower privileges");
1897
}
1898
}
1899
1900
/* Close the socket */
1901
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1902
if(ret == -1){
1903
perror_plus("close");
1904
}
1905
1906
if(ret_setflags == -1){
1907
errno = ioctl_errno;
1908
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1909
errno = old_errno;
1910
return ioctl_errno;
1911
}
1912
} else if(debug){
1913
fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
1914
interface);
1915
}
1916
1917
/* Sleep checking until interface is running.
1918
Check every 0.25s, up to total time of delay */
1919
for(int i=0; i < delay * 4; i++){
1920
if(interface_is_running(interface)){
1921
break;
1922
}
1923
struct timespec sleeptime = { .tv_nsec = 250000000 };
1924
ret = nanosleep(&sleeptime, NULL);
1925
if(ret == -1 and errno != EINTR){
1926
perror_plus("nanosleep");
1927
}
1928
}
1929
1930
errno = old_errno;
1931
return 0;
1932
}
1933
1934
__attribute__((nonnull, warn_unused_result))
1935
error_t take_down_interface(const char *const interface){
1936
error_t old_errno = errno;
1937
struct ifreq network;
1938
unsigned int if_index = if_nametoindex(interface);
1939
if(if_index == 0){
1940
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1941
errno = old_errno;
1942
return ENXIO;
1943
}
1944
if(interface_is_up(interface)){
1945
error_t ret_errno = 0, ioctl_errno = 0;
1946
if(not get_flags(interface, &network) and debug){
1947
ret_errno = errno;
1948
fprintf_plus(stderr, "Failed to get flags for interface "
1949
"\"%s\"\n", interface);
1950
errno = old_errno;
1951
return ret_errno;
1952
}
1953
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
1954
1955
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1956
if(sd == -1){
1957
ret_errno = errno;
1958
perror_plus("socket");
1959
errno = old_errno;
1960
return ret_errno;
1961
}
1962
1963
if(debug){
1964
fprintf_plus(stderr, "Taking down interface \"%s\"\n",
1965
interface);
1966
}
1967
1968
/* Raise privileges */
1969
ret_errno = raise_privileges();
1970
if(ret_errno != 0){
1971
errno = ret_errno;
1972
perror_plus("Failed to raise privileges");
1973
}
1974
1975
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1976
ioctl_errno = errno;
1977
1978
/* If raise_privileges() succeeded above */
1979
if(ret_errno == 0){
1980
/* Lower privileges */
1981
ret_errno = lower_privileges();
1982
if(ret_errno != 0){
1983
errno = ret_errno;
1984
perror_plus("Failed to lower privileges");
1985
}
1986
}
1987
1988
/* Close the socket */
1989
int ret = (int)TEMP_FAILURE_RETRY(close(sd));
1990
if(ret == -1){
1991
perror_plus("close");
1992
}
1993
1994
if(ret_setflags == -1){
1995
errno = ioctl_errno;
1996
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
1997
errno = old_errno;
1998
return ioctl_errno;
1999
}
2000
} else if(debug){
2001
fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
2002
interface);
2003
}
2004
2005
errno = old_errno;
2006
return 0;
1512
2007
}
1513
2008
1514
2009
int main(int argc, char *argv[]){
2010
mandos_context mc = { .server = NULL, .dh_bits = 0,
2011
.priority = "SECURE256:!CTYPE-X.509:"
2012
"+CTYPE-OPENPGP:!RSA", .current_server = NULL,
2013
.interfaces = NULL, .interfaces_size = 0 };
1515
2014
AvahiSServiceBrowser *sb = NULL;
1516
int error;
2015
error_t ret_errno;
1517
2016
int ret;
1518
2017
intmax_t tmpmax;
1519
2018
char *tmp;
1520
2019
int exitcode = EXIT_SUCCESS;
1521
const char *interface = "";
1522
struct ifreq network;
1523
int sd = -1;
1524
bool take_down_interface = false;
1525
uid_t uid;
1526
gid_t gid;
1527
char tempdir[] = "/tmp/mandosXXXXXX";
1528
bool tempdir_created = false;
2020
char *interfaces_to_take_down = NULL;
2021
size_t interfaces_to_take_down_size = 0;
2022
char run_tempdir[] = "/run/tmp/mandosXXXXXX";
2023
char old_tempdir[] = "/tmp/mandosXXXXXX";
2024
char *tempdir = NULL;
1529
2025
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1530
2026
const char *seckey = PATHDIR "/" SECKEY;
1531
2027
const char *pubkey = PATHDIR "/" PUBKEY;
2028
char *interfaces_hooks = NULL;
1532
2029
1533
2030
bool gnutls_initialized = false;
1534
2031
bool gpgme_initialized = false;
1596
2093
.group = 2 },
1597
2094
{ .name = "retry", .key = 132,
1598
2095
.arg = "SECONDS",
1599
.doc = "Retry interval used when denied by the mandos server",
2096
.doc = "Retry interval used when denied by the Mandos server",
1600
2097
.group = 2 },
1601
2098
{ .name = "network-hook-dir", .key = 133,
1602
2099
.arg = "DIR",
1625
2122
connect_to = arg;
1626
2123
break;
1627
2124
case 'i': /* --interface */
1628
interface = arg;
2125
ret_errno = argz_add_sep(&mc.interfaces, &mc.interfaces_size,
2126
arg, (int)',');
2127
if(ret_errno != 0){
2128
argp_error(state, "%s", strerror(ret_errno));
2129
}
1629
2130
break;
1630
2131
case 's': /* --seckey */
1631
2132
seckey = arg;
1674
2175
argp_state_help(state, state->out_stream,
1675
2176
ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
1676
2177
case 'V': /* --version */
1677
fprintf(state->out_stream, "Mandos plugin mandos-client: ");
1678
fprintf(state->out_stream, "%s\n", argp_program_version);
2178
fprintf_plus(state->out_stream, "%s\n", argp_program_version);
1679
2179
exit(argp_err_exit_status);
1680
2180
break;
1681
2181
default:
1708
2208
{
1709
2209
/* Work around Debian bug #633582:
1710
2210
<http://bugs.debian.org/633582> */
1711
struct stat st;
1712
1713
/* Re-raise priviliges */
1714
errno = 0;
1715
ret = seteuid(0);
1716
if(ret == -1){
1717
perror_plus("seteuid");
1718
}
1719
1720
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
1721
int seckey_fd = open(seckey, O_RDONLY);
1722
if(seckey_fd == -1){
1723
perror_plus("open");
1724
} else {
1725
ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
1726
if(ret == -1){
1727
perror_plus("fstat");
1728
} else {
1729
if(S_ISREG(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
1730
ret = fchown(seckey_fd, uid, gid);
1731
if(ret == -1){
1732
perror_plus("fchown");
1733
}
1734
}
1735
}
1736
TEMP_FAILURE_RETRY(close(seckey_fd));
1737
}
1738
}
1739
1740
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
1741
int pubkey_fd = open(pubkey, O_RDONLY);
1742
if(pubkey_fd == -1){
1743
perror_plus("open");
1744
} else {
1745
ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
1746
if(ret == -1){
1747
perror_plus("fstat");
1748
} else {
1749
if(S_ISREG(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
1750
ret = fchown(pubkey_fd, uid, gid);
1751
if(ret == -1){
1752
perror_plus("fchown");
1753
}
1754
}
1755
}
1756
TEMP_FAILURE_RETRY(close(pubkey_fd));
1757
}
1758
}
1759
1760
/* Lower privileges */
1761
errno = 0;
1762
ret = seteuid(uid);
1763
if(ret == -1){
1764
perror_plus("seteuid");
2211
2212
/* Re-raise privileges */
2213
ret_errno = raise_privileges();
2214
if(ret_errno != 0){
2215
errno = ret_errno;
2216
perror_plus("Failed to raise privileges");
2217
} else {
2218
struct stat st;
2219
2220
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
2221
int seckey_fd = open(seckey, O_RDONLY);
2222
if(seckey_fd == -1){
2223
perror_plus("open");
2224
} else {
2225
ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
2226
if(ret == -1){
2227
perror_plus("fstat");
2228
} else {
2229
if(S_ISREG(st.st_mode)
2230
and st.st_uid == 0 and st.st_gid == 0){
2231
ret = fchown(seckey_fd, uid, gid);
2232
if(ret == -1){
2233
perror_plus("fchown");
2234
}
2235
}
2236
}
2237
TEMP_FAILURE_RETRY(close(seckey_fd));
2238
}
2239
}
2240
2241
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2242
int pubkey_fd = open(pubkey, O_RDONLY);
2243
if(pubkey_fd == -1){
2244
perror_plus("open");
2245
} else {
2246
ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
2247
if(ret == -1){
2248
perror_plus("fstat");
2249
} else {
2250
if(S_ISREG(st.st_mode)
2251
and st.st_uid == 0 and st.st_gid == 0){
2252
ret = fchown(pubkey_fd, uid, gid);
2253
if(ret == -1){
2254
perror_plus("fchown");
2255
}
2256
}
2257
}
2258
TEMP_FAILURE_RETRY(close(pubkey_fd));
2259
}
2260
}
2261
2262
/* Lower privileges */
2263
ret_errno = lower_privileges();
2264
if(ret_errno != 0){
2265
errno = ret_errno;
2266
perror_plus("Failed to lower privileges");
2267
}
2268
}
2269
}
2270
2271
/* Remove invalid interface names (except "none") */
2272
{
2273
char *interface = NULL;
2274
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2275
interface))){
2276
if(strcmp(interface, "none") != 0
2277
and if_nametoindex(interface) == 0){
2278
if(interface[0] != '\0'){
2279
fprintf_plus(stderr, "Not using nonexisting interface"
2280
" \"%s\"\n", interface);
2281
}
2282
argz_delete(&mc.interfaces, &mc.interfaces_size, interface);
2283
interface = NULL;
2284
}
1765
2285
}
1766
2286
}
1767
2287
1768
2288
/* Run network hooks */
1769
2289
{
1770
/* Re-raise priviliges */
1771
errno = 0;
1772
ret = seteuid(0);
1773
if(ret == -1){
1774
perror_plus("seteuid");
1775
}
1776
if(not run_network_hooks("start", interface, delay)){
1777
goto end;
1778
}
1779
/* Lower privileges */
1780
errno = 0;
1781
ret = seteuid(uid);
1782
if(ret == -1){
1783
perror_plus("seteuid");
1784
}
2290
if(mc.interfaces != NULL){
2291
interfaces_hooks = malloc(mc.interfaces_size);
2292
if(interfaces_hooks == NULL){
2293
perror_plus("malloc");
2294
goto end;
2295
}
2296
memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
2297
argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
2298
}
2299
run_network_hooks("start", interfaces_hooks != NULL ?
2300
interfaces_hooks : "", delay);
1785
2301
}
1786
2302
1787
2303
if(not debug){
1788
2304
avahi_set_log_function(empty_log);
1789
2305
}
1790
2306
1791
if(interface[0] == '\0'){
1792
struct dirent **direntries;
1793
/* First look for interfaces that are up */
1794
ret = scandir(sys_class_net, &direntries, up_interface,
1795
alphasort);
1796
if(ret == 0){
1797
/* No up interfaces, look for any good interfaces */
1798
free(direntries);
1799
ret = scandir(sys_class_net, &direntries, good_interface,
1800
alphasort);
1801
}
1802
if(ret >= 1){
1803
/* Pick the first interface returned */
1804
interface = strdup(direntries[0]->d_name);
1805
if(debug){
1806
fprintf(stderr, "Mandos plugin mandos-client: "
1807
"Using interface \"%s\"\n", interface);
1808
}
1809
if(interface == NULL){
1810
perror_plus("malloc");
1811
free(direntries);
1812
exitcode = EXIT_FAILURE;
1813
goto end;
1814
}
1815
free(direntries);
1816
} else {
1817
free(direntries);
1818
fprintf(stderr, "Mandos plugin mandos-client: "
1819
"Could not find a network interface\n");
1820
exitcode = EXIT_FAILURE;
1821
goto end;
1822
}
1823
}
1824
1825
2307
/* Initialize Avahi early so avahi_simple_poll_quit() can be called
1826
2308
from the signal handler */
1827
2309
/* Initialize the pseudo-RNG for Avahi */
1828
2310
srand((unsigned int) time(NULL));
1829
mc.simple_poll = avahi_simple_poll_new();
1830
if(mc.simple_poll == NULL){
1831
fprintf(stderr, "Mandos plugin mandos-client: "
1832
"Avahi: Failed to create simple poll object.\n");
2311
simple_poll = avahi_simple_poll_new();
2312
if(simple_poll == NULL){
2313
fprintf_plus(stderr,
2314
"Avahi: Failed to create simple poll object.\n");
1833
2315
exitcode = EX_UNAVAILABLE;
1834
2316
goto end;
1835
2317
}
1897
2379
}
1898
2380
}
1899
2381
1900
/* If the interface is down, bring it up */
1901
if(strcmp(interface, "none") != 0){
1902
if_index = (AvahiIfIndex) if_nametoindex(interface);
1903
if(if_index == 0){
1904
fprintf(stderr, "Mandos plugin mandos-client: "
1905
"No such interface: \"%s\"\n", interface);
1906
exitcode = EX_UNAVAILABLE;
1907
goto end;
1908
}
1909
1910
if(quit_now){
1911
goto end;
1912
}
1913
1914
/* Re-raise priviliges */
1915
errno = 0;
1916
ret = seteuid(0);
1917
if(ret == -1){
1918
perror_plus("seteuid");
1919
}
1920
1921
#ifdef __linux__
1922
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1923
messages about the network interface to mess up the prompt */
1924
ret = klogctl(8, NULL, 5);
1925
bool restore_loglevel = true;
1926
if(ret == -1){
1927
restore_loglevel = false;
1928
perror_plus("klogctl");
1929
}
1930
#endif /* __linux__ */
1931
1932
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1933
if(sd < 0){
1934
perror_plus("socket");
1935
exitcode = EX_OSERR;
1936
#ifdef __linux__
1937
if(restore_loglevel){
1938
ret = klogctl(7, NULL, 0);
1939
if(ret == -1){
1940
perror_plus("klogctl");
1941
}
1942
}
1943
#endif /* __linux__ */
1944
/* Lower privileges */
1945
errno = 0;
1946
ret = seteuid(uid);
1947
if(ret == -1){
1948
perror_plus("seteuid");
1949
}
1950
goto end;
1951
}
1952
strcpy(network.ifr_name, interface);
1953
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1954
if(ret == -1){
1955
perror_plus("ioctl SIOCGIFFLAGS");
1956
#ifdef __linux__
1957
if(restore_loglevel){
1958
ret = klogctl(7, NULL, 0);
1959
if(ret == -1){
1960
perror_plus("klogctl");
1961
}
1962
}
1963
#endif /* __linux__ */
1964
exitcode = EX_OSERR;
1965
/* Lower privileges */
1966
errno = 0;
1967
ret = seteuid(uid);
1968
if(ret == -1){
1969
perror_plus("seteuid");
1970
}
1971
goto end;
1972
}
1973
if((network.ifr_flags & IFF_UP) == 0){
1974
network.ifr_flags |= IFF_UP;
1975
take_down_interface = true;
1976
ret = ioctl(sd, SIOCSIFFLAGS, &network);
1977
if(ret == -1){
1978
take_down_interface = false;
1979
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1980
exitcode = EX_OSERR;
1981
#ifdef __linux__
1982
if(restore_loglevel){
1983
ret = klogctl(7, NULL, 0);
1984
if(ret == -1){
1985
perror_plus("klogctl");
2382
/* If no interfaces were specified, make a list */
2383
if(mc.interfaces == NULL){
2384
struct dirent **direntries = NULL;
2385
/* Look for any good interfaces */
2386
ret = scandir(sys_class_net, &direntries, good_interface,
2387
alphasort);
2388
if(ret >= 1){
2389
/* Add all found interfaces to interfaces list */
2390
for(int i = 0; i < ret; ++i){
2391
ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
2392
direntries[i]->d_name);
2393
if(ret_errno != 0){
2394
errno = ret_errno;
2395
perror_plus("argz_add");
2396
free(direntries[i]);
2397
continue;
2398
}
2399
if(debug){
2400
fprintf_plus(stderr, "Will use interface \"%s\"\n",
2401
direntries[i]->d_name);
2402
}
2403
free(direntries[i]);
2404
}
2405
free(direntries);
2406
} else {
2407
if(ret == 0){
2408
free(direntries);
2409
}
2410
fprintf_plus(stderr, "Could not find a network interface\n");
2411
exitcode = EXIT_FAILURE;
2412
goto end;
2413
}
2414
}
2415
2416
/* Bring up interfaces which are down, and remove any "none"s */
2417
{
2418
char *interface = NULL;
2419
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2420
interface))){
2421
/* If interface name is "none", stop bringing up interfaces.
2422
Also remove all instances of "none" from the list */
2423
if(strcmp(interface, "none") == 0){
2424
argz_delete(&mc.interfaces, &mc.interfaces_size,
2425
interface);
2426
interface = NULL;
2427
while((interface = argz_next(mc.interfaces,
2428
mc.interfaces_size, interface))){
2429
if(strcmp(interface, "none") == 0){
2430
argz_delete(&mc.interfaces, &mc.interfaces_size,
2431
interface);
2432
interface = NULL;
1986
2433
}
1987
2434
}
1988
#endif /* __linux__ */
1989
/* Lower privileges */
1990
errno = 0;
1991
ret = seteuid(uid);
1992
if(ret == -1){
1993
perror_plus("seteuid");
1994
}
1995
goto end;
1996
}
1997
}
1998
/* Sleep checking until interface is running.
1999
Check every 0.25s, up to total time of delay */
2000
for(int i=0; i < delay * 4; i++){
2001
ret = ioctl(sd, SIOCGIFFLAGS, &network);
2002
if(ret == -1){
2003
perror_plus("ioctl SIOCGIFFLAGS");
2004
} else if(network.ifr_flags & IFF_RUNNING){
2005
2435
break;
2006
2436
}
2007
struct timespec sleeptime = { .tv_nsec = 250000000 };
2008
ret = nanosleep(&sleeptime, NULL);
2009
if(ret == -1 and errno != EINTR){
2010
perror_plus("nanosleep");
2011
}
2012
}
2013
if(not take_down_interface){
2014
/* We won't need the socket anymore */
2015
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2016
if(ret == -1){
2017
perror_plus("close");
2018
}
2019
}
2020
#ifdef __linux__
2021
if(restore_loglevel){
2022
/* Restores kernel loglevel to default */
2023
ret = klogctl(7, NULL, 0);
2024
if(ret == -1){
2025
perror_plus("klogctl");
2026
}
2027
}
2028
#endif /* __linux__ */
2029
/* Lower privileges */
2030
errno = 0;
2031
/* Lower privileges */
2032
ret = seteuid(uid);
2033
if(ret == -1){
2034
perror_plus("seteuid");
2035
}
2437
bool interface_was_up = interface_is_up(interface);
2438
errno = bring_up_interface(interface, delay);
2439
if(not interface_was_up){
2440
if(errno != 0){
2441
perror_plus("Failed to bring up interface");
2442
} else {
2443
errno = argz_add(&interfaces_to_take_down,
2444
&interfaces_to_take_down_size,
2445
interface);
2446
if(errno != 0){
2447
perror_plus("argz_add");
2448
}
2449
}
2450
}
2451
}
2452
if(debug and (interfaces_to_take_down == NULL)){
2453
fprintf_plus(stderr, "No interfaces were brought up\n");
2454
}
2455
}
2456
2457
/* If we only got one interface, explicitly use only that one */
2458
if(argz_count(mc.interfaces, mc.interfaces_size) == 1){
2459
if(debug){
2460
fprintf_plus(stderr, "Using only interface \"%s\"\n",
2461
mc.interfaces);
2462
}
2463
if_index = (AvahiIfIndex)if_nametoindex(mc.interfaces);
2036
2464
}
2037
2465
2038
2466
if(quit_now){
2039
2467
goto end;
2040
2468
}
2041
2469
2042
ret = init_gnutls_global(pubkey, seckey);
2470
ret = init_gnutls_global(pubkey, seckey, &mc);
2043
2471
if(ret == -1){
2044
fprintf(stderr, "Mandos plugin mandos-client: "
2045
"init_gnutls_global failed\n");
2472
fprintf_plus(stderr, "init_gnutls_global failed\n");
2046
2473
exitcode = EX_UNAVAILABLE;
2047
2474
goto end;
2048
2475
} else {
2053
2480
goto end;
2054
2481
}
2055
2482
2056
if(mkdtemp(tempdir) == NULL){
2483
/* Try /run/tmp before /tmp */
2484
tempdir = mkdtemp(run_tempdir);
2485
if(tempdir == NULL and errno == ENOENT){
2486
if(debug){
2487
fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
2488
run_tempdir, old_tempdir);
2489
}
2490
tempdir = mkdtemp(old_tempdir);
2491
}
2492
if(tempdir == NULL){
2057
2493
perror_plus("mkdtemp");
2058
2494
goto end;
2059
2495
}
2060
tempdir_created = true;
2061
2496
2062
2497
if(quit_now){
2063
2498
goto end;
2064
2499
}
2065
2500
2066
if(not init_gpgme(pubkey, seckey, tempdir)){
2067
fprintf(stderr, "Mandos plugin mandos-client: "
2068
"init_gpgme failed\n");
2501
if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
2502
fprintf_plus(stderr, "init_gpgme failed\n");
2069
2503
exitcode = EX_UNAVAILABLE;
2070
2504
goto end;
2071
2505
} else {
2080
2514
/* Connect directly, do not use Zeroconf */
2081
2515
/* (Mainly meant for debugging) */
2082
2516
char *address = strrchr(connect_to, ':');
2517
2083
2518
if(address == NULL){
2084
fprintf(stderr, "Mandos plugin mandos-client: "
2085
"No colon in address\n");
2519
fprintf_plus(stderr, "No colon in address\n");
2086
2520
exitcode = EX_USAGE;
2087
2521
goto end;
2088
2522
}
2091
2525
goto end;
2092
2526
}
2093
2527
2094
uint16_t port;
2528
in_port_t port;
2095
2529
errno = 0;
2096
2530
tmpmax = strtoimax(address+1, &tmp, 10);
2097
2531
if(errno != 0 or tmp == address+1 or *tmp != '\0'
2098
or tmpmax != (uint16_t)tmpmax){
2099
fprintf(stderr, "Mandos plugin mandos-client: "
2100
"Bad port number\n");
2532
or tmpmax != (in_port_t)tmpmax){
2533
fprintf_plus(stderr, "Bad port number\n");
2101
2534
exitcode = EX_USAGE;
2102
2535
goto end;
2103
2536
}
2104
2537
2105
2538
if(quit_now){
2106
2539
goto end;
2107
2540
}
2108
2541
2109
port = (uint16_t)tmpmax;
2542
port = (in_port_t)tmpmax;
2110
2543
*address = '\0';
2111
2544
/* Colon in address indicates IPv6 */
2112
2545
int af;
2128
2561
}
2129
2562
2130
2563
while(not quit_now){
2131
ret = start_mandos_communication(address, port, if_index, af);
2564
ret = start_mandos_communication(address, port, if_index, af,
2565
&mc);
2132
2566
if(quit_now or ret == 0){
2133
2567
break;
2134
2568
}
2135
2569
if(debug){
2136
fprintf(stderr, "Mandos plugin mandos-client: "
2137
"Retrying in %d seconds\n", (int)retry_interval);
2570
fprintf_plus(stderr, "Retrying in %d seconds\n",
2571
(int)retry_interval);
2138
2572
}
2139
sleep((int)retry_interval);
2573
sleep((unsigned int)retry_interval);
2140
2574
}
2141
2575
2142
if (not quit_now){
2576
if(not quit_now){
2143
2577
exitcode = EXIT_SUCCESS;
2144
2578
}
2145
2579
2160
2594
config.publish_domain = 0;
2161
2595
2162
2596
/* Allocate a new server */
2163
mc.server = avahi_server_new(avahi_simple_poll_get
2164
(mc.simple_poll), &config, NULL,
2165
NULL, &error);
2597
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
2598
&config, NULL, NULL, &ret_errno);
2166
2599
2167
2600
/* Free the Avahi configuration data */
2168
2601
avahi_server_config_free(&config);
2170
2603
2171
2604
/* Check if creating the Avahi server object succeeded */
2172
2605
if(mc.server == NULL){
2173
fprintf(stderr, "Mandos plugin mandos-client: "
2174
"Failed to create Avahi server: %s\n",
2175
avahi_strerror(error));
2606
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2607
avahi_strerror(ret_errno));
2176
2608
exitcode = EX_UNAVAILABLE;
2177
2609
goto end;
2178
2610
}
2184
2616
/* Create the Avahi service browser */
2185
2617
sb = avahi_s_service_browser_new(mc.server, if_index,
2186
2618
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
2187
NULL, 0, browse_callback, NULL);
2619
NULL, 0, browse_callback,
2620
(void *)&mc);
2188
2621
if(sb == NULL){
2189
fprintf(stderr, "Mandos plugin mandos-client: "
2190
"Failed to create service browser: %s\n",
2191
avahi_strerror(avahi_server_errno(mc.server)));
2622
fprintf_plus(stderr, "Failed to create service browser: %s\n",
2623
avahi_strerror(avahi_server_errno(mc.server)));
2192
2624
exitcode = EX_UNAVAILABLE;
2193
2625
goto end;
2194
2626
}
2200
2632
/* Run the main loop */
2201
2633
2202
2634
if(debug){
2203
fprintf(stderr, "Mandos plugin mandos-client: "
2204
"Starting Avahi loop search\n");
2635
fprintf_plus(stderr, "Starting Avahi loop search\n");
2205
2636
}
2206
2207
ret = avahi_loop_with_timeout(mc.simple_poll,
2208
(int)(retry_interval * 1000));
2637
2638
ret = avahi_loop_with_timeout(simple_poll,
2639
(int)(retry_interval * 1000), &mc);
2209
2640
if(debug){
2210
fprintf(stderr, "Mandos plugin mandos-client: "
2211
"avahi_loop_with_timeout exited %s\n",
2212
(ret == 0) ? "successfully" : "with error");
2641
fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
2642
(ret == 0) ? "successfully" : "with error");
2213
2643
}
2214
2644
2215
2645
end:
2216
2646
2217
2647
if(debug){
2218
fprintf(stderr, "Mandos plugin mandos-client: "
2219
"%s exiting\n", argv[0]);
2648
fprintf_plus(stderr, "%s exiting\n", argv[0]);
2220
2649
}
2221
2650
2222
2651
/* Cleanup things */
2652
free(mc.interfaces);
2653
2223
2654
if(sb != NULL)
2224
2655
avahi_s_service_browser_free(sb);
2225
2656
2226
2657
if(mc.server != NULL)
2227
2658
avahi_server_free(mc.server);
2228
2659
2229
if(mc.simple_poll != NULL)
2230
avahi_simple_poll_free(mc.simple_poll);
2660
if(simple_poll != NULL)
2661
avahi_simple_poll_free(simple_poll);
2231
2662
2232
2663
if(gnutls_initialized){
2233
2664
gnutls_certificate_free_credentials(mc.cred);
2238
2669
if(gpgme_initialized){
2239
2670
gpgme_release(mc.ctx);
2240
2671
}
2241
2672
2242
2673
/* Cleans up the circular linked list of Mandos servers the client
2243
2674
has seen */
2244
2675
if(mc.current_server != NULL){
2245
2676
mc.current_server->prev->next = NULL;
2246
2677
while(mc.current_server != NULL){
2247
2678
server *next = mc.current_server->next;
2679
#ifdef __GNUC__
2680
#pragma GCC diagnostic push
2681
#pragma GCC diagnostic ignored "-Wcast-qual"
2682
#endif
2683
free((char *)(mc.current_server->ip));
2684
#ifdef __GNUC__
2685
#pragma GCC diagnostic pop
2686
#endif
2248
2687
free(mc.current_server);
2249
2688
mc.current_server = next;
2250
2689
}
2251
2690
}
2252
2691
2253
/* Re-raise priviliges */
2692
/* Re-raise privileges */
2254
2693
{
2255
errno = 0;
2256
ret = seteuid(0);
2257
if(ret == -1){
2258
perror_plus("seteuid");
2259
}
2260
/* Run network hooks */
2261
if(not run_network_hooks("stop", interface, delay)){
2262
goto end;
2694
ret_errno = raise_privileges();
2695
if(ret_errno != 0){
2696
errno = ret_errno;
2697
perror_plus("Failed to raise privileges");
2698
} else {
2699
2700
/* Run network hooks */
2701
run_network_hooks("stop", interfaces_hooks != NULL ?
2702
interfaces_hooks : "", delay);
2703
2704
/* Take down the network interfaces which were brought up */
2705
{
2706
char *interface = NULL;
2707
while((interface=argz_next(interfaces_to_take_down,
2708
interfaces_to_take_down_size,
2709
interface))){
2710
ret_errno = take_down_interface(interface);
2711
if(ret_errno != 0){
2712
errno = ret_errno;
2713
perror_plus("Failed to take down interface");
2714
}
2715
}
2716
if(debug and (interfaces_to_take_down == NULL)){
2717
fprintf_plus(stderr, "No interfaces needed to be taken"
2718
" down\n");
2719
}
2720
}
2263
2721
}
2264
2722
2265
/* Take down the network interface */
2266
if(take_down_interface and geteuid() == 0){
2267
ret = ioctl(sd, SIOCGIFFLAGS, &network);
2268
if(ret == -1){
2269
perror_plus("ioctl SIOCGIFFLAGS");
2270
} else if(network.ifr_flags & IFF_UP){
2271
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
2272
ret = ioctl(sd, SIOCSIFFLAGS, &network);
2273
if(ret == -1){
2274
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
2275
}
2276
}
2277
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2278
if(ret == -1){
2279
perror_plus("close");
2280
}
2723
ret_errno = lower_privileges_permanently();
2724
if(ret_errno != 0){
2725
errno = ret_errno;
2726
perror_plus("Failed to lower privileges permanently");
2281
2727
}
2282
2728
}
2283
/* Lower privileges permanently */
2284
errno = 0;
2285
ret = setuid(uid);
2286
if(ret == -1){
2287
perror_plus("setuid");
2288
}
2729
2730
free(interfaces_to_take_down);
2731
free(interfaces_hooks);
2289
2732
2290
2733
/* Removes the GPGME temp directory and all files inside */
2291
if(tempdir_created){
2734
if(tempdir != NULL){
2292
2735
struct dirent **direntries = NULL;
2293
struct dirent *direntry = NULL;
2294
int numentries = scandir(tempdir, &direntries, notdotentries,
2295
alphasort);
2296
if (numentries > 0){
2297
for(int i = 0; i < numentries; i++){
2298
direntry = direntries[i];
2299
char *fullname = NULL;
2300
ret = asprintf(&fullname, "%s/%s", tempdir,
2301
direntry->d_name);
2302
if(ret < 0){
2303
perror_plus("asprintf");
2304
continue;
2305
}
2306
ret = remove(fullname);
2307
if(ret == -1){
2308
fprintf(stderr, "Mandos plugin mandos-client: "
2309
"remove(\"%s\"): %s\n", fullname, strerror(errno));
2310
}
2311
free(fullname);
2736
int tempdir_fd = (int)TEMP_FAILURE_RETRY(open(tempdir, O_RDONLY |
2737
O_NOFOLLOW));
2738
if(tempdir_fd == -1){
2739
perror_plus("open");
2740
} else {
2741
#ifdef __GLIBC__
2742
#if __GLIBC_PREREQ(2, 15)
2743
int numentries = scandirat(tempdir_fd, ".", &direntries,
2744
notdotentries, alphasort);
2745
#else /* not __GLIBC_PREREQ(2, 15) */
2746
int numentries = scandir(tempdir, &direntries, notdotentries,
2747
alphasort);
2748
#endif /* not __GLIBC_PREREQ(2, 15) */
2749
#else /* not __GLIBC__ */
2750
int numentries = scandir(tempdir, &direntries, notdotentries,
2751
alphasort);
2752
#endif /* not __GLIBC__ */
2753
if(numentries >= 0){
2754
for(int i = 0; i < numentries; i++){
2755
ret = unlinkat(tempdir_fd, direntries[i]->d_name, 0);
2756
if(ret == -1){
2757
fprintf_plus(stderr, "unlinkat(open(\"%s\", O_RDONLY),"
2758
" \"%s\", 0): %s\n", tempdir,
2759
direntries[i]->d_name, strerror(errno));
2760
}
2761
free(direntries[i]);
2762
}
2763
2764
/* need to clean even if 0 because man page doesn't specify */
2765
free(direntries);
2766
if(numentries == -1){
2767
perror_plus("scandir");
2768
}
2769
ret = rmdir(tempdir);
2770
if(ret == -1 and errno != ENOENT){
2771
perror_plus("rmdir");
2772
}
2312
2773
}
2313
}
2314
2315
/* need to clean even if 0 because man page doesn't specify */
2316
free(direntries);
2317
if (numentries == -1){
2318
perror_plus("scandir");
2319
}
2320
ret = rmdir(tempdir);
2321
if(ret == -1 and errno != ENOENT){
2322
perror_plus("rmdir");
2774
TEMP_FAILURE_RETRY(close(tempdir_fd));
2323
2775
}
2324
2776
}
2325
2777
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0