To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to plugins.d/mandos-client.c
- browse files at revision 12
- compare with another revision
- download diff
- download tarball
- view history from revision 12
- Committer: Teddy Hogeborn
- Date: 2008-07-19 18:43:24 UTC
- Revision ID: teddy@fukt.bsnet.se-20080719184324-iwhoa5in75xa0u2u
* mandos-clients.conf ([foo]/dn, [foo]/password, [braxen_client]/dn,
[braxen_client]/password): Removed.
([foo]/fingerprint, [braxen_client]/fingerprint): New.
([foo]/checker): New.
([foo]/secfile): New.
([braxen_client]/secret): New.
* server.py: New "--debug" option to set debug flag. Removed "cert",
"key", "ca", "crl", and "cred" variables. Added default
value for "checker" config file setting. Do not pass
credentials to IPv6_TCPServer constructor.
(debug): New global debug flag. Used by most debugging output code.
(Client.__init__): Keyword argument "dn" replaced by "fingerprint",
"password" renamed to "secret", and "passfile"
renamed to "secfile". New keyword argument
"checker". All callers changed.
(Client.dn): Removed.
(Client.fingerprint): New.
(Client.password): Renamed to "secret"; all users changed.
(Client.passfile): Renamed to "secfile"; all users changed.
(Client.timeout, Client.interval): Changed to be properties; now
automatically updates the
"_timeout_milliseconds" and
"_interval_milliseconds" values.
(Client.timeout_milliseconds): Renamed to "_timeout_milliseconds".
(Client.interval_milliseconds): Renamed to "_interval_milliseconds".
(Client.check_command): New.
(Client.start_checker): Use the new "check_command" attribute.
(peer_certificate, fingerprint): New functions.
(tcp_handler.handle): Use ClientSession with empty credentials
object instead of ServerSession. Set gnutls
priority string. Do not verify peer. Use
fingerprint instead of DN when searching for
clients. Bug fix: Loop sending data so even large
secret data strings are sent.
(IPv6_TCPServer.credentials): Removed.
(if_nametoindex): Do not import ctypes since that is now imported
globally.
[braxen_client]/password): Removed.
([foo]/fingerprint, [braxen_client]/fingerprint): New.
([foo]/checker): New.
([foo]/secfile): New.
([braxen_client]/secret): New.
* server.py: New "--debug" option to set debug flag. Removed "cert",
"key", "ca", "crl", and "cred" variables. Added default
value for "checker" config file setting. Do not pass
credentials to IPv6_TCPServer constructor.
(debug): New global debug flag. Used by most debugging output code.
(Client.__init__): Keyword argument "dn" replaced by "fingerprint",
"password" renamed to "secret", and "passfile"
renamed to "secfile". New keyword argument
"checker". All callers changed.
(Client.dn): Removed.
(Client.fingerprint): New.
(Client.password): Renamed to "secret"; all users changed.
(Client.passfile): Renamed to "secfile"; all users changed.
(Client.timeout, Client.interval): Changed to be properties; now
automatically updates the
"_timeout_milliseconds" and
"_interval_milliseconds" values.
(Client.timeout_milliseconds): Renamed to "_timeout_milliseconds".
(Client.interval_milliseconds): Renamed to "_interval_milliseconds".
(Client.check_command): New.
(Client.start_checker): Use the new "check_command" attribute.
(peer_certificate, fingerprint): New functions.
(tcp_handler.handle): Use ClientSession with empty credentials
object instead of ServerSession. Set gnutls
priority string. Do not verify peer. Use
fingerprint instead of DN when searching for
clients. Bug fix: Loop sending data so even large
secret data strings are sent.
(IPv6_TCPServer.credentials): Removed.
(if_nametoindex): Do not import ctypes since that is now imported
globally.
- files added:
- ca.pem
- files removed:
- .bzr-builddeb
- debian
- debian/po
- debian/source
- debian/upstream
- network-hooks.d
- plugins.d
- files renamed:
- clients.conf => mandos-clients.conf
- mandos => server.py
- files modified:
- Makefile
added
removed
plugins.d/mandos-client.c
1
/* -*- coding: utf-8 -*- */
2
/*
3
* Mandos-client - get and decrypt data from a Mandos server
4
*
5
* This program is partly derived from an example program for an Avahi
6
* service browser, downloaded from
7
* <http://avahi.org/browser/examples/core-browse-services.c>. This
8
* includes the following functions: "resolve_callback",
9
* "browse_callback", and parts of "main".
10
*
11
* Everything else is
12
* Copyright © 2008-2014 Teddy Hogeborn
13
* Copyright © 2008-2014 Björn Påhlsson
14
*
15
* This program is free software: you can redistribute it and/or
16
* modify it under the terms of the GNU General Public License as
17
* published by the Free Software Foundation, either version 3 of the
18
* License, or (at your option) any later version.
19
*
20
* This program is distributed in the hope that it will be useful, but
21
* WITHOUT ANY WARRANTY; without even the implied warranty of
22
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23
* General Public License for more details.
24
*
25
* You should have received a copy of the GNU General Public License
26
* along with this program. If not, see
27
* <http://www.gnu.org/licenses/>.
28
*
29
* Contact the authors at <mandos@recompile.se>.
30
*/
31
32
/* Needed by GPGME, specifically gpgme_data_seek() */
33
#ifndef _LARGEFILE_SOURCE
34
#define _LARGEFILE_SOURCE
35
#endif /* not _LARGEFILE_SOURCE */
36
#ifndef _FILE_OFFSET_BITS
37
#define _FILE_OFFSET_BITS 64
38
#endif /* not _FILE_OFFSET_BITS */
39
40
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
41
42
#include <stdio.h> /* fprintf(), stderr, fwrite(),
43
stdout, ferror() */
44
#include <stdint.h> /* uint16_t, uint32_t, intptr_t */
45
#include <stddef.h> /* NULL, size_t, ssize_t */
46
#include <stdlib.h> /* free(), EXIT_SUCCESS, srand(),
47
strtof(), abort() */
48
#include <stdbool.h> /* bool, false, true */
49
#include <string.h> /* memset(), strcmp(), strlen(),
50
strerror(), asprintf(), strcpy() */
51
#include <sys/ioctl.h> /* ioctl */
52
#include <sys/types.h> /* socket(), inet_pton(), sockaddr,
53
sockaddr_in6, PF_INET6,
54
SOCK_STREAM, uid_t, gid_t, open(),
55
opendir(), DIR */
56
#include <sys/stat.h> /* open(), S_ISREG */
57
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
58
inet_pton(), connect(),
59
getnameinfo() */
60
#include <fcntl.h> /* open(), unlinkat() */
61
#include <dirent.h> /* opendir(), struct dirent, readdir()
62
*/
63
#include <inttypes.h> /* PRIu16, PRIdMAX, intmax_t,
64
strtoimax() */
65
#include <errno.h> /* perror(), errno,
66
program_invocation_short_name */
67
#include <time.h> /* nanosleep(), time(), sleep() */
68
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
69
SIOCSIFFLAGS, if_indextoname(),
70
if_nametoindex(), IF_NAMESIZE */
71
#include <netinet/in.h> /* IN6_IS_ADDR_LINKLOCAL,
72
INET_ADDRSTRLEN, INET6_ADDRSTRLEN
73
*/
74
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
75
getuid(), getgid(), seteuid(),
76
setgid(), pause(), _exit(),
77
unlinkat() */
78
#include <arpa/inet.h> /* inet_pton(), htons() */
79
#include <iso646.h> /* not, or, and */
80
#include <argp.h> /* struct argp_option, error_t, struct
81
argp_state, struct argp,
82
argp_parse(), ARGP_KEY_ARG,
83
ARGP_KEY_END, ARGP_ERR_UNKNOWN */
84
#include <signal.h> /* sigemptyset(), sigaddset(),
85
sigaction(), SIGTERM, sig_atomic_t,
86
raise() */
87
#include <sysexits.h> /* EX_OSERR, EX_USAGE, EX_UNAVAILABLE,
88
EX_NOHOST, EX_IOERR, EX_PROTOCOL */
89
#include <sys/wait.h> /* waitpid(), WIFEXITED(),
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() */
98
99
#ifdef __linux__
100
#include <sys/klog.h> /* klogctl() */
101
#endif /* __linux__ */
102
103
/* Avahi */
104
/* All Avahi types, constants and functions
105
Avahi*, avahi_*,
106
AVAHI_* */
107
#include <avahi-core/core.h>
108
#include <avahi-core/lookup.h>
109
#include <avahi-core/log.h>
110
#include <avahi-common/simple-watch.h>
111
#include <avahi-common/malloc.h>
112
#include <avahi-common/error.h>
113
114
/* GnuTLS */
115
#include <gnutls/gnutls.h> /* All GnuTLS types, constants and
116
functions:
117
gnutls_*
118
init_gnutls_session(),
119
GNUTLS_* */
120
#include <gnutls/openpgp.h>
121
/* gnutls_certificate_set_openpgp_key_file(),
122
GNUTLS_OPENPGP_FMT_BASE64 */
123
124
/* GPGME */
125
#include <gpgme.h> /* All GPGME types, constants and
126
functions:
127
gpgme_*
128
GPGME_PROTOCOL_OpenPGP,
129
GPG_ERR_NO_* */
130
131
#define BUFFER_SIZE 256
132
133
#define PATHDIR "/conf/conf.d/mandos"
134
#define SECKEY "seckey.txt"
135
#define PUBKEY "pubkey.txt"
136
#define HOOKDIR "/lib/mandos/network-hooks.d"
137
138
bool debug = false;
139
static const char mandos_protocol_version[] = "1";
140
const char *argp_program_version = "mandos-client " VERSION;
141
const char *argp_program_bug_address = "<mandos@recompile.se>";
142
static const char sys_class_net[] = "/sys/class/net";
143
char *connect_to = NULL;
144
const char *hookdir = HOOKDIR;
145
int hookdir_fd = -1;
146
uid_t uid = 65534;
147
gid_t gid = 65534;
148
149
/* Doubly linked list that need to be circularly linked when used */
150
typedef struct server{
151
const char *ip;
152
in_port_t port;
153
AvahiIfIndex if_index;
154
int af;
155
struct timespec last_seen;
156
struct server *next;
157
struct server *prev;
158
} server;
159
160
/* Used for passing in values through the Avahi callback functions */
161
typedef struct {
162
AvahiServer *server;
163
gnutls_certificate_credentials_t cred;
164
unsigned int dh_bits;
165
gnutls_dh_params_t dh_params;
166
const char *priority;
167
gpgme_ctx_t ctx;
168
server *current_server;
169
char *interfaces;
170
size_t interfaces_size;
171
} mandos_context;
172
173
/* global so signal handler can reach it*/
174
AvahiSimplePoll *simple_poll;
175
176
sig_atomic_t quit_now = 0;
177
int signal_received = 0;
178
179
/* Function to use when printing errors */
180
void perror_plus(const char *print_text){
181
int e = errno;
182
fprintf(stderr, "Mandos plugin %s: ",
183
program_invocation_short_name);
184
errno = e;
185
perror(print_text);
186
}
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
198
/*
199
* Make additional room in "buffer" for at least BUFFER_SIZE more
200
* bytes. "buffer_capacity" is how much is currently allocated,
201
* "buffer_length" is how much is already used.
202
*/
203
__attribute__((nonnull, warn_unused_result))
204
size_t incbuffer(char **buffer, size_t buffer_length,
205
size_t buffer_capacity){
206
if(buffer_length + BUFFER_SIZE > buffer_capacity){
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;
213
return 0;
214
}
215
*buffer = new_buf;
216
buffer_capacity += BUFFER_SIZE;
217
}
218
return buffer_capacity;
219
}
220
221
/* Add server to set of servers to retry periodically */
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){
225
int ret;
226
server *new_server = malloc(sizeof(server));
227
if(new_server == NULL){
228
perror_plus("malloc");
229
return false;
230
}
231
*new_server = (server){ .ip = strdup(ip),
232
.port = port,
233
.if_index = if_index,
234
.af = af };
235
if(new_server->ip == NULL){
236
perror_plus("strdup");
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;
253
}
254
/* Special case of first server */
255
if(*current_server == NULL){
256
new_server->next = new_server;
257
new_server->prev = new_server;
258
*current_server = new_server;
259
} else {
260
/* Place the new server last in the list */
261
new_server->next = *current_server;
262
new_server->prev = (*current_server)->prev;
263
new_server->prev->next = new_server;
264
(*current_server)->prev = new_server;
265
}
266
return true;
267
}
268
269
/*
270
* Initialize GPGME.
271
*/
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){
277
gpgme_error_t rc;
278
gpgme_engine_info_t engine_info;
279
280
/*
281
* Helper function to insert pub and seckey to the engine keyring.
282
*/
283
bool import_key(const char * const filename){
284
int ret;
285
int fd;
286
gpgme_data_t pgp_data;
287
288
fd = (int)TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
289
if(fd == -1){
290
perror_plus("open");
291
return false;
292
}
293
294
rc = gpgme_data_new_from_fd(&pgp_data, fd);
295
if(rc != GPG_ERR_NO_ERROR){
296
fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
297
gpgme_strsource(rc), gpgme_strerror(rc));
298
return false;
299
}
300
301
rc = gpgme_op_import(mc->ctx, pgp_data);
302
if(rc != GPG_ERR_NO_ERROR){
303
fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
304
gpgme_strsource(rc), gpgme_strerror(rc));
305
return false;
306
}
307
308
ret = (int)TEMP_FAILURE_RETRY(close(fd));
309
if(ret == -1){
310
perror_plus("close");
311
}
312
gpgme_data_release(pgp_data);
313
return true;
314
}
315
316
if(debug){
317
fprintf_plus(stderr, "Initializing GPGME\n");
318
}
319
320
/* Init GPGME */
321
gpgme_check_version(NULL);
322
rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
323
if(rc != GPG_ERR_NO_ERROR){
324
fprintf_plus(stderr, "bad gpgme_engine_check_version: %s: %s\n",
325
gpgme_strsource(rc), gpgme_strerror(rc));
326
return false;
327
}
328
329
/* Set GPGME home directory for the OpenPGP engine only */
330
rc = gpgme_get_engine_info(&engine_info);
331
if(rc != GPG_ERR_NO_ERROR){
332
fprintf_plus(stderr, "bad gpgme_get_engine_info: %s: %s\n",
333
gpgme_strsource(rc), gpgme_strerror(rc));
334
return false;
335
}
336
while(engine_info != NULL){
337
if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){
338
gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,
339
engine_info->file_name, tempdir);
340
break;
341
}
342
engine_info = engine_info->next;
343
}
344
if(engine_info == NULL){
345
fprintf_plus(stderr, "Could not set GPGME home dir to %s\n",
346
tempdir);
347
return false;
348
}
349
350
/* Create new GPGME "context" */
351
rc = gpgme_new(&(mc->ctx));
352
if(rc != GPG_ERR_NO_ERROR){
353
fprintf_plus(stderr, "Mandos plugin mandos-client: "
354
"bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
355
gpgme_strerror(rc));
356
return false;
357
}
358
359
if(not import_key(pubkey) or not import_key(seckey)){
360
return false;
361
}
362
363
return true;
364
}
365
366
/*
367
* Decrypt OpenPGP data.
368
* Returns -1 on error
369
*/
370
__attribute__((nonnull, warn_unused_result))
371
static ssize_t pgp_packet_decrypt(const char *cryptotext,
372
size_t crypto_size,
373
char **plaintext,
374
mandos_context *mc){
375
gpgme_data_t dh_crypto, dh_plain;
376
gpgme_error_t rc;
377
ssize_t ret;
378
size_t plaintext_capacity = 0;
379
ssize_t plaintext_length = 0;
380
381
if(debug){
382
fprintf_plus(stderr, "Trying to decrypt OpenPGP data\n");
383
}
384
385
/* Create new GPGME data buffer from memory cryptotext */
386
rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
387
0);
388
if(rc != GPG_ERR_NO_ERROR){
389
fprintf_plus(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
390
gpgme_strsource(rc), gpgme_strerror(rc));
391
return -1;
392
}
393
394
/* Create new empty GPGME data buffer for the plaintext */
395
rc = gpgme_data_new(&dh_plain);
396
if(rc != GPG_ERR_NO_ERROR){
397
fprintf_plus(stderr, "Mandos plugin mandos-client: "
398
"bad gpgme_data_new: %s: %s\n",
399
gpgme_strsource(rc), gpgme_strerror(rc));
400
gpgme_data_release(dh_crypto);
401
return -1;
402
}
403
404
/* Decrypt data from the cryptotext data buffer to the plaintext
405
data buffer */
406
rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
407
if(rc != GPG_ERR_NO_ERROR){
408
fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
409
gpgme_strsource(rc), gpgme_strerror(rc));
410
plaintext_length = -1;
411
if(debug){
412
gpgme_decrypt_result_t result;
413
result = gpgme_op_decrypt_result(mc->ctx);
414
if(result == NULL){
415
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
416
} else {
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);
421
if(result->file_name != NULL){
422
fprintf_plus(stderr, "File name: %s\n", result->file_name);
423
}
424
gpgme_recipient_t recipient;
425
recipient = result->recipients;
426
while(recipient != NULL){
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");
434
recipient = recipient->next;
435
}
436
}
437
}
438
goto decrypt_end;
439
}
440
441
if(debug){
442
fprintf_plus(stderr, "Decryption of OpenPGP data succeeded\n");
443
}
444
445
/* Seek back to the beginning of the GPGME plaintext data buffer */
446
if(gpgme_data_seek(dh_plain, (off_t)0, SEEK_SET) == -1){
447
perror_plus("gpgme_data_seek");
448
plaintext_length = -1;
449
goto decrypt_end;
450
}
451
452
*plaintext = NULL;
453
while(true){
454
plaintext_capacity = incbuffer(plaintext,
455
(size_t)plaintext_length,
456
plaintext_capacity);
457
if(plaintext_capacity == 0){
458
perror_plus("incbuffer");
459
plaintext_length = -1;
460
goto decrypt_end;
461
}
462
463
ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
464
BUFFER_SIZE);
465
/* Print the data, if any */
466
if(ret == 0){
467
/* EOF */
468
break;
469
}
470
if(ret < 0){
471
perror_plus("gpgme_data_read");
472
plaintext_length = -1;
473
goto decrypt_end;
474
}
475
plaintext_length += ret;
476
}
477
478
if(debug){
479
fprintf_plus(stderr, "Decrypted password is: ");
480
for(ssize_t i = 0; i < plaintext_length; i++){
481
fprintf(stderr, "%02hhX ", (*plaintext)[i]);
482
}
483
fprintf(stderr, "\n");
484
}
485
486
decrypt_end:
487
488
/* Delete the GPGME cryptotext data buffer */
489
gpgme_data_release(dh_crypto);
490
491
/* Delete the GPGME plaintext data buffer */
492
gpgme_data_release(dh_plain);
493
return plaintext_length;
494
}
495
496
__attribute__((warn_unused_result))
497
static const char *safer_gnutls_strerror(int value){
498
const char *ret = gnutls_strerror(value);
499
if(ret == NULL)
500
ret = "(unknown)";
501
return ret;
502
}
503
504
/* GnuTLS log function callback */
505
__attribute__((nonnull))
506
static void debuggnutls(__attribute__((unused)) int level,
507
const char* string){
508
fprintf_plus(stderr, "GnuTLS: %s", string);
509
}
510
511
__attribute__((nonnull, warn_unused_result))
512
static int init_gnutls_global(const char *pubkeyfilename,
513
const char *seckeyfilename,
514
mandos_context *mc){
515
int ret;
516
517
if(debug){
518
fprintf_plus(stderr, "Initializing GnuTLS\n");
519
}
520
521
ret = gnutls_global_init();
522
if(ret != GNUTLS_E_SUCCESS){
523
fprintf_plus(stderr, "GnuTLS global_init: %s\n",
524
safer_gnutls_strerror(ret));
525
return -1;
526
}
527
528
if(debug){
529
/* "Use a log level over 10 to enable all debugging options."
530
* - GnuTLS manual
531
*/
532
gnutls_global_set_log_level(11);
533
gnutls_global_set_log_function(debuggnutls);
534
}
535
536
/* OpenPGP credentials */
537
ret = gnutls_certificate_allocate_credentials(&mc->cred);
538
if(ret != GNUTLS_E_SUCCESS){
539
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
540
safer_gnutls_strerror(ret));
541
gnutls_global_deinit();
542
return -1;
543
}
544
545
if(debug){
546
fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
547
" secret key %s as GnuTLS credentials\n",
548
pubkeyfilename,
549
seckeyfilename);
550
}
551
552
ret = gnutls_certificate_set_openpgp_key_file
553
(mc->cred, pubkeyfilename, seckeyfilename,
554
GNUTLS_OPENPGP_FMT_BASE64);
555
if(ret != GNUTLS_E_SUCCESS){
556
fprintf_plus(stderr,
557
"Error[%d] while reading the OpenPGP key pair ('%s',"
558
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
559
fprintf_plus(stderr, "The GnuTLS error is: %s\n",
560
safer_gnutls_strerror(ret));
561
goto globalfail;
562
}
563
564
/* GnuTLS server initialization */
565
ret = gnutls_dh_params_init(&mc->dh_params);
566
if(ret != GNUTLS_E_SUCCESS){
567
fprintf_plus(stderr, "Error in GnuTLS DH parameter"
568
" initialization: %s\n",
569
safer_gnutls_strerror(ret));
570
goto globalfail;
571
}
572
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
573
if(ret != GNUTLS_E_SUCCESS){
574
fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
575
safer_gnutls_strerror(ret));
576
goto globalfail;
577
}
578
579
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
580
581
return 0;
582
583
globalfail:
584
585
gnutls_certificate_free_credentials(mc->cred);
586
gnutls_global_deinit();
587
gnutls_dh_params_deinit(mc->dh_params);
588
return -1;
589
}
590
591
__attribute__((nonnull, warn_unused_result))
592
static int init_gnutls_session(gnutls_session_t *session,
593
mandos_context *mc){
594
int ret;
595
/* GnuTLS session creation */
596
do {
597
ret = gnutls_init(session, GNUTLS_SERVER);
598
if(quit_now){
599
return -1;
600
}
601
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
602
if(ret != GNUTLS_E_SUCCESS){
603
fprintf_plus(stderr,
604
"Error in GnuTLS session initialization: %s\n",
605
safer_gnutls_strerror(ret));
606
}
607
608
{
609
const char *err;
610
do {
611
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
612
if(quit_now){
613
gnutls_deinit(*session);
614
return -1;
615
}
616
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
617
if(ret != GNUTLS_E_SUCCESS){
618
fprintf_plus(stderr, "Syntax error at: %s\n", err);
619
fprintf_plus(stderr, "GnuTLS error: %s\n",
620
safer_gnutls_strerror(ret));
621
gnutls_deinit(*session);
622
return -1;
623
}
624
}
625
626
do {
627
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
628
mc->cred);
629
if(quit_now){
630
gnutls_deinit(*session);
631
return -1;
632
}
633
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
634
if(ret != GNUTLS_E_SUCCESS){
635
fprintf_plus(stderr, "Error setting GnuTLS credentials: %s\n",
636
safer_gnutls_strerror(ret));
637
gnutls_deinit(*session);
638
return -1;
639
}
640
641
/* ignore client certificate if any. */
642
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
643
644
gnutls_dh_set_prime_bits(*session, mc->dh_bits);
645
646
return 0;
647
}
648
649
/* Avahi log function callback */
650
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
651
__attribute__((unused)) const char *txt){}
652
653
/* Called when a Mandos server is found */
654
__attribute__((nonnull, warn_unused_result))
655
static int start_mandos_communication(const char *ip, in_port_t port,
656
AvahiIfIndex if_index,
657
int af, mandos_context *mc){
658
int ret, tcp_sd = -1;
659
ssize_t sret;
660
struct sockaddr_storage to;
661
char *buffer = NULL;
662
char *decrypted_buffer = NULL;
663
size_t buffer_length = 0;
664
size_t buffer_capacity = 0;
665
size_t written;
666
int retval = -1;
667
gnutls_session_t session;
668
int pf; /* Protocol family */
669
670
errno = 0;
671
672
if(quit_now){
673
errno = EINTR;
674
return -1;
675
}
676
677
switch(af){
678
case AF_INET6:
679
pf = PF_INET6;
680
break;
681
case AF_INET:
682
pf = PF_INET;
683
break;
684
default:
685
fprintf_plus(stderr, "Bad address family: %d\n", af);
686
errno = EINVAL;
687
return -1;
688
}
689
690
/* If the interface is specified and we have a list of interfaces */
691
if(if_index != AVAHI_IF_UNSPEC and mc->interfaces != NULL){
692
/* Check if the interface is one of the interfaces we are using */
693
bool match = false;
694
{
695
char *interface = NULL;
696
while((interface=argz_next(mc->interfaces, mc->interfaces_size,
697
interface))){
698
if(if_nametoindex(interface) == (unsigned int)if_index){
699
match = true;
700
break;
701
}
702
}
703
}
704
if(not match){
705
/* This interface does not match any in the list, so we don't
706
connect to the server */
707
if(debug){
708
char interface[IF_NAMESIZE];
709
if(if_indextoname((unsigned int)if_index, interface) == NULL){
710
perror_plus("if_indextoname");
711
} else {
712
fprintf_plus(stderr, "Skipping server on non-used interface"
713
" \"%s\"\n",
714
if_indextoname((unsigned int)if_index,
715
interface));
716
}
717
}
718
return -1;
719
}
720
}
721
722
ret = init_gnutls_session(&session, mc);
723
if(ret != 0){
724
return -1;
725
}
726
727
if(debug){
728
fprintf_plus(stderr, "Setting up a TCP connection to %s, port %"
729
PRIuMAX "\n", ip, (uintmax_t)port);
730
}
731
732
tcp_sd = socket(pf, SOCK_STREAM, 0);
733
if(tcp_sd < 0){
734
int e = errno;
735
perror_plus("socket");
736
errno = e;
737
goto mandos_end;
738
}
739
740
if(quit_now){
741
errno = EINTR;
742
goto mandos_end;
743
}
744
745
memset(&to, 0, sizeof(to));
746
if(af == AF_INET6){
747
((struct sockaddr_in6 *)&to)->sin6_family = (sa_family_t)af;
748
ret = inet_pton(af, ip, &((struct sockaddr_in6 *)&to)->sin6_addr);
749
} else { /* IPv4 */
750
((struct sockaddr_in *)&to)->sin_family = (sa_family_t)af;
751
ret = inet_pton(af, ip, &((struct sockaddr_in *)&to)->sin_addr);
752
}
753
if(ret < 0 ){
754
int e = errno;
755
perror_plus("inet_pton");
756
errno = e;
757
goto mandos_end;
758
}
759
if(ret == 0){
760
int e = errno;
761
fprintf_plus(stderr, "Bad address: %s\n", ip);
762
errno = e;
763
goto mandos_end;
764
}
765
if(af == AF_INET6){
766
((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
767
if(IN6_IS_ADDR_LINKLOCAL
768
(&((struct sockaddr_in6 *)&to)->sin6_addr)){
769
if(if_index == AVAHI_IF_UNSPEC){
770
fprintf_plus(stderr, "An IPv6 link-local address is"
771
" incomplete without a network interface\n");
772
errno = EINVAL;
773
goto mandos_end;
774
}
775
/* Set the network interface number as scope */
776
((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
777
}
778
} else {
779
((struct sockaddr_in *)&to)->sin_port = htons(port);
780
}
781
782
if(quit_now){
783
errno = EINTR;
784
goto mandos_end;
785
}
786
787
if(debug){
788
if(af == AF_INET6 and if_index != AVAHI_IF_UNSPEC){
789
char interface[IF_NAMESIZE];
790
if(if_indextoname((unsigned int)if_index, interface) == NULL){
791
perror_plus("if_indextoname");
792
} else {
793
fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIuMAX
794
"\n", ip, interface, (uintmax_t)port);
795
}
796
} else {
797
fprintf_plus(stderr, "Connection to: %s, port %" PRIuMAX "\n",
798
ip, (uintmax_t)port);
799
}
800
char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
801
INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
802
if(af == AF_INET6){
803
ret = getnameinfo((struct sockaddr *)&to,
804
sizeof(struct sockaddr_in6),
805
addrstr, sizeof(addrstr), NULL, 0,
806
NI_NUMERICHOST);
807
} else {
808
ret = getnameinfo((struct sockaddr *)&to,
809
sizeof(struct sockaddr_in),
810
addrstr, sizeof(addrstr), NULL, 0,
811
NI_NUMERICHOST);
812
}
813
if(ret == EAI_SYSTEM){
814
perror_plus("getnameinfo");
815
} else if(ret != 0) {
816
fprintf_plus(stderr, "getnameinfo: %s", gai_strerror(ret));
817
} else if(strcmp(addrstr, ip) != 0){
818
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
819
}
820
}
821
822
if(quit_now){
823
errno = EINTR;
824
goto mandos_end;
825
}
826
827
if(af == AF_INET6){
828
ret = connect(tcp_sd, (struct sockaddr *)&to,
829
sizeof(struct sockaddr_in6));
830
} else {
831
ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
832
sizeof(struct sockaddr_in));
833
}
834
if(ret < 0){
835
if((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
836
int e = errno;
837
perror_plus("connect");
838
errno = e;
839
}
840
goto mandos_end;
841
}
842
843
if(quit_now){
844
errno = EINTR;
845
goto mandos_end;
846
}
847
848
const char *out = mandos_protocol_version;
849
written = 0;
850
while(true){
851
size_t out_size = strlen(out);
852
ret = (int)TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
853
out_size - written));
854
if(ret == -1){
855
int e = errno;
856
perror_plus("write");
857
errno = e;
858
goto mandos_end;
859
}
860
written += (size_t)ret;
861
if(written < out_size){
862
continue;
863
} else {
864
if(out == mandos_protocol_version){
865
written = 0;
866
out = "\r\n";
867
} else {
868
break;
869
}
870
}
871
872
if(quit_now){
873
errno = EINTR;
874
goto mandos_end;
875
}
876
}
877
878
if(debug){
879
fprintf_plus(stderr, "Establishing TLS session with %s\n", ip);
880
}
881
882
if(quit_now){
883
errno = EINTR;
884
goto mandos_end;
885
}
886
887
/* This casting via intptr_t is to eliminate warning about casting
888
an int to a pointer type. This is exactly how the GnuTLS Guile
889
function "set-session-transport-fd!" does it. */
890
gnutls_transport_set_ptr(session,
891
(gnutls_transport_ptr_t)(intptr_t)tcp_sd);
892
893
if(quit_now){
894
errno = EINTR;
895
goto mandos_end;
896
}
897
898
do {
899
ret = gnutls_handshake(session);
900
if(quit_now){
901
errno = EINTR;
902
goto mandos_end;
903
}
904
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
905
906
if(ret != GNUTLS_E_SUCCESS){
907
if(debug){
908
fprintf_plus(stderr, "*** GnuTLS Handshake failed ***\n");
909
gnutls_perror(ret);
910
}
911
errno = EPROTO;
912
goto mandos_end;
913
}
914
915
/* Read OpenPGP packet that contains the wanted password */
916
917
if(debug){
918
fprintf_plus(stderr, "Retrieving OpenPGP encrypted password from"
919
" %s\n", ip);
920
}
921
922
while(true){
923
924
if(quit_now){
925
errno = EINTR;
926
goto mandos_end;
927
}
928
929
buffer_capacity = incbuffer(&buffer, buffer_length,
930
buffer_capacity);
931
if(buffer_capacity == 0){
932
int e = errno;
933
perror_plus("incbuffer");
934
errno = e;
935
goto mandos_end;
936
}
937
938
if(quit_now){
939
errno = EINTR;
940
goto mandos_end;
941
}
942
943
sret = gnutls_record_recv(session, buffer+buffer_length,
944
BUFFER_SIZE);
945
if(sret == 0){
946
break;
947
}
948
if(sret < 0){
949
switch(sret){
950
case GNUTLS_E_INTERRUPTED:
951
case GNUTLS_E_AGAIN:
952
break;
953
case GNUTLS_E_REHANDSHAKE:
954
do {
955
ret = gnutls_handshake(session);
956
957
if(quit_now){
958
errno = EINTR;
959
goto mandos_end;
960
}
961
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
962
if(ret < 0){
963
fprintf_plus(stderr, "*** GnuTLS Re-handshake failed "
964
"***\n");
965
gnutls_perror(ret);
966
errno = EPROTO;
967
goto mandos_end;
968
}
969
break;
970
default:
971
fprintf_plus(stderr, "Unknown error while reading data from"
972
" encrypted session with Mandos server\n");
973
gnutls_bye(session, GNUTLS_SHUT_RDWR);
974
errno = EIO;
975
goto mandos_end;
976
}
977
} else {
978
buffer_length += (size_t) sret;
979
}
980
}
981
982
if(debug){
983
fprintf_plus(stderr, "Closing TLS session\n");
984
}
985
986
if(quit_now){
987
errno = EINTR;
988
goto mandos_end;
989
}
990
991
do {
992
ret = gnutls_bye(session, GNUTLS_SHUT_RDWR);
993
if(quit_now){
994
errno = EINTR;
995
goto mandos_end;
996
}
997
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
998
999
if(buffer_length > 0){
1000
ssize_t decrypted_buffer_size;
1001
decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
1002
&decrypted_buffer, mc);
1003
if(decrypted_buffer_size >= 0){
1004
1005
written = 0;
1006
while(written < (size_t) decrypted_buffer_size){
1007
if(quit_now){
1008
errno = EINTR;
1009
goto mandos_end;
1010
}
1011
1012
ret = (int)fwrite(decrypted_buffer + written, 1,
1013
(size_t)decrypted_buffer_size - written,
1014
stdout);
1015
if(ret == 0 and ferror(stdout)){
1016
int e = errno;
1017
if(debug){
1018
fprintf_plus(stderr, "Error writing encrypted data: %s\n",
1019
strerror(errno));
1020
}
1021
errno = e;
1022
goto mandos_end;
1023
}
1024
written += (size_t)ret;
1025
}
1026
retval = 0;
1027
}
1028
}
1029
1030
/* Shutdown procedure */
1031
1032
mandos_end:
1033
{
1034
int e = errno;
1035
free(decrypted_buffer);
1036
free(buffer);
1037
if(tcp_sd >= 0){
1038
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
1039
}
1040
if(ret == -1){
1041
if(e == 0){
1042
e = errno;
1043
}
1044
perror_plus("close");
1045
}
1046
gnutls_deinit(session);
1047
errno = e;
1048
if(quit_now){
1049
errno = EINTR;
1050
retval = -1;
1051
}
1052
}
1053
return retval;
1054
}
1055
1056
__attribute__((nonnull))
1057
static void resolve_callback(AvahiSServiceResolver *r,
1058
AvahiIfIndex interface,
1059
AvahiProtocol proto,
1060
AvahiResolverEvent event,
1061
const char *name,
1062
const char *type,
1063
const char *domain,
1064
const char *host_name,
1065
const AvahiAddress *address,
1066
uint16_t port,
1067
AVAHI_GCC_UNUSED AvahiStringList *txt,
1068
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1069
flags,
1070
void *mc){
1071
if(r == NULL){
1072
return;
1073
}
1074
1075
/* Called whenever a service has been resolved successfully or
1076
timed out */
1077
1078
if(quit_now){
1079
return;
1080
}
1081
1082
switch(event){
1083
default:
1084
case AVAHI_RESOLVER_FAILURE:
1085
fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
1086
"'%s' of type '%s' in domain '%s': %s\n", name, type,
1087
domain,
1088
avahi_strerror(avahi_server_errno
1089
(((mandos_context*)mc)->server)));
1090
break;
1091
1092
case AVAHI_RESOLVER_FOUND:
1093
{
1094
char ip[AVAHI_ADDRESS_STR_MAX];
1095
avahi_address_snprint(ip, sizeof(ip), address);
1096
if(debug){
1097
fprintf_plus(stderr, "Mandos server \"%s\" found on %s (%s, %"
1098
PRIdMAX ") on port %" PRIu16 "\n", name,
1099
host_name, ip, (intmax_t)interface, port);
1100
}
1101
int ret = start_mandos_communication(ip, (in_port_t)port,
1102
interface,
1103
avahi_proto_to_af(proto),
1104
mc);
1105
if(ret == 0){
1106
avahi_simple_poll_quit(simple_poll);
1107
} else {
1108
if(not add_server(ip, (in_port_t)port, interface,
1109
avahi_proto_to_af(proto),
1110
&((mandos_context*)mc)->current_server)){
1111
fprintf_plus(stderr, "Failed to add server \"%s\" to server"
1112
" list\n", name);
1113
}
1114
}
1115
}
1116
}
1117
avahi_s_service_resolver_free(r);
1118
}
1119
1120
static void browse_callback(AvahiSServiceBrowser *b,
1121
AvahiIfIndex interface,
1122
AvahiProtocol protocol,
1123
AvahiBrowserEvent event,
1124
const char *name,
1125
const char *type,
1126
const char *domain,
1127
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1128
flags,
1129
void *mc){
1130
if(b == NULL){
1131
return;
1132
}
1133
1134
/* Called whenever a new services becomes available on the LAN or
1135
is removed from the LAN */
1136
1137
if(quit_now){
1138
return;
1139
}
1140
1141
switch(event){
1142
default:
1143
case AVAHI_BROWSER_FAILURE:
1144
1145
fprintf_plus(stderr, "(Avahi browser) %s\n",
1146
avahi_strerror(avahi_server_errno
1147
(((mandos_context*)mc)->server)));
1148
avahi_simple_poll_quit(simple_poll);
1149
return;
1150
1151
case AVAHI_BROWSER_NEW:
1152
/* We ignore the returned Avahi resolver object. In the callback
1153
function we free it. If the Avahi server is terminated before
1154
the callback function is called the Avahi server will free the
1155
resolver for us. */
1156
1157
if(avahi_s_service_resolver_new(((mandos_context*)mc)->server,
1158
interface, protocol, name, type,
1159
domain, protocol, 0,
1160
resolve_callback, mc) == NULL)
1161
fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
1162
" %s\n", name,
1163
avahi_strerror(avahi_server_errno
1164
(((mandos_context*)mc)->server)));
1165
break;
1166
1167
case AVAHI_BROWSER_REMOVE:
1168
break;
1169
1170
case AVAHI_BROWSER_ALL_FOR_NOW:
1171
case AVAHI_BROWSER_CACHE_EXHAUSTED:
1172
if(debug){
1173
fprintf_plus(stderr, "No Mandos server found, still"
1174
" searching...\n");
1175
}
1176
break;
1177
}
1178
}
1179
1180
/* Signal handler that stops main loop after SIGTERM */
1181
static void handle_sigterm(int sig){
1182
if(quit_now){
1183
return;
1184
}
1185
quit_now = 1;
1186
signal_received = sig;
1187
int old_errno = errno;
1188
/* set main loop to exit */
1189
if(simple_poll != NULL){
1190
avahi_simple_poll_quit(simple_poll);
1191
}
1192
errno = old_errno;
1193
}
1194
1195
__attribute__((nonnull, warn_unused_result))
1196
bool get_flags(const char *ifname, struct ifreq *ifr){
1197
int ret;
1198
error_t ret_errno;
1199
1200
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1201
if(s < 0){
1202
ret_errno = errno;
1203
perror_plus("socket");
1204
errno = ret_errno;
1205
return false;
1206
}
1207
strcpy(ifr->ifr_name, ifname);
1208
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1209
if(ret == -1){
1210
if(debug){
1211
ret_errno = errno;
1212
perror_plus("ioctl SIOCGIFFLAGS");
1213
errno = ret_errno;
1214
}
1215
return false;
1216
}
1217
return true;
1218
}
1219
1220
__attribute__((nonnull, warn_unused_result))
1221
bool good_flags(const char *ifname, const struct ifreq *ifr){
1222
1223
/* Reject the loopback device */
1224
if(ifr->ifr_flags & IFF_LOOPBACK){
1225
if(debug){
1226
fprintf_plus(stderr, "Rejecting loopback interface \"%s\"\n",
1227
ifname);
1228
}
1229
return false;
1230
}
1231
/* Accept point-to-point devices only if connect_to is specified */
1232
if(connect_to != NULL and (ifr->ifr_flags & IFF_POINTOPOINT)){
1233
if(debug){
1234
fprintf_plus(stderr, "Accepting point-to-point interface"
1235
" \"%s\"\n", ifname);
1236
}
1237
return true;
1238
}
1239
/* Otherwise, reject non-broadcast-capable devices */
1240
if(not (ifr->ifr_flags & IFF_BROADCAST)){
1241
if(debug){
1242
fprintf_plus(stderr, "Rejecting non-broadcast interface"
1243
" \"%s\"\n", ifname);
1244
}
1245
return false;
1246
}
1247
/* Reject non-ARP interfaces (including dummy interfaces) */
1248
if(ifr->ifr_flags & IFF_NOARP){
1249
if(debug){
1250
fprintf_plus(stderr, "Rejecting non-ARP interface \"%s\"\n",
1251
ifname);
1252
}
1253
return false;
1254
}
1255
1256
/* Accept this device */
1257
if(debug){
1258
fprintf_plus(stderr, "Interface \"%s\" is good\n", ifname);
1259
}
1260
return true;
1261
}
1262
1263
/*
1264
* This function determines if a directory entry in /sys/class/net
1265
* corresponds to an acceptable network device.
1266
* (This function is passed to scandir(3) as a filter function.)
1267
*/
1268
__attribute__((nonnull, warn_unused_result))
1269
int good_interface(const struct dirent *if_entry){
1270
if(if_entry->d_name[0] == '.'){
1271
return 0;
1272
}
1273
1274
struct ifreq ifr;
1275
if(not get_flags(if_entry->d_name, &ifr)){
1276
if(debug){
1277
fprintf_plus(stderr, "Failed to get flags for interface "
1278
"\"%s\"\n", if_entry->d_name);
1279
}
1280
return 0;
1281
}
1282
1283
if(not good_flags(if_entry->d_name, &ifr)){
1284
return 0;
1285
}
1286
return 1;
1287
}
1288
1289
/*
1290
* This function determines if a network interface is up.
1291
*/
1292
__attribute__((nonnull, warn_unused_result))
1293
bool interface_is_up(const char *interface){
1294
struct ifreq ifr;
1295
if(not get_flags(interface, &ifr)){
1296
if(debug){
1297
fprintf_plus(stderr, "Failed to get flags for interface "
1298
"\"%s\"\n", interface);
1299
}
1300
return false;
1301
}
1302
1303
return (bool)(ifr.ifr_flags & IFF_UP);
1304
}
1305
1306
/*
1307
* This function determines if a network interface is running
1308
*/
1309
__attribute__((nonnull, warn_unused_result))
1310
bool interface_is_running(const char *interface){
1311
struct ifreq ifr;
1312
if(not get_flags(interface, &ifr)){
1313
if(debug){
1314
fprintf_plus(stderr, "Failed to get flags for interface "
1315
"\"%s\"\n", interface);
1316
}
1317
return false;
1318
}
1319
1320
return (bool)(ifr.ifr_flags & IFF_RUNNING);
1321
}
1322
1323
__attribute__((nonnull, pure, warn_unused_result))
1324
int notdotentries(const struct dirent *direntry){
1325
/* Skip "." and ".." */
1326
if(direntry->d_name[0] == '.'
1327
and (direntry->d_name[1] == '\0'
1328
or (direntry->d_name[1] == '.'
1329
and direntry->d_name[2] == '\0'))){
1330
return 0;
1331
}
1332
return 1;
1333
}
1334
1335
/* Is this directory entry a runnable program? */
1336
__attribute__((nonnull, warn_unused_result))
1337
int runnable_hook(const struct dirent *direntry){
1338
int ret;
1339
size_t sret;
1340
struct stat st;
1341
1342
if((direntry->d_name)[0] == '\0'){
1343
/* Empty name? */
1344
return 0;
1345
}
1346
1347
sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1348
"abcdefghijklmnopqrstuvwxyz"
1349
"0123456789"
1350
"_.-");
1351
if((direntry->d_name)[sret] != '\0'){
1352
/* Contains non-allowed characters */
1353
if(debug){
1354
fprintf_plus(stderr, "Ignoring hook \"%s\" with bad name\n",
1355
direntry->d_name);
1356
}
1357
return 0;
1358
}
1359
1360
ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1361
if(ret == -1){
1362
if(debug){
1363
perror_plus("Could not stat hook");
1364
}
1365
return 0;
1366
}
1367
if(not (S_ISREG(st.st_mode))){
1368
/* Not a regular file */
1369
if(debug){
1370
fprintf_plus(stderr, "Ignoring hook \"%s\" - not a file\n",
1371
direntry->d_name);
1372
}
1373
return 0;
1374
}
1375
if(not (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))){
1376
/* Not executable */
1377
if(debug){
1378
fprintf_plus(stderr, "Ignoring hook \"%s\" - not executable\n",
1379
direntry->d_name);
1380
}
1381
return 0;
1382
}
1383
if(debug){
1384
fprintf_plus(stderr, "Hook \"%s\" is acceptable\n",
1385
direntry->d_name);
1386
}
1387
return 1;
1388
}
1389
1390
__attribute__((nonnull, warn_unused_result))
1391
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
1392
mandos_context *mc){
1393
int ret;
1394
struct timespec now;
1395
struct timespec waited_time;
1396
intmax_t block_time;
1397
1398
while(true){
1399
if(mc->current_server == NULL){
1400
if(debug){
1401
fprintf_plus(stderr, "Wait until first server is found."
1402
" No timeout!\n");
1403
}
1404
ret = avahi_simple_poll_iterate(s, -1);
1405
} else {
1406
if(debug){
1407
fprintf_plus(stderr, "Check current_server if we should run"
1408
" it, or wait\n");
1409
}
1410
/* the current time */
1411
ret = clock_gettime(CLOCK_MONOTONIC, &now);
1412
if(ret == -1){
1413
perror_plus("clock_gettime");
1414
return -1;
1415
}
1416
/* Calculating in ms how long time between now and server
1417
who we visted longest time ago. Now - last seen. */
1418
waited_time.tv_sec = (now.tv_sec
1419
- mc->current_server->last_seen.tv_sec);
1420
waited_time.tv_nsec = (now.tv_nsec
1421
- mc->current_server->last_seen.tv_nsec);
1422
/* total time is 10s/10,000ms.
1423
Converting to s from ms by dividing by 1,000,
1424
and ns to ms by dividing by 1,000,000. */
1425
block_time = ((retry_interval
1426
- ((intmax_t)waited_time.tv_sec * 1000))
1427
- ((intmax_t)waited_time.tv_nsec / 1000000));
1428
1429
if(debug){
1430
fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1431
block_time);
1432
}
1433
1434
if(block_time <= 0){
1435
ret = start_mandos_communication(mc->current_server->ip,
1436
mc->current_server->port,
1437
mc->current_server->if_index,
1438
mc->current_server->af, mc);
1439
if(ret == 0){
1440
avahi_simple_poll_quit(s);
1441
return 0;
1442
}
1443
ret = clock_gettime(CLOCK_MONOTONIC,
1444
&mc->current_server->last_seen);
1445
if(ret == -1){
1446
perror_plus("clock_gettime");
1447
return -1;
1448
}
1449
mc->current_server = mc->current_server->next;
1450
block_time = 0; /* Call avahi to find new Mandos
1451
servers, but don't block */
1452
}
1453
1454
ret = avahi_simple_poll_iterate(s, (int)block_time);
1455
}
1456
if(ret != 0){
1457
if(ret > 0 or errno != EINTR){
1458
return (ret != 1) ? ret : 0;
1459
}
1460
}
1461
}
1462
}
1463
1464
/* Set effective uid to 0, return errno */
1465
__attribute__((warn_unused_result))
1466
error_t raise_privileges(void){
1467
error_t old_errno = errno;
1468
error_t ret_errno = 0;
1469
if(seteuid(0) == -1){
1470
ret_errno = errno;
1471
}
1472
errno = old_errno;
1473
return ret_errno;
1474
}
1475
1476
/* Set effective and real user ID to 0. Return errno. */
1477
__attribute__((warn_unused_result))
1478
error_t raise_privileges_permanently(void){
1479
error_t old_errno = errno;
1480
error_t ret_errno = raise_privileges();
1481
if(ret_errno != 0){
1482
errno = old_errno;
1483
return ret_errno;
1484
}
1485
if(setuid(0) == -1){
1486
ret_errno = errno;
1487
}
1488
errno = old_errno;
1489
return ret_errno;
1490
}
1491
1492
/* Set effective user ID to unprivileged saved user ID */
1493
__attribute__((warn_unused_result))
1494
error_t lower_privileges(void){
1495
error_t old_errno = errno;
1496
error_t ret_errno = 0;
1497
if(seteuid(uid) == -1){
1498
ret_errno = errno;
1499
}
1500
errno = old_errno;
1501
return ret_errno;
1502
}
1503
1504
/* Lower privileges permanently */
1505
__attribute__((warn_unused_result))
1506
error_t lower_privileges_permanently(void){
1507
error_t old_errno = errno;
1508
error_t ret_errno = 0;
1509
if(setuid(uid) == -1){
1510
ret_errno = errno;
1511
}
1512
errno = old_errno;
1513
return ret_errno;
1514
}
1515
1516
__attribute__((nonnull))
1517
void run_network_hooks(const char *mode, const char *interface,
1518
const float delay){
1519
struct dirent **direntries = NULL;
1520
if(hookdir_fd == -1){
1521
hookdir_fd = open(hookdir, O_RDONLY);
1522
if(hookdir_fd == -1){
1523
if(errno == ENOENT){
1524
if(debug){
1525
fprintf_plus(stderr, "Network hook directory \"%s\" not"
1526
" found\n", hookdir);
1527
}
1528
} else {
1529
perror_plus("open");
1530
}
1531
return;
1532
}
1533
}
1534
#ifdef __GLIBC__
1535
#if __GLIBC_PREREQ(2, 15)
1536
int numhooks = scandirat(hookdir_fd, ".", &direntries,
1537
runnable_hook, alphasort);
1538
#else /* not __GLIBC_PREREQ(2, 15) */
1539
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1540
alphasort);
1541
#endif /* not __GLIBC_PREREQ(2, 15) */
1542
#else /* not __GLIBC__ */
1543
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1544
alphasort);
1545
#endif /* not __GLIBC__ */
1546
if(numhooks == -1){
1547
perror_plus("scandir");
1548
return;
1549
}
1550
struct dirent *direntry;
1551
int ret;
1552
int devnull = open("/dev/null", O_RDONLY);
1553
for(int i = 0; i < numhooks; i++){
1554
direntry = direntries[i];
1555
if(debug){
1556
fprintf_plus(stderr, "Running network hook \"%s\"\n",
1557
direntry->d_name);
1558
}
1559
pid_t hook_pid = fork();
1560
if(hook_pid == 0){
1561
/* Child */
1562
/* Raise privileges */
1563
errno = raise_privileges_permanently();
1564
if(errno != 0){
1565
perror_plus("Failed to raise privileges");
1566
_exit(EX_NOPERM);
1567
}
1568
/* Set group */
1569
errno = 0;
1570
ret = setgid(0);
1571
if(ret == -1){
1572
perror_plus("setgid");
1573
_exit(EX_NOPERM);
1574
}
1575
/* Reset supplementary groups */
1576
errno = 0;
1577
ret = setgroups(0, NULL);
1578
if(ret == -1){
1579
perror_plus("setgroups");
1580
_exit(EX_NOPERM);
1581
}
1582
ret = dup2(devnull, STDIN_FILENO);
1583
if(ret == -1){
1584
perror_plus("dup2(devnull, STDIN_FILENO)");
1585
_exit(EX_OSERR);
1586
}
1587
ret = close(devnull);
1588
if(ret == -1){
1589
perror_plus("close");
1590
_exit(EX_OSERR);
1591
}
1592
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
1593
if(ret == -1){
1594
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
1595
_exit(EX_OSERR);
1596
}
1597
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1598
if(ret == -1){
1599
perror_plus("setenv");
1600
_exit(EX_OSERR);
1601
}
1602
ret = setenv("DEVICE", interface, 1);
1603
if(ret == -1){
1604
perror_plus("setenv");
1605
_exit(EX_OSERR);
1606
}
1607
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
1608
if(ret == -1){
1609
perror_plus("setenv");
1610
_exit(EX_OSERR);
1611
}
1612
ret = setenv("MODE", mode, 1);
1613
if(ret == -1){
1614
perror_plus("setenv");
1615
_exit(EX_OSERR);
1616
}
1617
char *delaystring;
1618
ret = asprintf(&delaystring, "%f", (double)delay);
1619
if(ret == -1){
1620
perror_plus("asprintf");
1621
_exit(EX_OSERR);
1622
}
1623
ret = setenv("DELAY", delaystring, 1);
1624
if(ret == -1){
1625
free(delaystring);
1626
perror_plus("setenv");
1627
_exit(EX_OSERR);
1628
}
1629
free(delaystring);
1630
if(connect_to != NULL){
1631
ret = setenv("CONNECT", connect_to, 1);
1632
if(ret == -1){
1633
perror_plus("setenv");
1634
_exit(EX_OSERR);
1635
}
1636
}
1637
int hook_fd = openat(hookdir_fd, direntry->d_name, O_RDONLY);
1638
if(hook_fd == -1){
1639
perror_plus("openat");
1640
_exit(EXIT_FAILURE);
1641
}
1642
if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
1643
perror_plus("close");
1644
_exit(EXIT_FAILURE);
1645
}
1646
if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
1647
environ) == -1){
1648
perror_plus("fexecve");
1649
_exit(EXIT_FAILURE);
1650
}
1651
} else {
1652
int status;
1653
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1654
perror_plus("waitpid");
1655
continue;
1656
}
1657
if(WIFEXITED(status)){
1658
if(WEXITSTATUS(status) != 0){
1659
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1660
" with status %d\n", direntry->d_name,
1661
WEXITSTATUS(status));
1662
continue;
1663
}
1664
} else if(WIFSIGNALED(status)){
1665
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1666
" signal %d\n", direntry->d_name,
1667
WTERMSIG(status));
1668
continue;
1669
} else {
1670
fprintf_plus(stderr, "Warning: network hook \"%s\""
1671
" crashed\n", direntry->d_name);
1672
continue;
1673
}
1674
}
1675
if(debug){
1676
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1677
direntry->d_name);
1678
}
1679
}
1680
free(direntries);
1681
if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
1682
perror_plus("close");
1683
} else {
1684
hookdir_fd = -1;
1685
}
1686
close(devnull);
1687
}
1688
1689
__attribute__((nonnull, warn_unused_result))
1690
error_t bring_up_interface(const char *const interface,
1691
const float delay){
1692
error_t old_errno = errno;
1693
int ret;
1694
struct ifreq network;
1695
unsigned int if_index = if_nametoindex(interface);
1696
if(if_index == 0){
1697
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1698
errno = old_errno;
1699
return ENXIO;
1700
}
1701
1702
if(quit_now){
1703
errno = old_errno;
1704
return EINTR;
1705
}
1706
1707
if(not interface_is_up(interface)){
1708
error_t ret_errno = 0, ioctl_errno = 0;
1709
if(not get_flags(interface, &network)){
1710
ret_errno = errno;
1711
fprintf_plus(stderr, "Failed to get flags for interface "
1712
"\"%s\"\n", interface);
1713
errno = old_errno;
1714
return ret_errno;
1715
}
1716
network.ifr_flags |= IFF_UP; /* set flag */
1717
1718
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1719
if(sd == -1){
1720
ret_errno = errno;
1721
perror_plus("socket");
1722
errno = old_errno;
1723
return ret_errno;
1724
}
1725
1726
if(quit_now){
1727
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1728
if(ret == -1){
1729
perror_plus("close");
1730
}
1731
errno = old_errno;
1732
return EINTR;
1733
}
1734
1735
if(debug){
1736
fprintf_plus(stderr, "Bringing up interface \"%s\"\n",
1737
interface);
1738
}
1739
1740
/* Raise privileges */
1741
ret_errno = raise_privileges();
1742
if(ret_errno != 0){
1743
errno = ret_errno;
1744
perror_plus("Failed to raise privileges");
1745
}
1746
1747
#ifdef __linux__
1748
int ret_linux;
1749
bool restore_loglevel = false;
1750
if(ret_errno == 0){
1751
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1752
messages about the network interface to mess up the prompt */
1753
ret_linux = klogctl(8, NULL, 5);
1754
if(ret_linux == -1){
1755
perror_plus("klogctl");
1756
} else {
1757
restore_loglevel = true;
1758
}
1759
}
1760
#endif /* __linux__ */
1761
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1762
ioctl_errno = errno;
1763
#ifdef __linux__
1764
if(restore_loglevel){
1765
ret_linux = klogctl(7, NULL, 0);
1766
if(ret_linux == -1){
1767
perror_plus("klogctl");
1768
}
1769
}
1770
#endif /* __linux__ */
1771
1772
/* If raise_privileges() succeeded above */
1773
if(ret_errno == 0){
1774
/* Lower privileges */
1775
ret_errno = lower_privileges();
1776
if(ret_errno != 0){
1777
errno = ret_errno;
1778
perror_plus("Failed to lower privileges");
1779
}
1780
}
1781
1782
/* Close the socket */
1783
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1784
if(ret == -1){
1785
perror_plus("close");
1786
}
1787
1788
if(ret_setflags == -1){
1789
errno = ioctl_errno;
1790
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1791
errno = old_errno;
1792
return ioctl_errno;
1793
}
1794
} else if(debug){
1795
fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
1796
interface);
1797
}
1798
1799
/* Sleep checking until interface is running.
1800
Check every 0.25s, up to total time of delay */
1801
for(int i=0; i < delay * 4; i++){
1802
if(interface_is_running(interface)){
1803
break;
1804
}
1805
struct timespec sleeptime = { .tv_nsec = 250000000 };
1806
ret = nanosleep(&sleeptime, NULL);
1807
if(ret == -1 and errno != EINTR){
1808
perror_plus("nanosleep");
1809
}
1810
}
1811
1812
errno = old_errno;
1813
return 0;
1814
}
1815
1816
__attribute__((nonnull, warn_unused_result))
1817
error_t take_down_interface(const char *const interface){
1818
error_t old_errno = errno;
1819
struct ifreq network;
1820
unsigned int if_index = if_nametoindex(interface);
1821
if(if_index == 0){
1822
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1823
errno = old_errno;
1824
return ENXIO;
1825
}
1826
if(interface_is_up(interface)){
1827
error_t ret_errno = 0, ioctl_errno = 0;
1828
if(not get_flags(interface, &network) and debug){
1829
ret_errno = errno;
1830
fprintf_plus(stderr, "Failed to get flags for interface "
1831
"\"%s\"\n", interface);
1832
errno = old_errno;
1833
return ret_errno;
1834
}
1835
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
1836
1837
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1838
if(sd == -1){
1839
ret_errno = errno;
1840
perror_plus("socket");
1841
errno = old_errno;
1842
return ret_errno;
1843
}
1844
1845
if(debug){
1846
fprintf_plus(stderr, "Taking down interface \"%s\"\n",
1847
interface);
1848
}
1849
1850
/* Raise privileges */
1851
ret_errno = raise_privileges();
1852
if(ret_errno != 0){
1853
errno = ret_errno;
1854
perror_plus("Failed to raise privileges");
1855
}
1856
1857
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1858
ioctl_errno = errno;
1859
1860
/* If raise_privileges() succeeded above */
1861
if(ret_errno == 0){
1862
/* Lower privileges */
1863
ret_errno = lower_privileges();
1864
if(ret_errno != 0){
1865
errno = ret_errno;
1866
perror_plus("Failed to lower privileges");
1867
}
1868
}
1869
1870
/* Close the socket */
1871
int ret = (int)TEMP_FAILURE_RETRY(close(sd));
1872
if(ret == -1){
1873
perror_plus("close");
1874
}
1875
1876
if(ret_setflags == -1){
1877
errno = ioctl_errno;
1878
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
1879
errno = old_errno;
1880
return ioctl_errno;
1881
}
1882
} else if(debug){
1883
fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
1884
interface);
1885
}
1886
1887
errno = old_errno;
1888
return 0;
1889
}
1890
1891
int main(int argc, char *argv[]){
1892
mandos_context mc = { .server = NULL, .dh_bits = 1024,
1893
.priority = "SECURE256:!CTYPE-X.509:"
1894
"+CTYPE-OPENPGP", .current_server = NULL,
1895
.interfaces = NULL, .interfaces_size = 0 };
1896
AvahiSServiceBrowser *sb = NULL;
1897
error_t ret_errno;
1898
int ret;
1899
intmax_t tmpmax;
1900
char *tmp;
1901
int exitcode = EXIT_SUCCESS;
1902
char *interfaces_to_take_down = NULL;
1903
size_t interfaces_to_take_down_size = 0;
1904
char run_tempdir[] = "/run/tmp/mandosXXXXXX";
1905
char old_tempdir[] = "/tmp/mandosXXXXXX";
1906
char *tempdir = NULL;
1907
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1908
const char *seckey = PATHDIR "/" SECKEY;
1909
const char *pubkey = PATHDIR "/" PUBKEY;
1910
char *interfaces_hooks = NULL;
1911
1912
bool gnutls_initialized = false;
1913
bool gpgme_initialized = false;
1914
float delay = 2.5f;
1915
double retry_interval = 10; /* 10s between trying a server and
1916
retrying the same server again */
1917
1918
struct sigaction old_sigterm_action = { .sa_handler = SIG_DFL };
1919
struct sigaction sigterm_action = { .sa_handler = handle_sigterm };
1920
1921
uid = getuid();
1922
gid = getgid();
1923
1924
/* Lower any group privileges we might have, just to be safe */
1925
errno = 0;
1926
ret = setgid(gid);
1927
if(ret == -1){
1928
perror_plus("setgid");
1929
}
1930
1931
/* Lower user privileges (temporarily) */
1932
errno = 0;
1933
ret = seteuid(uid);
1934
if(ret == -1){
1935
perror_plus("seteuid");
1936
}
1937
1938
if(quit_now){
1939
goto end;
1940
}
1941
1942
{
1943
struct argp_option options[] = {
1944
{ .name = "debug", .key = 128,
1945
.doc = "Debug mode", .group = 3 },
1946
{ .name = "connect", .key = 'c',
1947
.arg = "ADDRESS:PORT",
1948
.doc = "Connect directly to a specific Mandos server",
1949
.group = 1 },
1950
{ .name = "interface", .key = 'i',
1951
.arg = "NAME",
1952
.doc = "Network interface that will be used to search for"
1953
" Mandos servers",
1954
.group = 1 },
1955
{ .name = "seckey", .key = 's',
1956
.arg = "FILE",
1957
.doc = "OpenPGP secret key file base name",
1958
.group = 1 },
1959
{ .name = "pubkey", .key = 'p',
1960
.arg = "FILE",
1961
.doc = "OpenPGP public key file base name",
1962
.group = 2 },
1963
{ .name = "dh-bits", .key = 129,
1964
.arg = "BITS",
1965
.doc = "Bit length of the prime number used in the"
1966
" Diffie-Hellman key exchange",
1967
.group = 2 },
1968
{ .name = "priority", .key = 130,
1969
.arg = "STRING",
1970
.doc = "GnuTLS priority string for the TLS handshake",
1971
.group = 1 },
1972
{ .name = "delay", .key = 131,
1973
.arg = "SECONDS",
1974
.doc = "Maximum delay to wait for interface startup",
1975
.group = 2 },
1976
{ .name = "retry", .key = 132,
1977
.arg = "SECONDS",
1978
.doc = "Retry interval used when denied by the Mandos server",
1979
.group = 2 },
1980
{ .name = "network-hook-dir", .key = 133,
1981
.arg = "DIR",
1982
.doc = "Directory where network hooks are located",
1983
.group = 2 },
1984
/*
1985
* These reproduce what we would get without ARGP_NO_HELP
1986
*/
1987
{ .name = "help", .key = '?',
1988
.doc = "Give this help list", .group = -1 },
1989
{ .name = "usage", .key = -3,
1990
.doc = "Give a short usage message", .group = -1 },
1991
{ .name = "version", .key = 'V',
1992
.doc = "Print program version", .group = -1 },
1993
{ .name = NULL }
1994
};
1995
1996
error_t parse_opt(int key, char *arg,
1997
struct argp_state *state){
1998
errno = 0;
1999
switch(key){
2000
case 128: /* --debug */
2001
debug = true;
2002
break;
2003
case 'c': /* --connect */
2004
connect_to = arg;
2005
break;
2006
case 'i': /* --interface */
2007
ret_errno = argz_add_sep(&mc.interfaces, &mc.interfaces_size,
2008
arg, (int)',');
2009
if(ret_errno != 0){
2010
argp_error(state, "%s", strerror(ret_errno));
2011
}
2012
break;
2013
case 's': /* --seckey */
2014
seckey = arg;
2015
break;
2016
case 'p': /* --pubkey */
2017
pubkey = arg;
2018
break;
2019
case 129: /* --dh-bits */
2020
errno = 0;
2021
tmpmax = strtoimax(arg, &tmp, 10);
2022
if(errno != 0 or tmp == arg or *tmp != '\0'
2023
or tmpmax != (typeof(mc.dh_bits))tmpmax){
2024
argp_error(state, "Bad number of DH bits");
2025
}
2026
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
2027
break;
2028
case 130: /* --priority */
2029
mc.priority = arg;
2030
break;
2031
case 131: /* --delay */
2032
errno = 0;
2033
delay = strtof(arg, &tmp);
2034
if(errno != 0 or tmp == arg or *tmp != '\0'){
2035
argp_error(state, "Bad delay");
2036
}
2037
case 132: /* --retry */
2038
errno = 0;
2039
retry_interval = strtod(arg, &tmp);
2040
if(errno != 0 or tmp == arg or *tmp != '\0'
2041
or (retry_interval * 1000) > INT_MAX
2042
or retry_interval < 0){
2043
argp_error(state, "Bad retry interval");
2044
}
2045
break;
2046
case 133: /* --network-hook-dir */
2047
hookdir = arg;
2048
break;
2049
/*
2050
* These reproduce what we would get without ARGP_NO_HELP
2051
*/
2052
case '?': /* --help */
2053
argp_state_help(state, state->out_stream,
2054
(ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
2055
& ~(unsigned int)ARGP_HELP_EXIT_OK);
2056
case -3: /* --usage */
2057
argp_state_help(state, state->out_stream,
2058
ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
2059
case 'V': /* --version */
2060
fprintf_plus(state->out_stream, "%s\n", argp_program_version);
2061
exit(argp_err_exit_status);
2062
break;
2063
default:
2064
return ARGP_ERR_UNKNOWN;
2065
}
2066
return errno;
2067
}
2068
2069
struct argp argp = { .options = options, .parser = parse_opt,
2070
.args_doc = "",
2071
.doc = "Mandos client -- Get and decrypt"
2072
" passwords from a Mandos server" };
2073
ret = argp_parse(&argp, argc, argv,
2074
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2075
switch(ret){
2076
case 0:
2077
break;
2078
case ENOMEM:
2079
default:
2080
errno = ret;
2081
perror_plus("argp_parse");
2082
exitcode = EX_OSERR;
2083
goto end;
2084
case EINVAL:
2085
exitcode = EX_USAGE;
2086
goto end;
2087
}
2088
}
2089
2090
{
2091
/* Work around Debian bug #633582:
2092
<http://bugs.debian.org/633582> */
2093
2094
/* Re-raise privileges */
2095
ret_errno = raise_privileges();
2096
if(ret_errno != 0){
2097
errno = ret_errno;
2098
perror_plus("Failed to raise privileges");
2099
} else {
2100
struct stat st;
2101
2102
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
2103
int seckey_fd = open(seckey, O_RDONLY);
2104
if(seckey_fd == -1){
2105
perror_plus("open");
2106
} else {
2107
ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
2108
if(ret == -1){
2109
perror_plus("fstat");
2110
} else {
2111
if(S_ISREG(st.st_mode)
2112
and st.st_uid == 0 and st.st_gid == 0){
2113
ret = fchown(seckey_fd, uid, gid);
2114
if(ret == -1){
2115
perror_plus("fchown");
2116
}
2117
}
2118
}
2119
TEMP_FAILURE_RETRY(close(seckey_fd));
2120
}
2121
}
2122
2123
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2124
int pubkey_fd = open(pubkey, O_RDONLY);
2125
if(pubkey_fd == -1){
2126
perror_plus("open");
2127
} else {
2128
ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
2129
if(ret == -1){
2130
perror_plus("fstat");
2131
} else {
2132
if(S_ISREG(st.st_mode)
2133
and st.st_uid == 0 and st.st_gid == 0){
2134
ret = fchown(pubkey_fd, uid, gid);
2135
if(ret == -1){
2136
perror_plus("fchown");
2137
}
2138
}
2139
}
2140
TEMP_FAILURE_RETRY(close(pubkey_fd));
2141
}
2142
}
2143
2144
/* Lower privileges */
2145
ret_errno = lower_privileges();
2146
if(ret_errno != 0){
2147
errno = ret_errno;
2148
perror_plus("Failed to lower privileges");
2149
}
2150
}
2151
}
2152
2153
/* Remove invalid interface names (except "none") */
2154
{
2155
char *interface = NULL;
2156
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2157
interface))){
2158
if(strcmp(interface, "none") != 0
2159
and if_nametoindex(interface) == 0){
2160
if(interface[0] != '\0'){
2161
fprintf_plus(stderr, "Not using nonexisting interface"
2162
" \"%s\"\n", interface);
2163
}
2164
argz_delete(&mc.interfaces, &mc.interfaces_size, interface);
2165
interface = NULL;
2166
}
2167
}
2168
}
2169
2170
/* Run network hooks */
2171
{
2172
if(mc.interfaces != NULL){
2173
interfaces_hooks = malloc(mc.interfaces_size);
2174
if(interfaces_hooks == NULL){
2175
perror_plus("malloc");
2176
goto end;
2177
}
2178
memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
2179
argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
2180
}
2181
run_network_hooks("start", interfaces_hooks != NULL ?
2182
interfaces_hooks : "", delay);
2183
}
2184
2185
if(not debug){
2186
avahi_set_log_function(empty_log);
2187
}
2188
2189
/* Initialize Avahi early so avahi_simple_poll_quit() can be called
2190
from the signal handler */
2191
/* Initialize the pseudo-RNG for Avahi */
2192
srand((unsigned int) time(NULL));
2193
simple_poll = avahi_simple_poll_new();
2194
if(simple_poll == NULL){
2195
fprintf_plus(stderr,
2196
"Avahi: Failed to create simple poll object.\n");
2197
exitcode = EX_UNAVAILABLE;
2198
goto end;
2199
}
2200
2201
sigemptyset(&sigterm_action.sa_mask);
2202
ret = sigaddset(&sigterm_action.sa_mask, SIGINT);
2203
if(ret == -1){
2204
perror_plus("sigaddset");
2205
exitcode = EX_OSERR;
2206
goto end;
2207
}
2208
ret = sigaddset(&sigterm_action.sa_mask, SIGHUP);
2209
if(ret == -1){
2210
perror_plus("sigaddset");
2211
exitcode = EX_OSERR;
2212
goto end;
2213
}
2214
ret = sigaddset(&sigterm_action.sa_mask, SIGTERM);
2215
if(ret == -1){
2216
perror_plus("sigaddset");
2217
exitcode = EX_OSERR;
2218
goto end;
2219
}
2220
/* Need to check if the handler is SIG_IGN before handling:
2221
| [[info:libc:Initial Signal Actions]] |
2222
| [[info:libc:Basic Signal Handling]] |
2223
*/
2224
ret = sigaction(SIGINT, NULL, &old_sigterm_action);
2225
if(ret == -1){
2226
perror_plus("sigaction");
2227
return EX_OSERR;
2228
}
2229
if(old_sigterm_action.sa_handler != SIG_IGN){
2230
ret = sigaction(SIGINT, &sigterm_action, NULL);
2231
if(ret == -1){
2232
perror_plus("sigaction");
2233
exitcode = EX_OSERR;
2234
goto end;
2235
}
2236
}
2237
ret = sigaction(SIGHUP, NULL, &old_sigterm_action);
2238
if(ret == -1){
2239
perror_plus("sigaction");
2240
return EX_OSERR;
2241
}
2242
if(old_sigterm_action.sa_handler != SIG_IGN){
2243
ret = sigaction(SIGHUP, &sigterm_action, NULL);
2244
if(ret == -1){
2245
perror_plus("sigaction");
2246
exitcode = EX_OSERR;
2247
goto end;
2248
}
2249
}
2250
ret = sigaction(SIGTERM, NULL, &old_sigterm_action);
2251
if(ret == -1){
2252
perror_plus("sigaction");
2253
return EX_OSERR;
2254
}
2255
if(old_sigterm_action.sa_handler != SIG_IGN){
2256
ret = sigaction(SIGTERM, &sigterm_action, NULL);
2257
if(ret == -1){
2258
perror_plus("sigaction");
2259
exitcode = EX_OSERR;
2260
goto end;
2261
}
2262
}
2263
2264
/* If no interfaces were specified, make a list */
2265
if(mc.interfaces == NULL){
2266
struct dirent **direntries = NULL;
2267
/* Look for any good interfaces */
2268
ret = scandir(sys_class_net, &direntries, good_interface,
2269
alphasort);
2270
if(ret >= 1){
2271
/* Add all found interfaces to interfaces list */
2272
for(int i = 0; i < ret; ++i){
2273
ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
2274
direntries[i]->d_name);
2275
if(ret_errno != 0){
2276
errno = ret_errno;
2277
perror_plus("argz_add");
2278
continue;
2279
}
2280
if(debug){
2281
fprintf_plus(stderr, "Will use interface \"%s\"\n",
2282
direntries[i]->d_name);
2283
}
2284
}
2285
free(direntries);
2286
} else {
2287
if(ret == 0){
2288
free(direntries);
2289
}
2290
fprintf_plus(stderr, "Could not find a network interface\n");
2291
exitcode = EXIT_FAILURE;
2292
goto end;
2293
}
2294
}
2295
2296
/* Bring up interfaces which are down, and remove any "none"s */
2297
{
2298
char *interface = NULL;
2299
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2300
interface))){
2301
/* If interface name is "none", stop bringing up interfaces.
2302
Also remove all instances of "none" from the list */
2303
if(strcmp(interface, "none") == 0){
2304
argz_delete(&mc.interfaces, &mc.interfaces_size,
2305
interface);
2306
interface = NULL;
2307
while((interface = argz_next(mc.interfaces,
2308
mc.interfaces_size, interface))){
2309
if(strcmp(interface, "none") == 0){
2310
argz_delete(&mc.interfaces, &mc.interfaces_size,
2311
interface);
2312
interface = NULL;
2313
}
2314
}
2315
break;
2316
}
2317
bool interface_was_up = interface_is_up(interface);
2318
errno = bring_up_interface(interface, delay);
2319
if(not interface_was_up){
2320
if(errno != 0){
2321
perror_plus("Failed to bring up interface");
2322
} else {
2323
errno = argz_add(&interfaces_to_take_down,
2324
&interfaces_to_take_down_size,
2325
interface);
2326
if(errno != 0){
2327
perror_plus("argz_add");
2328
}
2329
}
2330
}
2331
}
2332
if(debug and (interfaces_to_take_down == NULL)){
2333
fprintf_plus(stderr, "No interfaces were brought up\n");
2334
}
2335
}
2336
2337
/* If we only got one interface, explicitly use only that one */
2338
if(argz_count(mc.interfaces, mc.interfaces_size) == 1){
2339
if(debug){
2340
fprintf_plus(stderr, "Using only interface \"%s\"\n",
2341
mc.interfaces);
2342
}
2343
if_index = (AvahiIfIndex)if_nametoindex(mc.interfaces);
2344
}
2345
2346
if(quit_now){
2347
goto end;
2348
}
2349
2350
ret = init_gnutls_global(pubkey, seckey, &mc);
2351
if(ret == -1){
2352
fprintf_plus(stderr, "init_gnutls_global failed\n");
2353
exitcode = EX_UNAVAILABLE;
2354
goto end;
2355
} else {
2356
gnutls_initialized = true;
2357
}
2358
2359
if(quit_now){
2360
goto end;
2361
}
2362
2363
/* Try /run/tmp before /tmp */
2364
tempdir = mkdtemp(run_tempdir);
2365
if(tempdir == NULL and errno == ENOENT){
2366
if(debug){
2367
fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
2368
run_tempdir, old_tempdir);
2369
}
2370
tempdir = mkdtemp(old_tempdir);
2371
}
2372
if(tempdir == NULL){
2373
perror_plus("mkdtemp");
2374
goto end;
2375
}
2376
2377
if(quit_now){
2378
goto end;
2379
}
2380
2381
if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
2382
fprintf_plus(stderr, "init_gpgme failed\n");
2383
exitcode = EX_UNAVAILABLE;
2384
goto end;
2385
} else {
2386
gpgme_initialized = true;
2387
}
2388
2389
if(quit_now){
2390
goto end;
2391
}
2392
2393
if(connect_to != NULL){
2394
/* Connect directly, do not use Zeroconf */
2395
/* (Mainly meant for debugging) */
2396
char *address = strrchr(connect_to, ':');
2397
2398
if(address == NULL){
2399
fprintf_plus(stderr, "No colon in address\n");
2400
exitcode = EX_USAGE;
2401
goto end;
2402
}
2403
2404
if(quit_now){
2405
goto end;
2406
}
2407
2408
in_port_t port;
2409
errno = 0;
2410
tmpmax = strtoimax(address+1, &tmp, 10);
2411
if(errno != 0 or tmp == address+1 or *tmp != '\0'
2412
or tmpmax != (in_port_t)tmpmax){
2413
fprintf_plus(stderr, "Bad port number\n");
2414
exitcode = EX_USAGE;
2415
goto end;
2416
}
2417
2418
if(quit_now){
2419
goto end;
2420
}
2421
2422
port = (in_port_t)tmpmax;
2423
*address = '\0';
2424
/* Colon in address indicates IPv6 */
2425
int af;
2426
if(strchr(connect_to, ':') != NULL){
2427
af = AF_INET6;
2428
/* Accept [] around IPv6 address - see RFC 5952 */
2429
if(connect_to[0] == '[' and address[-1] == ']')
2430
{
2431
connect_to++;
2432
address[-1] = '\0';
2433
}
2434
} else {
2435
af = AF_INET;
2436
}
2437
address = connect_to;
2438
2439
if(quit_now){
2440
goto end;
2441
}
2442
2443
while(not quit_now){
2444
ret = start_mandos_communication(address, port, if_index, af,
2445
&mc);
2446
if(quit_now or ret == 0){
2447
break;
2448
}
2449
if(debug){
2450
fprintf_plus(stderr, "Retrying in %d seconds\n",
2451
(int)retry_interval);
2452
}
2453
sleep((unsigned int)retry_interval);
2454
}
2455
2456
if(not quit_now){
2457
exitcode = EXIT_SUCCESS;
2458
}
2459
2460
goto end;
2461
}
2462
2463
if(quit_now){
2464
goto end;
2465
}
2466
2467
{
2468
AvahiServerConfig config;
2469
/* Do not publish any local Zeroconf records */
2470
avahi_server_config_init(&config);
2471
config.publish_hinfo = 0;
2472
config.publish_addresses = 0;
2473
config.publish_workstation = 0;
2474
config.publish_domain = 0;
2475
2476
/* Allocate a new server */
2477
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
2478
&config, NULL, NULL, &ret_errno);
2479
2480
/* Free the Avahi configuration data */
2481
avahi_server_config_free(&config);
2482
}
2483
2484
/* Check if creating the Avahi server object succeeded */
2485
if(mc.server == NULL){
2486
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2487
avahi_strerror(ret_errno));
2488
exitcode = EX_UNAVAILABLE;
2489
goto end;
2490
}
2491
2492
if(quit_now){
2493
goto end;
2494
}
2495
2496
/* Create the Avahi service browser */
2497
sb = avahi_s_service_browser_new(mc.server, if_index,
2498
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
2499
NULL, 0, browse_callback,
2500
(void *)&mc);
2501
if(sb == NULL){
2502
fprintf_plus(stderr, "Failed to create service browser: %s\n",
2503
avahi_strerror(avahi_server_errno(mc.server)));
2504
exitcode = EX_UNAVAILABLE;
2505
goto end;
2506
}
2507
2508
if(quit_now){
2509
goto end;
2510
}
2511
2512
/* Run the main loop */
2513
2514
if(debug){
2515
fprintf_plus(stderr, "Starting Avahi loop search\n");
2516
}
2517
2518
ret = avahi_loop_with_timeout(simple_poll,
2519
(int)(retry_interval * 1000), &mc);
2520
if(debug){
2521
fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
2522
(ret == 0) ? "successfully" : "with error");
2523
}
2524
2525
end:
2526
2527
if(debug){
2528
fprintf_plus(stderr, "%s exiting\n", argv[0]);
2529
}
2530
2531
/* Cleanup things */
2532
free(mc.interfaces);
2533
2534
if(sb != NULL)
2535
avahi_s_service_browser_free(sb);
2536
2537
if(mc.server != NULL)
2538
avahi_server_free(mc.server);
2539
2540
if(simple_poll != NULL)
2541
avahi_simple_poll_free(simple_poll);
2542
2543
if(gnutls_initialized){
2544
gnutls_certificate_free_credentials(mc.cred);
2545
gnutls_global_deinit();
2546
gnutls_dh_params_deinit(mc.dh_params);
2547
}
2548
2549
if(gpgme_initialized){
2550
gpgme_release(mc.ctx);
2551
}
2552
2553
/* Cleans up the circular linked list of Mandos servers the client
2554
has seen */
2555
if(mc.current_server != NULL){
2556
mc.current_server->prev->next = NULL;
2557
while(mc.current_server != NULL){
2558
server *next = mc.current_server->next;
2559
#ifdef __GNUC__
2560
#pragma GCC diagnostic push
2561
#pragma GCC diagnostic ignored "-Wcast-qual"
2562
#endif
2563
free((char *)(mc.current_server->ip));
2564
#ifdef __GNUC__
2565
#pragma GCC diagnostic pop
2566
#endif
2567
free(mc.current_server);
2568
mc.current_server = next;
2569
}
2570
}
2571
2572
/* Re-raise privileges */
2573
{
2574
ret_errno = raise_privileges();
2575
if(ret_errno != 0){
2576
errno = ret_errno;
2577
perror_plus("Failed to raise privileges");
2578
} else {
2579
2580
/* Run network hooks */
2581
run_network_hooks("stop", interfaces_hooks != NULL ?
2582
interfaces_hooks : "", delay);
2583
2584
/* Take down the network interfaces which were brought up */
2585
{
2586
char *interface = NULL;
2587
while((interface=argz_next(interfaces_to_take_down,
2588
interfaces_to_take_down_size,
2589
interface))){
2590
ret_errno = take_down_interface(interface);
2591
if(ret_errno != 0){
2592
errno = ret_errno;
2593
perror_plus("Failed to take down interface");
2594
}
2595
}
2596
if(debug and (interfaces_to_take_down == NULL)){
2597
fprintf_plus(stderr, "No interfaces needed to be taken"
2598
" down\n");
2599
}
2600
}
2601
}
2602
2603
ret_errno = lower_privileges_permanently();
2604
if(ret_errno != 0){
2605
errno = ret_errno;
2606
perror_plus("Failed to lower privileges permanently");
2607
}
2608
}
2609
2610
free(interfaces_to_take_down);
2611
free(interfaces_hooks);
2612
2613
/* Removes the GPGME temp directory and all files inside */
2614
if(tempdir != NULL){
2615
struct dirent **direntries = NULL;
2616
int tempdir_fd = (int)TEMP_FAILURE_RETRY(open(tempdir, O_RDONLY |
2617
O_NOFOLLOW));
2618
if(tempdir_fd == -1){
2619
perror_plus("open");
2620
} else {
2621
#ifdef __GLIBC__
2622
#if __GLIBC_PREREQ(2, 15)
2623
int numentries = scandirat(tempdir_fd, ".", &direntries,
2624
notdotentries, alphasort);
2625
#else /* not __GLIBC_PREREQ(2, 15) */
2626
int numentries = scandir(tempdir, &direntries, notdotentries,
2627
alphasort);
2628
#endif /* not __GLIBC_PREREQ(2, 15) */
2629
#else /* not __GLIBC__ */
2630
int numentries = scandir(tempdir, &direntries, notdotentries,
2631
alphasort);
2632
#endif /* not __GLIBC__ */
2633
if(numentries >= 0){
2634
for(int i = 0; i < numentries; i++){
2635
ret = unlinkat(tempdir_fd, direntries[i]->d_name, 0);
2636
if(ret == -1){
2637
fprintf_plus(stderr, "unlinkat(open(\"%s\", O_RDONLY),"
2638
" \"%s\", 0): %s\n", tempdir,
2639
direntries[i]->d_name, strerror(errno));
2640
}
2641
}
2642
2643
/* need to clean even if 0 because man page doesn't specify */
2644
free(direntries);
2645
if(numentries == -1){
2646
perror_plus("scandir");
2647
}
2648
ret = rmdir(tempdir);
2649
if(ret == -1 and errno != ENOENT){
2650
perror_plus("rmdir");
2651
}
2652
}
2653
TEMP_FAILURE_RETRY(close(tempdir_fd));
2654
}
2655
}
2656
2657
if(quit_now){
2658
sigemptyset(&old_sigterm_action.sa_mask);
2659
old_sigterm_action.sa_handler = SIG_DFL;
2660
ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
2661
&old_sigterm_action,
2662
NULL));
2663
if(ret == -1){
2664
perror_plus("sigaction");
2665
}
2666
do {
2667
ret = raise(signal_received);
2668
} while(ret != 0 and errno == EINTR);
2669
if(ret != 0){
2670
perror_plus("raise");
2671
abort();
2672
}
2673
TEMP_FAILURE_RETRY(pause());
2674
}
2675
2676
return exitcode;
2677
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0