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:
- debian/upstream-signing-key.pgp
- 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-2013 Teddy Hogeborn
13
* Copyright © 2008-2013 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,
57
59
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
58
60
inet_pton(), connect(),
59
61
getnameinfo() */
60
#include <fcntl.h> /* open() */
62
#include <fcntl.h> /* open(), unlinkat(), AT_REMOVEDIR */
61
63
#include <dirent.h> /* opendir(), struct dirent, readdir()
62
64
*/
63
65
#include <inttypes.h> /* PRIu16, PRIdMAX, intmax_t,
64
66
strtoimax() */
65
#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,
66
72
program_invocation_short_name */
67
73
#include <time.h> /* nanosleep(), time(), sleep() */
68
74
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
73
79
*/
74
80
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
75
81
getuid(), getgid(), seteuid(),
76
setgid(), pause(), _exit() */
82
setgid(), pause(), _exit(),
83
unlinkat() */
77
84
#include <arpa/inet.h> /* inet_pton(), htons() */
78
85
#include <iso646.h> /* not, or, and */
79
86
#include <argp.h> /* struct argp_option, error_t, struct
116
123
gnutls_*
117
124
init_gnutls_session(),
118
125
GNUTLS_* */
126
#if GNUTLS_VERSION_NUMBER < 0x030600
119
127
#include <gnutls/openpgp.h>
120
128
/* gnutls_certificate_set_openpgp_key_file(),
121
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
122
135
123
136
/* GPGME */
124
137
#include <gpgme.h> /* All GPGME types, constants and
132
145
#define PATHDIR "/conf/conf.d/mandos"
133
146
#define SECKEY "seckey.txt"
134
147
#define PUBKEY "pubkey.txt"
148
#define TLS_PRIVKEY "tls-privkey.pem"
149
#define TLS_PUBKEY "tls-pubkey.pem"
135
150
#define HOOKDIR "/lib/mandos/network-hooks.d"
136
151
137
152
bool debug = false;
141
156
static const char sys_class_net[] = "/sys/class/net";
142
157
char *connect_to = NULL;
143
158
const char *hookdir = HOOKDIR;
159
int hookdir_fd = -1;
144
160
uid_t uid = 65534;
145
161
gid_t gid = 65534;
146
162
183
199
perror(print_text);
184
200
}
185
201
186
__attribute__((format (gnu_printf, 2, 3)))
202
__attribute__((format (gnu_printf, 2, 3), nonnull))
187
203
int fprintf_plus(FILE *stream, const char *format, ...){
188
204
va_list ap;
189
205
va_start (ap, format);
198
214
* bytes. "buffer_capacity" is how much is currently allocated,
199
215
* "buffer_length" is how much is already used.
200
216
*/
217
__attribute__((nonnull, warn_unused_result))
201
218
size_t incbuffer(char **buffer, size_t buffer_length,
202
219
size_t buffer_capacity){
203
220
if(buffer_length + BUFFER_SIZE > buffer_capacity){
216
233
}
217
234
218
235
/* Add server to set of servers to retry periodically */
236
__attribute__((nonnull, warn_unused_result))
219
237
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
220
238
int af, server **current_server){
221
239
int ret;
230
248
.af = af };
231
249
if(new_server->ip == NULL){
232
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);
233
266
return false;
234
267
}
235
268
/* Special case of first server */
237
270
new_server->next = new_server;
238
271
new_server->prev = new_server;
239
272
*current_server = new_server;
240
/* Place the new server last in the list */
241
273
} else {
274
/* Place the new server last in the list */
242
275
new_server->next = *current_server;
243
276
new_server->prev = (*current_server)->prev;
244
277
new_server->prev->next = new_server;
245
278
(*current_server)->prev = new_server;
246
279
}
247
ret = clock_gettime(CLOCK_MONOTONIC, &(*current_server)->last_seen);
248
if(ret == -1){
249
perror_plus("clock_gettime");
250
return false;
251
}
252
280
return true;
253
281
}
254
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
255
335
/*
256
336
* Initialize GPGME.
257
337
*/
258
static bool init_gpgme(const char *seckey, const char *pubkey,
259
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){
260
343
gpgme_error_t rc;
261
344
gpgme_engine_info_t engine_info;
262
345
263
346
/*
264
347
* Helper function to insert pub and seckey to the engine keyring.
265
348
*/
266
bool import_key(const char *filename){
349
bool import_key(const char * const filename){
267
350
int ret;
268
351
int fd;
269
352
gpgme_data_t pgp_data;
274
357
return false;
275
358
}
276
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
277
410
rc = gpgme_data_new_from_fd(&pgp_data, fd);
278
411
if(rc != GPG_ERR_NO_ERROR){
279
412
fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
287
420
gpgme_strsource(rc), gpgme_strerror(rc));
288
421
return false;
289
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
}
290
498
291
ret = (int)TEMP_FAILURE_RETRY(close(fd));
499
ret = close(fd);
292
500
if(ret == -1){
293
501
perror_plus("close");
294
502
}
333
541
/* Create new GPGME "context" */
334
542
rc = gpgme_new(&(mc->ctx));
335
543
if(rc != GPG_ERR_NO_ERROR){
336
fprintf_plus(stderr, "Mandos plugin mandos-client: "
337
"bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
338
gpgme_strerror(rc));
544
fprintf_plus(stderr, "bad gpgme_new: %s: %s\n",
545
gpgme_strsource(rc), gpgme_strerror(rc));
339
546
return false;
340
547
}
341
548
350
557
* Decrypt OpenPGP data.
351
558
* Returns -1 on error
352
559
*/
560
__attribute__((nonnull, warn_unused_result))
353
561
static ssize_t pgp_packet_decrypt(const char *cryptotext,
354
562
size_t crypto_size,
355
563
char **plaintext,
376
584
/* Create new empty GPGME data buffer for the plaintext */
377
585
rc = gpgme_data_new(&dh_plain);
378
586
if(rc != GPG_ERR_NO_ERROR){
379
fprintf_plus(stderr, "Mandos plugin mandos-client: "
380
"bad gpgme_data_new: %s: %s\n",
587
fprintf_plus(stderr, "bad gpgme_data_new: %s: %s\n",
381
588
gpgme_strsource(rc), gpgme_strerror(rc));
382
589
gpgme_data_release(dh_crypto);
383
590
return -1;
396
603
if(result == NULL){
397
604
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
398
605
} else {
399
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
400
result->unsupported_algorithm);
401
fprintf_plus(stderr, "Wrong key usage: %u\n",
402
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");
403
612
if(result->file_name != NULL){
404
613
fprintf_plus(stderr, "File name: %s\n", result->file_name);
405
614
}
406
gpgme_recipient_t recipient;
407
recipient = result->recipients;
408
while(recipient != NULL){
615
616
for(gpgme_recipient_t r = result->recipients; r != NULL;
617
r = r->next){
409
618
fprintf_plus(stderr, "Public key algorithm: %s\n",
410
gpgme_pubkey_algo_name
411
(recipient->pubkey_algo));
412
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);
413
621
fprintf_plus(stderr, "Secret key available: %s\n",
414
recipient->status == GPG_ERR_NO_SECKEY
415
? "No" : "Yes");
416
recipient = recipient->next;
622
r->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
417
623
}
418
624
}
419
625
}
475
681
return plaintext_length;
476
682
}
477
683
478
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){
479
693
const char *ret = gnutls_strerror(value);
480
if(ret == NULL)
481
ret = "(unknown)";
482
return ret;
694
return safe_string(ret);
483
695
}
484
696
485
697
/* GnuTLS log function callback */
698
__attribute__((nonnull))
486
699
static void debuggnutls(__attribute__((unused)) int level,
487
700
const char* string){
488
701
fprintf_plus(stderr, "GnuTLS: %s", string);
489
702
}
490
703
704
__attribute__((nonnull(1, 2, 4), warn_unused_result))
491
705
static int init_gnutls_global(const char *pubkeyfilename,
492
706
const char *seckeyfilename,
707
const char *dhparamsfilename,
493
708
mandos_context *mc){
494
709
int ret;
495
710
497
712
fprintf_plus(stderr, "Initializing GnuTLS\n");
498
713
}
499
714
500
ret = gnutls_global_init();
501
if(ret != GNUTLS_E_SUCCESS){
502
fprintf_plus(stderr, "GnuTLS global_init: %s\n",
503
safer_gnutls_strerror(ret));
504
return -1;
505
}
506
507
715
if(debug){
508
716
/* "Use a log level over 10 to enable all debugging options."
509
717
* - GnuTLS manual
517
725
if(ret != GNUTLS_E_SUCCESS){
518
726
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
519
727
safer_gnutls_strerror(ret));
520
gnutls_global_deinit();
521
728
return -1;
522
729
}
523
730
524
731
if(debug){
525
fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
526
" 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",
527
734
pubkeyfilename,
528
735
seckeyfilename);
529
736
}
530
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
531
751
ret = gnutls_certificate_set_openpgp_key_file
532
752
(mc->cred, pubkeyfilename, seckeyfilename,
533
753
GNUTLS_OPENPGP_FMT_BASE64);
754
#else
755
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
756
#endif
534
757
if(ret != GNUTLS_E_SUCCESS){
535
758
fprintf_plus(stderr,
536
"Error[%d] while reading the OpenPGP key pair ('%s',"
759
"Error[%d] while reading the key pair ('%s',"
537
760
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
538
761
fprintf_plus(stderr, "The GnuTLS error is: %s\n",
539
762
safer_gnutls_strerror(ret));
548
771
safer_gnutls_strerror(ret));
549
772
goto globalfail;
550
773
}
551
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
552
if(ret != GNUTLS_E_SUCCESS){
553
fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
554
safer_gnutls_strerror(ret));
555
goto globalfail;
556
}
557
558
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
}
559
956
560
957
return 0;
561
958
562
959
globalfail:
563
960
564
961
gnutls_certificate_free_credentials(mc->cred);
565
gnutls_global_deinit();
566
962
gnutls_dh_params_deinit(mc->dh_params);
567
963
return -1;
568
964
}
569
965
966
__attribute__((nonnull, warn_unused_result))
570
967
static int init_gnutls_session(gnutls_session_t *session,
571
968
mandos_context *mc){
572
969
int ret;
573
970
/* GnuTLS session creation */
574
971
do {
575
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
));
576
980
if(quit_now){
577
981
return -1;
578
982
}
619
1023
/* ignore client certificate if any. */
620
1024
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
621
1025
622
gnutls_dh_set_prime_bits(*session, mc->dh_bits);
623
624
1026
return 0;
625
1027
}
626
1028
628
1030
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
629
1031
__attribute__((unused)) const char *txt){}
630
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
631
1199
/* Called when a Mandos server is found */
1200
__attribute__((nonnull, warn_unused_result))
632
1201
static int start_mandos_communication(const char *ip, in_port_t port,
633
1202
AvahiIfIndex if_index,
634
1203
int af, mandos_context *mc){
635
1204
int ret, tcp_sd = -1;
636
1205
ssize_t sret;
637
union {
638
struct sockaddr_in in;
639
struct sockaddr_in6 in6;
640
} to;
1206
struct sockaddr_storage to;
641
1207
char *buffer = NULL;
642
1208
char *decrypted_buffer = NULL;
643
1209
size_t buffer_length = 0;
646
1212
int retval = -1;
647
1213
gnutls_session_t session;
648
1214
int pf; /* Protocol family */
1215
bool route_added = false;
649
1216
650
1217
errno = 0;
651
1218
673
1240
bool match = false;
674
1241
{
675
1242
char *interface = NULL;
676
while((interface=argz_next(mc->interfaces, mc->interfaces_size,
677
interface))){
1243
while((interface = argz_next(mc->interfaces,
1244
mc->interfaces_size,
1245
interface))){
678
1246
if(if_nametoindex(interface) == (unsigned int)if_index){
679
1247
match = true;
680
1248
break;
709
1277
PRIuMAX "\n", ip, (uintmax_t)port);
710
1278
}
711
1279
712
tcp_sd = socket(pf, SOCK_STREAM, 0);
1280
tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
713
1281
if(tcp_sd < 0){
714
1282
int e = errno;
715
1283
perror_plus("socket");
722
1290
goto mandos_end;
723
1291
}
724
1292
725
memset(&to, 0, sizeof(to));
726
1293
if(af == AF_INET6){
727
to.in6.sin6_family = (sa_family_t)af;
728
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);
729
1297
} else { /* IPv4 */
730
to.in.sin_family = (sa_family_t)af;
731
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);
732
1301
}
733
1302
if(ret < 0 ){
734
1303
int e = errno;
743
1312
goto mandos_end;
744
1313
}
745
1314
if(af == AF_INET6){
746
to.in6.sin6_port = htons(port);
747
#ifdef __GNUC__
748
#pragma GCC diagnostic push
749
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
750
#endif
751
if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
752
(&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower */
753
#ifdef __GNUC__
754
#pragma GCC diagnostic pop
755
#endif
1315
((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
1316
if(IN6_IS_ADDR_LINKLOCAL
1317
(&((struct sockaddr_in6 *)&to)->sin6_addr)){
756
1318
if(if_index == AVAHI_IF_UNSPEC){
757
1319
fprintf_plus(stderr, "An IPv6 link-local address is"
758
1320
" incomplete without a network interface\n");
760
1322
goto mandos_end;
761
1323
}
762
1324
/* Set the network interface number as scope */
763
to.in6.sin6_scope_id = (uint32_t)if_index;
1325
((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
764
1326
}
765
1327
} else {
766
to.in.sin_port = htons(port);
1328
((struct sockaddr_in *)&to)->sin_port = htons(port);
767
1329
}
768
1330
769
1331
if(quit_now){
787
1349
char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
788
1350
INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
789
1351
if(af == AF_INET6){
790
ret = getnameinfo((struct sockaddr *)&(to.in6), sizeof(to.in6),
1352
ret = getnameinfo((struct sockaddr *)&to,
1353
sizeof(struct sockaddr_in6),
791
1354
addrstr, sizeof(addrstr), NULL, 0,
792
1355
NI_NUMERICHOST);
793
1356
} else {
794
ret = getnameinfo((struct sockaddr *)&(to.in), sizeof(to.in),
1357
ret = getnameinfo((struct sockaddr *)&to,
1358
sizeof(struct sockaddr_in),
795
1359
addrstr, sizeof(addrstr), NULL, 0,
796
1360
NI_NUMERICHOST);
797
1361
}
809
1373
goto mandos_end;
810
1374
}
811
1375
812
if(af == AF_INET6){
813
ret = connect(tcp_sd, &to.in6, sizeof(to));
814
} else {
815
ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
816
}
817
if(ret < 0){
818
if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
819
int e = errno;
820
perror_plus("connect");
821
errno = e;
822
}
823
goto mandos_end;
824
}
825
826
if(quit_now){
827
errno = EINTR;
828
goto mandos_end;
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;
829
1431
}
830
1432
831
1433
const char *out = mandos_protocol_version;
985
1587
&decrypted_buffer, mc);
986
1588
if(decrypted_buffer_size >= 0){
987
1589
1590
clearerr(stdout);
988
1591
written = 0;
989
1592
while(written < (size_t) decrypted_buffer_size){
990
1593
if(quit_now){
1006
1609
}
1007
1610
written += (size_t)ret;
1008
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
}
1009
1622
retval = 0;
1010
1623
}
1011
1624
}
1014
1627
1015
1628
mandos_end:
1016
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
}
1017
1636
int e = errno;
1018
1637
free(decrypted_buffer);
1019
1638
free(buffer);
1020
1639
if(tcp_sd >= 0){
1021
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
1640
ret = close(tcp_sd);
1022
1641
}
1023
1642
if(ret == -1){
1024
1643
if(e == 0){
1049
1668
AVAHI_GCC_UNUSED AvahiStringList *txt,
1050
1669
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1051
1670
flags,
1052
void* mc){
1671
void *mc){
1053
1672
if(r == NULL){
1054
1673
return;
1055
1674
}
1058
1677
timed out */
1059
1678
1060
1679
if(quit_now){
1680
avahi_s_service_resolver_free(r);
1061
1681
return;
1062
1682
}
1063
1683
1108
1728
const char *domain,
1109
1729
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1110
1730
flags,
1111
void* mc){
1731
void *mc){
1112
1732
if(b == NULL){
1113
1733
return;
1114
1734
}
1174
1794
errno = old_errno;
1175
1795
}
1176
1796
1797
__attribute__((nonnull, warn_unused_result))
1177
1798
bool get_flags(const char *ifname, struct ifreq *ifr){
1178
1799
int ret;
1179
error_t ret_errno;
1800
int old_errno;
1180
1801
1181
1802
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1182
1803
if(s < 0){
1183
ret_errno = errno;
1804
old_errno = errno;
1184
1805
perror_plus("socket");
1185
errno = ret_errno;
1806
errno = old_errno;
1186
1807
return false;
1187
1808
}
1188
strcpy(ifr->ifr_name, ifname);
1809
strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
1810
ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
1189
1811
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1190
1812
if(ret == -1){
1191
1813
if(debug){
1192
ret_errno = errno;
1814
old_errno = errno;
1193
1815
perror_plus("ioctl SIOCGIFFLAGS");
1194
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;
1195
1822
}
1196
1823
return false;
1197
1824
}
1825
if((close(s) == -1) and debug){
1826
old_errno = errno;
1827
perror_plus("close");
1828
errno = old_errno;
1829
}
1198
1830
return true;
1199
1831
}
1200
1832
1833
__attribute__((nonnull, warn_unused_result))
1201
1834
bool good_flags(const char *ifname, const struct ifreq *ifr){
1202
1835
1203
1836
/* Reject the loopback device */
1245
1878
* corresponds to an acceptable network device.
1246
1879
* (This function is passed to scandir(3) as a filter function.)
1247
1880
*/
1881
__attribute__((nonnull, warn_unused_result))
1248
1882
int good_interface(const struct dirent *if_entry){
1249
1883
if(if_entry->d_name[0] == '.'){
1250
1884
return 0;
1268
1902
/*
1269
1903
* This function determines if a network interface is up.
1270
1904
*/
1905
__attribute__((nonnull, warn_unused_result))
1271
1906
bool interface_is_up(const char *interface){
1272
1907
struct ifreq ifr;
1273
1908
if(not get_flags(interface, &ifr)){
1284
1919
/*
1285
1920
* This function determines if a network interface is running
1286
1921
*/
1922
__attribute__((nonnull, warn_unused_result))
1287
1923
bool interface_is_running(const char *interface){
1288
1924
struct ifreq ifr;
1289
1925
if(not get_flags(interface, &ifr)){
1297
1933
return (bool)(ifr.ifr_flags & IFF_RUNNING);
1298
1934
}
1299
1935
1936
__attribute__((nonnull, pure, warn_unused_result))
1300
1937
int notdotentries(const struct dirent *direntry){
1301
1938
/* Skip "." and ".." */
1302
1939
if(direntry->d_name[0] == '.'
1309
1946
}
1310
1947
1311
1948
/* Is this directory entry a runnable program? */
1949
__attribute__((nonnull, warn_unused_result))
1312
1950
int runnable_hook(const struct dirent *direntry){
1313
1951
int ret;
1314
1952
size_t sret;
1322
1960
sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1323
1961
"abcdefghijklmnopqrstuvwxyz"
1324
1962
"0123456789"
1325
"_-");
1963
"_.-");
1326
1964
if((direntry->d_name)[sret] != '\0'){
1327
1965
/* Contains non-allowed characters */
1328
1966
if(debug){
1332
1970
return 0;
1333
1971
}
1334
1972
1335
char *fullname = NULL;
1336
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1337
if(ret < 0){
1338
perror_plus("asprintf");
1339
return 0;
1340
}
1341
1342
ret = stat(fullname, &st);
1973
ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1343
1974
if(ret == -1){
1344
1975
if(debug){
1345
1976
perror_plus("Could not stat hook");
1369
2000
return 1;
1370
2001
}
1371
2002
2003
__attribute__((nonnull, warn_unused_result))
1372
2004
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
1373
2005
mandos_context *mc){
1374
2006
int ret;
1378
2010
1379
2011
while(true){
1380
2012
if(mc->current_server == NULL){
1381
if (debug){
2013
if(debug){
1382
2014
fprintf_plus(stderr, "Wait until first server is found."
1383
2015
" No timeout!\n");
1384
2016
}
1385
2017
ret = avahi_simple_poll_iterate(s, -1);
1386
2018
} else {
1387
if (debug){
2019
if(debug){
1388
2020
fprintf_plus(stderr, "Check current_server if we should run"
1389
2021
" it, or wait\n");
1390
2022
}
1407
2039
- ((intmax_t)waited_time.tv_sec * 1000))
1408
2040
- ((intmax_t)waited_time.tv_nsec / 1000000));
1409
2041
1410
if (debug){
2042
if(debug){
1411
2043
fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1412
2044
block_time);
1413
2045
}
1435
2067
ret = avahi_simple_poll_iterate(s, (int)block_time);
1436
2068
}
1437
2069
if(ret != 0){
1438
if (ret > 0 or errno != EINTR){
2070
if(ret > 0 or errno != EINTR){
1439
2071
return (ret != 1) ? ret : 0;
1440
2072
}
1441
2073
}
1442
2074
}
1443
2075
}
1444
2076
1445
/* Set effective uid to 0, return errno */
1446
error_t raise_privileges(void){
1447
error_t old_errno = errno;
1448
error_t ret_errno = 0;
1449
if(seteuid(0) == -1){
1450
ret_errno = errno;
1451
perror_plus("seteuid");
1452
}
1453
errno = old_errno;
1454
return ret_errno;
1455
}
1456
1457
/* Set effective and real user ID to 0. Return errno. */
1458
error_t raise_privileges_permanently(void){
1459
error_t old_errno = errno;
1460
error_t ret_errno = raise_privileges();
1461
if(ret_errno != 0){
1462
errno = old_errno;
1463
return ret_errno;
1464
}
1465
if(setuid(0) == -1){
1466
ret_errno = errno;
1467
perror_plus("seteuid");
1468
}
1469
errno = old_errno;
1470
return ret_errno;
1471
}
1472
1473
/* Set effective user ID to unprivileged saved user ID */
1474
error_t lower_privileges(void){
1475
error_t old_errno = errno;
1476
error_t ret_errno = 0;
1477
if(seteuid(uid) == -1){
1478
ret_errno = errno;
1479
perror_plus("seteuid");
1480
}
1481
errno = old_errno;
1482
return ret_errno;
1483
}
1484
1485
/* Lower privileges permanently */
1486
error_t lower_privileges_permanently(void){
1487
error_t old_errno = errno;
1488
error_t ret_errno = 0;
1489
if(setuid(uid) == -1){
1490
ret_errno = errno;
1491
perror_plus("setuid");
1492
}
1493
errno = old_errno;
1494
return ret_errno;
1495
}
1496
1497
bool run_network_hooks(const char *mode, const char *interface,
2077
__attribute__((nonnull))
2078
void run_network_hooks(const char *mode, const char *interface,
1498
2079
const float delay){
1499
struct dirent **direntries;
1500
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1501
alphasort);
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);
1502
2103
if(numhooks == -1){
1503
if(errno == ENOENT){
1504
if(debug){
1505
fprintf_plus(stderr, "Network hook directory \"%s\" not"
1506
" found\n", hookdir);
1507
}
1508
} else {
1509
perror_plus("scandir");
2104
perror_plus("scandir");
2105
close(devnull);
2106
return;
2107
}
2108
struct dirent *direntry;
2109
int ret;
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);
1510
2115
}
1511
} else {
1512
struct dirent *direntry;
1513
int ret;
1514
int devnull = open("/dev/null", O_RDONLY);
1515
for(int i = 0; i < numhooks; i++){
1516
direntry = direntries[i];
1517
char *fullname = NULL;
1518
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1519
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){
1520
2162
perror_plus("asprintf");
1521
continue;
1522
}
1523
if(debug){
1524
fprintf_plus(stderr, "Running network hook \"%s\"\n",
1525
direntry->d_name);
1526
}
1527
pid_t hook_pid = fork();
1528
if(hook_pid == 0){
1529
/* Child */
1530
/* Raise privileges */
1531
raise_privileges_permanently();
1532
/* Set group */
1533
errno = 0;
1534
ret = setgid(0);
1535
if(ret == -1){
1536
perror_plus("setgid");
1537
}
1538
/* Reset supplementary groups */
1539
errno = 0;
1540
ret = setgroups(0, NULL);
1541
if(ret == -1){
1542
perror_plus("setgroups");
1543
}
1544
dup2(devnull, STDIN_FILENO);
1545
close(devnull);
1546
dup2(STDERR_FILENO, STDOUT_FILENO);
1547
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1548
if(ret == -1){
1549
perror_plus("setenv");
1550
_exit(EX_OSERR);
1551
}
1552
ret = setenv("DEVICE", interface, 1);
1553
if(ret == -1){
1554
perror_plus("setenv");
1555
_exit(EX_OSERR);
1556
}
1557
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
1558
if(ret == -1){
1559
perror_plus("setenv");
1560
_exit(EX_OSERR);
1561
}
1562
ret = setenv("MODE", mode, 1);
1563
if(ret == -1){
1564
perror_plus("setenv");
1565
_exit(EX_OSERR);
1566
}
1567
char *delaystring;
1568
ret = asprintf(&delaystring, "%f", delay);
1569
if(ret == -1){
1570
perror_plus("asprintf");
1571
_exit(EX_OSERR);
1572
}
1573
ret = setenv("DELAY", delaystring, 1);
1574
if(ret == -1){
1575
free(delaystring);
1576
perror_plus("setenv");
1577
_exit(EX_OSERR);
1578
}
2163
_exit(EX_OSERR);
2164
}
2165
ret = setenv("DELAY", delaystring, 1);
2166
if(ret == -1){
1579
2167
free(delaystring);
1580
if(connect_to != NULL){
1581
ret = setenv("CONNECT", connect_to, 1);
1582
if(ret == -1){
1583
perror_plus("setenv");
1584
_exit(EX_OSERR);
1585
}
1586
}
1587
if(execl(fullname, direntry->d_name, mode, NULL) == -1){
1588
perror_plus("execl");
1589
_exit(EXIT_FAILURE);
1590
}
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;
1591
2236
} else {
1592
int status;
1593
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1594
perror_plus("waitpid");
1595
free(fullname);
1596
continue;
1597
}
1598
if(WIFEXITED(status)){
1599
if(WEXITSTATUS(status) != 0){
1600
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1601
" with status %d\n", direntry->d_name,
1602
WEXITSTATUS(status));
1603
free(fullname);
1604
continue;
1605
}
1606
} else if(WIFSIGNALED(status)){
1607
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1608
" signal %d\n", direntry->d_name,
1609
WTERMSIG(status));
1610
free(fullname);
1611
continue;
1612
} else {
1613
fprintf_plus(stderr, "Warning: network hook \"%s\""
1614
" crashed\n", direntry->d_name);
1615
free(fullname);
1616
continue;
1617
}
1618
}
1619
free(fullname);
1620
if(debug){
1621
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1622
direntry->d_name);
1623
}
1624
}
1625
close(devnull);
1626
}
1627
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);
1628
2256
}
1629
2257
1630
error_t bring_up_interface(const char *const interface,
1631
const float delay){
1632
int sd = -1;
1633
error_t old_errno = errno;
1634
error_t ret_errno = 0;
1635
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;
1636
2263
struct ifreq network;
1637
2264
unsigned int if_index = if_nametoindex(interface);
1638
2265
if(if_index == 0){
1647
2274
}
1648
2275
1649
2276
if(not interface_is_up(interface)){
1650
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)){
1651
2280
ret_errno = errno;
1652
2281
fprintf_plus(stderr, "Failed to get flags for interface "
1653
2282
"\"%s\"\n", interface);
2283
errno = old_errno;
1654
2284
return ret_errno;
1655
2285
}
1656
network.ifr_flags |= IFF_UP;
2286
network.ifr_flags |= IFF_UP; /* set flag */
1657
2287
1658
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1659
if(sd < 0){
2288
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
2289
if(sd == -1){
1660
2290
ret_errno = errno;
1661
2291
perror_plus("socket");
1662
2292
errno = old_errno;
1663
2293
return ret_errno;
1664
2294
}
1665
2295
1666
2296
if(quit_now){
1667
close(sd);
2297
ret = close(sd);
2298
if(ret == -1){
2299
perror_plus("close");
2300
}
1668
2301
errno = old_errno;
1669
2302
return EINTR;
1670
2303
}
1674
2307
interface);
1675
2308
}
1676
2309
1677
/* Raise priviliges */
1678
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
}
1679
2316
1680
2317
#ifdef __linux__
1681
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1682
messages about the network interface to mess up the prompt */
1683
int ret_linux = klogctl(8, NULL, 5);
1684
bool restore_loglevel = true;
1685
if(ret_linux == -1){
1686
restore_loglevel = false;
1687
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
}
1688
2329
}
1689
2330
#endif /* __linux__ */
1690
ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1691
ret_errno = errno;
2331
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
2332
ioctl_errno = errno;
1692
2333
#ifdef __linux__
1693
2334
if(restore_loglevel){
1694
2335
ret_linux = klogctl(7, NULL, 0);
1698
2339
}
1699
2340
#endif /* __linux__ */
1700
2341
1701
/* Lower privileges */
1702
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
}
1703
2351
1704
2352
/* Close the socket */
1705
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2353
ret = close(sd);
1706
2354
if(ret == -1){
1707
2355
perror_plus("close");
1708
2356
}
1709
2357
1710
2358
if(ret_setflags == -1){
1711
errno = ret_errno;
2359
errno = ioctl_errno;
1712
2360
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1713
2361
errno = old_errno;
1714
return ret_errno;
2362
return ioctl_errno;
1715
2363
}
1716
2364
} else if(debug){
1717
2365
fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
1720
2368
1721
2369
/* Sleep checking until interface is running.
1722
2370
Check every 0.25s, up to total time of delay */
1723
for(int i=0; i < delay * 4; i++){
2371
for(int i = 0; i < delay * 4; i++){
1724
2372
if(interface_is_running(interface)){
1725
2373
break;
1726
2374
}
1735
2383
return 0;
1736
2384
}
1737
2385
1738
error_t take_down_interface(const char *const interface){
1739
error_t old_errno = errno;
2386
__attribute__((nonnull, warn_unused_result))
2387
int take_down_interface(const char *const interface){
2388
int old_errno = errno;
1740
2389
struct ifreq network;
1741
2390
unsigned int if_index = if_nametoindex(interface);
1742
2391
if(if_index == 0){
1745
2394
return ENXIO;
1746
2395
}
1747
2396
if(interface_is_up(interface)){
1748
error_t ret_errno = 0;
2397
int ret_errno = 0;
2398
int ioctl_errno = 0;
1749
2399
if(not get_flags(interface, &network) and debug){
1750
2400
ret_errno = errno;
1751
2401
fprintf_plus(stderr, "Failed to get flags for interface "
1752
2402
"\"%s\"\n", interface);
2403
errno = old_errno;
1753
2404
return ret_errno;
1754
2405
}
1755
2406
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
1756
2407
1757
2408
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1758
if(sd < 0){
2409
if(sd == -1){
1759
2410
ret_errno = errno;
1760
2411
perror_plus("socket");
1761
2412
errno = old_errno;
1767
2418
interface);
1768
2419
}
1769
2420
1770
/* Raise priviliges */
1771
raise_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
}
1772
2427
1773
2428
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1774
ret_errno = errno;
2429
ioctl_errno = errno;
1775
2430
1776
/* Lower privileges */
1777
lower_privileges();
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
}
1778
2440
1779
2441
/* Close the socket */
1780
int ret = (int)TEMP_FAILURE_RETRY(close(sd));
2442
int ret = close(sd);
1781
2443
if(ret == -1){
1782
2444
perror_plus("close");
1783
2445
}
1784
2446
1785
2447
if(ret_setflags == -1){
1786
errno = ret_errno;
2448
errno = ioctl_errno;
1787
2449
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
1788
2450
errno = old_errno;
1789
return ret_errno;
2451
return ioctl_errno;
1790
2452
}
1791
2453
} else if(debug){
1792
2454
fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
1798
2460
}
1799
2461
1800
2462
int main(int argc, char *argv[]){
1801
mandos_context mc = { .server = NULL, .dh_bits = 1024,
1802
.priority = "SECURE256:!CTYPE-X.509:"
1803
"+CTYPE-OPENPGP", .current_server = NULL,
1804
.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 };
1805
2476
AvahiSServiceBrowser *sb = NULL;
1806
2477
error_t ret_errno;
1807
2478
int ret;
1810
2481
int exitcode = EXIT_SUCCESS;
1811
2482
char *interfaces_to_take_down = NULL;
1812
2483
size_t interfaces_to_take_down_size = 0;
1813
char tempdir[] = "/tmp/mandosXXXXXX";
1814
bool tempdir_created = false;
2484
char run_tempdir[] = "/run/tmp/mandosXXXXXX";
2485
char old_tempdir[] = "/tmp/mandosXXXXXX";
2486
char *tempdir = NULL;
1815
2487
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1816
2488
const char *seckey = PATHDIR "/" SECKEY;
1817
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;
1818
2495
char *interfaces_hooks = NULL;
1819
2496
1820
2497
bool gnutls_initialized = false;
1867
2544
{ .name = "pubkey", .key = 'p',
1868
2545
.arg = "FILE",
1869
2546
.doc = "OpenPGP public key file base name",
1870
.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 },
1871
2564
{ .name = "dh-bits", .key = 129,
1872
2565
.arg = "BITS",
1873
2566
.doc = "Bit length of the prime number used in the"
1874
2567
" Diffie-Hellman key exchange",
1875
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 },
1876
2574
{ .name = "priority", .key = 130,
1877
2575
.arg = "STRING",
1878
2576
.doc = "GnuTLS priority string for the TLS handshake",
1924
2622
case 'p': /* --pubkey */
1925
2623
pubkey = arg;
1926
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;
1927
2635
case 129: /* --dh-bits */
1928
2636
errno = 0;
1929
2637
tmpmax = strtoimax(arg, &tmp, 10);
1933
2641
}
1934
2642
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
1935
2643
break;
2644
case 134: /* --dh-params */
2645
dh_params_file = arg;
2646
break;
1936
2647
case 130: /* --priority */
1937
2648
mc.priority = arg;
1938
2649
break;
1978
2689
.args_doc = "",
1979
2690
.doc = "Mandos client -- Get and decrypt"
1980
2691
" passwords from a Mandos server" };
1981
ret = argp_parse(&argp, argc, argv,
1982
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
1983
switch(ret){
2692
ret_errno = argp_parse(&argp, argc, argv,
2693
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2694
switch(ret_errno){
1984
2695
case 0:
1985
2696
break;
1986
2697
case ENOMEM:
1987
2698
default:
1988
errno = ret;
2699
errno = ret_errno;
1989
2700
perror_plus("argp_parse");
1990
2701
exitcode = EX_OSERR;
1991
2702
goto end;
1994
2705
goto end;
1995
2706
}
1996
2707
}
1997
2708
1998
2709
{
1999
2710
/* Work around Debian bug #633582:
2000
<http://bugs.debian.org/633582> */
2711
<https://bugs.debian.org/633582> */
2001
2712
2002
/* Re-raise priviliges */
2003
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 {
2004
2719
struct stat st;
2005
2720
2006
2721
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
2020
2735
}
2021
2736
}
2022
2737
}
2023
TEMP_FAILURE_RETRY(close(seckey_fd));
2738
close(seckey_fd);
2024
2739
}
2025
2740
}
2026
2741
2027
2742
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2028
2743
int pubkey_fd = open(pubkey, O_RDONLY);
2029
2744
if(pubkey_fd == -1){
2041
2756
}
2042
2757
}
2043
2758
}
2044
TEMP_FAILURE_RETRY(close(pubkey_fd));
2045
}
2046
}
2047
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
2048
2785
/* Lower privileges */
2049
lower_privileges();
2786
ret = lower_privileges();
2787
if(ret != 0){
2788
errno = ret;
2789
perror_plus("Failed to lower privileges");
2790
}
2050
2791
}
2051
2792
}
2052
2793
2078
2819
memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
2079
2820
argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
2080
2821
}
2081
if(not run_network_hooks("start", interfaces_hooks != NULL ?
2082
interfaces_hooks : "", delay)){
2083
goto end;
2084
}
2822
run_network_hooks("start", interfaces_hooks != NULL ?
2823
interfaces_hooks : "", delay);
2085
2824
}
2086
2825
2087
2826
if(not debug){
2165
2904
2166
2905
/* If no interfaces were specified, make a list */
2167
2906
if(mc.interfaces == NULL){
2168
struct dirent **direntries;
2907
struct dirent **direntries = NULL;
2169
2908
/* Look for any good interfaces */
2170
2909
ret = scandir(sys_class_net, &direntries, good_interface,
2171
2910
alphasort);
2177
2916
if(ret_errno != 0){
2178
2917
errno = ret_errno;
2179
2918
perror_plus("argz_add");
2919
free(direntries[i]);
2180
2920
continue;
2181
2921
}
2182
2922
if(debug){
2183
2923
fprintf_plus(stderr, "Will use interface \"%s\"\n",
2184
2924
direntries[i]->d_name);
2185
2925
}
2926
free(direntries[i]);
2186
2927
}
2187
2928
free(direntries);
2188
2929
} else {
2189
free(direntries);
2930
if(ret == 0){
2931
free(direntries);
2932
}
2190
2933
fprintf_plus(stderr, "Could not find a network interface\n");
2191
2934
exitcode = EXIT_FAILURE;
2192
2935
goto end;
2215
2958
break;
2216
2959
}
2217
2960
bool interface_was_up = interface_is_up(interface);
2218
ret = bring_up_interface(interface, delay);
2961
errno = bring_up_interface(interface, delay);
2219
2962
if(not interface_was_up){
2220
if(ret != 0){
2221
errno = ret;
2222
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));
2223
2966
} else {
2224
ret_errno = argz_add(&interfaces_to_take_down,
2225
&interfaces_to_take_down_size,
2226
interface);
2227
if(ret_errno != 0){
2228
errno = ret_errno;
2967
errno = argz_add(&interfaces_to_take_down,
2968
&interfaces_to_take_down_size,
2969
interface);
2970
if(errno != 0){
2229
2971
perror_plus("argz_add");
2230
2972
}
2231
2973
}
2249
2991
goto end;
2250
2992
}
2251
2993
2252
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
2253
3001
if(ret == -1){
2254
3002
fprintf_plus(stderr, "init_gnutls_global failed\n");
2255
3003
exitcode = EX_UNAVAILABLE;
2262
3010
goto end;
2263
3011
}
2264
3012
2265
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){
2266
3023
perror_plus("mkdtemp");
2267
3024
goto end;
2268
3025
}
2269
tempdir_created = true;
2270
3026
2271
3027
if(quit_now){
2272
3028
goto end;
2347
3103
sleep((unsigned int)retry_interval);
2348
3104
}
2349
3105
2350
if (not quit_now){
3106
if(not quit_now){
2351
3107
exitcode = EXIT_SUCCESS;
2352
3108
}
2353
3109
2369
3125
2370
3126
/* Allocate a new server */
2371
3127
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
2372
&config, NULL, NULL, &ret_errno);
3128
&config, NULL, NULL, &ret);
2373
3129
2374
3130
/* Free the Avahi configuration data */
2375
3131
avahi_server_config_free(&config);
2378
3134
/* Check if creating the Avahi server object succeeded */
2379
3135
if(mc.server == NULL){
2380
3136
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2381
avahi_strerror(ret_errno));
3137
avahi_strerror(ret));
2382
3138
exitcode = EX_UNAVAILABLE;
2383
3139
goto end;
2384
3140
}
2408
3164
if(debug){
2409
3165
fprintf_plus(stderr, "Starting Avahi loop search\n");
2410
3166
}
2411
3167
2412
3168
ret = avahi_loop_with_timeout(simple_poll,
2413
3169
(int)(retry_interval * 1000), &mc);
2414
3170
if(debug){
2419
3175
end:
2420
3176
2421
3177
if(debug){
2422
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
}
2423
3185
}
2424
3186
2425
3187
/* Cleanup things */
2436
3198
2437
3199
if(gnutls_initialized){
2438
3200
gnutls_certificate_free_credentials(mc.cred);
2439
gnutls_global_deinit();
2440
3201
gnutls_dh_params_deinit(mc.dh_params);
2441
3202
}
2442
3203
2450
3211
mc.current_server->prev->next = NULL;
2451
3212
while(mc.current_server != NULL){
2452
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
2453
3222
free(mc.current_server);
2454
3223
mc.current_server = next;
2455
3224
}
2456
3225
}
2457
3226
2458
/* Re-raise priviliges */
3227
/* Re-raise privileges */
2459
3228
{
2460
raise_privileges();
2461
2462
/* Run network hooks */
2463
run_network_hooks("stop", interfaces_hooks != NULL ?
2464
interfaces_hooks : "", delay);
2465
2466
/* Take down the network interfaces which were brought up */
2467
{
2468
char *interface = NULL;
2469
while((interface=argz_next(interfaces_to_take_down,
2470
interfaces_to_take_down_size,
2471
interface))){
2472
ret_errno = take_down_interface(interface);
2473
if(ret_errno != 0){
2474
errno = ret_errno;
2475
perror_plus("Failed to take down interface");
2476
}
2477
}
2478
if(debug and (interfaces_to_take_down == NULL)){
2479
fprintf_plus(stderr, "No interfaces needed to be taken"
2480
" down\n");
2481
}
2482
}
2483
2484
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
}
2485
3263
}
2486
3264
2487
3265
free(interfaces_to_take_down);
2488
3266
free(interfaces_hooks);
2489
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
2490
3322
/* Removes the GPGME temp directory and all files inside */
2491
if(tempdir_created){
2492
struct dirent **direntries = NULL;
2493
struct dirent *direntry = NULL;
2494
int numentries = scandir(tempdir, &direntries, notdotentries,
2495
alphasort);
2496
if (numentries > 0){
2497
for(int i = 0; i < numentries; i++){
2498
direntry = direntries[i];
2499
char *fullname = NULL;
2500
ret = asprintf(&fullname, "%s/%s", tempdir,
2501
direntry->d_name);
2502
if(ret < 0){
2503
perror_plus("asprintf");
2504
continue;
2505
}
2506
ret = remove(fullname);
2507
if(ret == -1){
2508
fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2509
strerror(errno));
2510
}
2511
free(fullname);
2512
}
2513
}
2514
2515
/* need to clean even if 0 because man page doesn't specify */
2516
free(direntries);
2517
if (numentries == -1){
2518
perror_plus("scandir");
2519
}
2520
ret = rmdir(tempdir);
2521
if(ret == -1 and errno != ENOENT){
2522
perror_plus("rmdir");
2523
}
3323
if(tempdir != NULL){
3324
clean_dir_at(-1, tempdir, 0);
2524
3325
}
2525
3326
2526
3327
if(quit_now){
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0