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 962
- compare with another revision
- download diff
- download tarball
- view history from revision 962
- Committer: Teddy Hogeborn
- Date: 2019-02-09 23:23:26 UTC
- Revision ID: teddy@recompile.se-20190209232326-z1z2kzpgfixz7iaj
Add support for using raw public keys in TLS (RFC 7250)
Since GnuTLS removed support for OpenPGP keys in TLS (RFC 6091), and
no other library supports it, we have to change the protocol to use
something else. We choose to use "raw public keys" (RFC 7250). Since
we still use OpenPGP keys to decrypt the secret password, this means
that each client will have two keys: One OpenPGP key and one TLS
public/private key, and the key ID of the latter key is used to
identify clients instead of the fingerprint of the OpenPGP key.
Note that this code is still compatible with GnuTLS before version
3.6.0 (when OpenPGP key support was removed). This commit merely adds
support for using raw pulic keys instead with GnuTLS 3.6.6. or later.
* DBUS-API (Signals/ClientNotFound): Change name of first parameter
from "Fingerprint" to "KeyID".
(Mandos Client Interface/Properties/KeyID): New.
* INSTALL: Document conflict with GnuTLS 3.6.0 (which removed OpenPGP
key support) up until 3.6.6, when support for raw public
keys was added. Also document new dependency of client on
"gnutls-bin" package (for certtool).
* Makefile (run-client): Depend on TLS key files, and also pass them
as arguments to client.
(keydir/tls-privkey.pem, keydir/tls-pubkey.pem): New.
(confdir/clients.conf): Add dependency on TLS public key.
(purge-client): Add removal of TLS key files.
* clients.conf ([foo]/key_id, [bar]/key_id): New.
* debian/control (Source: mandos/Build-Depends): Also allow
libgnutls30 (>= 3.6.6)
(Package: mandos/Depends): - '' -
(Package: mandos/Description): Alter description to match new
design.
(Package: mandos-client/Description): - '' -
(Package: mandos-client/Depends): Move "gnutls-bin | openssl" to
here from "Recommends".
* debian/mandos-client.README.Debian: Add --tls-privkey and
--tls-pubkey options to test
command.
* debian/mandos-client.postinst (create_key): Renamed to "create_keys"
(all callers changed),
and also create TLS key.
* debian/mandos-client.postrm (purge): Also remove TLS key files.
* intro.xml (DESCRIPTION): Describe new dual-key design.
* mandos (GnuTLS): Define different functions depending on whether
support for raw public keys is detected.
(Client.key_id): New attribute.
(ClientDBus.KeyID_dbus_property): New method.
(ProxyClient.__init__): Take new "key_id" parameter.
(ClientHandler.handle): Use key IDs when using raw public keys and
use fingerprints when using OpenPGP keys.
(ClientHandler.peer_certificate): Also handle raw public keys.
(ClientHandler.key_id): New.
(MandosServer.handle_ipc): Pass key ID over the pipe IPC. Also
check for key ID matches when looking up
clients.
(main): Default GnuTLS priority string depends on whether we are
using raw public keys or not. When unpickling clients, set
key_id if not set in the pickle.
(main/MandosDBusService.ClientNotFound): Change name of first
parameter from
"Fingerprint" to "KeyID".
* mandos-clients.conf.xml (OPTIONS): Document new "key_id" option.
(OPTIONS/secret): Mention new key ID matchning.
(EXPANSION/RUNTIME EXPANSION): Add new "key_id" option.
(EXAMPLE): - '' -
* mandos-ctl (tablewords, main/keywords): Add new "KeyID" property.
* mandos-keygen: Create TLS key files. New "--tls-keytype" (-T)
option. Alter help text to be more clear about key
types. When in password mode, also output "key_id"
option.
* mandos-keygen.xml (SYNOPSIS): Add new "--tls-keytype" (-T) option.
(DESCRIPTION): Alter to match new dual-key design.
(OVERVIEW): - '' -
(FILES): Add TLS key files.
* mandos-options.xml (priority): Document new default priority string
when using raw public keys.
* mandos.xml (NETWORK PROTOCOL): Describe new protocol using key ID.
(BUGS): Remove issue about checking expire times of OpenPGP keys,
since TLS public keys do not have expiration times.
(SECURITY/CLIENT): Alter description to match new design.
(SEE ALSO/GnuTLS): - '' -
(SEE ALSO): Add reference to RFC 7250, and alter description of when
RFC 6091 is used.
* overview.xml: Alter text to match new design.
* plugin-runner.xml (EXAMPLE): Add --tls-pubkey and --tls-privkey
options to mandos-client options.
* plugins.d/mandos-client.c: Use raw public keys when compiling with
supporting GnuTLS versions. Add new
"--tls-pubkey" and "--tls-privkey"
options (which do nothing if GnuTLS
library does not support raw public
keys). Alter text throughout to reflect
new design. Only generate new DH
parameters (based on size of OpenPGP key)
when using OpenPGP in TLS. Default
GnuTLS priority string depends on whether
we are using raw public keys or not.
* plugins.d/mandos-client.xml (SYNOPSIS): Add new "--tls-privkey" (-t)
and "--tls-pubkey" (-T)
options.
(DESCRIPTION): Describe new dual-key design.
(OPTIONS): Document new "--tls-privkey" (-t) and "--tls-pubkey" (-T)
options.
(OPTIONS/--dh-bits): No longer necessarily depends on OpenPGP key
size.
(FILES): Add default locations for TLS public and private key files.
(EXAMPLE): Use new --tls-pubkey and --tls-privkey options.
(SECURITY): Alter wording slightly to reflect new dual-key design.
(SEE ALSO/GnuTLS): Alter description to match new design.
(SEE ALSO): Add reference to RFC 7250, and alter description of when
RFC 6091 is used.
Since GnuTLS removed support for OpenPGP keys in TLS (RFC 6091), and
no other library supports it, we have to change the protocol to use
something else. We choose to use "raw public keys" (RFC 7250). Since
we still use OpenPGP keys to decrypt the secret password, this means
that each client will have two keys: One OpenPGP key and one TLS
public/private key, and the key ID of the latter key is used to
identify clients instead of the fingerprint of the OpenPGP key.
Note that this code is still compatible with GnuTLS before version
3.6.0 (when OpenPGP key support was removed). This commit merely adds
support for using raw pulic keys instead with GnuTLS 3.6.6. or later.
* DBUS-API (Signals/ClientNotFound): Change name of first parameter
from "Fingerprint" to "KeyID".
(Mandos Client Interface/Properties/KeyID): New.
* INSTALL: Document conflict with GnuTLS 3.6.0 (which removed OpenPGP
key support) up until 3.6.6, when support for raw public
keys was added. Also document new dependency of client on
"gnutls-bin" package (for certtool).
* Makefile (run-client): Depend on TLS key files, and also pass them
as arguments to client.
(keydir/tls-privkey.pem, keydir/tls-pubkey.pem): New.
(confdir/clients.conf): Add dependency on TLS public key.
(purge-client): Add removal of TLS key files.
* clients.conf ([foo]/key_id, [bar]/key_id): New.
* debian/control (Source: mandos/Build-Depends): Also allow
libgnutls30 (>= 3.6.6)
(Package: mandos/Depends): - '' -
(Package: mandos/Description): Alter description to match new
design.
(Package: mandos-client/Description): - '' -
(Package: mandos-client/Depends): Move "gnutls-bin | openssl" to
here from "Recommends".
* debian/mandos-client.README.Debian: Add --tls-privkey and
--tls-pubkey options to test
command.
* debian/mandos-client.postinst (create_key): Renamed to "create_keys"
(all callers changed),
and also create TLS key.
* debian/mandos-client.postrm (purge): Also remove TLS key files.
* intro.xml (DESCRIPTION): Describe new dual-key design.
* mandos (GnuTLS): Define different functions depending on whether
support for raw public keys is detected.
(Client.key_id): New attribute.
(ClientDBus.KeyID_dbus_property): New method.
(ProxyClient.__init__): Take new "key_id" parameter.
(ClientHandler.handle): Use key IDs when using raw public keys and
use fingerprints when using OpenPGP keys.
(ClientHandler.peer_certificate): Also handle raw public keys.
(ClientHandler.key_id): New.
(MandosServer.handle_ipc): Pass key ID over the pipe IPC. Also
check for key ID matches when looking up
clients.
(main): Default GnuTLS priority string depends on whether we are
using raw public keys or not. When unpickling clients, set
key_id if not set in the pickle.
(main/MandosDBusService.ClientNotFound): Change name of first
parameter from
"Fingerprint" to "KeyID".
* mandos-clients.conf.xml (OPTIONS): Document new "key_id" option.
(OPTIONS/secret): Mention new key ID matchning.
(EXPANSION/RUNTIME EXPANSION): Add new "key_id" option.
(EXAMPLE): - '' -
* mandos-ctl (tablewords, main/keywords): Add new "KeyID" property.
* mandos-keygen: Create TLS key files. New "--tls-keytype" (-T)
option. Alter help text to be more clear about key
types. When in password mode, also output "key_id"
option.
* mandos-keygen.xml (SYNOPSIS): Add new "--tls-keytype" (-T) option.
(DESCRIPTION): Alter to match new dual-key design.
(OVERVIEW): - '' -
(FILES): Add TLS key files.
* mandos-options.xml (priority): Document new default priority string
when using raw public keys.
* mandos.xml (NETWORK PROTOCOL): Describe new protocol using key ID.
(BUGS): Remove issue about checking expire times of OpenPGP keys,
since TLS public keys do not have expiration times.
(SECURITY/CLIENT): Alter description to match new design.
(SEE ALSO/GnuTLS): - '' -
(SEE ALSO): Add reference to RFC 7250, and alter description of when
RFC 6091 is used.
* overview.xml: Alter text to match new design.
* plugin-runner.xml (EXAMPLE): Add --tls-pubkey and --tls-privkey
options to mandos-client options.
* plugins.d/mandos-client.c: Use raw public keys when compiling with
supporting GnuTLS versions. Add new
"--tls-pubkey" and "--tls-privkey"
options (which do nothing if GnuTLS
library does not support raw public
keys). Alter text throughout to reflect
new design. Only generate new DH
parameters (based on size of OpenPGP key)
when using OpenPGP in TLS. Default
GnuTLS priority string depends on whether
we are using raw public keys or not.
* plugins.d/mandos-client.xml (SYNOPSIS): Add new "--tls-privkey" (-t)
and "--tls-pubkey" (-T)
options.
(DESCRIPTION): Describe new dual-key design.
(OPTIONS): Document new "--tls-privkey" (-t) and "--tls-pubkey" (-T)
options.
(OPTIONS/--dh-bits): No longer necessarily depends on OpenPGP key
size.
(FILES): Add default locations for TLS public and private key files.
(EXAMPLE): Use new --tls-pubkey and --tls-privkey options.
(SECURITY): Alter wording slightly to reflect new dual-key design.
(SEE ALSO/GnuTLS): Alter description to match new design.
(SEE ALSO): Add reference to RFC 7250, and alter description of when
RFC 6091 is used.
- files added:
- bugs.xml
- debian/upstream
- plugin-helpers
- files removed:
- initramfs-tools-hook-conf
- files modified:
- DBUS-API
added
removed
plugins.d/mandos-client.c
9
9
* "browse_callback", and parts of "main".
10
10
*
11
11
* Everything else is
12
* Copyright © 2008-2012 Teddy Hogeborn
13
* Copyright © 2008-2012 Björn Påhlsson
14
*
15
* This program is free software: you can redistribute it and/or
16
* modify it under the terms of the GNU General Public License as
17
* published by the Free Software Foundation, either version 3 of the
18
* License, or (at your option) any later version.
19
*
20
* This program is distributed in the hope that it will be useful, but
12
* Copyright © 2008-2018 Teddy Hogeborn
13
* Copyright © 2008-2018 Björn Påhlsson
14
*
15
* This file is part of Mandos.
16
*
17
* Mandos is free software: you can redistribute it and/or modify it
18
* under the terms of the GNU General Public License as published by
19
* the Free Software Foundation, either version 3 of the License, or
20
* (at your option) any later version.
21
*
22
* Mandos is distributed in the hope that it will be useful, but
21
23
* WITHOUT ANY WARRANTY; without even the implied warranty of
22
24
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23
25
* General Public License for more details.
24
26
*
25
27
* You should have received a copy of the GNU General Public License
26
* along with this program. If not, see
27
* <http://www.gnu.org/licenses/>.
28
* along with Mandos. If not, see <http://www.gnu.org/licenses/>.
28
29
*
29
30
* Contact the authors at <mandos@recompile.se>.
30
31
*/
32
33
/* Needed by GPGME, specifically gpgme_data_seek() */
33
34
#ifndef _LARGEFILE_SOURCE
34
35
#define _LARGEFILE_SOURCE
35
#endif
36
#endif /* not _LARGEFILE_SOURCE */
36
37
#ifndef _FILE_OFFSET_BITS
37
38
#define _FILE_OFFSET_BITS 64
38
#endif
39
#endif /* not _FILE_OFFSET_BITS */
39
40
40
41
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
41
42
42
43
#include <stdio.h> /* fprintf(), stderr, fwrite(),
43
stdout, ferror(), remove() */
44
stdout, ferror() */
44
45
#include <stdint.h> /* uint16_t, uint32_t, intptr_t */
45
46
#include <stddef.h> /* NULL, size_t, ssize_t */
46
47
#include <stdlib.h> /* free(), EXIT_SUCCESS, srand(),
47
48
strtof(), abort() */
48
49
#include <stdbool.h> /* bool, false, true */
49
#include <string.h> /* memset(), strcmp(), strlen(),
50
strerror(), asprintf(), strcpy() */
50
#include <string.h> /* strcmp(), strlen(), strerror(),
51
asprintf(), strncpy(), strsignal()
52
*/
51
53
#include <sys/ioctl.h> /* ioctl */
52
54
#include <sys/types.h> /* socket(), inet_pton(), sockaddr,
53
55
sockaddr_in6, PF_INET6,
55
57
opendir(), DIR */
56
58
#include <sys/stat.h> /* open(), S_ISREG */
57
59
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
58
inet_pton(), connect() */
59
#include <fcntl.h> /* open() */
60
inet_pton(), connect(),
61
getnameinfo() */
62
#include <fcntl.h> /* open(), unlinkat(), AT_REMOVEDIR */
60
63
#include <dirent.h> /* opendir(), struct dirent, readdir()
61
64
*/
62
65
#include <inttypes.h> /* PRIu16, PRIdMAX, intmax_t,
63
66
strtoimax() */
64
#include <errno.h> /* perror(), errno,
67
#include <errno.h> /* perror(), errno, EINTR, EINVAL,
68
EAI_SYSTEM, ENETUNREACH,
69
EHOSTUNREACH, ECONNREFUSED, EPROTO,
70
EIO, ENOENT, ENXIO, ENOMEM, EISDIR,
71
ENOTEMPTY,
65
72
program_invocation_short_name */
66
73
#include <time.h> /* nanosleep(), time(), sleep() */
67
74
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
72
79
*/
73
80
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
74
81
getuid(), getgid(), seteuid(),
75
setgid(), pause(), _exit() */
76
#include <arpa/inet.h> /* inet_pton(), htons, inet_ntop() */
82
setgid(), pause(), _exit(),
83
unlinkat() */
84
#include <arpa/inet.h> /* inet_pton(), htons() */
77
85
#include <iso646.h> /* not, or, and */
78
86
#include <argp.h> /* struct argp_option, error_t, struct
79
87
argp_state, struct argp,
91
99
argz_delete(), argz_append(),
92
100
argz_stringify(), argz_add(),
93
101
argz_count() */
102
#include <netdb.h> /* getnameinfo(), NI_NUMERICHOST,
103
EAI_SYSTEM, gai_strerror() */
94
104
95
105
#ifdef __linux__
96
106
#include <sys/klog.h> /* klogctl() */
113
123
gnutls_*
114
124
init_gnutls_session(),
115
125
GNUTLS_* */
126
#if GNUTLS_VERSION_NUMBER < 0x030600
116
127
#include <gnutls/openpgp.h>
117
128
/* gnutls_certificate_set_openpgp_key_file(),
118
129
GNUTLS_OPENPGP_FMT_BASE64 */
130
#elif GNUTLS_VERSION_NUMBER >= 0x030606
131
#include <gnutls/x509.h> /* gnutls_pkcs_encrypt_flags_t,
132
GNUTLS_PKCS_PLAIN,
133
GNUTLS_PKCS_NULL_PASSWORD */
134
#endif
119
135
120
136
/* GPGME */
121
137
#include <gpgme.h> /* All GPGME types, constants and
129
145
#define PATHDIR "/conf/conf.d/mandos"
130
146
#define SECKEY "seckey.txt"
131
147
#define PUBKEY "pubkey.txt"
148
#define TLS_PRIVKEY "tls-privkey.pem"
149
#define TLS_PUBKEY "tls-pubkey.pem"
132
150
#define HOOKDIR "/lib/mandos/network-hooks.d"
133
151
134
152
bool debug = false;
138
156
static const char sys_class_net[] = "/sys/class/net";
139
157
char *connect_to = NULL;
140
158
const char *hookdir = HOOKDIR;
159
int hookdir_fd = -1;
141
160
uid_t uid = 65534;
142
161
gid_t gid = 65534;
143
162
180
199
perror(print_text);
181
200
}
182
201
183
__attribute__((format (gnu_printf, 2, 3)))
202
__attribute__((format (gnu_printf, 2, 3), nonnull))
184
203
int fprintf_plus(FILE *stream, const char *format, ...){
185
204
va_list ap;
186
205
va_start (ap, format);
187
206
188
207
TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
189
208
program_invocation_short_name));
190
return TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
209
return (int)TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
191
210
}
192
211
193
212
/*
195
214
* bytes. "buffer_capacity" is how much is currently allocated,
196
215
* "buffer_length" is how much is already used.
197
216
*/
217
__attribute__((nonnull, warn_unused_result))
198
218
size_t incbuffer(char **buffer, size_t buffer_length,
199
219
size_t buffer_capacity){
200
220
if(buffer_length + BUFFER_SIZE > buffer_capacity){
201
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
202
if(buffer == NULL){
221
char *new_buf = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
222
if(new_buf == NULL){
223
int old_errno = errno;
224
free(*buffer);
225
errno = old_errno;
226
*buffer = NULL;
203
227
return 0;
204
228
}
229
*buffer = new_buf;
205
230
buffer_capacity += BUFFER_SIZE;
206
231
}
207
232
return buffer_capacity;
208
233
}
209
234
210
235
/* Add server to set of servers to retry periodically */
236
__attribute__((nonnull, warn_unused_result))
211
237
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
212
238
int af, server **current_server){
213
239
int ret;
222
248
.af = af };
223
249
if(new_server->ip == NULL){
224
250
perror_plus("strdup");
251
free(new_server);
252
return false;
253
}
254
ret = clock_gettime(CLOCK_MONOTONIC, &(new_server->last_seen));
255
if(ret == -1){
256
perror_plus("clock_gettime");
257
#ifdef __GNUC__
258
#pragma GCC diagnostic push
259
#pragma GCC diagnostic ignored "-Wcast-qual"
260
#endif
261
free((char *)(new_server->ip));
262
#ifdef __GNUC__
263
#pragma GCC diagnostic pop
264
#endif
265
free(new_server);
225
266
return false;
226
267
}
227
268
/* Special case of first server */
229
270
new_server->next = new_server;
230
271
new_server->prev = new_server;
231
272
*current_server = new_server;
232
/* Place the new server last in the list */
233
273
} else {
274
/* Place the new server last in the list */
234
275
new_server->next = *current_server;
235
276
new_server->prev = (*current_server)->prev;
236
277
new_server->prev->next = new_server;
237
278
(*current_server)->prev = new_server;
238
279
}
239
ret = clock_gettime(CLOCK_MONOTONIC, &(*current_server)->last_seen);
240
if(ret == -1){
241
perror_plus("clock_gettime");
242
return false;
243
}
244
280
return true;
245
281
}
246
282
283
/* Set effective uid to 0, return errno */
284
__attribute__((warn_unused_result))
285
int raise_privileges(void){
286
int old_errno = errno;
287
int ret = 0;
288
if(seteuid(0) == -1){
289
ret = errno;
290
}
291
errno = old_errno;
292
return ret;
293
}
294
295
/* Set effective and real user ID to 0. Return errno. */
296
__attribute__((warn_unused_result))
297
int raise_privileges_permanently(void){
298
int old_errno = errno;
299
int ret = raise_privileges();
300
if(ret != 0){
301
errno = old_errno;
302
return ret;
303
}
304
if(setuid(0) == -1){
305
ret = errno;
306
}
307
errno = old_errno;
308
return ret;
309
}
310
311
/* Set effective user ID to unprivileged saved user ID */
312
__attribute__((warn_unused_result))
313
int lower_privileges(void){
314
int old_errno = errno;
315
int ret = 0;
316
if(seteuid(uid) == -1){
317
ret = errno;
318
}
319
errno = old_errno;
320
return ret;
321
}
322
323
/* Lower privileges permanently */
324
__attribute__((warn_unused_result))
325
int lower_privileges_permanently(void){
326
int old_errno = errno;
327
int ret = 0;
328
if(setuid(uid) == -1){
329
ret = errno;
330
}
331
errno = old_errno;
332
return ret;
333
}
334
247
335
/*
248
336
* Initialize GPGME.
249
337
*/
250
static bool init_gpgme(const char *seckey, const char *pubkey,
251
const char *tempdir, mandos_context *mc){
338
__attribute__((nonnull, warn_unused_result))
339
static bool init_gpgme(const char * const seckey,
340
const char * const pubkey,
341
const char * const tempdir,
342
mandos_context *mc){
252
343
gpgme_error_t rc;
253
344
gpgme_engine_info_t engine_info;
254
345
255
346
/*
256
347
* Helper function to insert pub and seckey to the engine keyring.
257
348
*/
258
bool import_key(const char *filename){
349
bool import_key(const char * const filename){
259
350
int ret;
260
351
int fd;
261
352
gpgme_data_t pgp_data;
266
357
return false;
267
358
}
268
359
360
/* Workaround for systems without a real-time clock; see also
361
Debian bug #894495: <https://bugs.debian.org/894495> */
362
do {
363
{
364
time_t currtime = time(NULL);
365
if(currtime != (time_t)-1){
366
struct tm tm;
367
if(gmtime_r(&currtime, &tm) == NULL) {
368
perror_plus("gmtime_r");
369
break;
370
}
371
if(tm.tm_year != 70 or tm.tm_mon != 0){
372
break;
373
}
374
if(debug){
375
fprintf_plus(stderr, "System clock is January 1970");
376
}
377
} else {
378
if(debug){
379
fprintf_plus(stderr, "System clock is invalid");
380
}
381
}
382
}
383
struct stat keystat;
384
ret = fstat(fd, &keystat);
385
if(ret != 0){
386
perror_plus("fstat");
387
break;
388
}
389
ret = raise_privileges();
390
if(ret != 0){
391
errno = ret;
392
perror_plus("Failed to raise privileges");
393
break;
394
}
395
if(debug){
396
fprintf_plus(stderr,
397
"Setting system clock to key file mtime");
398
}
399
time_t keytime = keystat.st_mtim.tv_sec;
400
if(stime(&keytime) != 0){
401
perror_plus("stime");
402
}
403
ret = lower_privileges();
404
if(ret != 0){
405
errno = ret;
406
perror_plus("Failed to lower privileges");
407
}
408
} while(false);
409
269
410
rc = gpgme_data_new_from_fd(&pgp_data, fd);
270
411
if(rc != GPG_ERR_NO_ERROR){
271
412
fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
279
420
gpgme_strsource(rc), gpgme_strerror(rc));
280
421
return false;
281
422
}
423
{
424
gpgme_import_result_t import_result
425
= gpgme_op_import_result(mc->ctx);
426
if((import_result->imported < 1
427
or import_result->not_imported > 0)
428
and import_result->unchanged == 0){
429
fprintf_plus(stderr, "bad gpgme_op_import_results:\n");
430
fprintf_plus(stderr,
431
"The total number of considered keys: %d\n",
432
import_result->considered);
433
fprintf_plus(stderr,
434
"The number of keys without user ID: %d\n",
435
import_result->no_user_id);
436
fprintf_plus(stderr,
437
"The total number of imported keys: %d\n",
438
import_result->imported);
439
fprintf_plus(stderr, "The number of imported RSA keys: %d\n",
440
import_result->imported_rsa);
441
fprintf_plus(stderr, "The number of unchanged keys: %d\n",
442
import_result->unchanged);
443
fprintf_plus(stderr, "The number of new user IDs: %d\n",
444
import_result->new_user_ids);
445
fprintf_plus(stderr, "The number of new sub keys: %d\n",
446
import_result->new_sub_keys);
447
fprintf_plus(stderr, "The number of new signatures: %d\n",
448
import_result->new_signatures);
449
fprintf_plus(stderr, "The number of new revocations: %d\n",
450
import_result->new_revocations);
451
fprintf_plus(stderr,
452
"The total number of secret keys read: %d\n",
453
import_result->secret_read);
454
fprintf_plus(stderr,
455
"The number of imported secret keys: %d\n",
456
import_result->secret_imported);
457
fprintf_plus(stderr,
458
"The number of unchanged secret keys: %d\n",
459
import_result->secret_unchanged);
460
fprintf_plus(stderr, "The number of keys not imported: %d\n",
461
import_result->not_imported);
462
for(gpgme_import_status_t import_status
463
= import_result->imports;
464
import_status != NULL;
465
import_status = import_status->next){
466
fprintf_plus(stderr, "Import status for key: %s\n",
467
import_status->fpr);
468
if(import_status->result != GPG_ERR_NO_ERROR){
469
fprintf_plus(stderr, "Import result: %s: %s\n",
470
gpgme_strsource(import_status->result),
471
gpgme_strerror(import_status->result));
472
}
473
fprintf_plus(stderr, "Key status:\n");
474
fprintf_plus(stderr,
475
import_status->status & GPGME_IMPORT_NEW
476
? "The key was new.\n"
477
: "The key was not new.\n");
478
fprintf_plus(stderr,
479
import_status->status & GPGME_IMPORT_UID
480
? "The key contained new user IDs.\n"
481
: "The key did not contain new user IDs.\n");
482
fprintf_plus(stderr,
483
import_status->status & GPGME_IMPORT_SIG
484
? "The key contained new signatures.\n"
485
: "The key did not contain new signatures.\n");
486
fprintf_plus(stderr,
487
import_status->status & GPGME_IMPORT_SUBKEY
488
? "The key contained new sub keys.\n"
489
: "The key did not contain new sub keys.\n");
490
fprintf_plus(stderr,
491
import_status->status & GPGME_IMPORT_SECRET
492
? "The key contained a secret key.\n"
493
: "The key did not contain a secret key.\n");
494
}
495
return false;
496
}
497
}
282
498
283
ret = (int)TEMP_FAILURE_RETRY(close(fd));
499
ret = close(fd);
284
500
if(ret == -1){
285
501
perror_plus("close");
286
502
}
325
541
/* Create new GPGME "context" */
326
542
rc = gpgme_new(&(mc->ctx));
327
543
if(rc != GPG_ERR_NO_ERROR){
328
fprintf_plus(stderr, "Mandos plugin mandos-client: "
329
"bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
330
gpgme_strerror(rc));
544
fprintf_plus(stderr, "bad gpgme_new: %s: %s\n",
545
gpgme_strsource(rc), gpgme_strerror(rc));
331
546
return false;
332
547
}
333
548
342
557
* Decrypt OpenPGP data.
343
558
* Returns -1 on error
344
559
*/
560
__attribute__((nonnull, warn_unused_result))
345
561
static ssize_t pgp_packet_decrypt(const char *cryptotext,
346
562
size_t crypto_size,
347
563
char **plaintext,
368
584
/* Create new empty GPGME data buffer for the plaintext */
369
585
rc = gpgme_data_new(&dh_plain);
370
586
if(rc != GPG_ERR_NO_ERROR){
371
fprintf_plus(stderr, "Mandos plugin mandos-client: "
372
"bad gpgme_data_new: %s: %s\n",
587
fprintf_plus(stderr, "bad gpgme_data_new: %s: %s\n",
373
588
gpgme_strsource(rc), gpgme_strerror(rc));
374
589
gpgme_data_release(dh_crypto);
375
590
return -1;
388
603
if(result == NULL){
389
604
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
390
605
} else {
391
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
392
result->unsupported_algorithm);
393
fprintf_plus(stderr, "Wrong key usage: %u\n",
394
result->wrong_key_usage);
606
if(result->unsupported_algorithm != NULL) {
607
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
608
result->unsupported_algorithm);
609
}
610
fprintf_plus(stderr, "Wrong key usage: %s\n",
611
result->wrong_key_usage ? "Yes" : "No");
395
612
if(result->file_name != NULL){
396
613
fprintf_plus(stderr, "File name: %s\n", result->file_name);
397
614
}
398
gpgme_recipient_t recipient;
399
recipient = result->recipients;
400
while(recipient != NULL){
615
616
for(gpgme_recipient_t r = result->recipients; r != NULL;
617
r = r->next){
401
618
fprintf_plus(stderr, "Public key algorithm: %s\n",
402
gpgme_pubkey_algo_name
403
(recipient->pubkey_algo));
404
fprintf_plus(stderr, "Key ID: %s\n", recipient->keyid);
619
gpgme_pubkey_algo_name(r->pubkey_algo));
620
fprintf_plus(stderr, "Key ID: %s\n", r->keyid);
405
621
fprintf_plus(stderr, "Secret key available: %s\n",
406
recipient->status == GPG_ERR_NO_SECKEY
407
? "No" : "Yes");
408
recipient = recipient->next;
622
r->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
409
623
}
410
624
}
411
625
}
467
681
return plaintext_length;
468
682
}
469
683
470
static const char * safer_gnutls_strerror(int value){
684
__attribute__((warn_unused_result, const))
685
static const char *safe_string(const char *str){
686
if(str == NULL)
687
return "(unknown)";
688
return str;
689
}
690
691
__attribute__((warn_unused_result))
692
static const char *safer_gnutls_strerror(int value){
471
693
const char *ret = gnutls_strerror(value);
472
if(ret == NULL)
473
ret = "(unknown)";
474
return ret;
694
return safe_string(ret);
475
695
}
476
696
477
697
/* GnuTLS log function callback */
698
__attribute__((nonnull))
478
699
static void debuggnutls(__attribute__((unused)) int level,
479
700
const char* string){
480
701
fprintf_plus(stderr, "GnuTLS: %s", string);
481
702
}
482
703
704
__attribute__((nonnull(1, 2, 4), warn_unused_result))
483
705
static int init_gnutls_global(const char *pubkeyfilename,
484
706
const char *seckeyfilename,
707
const char *dhparamsfilename,
485
708
mandos_context *mc){
486
709
int ret;
487
710
489
712
fprintf_plus(stderr, "Initializing GnuTLS\n");
490
713
}
491
714
492
ret = gnutls_global_init();
493
if(ret != GNUTLS_E_SUCCESS){
494
fprintf_plus(stderr, "GnuTLS global_init: %s\n",
495
safer_gnutls_strerror(ret));
496
return -1;
497
}
498
499
715
if(debug){
500
716
/* "Use a log level over 10 to enable all debugging options."
501
717
* - GnuTLS manual
509
725
if(ret != GNUTLS_E_SUCCESS){
510
726
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
511
727
safer_gnutls_strerror(ret));
512
gnutls_global_deinit();
513
728
return -1;
514
729
}
515
730
516
731
if(debug){
517
fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
518
" secret key %s as GnuTLS credentials\n",
732
fprintf_plus(stderr, "Attempting to use public key %s and"
733
" private key %s as GnuTLS credentials\n",
519
734
pubkeyfilename,
520
735
seckeyfilename);
521
736
}
522
737
738
#if GNUTLS_VERSION_NUMBER >= 0x030606
739
ret = gnutls_certificate_set_rawpk_key_file
740
(mc->cred, pubkeyfilename, seckeyfilename,
741
GNUTLS_X509_FMT_PEM, /* format */
742
NULL, /* pass */
743
/* key_usage */
744
GNUTLS_KEY_DIGITAL_SIGNATURE | GNUTLS_KEY_KEY_ENCIPHERMENT,
745
NULL, /* names */
746
0, /* names_length */
747
/* privkey_flags */
748
GNUTLS_PKCS_PLAIN | GNUTLS_PKCS_NULL_PASSWORD,
749
0); /* pkcs11_flags */
750
#elif GNUTLS_VERSION_NUMBER < 0x030600
523
751
ret = gnutls_certificate_set_openpgp_key_file
524
752
(mc->cred, pubkeyfilename, seckeyfilename,
525
753
GNUTLS_OPENPGP_FMT_BASE64);
754
#else
755
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
756
#endif
526
757
if(ret != GNUTLS_E_SUCCESS){
527
758
fprintf_plus(stderr,
528
"Error[%d] while reading the OpenPGP key pair ('%s',"
759
"Error[%d] while reading the key pair ('%s',"
529
760
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
530
761
fprintf_plus(stderr, "The GnuTLS error is: %s\n",
531
762
safer_gnutls_strerror(ret));
540
771
safer_gnutls_strerror(ret));
541
772
goto globalfail;
542
773
}
543
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
544
if(ret != GNUTLS_E_SUCCESS){
545
fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
546
safer_gnutls_strerror(ret));
547
goto globalfail;
548
}
549
550
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
774
/* If a Diffie-Hellman parameters file was given, try to use it */
775
if(dhparamsfilename != NULL){
776
gnutls_datum_t params = { .data = NULL, .size = 0 };
777
do {
778
int dhpfile = open(dhparamsfilename, O_RDONLY);
779
if(dhpfile == -1){
780
perror_plus("open");
781
dhparamsfilename = NULL;
782
break;
783
}
784
size_t params_capacity = 0;
785
while(true){
786
params_capacity = incbuffer((char **)¶ms.data,
787
(size_t)params.size,
788
(size_t)params_capacity);
789
if(params_capacity == 0){
790
perror_plus("incbuffer");
791
free(params.data);
792
params.data = NULL;
793
dhparamsfilename = NULL;
794
break;
795
}
796
ssize_t bytes_read = read(dhpfile,
797
params.data + params.size,
798
BUFFER_SIZE);
799
/* EOF */
800
if(bytes_read == 0){
801
break;
802
}
803
/* check bytes_read for failure */
804
if(bytes_read < 0){
805
perror_plus("read");
806
free(params.data);
807
params.data = NULL;
808
dhparamsfilename = NULL;
809
break;
810
}
811
params.size += (unsigned int)bytes_read;
812
}
813
ret = close(dhpfile);
814
if(ret == -1){
815
perror_plus("close");
816
}
817
if(params.data == NULL){
818
dhparamsfilename = NULL;
819
}
820
if(dhparamsfilename == NULL){
821
break;
822
}
823
ret = gnutls_dh_params_import_pkcs3(mc->dh_params, ¶ms,
824
GNUTLS_X509_FMT_PEM);
825
if(ret != GNUTLS_E_SUCCESS){
826
fprintf_plus(stderr, "Failed to parse DH parameters in file"
827
" \"%s\": %s\n", dhparamsfilename,
828
safer_gnutls_strerror(ret));
829
dhparamsfilename = NULL;
830
}
831
free(params.data);
832
} while(false);
833
}
834
if(dhparamsfilename == NULL){
835
if(mc->dh_bits == 0){
836
#if GNUTLS_VERSION_NUMBER < 0x030600
837
/* Find out the optimal number of DH bits */
838
/* Try to read the private key file */
839
gnutls_datum_t buffer = { .data = NULL, .size = 0 };
840
do {
841
int secfile = open(seckeyfilename, O_RDONLY);
842
if(secfile == -1){
843
perror_plus("open");
844
break;
845
}
846
size_t buffer_capacity = 0;
847
while(true){
848
buffer_capacity = incbuffer((char **)&buffer.data,
849
(size_t)buffer.size,
850
(size_t)buffer_capacity);
851
if(buffer_capacity == 0){
852
perror_plus("incbuffer");
853
free(buffer.data);
854
buffer.data = NULL;
855
break;
856
}
857
ssize_t bytes_read = read(secfile,
858
buffer.data + buffer.size,
859
BUFFER_SIZE);
860
/* EOF */
861
if(bytes_read == 0){
862
break;
863
}
864
/* check bytes_read for failure */
865
if(bytes_read < 0){
866
perror_plus("read");
867
free(buffer.data);
868
buffer.data = NULL;
869
break;
870
}
871
buffer.size += (unsigned int)bytes_read;
872
}
873
close(secfile);
874
} while(false);
875
/* If successful, use buffer to parse private key */
876
gnutls_sec_param_t sec_param = GNUTLS_SEC_PARAM_ULTRA;
877
if(buffer.data != NULL){
878
{
879
gnutls_openpgp_privkey_t privkey = NULL;
880
ret = gnutls_openpgp_privkey_init(&privkey);
881
if(ret != GNUTLS_E_SUCCESS){
882
fprintf_plus(stderr, "Error initializing OpenPGP key"
883
" structure: %s",
884
safer_gnutls_strerror(ret));
885
free(buffer.data);
886
buffer.data = NULL;
887
} else {
888
ret = gnutls_openpgp_privkey_import
889
(privkey, &buffer, GNUTLS_OPENPGP_FMT_BASE64, "", 0);
890
if(ret != GNUTLS_E_SUCCESS){
891
fprintf_plus(stderr, "Error importing OpenPGP key : %s",
892
safer_gnutls_strerror(ret));
893
privkey = NULL;
894
}
895
free(buffer.data);
896
buffer.data = NULL;
897
if(privkey != NULL){
898
/* Use private key to suggest an appropriate
899
sec_param */
900
sec_param = gnutls_openpgp_privkey_sec_param(privkey);
901
gnutls_openpgp_privkey_deinit(privkey);
902
if(debug){
903
fprintf_plus(stderr, "This OpenPGP key implies using"
904
" a GnuTLS security parameter \"%s\".\n",
905
safe_string(gnutls_sec_param_get_name
906
(sec_param)));
907
}
908
}
909
}
910
}
911
if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
912
/* Err on the side of caution */
913
sec_param = GNUTLS_SEC_PARAM_ULTRA;
914
if(debug){
915
fprintf_plus(stderr, "Falling back to security parameter"
916
" \"%s\"\n",
917
safe_string(gnutls_sec_param_get_name
918
(sec_param)));
919
}
920
}
921
}
922
unsigned int uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
923
if(uret != 0){
924
mc->dh_bits = uret;
925
if(debug){
926
fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
927
" implies %u DH bits; using that.\n",
928
safe_string(gnutls_sec_param_get_name
929
(sec_param)),
930
mc->dh_bits);
931
}
932
} else {
933
fprintf_plus(stderr, "Failed to get implied number of DH"
934
" bits for security parameter \"%s\"): %s\n",
935
safe_string(gnutls_sec_param_get_name
936
(sec_param)),
937
safer_gnutls_strerror(ret));
938
goto globalfail;
939
}
940
#endif
941
} else { /* dh_bits != 0 */
942
if(debug){
943
fprintf_plus(stderr, "DH bits explicitly set to %u\n",
944
mc->dh_bits);
945
}
946
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
947
if(ret != GNUTLS_E_SUCCESS){
948
fprintf_plus(stderr, "Error in GnuTLS prime generation (%u"
949
" bits): %s\n", mc->dh_bits,
950
safer_gnutls_strerror(ret));
951
goto globalfail;
952
}
953
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
954
}
955
}
551
956
552
957
return 0;
553
958
554
959
globalfail:
555
960
556
961
gnutls_certificate_free_credentials(mc->cred);
557
gnutls_global_deinit();
558
962
gnutls_dh_params_deinit(mc->dh_params);
559
963
return -1;
560
964
}
561
965
966
__attribute__((nonnull, warn_unused_result))
562
967
static int init_gnutls_session(gnutls_session_t *session,
563
968
mandos_context *mc){
564
969
int ret;
565
970
/* GnuTLS session creation */
566
971
do {
567
ret = gnutls_init(session, GNUTLS_SERVER);
972
ret = gnutls_init(session, (GNUTLS_SERVER
973
#if GNUTLS_VERSION_NUMBER >= 0x030506
974
| GNUTLS_NO_TICKETS
975
#endif
976
#if GNUTLS_VERSION_NUMBER >= 0x030606
977
| GNUTLS_ENABLE_RAWPK
978
#endif
979
));
568
980
if(quit_now){
569
981
return -1;
570
982
}
611
1023
/* ignore client certificate if any. */
612
1024
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
613
1025
614
gnutls_dh_set_prime_bits(*session, mc->dh_bits);
615
616
1026
return 0;
617
1027
}
618
1028
620
1030
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
621
1031
__attribute__((unused)) const char *txt){}
622
1032
1033
/* Helper function to add_local_route() and delete_local_route() */
1034
__attribute__((nonnull, warn_unused_result))
1035
static bool add_delete_local_route(const bool add,
1036
const char *address,
1037
AvahiIfIndex if_index){
1038
int ret;
1039
char helper[] = "mandos-client-iprouteadddel";
1040
char add_arg[] = "add";
1041
char delete_arg[] = "delete";
1042
char debug_flag[] = "--debug";
1043
char *pluginhelperdir = getenv("MANDOSPLUGINHELPERDIR");
1044
if(pluginhelperdir == NULL){
1045
if(debug){
1046
fprintf_plus(stderr, "MANDOSPLUGINHELPERDIR environment"
1047
" variable not set; cannot run helper\n");
1048
}
1049
return false;
1050
}
1051
1052
char interface[IF_NAMESIZE];
1053
if(if_indextoname((unsigned int)if_index, interface) == NULL){
1054
perror_plus("if_indextoname");
1055
return false;
1056
}
1057
1058
int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
1059
if(devnull == -1){
1060
perror_plus("open(\"/dev/null\", O_RDONLY)");
1061
return false;
1062
}
1063
pid_t pid = fork();
1064
if(pid == 0){
1065
/* Child */
1066
/* Raise privileges */
1067
errno = raise_privileges_permanently();
1068
if(errno != 0){
1069
perror_plus("Failed to raise privileges");
1070
/* _exit(EX_NOPERM); */
1071
} else {
1072
/* Set group */
1073
errno = 0;
1074
ret = setgid(0);
1075
if(ret == -1){
1076
perror_plus("setgid");
1077
_exit(EX_NOPERM);
1078
}
1079
/* Reset supplementary groups */
1080
errno = 0;
1081
ret = setgroups(0, NULL);
1082
if(ret == -1){
1083
perror_plus("setgroups");
1084
_exit(EX_NOPERM);
1085
}
1086
}
1087
ret = dup2(devnull, STDIN_FILENO);
1088
if(ret == -1){
1089
perror_plus("dup2(devnull, STDIN_FILENO)");
1090
_exit(EX_OSERR);
1091
}
1092
ret = close(devnull);
1093
if(ret == -1){
1094
perror_plus("close");
1095
_exit(EX_OSERR);
1096
}
1097
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
1098
if(ret == -1){
1099
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
1100
_exit(EX_OSERR);
1101
}
1102
int helperdir_fd = (int)TEMP_FAILURE_RETRY(open(pluginhelperdir,
1103
O_RDONLY
1104
| O_DIRECTORY
1105
| O_PATH
1106
| O_CLOEXEC));
1107
if(helperdir_fd == -1){
1108
perror_plus("open");
1109
_exit(EX_UNAVAILABLE);
1110
}
1111
int helper_fd = (int)TEMP_FAILURE_RETRY(openat(helperdir_fd,
1112
helper, O_RDONLY));
1113
if(helper_fd == -1){
1114
perror_plus("openat");
1115
close(helperdir_fd);
1116
_exit(EX_UNAVAILABLE);
1117
}
1118
close(helperdir_fd);
1119
#ifdef __GNUC__
1120
#pragma GCC diagnostic push
1121
#pragma GCC diagnostic ignored "-Wcast-qual"
1122
#endif
1123
if(fexecve(helper_fd, (char *const [])
1124
{ helper, add ? add_arg : delete_arg, (char *)address,
1125
interface, debug ? debug_flag : NULL, NULL },
1126
environ) == -1){
1127
#ifdef __GNUC__
1128
#pragma GCC diagnostic pop
1129
#endif
1130
perror_plus("fexecve");
1131
_exit(EXIT_FAILURE);
1132
}
1133
}
1134
if(pid == -1){
1135
perror_plus("fork");
1136
return false;
1137
}
1138
int status;
1139
pid_t pret = -1;
1140
errno = 0;
1141
do {
1142
pret = waitpid(pid, &status, 0);
1143
if(pret == -1 and errno == EINTR and quit_now){
1144
int errno_raising = 0;
1145
if((errno = raise_privileges()) != 0){
1146
errno_raising = errno;
1147
perror_plus("Failed to raise privileges in order to"
1148
" kill helper program");
1149
}
1150
if(kill(pid, SIGTERM) == -1){
1151
perror_plus("kill");
1152
}
1153
if((errno_raising == 0) and (errno = lower_privileges()) != 0){
1154
perror_plus("Failed to lower privileges after killing"
1155
" helper program");
1156
}
1157
return false;
1158
}
1159
} while(pret == -1 and errno == EINTR);
1160
if(pret == -1){
1161
perror_plus("waitpid");
1162
return false;
1163
}
1164
if(WIFEXITED(status)){
1165
if(WEXITSTATUS(status) != 0){
1166
fprintf_plus(stderr, "Error: iprouteadddel exited"
1167
" with status %d\n", WEXITSTATUS(status));
1168
return false;
1169
}
1170
return true;
1171
}
1172
if(WIFSIGNALED(status)){
1173
fprintf_plus(stderr, "Error: iprouteadddel died by"
1174
" signal %d\n", WTERMSIG(status));
1175
return false;
1176
}
1177
fprintf_plus(stderr, "Error: iprouteadddel crashed\n");
1178
return false;
1179
}
1180
1181
__attribute__((nonnull, warn_unused_result))
1182
static bool add_local_route(const char *address,
1183
AvahiIfIndex if_index){
1184
if(debug){
1185
fprintf_plus(stderr, "Adding route to %s\n", address);
1186
}
1187
return add_delete_local_route(true, address, if_index);
1188
}
1189
1190
__attribute__((nonnull, warn_unused_result))
1191
static bool delete_local_route(const char *address,
1192
AvahiIfIndex if_index){
1193
if(debug){
1194
fprintf_plus(stderr, "Removing route to %s\n", address);
1195
}
1196
return add_delete_local_route(false, address, if_index);
1197
}
1198
623
1199
/* Called when a Mandos server is found */
1200
__attribute__((nonnull, warn_unused_result))
624
1201
static int start_mandos_communication(const char *ip, in_port_t port,
625
1202
AvahiIfIndex if_index,
626
1203
int af, mandos_context *mc){
627
1204
int ret, tcp_sd = -1;
628
1205
ssize_t sret;
629
union {
630
struct sockaddr_in in;
631
struct sockaddr_in6 in6;
632
} to;
1206
struct sockaddr_storage to;
633
1207
char *buffer = NULL;
634
1208
char *decrypted_buffer = NULL;
635
1209
size_t buffer_length = 0;
638
1212
int retval = -1;
639
1213
gnutls_session_t session;
640
1214
int pf; /* Protocol family */
1215
bool route_added = false;
641
1216
642
1217
errno = 0;
643
1218
665
1240
bool match = false;
666
1241
{
667
1242
char *interface = NULL;
668
while((interface=argz_next(mc->interfaces, mc->interfaces_size,
669
interface))){
1243
while((interface = argz_next(mc->interfaces,
1244
mc->interfaces_size,
1245
interface))){
670
1246
if(if_nametoindex(interface) == (unsigned int)if_index){
671
1247
match = true;
672
1248
break;
701
1277
PRIuMAX "\n", ip, (uintmax_t)port);
702
1278
}
703
1279
704
tcp_sd = socket(pf, SOCK_STREAM, 0);
1280
tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
705
1281
if(tcp_sd < 0){
706
1282
int e = errno;
707
1283
perror_plus("socket");
714
1290
goto mandos_end;
715
1291
}
716
1292
717
memset(&to, 0, sizeof(to));
718
1293
if(af == AF_INET6){
719
to.in6.sin6_family = (sa_family_t)af;
720
ret = inet_pton(af, ip, &to.in6.sin6_addr);
1294
struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)&to;
1295
*to6 = (struct sockaddr_in6){ .sin6_family = (sa_family_t)af };
1296
ret = inet_pton(af, ip, &to6->sin6_addr);
721
1297
} else { /* IPv4 */
722
to.in.sin_family = (sa_family_t)af;
723
ret = inet_pton(af, ip, &to.in.sin_addr);
1298
struct sockaddr_in *to4 = (struct sockaddr_in *)&to;
1299
*to4 = (struct sockaddr_in){ .sin_family = (sa_family_t)af };
1300
ret = inet_pton(af, ip, &to4->sin_addr);
724
1301
}
725
1302
if(ret < 0 ){
726
1303
int e = errno;
735
1312
goto mandos_end;
736
1313
}
737
1314
if(af == AF_INET6){
738
to.in6.sin6_port = htons(port);
739
if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
740
(&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
741
-Wunreachable-code*/
1315
((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
1316
if(IN6_IS_ADDR_LINKLOCAL
1317
(&((struct sockaddr_in6 *)&to)->sin6_addr)){
742
1318
if(if_index == AVAHI_IF_UNSPEC){
743
1319
fprintf_plus(stderr, "An IPv6 link-local address is"
744
1320
" incomplete without a network interface\n");
746
1322
goto mandos_end;
747
1323
}
748
1324
/* Set the network interface number as scope */
749
to.in6.sin6_scope_id = (uint32_t)if_index;
1325
((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
750
1326
}
751
1327
} else {
752
to.in.sin_port = htons(port); /* Spurious warnings from
753
-Wconversion and
754
-Wunreachable-code */
1328
((struct sockaddr_in *)&to)->sin_port = htons(port);
755
1329
}
756
1330
757
1331
if(quit_now){
774
1348
}
775
1349
char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
776
1350
INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
777
const char *pcret;
778
if(af == AF_INET6){
779
pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
780
sizeof(addrstr));
781
} else {
782
pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
783
sizeof(addrstr));
784
}
785
if(pcret == NULL){
786
perror_plus("inet_ntop");
787
} else {
788
if(strcmp(addrstr, ip) != 0){
789
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
790
}
791
}
792
}
793
794
if(quit_now){
795
errno = EINTR;
796
goto mandos_end;
797
}
798
799
if(af == AF_INET6){
800
ret = connect(tcp_sd, &to.in6, sizeof(to));
801
} else {
802
ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
803
}
804
if(ret < 0){
805
if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
806
int e = errno;
807
perror_plus("connect");
808
errno = e;
809
}
810
goto mandos_end;
811
}
812
813
if(quit_now){
814
errno = EINTR;
815
goto mandos_end;
1351
if(af == AF_INET6){
1352
ret = getnameinfo((struct sockaddr *)&to,
1353
sizeof(struct sockaddr_in6),
1354
addrstr, sizeof(addrstr), NULL, 0,
1355
NI_NUMERICHOST);
1356
} else {
1357
ret = getnameinfo((struct sockaddr *)&to,
1358
sizeof(struct sockaddr_in),
1359
addrstr, sizeof(addrstr), NULL, 0,
1360
NI_NUMERICHOST);
1361
}
1362
if(ret == EAI_SYSTEM){
1363
perror_plus("getnameinfo");
1364
} else if(ret != 0) {
1365
fprintf_plus(stderr, "getnameinfo: %s", gai_strerror(ret));
1366
} else if(strcmp(addrstr, ip) != 0){
1367
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
1368
}
1369
}
1370
1371
if(quit_now){
1372
errno = EINTR;
1373
goto mandos_end;
1374
}
1375
1376
while(true){
1377
if(af == AF_INET6){
1378
ret = connect(tcp_sd, (struct sockaddr *)&to,
1379
sizeof(struct sockaddr_in6));
1380
} else {
1381
ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
1382
sizeof(struct sockaddr_in));
1383
}
1384
if(ret < 0){
1385
if(((errno == ENETUNREACH) or (errno == EHOSTUNREACH))
1386
and if_index != AVAHI_IF_UNSPEC
1387
and connect_to == NULL
1388
and not route_added and
1389
((af == AF_INET6 and not
1390
IN6_IS_ADDR_LINKLOCAL(&(((struct sockaddr_in6 *)
1391
&to)->sin6_addr)))
1392
or (af == AF_INET and
1393
/* Not a a IPv4LL address */
1394
(ntohl(((struct sockaddr_in *)&to)->sin_addr.s_addr)
1395
& 0xFFFF0000L) != 0xA9FE0000L))){
1396
/* Work around Avahi bug - Avahi does not announce link-local
1397
addresses if it has a global address, so local hosts with
1398
*only* a link-local address (e.g. Mandos clients) cannot
1399
connect to a Mandos server announced by Avahi on a server
1400
host with a global address. Work around this by retrying
1401
with an explicit route added with the server's address.
1402
1403
Avahi bug reference:
1404
https://lists.freedesktop.org/archives/avahi/2010-February/001833.html
1405
https://bugs.debian.org/587961
1406
*/
1407
if(debug){
1408
fprintf_plus(stderr, "Mandos server unreachable, trying"
1409
" direct route\n");
1410
}
1411
int e = errno;
1412
route_added = add_local_route(ip, if_index);
1413
if(route_added){
1414
continue;
1415
}
1416
errno = e;
1417
}
1418
if(errno != ECONNREFUSED or debug){
1419
int e = errno;
1420
perror_plus("connect");
1421
errno = e;
1422
}
1423
goto mandos_end;
1424
}
1425
1426
if(quit_now){
1427
errno = EINTR;
1428
goto mandos_end;
1429
}
1430
break;
816
1431
}
817
1432
818
1433
const char *out = mandos_protocol_version;
972
1587
&decrypted_buffer, mc);
973
1588
if(decrypted_buffer_size >= 0){
974
1589
1590
clearerr(stdout);
975
1591
written = 0;
976
1592
while(written < (size_t) decrypted_buffer_size){
977
1593
if(quit_now){
993
1609
}
994
1610
written += (size_t)ret;
995
1611
}
1612
ret = fflush(stdout);
1613
if(ret != 0){
1614
int e = errno;
1615
if(debug){
1616
fprintf_plus(stderr, "Error writing encrypted data: %s\n",
1617
strerror(errno));
1618
}
1619
errno = e;
1620
goto mandos_end;
1621
}
996
1622
retval = 0;
997
1623
}
998
1624
}
1001
1627
1002
1628
mandos_end:
1003
1629
{
1630
if(route_added){
1631
if(not delete_local_route(ip, if_index)){
1632
fprintf_plus(stderr, "Failed to delete local route to %s on"
1633
" interface %d", ip, if_index);
1634
}
1635
}
1004
1636
int e = errno;
1005
1637
free(decrypted_buffer);
1006
1638
free(buffer);
1007
1639
if(tcp_sd >= 0){
1008
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
1640
ret = close(tcp_sd);
1009
1641
}
1010
1642
if(ret == -1){
1011
1643
if(e == 0){
1036
1668
AVAHI_GCC_UNUSED AvahiStringList *txt,
1037
1669
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1038
1670
flags,
1039
void* mc){
1671
void *mc){
1040
1672
if(r == NULL){
1041
1673
return;
1042
1674
}
1045
1677
timed out */
1046
1678
1047
1679
if(quit_now){
1680
avahi_s_service_resolver_free(r);
1048
1681
return;
1049
1682
}
1050
1683
1095
1728
const char *domain,
1096
1729
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1097
1730
flags,
1098
void* mc){
1731
void *mc){
1099
1732
if(b == NULL){
1100
1733
return;
1101
1734
}
1161
1794
errno = old_errno;
1162
1795
}
1163
1796
1797
__attribute__((nonnull, warn_unused_result))
1164
1798
bool get_flags(const char *ifname, struct ifreq *ifr){
1165
1799
int ret;
1166
error_t ret_errno;
1800
int old_errno;
1167
1801
1168
1802
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1169
1803
if(s < 0){
1170
ret_errno = errno;
1804
old_errno = errno;
1171
1805
perror_plus("socket");
1172
errno = ret_errno;
1806
errno = old_errno;
1173
1807
return false;
1174
1808
}
1175
strcpy(ifr->ifr_name, ifname);
1809
strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
1810
ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
1176
1811
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1177
1812
if(ret == -1){
1178
1813
if(debug){
1179
ret_errno = errno;
1814
old_errno = errno;
1180
1815
perror_plus("ioctl SIOCGIFFLAGS");
1181
errno = ret_errno;
1816
errno = old_errno;
1817
}
1818
if((close(s) == -1) and debug){
1819
old_errno = errno;
1820
perror_plus("close");
1821
errno = old_errno;
1182
1822
}
1183
1823
return false;
1184
1824
}
1825
if((close(s) == -1) and debug){
1826
old_errno = errno;
1827
perror_plus("close");
1828
errno = old_errno;
1829
}
1185
1830
return true;
1186
1831
}
1187
1832
1833
__attribute__((nonnull, warn_unused_result))
1188
1834
bool good_flags(const char *ifname, const struct ifreq *ifr){
1189
1835
1190
1836
/* Reject the loopback device */
1232
1878
* corresponds to an acceptable network device.
1233
1879
* (This function is passed to scandir(3) as a filter function.)
1234
1880
*/
1881
__attribute__((nonnull, warn_unused_result))
1235
1882
int good_interface(const struct dirent *if_entry){
1236
1883
if(if_entry->d_name[0] == '.'){
1237
1884
return 0;
1255
1902
/*
1256
1903
* This function determines if a network interface is up.
1257
1904
*/
1905
__attribute__((nonnull, warn_unused_result))
1258
1906
bool interface_is_up(const char *interface){
1259
1907
struct ifreq ifr;
1260
1908
if(not get_flags(interface, &ifr)){
1271
1919
/*
1272
1920
* This function determines if a network interface is running
1273
1921
*/
1922
__attribute__((nonnull, warn_unused_result))
1274
1923
bool interface_is_running(const char *interface){
1275
1924
struct ifreq ifr;
1276
1925
if(not get_flags(interface, &ifr)){
1284
1933
return (bool)(ifr.ifr_flags & IFF_RUNNING);
1285
1934
}
1286
1935
1936
__attribute__((nonnull, pure, warn_unused_result))
1287
1937
int notdotentries(const struct dirent *direntry){
1288
1938
/* Skip "." and ".." */
1289
1939
if(direntry->d_name[0] == '.'
1296
1946
}
1297
1947
1298
1948
/* Is this directory entry a runnable program? */
1949
__attribute__((nonnull, warn_unused_result))
1299
1950
int runnable_hook(const struct dirent *direntry){
1300
1951
int ret;
1301
1952
size_t sret;
1309
1960
sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1310
1961
"abcdefghijklmnopqrstuvwxyz"
1311
1962
"0123456789"
1312
"_-");
1963
"_.-");
1313
1964
if((direntry->d_name)[sret] != '\0'){
1314
1965
/* Contains non-allowed characters */
1315
1966
if(debug){
1319
1970
return 0;
1320
1971
}
1321
1972
1322
char *fullname = NULL;
1323
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1324
if(ret < 0){
1325
perror_plus("asprintf");
1326
return 0;
1327
}
1328
1329
ret = stat(fullname, &st);
1973
ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1330
1974
if(ret == -1){
1331
1975
if(debug){
1332
1976
perror_plus("Could not stat hook");
1356
2000
return 1;
1357
2001
}
1358
2002
2003
__attribute__((nonnull, warn_unused_result))
1359
2004
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
1360
2005
mandos_context *mc){
1361
2006
int ret;
1365
2010
1366
2011
while(true){
1367
2012
if(mc->current_server == NULL){
1368
if (debug){
2013
if(debug){
1369
2014
fprintf_plus(stderr, "Wait until first server is found."
1370
2015
" No timeout!\n");
1371
2016
}
1372
2017
ret = avahi_simple_poll_iterate(s, -1);
1373
2018
} else {
1374
if (debug){
2019
if(debug){
1375
2020
fprintf_plus(stderr, "Check current_server if we should run"
1376
2021
" it, or wait\n");
1377
2022
}
1394
2039
- ((intmax_t)waited_time.tv_sec * 1000))
1395
2040
- ((intmax_t)waited_time.tv_nsec / 1000000));
1396
2041
1397
if (debug){
2042
if(debug){
1398
2043
fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1399
2044
block_time);
1400
2045
}
1422
2067
ret = avahi_simple_poll_iterate(s, (int)block_time);
1423
2068
}
1424
2069
if(ret != 0){
1425
if (ret > 0 or errno != EINTR){
2070
if(ret > 0 or errno != EINTR){
1426
2071
return (ret != 1) ? ret : 0;
1427
2072
}
1428
2073
}
1429
2074
}
1430
2075
}
1431
2076
1432
/* Set effective uid to 0, return errno */
1433
error_t raise_privileges(void){
1434
error_t old_errno = errno;
1435
error_t ret_errno = 0;
1436
if(seteuid(0) == -1){
1437
ret_errno = errno;
1438
perror_plus("seteuid");
1439
}
1440
errno = old_errno;
1441
return ret_errno;
1442
}
1443
1444
/* Set effective and real user ID to 0. Return errno. */
1445
error_t raise_privileges_permanently(void){
1446
error_t old_errno = errno;
1447
error_t ret_errno = raise_privileges();
1448
if(ret_errno != 0){
1449
errno = old_errno;
1450
return ret_errno;
1451
}
1452
if(setuid(0) == -1){
1453
ret_errno = errno;
1454
perror_plus("seteuid");
1455
}
1456
errno = old_errno;
1457
return ret_errno;
1458
}
1459
1460
/* Set effective user ID to unprivileged saved user ID */
1461
error_t lower_privileges(void){
1462
error_t old_errno = errno;
1463
error_t ret_errno = 0;
1464
if(seteuid(uid) == -1){
1465
ret_errno = errno;
1466
perror_plus("seteuid");
1467
}
1468
errno = old_errno;
1469
return ret_errno;
1470
}
1471
1472
/* Lower privileges permanently */
1473
error_t lower_privileges_permanently(void){
1474
error_t old_errno = errno;
1475
error_t ret_errno = 0;
1476
if(setuid(uid) == -1){
1477
ret_errno = errno;
1478
perror_plus("setuid");
1479
}
1480
errno = old_errno;
1481
return ret_errno;
1482
}
1483
1484
bool run_network_hooks(const char *mode, const char *interface,
2077
__attribute__((nonnull))
2078
void run_network_hooks(const char *mode, const char *interface,
1485
2079
const float delay){
1486
struct dirent **direntries;
2080
struct dirent **direntries = NULL;
2081
if(hookdir_fd == -1){
2082
hookdir_fd = open(hookdir, O_RDONLY | O_DIRECTORY | O_PATH
2083
| O_CLOEXEC);
2084
if(hookdir_fd == -1){
2085
if(errno == ENOENT){
2086
if(debug){
2087
fprintf_plus(stderr, "Network hook directory \"%s\" not"
2088
" found\n", hookdir);
2089
}
2090
} else {
2091
perror_plus("open");
2092
}
2093
return;
2094
}
2095
}
2096
int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
2097
if(devnull == -1){
2098
perror_plus("open(\"/dev/null\", O_RDONLY)");
2099
return;
2100
}
2101
int numhooks = scandirat(hookdir_fd, ".", &direntries,
2102
runnable_hook, alphasort);
2103
if(numhooks == -1){
2104
perror_plus("scandir");
2105
close(devnull);
2106
return;
2107
}
1487
2108
struct dirent *direntry;
1488
2109
int ret;
1489
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1490
alphasort);
1491
if(numhooks == -1){
1492
if(errno == ENOENT){
1493
if(debug){
1494
fprintf_plus(stderr, "Network hook directory \"%s\" not"
1495
" found\n", hookdir);
1496
}
1497
} else {
1498
perror_plus("scandir");
2110
for(int i = 0; i < numhooks; i++){
2111
direntry = direntries[i];
2112
if(debug){
2113
fprintf_plus(stderr, "Running network hook \"%s\"\n",
2114
direntry->d_name);
1499
2115
}
1500
} else {
1501
int devnull = open("/dev/null", O_RDONLY);
1502
for(int i = 0; i < numhooks; i++){
1503
direntry = direntries[i];
1504
char *fullname = NULL;
1505
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1506
if(ret < 0){
2116
pid_t hook_pid = fork();
2117
if(hook_pid == 0){
2118
/* Child */
2119
/* Raise privileges */
2120
errno = raise_privileges_permanently();
2121
if(errno != 0){
2122
perror_plus("Failed to raise privileges");
2123
_exit(EX_NOPERM);
2124
}
2125
/* Set group */
2126
errno = 0;
2127
ret = setgid(0);
2128
if(ret == -1){
2129
perror_plus("setgid");
2130
_exit(EX_NOPERM);
2131
}
2132
/* Reset supplementary groups */
2133
errno = 0;
2134
ret = setgroups(0, NULL);
2135
if(ret == -1){
2136
perror_plus("setgroups");
2137
_exit(EX_NOPERM);
2138
}
2139
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
2140
if(ret == -1){
2141
perror_plus("setenv");
2142
_exit(EX_OSERR);
2143
}
2144
ret = setenv("DEVICE", interface, 1);
2145
if(ret == -1){
2146
perror_plus("setenv");
2147
_exit(EX_OSERR);
2148
}
2149
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
2150
if(ret == -1){
2151
perror_plus("setenv");
2152
_exit(EX_OSERR);
2153
}
2154
ret = setenv("MODE", mode, 1);
2155
if(ret == -1){
2156
perror_plus("setenv");
2157
_exit(EX_OSERR);
2158
}
2159
char *delaystring;
2160
ret = asprintf(&delaystring, "%f", (double)delay);
2161
if(ret == -1){
1507
2162
perror_plus("asprintf");
1508
continue;
1509
}
1510
if(debug){
1511
fprintf_plus(stderr, "Running network hook \"%s\"\n",
1512
direntry->d_name);
1513
}
1514
pid_t hook_pid = fork();
1515
if(hook_pid == 0){
1516
/* Child */
1517
/* Raise privileges */
1518
raise_privileges_permanently();
1519
/* Set group */
1520
errno = 0;
1521
ret = setgid(0);
1522
if(ret == -1){
1523
perror_plus("setgid");
1524
}
1525
/* Reset supplementary groups */
1526
errno = 0;
1527
ret = setgroups(0, NULL);
1528
if(ret == -1){
1529
perror_plus("setgroups");
1530
}
1531
dup2(devnull, STDIN_FILENO);
1532
close(devnull);
1533
dup2(STDERR_FILENO, STDOUT_FILENO);
1534
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1535
if(ret == -1){
1536
perror_plus("setenv");
1537
_exit(EX_OSERR);
1538
}
1539
ret = setenv("DEVICE", interface, 1);
1540
if(ret == -1){
1541
perror_plus("setenv");
1542
_exit(EX_OSERR);
1543
}
1544
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
1545
if(ret == -1){
1546
perror_plus("setenv");
1547
_exit(EX_OSERR);
1548
}
1549
ret = setenv("MODE", mode, 1);
1550
if(ret == -1){
1551
perror_plus("setenv");
1552
_exit(EX_OSERR);
1553
}
1554
char *delaystring;
1555
ret = asprintf(&delaystring, "%f", delay);
1556
if(ret == -1){
1557
perror_plus("asprintf");
1558
_exit(EX_OSERR);
1559
}
1560
ret = setenv("DELAY", delaystring, 1);
1561
if(ret == -1){
1562
free(delaystring);
1563
perror_plus("setenv");
1564
_exit(EX_OSERR);
1565
}
2163
_exit(EX_OSERR);
2164
}
2165
ret = setenv("DELAY", delaystring, 1);
2166
if(ret == -1){
1566
2167
free(delaystring);
1567
if(connect_to != NULL){
1568
ret = setenv("CONNECT", connect_to, 1);
1569
if(ret == -1){
1570
perror_plus("setenv");
1571
_exit(EX_OSERR);
1572
}
1573
}
1574
if(execl(fullname, direntry->d_name, mode, NULL) == -1){
1575
perror_plus("execl");
1576
_exit(EXIT_FAILURE);
1577
}
2168
perror_plus("setenv");
2169
_exit(EX_OSERR);
2170
}
2171
free(delaystring);
2172
if(connect_to != NULL){
2173
ret = setenv("CONNECT", connect_to, 1);
2174
if(ret == -1){
2175
perror_plus("setenv");
2176
_exit(EX_OSERR);
2177
}
2178
}
2179
int hook_fd = (int)TEMP_FAILURE_RETRY(openat(hookdir_fd,
2180
direntry->d_name,
2181
O_RDONLY));
2182
if(hook_fd == -1){
2183
perror_plus("openat");
2184
_exit(EXIT_FAILURE);
2185
}
2186
if(close(hookdir_fd) == -1){
2187
perror_plus("close");
2188
_exit(EXIT_FAILURE);
2189
}
2190
ret = dup2(devnull, STDIN_FILENO);
2191
if(ret == -1){
2192
perror_plus("dup2(devnull, STDIN_FILENO)");
2193
_exit(EX_OSERR);
2194
}
2195
ret = close(devnull);
2196
if(ret == -1){
2197
perror_plus("close");
2198
_exit(EX_OSERR);
2199
}
2200
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
2201
if(ret == -1){
2202
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
2203
_exit(EX_OSERR);
2204
}
2205
if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
2206
environ) == -1){
2207
perror_plus("fexecve");
2208
_exit(EXIT_FAILURE);
2209
}
2210
} else {
2211
if(hook_pid == -1){
2212
perror_plus("fork");
2213
free(direntry);
2214
continue;
2215
}
2216
int status;
2217
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
2218
perror_plus("waitpid");
2219
free(direntry);
2220
continue;
2221
}
2222
if(WIFEXITED(status)){
2223
if(WEXITSTATUS(status) != 0){
2224
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
2225
" with status %d\n", direntry->d_name,
2226
WEXITSTATUS(status));
2227
free(direntry);
2228
continue;
2229
}
2230
} else if(WIFSIGNALED(status)){
2231
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
2232
" signal %d\n", direntry->d_name,
2233
WTERMSIG(status));
2234
free(direntry);
2235
continue;
1578
2236
} else {
1579
int status;
1580
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1581
perror_plus("waitpid");
1582
free(fullname);
1583
continue;
1584
}
1585
if(WIFEXITED(status)){
1586
if(WEXITSTATUS(status) != 0){
1587
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1588
" with status %d\n", direntry->d_name,
1589
WEXITSTATUS(status));
1590
free(fullname);
1591
continue;
1592
}
1593
} else if(WIFSIGNALED(status)){
1594
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1595
" signal %d\n", direntry->d_name,
1596
WTERMSIG(status));
1597
free(fullname);
1598
continue;
1599
} else {
1600
fprintf_plus(stderr, "Warning: network hook \"%s\""
1601
" crashed\n", direntry->d_name);
1602
free(fullname);
1603
continue;
1604
}
1605
}
1606
free(fullname);
1607
if(debug){
1608
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1609
direntry->d_name);
1610
}
1611
}
1612
close(devnull);
1613
}
1614
return true;
2237
fprintf_plus(stderr, "Warning: network hook \"%s\""
2238
" crashed\n", direntry->d_name);
2239
free(direntry);
2240
continue;
2241
}
2242
}
2243
if(debug){
2244
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
2245
direntry->d_name);
2246
}
2247
free(direntry);
2248
}
2249
free(direntries);
2250
if(close(hookdir_fd) == -1){
2251
perror_plus("close");
2252
} else {
2253
hookdir_fd = -1;
2254
}
2255
close(devnull);
1615
2256
}
1616
2257
1617
error_t bring_up_interface(const char *const interface,
1618
const float delay){
1619
int sd = -1;
1620
error_t old_errno = errno;
1621
error_t ret_errno = 0;
1622
int ret, ret_setflags;
2258
__attribute__((nonnull, warn_unused_result))
2259
int bring_up_interface(const char *const interface,
2260
const float delay){
2261
int old_errno = errno;
2262
int ret;
1623
2263
struct ifreq network;
1624
2264
unsigned int if_index = if_nametoindex(interface);
1625
2265
if(if_index == 0){
1634
2274
}
1635
2275
1636
2276
if(not interface_is_up(interface)){
1637
if(not get_flags(interface, &network) and debug){
2277
int ret_errno = 0;
2278
int ioctl_errno = 0;
2279
if(not get_flags(interface, &network)){
1638
2280
ret_errno = errno;
1639
2281
fprintf_plus(stderr, "Failed to get flags for interface "
1640
2282
"\"%s\"\n", interface);
2283
errno = old_errno;
1641
2284
return ret_errno;
1642
2285
}
1643
network.ifr_flags |= IFF_UP;
2286
network.ifr_flags |= IFF_UP; /* set flag */
1644
2287
1645
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1646
if(sd < 0){
2288
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
2289
if(sd == -1){
1647
2290
ret_errno = errno;
1648
2291
perror_plus("socket");
1649
2292
errno = old_errno;
1650
2293
return ret_errno;
1651
2294
}
1652
2295
1653
2296
if(quit_now){
1654
close(sd);
2297
ret = close(sd);
2298
if(ret == -1){
2299
perror_plus("close");
2300
}
1655
2301
errno = old_errno;
1656
2302
return EINTR;
1657
2303
}
1661
2307
interface);
1662
2308
}
1663
2309
1664
/* Raise priviliges */
1665
raise_privileges();
2310
/* Raise privileges */
2311
ret_errno = raise_privileges();
2312
if(ret_errno != 0){
2313
errno = ret_errno;
2314
perror_plus("Failed to raise privileges");
2315
}
1666
2316
1667
2317
#ifdef __linux__
1668
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1669
messages about the network interface to mess up the prompt */
1670
int ret_linux = klogctl(8, NULL, 5);
1671
bool restore_loglevel = true;
1672
if(ret_linux == -1){
1673
restore_loglevel = false;
1674
perror_plus("klogctl");
2318
int ret_linux;
2319
bool restore_loglevel = false;
2320
if(ret_errno == 0){
2321
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
2322
messages about the network interface to mess up the prompt */
2323
ret_linux = klogctl(8, NULL, 5);
2324
if(ret_linux == -1){
2325
perror_plus("klogctl");
2326
} else {
2327
restore_loglevel = true;
2328
}
1675
2329
}
1676
2330
#endif /* __linux__ */
1677
ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1678
ret_errno = errno;
2331
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
2332
ioctl_errno = errno;
1679
2333
#ifdef __linux__
1680
2334
if(restore_loglevel){
1681
2335
ret_linux = klogctl(7, NULL, 0);
1685
2339
}
1686
2340
#endif /* __linux__ */
1687
2341
1688
/* Lower privileges */
1689
lower_privileges();
2342
/* If raise_privileges() succeeded above */
2343
if(ret_errno == 0){
2344
/* Lower privileges */
2345
ret_errno = lower_privileges();
2346
if(ret_errno != 0){
2347
errno = ret_errno;
2348
perror_plus("Failed to lower privileges");
2349
}
2350
}
1690
2351
1691
2352
/* Close the socket */
1692
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2353
ret = close(sd);
1693
2354
if(ret == -1){
1694
2355
perror_plus("close");
1695
2356
}
1696
2357
1697
2358
if(ret_setflags == -1){
1698
errno = ret_errno;
2359
errno = ioctl_errno;
1699
2360
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1700
2361
errno = old_errno;
1701
return ret_errno;
2362
return ioctl_errno;
1702
2363
}
1703
2364
} else if(debug){
1704
2365
fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
1707
2368
1708
2369
/* Sleep checking until interface is running.
1709
2370
Check every 0.25s, up to total time of delay */
1710
for(int i=0; i < delay * 4; i++){
2371
for(int i = 0; i < delay * 4; i++){
1711
2372
if(interface_is_running(interface)){
1712
2373
break;
1713
2374
}
1722
2383
return 0;
1723
2384
}
1724
2385
1725
error_t take_down_interface(const char *const interface){
1726
int sd = -1;
1727
error_t old_errno = errno;
1728
error_t ret_errno = 0;
1729
int ret, ret_setflags;
2386
__attribute__((nonnull, warn_unused_result))
2387
int take_down_interface(const char *const interface){
2388
int old_errno = errno;
1730
2389
struct ifreq network;
1731
2390
unsigned int if_index = if_nametoindex(interface);
1732
2391
if(if_index == 0){
1735
2394
return ENXIO;
1736
2395
}
1737
2396
if(interface_is_up(interface)){
2397
int ret_errno = 0;
2398
int ioctl_errno = 0;
1738
2399
if(not get_flags(interface, &network) and debug){
1739
2400
ret_errno = errno;
1740
2401
fprintf_plus(stderr, "Failed to get flags for interface "
1741
2402
"\"%s\"\n", interface);
2403
errno = old_errno;
1742
2404
return ret_errno;
1743
2405
}
1744
2406
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
1745
2407
1746
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1747
if(sd < 0){
2408
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
2409
if(sd == -1){
1748
2410
ret_errno = errno;
1749
2411
perror_plus("socket");
1750
2412
errno = old_errno;
1756
2418
interface);
1757
2419
}
1758
2420
1759
/* Raise priviliges */
1760
raise_privileges();
1761
1762
ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1763
ret_errno = errno;
1764
1765
/* Lower privileges */
1766
lower_privileges();
2421
/* Raise privileges */
2422
ret_errno = raise_privileges();
2423
if(ret_errno != 0){
2424
errno = ret_errno;
2425
perror_plus("Failed to raise privileges");
2426
}
2427
2428
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
2429
ioctl_errno = errno;
2430
2431
/* If raise_privileges() succeeded above */
2432
if(ret_errno == 0){
2433
/* Lower privileges */
2434
ret_errno = lower_privileges();
2435
if(ret_errno != 0){
2436
errno = ret_errno;
2437
perror_plus("Failed to lower privileges");
2438
}
2439
}
1767
2440
1768
2441
/* Close the socket */
1769
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2442
int ret = close(sd);
1770
2443
if(ret == -1){
1771
2444
perror_plus("close");
1772
2445
}
1773
2446
1774
2447
if(ret_setflags == -1){
1775
errno = ret_errno;
2448
errno = ioctl_errno;
1776
2449
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
1777
2450
errno = old_errno;
1778
return ret_errno;
2451
return ioctl_errno;
1779
2452
}
1780
2453
} else if(debug){
1781
2454
fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
1787
2460
}
1788
2461
1789
2462
int main(int argc, char *argv[]){
1790
mandos_context mc = { .server = NULL, .dh_bits = 1024,
1791
.priority = "SECURE256:!CTYPE-X.509:"
1792
"+CTYPE-OPENPGP", .current_server = NULL,
1793
.interfaces = NULL, .interfaces_size = 0 };
2463
mandos_context mc = { .server = NULL, .dh_bits = 0,
2464
#if GNUTLS_VERSION_NUMBER >= 0x030606
2465
.priority = "SECURE128:!CTYPE-X.509"
2466
":+CTYPE-RAWPK:!RSA:!VERS-ALL:+VERS-TLS1.3"
2467
":%PROFILE_ULTRA",
2468
#elif GNUTLS_VERSION_NUMBER < 0x030600
2469
.priority = "SECURE256:!CTYPE-X.509"
2470
":+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256",
2471
#else
2472
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
2473
#endif
2474
.current_server = NULL, .interfaces = NULL,
2475
.interfaces_size = 0 };
1794
2476
AvahiSServiceBrowser *sb = NULL;
1795
2477
error_t ret_errno;
1796
2478
int ret;
1799
2481
int exitcode = EXIT_SUCCESS;
1800
2482
char *interfaces_to_take_down = NULL;
1801
2483
size_t interfaces_to_take_down_size = 0;
1802
char tempdir[] = "/tmp/mandosXXXXXX";
1803
bool tempdir_created = false;
2484
char run_tempdir[] = "/run/tmp/mandosXXXXXX";
2485
char old_tempdir[] = "/tmp/mandosXXXXXX";
2486
char *tempdir = NULL;
1804
2487
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1805
2488
const char *seckey = PATHDIR "/" SECKEY;
1806
2489
const char *pubkey = PATHDIR "/" PUBKEY;
2490
#if GNUTLS_VERSION_NUMBER >= 0x030606
2491
const char *tls_privkey = PATHDIR "/" TLS_PRIVKEY;
2492
const char *tls_pubkey = PATHDIR "/" TLS_PUBKEY;
2493
#endif
2494
const char *dh_params_file = NULL;
1807
2495
char *interfaces_hooks = NULL;
1808
size_t interfaces_hooks_size = 0;
1809
2496
1810
2497
bool gnutls_initialized = false;
1811
2498
bool gpgme_initialized = false;
1857
2544
{ .name = "pubkey", .key = 'p',
1858
2545
.arg = "FILE",
1859
2546
.doc = "OpenPGP public key file base name",
1860
.group = 2 },
2547
.group = 1 },
2548
{ .name = "tls-privkey", .key = 't',
2549
.arg = "FILE",
2550
#if GNUTLS_VERSION_NUMBER >= 0x030606
2551
.doc = "TLS private key file base name",
2552
#else
2553
.doc = "Dummy; ignored (requires GnuTLS 3.6.6)",
2554
#endif
2555
.group = 1 },
2556
{ .name = "tls-pubkey", .key = 'T',
2557
.arg = "FILE",
2558
#if GNUTLS_VERSION_NUMBER >= 0x030606
2559
.doc = "TLS public key file base name",
2560
#else
2561
.doc = "Dummy; ignored (requires GnuTLS 3.6.6)",
2562
#endif
2563
.group = 1 },
1861
2564
{ .name = "dh-bits", .key = 129,
1862
2565
.arg = "BITS",
1863
2566
.doc = "Bit length of the prime number used in the"
1864
2567
" Diffie-Hellman key exchange",
1865
2568
.group = 2 },
2569
{ .name = "dh-params", .key = 134,
2570
.arg = "FILE",
2571
.doc = "PEM-encoded PKCS#3 file with pre-generated parameters"
2572
" for the Diffie-Hellman key exchange",
2573
.group = 2 },
1866
2574
{ .name = "priority", .key = 130,
1867
2575
.arg = "STRING",
1868
2576
.doc = "GnuTLS priority string for the TLS handshake",
1914
2622
case 'p': /* --pubkey */
1915
2623
pubkey = arg;
1916
2624
break;
2625
case 't': /* --tls-privkey */
2626
#if GNUTLS_VERSION_NUMBER >= 0x030606
2627
tls_privkey = arg;
2628
#endif
2629
break;
2630
case 'T': /* --tls-pubkey */
2631
#if GNUTLS_VERSION_NUMBER >= 0x030606
2632
tls_pubkey = arg;
2633
#endif
2634
break;
1917
2635
case 129: /* --dh-bits */
1918
2636
errno = 0;
1919
2637
tmpmax = strtoimax(arg, &tmp, 10);
1923
2641
}
1924
2642
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
1925
2643
break;
2644
case 134: /* --dh-params */
2645
dh_params_file = arg;
2646
break;
1926
2647
case 130: /* --priority */
1927
2648
mc.priority = arg;
1928
2649
break;
1968
2689
.args_doc = "",
1969
2690
.doc = "Mandos client -- Get and decrypt"
1970
2691
" passwords from a Mandos server" };
1971
ret = argp_parse(&argp, argc, argv,
1972
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
1973
switch(ret){
2692
ret_errno = argp_parse(&argp, argc, argv,
2693
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2694
switch(ret_errno){
1974
2695
case 0:
1975
2696
break;
1976
2697
case ENOMEM:
1977
2698
default:
1978
errno = ret;
2699
errno = ret_errno;
1979
2700
perror_plus("argp_parse");
1980
2701
exitcode = EX_OSERR;
1981
2702
goto end;
1984
2705
goto end;
1985
2706
}
1986
2707
}
1987
2708
1988
2709
{
1989
2710
/* Work around Debian bug #633582:
1990
<http://bugs.debian.org/633582> */
2711
<https://bugs.debian.org/633582> */
1991
2712
1992
/* Re-raise priviliges */
1993
if(raise_privileges() == 0){
2713
/* Re-raise privileges */
2714
ret = raise_privileges();
2715
if(ret != 0){
2716
errno = ret;
2717
perror_plus("Failed to raise privileges");
2718
} else {
1994
2719
struct stat st;
1995
2720
1996
2721
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
2010
2735
}
2011
2736
}
2012
2737
}
2013
TEMP_FAILURE_RETRY(close(seckey_fd));
2738
close(seckey_fd);
2014
2739
}
2015
2740
}
2016
2741
2017
2742
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2018
2743
int pubkey_fd = open(pubkey, O_RDONLY);
2019
2744
if(pubkey_fd == -1){
2031
2756
}
2032
2757
}
2033
2758
}
2034
TEMP_FAILURE_RETRY(close(pubkey_fd));
2035
}
2036
}
2037
2759
close(pubkey_fd);
2760
}
2761
}
2762
2763
if(dh_params_file != NULL
2764
and strcmp(dh_params_file, PATHDIR "/dhparams.pem" ) == 0){
2765
int dhparams_fd = open(dh_params_file, O_RDONLY);
2766
if(dhparams_fd == -1){
2767
perror_plus("open");
2768
} else {
2769
ret = (int)TEMP_FAILURE_RETRY(fstat(dhparams_fd, &st));
2770
if(ret == -1){
2771
perror_plus("fstat");
2772
} else {
2773
if(S_ISREG(st.st_mode)
2774
and st.st_uid == 0 and st.st_gid == 0){
2775
ret = fchown(dhparams_fd, uid, gid);
2776
if(ret == -1){
2777
perror_plus("fchown");
2778
}
2779
}
2780
}
2781
close(dhparams_fd);
2782
}
2783
}
2784
2038
2785
/* Lower privileges */
2039
lower_privileges();
2786
ret = lower_privileges();
2787
if(ret != 0){
2788
errno = ret;
2789
perror_plus("Failed to lower privileges");
2790
}
2040
2791
}
2041
2792
}
2042
2793
2066
2817
goto end;
2067
2818
}
2068
2819
memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
2069
interfaces_hooks_size = mc.interfaces_size;
2070
argz_stringify(interfaces_hooks, interfaces_hooks_size,
2071
(int)',');
2072
}
2073
if(not run_network_hooks("start", interfaces_hooks != NULL ?
2074
interfaces_hooks : "", delay)){
2075
goto end;
2076
}
2820
argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
2821
}
2822
run_network_hooks("start", interfaces_hooks != NULL ?
2823
interfaces_hooks : "", delay);
2077
2824
}
2078
2825
2079
2826
if(not debug){
2157
2904
2158
2905
/* If no interfaces were specified, make a list */
2159
2906
if(mc.interfaces == NULL){
2160
struct dirent **direntries;
2907
struct dirent **direntries = NULL;
2161
2908
/* Look for any good interfaces */
2162
2909
ret = scandir(sys_class_net, &direntries, good_interface,
2163
2910
alphasort);
2167
2914
ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
2168
2915
direntries[i]->d_name);
2169
2916
if(ret_errno != 0){
2917
errno = ret_errno;
2170
2918
perror_plus("argz_add");
2919
free(direntries[i]);
2171
2920
continue;
2172
2921
}
2173
2922
if(debug){
2174
2923
fprintf_plus(stderr, "Will use interface \"%s\"\n",
2175
2924
direntries[i]->d_name);
2176
2925
}
2926
free(direntries[i]);
2177
2927
}
2178
2928
free(direntries);
2179
2929
} else {
2180
free(direntries);
2930
if(ret == 0){
2931
free(direntries);
2932
}
2181
2933
fprintf_plus(stderr, "Could not find a network interface\n");
2182
2934
exitcode = EXIT_FAILURE;
2183
2935
goto end;
2206
2958
break;
2207
2959
}
2208
2960
bool interface_was_up = interface_is_up(interface);
2209
ret = bring_up_interface(interface, delay);
2961
errno = bring_up_interface(interface, delay);
2210
2962
if(not interface_was_up){
2211
if(ret != 0){
2212
errno = ret;
2213
perror_plus("Failed to bring up interface");
2963
if(errno != 0){
2964
fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
2965
" %s\n", interface, strerror(errno));
2214
2966
} else {
2215
ret_errno = argz_add(&interfaces_to_take_down,
2216
&interfaces_to_take_down_size,
2217
interface);
2967
errno = argz_add(&interfaces_to_take_down,
2968
&interfaces_to_take_down_size,
2969
interface);
2970
if(errno != 0){
2971
perror_plus("argz_add");
2972
}
2218
2973
}
2219
2974
}
2220
2975
}
2236
2991
goto end;
2237
2992
}
2238
2993
2239
ret = init_gnutls_global(pubkey, seckey, &mc);
2994
#if GNUTLS_VERSION_NUMBER >= 0x030606
2995
ret = init_gnutls_global(tls_pubkey, tls_privkey, dh_params_file, &mc);
2996
#elif GNUTLS_VERSION_NUMBER < 0x030600
2997
ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
2998
#else
2999
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
3000
#endif
2240
3001
if(ret == -1){
2241
3002
fprintf_plus(stderr, "init_gnutls_global failed\n");
2242
3003
exitcode = EX_UNAVAILABLE;
2249
3010
goto end;
2250
3011
}
2251
3012
2252
if(mkdtemp(tempdir) == NULL){
3013
/* Try /run/tmp before /tmp */
3014
tempdir = mkdtemp(run_tempdir);
3015
if(tempdir == NULL and errno == ENOENT){
3016
if(debug){
3017
fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
3018
run_tempdir, old_tempdir);
3019
}
3020
tempdir = mkdtemp(old_tempdir);
3021
}
3022
if(tempdir == NULL){
2253
3023
perror_plus("mkdtemp");
2254
3024
goto end;
2255
3025
}
2256
tempdir_created = true;
2257
3026
2258
3027
if(quit_now){
2259
3028
goto end;
2331
3100
fprintf_plus(stderr, "Retrying in %d seconds\n",
2332
3101
(int)retry_interval);
2333
3102
}
2334
sleep((int)retry_interval);
3103
sleep((unsigned int)retry_interval);
2335
3104
}
2336
3105
2337
if (not quit_now){
3106
if(not quit_now){
2338
3107
exitcode = EXIT_SUCCESS;
2339
3108
}
2340
3109
2356
3125
2357
3126
/* Allocate a new server */
2358
3127
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
2359
&config, NULL, NULL, &ret_errno);
3128
&config, NULL, NULL, &ret);
2360
3129
2361
3130
/* Free the Avahi configuration data */
2362
3131
avahi_server_config_free(&config);
2365
3134
/* Check if creating the Avahi server object succeeded */
2366
3135
if(mc.server == NULL){
2367
3136
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2368
avahi_strerror(ret_errno));
3137
avahi_strerror(ret));
2369
3138
exitcode = EX_UNAVAILABLE;
2370
3139
goto end;
2371
3140
}
2395
3164
if(debug){
2396
3165
fprintf_plus(stderr, "Starting Avahi loop search\n");
2397
3166
}
2398
3167
2399
3168
ret = avahi_loop_with_timeout(simple_poll,
2400
3169
(int)(retry_interval * 1000), &mc);
2401
3170
if(debug){
2406
3175
end:
2407
3176
2408
3177
if(debug){
2409
fprintf_plus(stderr, "%s exiting\n", argv[0]);
3178
if(signal_received){
3179
fprintf_plus(stderr, "%s exiting due to signal %d: %s\n",
3180
argv[0], signal_received,
3181
strsignal(signal_received));
3182
} else {
3183
fprintf_plus(stderr, "%s exiting\n", argv[0]);
3184
}
2410
3185
}
2411
3186
2412
3187
/* Cleanup things */
2423
3198
2424
3199
if(gnutls_initialized){
2425
3200
gnutls_certificate_free_credentials(mc.cred);
2426
gnutls_global_deinit();
2427
3201
gnutls_dh_params_deinit(mc.dh_params);
2428
3202
}
2429
3203
2437
3211
mc.current_server->prev->next = NULL;
2438
3212
while(mc.current_server != NULL){
2439
3213
server *next = mc.current_server->next;
3214
#ifdef __GNUC__
3215
#pragma GCC diagnostic push
3216
#pragma GCC diagnostic ignored "-Wcast-qual"
3217
#endif
3218
free((char *)(mc.current_server->ip));
3219
#ifdef __GNUC__
3220
#pragma GCC diagnostic pop
3221
#endif
2440
3222
free(mc.current_server);
2441
3223
mc.current_server = next;
2442
3224
}
2443
3225
}
2444
3226
2445
/* Re-raise priviliges */
3227
/* Re-raise privileges */
2446
3228
{
2447
raise_privileges();
2448
2449
/* Run network hooks */
2450
run_network_hooks("stop", interfaces_hooks != NULL ?
2451
interfaces_hooks : "", delay);
2452
2453
/* Take down the network interfaces which were brought up */
2454
{
2455
char *interface = NULL;
2456
while((interface=argz_next(interfaces_to_take_down,
2457
interfaces_to_take_down_size,
2458
interface))){
2459
ret_errno = take_down_interface(interface);
2460
if(ret_errno != 0){
2461
errno = ret_errno;
2462
perror_plus("Failed to take down interface");
2463
}
2464
}
2465
if(debug and (interfaces_to_take_down == NULL)){
2466
fprintf_plus(stderr, "No interfaces needed to be taken"
2467
" down\n");
2468
}
2469
}
2470
2471
lower_privileges_permanently();
3229
ret = raise_privileges();
3230
if(ret != 0){
3231
errno = ret;
3232
perror_plus("Failed to raise privileges");
3233
} else {
3234
3235
/* Run network hooks */
3236
run_network_hooks("stop", interfaces_hooks != NULL ?
3237
interfaces_hooks : "", delay);
3238
3239
/* Take down the network interfaces which were brought up */
3240
{
3241
char *interface = NULL;
3242
while((interface = argz_next(interfaces_to_take_down,
3243
interfaces_to_take_down_size,
3244
interface))){
3245
ret = take_down_interface(interface);
3246
if(ret != 0){
3247
errno = ret;
3248
perror_plus("Failed to take down interface");
3249
}
3250
}
3251
if(debug and (interfaces_to_take_down == NULL)){
3252
fprintf_plus(stderr, "No interfaces needed to be taken"
3253
" down\n");
3254
}
3255
}
3256
}
3257
3258
ret = lower_privileges_permanently();
3259
if(ret != 0){
3260
errno = ret;
3261
perror_plus("Failed to lower privileges permanently");
3262
}
2472
3263
}
2473
3264
2474
3265
free(interfaces_to_take_down);
2475
3266
free(interfaces_hooks);
2476
3267
3268
void clean_dir_at(int base, const char * const dirname,
3269
uintmax_t level){
3270
struct dirent **direntries = NULL;
3271
int dret;
3272
int dir_fd = (int)TEMP_FAILURE_RETRY(openat(base, dirname,
3273
O_RDONLY
3274
| O_NOFOLLOW
3275
| O_DIRECTORY
3276
| O_PATH));
3277
if(dir_fd == -1){
3278
perror_plus("open");
3279
return;
3280
}
3281
int numentries = scandirat(dir_fd, ".", &direntries,
3282
notdotentries, alphasort);
3283
if(numentries >= 0){
3284
for(int i = 0; i < numentries; i++){
3285
if(debug){
3286
fprintf_plus(stderr, "Unlinking \"%s/%s\"\n",
3287
dirname, direntries[i]->d_name);
3288
}
3289
dret = unlinkat(dir_fd, direntries[i]->d_name, 0);
3290
if(dret == -1){
3291
if(errno == EISDIR){
3292
dret = unlinkat(dir_fd, direntries[i]->d_name,
3293
AT_REMOVEDIR);
3294
}
3295
if((dret == -1) and (errno == ENOTEMPTY)
3296
and (strcmp(direntries[i]->d_name, "private-keys-v1.d")
3297
== 0) and (level == 0)){
3298
/* Recurse only in this special case */
3299
clean_dir_at(dir_fd, direntries[i]->d_name, level+1);
3300
dret = 0;
3301
}
3302
if((dret == -1) and (errno != ENOENT)){
3303
fprintf_plus(stderr, "unlink(\"%s/%s\"): %s\n", dirname,
3304
direntries[i]->d_name, strerror(errno));
3305
}
3306
}
3307
free(direntries[i]);
3308
}
3309
3310
/* need to clean even if 0 because man page doesn't specify */
3311
free(direntries);
3312
dret = unlinkat(base, dirname, AT_REMOVEDIR);
3313
if(dret == -1 and errno != ENOENT){
3314
perror_plus("rmdir");
3315
}
3316
} else {
3317
perror_plus("scandirat");
3318
}
3319
close(dir_fd);
3320
}
3321
2477
3322
/* Removes the GPGME temp directory and all files inside */
2478
if(tempdir_created){
2479
struct dirent **direntries = NULL;
2480
struct dirent *direntry = NULL;
2481
int numentries = scandir(tempdir, &direntries, notdotentries,
2482
alphasort);
2483
if (numentries > 0){
2484
for(int i = 0; i < numentries; i++){
2485
direntry = direntries[i];
2486
char *fullname = NULL;
2487
ret = asprintf(&fullname, "%s/%s", tempdir,
2488
direntry->d_name);
2489
if(ret < 0){
2490
perror_plus("asprintf");
2491
continue;
2492
}
2493
ret = remove(fullname);
2494
if(ret == -1){
2495
fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2496
strerror(errno));
2497
}
2498
free(fullname);
2499
}
2500
}
2501
2502
/* need to clean even if 0 because man page doesn't specify */
2503
free(direntries);
2504
if (numentries == -1){
2505
perror_plus("scandir");
2506
}
2507
ret = rmdir(tempdir);
2508
if(ret == -1 and errno != ENOENT){
2509
perror_plus("rmdir");
2510
}
3323
if(tempdir != NULL){
3324
clean_dir_at(-1, tempdir, 0);
2511
3325
}
2512
3326
2513
3327
if(quit_now){
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0