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