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