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