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