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