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