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