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