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