To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to plugins.d/mandos-client.c
- browse files at revision 591
- compare with another revision
- download diff
- download tarball
- view history from revision 591
- Committer: Teddy Hogeborn
- Date: 2012-05-26 22:56:38 UTC
- mfrom: (589.1.1 socket-option)
- Revision ID: teddy@recompile.se-20120526225638-4hvqyrvmj0036lfn
Merge "--socket" option for server.
This is suggested by the GNU Coding Standards' Table of Long Options,
and will probably also allow socket activation (e.g. by systemd(8)).
This is suggested by the GNU Coding Standards' Table of Long Options,
and will probably also allow socket activation (e.g. by systemd(8)).
- files added:
- DBUS-API
- debian/source
- network-hooks.d
- files modified:
- .bzrignore
added
removed
plugins.d/mandos-client.c
9
9
* "browse_callback", and parts of "main".
10
10
*
11
11
* Everything else is
12
* Copyright © 2008,2009 Teddy Hogeborn
13
* Copyright © 2008,2009 Björn Påhlsson
12
* Copyright © 2008-2012 Teddy Hogeborn
13
* Copyright © 2008-2012 Björn Påhlsson
14
14
*
15
15
* This program is free software: you can redistribute it and/or
16
16
* modify it under the terms of the GNU General Public License as
26
26
* along with this program. If not, see
27
27
* <http://www.gnu.org/licenses/>.
28
28
*
29
* Contact the authors at <mandos@fukt.bsnet.se>.
29
* Contact the authors at <mandos@recompile.se>.
30
30
*/
31
31
32
32
/* Needed by GPGME, specifically gpgme_data_seek() */
33
#ifndef _LARGEFILE_SOURCE
33
34
#define _LARGEFILE_SOURCE
35
#endif
36
#ifndef _FILE_OFFSET_BITS
34
37
#define _FILE_OFFSET_BITS 64
38
#endif
35
39
36
40
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
37
41
38
42
#include <stdio.h> /* fprintf(), stderr, fwrite(),
39
stdout, ferror(), sscanf(),
40
remove() */
41
#include <stdint.h> /* uint16_t, uint32_t */
43
stdout, ferror(), remove() */
44
#include <stdint.h> /* uint16_t, uint32_t, intptr_t */
42
45
#include <stddef.h> /* NULL, size_t, ssize_t */
43
#include <stdlib.h> /* free(), EXIT_SUCCESS, EXIT_FAILURE,
44
srand() */
45
#include <stdbool.h> /* bool, true */
46
#include <stdlib.h> /* free(), EXIT_SUCCESS, srand(),
47
strtof(), abort() */
48
#include <stdbool.h> /* bool, false, true */
46
49
#include <string.h> /* memset(), strcmp(), strlen(),
47
50
strerror(), asprintf(), strcpy() */
48
#include <sys/ioctl.h> /* ioctl */
51
#include <sys/ioctl.h> /* ioctl */
49
52
#include <sys/types.h> /* socket(), inet_pton(), sockaddr,
50
53
sockaddr_in6, PF_INET6,
51
SOCK_STREAM, INET6_ADDRSTRLEN,
52
uid_t, gid_t, open(), opendir(),
53
DIR */
54
#include <sys/stat.h> /* open() */
54
SOCK_STREAM, uid_t, gid_t, open(),
55
opendir(), DIR */
56
#include <sys/stat.h> /* open(), S_ISREG */
55
57
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
56
struct in6_addr, inet_pton(),
57
connect() */
58
inet_pton(), connect() */
58
59
#include <fcntl.h> /* open() */
59
60
#include <dirent.h> /* opendir(), struct dirent, readdir()
60
61
*/
61
#include <inttypes.h> /* PRIu16, intmax_t, SCNdMAX */
62
#include <inttypes.h> /* PRIu16, PRIdMAX, intmax_t,
63
strtoimax() */
62
64
#include <assert.h> /* assert() */
63
#include <errno.h> /* perror(), errno */
64
#include <time.h> /* nanosleep(), time() */
65
#include <errno.h> /* perror(), errno,
66
program_invocation_short_name */
67
#include <time.h> /* nanosleep(), time(), sleep() */
65
68
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
66
69
SIOCSIFFLAGS, if_indextoname(),
67
70
if_nametoindex(), IF_NAMESIZE */
68
#include <netinet/in.h>
71
#include <netinet/in.h> /* IN6_IS_ADDR_LINKLOCAL,
72
INET_ADDRSTRLEN, INET6_ADDRSTRLEN
73
*/
69
74
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
70
getuid(), getgid(), setuid(),
71
setgid() */
72
#include <arpa/inet.h> /* inet_pton(), htons */
73
#include <iso646.h> /* not, and, or */
75
getuid(), getgid(), seteuid(),
76
setgid(), pause(), _exit() */
77
#include <arpa/inet.h> /* inet_pton(), htons, inet_ntop() */
78
#include <iso646.h> /* not, or, and */
74
79
#include <argp.h> /* struct argp_option, error_t, struct
75
80
argp_state, struct argp,
76
81
argp_parse(), ARGP_KEY_ARG,
77
82
ARGP_KEY_END, ARGP_ERR_UNKNOWN */
83
#include <signal.h> /* sigemptyset(), sigaddset(),
84
sigaction(), SIGTERM, sig_atomic_t,
85
raise() */
86
#include <sysexits.h> /* EX_OSERR, EX_USAGE, EX_UNAVAILABLE,
87
EX_NOHOST, EX_IOERR, EX_PROTOCOL */
88
#include <sys/wait.h> /* waitpid(), WIFEXITED(),
89
WEXITSTATUS(), WTERMSIG() */
90
#include <grp.h> /* setgroups() */
91
78
92
#ifdef __linux__
79
93
#include <sys/klog.h> /* klogctl() */
80
#endif
94
#endif /* __linux__ */
81
95
82
96
/* Avahi */
83
97
/* All Avahi types, constants and functions
97
111
init_gnutls_session(),
98
112
GNUTLS_* */
99
113
#include <gnutls/openpgp.h>
100
/* gnutls_certificate_set_openpgp_key_file(),
101
GNUTLS_OPENPGP_FMT_BASE64 */
114
/* gnutls_certificate_set_openpgp_key_file(),
115
GNUTLS_OPENPGP_FMT_BASE64 */
102
116
103
117
/* GPGME */
104
118
#include <gpgme.h> /* All GPGME types, constants and
112
126
#define PATHDIR "/conf/conf.d/mandos"
113
127
#define SECKEY "seckey.txt"
114
128
#define PUBKEY "pubkey.txt"
129
#define HOOKDIR "/lib/mandos/network-hooks.d"
115
130
116
131
bool debug = false;
117
132
static const char mandos_protocol_version[] = "1";
118
133
const char *argp_program_version = "mandos-client " VERSION;
119
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
134
const char *argp_program_bug_address = "<mandos@recompile.se>";
135
static const char sys_class_net[] = "/sys/class/net";
136
char *connect_to = NULL;
137
const char *hookdir = HOOKDIR;
138
139
/* Doubly linked list that need to be circularly linked when used */
140
typedef struct server{
141
const char *ip;
142
uint16_t port;
143
AvahiIfIndex if_index;
144
int af;
145
struct timespec last_seen;
146
struct server *next;
147
struct server *prev;
148
} server;
120
149
121
150
/* Used for passing in values through the Avahi callback functions */
122
151
typedef struct {
127
156
gnutls_dh_params_t dh_params;
128
157
const char *priority;
129
158
gpgme_ctx_t ctx;
159
server *current_server;
130
160
} mandos_context;
131
161
162
/* global context so signal handler can reach it*/
163
mandos_context mc = { .simple_poll = NULL, .server = NULL,
164
.dh_bits = 1024, .priority = "SECURE256"
165
":!CTYPE-X.509:+CTYPE-OPENPGP",
166
.current_server = NULL };
167
168
sig_atomic_t quit_now = 0;
169
int signal_received = 0;
170
171
/* Function to use when printing errors */
172
void perror_plus(const char *print_text){
173
int e = errno;
174
fprintf(stderr, "Mandos plugin %s: ",
175
program_invocation_short_name);
176
errno = e;
177
perror(print_text);
178
}
179
180
__attribute__((format (gnu_printf, 2, 3)))
181
int fprintf_plus(FILE *stream, const char *format, ...){
182
va_list ap;
183
va_start (ap, format);
184
185
TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
186
program_invocation_short_name));
187
return TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
188
}
189
132
190
/*
133
* Make room in "buffer" for at least BUFFER_SIZE additional bytes.
134
* "buffer_capacity" is how much is currently allocated,
191
* Make additional room in "buffer" for at least BUFFER_SIZE more
192
* bytes. "buffer_capacity" is how much is currently allocated,
135
193
* "buffer_length" is how much is already used.
136
194
*/
137
size_t adjustbuffer(char **buffer, size_t buffer_length,
138
size_t buffer_capacity){
195
size_t incbuffer(char **buffer, size_t buffer_length,
196
size_t buffer_capacity){
139
197
if(buffer_length + BUFFER_SIZE > buffer_capacity){
140
198
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
141
199
if(buffer == NULL){
146
204
return buffer_capacity;
147
205
}
148
206
207
/* Add server to set of servers to retry periodically */
208
bool add_server(const char *ip, uint16_t port, AvahiIfIndex if_index,
209
int af){
210
int ret;
211
server *new_server = malloc(sizeof(server));
212
if(new_server == NULL){
213
perror_plus("malloc");
214
return false;
215
}
216
*new_server = (server){ .ip = strdup(ip),
217
.port = port,
218
.if_index = if_index,
219
.af = af };
220
if(new_server->ip == NULL){
221
perror_plus("strdup");
222
return false;
223
}
224
/* Special case of first server */
225
if (mc.current_server == NULL){
226
new_server->next = new_server;
227
new_server->prev = new_server;
228
mc.current_server = new_server;
229
/* Place the new server last in the list */
230
} else {
231
new_server->next = mc.current_server;
232
new_server->prev = mc.current_server->prev;
233
new_server->prev->next = new_server;
234
mc.current_server->prev = new_server;
235
}
236
ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);
237
if(ret == -1){
238
perror_plus("clock_gettime");
239
return false;
240
}
241
return true;
242
}
243
149
244
/*
150
245
* Initialize GPGME.
151
246
*/
152
static bool init_gpgme(mandos_context *mc, const char *seckey,
153
const char *pubkey, const char *tempdir){
154
int ret;
247
static bool init_gpgme(const char *seckey, const char *pubkey,
248
const char *tempdir){
155
249
gpgme_error_t rc;
156
250
gpgme_engine_info_t engine_info;
157
251
160
254
* Helper function to insert pub and seckey to the engine keyring.
161
255
*/
162
256
bool import_key(const char *filename){
257
int ret;
163
258
int fd;
164
259
gpgme_data_t pgp_data;
165
260
166
261
fd = (int)TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
167
262
if(fd == -1){
168
perror("open");
263
perror_plus("open");
169
264
return false;
170
265
}
171
266
172
267
rc = gpgme_data_new_from_fd(&pgp_data, fd);
173
268
if(rc != GPG_ERR_NO_ERROR){
174
fprintf(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
175
gpgme_strsource(rc), gpgme_strerror(rc));
269
fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
270
gpgme_strsource(rc), gpgme_strerror(rc));
176
271
return false;
177
272
}
178
273
179
rc = gpgme_op_import(mc->ctx, pgp_data);
274
rc = gpgme_op_import(mc.ctx, pgp_data);
180
275
if(rc != GPG_ERR_NO_ERROR){
181
fprintf(stderr, "bad gpgme_op_import: %s: %s\n",
182
gpgme_strsource(rc), gpgme_strerror(rc));
276
fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
277
gpgme_strsource(rc), gpgme_strerror(rc));
183
278
return false;
184
279
}
185
280
186
281
ret = (int)TEMP_FAILURE_RETRY(close(fd));
187
282
if(ret == -1){
188
perror("close");
283
perror_plus("close");
189
284
}
190
285
gpgme_data_release(pgp_data);
191
286
return true;
192
287
}
193
288
194
289
if(debug){
195
fprintf(stderr, "Initialize gpgme\n");
290
fprintf_plus(stderr, "Initializing GPGME\n");
196
291
}
197
292
198
293
/* Init GPGME */
199
294
gpgme_check_version(NULL);
200
295
rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
201
296
if(rc != GPG_ERR_NO_ERROR){
202
fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
203
gpgme_strsource(rc), gpgme_strerror(rc));
297
fprintf_plus(stderr, "bad gpgme_engine_check_version: %s: %s\n",
298
gpgme_strsource(rc), gpgme_strerror(rc));
204
299
return false;
205
300
}
206
301
207
/* Set GPGME home directory for the OpenPGP engine only */
302
/* Set GPGME home directory for the OpenPGP engine only */
208
303
rc = gpgme_get_engine_info(&engine_info);
209
304
if(rc != GPG_ERR_NO_ERROR){
210
fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
211
gpgme_strsource(rc), gpgme_strerror(rc));
305
fprintf_plus(stderr, "bad gpgme_get_engine_info: %s: %s\n",
306
gpgme_strsource(rc), gpgme_strerror(rc));
212
307
return false;
213
308
}
214
309
while(engine_info != NULL){
220
315
engine_info = engine_info->next;
221
316
}
222
317
if(engine_info == NULL){
223
fprintf(stderr, "Could not set GPGME home dir to %s\n", tempdir);
318
fprintf_plus(stderr, "Could not set GPGME home dir to %s\n",
319
tempdir);
224
320
return false;
225
321
}
226
322
227
323
/* Create new GPGME "context" */
228
rc = gpgme_new(&(mc->ctx));
324
rc = gpgme_new(&(mc.ctx));
229
325
if(rc != GPG_ERR_NO_ERROR){
230
fprintf(stderr, "bad gpgme_new: %s: %s\n",
231
gpgme_strsource(rc), gpgme_strerror(rc));
326
fprintf_plus(stderr, "Mandos plugin mandos-client: "
327
"bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
328
gpgme_strerror(rc));
232
329
return false;
233
330
}
234
331
236
333
return false;
237
334
}
238
335
239
return true;
336
return true;
240
337
}
241
338
242
339
/*
243
340
* Decrypt OpenPGP data.
244
341
* Returns -1 on error
245
342
*/
246
static ssize_t pgp_packet_decrypt(const mandos_context *mc,
247
const char *cryptotext,
343
static ssize_t pgp_packet_decrypt(const char *cryptotext,
248
344
size_t crypto_size,
249
345
char **plaintext){
250
346
gpgme_data_t dh_crypto, dh_plain;
254
350
ssize_t plaintext_length = 0;
255
351
256
352
if(debug){
257
fprintf(stderr, "Trying to decrypt OpenPGP data\n");
353
fprintf_plus(stderr, "Trying to decrypt OpenPGP data\n");
258
354
}
259
355
260
356
/* Create new GPGME data buffer from memory cryptotext */
261
357
rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
262
358
0);
263
359
if(rc != GPG_ERR_NO_ERROR){
264
fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
265
gpgme_strsource(rc), gpgme_strerror(rc));
360
fprintf_plus(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
361
gpgme_strsource(rc), gpgme_strerror(rc));
266
362
return -1;
267
363
}
268
364
269
365
/* Create new empty GPGME data buffer for the plaintext */
270
366
rc = gpgme_data_new(&dh_plain);
271
367
if(rc != GPG_ERR_NO_ERROR){
272
fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
273
gpgme_strsource(rc), gpgme_strerror(rc));
368
fprintf_plus(stderr, "Mandos plugin mandos-client: "
369
"bad gpgme_data_new: %s: %s\n",
370
gpgme_strsource(rc), gpgme_strerror(rc));
274
371
gpgme_data_release(dh_crypto);
275
372
return -1;
276
373
}
277
374
278
375
/* Decrypt data from the cryptotext data buffer to the plaintext
279
376
data buffer */
280
rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
377
rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
281
378
if(rc != GPG_ERR_NO_ERROR){
282
fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
283
gpgme_strsource(rc), gpgme_strerror(rc));
379
fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
380
gpgme_strsource(rc), gpgme_strerror(rc));
284
381
plaintext_length = -1;
285
382
if(debug){
286
383
gpgme_decrypt_result_t result;
287
result = gpgme_op_decrypt_result(mc->ctx);
384
result = gpgme_op_decrypt_result(mc.ctx);
288
385
if(result == NULL){
289
fprintf(stderr, "gpgme_op_decrypt_result failed\n");
386
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
290
387
} else {
291
fprintf(stderr, "Unsupported algorithm: %s\n",
292
result->unsupported_algorithm);
293
fprintf(stderr, "Wrong key usage: %u\n",
294
result->wrong_key_usage);
388
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
389
result->unsupported_algorithm);
390
fprintf_plus(stderr, "Wrong key usage: %u\n",
391
result->wrong_key_usage);
295
392
if(result->file_name != NULL){
296
fprintf(stderr, "File name: %s\n", result->file_name);
393
fprintf_plus(stderr, "File name: %s\n", result->file_name);
297
394
}
298
395
gpgme_recipient_t recipient;
299
396
recipient = result->recipients;
300
if(recipient){
301
while(recipient != NULL){
302
fprintf(stderr, "Public key algorithm: %s\n",
303
gpgme_pubkey_algo_name(recipient->pubkey_algo));
304
fprintf(stderr, "Key ID: %s\n", recipient->keyid);
305
fprintf(stderr, "Secret key available: %s\n",
306
recipient->status == GPG_ERR_NO_SECKEY
307
? "No" : "Yes");
308
recipient = recipient->next;
309
}
397
while(recipient != NULL){
398
fprintf_plus(stderr, "Public key algorithm: %s\n",
399
gpgme_pubkey_algo_name
400
(recipient->pubkey_algo));
401
fprintf_plus(stderr, "Key ID: %s\n", recipient->keyid);
402
fprintf_plus(stderr, "Secret key available: %s\n",
403
recipient->status == GPG_ERR_NO_SECKEY
404
? "No" : "Yes");
405
recipient = recipient->next;
310
406
}
311
407
}
312
408
}
314
410
}
315
411
316
412
if(debug){
317
fprintf(stderr, "Decryption of OpenPGP data succeeded\n");
413
fprintf_plus(stderr, "Decryption of OpenPGP data succeeded\n");
318
414
}
319
415
320
416
/* Seek back to the beginning of the GPGME plaintext data buffer */
321
417
if(gpgme_data_seek(dh_plain, (off_t)0, SEEK_SET) == -1){
322
perror("gpgme_data_seek");
418
perror_plus("gpgme_data_seek");
323
419
plaintext_length = -1;
324
420
goto decrypt_end;
325
421
}
326
422
327
423
*plaintext = NULL;
328
424
while(true){
329
plaintext_capacity = adjustbuffer(plaintext,
330
(size_t)plaintext_length,
331
plaintext_capacity);
425
plaintext_capacity = incbuffer(plaintext,
426
(size_t)plaintext_length,
427
plaintext_capacity);
332
428
if(plaintext_capacity == 0){
333
perror("adjustbuffer");
334
plaintext_length = -1;
335
goto decrypt_end;
429
perror_plus("incbuffer");
430
plaintext_length = -1;
431
goto decrypt_end;
336
432
}
337
433
338
434
ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
343
439
break;
344
440
}
345
441
if(ret < 0){
346
perror("gpgme_data_read");
442
perror_plus("gpgme_data_read");
347
443
plaintext_length = -1;
348
444
goto decrypt_end;
349
445
}
351
447
}
352
448
353
449
if(debug){
354
fprintf(stderr, "Decrypted password is: ");
450
fprintf_plus(stderr, "Decrypted password is: ");
355
451
for(ssize_t i = 0; i < plaintext_length; i++){
356
452
fprintf(stderr, "%02hhX ", (*plaintext)[i]);
357
453
}
379
475
/* GnuTLS log function callback */
380
476
static void debuggnutls(__attribute__((unused)) int level,
381
477
const char* string){
382
fprintf(stderr, "GnuTLS: %s", string);
478
fprintf_plus(stderr, "GnuTLS: %s", string);
383
479
}
384
480
385
static int init_gnutls_global(mandos_context *mc,
386
const char *pubkeyfilename,
481
static int init_gnutls_global(const char *pubkeyfilename,
387
482
const char *seckeyfilename){
388
483
int ret;
389
484
390
485
if(debug){
391
fprintf(stderr, "Initializing GnuTLS\n");
486
fprintf_plus(stderr, "Initializing GnuTLS\n");
392
487
}
393
488
394
489
ret = gnutls_global_init();
395
490
if(ret != GNUTLS_E_SUCCESS){
396
fprintf(stderr, "GnuTLS global_init: %s\n",
397
safer_gnutls_strerror(ret));
491
fprintf_plus(stderr, "GnuTLS global_init: %s\n",
492
safer_gnutls_strerror(ret));
398
493
return -1;
399
494
}
400
495
407
502
}
408
503
409
504
/* OpenPGP credentials */
410
gnutls_certificate_allocate_credentials(&mc->cred);
505
ret = gnutls_certificate_allocate_credentials(&mc.cred);
411
506
if(ret != GNUTLS_E_SUCCESS){
412
fprintf(stderr, "GnuTLS memory error: %s\n", /* Spurious warning
413
* from
414
* -Wunreachable-code
415
*/
416
safer_gnutls_strerror(ret));
507
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
508
safer_gnutls_strerror(ret));
417
509
gnutls_global_deinit();
418
510
return -1;
419
511
}
420
512
421
513
if(debug){
422
fprintf(stderr, "Attempting to use OpenPGP public key %s and"
423
" secret key %s as GnuTLS credentials\n", pubkeyfilename,
424
seckeyfilename);
514
fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
515
" secret key %s as GnuTLS credentials\n",
516
pubkeyfilename,
517
seckeyfilename);
425
518
}
426
519
427
520
ret = gnutls_certificate_set_openpgp_key_file
428
(mc->cred, pubkeyfilename, seckeyfilename,
521
(mc.cred, pubkeyfilename, seckeyfilename,
429
522
GNUTLS_OPENPGP_FMT_BASE64);
430
523
if(ret != GNUTLS_E_SUCCESS){
431
fprintf(stderr,
432
"Error[%d] while reading the OpenPGP key pair ('%s',"
433
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
434
fprintf(stderr, "The GnuTLS error is: %s\n",
435
safer_gnutls_strerror(ret));
524
fprintf_plus(stderr,
525
"Error[%d] while reading the OpenPGP key pair ('%s',"
526
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
527
fprintf_plus(stderr, "The GnuTLS error is: %s\n",
528
safer_gnutls_strerror(ret));
436
529
goto globalfail;
437
530
}
438
531
439
532
/* GnuTLS server initialization */
440
ret = gnutls_dh_params_init(&mc->dh_params);
533
ret = gnutls_dh_params_init(&mc.dh_params);
441
534
if(ret != GNUTLS_E_SUCCESS){
442
fprintf(stderr, "Error in GnuTLS DH parameter initialization:"
443
" %s\n", safer_gnutls_strerror(ret));
535
fprintf_plus(stderr, "Error in GnuTLS DH parameter"
536
" initialization: %s\n",
537
safer_gnutls_strerror(ret));
444
538
goto globalfail;
445
539
}
446
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
540
ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
447
541
if(ret != GNUTLS_E_SUCCESS){
448
fprintf(stderr, "Error in GnuTLS prime generation: %s\n",
449
safer_gnutls_strerror(ret));
542
fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
543
safer_gnutls_strerror(ret));
450
544
goto globalfail;
451
545
}
452
546
453
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
547
gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
454
548
455
549
return 0;
456
550
457
551
globalfail:
458
552
459
gnutls_certificate_free_credentials(mc->cred);
553
gnutls_certificate_free_credentials(mc.cred);
460
554
gnutls_global_deinit();
461
gnutls_dh_params_deinit(mc->dh_params);
555
gnutls_dh_params_deinit(mc.dh_params);
462
556
return -1;
463
557
}
464
558
465
static int init_gnutls_session(mandos_context *mc,
466
gnutls_session_t *session){
559
static int init_gnutls_session(gnutls_session_t *session){
467
560
int ret;
468
561
/* GnuTLS session creation */
469
ret = gnutls_init(session, GNUTLS_SERVER);
562
do {
563
ret = gnutls_init(session, GNUTLS_SERVER);
564
if(quit_now){
565
return -1;
566
}
567
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
470
568
if(ret != GNUTLS_E_SUCCESS){
471
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
472
safer_gnutls_strerror(ret));
569
fprintf_plus(stderr,
570
"Error in GnuTLS session initialization: %s\n",
571
safer_gnutls_strerror(ret));
473
572
}
474
573
475
574
{
476
575
const char *err;
477
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
576
do {
577
ret = gnutls_priority_set_direct(*session, mc.priority, &err);
578
if(quit_now){
579
gnutls_deinit(*session);
580
return -1;
581
}
582
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
478
583
if(ret != GNUTLS_E_SUCCESS){
479
fprintf(stderr, "Syntax error at: %s\n", err);
480
fprintf(stderr, "GnuTLS error: %s\n",
481
safer_gnutls_strerror(ret));
584
fprintf_plus(stderr, "Syntax error at: %s\n", err);
585
fprintf_plus(stderr, "GnuTLS error: %s\n",
586
safer_gnutls_strerror(ret));
482
587
gnutls_deinit(*session);
483
588
return -1;
484
589
}
485
590
}
486
591
487
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
488
mc->cred);
592
do {
593
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
594
mc.cred);
595
if(quit_now){
596
gnutls_deinit(*session);
597
return -1;
598
}
599
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
489
600
if(ret != GNUTLS_E_SUCCESS){
490
fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
491
safer_gnutls_strerror(ret));
601
fprintf_plus(stderr, "Error setting GnuTLS credentials: %s\n",
602
safer_gnutls_strerror(ret));
492
603
gnutls_deinit(*session);
493
604
return -1;
494
605
}
495
606
496
607
/* ignore client certificate if any. */
497
gnutls_certificate_server_set_request(*session,
498
GNUTLS_CERT_IGNORE);
608
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
499
609
500
gnutls_dh_set_prime_bits(*session, mc->dh_bits);
610
gnutls_dh_set_prime_bits(*session, mc.dh_bits);
501
611
502
612
return 0;
503
613
}
509
619
/* Called when a Mandos server is found */
510
620
static int start_mandos_communication(const char *ip, uint16_t port,
511
621
AvahiIfIndex if_index,
512
mandos_context *mc){
513
int ret, tcp_sd;
622
int af){
623
int ret, tcp_sd = -1;
514
624
ssize_t sret;
515
union { struct sockaddr in; struct sockaddr_in6 in6; } to;
625
union {
626
struct sockaddr_in in;
627
struct sockaddr_in6 in6;
628
} to;
516
629
char *buffer = NULL;
517
char *decrypted_buffer;
630
char *decrypted_buffer = NULL;
518
631
size_t buffer_length = 0;
519
632
size_t buffer_capacity = 0;
520
ssize_t decrypted_buffer_size;
521
633
size_t written;
522
int retval = 0;
523
char interface[IF_NAMESIZE];
634
int retval = -1;
524
635
gnutls_session_t session;
525
526
ret = init_gnutls_session(mc, &session);
636
int pf; /* Protocol family */
637
638
errno = 0;
639
640
if(quit_now){
641
errno = EINTR;
642
return -1;
643
}
644
645
switch(af){
646
case AF_INET6:
647
pf = PF_INET6;
648
break;
649
case AF_INET:
650
pf = PF_INET;
651
break;
652
default:
653
fprintf_plus(stderr, "Bad address family: %d\n", af);
654
errno = EINVAL;
655
return -1;
656
}
657
658
ret = init_gnutls_session(&session);
527
659
if(ret != 0){
528
660
return -1;
529
661
}
530
662
531
663
if(debug){
532
fprintf(stderr, "Setting up a tcp connection to %s, port %" PRIu16
533
"\n", ip, port);
664
fprintf_plus(stderr, "Setting up a TCP connection to %s, port %"
665
PRIu16 "\n", ip, port);
534
666
}
535
667
536
tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
668
tcp_sd = socket(pf, SOCK_STREAM, 0);
537
669
if(tcp_sd < 0){
538
perror("socket");
539
return -1;
670
int e = errno;
671
perror_plus("socket");
672
errno = e;
673
goto mandos_end;
540
674
}
541
675
542
if(debug){
543
if(if_indextoname((unsigned int)if_index, interface) == NULL){
544
perror("if_indextoname");
545
return -1;
546
}
547
fprintf(stderr, "Binding to interface %s\n", interface);
676
if(quit_now){
677
errno = EINTR;
678
goto mandos_end;
548
679
}
549
680
550
681
memset(&to, 0, sizeof(to));
551
to.in6.sin6_family = AF_INET6;
552
/* It would be nice to have a way to detect if we were passed an
553
IPv4 address here. Now we assume an IPv6 address. */
554
ret = inet_pton(AF_INET6, ip, &to.in6.sin6_addr);
682
if(af == AF_INET6){
683
to.in6.sin6_family = (sa_family_t)af;
684
ret = inet_pton(af, ip, &to.in6.sin6_addr);
685
} else { /* IPv4 */
686
to.in.sin_family = (sa_family_t)af;
687
ret = inet_pton(af, ip, &to.in.sin_addr);
688
}
555
689
if(ret < 0 ){
556
perror("inet_pton");
557
return -1;
690
int e = errno;
691
perror_plus("inet_pton");
692
errno = e;
693
goto mandos_end;
558
694
}
559
695
if(ret == 0){
560
fprintf(stderr, "Bad address: %s\n", ip);
561
return -1;
696
int e = errno;
697
fprintf_plus(stderr, "Bad address: %s\n", ip);
698
errno = e;
699
goto mandos_end;
562
700
}
563
to.in6.sin6_port = htons(port); /* Spurious warnings from
701
if(af == AF_INET6){
702
to.in6.sin6_port = htons(port); /* Spurious warnings from
703
-Wconversion and
704
-Wunreachable-code */
705
706
if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
707
(&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
708
-Wunreachable-code*/
709
if(if_index == AVAHI_IF_UNSPEC){
710
fprintf_plus(stderr, "An IPv6 link-local address is"
711
" incomplete without a network interface\n");
712
errno = EINVAL;
713
goto mandos_end;
714
}
715
/* Set the network interface number as scope */
716
to.in6.sin6_scope_id = (uint32_t)if_index;
717
}
718
} else {
719
to.in.sin_port = htons(port); /* Spurious warnings from
564
720
-Wconversion and
565
721
-Wunreachable-code */
722
}
566
723
567
to.in6.sin6_scope_id = (uint32_t)if_index;
724
if(quit_now){
725
errno = EINTR;
726
goto mandos_end;
727
}
568
728
569
729
if(debug){
570
fprintf(stderr, "Connection to: %s, port %" PRIu16 "\n", ip,
571
port);
572
char addrstr[INET6_ADDRSTRLEN] = "";
573
if(inet_ntop(to.in6.sin6_family, &(to.in6.sin6_addr), addrstr,
574
sizeof(addrstr)) == NULL){
575
perror("inet_ntop");
730
if(af == AF_INET6 and if_index != AVAHI_IF_UNSPEC){
731
char interface[IF_NAMESIZE];
732
if(if_indextoname((unsigned int)if_index, interface) == NULL){
733
perror_plus("if_indextoname");
734
} else {
735
fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIu16
736
"\n", ip, interface, port);
737
}
738
} else {
739
fprintf_plus(stderr, "Connection to: %s, port %" PRIu16 "\n",
740
ip, port);
741
}
742
char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
743
INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
744
const char *pcret;
745
if(af == AF_INET6){
746
pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
747
sizeof(addrstr));
748
} else {
749
pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
750
sizeof(addrstr));
751
}
752
if(pcret == NULL){
753
perror_plus("inet_ntop");
576
754
} else {
577
755
if(strcmp(addrstr, ip) != 0){
578
fprintf(stderr, "Canonical address form: %s\n", addrstr);
756
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
579
757
}
580
758
}
581
759
}
582
760
583
ret = connect(tcp_sd, &to.in, sizeof(to));
761
if(quit_now){
762
errno = EINTR;
763
goto mandos_end;
764
}
765
766
if(af == AF_INET6){
767
ret = connect(tcp_sd, &to.in6, sizeof(to));
768
} else {
769
ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
770
}
584
771
if(ret < 0){
585
perror("connect");
586
return -1;
772
if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
773
int e = errno;
774
perror_plus("connect");
775
errno = e;
776
}
777
goto mandos_end;
778
}
779
780
if(quit_now){
781
errno = EINTR;
782
goto mandos_end;
587
783
}
588
784
589
785
const char *out = mandos_protocol_version;
591
787
while(true){
592
788
size_t out_size = strlen(out);
593
789
ret = (int)TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
594
out_size - written));
790
out_size - written));
595
791
if(ret == -1){
596
perror("write");
597
retval = -1;
792
int e = errno;
793
perror_plus("write");
794
errno = e;
598
795
goto mandos_end;
599
796
}
600
797
written += (size_t)ret;
608
805
break;
609
806
}
610
807
}
808
809
if(quit_now){
810
errno = EINTR;
811
goto mandos_end;
812
}
611
813
}
612
814
613
815
if(debug){
614
fprintf(stderr, "Establishing TLS session with %s\n", ip);
615
}
616
617
gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
618
619
do{
816
fprintf_plus(stderr, "Establishing TLS session with %s\n", ip);
817
}
818
819
if(quit_now){
820
errno = EINTR;
821
goto mandos_end;
822
}
823
824
/* This casting via intptr_t is to eliminate warning about casting
825
an int to a pointer type. This is exactly how the GnuTLS Guile
826
function "set-session-transport-fd!" does it. */
827
gnutls_transport_set_ptr(session,
828
(gnutls_transport_ptr_t)(intptr_t)tcp_sd);
829
830
if(quit_now){
831
errno = EINTR;
832
goto mandos_end;
833
}
834
835
do {
620
836
ret = gnutls_handshake(session);
837
if(quit_now){
838
errno = EINTR;
839
goto mandos_end;
840
}
621
841
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
622
842
623
843
if(ret != GNUTLS_E_SUCCESS){
624
844
if(debug){
625
fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
845
fprintf_plus(stderr, "*** GnuTLS Handshake failed ***\n");
626
846
gnutls_perror(ret);
627
847
}
628
retval = -1;
848
errno = EPROTO;
629
849
goto mandos_end;
630
850
}
631
851
632
852
/* Read OpenPGP packet that contains the wanted password */
633
853
634
854
if(debug){
635
fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
636
ip);
855
fprintf_plus(stderr, "Retrieving OpenPGP encrypted password from"
856
" %s\n", ip);
637
857
}
638
858
639
859
while(true){
640
buffer_capacity = adjustbuffer(&buffer, buffer_length,
641
buffer_capacity);
860
861
if(quit_now){
862
errno = EINTR;
863
goto mandos_end;
864
}
865
866
buffer_capacity = incbuffer(&buffer, buffer_length,
867
buffer_capacity);
642
868
if(buffer_capacity == 0){
643
perror("adjustbuffer");
644
retval = -1;
869
int e = errno;
870
perror_plus("incbuffer");
871
errno = e;
872
goto mandos_end;
873
}
874
875
if(quit_now){
876
errno = EINTR;
645
877
goto mandos_end;
646
878
}
647
879
656
888
case GNUTLS_E_AGAIN:
657
889
break;
658
890
case GNUTLS_E_REHANDSHAKE:
659
do{
891
do {
660
892
ret = gnutls_handshake(session);
893
894
if(quit_now){
895
errno = EINTR;
896
goto mandos_end;
897
}
661
898
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
662
899
if(ret < 0){
663
fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
900
fprintf_plus(stderr, "*** GnuTLS Re-handshake failed "
901
"***\n");
664
902
gnutls_perror(ret);
665
retval = -1;
903
errno = EPROTO;
666
904
goto mandos_end;
667
905
}
668
906
break;
669
907
default:
670
fprintf(stderr, "Unknown error while reading data from"
671
" encrypted session with Mandos server\n");
672
retval = -1;
908
fprintf_plus(stderr, "Unknown error while reading data from"
909
" encrypted session with Mandos server\n");
673
910
gnutls_bye(session, GNUTLS_SHUT_RDWR);
911
errno = EIO;
674
912
goto mandos_end;
675
913
}
676
914
} else {
679
917
}
680
918
681
919
if(debug){
682
fprintf(stderr, "Closing TLS session\n");
683
}
684
685
gnutls_bye(session, GNUTLS_SHUT_RDWR);
920
fprintf_plus(stderr, "Closing TLS session\n");
921
}
922
923
if(quit_now){
924
errno = EINTR;
925
goto mandos_end;
926
}
927
928
do {
929
ret = gnutls_bye(session, GNUTLS_SHUT_RDWR);
930
if(quit_now){
931
errno = EINTR;
932
goto mandos_end;
933
}
934
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
686
935
687
936
if(buffer_length > 0){
688
decrypted_buffer_size = pgp_packet_decrypt(mc, buffer,
689
buffer_length,
937
ssize_t decrypted_buffer_size;
938
decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
690
939
&decrypted_buffer);
691
940
if(decrypted_buffer_size >= 0){
941
692
942
written = 0;
693
943
while(written < (size_t) decrypted_buffer_size){
944
if(quit_now){
945
errno = EINTR;
946
goto mandos_end;
947
}
948
694
949
ret = (int)fwrite(decrypted_buffer + written, 1,
695
950
(size_t)decrypted_buffer_size - written,
696
951
stdout);
697
952
if(ret == 0 and ferror(stdout)){
953
int e = errno;
698
954
if(debug){
699
fprintf(stderr, "Error writing encrypted data: %s\n",
700
strerror(errno));
955
fprintf_plus(stderr, "Error writing encrypted data: %s\n",
956
strerror(errno));
701
957
}
702
retval = -1;
703
break;
958
errno = e;
959
goto mandos_end;
704
960
}
705
961
written += (size_t)ret;
706
962
}
707
free(decrypted_buffer);
708
} else {
709
retval = -1;
963
retval = 0;
710
964
}
711
} else {
712
retval = -1;
713
965
}
714
966
715
967
/* Shutdown procedure */
716
968
717
969
mandos_end:
718
free(buffer);
719
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
720
if(ret == -1){
721
perror("close");
970
{
971
int e = errno;
972
free(decrypted_buffer);
973
free(buffer);
974
if(tcp_sd >= 0){
975
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
976
}
977
if(ret == -1){
978
if(e == 0){
979
e = errno;
980
}
981
perror_plus("close");
982
}
983
gnutls_deinit(session);
984
errno = e;
985
if(quit_now){
986
errno = EINTR;
987
retval = -1;
988
}
722
989
}
723
gnutls_deinit(session);
724
990
return retval;
725
991
}
726
992
727
993
static void resolve_callback(AvahiSServiceResolver *r,
728
994
AvahiIfIndex interface,
729
AVAHI_GCC_UNUSED AvahiProtocol protocol,
995
AvahiProtocol proto,
730
996
AvahiResolverEvent event,
731
997
const char *name,
732
998
const char *type,
737
1003
AVAHI_GCC_UNUSED AvahiStringList *txt,
738
1004
AVAHI_GCC_UNUSED AvahiLookupResultFlags
739
1005
flags,
740
void* userdata){
741
mandos_context *mc = userdata;
1006
AVAHI_GCC_UNUSED void* userdata){
742
1007
assert(r);
743
1008
744
1009
/* Called whenever a service has been resolved successfully or
745
1010
timed out */
746
1011
1012
if(quit_now){
1013
return;
1014
}
1015
747
1016
switch(event){
748
1017
default:
749
1018
case AVAHI_RESOLVER_FAILURE:
750
fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
751
" of type '%s' in domain '%s': %s\n", name, type, domain,
752
avahi_strerror(avahi_server_errno(mc->server)));
1019
fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
1020
"'%s' of type '%s' in domain '%s': %s\n", name, type,
1021
domain,
1022
avahi_strerror(avahi_server_errno(mc.server)));
753
1023
break;
754
1024
755
1025
case AVAHI_RESOLVER_FOUND:
757
1027
char ip[AVAHI_ADDRESS_STR_MAX];
758
1028
avahi_address_snprint(ip, sizeof(ip), address);
759
1029
if(debug){
760
fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %"
761
PRIdMAX ") on port %" PRIu16 "\n", name, host_name,
762
ip, (intmax_t)interface, port);
1030
fprintf_plus(stderr, "Mandos server \"%s\" found on %s (%s, %"
1031
PRIdMAX ") on port %" PRIu16 "\n", name,
1032
host_name, ip, (intmax_t)interface, port);
763
1033
}
764
int ret = start_mandos_communication(ip, port, interface, mc);
1034
int ret = start_mandos_communication(ip, port, interface,
1035
avahi_proto_to_af(proto));
765
1036
if(ret == 0){
766
avahi_simple_poll_quit(mc->simple_poll);
1037
avahi_simple_poll_quit(mc.simple_poll);
1038
} else {
1039
if(not add_server(ip, port, interface,
1040
avahi_proto_to_af(proto))){
1041
fprintf_plus(stderr, "Failed to add server \"%s\" to server"
1042
" list\n", name);
1043
}
767
1044
}
768
1045
}
769
1046
}
779
1056
const char *domain,
780
1057
AVAHI_GCC_UNUSED AvahiLookupResultFlags
781
1058
flags,
782
void* userdata){
783
mandos_context *mc = userdata;
1059
AVAHI_GCC_UNUSED void* userdata){
784
1060
assert(b);
785
1061
786
1062
/* Called whenever a new services becomes available on the LAN or
787
1063
is removed from the LAN */
788
1064
1065
if(quit_now){
1066
return;
1067
}
1068
789
1069
switch(event){
790
1070
default:
791
1071
case AVAHI_BROWSER_FAILURE:
792
1072
793
fprintf(stderr, "(Avahi browser) %s\n",
794
avahi_strerror(avahi_server_errno(mc->server)));
795
avahi_simple_poll_quit(mc->simple_poll);
1073
fprintf_plus(stderr, "(Avahi browser) %s\n",
1074
avahi_strerror(avahi_server_errno(mc.server)));
1075
avahi_simple_poll_quit(mc.simple_poll);
796
1076
return;
797
1077
798
1078
case AVAHI_BROWSER_NEW:
801
1081
the callback function is called the Avahi server will free the
802
1082
resolver for us. */
803
1083
804
if(!(avahi_s_service_resolver_new(mc->server, interface,
805
protocol, name, type, domain,
806
AVAHI_PROTO_INET6, 0,
807
resolve_callback, mc)))
808
fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
809
name, avahi_strerror(avahi_server_errno(mc->server)));
1084
if(avahi_s_service_resolver_new(mc.server, interface, protocol,
1085
name, type, domain, protocol, 0,
1086
resolve_callback, NULL) == NULL)
1087
fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
1088
" %s\n", name,
1089
avahi_strerror(avahi_server_errno(mc.server)));
810
1090
break;
811
1091
812
1092
case AVAHI_BROWSER_REMOVE:
815
1095
case AVAHI_BROWSER_ALL_FOR_NOW:
816
1096
case AVAHI_BROWSER_CACHE_EXHAUSTED:
817
1097
if(debug){
818
fprintf(stderr, "No Mandos server found, still searching...\n");
1098
fprintf_plus(stderr, "No Mandos server found, still"
1099
" searching...\n");
819
1100
}
820
1101
break;
821
1102
}
822
1103
}
823
1104
1105
/* Signal handler that stops main loop after SIGTERM */
1106
static void handle_sigterm(int sig){
1107
if(quit_now){
1108
return;
1109
}
1110
quit_now = 1;
1111
signal_received = sig;
1112
int old_errno = errno;
1113
/* set main loop to exit */
1114
if(mc.simple_poll != NULL){
1115
avahi_simple_poll_quit(mc.simple_poll);
1116
}
1117
errno = old_errno;
1118
}
1119
1120
bool get_flags(const char *ifname, struct ifreq *ifr){
1121
int ret;
1122
1123
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1124
if(s < 0){
1125
perror_plus("socket");
1126
return false;
1127
}
1128
strcpy(ifr->ifr_name, ifname);
1129
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1130
if(ret == -1){
1131
if(debug){
1132
perror_plus("ioctl SIOCGIFFLAGS");
1133
}
1134
return false;
1135
}
1136
return true;
1137
}
1138
1139
bool good_flags(const char *ifname, const struct ifreq *ifr){
1140
1141
/* Reject the loopback device */
1142
if(ifr->ifr_flags & IFF_LOOPBACK){
1143
if(debug){
1144
fprintf_plus(stderr, "Rejecting loopback interface \"%s\"\n",
1145
ifname);
1146
}
1147
return false;
1148
}
1149
/* Accept point-to-point devices only if connect_to is specified */
1150
if(connect_to != NULL and (ifr->ifr_flags & IFF_POINTOPOINT)){
1151
if(debug){
1152
fprintf_plus(stderr, "Accepting point-to-point interface"
1153
" \"%s\"\n", ifname);
1154
}
1155
return true;
1156
}
1157
/* Otherwise, reject non-broadcast-capable devices */
1158
if(not (ifr->ifr_flags & IFF_BROADCAST)){
1159
if(debug){
1160
fprintf_plus(stderr, "Rejecting non-broadcast interface"
1161
" \"%s\"\n", ifname);
1162
}
1163
return false;
1164
}
1165
/* Reject non-ARP interfaces (including dummy interfaces) */
1166
if(ifr->ifr_flags & IFF_NOARP){
1167
if(debug){
1168
fprintf_plus(stderr, "Rejecting non-ARP interface \"%s\"\n",
1169
ifname);
1170
}
1171
return false;
1172
}
1173
1174
/* Accept this device */
1175
if(debug){
1176
fprintf_plus(stderr, "Interface \"%s\" is good\n", ifname);
1177
}
1178
return true;
1179
}
1180
1181
/*
1182
* This function determines if a directory entry in /sys/class/net
1183
* corresponds to an acceptable network device.
1184
* (This function is passed to scandir(3) as a filter function.)
1185
*/
1186
int good_interface(const struct dirent *if_entry){
1187
if(if_entry->d_name[0] == '.'){
1188
return 0;
1189
}
1190
1191
struct ifreq ifr;
1192
if(not get_flags(if_entry->d_name, &ifr)){
1193
if(debug){
1194
fprintf_plus(stderr, "Failed to get flags for interface "
1195
"\"%s\"\n", if_entry->d_name);
1196
}
1197
return 0;
1198
}
1199
1200
if(not good_flags(if_entry->d_name, &ifr)){
1201
return 0;
1202
}
1203
return 1;
1204
}
1205
1206
/*
1207
* This function determines if a directory entry in /sys/class/net
1208
* corresponds to an acceptable network device which is up.
1209
* (This function is passed to scandir(3) as a filter function.)
1210
*/
1211
int up_interface(const struct dirent *if_entry){
1212
if(if_entry->d_name[0] == '.'){
1213
return 0;
1214
}
1215
1216
struct ifreq ifr;
1217
if(not get_flags(if_entry->d_name, &ifr)){
1218
if(debug){
1219
fprintf_plus(stderr, "Failed to get flags for interface "
1220
"\"%s\"\n", if_entry->d_name);
1221
}
1222
return 0;
1223
}
1224
1225
/* Reject down interfaces */
1226
if(not (ifr.ifr_flags & IFF_UP)){
1227
if(debug){
1228
fprintf_plus(stderr, "Rejecting down interface \"%s\"\n",
1229
if_entry->d_name);
1230
}
1231
return 0;
1232
}
1233
1234
/* Reject non-running interfaces */
1235
if(not (ifr.ifr_flags & IFF_RUNNING)){
1236
if(debug){
1237
fprintf_plus(stderr, "Rejecting non-running interface \"%s\"\n",
1238
if_entry->d_name);
1239
}
1240
return 0;
1241
}
1242
1243
if(not good_flags(if_entry->d_name, &ifr)){
1244
return 0;
1245
}
1246
return 1;
1247
}
1248
1249
int notdotentries(const struct dirent *direntry){
1250
/* Skip "." and ".." */
1251
if(direntry->d_name[0] == '.'
1252
and (direntry->d_name[1] == '\0'
1253
or (direntry->d_name[1] == '.'
1254
and direntry->d_name[2] == '\0'))){
1255
return 0;
1256
}
1257
return 1;
1258
}
1259
1260
/* Is this directory entry a runnable program? */
1261
int runnable_hook(const struct dirent *direntry){
1262
int ret;
1263
size_t sret;
1264
struct stat st;
1265
1266
if((direntry->d_name)[0] == '\0'){
1267
/* Empty name? */
1268
return 0;
1269
}
1270
1271
sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1272
"abcdefghijklmnopqrstuvwxyz"
1273
"0123456789"
1274
"_-");
1275
if((direntry->d_name)[sret] != '\0'){
1276
/* Contains non-allowed characters */
1277
if(debug){
1278
fprintf_plus(stderr, "Ignoring hook \"%s\" with bad name\n",
1279
direntry->d_name);
1280
}
1281
return 0;
1282
}
1283
1284
char *fullname = NULL;
1285
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1286
if(ret < 0){
1287
perror_plus("asprintf");
1288
return 0;
1289
}
1290
1291
ret = stat(fullname, &st);
1292
if(ret == -1){
1293
if(debug){
1294
perror_plus("Could not stat hook");
1295
}
1296
return 0;
1297
}
1298
if(not (S_ISREG(st.st_mode))){
1299
/* Not a regular file */
1300
if(debug){
1301
fprintf_plus(stderr, "Ignoring hook \"%s\" - not a file\n",
1302
direntry->d_name);
1303
}
1304
return 0;
1305
}
1306
if(not (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))){
1307
/* Not executable */
1308
if(debug){
1309
fprintf_plus(stderr, "Ignoring hook \"%s\" - not executable\n",
1310
direntry->d_name);
1311
}
1312
return 0;
1313
}
1314
if(debug){
1315
fprintf_plus(stderr, "Hook \"%s\" is acceptable\n",
1316
direntry->d_name);
1317
}
1318
return 1;
1319
}
1320
1321
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval){
1322
int ret;
1323
struct timespec now;
1324
struct timespec waited_time;
1325
intmax_t block_time;
1326
1327
while(true){
1328
if(mc.current_server == NULL){
1329
if (debug){
1330
fprintf_plus(stderr, "Wait until first server is found."
1331
" No timeout!\n");
1332
}
1333
ret = avahi_simple_poll_iterate(s, -1);
1334
} else {
1335
if (debug){
1336
fprintf_plus(stderr, "Check current_server if we should run"
1337
" it, or wait\n");
1338
}
1339
/* the current time */
1340
ret = clock_gettime(CLOCK_MONOTONIC, &now);
1341
if(ret == -1){
1342
perror_plus("clock_gettime");
1343
return -1;
1344
}
1345
/* Calculating in ms how long time between now and server
1346
who we visted longest time ago. Now - last seen. */
1347
waited_time.tv_sec = (now.tv_sec
1348
- mc.current_server->last_seen.tv_sec);
1349
waited_time.tv_nsec = (now.tv_nsec
1350
- mc.current_server->last_seen.tv_nsec);
1351
/* total time is 10s/10,000ms.
1352
Converting to s from ms by dividing by 1,000,
1353
and ns to ms by dividing by 1,000,000. */
1354
block_time = ((retry_interval
1355
- ((intmax_t)waited_time.tv_sec * 1000))
1356
- ((intmax_t)waited_time.tv_nsec / 1000000));
1357
1358
if (debug){
1359
fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1360
block_time);
1361
}
1362
1363
if(block_time <= 0){
1364
ret = start_mandos_communication(mc.current_server->ip,
1365
mc.current_server->port,
1366
mc.current_server->if_index,
1367
mc.current_server->af);
1368
if(ret == 0){
1369
avahi_simple_poll_quit(mc.simple_poll);
1370
return 0;
1371
}
1372
ret = clock_gettime(CLOCK_MONOTONIC,
1373
&mc.current_server->last_seen);
1374
if(ret == -1){
1375
perror_plus("clock_gettime");
1376
return -1;
1377
}
1378
mc.current_server = mc.current_server->next;
1379
block_time = 0; /* Call avahi to find new Mandos
1380
servers, but don't block */
1381
}
1382
1383
ret = avahi_simple_poll_iterate(s, (int)block_time);
1384
}
1385
if(ret != 0){
1386
if (ret > 0 or errno != EINTR){
1387
return (ret != 1) ? ret : 0;
1388
}
1389
}
1390
}
1391
}
1392
1393
bool run_network_hooks(const char *mode, const char *interface,
1394
const float delay){
1395
struct dirent **direntries;
1396
struct dirent *direntry;
1397
int ret;
1398
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1399
alphasort);
1400
if(numhooks == -1){
1401
perror_plus("scandir");
1402
} else {
1403
int devnull = open("/dev/null", O_RDONLY);
1404
for(int i = 0; i < numhooks; i++){
1405
direntry = direntries[i];
1406
char *fullname = NULL;
1407
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1408
if(ret < 0){
1409
perror_plus("asprintf");
1410
continue;
1411
}
1412
if(debug){
1413
fprintf_plus(stderr, "Running network hook \"%s\"\n",
1414
direntry->d_name);
1415
}
1416
pid_t hook_pid = fork();
1417
if(hook_pid == 0){
1418
/* Child */
1419
/* Raise privileges */
1420
errno = 0;
1421
ret = seteuid(0);
1422
if(ret == -1){
1423
perror_plus("seteuid");
1424
}
1425
/* Raise privileges even more */
1426
errno = 0;
1427
ret = setuid(0);
1428
if(ret == -1){
1429
perror_plus("setuid");
1430
}
1431
/* Set group */
1432
errno = 0;
1433
ret = setgid(0);
1434
if(ret == -1){
1435
perror_plus("setgid");
1436
}
1437
/* Reset supplementary groups */
1438
errno = 0;
1439
ret = setgroups(0, NULL);
1440
if(ret == -1){
1441
perror_plus("setgroups");
1442
}
1443
dup2(devnull, STDIN_FILENO);
1444
close(devnull);
1445
dup2(STDERR_FILENO, STDOUT_FILENO);
1446
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1447
if(ret == -1){
1448
perror_plus("setenv");
1449
_exit(EX_OSERR);
1450
}
1451
ret = setenv("DEVICE", interface, 1);
1452
if(ret == -1){
1453
perror_plus("setenv");
1454
_exit(EX_OSERR);
1455
}
1456
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
1457
if(ret == -1){
1458
perror_plus("setenv");
1459
_exit(EX_OSERR);
1460
}
1461
ret = setenv("MODE", mode, 1);
1462
if(ret == -1){
1463
perror_plus("setenv");
1464
_exit(EX_OSERR);
1465
}
1466
char *delaystring;
1467
ret = asprintf(&delaystring, "%f", delay);
1468
if(ret == -1){
1469
perror_plus("asprintf");
1470
_exit(EX_OSERR);
1471
}
1472
ret = setenv("DELAY", delaystring, 1);
1473
if(ret == -1){
1474
free(delaystring);
1475
perror_plus("setenv");
1476
_exit(EX_OSERR);
1477
}
1478
free(delaystring);
1479
if(connect_to != NULL){
1480
ret = setenv("CONNECT", connect_to, 1);
1481
if(ret == -1){
1482
perror_plus("setenv");
1483
_exit(EX_OSERR);
1484
}
1485
}
1486
if(execl(fullname, direntry->d_name, mode, NULL) == -1){
1487
perror_plus("execl");
1488
_exit(EXIT_FAILURE);
1489
}
1490
} else {
1491
int status;
1492
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1493
perror_plus("waitpid");
1494
free(fullname);
1495
continue;
1496
}
1497
if(WIFEXITED(status)){
1498
if(WEXITSTATUS(status) != 0){
1499
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1500
" with status %d\n", direntry->d_name,
1501
WEXITSTATUS(status));
1502
free(fullname);
1503
continue;
1504
}
1505
} else if(WIFSIGNALED(status)){
1506
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1507
" signal %d\n", direntry->d_name,
1508
WTERMSIG(status));
1509
free(fullname);
1510
continue;
1511
} else {
1512
fprintf_plus(stderr, "Warning: network hook \"%s\""
1513
" crashed\n", direntry->d_name);
1514
free(fullname);
1515
continue;
1516
}
1517
}
1518
free(fullname);
1519
if(debug){
1520
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1521
direntry->d_name);
1522
}
1523
}
1524
close(devnull);
1525
}
1526
return true;
1527
}
1528
824
1529
int main(int argc, char *argv[]){
825
1530
AvahiSServiceBrowser *sb = NULL;
826
1531
int error;
827
1532
int ret;
828
1533
intmax_t tmpmax;
829
int numchars;
1534
char *tmp;
830
1535
int exitcode = EXIT_SUCCESS;
831
const char *interface = "eth0";
1536
const char *interface = "";
832
1537
struct ifreq network;
833
int sd;
1538
int sd = -1;
1539
bool take_down_interface = false;
834
1540
uid_t uid;
835
1541
gid_t gid;
836
char *connect_to = NULL;
837
1542
char tempdir[] = "/tmp/mandosXXXXXX";
838
1543
bool tempdir_created = false;
839
1544
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
840
1545
const char *seckey = PATHDIR "/" SECKEY;
841
1546
const char *pubkey = PATHDIR "/" PUBKEY;
842
1547
843
mandos_context mc = { .simple_poll = NULL, .server = NULL,
844
.dh_bits = 1024, .priority = "SECURE256"
845
":!CTYPE-X.509:+CTYPE-OPENPGP" };
846
1548
bool gnutls_initialized = false;
847
1549
bool gpgme_initialized = false;
848
double delay = 2.5;
1550
float delay = 2.5f;
1551
double retry_interval = 10; /* 10s between trying a server and
1552
retrying the same server again */
1553
1554
struct sigaction old_sigterm_action = { .sa_handler = SIG_DFL };
1555
struct sigaction sigterm_action = { .sa_handler = handle_sigterm };
1556
1557
uid = getuid();
1558
gid = getgid();
1559
1560
/* Lower any group privileges we might have, just to be safe */
1561
errno = 0;
1562
ret = setgid(gid);
1563
if(ret == -1){
1564
perror_plus("setgid");
1565
}
1566
1567
/* Lower user privileges (temporarily) */
1568
errno = 0;
1569
ret = seteuid(uid);
1570
if(ret == -1){
1571
perror_plus("seteuid");
1572
}
1573
1574
if(quit_now){
1575
goto end;
1576
}
849
1577
850
1578
{
851
1579
struct argp_option options[] = {
857
1585
.group = 1 },
858
1586
{ .name = "interface", .key = 'i',
859
1587
.arg = "NAME",
860
.doc = "Interface that will be used to search for Mandos"
861
" servers",
1588
.doc = "Network interface that will be used to search for"
1589
" Mandos servers",
862
1590
.group = 1 },
863
1591
{ .name = "seckey", .key = 's',
864
1592
.arg = "FILE",
881
1609
.arg = "SECONDS",
882
1610
.doc = "Maximum delay to wait for interface startup",
883
1611
.group = 2 },
1612
{ .name = "retry", .key = 132,
1613
.arg = "SECONDS",
1614
.doc = "Retry interval used when denied by the Mandos server",
1615
.group = 2 },
1616
{ .name = "network-hook-dir", .key = 133,
1617
.arg = "DIR",
1618
.doc = "Directory where network hooks are located",
1619
.group = 2 },
1620
/*
1621
* These reproduce what we would get without ARGP_NO_HELP
1622
*/
1623
{ .name = "help", .key = '?',
1624
.doc = "Give this help list", .group = -1 },
1625
{ .name = "usage", .key = -3,
1626
.doc = "Give a short usage message", .group = -1 },
1627
{ .name = "version", .key = 'V',
1628
.doc = "Print program version", .group = -1 },
884
1629
{ .name = NULL }
885
1630
};
886
1631
887
1632
error_t parse_opt(int key, char *arg,
888
1633
struct argp_state *state){
1634
errno = 0;
889
1635
switch(key){
890
1636
case 128: /* --debug */
891
1637
debug = true;
903
1649
pubkey = arg;
904
1650
break;
905
1651
case 129: /* --dh-bits */
906
ret = sscanf(arg, "%" SCNdMAX "%n", &tmpmax, &numchars);
907
if(ret < 1 or tmpmax != (typeof(mc.dh_bits))tmpmax
908
or arg[numchars] != '\0'){
909
fprintf(stderr, "Bad number of DH bits\n");
910
exit(EXIT_FAILURE);
1652
errno = 0;
1653
tmpmax = strtoimax(arg, &tmp, 10);
1654
if(errno != 0 or tmp == arg or *tmp != '\0'
1655
or tmpmax != (typeof(mc.dh_bits))tmpmax){
1656
argp_error(state, "Bad number of DH bits");
911
1657
}
912
1658
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
913
1659
break;
915
1661
mc.priority = arg;
916
1662
break;
917
1663
case 131: /* --delay */
918
ret = sscanf(arg, "%lf%n", &delay, &numchars);
919
if(ret < 1 or arg[numchars] != '\0'){
920
fprintf(stderr, "Bad delay\n");
921
exit(EXIT_FAILURE);
922
}
923
break;
924
case ARGP_KEY_ARG:
925
argp_usage(state);
926
case ARGP_KEY_END:
1664
errno = 0;
1665
delay = strtof(arg, &tmp);
1666
if(errno != 0 or tmp == arg or *tmp != '\0'){
1667
argp_error(state, "Bad delay");
1668
}
1669
case 132: /* --retry */
1670
errno = 0;
1671
retry_interval = strtod(arg, &tmp);
1672
if(errno != 0 or tmp == arg or *tmp != '\0'
1673
or (retry_interval * 1000) > INT_MAX
1674
or retry_interval < 0){
1675
argp_error(state, "Bad retry interval");
1676
}
1677
break;
1678
case 133: /* --network-hook-dir */
1679
hookdir = arg;
1680
break;
1681
/*
1682
* These reproduce what we would get without ARGP_NO_HELP
1683
*/
1684
case '?': /* --help */
1685
argp_state_help(state, state->out_stream,
1686
(ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
1687
& ~(unsigned int)ARGP_HELP_EXIT_OK);
1688
case -3: /* --usage */
1689
argp_state_help(state, state->out_stream,
1690
ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
1691
case 'V': /* --version */
1692
fprintf_plus(state->out_stream, "%s\n", argp_program_version);
1693
exit(argp_err_exit_status);
927
1694
break;
928
1695
default:
929
1696
return ARGP_ERR_UNKNOWN;
930
1697
}
931
return 0;
1698
return errno;
932
1699
}
933
1700
934
1701
struct argp argp = { .options = options, .parser = parse_opt,
935
1702
.args_doc = "",
936
1703
.doc = "Mandos client -- Get and decrypt"
937
1704
" passwords from a Mandos server" };
938
ret = argp_parse(&argp, argc, argv, 0, 0, NULL);
939
if(ret == ARGP_ERR_UNKNOWN){
940
fprintf(stderr, "Unknown error while parsing arguments\n");
1705
ret = argp_parse(&argp, argc, argv,
1706
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
1707
switch(ret){
1708
case 0:
1709
break;
1710
case ENOMEM:
1711
default:
1712
errno = ret;
1713
perror_plus("argp_parse");
1714
exitcode = EX_OSERR;
1715
goto end;
1716
case EINVAL:
1717
exitcode = EX_USAGE;
1718
goto end;
1719
}
1720
}
1721
1722
{
1723
/* Work around Debian bug #633582:
1724
<http://bugs.debian.org/633582> */
1725
1726
/* Re-raise priviliges */
1727
errno = 0;
1728
ret = seteuid(0);
1729
if(ret == -1){
1730
perror_plus("seteuid");
1731
} else {
1732
struct stat st;
1733
1734
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
1735
int seckey_fd = open(seckey, O_RDONLY);
1736
if(seckey_fd == -1){
1737
perror_plus("open");
1738
} else {
1739
ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
1740
if(ret == -1){
1741
perror_plus("fstat");
1742
} else {
1743
if(S_ISREG(st.st_mode)
1744
and st.st_uid == 0 and st.st_gid == 0){
1745
ret = fchown(seckey_fd, uid, gid);
1746
if(ret == -1){
1747
perror_plus("fchown");
1748
}
1749
}
1750
}
1751
TEMP_FAILURE_RETRY(close(seckey_fd));
1752
}
1753
}
1754
1755
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
1756
int pubkey_fd = open(pubkey, O_RDONLY);
1757
if(pubkey_fd == -1){
1758
perror_plus("open");
1759
} else {
1760
ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
1761
if(ret == -1){
1762
perror_plus("fstat");
1763
} else {
1764
if(S_ISREG(st.st_mode)
1765
and st.st_uid == 0 and st.st_gid == 0){
1766
ret = fchown(pubkey_fd, uid, gid);
1767
if(ret == -1){
1768
perror_plus("fchown");
1769
}
1770
}
1771
}
1772
TEMP_FAILURE_RETRY(close(pubkey_fd));
1773
}
1774
}
1775
1776
/* Lower privileges */
1777
errno = 0;
1778
ret = seteuid(uid);
1779
if(ret == -1){
1780
perror_plus("seteuid");
1781
}
1782
}
1783
}
1784
1785
/* Run network hooks */
1786
if(not run_network_hooks("start", interface, delay)){
1787
goto end;
1788
}
1789
1790
if(not debug){
1791
avahi_set_log_function(empty_log);
1792
}
1793
1794
if(interface[0] == '\0'){
1795
struct dirent **direntries;
1796
/* First look for interfaces that are up */
1797
ret = scandir(sys_class_net, &direntries, up_interface,
1798
alphasort);
1799
if(ret == 0){
1800
/* No up interfaces, look for any good interfaces */
1801
free(direntries);
1802
ret = scandir(sys_class_net, &direntries, good_interface,
1803
alphasort);
1804
}
1805
if(ret >= 1){
1806
/* Pick the first interface returned */
1807
interface = strdup(direntries[0]->d_name);
1808
if(debug){
1809
fprintf_plus(stderr, "Using interface \"%s\"\n", interface);
1810
}
1811
if(interface == NULL){
1812
perror_plus("malloc");
1813
free(direntries);
1814
exitcode = EXIT_FAILURE;
1815
goto end;
1816
}
1817
free(direntries);
1818
} else {
1819
free(direntries);
1820
fprintf_plus(stderr, "Could not find a network interface\n");
941
1821
exitcode = EXIT_FAILURE;
942
1822
goto end;
943
1823
}
944
1824
}
945
1825
1826
/* Initialize Avahi early so avahi_simple_poll_quit() can be called
1827
from the signal handler */
1828
/* Initialize the pseudo-RNG for Avahi */
1829
srand((unsigned int) time(NULL));
1830
mc.simple_poll = avahi_simple_poll_new();
1831
if(mc.simple_poll == NULL){
1832
fprintf_plus(stderr,
1833
"Avahi: Failed to create simple poll object.\n");
1834
exitcode = EX_UNAVAILABLE;
1835
goto end;
1836
}
1837
1838
sigemptyset(&sigterm_action.sa_mask);
1839
ret = sigaddset(&sigterm_action.sa_mask, SIGINT);
1840
if(ret == -1){
1841
perror_plus("sigaddset");
1842
exitcode = EX_OSERR;
1843
goto end;
1844
}
1845
ret = sigaddset(&sigterm_action.sa_mask, SIGHUP);
1846
if(ret == -1){
1847
perror_plus("sigaddset");
1848
exitcode = EX_OSERR;
1849
goto end;
1850
}
1851
ret = sigaddset(&sigterm_action.sa_mask, SIGTERM);
1852
if(ret == -1){
1853
perror_plus("sigaddset");
1854
exitcode = EX_OSERR;
1855
goto end;
1856
}
1857
/* Need to check if the handler is SIG_IGN before handling:
1858
| [[info:libc:Initial Signal Actions]] |
1859
| [[info:libc:Basic Signal Handling]] |
1860
*/
1861
ret = sigaction(SIGINT, NULL, &old_sigterm_action);
1862
if(ret == -1){
1863
perror_plus("sigaction");
1864
return EX_OSERR;
1865
}
1866
if(old_sigterm_action.sa_handler != SIG_IGN){
1867
ret = sigaction(SIGINT, &sigterm_action, NULL);
1868
if(ret == -1){
1869
perror_plus("sigaction");
1870
exitcode = EX_OSERR;
1871
goto end;
1872
}
1873
}
1874
ret = sigaction(SIGHUP, NULL, &old_sigterm_action);
1875
if(ret == -1){
1876
perror_plus("sigaction");
1877
return EX_OSERR;
1878
}
1879
if(old_sigterm_action.sa_handler != SIG_IGN){
1880
ret = sigaction(SIGHUP, &sigterm_action, NULL);
1881
if(ret == -1){
1882
perror_plus("sigaction");
1883
exitcode = EX_OSERR;
1884
goto end;
1885
}
1886
}
1887
ret = sigaction(SIGTERM, NULL, &old_sigterm_action);
1888
if(ret == -1){
1889
perror_plus("sigaction");
1890
return EX_OSERR;
1891
}
1892
if(old_sigterm_action.sa_handler != SIG_IGN){
1893
ret = sigaction(SIGTERM, &sigterm_action, NULL);
1894
if(ret == -1){
1895
perror_plus("sigaction");
1896
exitcode = EX_OSERR;
1897
goto end;
1898
}
1899
}
1900
946
1901
/* If the interface is down, bring it up */
947
{
1902
if(strcmp(interface, "none") != 0){
1903
if_index = (AvahiIfIndex) if_nametoindex(interface);
1904
if(if_index == 0){
1905
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1906
exitcode = EX_UNAVAILABLE;
1907
goto end;
1908
}
1909
1910
if(quit_now){
1911
goto end;
1912
}
1913
1914
/* Re-raise priviliges */
1915
errno = 0;
1916
ret = seteuid(0);
1917
if(ret == -1){
1918
perror_plus("seteuid");
1919
}
1920
948
1921
#ifdef __linux__
949
1922
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
950
messages to mess up the prompt */
1923
messages about the network interface to mess up the prompt */
951
1924
ret = klogctl(8, NULL, 5);
1925
bool restore_loglevel = true;
952
1926
if(ret == -1){
953
perror("klogctl");
1927
restore_loglevel = false;
1928
perror_plus("klogctl");
954
1929
}
955
#endif
1930
#endif /* __linux__ */
956
1931
957
1932
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
958
1933
if(sd < 0){
959
perror("socket");
960
exitcode = EXIT_FAILURE;
1934
perror_plus("socket");
1935
exitcode = EX_OSERR;
961
1936
#ifdef __linux__
962
ret = klogctl(7, NULL, 0);
1937
if(restore_loglevel){
1938
ret = klogctl(7, NULL, 0);
1939
if(ret == -1){
1940
perror_plus("klogctl");
1941
}
1942
}
1943
#endif /* __linux__ */
1944
/* Lower privileges */
1945
errno = 0;
1946
ret = seteuid(uid);
963
1947
if(ret == -1){
964
perror("klogctl");
1948
perror_plus("seteuid");
965
1949
}
966
#endif
967
1950
goto end;
968
1951
}
969
1952
strcpy(network.ifr_name, interface);
970
1953
ret = ioctl(sd, SIOCGIFFLAGS, &network);
971
1954
if(ret == -1){
972
perror("ioctl SIOCGIFFLAGS");
1955
perror_plus("ioctl SIOCGIFFLAGS");
973
1956
#ifdef __linux__
974
ret = klogctl(7, NULL, 0);
1957
if(restore_loglevel){
1958
ret = klogctl(7, NULL, 0);
1959
if(ret == -1){
1960
perror_plus("klogctl");
1961
}
1962
}
1963
#endif /* __linux__ */
1964
exitcode = EX_OSERR;
1965
/* Lower privileges */
1966
errno = 0;
1967
ret = seteuid(uid);
975
1968
if(ret == -1){
976
perror("klogctl");
1969
perror_plus("seteuid");
977
1970
}
978
#endif
979
exitcode = EXIT_FAILURE;
980
1971
goto end;
981
1972
}
982
1973
if((network.ifr_flags & IFF_UP) == 0){
983
1974
network.ifr_flags |= IFF_UP;
1975
take_down_interface = true;
984
1976
ret = ioctl(sd, SIOCSIFFLAGS, &network);
985
1977
if(ret == -1){
986
perror("ioctl SIOCSIFFLAGS");
987
exitcode = EXIT_FAILURE;
1978
take_down_interface = false;
1979
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1980
exitcode = EX_OSERR;
988
1981
#ifdef __linux__
989
ret = klogctl(7, NULL, 0);
1982
if(restore_loglevel){
1983
ret = klogctl(7, NULL, 0);
1984
if(ret == -1){
1985
perror_plus("klogctl");
1986
}
1987
}
1988
#endif /* __linux__ */
1989
/* Lower privileges */
1990
errno = 0;
1991
ret = seteuid(uid);
990
1992
if(ret == -1){
991
perror("klogctl");
1993
perror_plus("seteuid");
992
1994
}
993
#endif
994
1995
goto end;
995
1996
}
996
1997
}
997
/* sleep checking until interface is running */
1998
/* Sleep checking until interface is running.
1999
Check every 0.25s, up to total time of delay */
998
2000
for(int i=0; i < delay * 4; i++){
999
2001
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1000
2002
if(ret == -1){
1001
perror("ioctl SIOCGIFFLAGS");
2003
perror_plus("ioctl SIOCGIFFLAGS");
1002
2004
} else if(network.ifr_flags & IFF_RUNNING){
1003
2005
break;
1004
2006
}
1005
2007
struct timespec sleeptime = { .tv_nsec = 250000000 };
1006
2008
ret = nanosleep(&sleeptime, NULL);
1007
2009
if(ret == -1 and errno != EINTR){
1008
perror("nanosleep");
2010
perror_plus("nanosleep");
1009
2011
}
1010
2012
}
1011
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1012
if(ret == -1){
1013
perror("close");
2013
if(not take_down_interface){
2014
/* We won't need the socket anymore */
2015
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2016
if(ret == -1){
2017
perror_plus("close");
2018
}
1014
2019
}
1015
2020
#ifdef __linux__
1016
/* Restores kernel loglevel to default */
1017
ret = klogctl(7, NULL, 0);
2021
if(restore_loglevel){
2022
/* Restores kernel loglevel to default */
2023
ret = klogctl(7, NULL, 0);
2024
if(ret == -1){
2025
perror_plus("klogctl");
2026
}
2027
}
2028
#endif /* __linux__ */
2029
/* Lower privileges */
2030
errno = 0;
2031
/* Lower privileges */
2032
ret = seteuid(uid);
1018
2033
if(ret == -1){
1019
perror("klogctl");
2034
perror_plus("seteuid");
1020
2035
}
1021
#endif
1022
}
1023
1024
uid = getuid();
1025
gid = getgid();
1026
1027
setgid(gid);
1028
if(ret == -1){
1029
perror("setgid");
1030
}
1031
1032
ret = setuid(uid);
1033
if(ret == -1){
1034
perror("setuid");
1035
}
1036
1037
ret = init_gnutls_global(&mc, pubkey, seckey);
1038
if(ret == -1){
1039
fprintf(stderr, "init_gnutls_global failed\n");
1040
exitcode = EXIT_FAILURE;
2036
}
2037
2038
if(quit_now){
2039
goto end;
2040
}
2041
2042
ret = init_gnutls_global(pubkey, seckey);
2043
if(ret == -1){
2044
fprintf_plus(stderr, "init_gnutls_global failed\n");
2045
exitcode = EX_UNAVAILABLE;
1041
2046
goto end;
1042
2047
} else {
1043
2048
gnutls_initialized = true;
1044
2049
}
1045
2050
2051
if(quit_now){
2052
goto end;
2053
}
2054
1046
2055
if(mkdtemp(tempdir) == NULL){
1047
perror("mkdtemp");
2056
perror_plus("mkdtemp");
1048
2057
goto end;
1049
2058
}
1050
2059
tempdir_created = true;
1051
2060
1052
if(not init_gpgme(&mc, pubkey, seckey, tempdir)){
1053
fprintf(stderr, "init_gpgme failed\n");
1054
exitcode = EXIT_FAILURE;
2061
if(quit_now){
2062
goto end;
2063
}
2064
2065
if(not init_gpgme(pubkey, seckey, tempdir)){
2066
fprintf_plus(stderr, "init_gpgme failed\n");
2067
exitcode = EX_UNAVAILABLE;
1055
2068
goto end;
1056
2069
} else {
1057
2070
gpgme_initialized = true;
1058
2071
}
1059
2072
1060
if_index = (AvahiIfIndex) if_nametoindex(interface);
1061
if(if_index == 0){
1062
fprintf(stderr, "No such interface: \"%s\"\n", interface);
1063
exitcode = EXIT_FAILURE;
2073
if(quit_now){
1064
2074
goto end;
1065
2075
}
1066
2076
1069
2079
/* (Mainly meant for debugging) */
1070
2080
char *address = strrchr(connect_to, ':');
1071
2081
if(address == NULL){
1072
fprintf(stderr, "No colon in address\n");
1073
exitcode = EXIT_FAILURE;
1074
goto end;
1075
}
2082
fprintf_plus(stderr, "No colon in address\n");
2083
exitcode = EX_USAGE;
2084
goto end;
2085
}
2086
2087
if(quit_now){
2088
goto end;
2089
}
2090
1076
2091
uint16_t port;
1077
ret = sscanf(address+1, "%" SCNdMAX "%n", &tmpmax, &numchars);
1078
if(ret < 1 or tmpmax != (uint16_t)tmpmax
1079
or address[numchars+1] != '\0'){
1080
fprintf(stderr, "Bad port number\n");
1081
exitcode = EXIT_FAILURE;
1082
goto end;
1083
}
2092
errno = 0;
2093
tmpmax = strtoimax(address+1, &tmp, 10);
2094
if(errno != 0 or tmp == address+1 or *tmp != '\0'
2095
or tmpmax != (uint16_t)tmpmax){
2096
fprintf_plus(stderr, "Bad port number\n");
2097
exitcode = EX_USAGE;
2098
goto end;
2099
}
2100
2101
if(quit_now){
2102
goto end;
2103
}
2104
1084
2105
port = (uint16_t)tmpmax;
1085
2106
*address = '\0';
2107
/* Colon in address indicates IPv6 */
2108
int af;
2109
if(strchr(connect_to, ':') != NULL){
2110
af = AF_INET6;
2111
/* Accept [] around IPv6 address - see RFC 5952 */
2112
if(connect_to[0] == '[' and address[-1] == ']')
2113
{
2114
connect_to++;
2115
address[-1] = '\0';
2116
}
2117
} else {
2118
af = AF_INET;
2119
}
1086
2120
address = connect_to;
1087
ret = start_mandos_communication(address, port, if_index, &mc);
1088
if(ret < 0){
1089
exitcode = EXIT_FAILURE;
1090
} else {
2121
2122
if(quit_now){
2123
goto end;
2124
}
2125
2126
while(not quit_now){
2127
ret = start_mandos_communication(address, port, if_index, af);
2128
if(quit_now or ret == 0){
2129
break;
2130
}
2131
if(debug){
2132
fprintf_plus(stderr, "Retrying in %d seconds\n",
2133
(int)retry_interval);
2134
}
2135
sleep((int)retry_interval);
2136
}
2137
2138
if (not quit_now){
1091
2139
exitcode = EXIT_SUCCESS;
1092
2140
}
2141
1093
2142
goto end;
1094
2143
}
1095
2144
1096
if(not debug){
1097
avahi_set_log_function(empty_log);
1098
}
1099
1100
/* Initialize the pseudo-RNG for Avahi */
1101
srand((unsigned int) time(NULL));
1102
1103
/* Allocate main Avahi loop object */
1104
mc.simple_poll = avahi_simple_poll_new();
1105
if(mc.simple_poll == NULL){
1106
fprintf(stderr, "Avahi: Failed to create simple poll object.\n");
1107
exitcode = EXIT_FAILURE;
2145
if(quit_now){
1108
2146
goto end;
1109
2147
}
1110
2148
1128
2166
1129
2167
/* Check if creating the Avahi server object succeeded */
1130
2168
if(mc.server == NULL){
1131
fprintf(stderr, "Failed to create Avahi server: %s\n",
1132
avahi_strerror(error));
1133
exitcode = EXIT_FAILURE;
2169
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2170
avahi_strerror(error));
2171
exitcode = EX_UNAVAILABLE;
2172
goto end;
2173
}
2174
2175
if(quit_now){
1134
2176
goto end;
1135
2177
}
1136
2178
1137
2179
/* Create the Avahi service browser */
1138
2180
sb = avahi_s_service_browser_new(mc.server, if_index,
1139
AVAHI_PROTO_INET6, "_mandos._tcp",
1140
NULL, 0, browse_callback, &mc);
2181
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
2182
NULL, 0, browse_callback, NULL);
1141
2183
if(sb == NULL){
1142
fprintf(stderr, "Failed to create service browser: %s\n",
1143
avahi_strerror(avahi_server_errno(mc.server)));
1144
exitcode = EXIT_FAILURE;
2184
fprintf_plus(stderr, "Failed to create service browser: %s\n",
2185
avahi_strerror(avahi_server_errno(mc.server)));
2186
exitcode = EX_UNAVAILABLE;
2187
goto end;
2188
}
2189
2190
if(quit_now){
1145
2191
goto end;
1146
2192
}
1147
2193
1148
2194
/* Run the main loop */
1149
2195
1150
2196
if(debug){
1151
fprintf(stderr, "Starting Avahi loop search\n");
1152
}
1153
1154
avahi_simple_poll_loop(mc.simple_poll);
2197
fprintf_plus(stderr, "Starting Avahi loop search\n");
2198
}
2199
2200
ret = avahi_loop_with_timeout(mc.simple_poll,
2201
(int)(retry_interval * 1000));
2202
if(debug){
2203
fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
2204
(ret == 0) ? "successfully" : "with error");
2205
}
1155
2206
1156
2207
end:
1157
2208
1158
2209
if(debug){
1159
fprintf(stderr, "%s exiting\n", argv[0]);
2210
fprintf_plus(stderr, "%s exiting\n", argv[0]);
1160
2211
}
1161
2212
1162
2213
/* Cleanup things */
1179
2230
gpgme_release(mc.ctx);
1180
2231
}
1181
2232
1182
/* Removes the temp directory used by GPGME */
2233
/* Cleans up the circular linked list of Mandos servers the client
2234
has seen */
2235
if(mc.current_server != NULL){
2236
mc.current_server->prev->next = NULL;
2237
while(mc.current_server != NULL){
2238
server *next = mc.current_server->next;
2239
free(mc.current_server);
2240
mc.current_server = next;
2241
}
2242
}
2243
2244
/* Run network hooks */
2245
run_network_hooks("stop", interface, delay);
2246
2247
/* Re-raise priviliges */
2248
{
2249
errno = 0;
2250
ret = seteuid(0);
2251
if(ret == -1){
2252
perror_plus("seteuid");
2253
}
2254
2255
/* Take down the network interface */
2256
if(take_down_interface and geteuid() == 0){
2257
ret = ioctl(sd, SIOCGIFFLAGS, &network);
2258
if(ret == -1){
2259
perror_plus("ioctl SIOCGIFFLAGS");
2260
} else if(network.ifr_flags & IFF_UP){
2261
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
2262
ret = ioctl(sd, SIOCSIFFLAGS, &network);
2263
if(ret == -1){
2264
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
2265
}
2266
}
2267
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2268
if(ret == -1){
2269
perror_plus("close");
2270
}
2271
}
2272
}
2273
/* Lower privileges permanently */
2274
errno = 0;
2275
ret = setuid(uid);
2276
if(ret == -1){
2277
perror_plus("setuid");
2278
}
2279
2280
/* Removes the GPGME temp directory and all files inside */
1183
2281
if(tempdir_created){
1184
DIR *d;
1185
struct dirent *direntry;
1186
d = opendir(tempdir);
1187
if(d == NULL){
1188
if(errno != ENOENT){
1189
perror("opendir");
1190
}
1191
} else {
1192
while(true){
1193
direntry = readdir(d);
1194
if(direntry == NULL){
1195
break;
1196
}
1197
/* Skip "." and ".." */
1198
if(direntry->d_name[0] == '.'
1199
and (direntry->d_name[1] == '\0'
1200
or (direntry->d_name[1] == '.'
1201
and direntry->d_name[2] == '\0'))){
1202
continue;
1203
}
2282
struct dirent **direntries = NULL;
2283
struct dirent *direntry = NULL;
2284
int numentries = scandir(tempdir, &direntries, notdotentries,
2285
alphasort);
2286
if (numentries > 0){
2287
for(int i = 0; i < numentries; i++){
2288
direntry = direntries[i];
1204
2289
char *fullname = NULL;
1205
2290
ret = asprintf(&fullname, "%s/%s", tempdir,
1206
2291
direntry->d_name);
1207
2292
if(ret < 0){
1208
perror("asprintf");
2293
perror_plus("asprintf");
1209
2294
continue;
1210
2295
}
1211
2296
ret = remove(fullname);
1212
2297
if(ret == -1){
1213
fprintf(stderr, "remove(\"%s\"): %s\n", fullname,
1214
strerror(errno));
2298
fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2299
strerror(errno));
1215
2300
}
1216
2301
free(fullname);
1217
2302
}
1218
closedir(d);
2303
}
2304
2305
/* need to clean even if 0 because man page doesn't specify */
2306
free(direntries);
2307
if (numentries == -1){
2308
perror_plus("scandir");
1219
2309
}
1220
2310
ret = rmdir(tempdir);
1221
2311
if(ret == -1 and errno != ENOENT){
1222
perror("rmdir");
1223
}
2312
perror_plus("rmdir");
2313
}
2314
}
2315
2316
if(quit_now){
2317
sigemptyset(&old_sigterm_action.sa_mask);
2318
old_sigterm_action.sa_handler = SIG_DFL;
2319
ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
2320
&old_sigterm_action,
2321
NULL));
2322
if(ret == -1){
2323
perror_plus("sigaction");
2324
}
2325
do {
2326
ret = raise(signal_received);
2327
} while(ret != 0 and errno == EINTR);
2328
if(ret != 0){
2329
perror_plus("raise");
2330
abort();
2331
}
2332
TEMP_FAILURE_RETRY(pause());
1224
2333
}
1225
2334
1226
2335
return exitcode;
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0