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