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