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