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