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:
- .bzr-builddeb
- debian
- debian/po
- debian/source
- debian/upstream
- network-hooks.d
- plugin-helpers
- files removed:
- etc-plugins.d-README
- files modified:
- .bzrignore
added
removed
plugins.d/mandos-client.c
1
1
/* -*- coding: utf-8 -*- */
2
2
/*
3
* Mandos client - get and decrypt data from a Mandos server
3
* Mandos-client - get and decrypt data from a Mandos server
4
4
*
5
5
* This program is partly derived from an example program for an Avahi
6
6
* service browser, downloaded from
9
9
* "browse_callback", and parts of "main".
10
10
*
11
11
* Everything else is
12
* Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
13
*
14
* This program is free software: you can redistribute it and/or
15
* modify it under the terms of the GNU General Public License as
16
* published by the Free Software Foundation, either version 3 of the
17
* License, or (at your option) any later version.
18
*
19
* 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
20
23
* WITHOUT ANY WARRANTY; without even the implied warranty of
21
24
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22
25
* General Public License for more details.
23
26
*
24
27
* You should have received a copy of the GNU General Public License
25
* along with this program. If not, see
26
* <http://www.gnu.org/licenses/>.
28
* along with Mandos. If not, see <http://www.gnu.org/licenses/>.
27
29
*
28
* Contact the authors at <mandos@fukt.bsnet.se>.
30
* Contact the authors at <mandos@recompile.se>.
29
31
*/
30
32
31
33
/* Needed by GPGME, specifically gpgme_data_seek() */
34
#ifndef _LARGEFILE_SOURCE
32
35
#define _LARGEFILE_SOURCE
36
#endif /* not _LARGEFILE_SOURCE */
37
#ifndef _FILE_OFFSET_BITS
33
38
#define _FILE_OFFSET_BITS 64
39
#endif /* not _FILE_OFFSET_BITS */
34
40
35
41
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
36
42
37
43
#include <stdio.h> /* fprintf(), stderr, fwrite(),
38
44
stdout, ferror() */
39
#include <stdint.h> /* uint16_t, uint32_t */
45
#include <stdint.h> /* uint16_t, uint32_t, intptr_t */
40
46
#include <stddef.h> /* NULL, size_t, ssize_t */
41
#include <stdlib.h> /* free(), EXIT_SUCCESS, EXIT_FAILURE,
42
srand() */
43
#include <stdbool.h> /* bool, true */
44
#include <string.h> /* memset(), strcmp(), strlen(),
45
strerror(), asprintf(), strcpy() */
46
#include <sys/ioctl.h> /* ioctl */
47
#include <stdlib.h> /* free(), EXIT_SUCCESS, srand(),
48
strtof(), abort() */
49
#include <stdbool.h> /* bool, false, true */
50
#include <string.h> /* strcmp(), strlen(), strerror(),
51
asprintf(), strncpy(), strsignal()
52
*/
53
#include <sys/ioctl.h> /* ioctl */
47
54
#include <sys/types.h> /* socket(), inet_pton(), sockaddr,
48
55
sockaddr_in6, PF_INET6,
49
SOCK_STREAM, INET6_ADDRSTRLEN,
50
uid_t, gid_t, open(), opendir(), DIR */
51
#include <sys/stat.h> /* open() */
56
SOCK_STREAM, uid_t, gid_t, open(),
57
opendir(), DIR */
58
#include <sys/stat.h> /* open(), S_ISREG */
52
59
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
53
struct in6_addr, inet_pton(),
54
connect() */
55
#include <fcntl.h> /* open() */
56
#include <dirent.h> /* opendir(), struct dirent, readdir() */
57
#include <inttypes.h> /* PRIu16 */
58
#include <assert.h> /* assert() */
59
#include <errno.h> /* perror(), errno */
60
#include <time.h> /* time() */
60
inet_pton(), connect(),
61
getnameinfo() */
62
#include <fcntl.h> /* open(), unlinkat(), AT_REMOVEDIR */
63
#include <dirent.h> /* opendir(), struct dirent, readdir()
64
*/
65
#include <inttypes.h> /* PRIu16, PRIdMAX, intmax_t,
66
strtoimax() */
67
#include <errno.h> /* perror(), errno, EINTR, EINVAL,
68
EAI_SYSTEM, ENETUNREACH,
69
EHOSTUNREACH, ECONNREFUSED, EPROTO,
70
EIO, ENOENT, ENXIO, ENOMEM, EISDIR,
71
ENOTEMPTY,
72
program_invocation_short_name */
73
#include <time.h> /* nanosleep(), time(), sleep() */
61
74
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
62
75
SIOCSIFFLAGS, if_indextoname(),
63
76
if_nametoindex(), IF_NAMESIZE */
64
#include <netinet/in.h>
77
#include <netinet/in.h> /* IN6_IS_ADDR_LINKLOCAL,
78
INET_ADDRSTRLEN, INET6_ADDRSTRLEN
79
*/
65
80
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
66
getuid(), getgid(), setuid(),
67
setgid() */
68
#include <arpa/inet.h> /* inet_pton(), htons */
69
#include <iso646.h> /* not, and */
81
getuid(), getgid(), seteuid(),
82
setgid(), pause(), _exit(),
83
unlinkat() */
84
#include <arpa/inet.h> /* inet_pton(), htons() */
85
#include <iso646.h> /* not, or, and */
70
86
#include <argp.h> /* struct argp_option, error_t, struct
71
87
argp_state, struct argp,
72
88
argp_parse(), ARGP_KEY_ARG,
73
89
ARGP_KEY_END, ARGP_ERR_UNKNOWN */
90
#include <signal.h> /* sigemptyset(), sigaddset(),
91
sigaction(), SIGTERM, sig_atomic_t,
92
raise() */
93
#include <sysexits.h> /* EX_OSERR, EX_USAGE, EX_UNAVAILABLE,
94
EX_NOHOST, EX_IOERR, EX_PROTOCOL */
95
#include <sys/wait.h> /* waitpid(), WIFEXITED(),
96
WEXITSTATUS(), WTERMSIG() */
97
#include <grp.h> /* setgroups() */
98
#include <argz.h> /* argz_add_sep(), argz_next(),
99
argz_delete(), argz_append(),
100
argz_stringify(), argz_add(),
101
argz_count() */
102
#include <netdb.h> /* getnameinfo(), NI_NUMERICHOST,
103
EAI_SYSTEM, gai_strerror() */
104
105
#ifdef __linux__
106
#include <sys/klog.h> /* klogctl() */
107
#endif /* __linux__ */
74
108
75
109
/* Avahi */
76
110
/* All Avahi types, constants and functions
89
123
gnutls_*
90
124
init_gnutls_session(),
91
125
GNUTLS_* */
92
#include <gnutls/openpgp.h> /* gnutls_certificate_set_openpgp_key_file(),
93
GNUTLS_OPENPGP_FMT_BASE64 */
126
#if GNUTLS_VERSION_NUMBER < 0x030600
127
#include <gnutls/openpgp.h>
128
/* gnutls_certificate_set_openpgp_key_file(),
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
94
135
95
136
/* GPGME */
96
137
#include <gpgme.h> /* All GPGME types, constants and
101
142
102
143
#define BUFFER_SIZE 256
103
144
104
/*
105
#define PATHDIR "/conf/conf.d/mandos"
106
*/
107
108
145
#define PATHDIR "/conf/conf.d/mandos"
109
146
#define SECKEY "seckey.txt"
110
147
#define PUBKEY "pubkey.txt"
148
#define TLS_PRIVKEY "tls-privkey.pem"
149
#define TLS_PUBKEY "tls-pubkey.pem"
150
#define HOOKDIR "/lib/mandos/network-hooks.d"
111
151
112
152
bool debug = false;
113
153
static const char mandos_protocol_version[] = "1";
114
const char *argp_program_version = "mandos-client 1.0";
115
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
154
const char *argp_program_version = "mandos-client " VERSION;
155
const char *argp_program_bug_address = "<mandos@recompile.se>";
156
static const char sys_class_net[] = "/sys/class/net";
157
char *connect_to = NULL;
158
const char *hookdir = HOOKDIR;
159
int hookdir_fd = -1;
160
uid_t uid = 65534;
161
gid_t gid = 65534;
162
163
/* Doubly linked list that need to be circularly linked when used */
164
typedef struct server{
165
const char *ip;
166
in_port_t port;
167
AvahiIfIndex if_index;
168
int af;
169
struct timespec last_seen;
170
struct server *next;
171
struct server *prev;
172
} server;
116
173
117
174
/* Used for passing in values through the Avahi callback functions */
118
175
typedef struct {
119
AvahiSimplePoll *simple_poll;
120
176
AvahiServer *server;
121
177
gnutls_certificate_credentials_t cred;
122
178
unsigned int dh_bits;
123
179
gnutls_dh_params_t dh_params;
124
180
const char *priority;
125
181
gpgme_ctx_t ctx;
182
server *current_server;
183
char *interfaces;
184
size_t interfaces_size;
126
185
} mandos_context;
127
186
187
/* global so signal handler can reach it*/
188
AvahiSimplePoll *simple_poll;
189
190
sig_atomic_t quit_now = 0;
191
int signal_received = 0;
192
193
/* Function to use when printing errors */
194
void perror_plus(const char *print_text){
195
int e = errno;
196
fprintf(stderr, "Mandos plugin %s: ",
197
program_invocation_short_name);
198
errno = e;
199
perror(print_text);
200
}
201
202
__attribute__((format (gnu_printf, 2, 3), nonnull))
203
int fprintf_plus(FILE *stream, const char *format, ...){
204
va_list ap;
205
va_start (ap, format);
206
207
TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
208
program_invocation_short_name));
209
return (int)TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
210
}
211
128
212
/*
129
* Make room in "buffer" for at least BUFFER_SIZE additional bytes.
130
* "buffer_capacity" is how much is currently allocated,
213
* Make additional room in "buffer" for at least BUFFER_SIZE more
214
* bytes. "buffer_capacity" is how much is currently allocated,
131
215
* "buffer_length" is how much is already used.
132
216
*/
133
size_t adjustbuffer(char **buffer, size_t buffer_length,
134
size_t buffer_capacity){
135
if (buffer_length + BUFFER_SIZE > buffer_capacity){
136
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
137
if (buffer == NULL){
217
__attribute__((nonnull, warn_unused_result))
218
size_t incbuffer(char **buffer, size_t buffer_length,
219
size_t buffer_capacity){
220
if(buffer_length + BUFFER_SIZE > buffer_capacity){
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;
138
227
return 0;
139
228
}
229
*buffer = new_buf;
140
230
buffer_capacity += BUFFER_SIZE;
141
231
}
142
232
return buffer_capacity;
143
233
}
144
234
235
/* Add server to set of servers to retry periodically */
236
__attribute__((nonnull, warn_unused_result))
237
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
238
int af, server **current_server){
239
int ret;
240
server *new_server = malloc(sizeof(server));
241
if(new_server == NULL){
242
perror_plus("malloc");
243
return false;
244
}
245
*new_server = (server){ .ip = strdup(ip),
246
.port = port,
247
.if_index = if_index,
248
.af = af };
249
if(new_server->ip == NULL){
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);
266
return false;
267
}
268
/* Special case of first server */
269
if(*current_server == NULL){
270
new_server->next = new_server;
271
new_server->prev = new_server;
272
*current_server = new_server;
273
} else {
274
/* Place the new server last in the list */
275
new_server->next = *current_server;
276
new_server->prev = (*current_server)->prev;
277
new_server->prev->next = new_server;
278
(*current_server)->prev = new_server;
279
}
280
return true;
281
}
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
145
335
/*
146
336
* Initialize GPGME.
147
337
*/
148
static bool init_gpgme(mandos_context *mc, const char *seckey,
149
const char *pubkey, const char *tempdir){
150
int ret;
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){
151
343
gpgme_error_t rc;
152
344
gpgme_engine_info_t engine_info;
153
345
154
155
346
/*
156
* Helper function to insert pub and seckey to the enigne keyring.
347
* Helper function to insert pub and seckey to the engine keyring.
157
348
*/
158
bool import_key(const char *filename){
349
bool import_key(const char * const filename){
350
int ret;
159
351
int fd;
160
352
gpgme_data_t pgp_data;
161
353
162
fd = TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
354
fd = (int)TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
163
355
if(fd == -1){
164
perror("open");
356
perror_plus("open");
165
357
return false;
166
358
}
167
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
168
410
rc = gpgme_data_new_from_fd(&pgp_data, fd);
169
if (rc != GPG_ERR_NO_ERROR){
170
fprintf(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
171
gpgme_strsource(rc), gpgme_strerror(rc));
411
if(rc != GPG_ERR_NO_ERROR){
412
fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
413
gpgme_strsource(rc), gpgme_strerror(rc));
172
414
return false;
173
415
}
174
416
175
417
rc = gpgme_op_import(mc->ctx, pgp_data);
176
if (rc != GPG_ERR_NO_ERROR){
177
fprintf(stderr, "bad gpgme_op_import: %s: %s\n",
178
gpgme_strsource(rc), gpgme_strerror(rc));
418
if(rc != GPG_ERR_NO_ERROR){
419
fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
420
gpgme_strsource(rc), gpgme_strerror(rc));
179
421
return false;
180
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
}
181
498
182
ret = TEMP_FAILURE_RETRY(close(fd));
499
ret = close(fd);
183
500
if(ret == -1){
184
perror("close");
501
perror_plus("close");
185
502
}
186
503
gpgme_data_release(pgp_data);
187
504
return true;
188
505
}
189
506
190
if (debug){
191
fprintf(stderr, "Initialize gpgme\n");
507
if(debug){
508
fprintf_plus(stderr, "Initializing GPGME\n");
192
509
}
193
510
194
511
/* Init GPGME */
195
512
gpgme_check_version(NULL);
196
513
rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
197
if (rc != GPG_ERR_NO_ERROR){
198
fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
199
gpgme_strsource(rc), gpgme_strerror(rc));
514
if(rc != GPG_ERR_NO_ERROR){
515
fprintf_plus(stderr, "bad gpgme_engine_check_version: %s: %s\n",
516
gpgme_strsource(rc), gpgme_strerror(rc));
200
517
return false;
201
518
}
202
519
203
/* Set GPGME home directory for the OpenPGP engine only */
204
rc = gpgme_get_engine_info (&engine_info);
205
if (rc != GPG_ERR_NO_ERROR){
206
fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
207
gpgme_strsource(rc), gpgme_strerror(rc));
520
/* Set GPGME home directory for the OpenPGP engine only */
521
rc = gpgme_get_engine_info(&engine_info);
522
if(rc != GPG_ERR_NO_ERROR){
523
fprintf_plus(stderr, "bad gpgme_get_engine_info: %s: %s\n",
524
gpgme_strsource(rc), gpgme_strerror(rc));
208
525
return false;
209
526
}
210
527
while(engine_info != NULL){
216
533
engine_info = engine_info->next;
217
534
}
218
535
if(engine_info == NULL){
219
fprintf(stderr, "Could not set GPGME home dir to %s\n", tempdir);
536
fprintf_plus(stderr, "Could not set GPGME home dir to %s\n",
537
tempdir);
220
538
return false;
221
539
}
222
540
223
541
/* Create new GPGME "context" */
224
542
rc = gpgme_new(&(mc->ctx));
225
if (rc != GPG_ERR_NO_ERROR){
226
fprintf(stderr, "bad gpgme_new: %s: %s\n",
227
gpgme_strsource(rc), gpgme_strerror(rc));
228
return false;
229
}
230
231
if (not import_key(pubkey) or not import_key(seckey)){
232
return false;
233
}
234
235
return true;
543
if(rc != GPG_ERR_NO_ERROR){
544
fprintf_plus(stderr, "bad gpgme_new: %s: %s\n",
545
gpgme_strsource(rc), gpgme_strerror(rc));
546
return false;
547
}
548
549
if(not import_key(pubkey) or not import_key(seckey)){
550
return false;
551
}
552
553
return true;
236
554
}
237
555
238
556
/*
239
557
* Decrypt OpenPGP data.
240
558
* Returns -1 on error
241
559
*/
242
static ssize_t pgp_packet_decrypt (const mandos_context *mc,
243
const char *cryptotext,
244
size_t crypto_size,
245
char **plaintext){
560
__attribute__((nonnull, warn_unused_result))
561
static ssize_t pgp_packet_decrypt(const char *cryptotext,
562
size_t crypto_size,
563
char **plaintext,
564
mandos_context *mc){
246
565
gpgme_data_t dh_crypto, dh_plain;
247
566
gpgme_error_t rc;
248
567
ssize_t ret;
249
568
size_t plaintext_capacity = 0;
250
569
ssize_t plaintext_length = 0;
251
570
252
if (debug){
253
fprintf(stderr, "Trying to decrypt OpenPGP data\n");
571
if(debug){
572
fprintf_plus(stderr, "Trying to decrypt OpenPGP data\n");
254
573
}
255
574
256
575
/* Create new GPGME data buffer from memory cryptotext */
257
576
rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
258
577
0);
259
if (rc != GPG_ERR_NO_ERROR){
260
fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
261
gpgme_strsource(rc), gpgme_strerror(rc));
578
if(rc != GPG_ERR_NO_ERROR){
579
fprintf_plus(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
580
gpgme_strsource(rc), gpgme_strerror(rc));
262
581
return -1;
263
582
}
264
583
265
584
/* Create new empty GPGME data buffer for the plaintext */
266
585
rc = gpgme_data_new(&dh_plain);
267
if (rc != GPG_ERR_NO_ERROR){
268
fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
269
gpgme_strsource(rc), gpgme_strerror(rc));
586
if(rc != GPG_ERR_NO_ERROR){
587
fprintf_plus(stderr, "bad gpgme_data_new: %s: %s\n",
588
gpgme_strsource(rc), gpgme_strerror(rc));
270
589
gpgme_data_release(dh_crypto);
271
590
return -1;
272
591
}
274
593
/* Decrypt data from the cryptotext data buffer to the plaintext
275
594
data buffer */
276
595
rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
277
if (rc != GPG_ERR_NO_ERROR){
278
fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
279
gpgme_strsource(rc), gpgme_strerror(rc));
596
if(rc != GPG_ERR_NO_ERROR){
597
fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
598
gpgme_strsource(rc), gpgme_strerror(rc));
280
599
plaintext_length = -1;
281
if (debug){
600
if(debug){
282
601
gpgme_decrypt_result_t result;
283
602
result = gpgme_op_decrypt_result(mc->ctx);
284
if (result == NULL){
285
fprintf(stderr, "gpgme_op_decrypt_result failed\n");
603
if(result == NULL){
604
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
286
605
} else {
287
fprintf(stderr, "Unsupported algorithm: %s\n",
288
result->unsupported_algorithm);
289
fprintf(stderr, "Wrong key usage: %u\n",
290
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");
291
612
if(result->file_name != NULL){
292
fprintf(stderr, "File name: %s\n", result->file_name);
613
fprintf_plus(stderr, "File name: %s\n", result->file_name);
293
614
}
294
gpgme_recipient_t recipient;
295
recipient = result->recipients;
296
if(recipient){
297
while(recipient != NULL){
298
fprintf(stderr, "Public key algorithm: %s\n",
299
gpgme_pubkey_algo_name(recipient->pubkey_algo));
300
fprintf(stderr, "Key ID: %s\n", recipient->keyid);
301
fprintf(stderr, "Secret key available: %s\n",
302
recipient->status == GPG_ERR_NO_SECKEY
303
? "No" : "Yes");
304
recipient = recipient->next;
305
}
615
616
for(gpgme_recipient_t r = result->recipients; r != NULL;
617
r = r->next){
618
fprintf_plus(stderr, "Public key algorithm: %s\n",
619
gpgme_pubkey_algo_name(r->pubkey_algo));
620
fprintf_plus(stderr, "Key ID: %s\n", r->keyid);
621
fprintf_plus(stderr, "Secret key available: %s\n",
622
r->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
306
623
}
307
624
}
308
625
}
310
627
}
311
628
312
629
if(debug){
313
fprintf(stderr, "Decryption of OpenPGP data succeeded\n");
630
fprintf_plus(stderr, "Decryption of OpenPGP data succeeded\n");
314
631
}
315
632
316
633
/* Seek back to the beginning of the GPGME plaintext data buffer */
317
if (gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET) == -1){
318
perror("pgpme_data_seek");
634
if(gpgme_data_seek(dh_plain, (off_t)0, SEEK_SET) == -1){
635
perror_plus("gpgme_data_seek");
319
636
plaintext_length = -1;
320
637
goto decrypt_end;
321
638
}
322
639
323
640
*plaintext = NULL;
324
641
while(true){
325
plaintext_capacity = adjustbuffer(plaintext,
326
(size_t)plaintext_length,
327
plaintext_capacity);
328
if (plaintext_capacity == 0){
329
perror("adjustbuffer");
330
plaintext_length = -1;
331
goto decrypt_end;
642
plaintext_capacity = incbuffer(plaintext,
643
(size_t)plaintext_length,
644
plaintext_capacity);
645
if(plaintext_capacity == 0){
646
perror_plus("incbuffer");
647
plaintext_length = -1;
648
goto decrypt_end;
332
649
}
333
650
334
651
ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
335
652
BUFFER_SIZE);
336
653
/* Print the data, if any */
337
if (ret == 0){
654
if(ret == 0){
338
655
/* EOF */
339
656
break;
340
657
}
341
658
if(ret < 0){
342
perror("gpgme_data_read");
659
perror_plus("gpgme_data_read");
343
660
plaintext_length = -1;
344
661
goto decrypt_end;
345
662
}
347
664
}
348
665
349
666
if(debug){
350
fprintf(stderr, "Decrypted password is: ");
667
fprintf_plus(stderr, "Decrypted password is: ");
351
668
for(ssize_t i = 0; i < plaintext_length; i++){
352
669
fprintf(stderr, "%02hhX ", (*plaintext)[i]);
353
670
}
364
681
return plaintext_length;
365
682
}
366
683
367
static const char * safer_gnutls_strerror (int value) {
368
const char *ret = gnutls_strerror (value); /* Spurious warning */
369
if (ret == NULL)
370
ret = "(unknown)";
371
return ret;
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){
693
const char *ret = gnutls_strerror(value);
694
return safe_string(ret);
372
695
}
373
696
374
697
/* GnuTLS log function callback */
698
__attribute__((nonnull))
375
699
static void debuggnutls(__attribute__((unused)) int level,
376
700
const char* string){
377
fprintf(stderr, "GnuTLS: %s", string);
701
fprintf_plus(stderr, "GnuTLS: %s", string);
378
702
}
379
703
380
static int init_gnutls_global(mandos_context *mc,
381
const char *pubkeyfilename,
382
const char *seckeyfilename){
704
__attribute__((nonnull(1, 2, 4), warn_unused_result))
705
static int init_gnutls_global(const char *pubkeyfilename,
706
const char *seckeyfilename,
707
const char *dhparamsfilename,
708
mandos_context *mc){
383
709
int ret;
384
710
385
711
if(debug){
386
fprintf(stderr, "Initializing GnuTLS\n");
387
}
388
389
ret = gnutls_global_init();
390
if (ret != GNUTLS_E_SUCCESS) {
391
fprintf (stderr, "GnuTLS global_init: %s\n",
392
safer_gnutls_strerror(ret));
393
return -1;
394
}
395
396
if (debug){
712
fprintf_plus(stderr, "Initializing GnuTLS\n");
713
}
714
715
if(debug){
397
716
/* "Use a log level over 10 to enable all debugging options."
398
717
* - GnuTLS manual
399
718
*/
402
721
}
403
722
404
723
/* OpenPGP credentials */
405
gnutls_certificate_allocate_credentials(&mc->cred);
406
if (ret != GNUTLS_E_SUCCESS){
407
fprintf (stderr, "GnuTLS memory error: %s\n", /* Spurious
408
warning */
409
safer_gnutls_strerror(ret));
410
gnutls_global_deinit ();
724
ret = gnutls_certificate_allocate_credentials(&mc->cred);
725
if(ret != GNUTLS_E_SUCCESS){
726
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
727
safer_gnutls_strerror(ret));
411
728
return -1;
412
729
}
413
730
414
731
if(debug){
415
fprintf(stderr, "Attempting to use OpenPGP public key %s and"
416
" secret key %s as GnuTLS credentials\n", pubkeyfilename,
417
seckeyfilename);
732
fprintf_plus(stderr, "Attempting to use public key %s and"
733
" private key %s as GnuTLS credentials\n",
734
pubkeyfilename,
735
seckeyfilename);
418
736
}
419
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
420
751
ret = gnutls_certificate_set_openpgp_key_file
421
752
(mc->cred, pubkeyfilename, seckeyfilename,
422
753
GNUTLS_OPENPGP_FMT_BASE64);
423
if (ret != GNUTLS_E_SUCCESS) {
424
fprintf(stderr,
425
"Error[%d] while reading the OpenPGP key pair ('%s',"
426
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
427
fprintf(stderr, "The GnuTLS error is: %s\n",
428
safer_gnutls_strerror(ret));
754
#else
755
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
756
#endif
757
if(ret != GNUTLS_E_SUCCESS){
758
fprintf_plus(stderr,
759
"Error[%d] while reading the key pair ('%s',"
760
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
761
fprintf_plus(stderr, "The GnuTLS error is: %s\n",
762
safer_gnutls_strerror(ret));
429
763
goto globalfail;
430
764
}
431
765
432
766
/* GnuTLS server initialization */
433
767
ret = gnutls_dh_params_init(&mc->dh_params);
434
if (ret != GNUTLS_E_SUCCESS) {
435
fprintf (stderr, "Error in GnuTLS DH parameter initialization:"
436
" %s\n", safer_gnutls_strerror(ret));
437
goto globalfail;
438
}
439
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
440
if (ret != GNUTLS_E_SUCCESS) {
441
fprintf (stderr, "Error in GnuTLS prime generation: %s\n",
442
safer_gnutls_strerror(ret));
443
goto globalfail;
444
}
445
446
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
768
if(ret != GNUTLS_E_SUCCESS){
769
fprintf_plus(stderr, "Error in GnuTLS DH parameter"
770
" initialization: %s\n",
771
safer_gnutls_strerror(ret));
772
goto globalfail;
773
}
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
}
447
956
448
957
return 0;
449
958
450
959
globalfail:
451
960
452
961
gnutls_certificate_free_credentials(mc->cred);
453
gnutls_global_deinit();
962
gnutls_dh_params_deinit(mc->dh_params);
454
963
return -1;
455
964
}
456
965
457
static int init_gnutls_session(mandos_context *mc,
458
gnutls_session_t *session){
966
__attribute__((nonnull, warn_unused_result))
967
static int init_gnutls_session(gnutls_session_t *session,
968
mandos_context *mc){
459
969
int ret;
460
970
/* GnuTLS session creation */
461
ret = gnutls_init(session, GNUTLS_SERVER);
462
if (ret != GNUTLS_E_SUCCESS){
463
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
464
safer_gnutls_strerror(ret));
971
do {
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
));
980
if(quit_now){
981
return -1;
982
}
983
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
984
if(ret != GNUTLS_E_SUCCESS){
985
fprintf_plus(stderr,
986
"Error in GnuTLS session initialization: %s\n",
987
safer_gnutls_strerror(ret));
465
988
}
466
989
467
990
{
468
991
const char *err;
469
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
470
if (ret != GNUTLS_E_SUCCESS) {
471
fprintf(stderr, "Syntax error at: %s\n", err);
472
fprintf(stderr, "GnuTLS error: %s\n",
473
safer_gnutls_strerror(ret));
474
gnutls_deinit (*session);
992
do {
993
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
994
if(quit_now){
995
gnutls_deinit(*session);
996
return -1;
997
}
998
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
999
if(ret != GNUTLS_E_SUCCESS){
1000
fprintf_plus(stderr, "Syntax error at: %s\n", err);
1001
fprintf_plus(stderr, "GnuTLS error: %s\n",
1002
safer_gnutls_strerror(ret));
1003
gnutls_deinit(*session);
475
1004
return -1;
476
1005
}
477
1006
}
478
1007
479
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
480
mc->cred);
481
if (ret != GNUTLS_E_SUCCESS) {
482
fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
483
safer_gnutls_strerror(ret));
484
gnutls_deinit (*session);
1008
do {
1009
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
1010
mc->cred);
1011
if(quit_now){
1012
gnutls_deinit(*session);
1013
return -1;
1014
}
1015
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
1016
if(ret != GNUTLS_E_SUCCESS){
1017
fprintf_plus(stderr, "Error setting GnuTLS credentials: %s\n",
1018
safer_gnutls_strerror(ret));
1019
gnutls_deinit(*session);
485
1020
return -1;
486
1021
}
487
1022
488
1023
/* ignore client certificate if any. */
489
gnutls_certificate_server_set_request (*session,
490
GNUTLS_CERT_IGNORE);
491
492
gnutls_dh_set_prime_bits (*session, mc->dh_bits);
1024
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
493
1025
494
1026
return 0;
495
1027
}
498
1030
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
499
1031
__attribute__((unused)) const char *txt){}
500
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
501
1199
/* Called when a Mandos server is found */
502
static int start_mandos_communication(const char *ip, uint16_t port,
1200
__attribute__((nonnull, warn_unused_result))
1201
static int start_mandos_communication(const char *ip, in_port_t port,
503
1202
AvahiIfIndex if_index,
504
mandos_context *mc){
505
int ret, tcp_sd;
506
union { struct sockaddr in; struct sockaddr_in6 in6; } to;
1203
int af, mandos_context *mc){
1204
int ret, tcp_sd = -1;
1205
ssize_t sret;
1206
struct sockaddr_storage to;
507
1207
char *buffer = NULL;
508
char *decrypted_buffer;
1208
char *decrypted_buffer = NULL;
509
1209
size_t buffer_length = 0;
510
1210
size_t buffer_capacity = 0;
511
ssize_t decrypted_buffer_size;
512
1211
size_t written;
513
int retval = 0;
514
char interface[IF_NAMESIZE];
1212
int retval = -1;
515
1213
gnutls_session_t session;
516
517
ret = init_gnutls_session (mc, &session);
518
if (ret != 0){
519
return -1;
520
}
521
522
if(debug){
523
fprintf(stderr, "Setting up a tcp connection to %s, port %" PRIu16
524
"\n", ip, port);
525
}
526
527
tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
528
if(tcp_sd < 0) {
529
perror("socket");
530
return -1;
531
}
532
533
if(debug){
534
if(if_indextoname((unsigned int)if_index, interface) == NULL){
535
perror("if_indextoname");
1214
int pf; /* Protocol family */
1215
bool route_added = false;
1216
1217
errno = 0;
1218
1219
if(quit_now){
1220
errno = EINTR;
1221
return -1;
1222
}
1223
1224
switch(af){
1225
case AF_INET6:
1226
pf = PF_INET6;
1227
break;
1228
case AF_INET:
1229
pf = PF_INET;
1230
break;
1231
default:
1232
fprintf_plus(stderr, "Bad address family: %d\n", af);
1233
errno = EINVAL;
1234
return -1;
1235
}
1236
1237
/* If the interface is specified and we have a list of interfaces */
1238
if(if_index != AVAHI_IF_UNSPEC and mc->interfaces != NULL){
1239
/* Check if the interface is one of the interfaces we are using */
1240
bool match = false;
1241
{
1242
char *interface = NULL;
1243
while((interface = argz_next(mc->interfaces,
1244
mc->interfaces_size,
1245
interface))){
1246
if(if_nametoindex(interface) == (unsigned int)if_index){
1247
match = true;
1248
break;
1249
}
1250
}
1251
}
1252
if(not match){
1253
/* This interface does not match any in the list, so we don't
1254
connect to the server */
1255
if(debug){
1256
char interface[IF_NAMESIZE];
1257
if(if_indextoname((unsigned int)if_index, interface) == NULL){
1258
perror_plus("if_indextoname");
1259
} else {
1260
fprintf_plus(stderr, "Skipping server on non-used interface"
1261
" \"%s\"\n",
1262
if_indextoname((unsigned int)if_index,
1263
interface));
1264
}
1265
}
536
1266
return -1;
537
1267
}
538
fprintf(stderr, "Binding to interface %s\n", interface);
539
1268
}
540
1269
541
memset(&to, 0, sizeof(to));
542
to.in6.sin6_family = AF_INET6;
543
/* It would be nice to have a way to detect if we were passed an
544
IPv4 address here. Now we assume an IPv6 address. */
545
ret = inet_pton(AF_INET6, ip, &to.in6.sin6_addr);
546
if (ret < 0 ){
547
perror("inet_pton");
1270
ret = init_gnutls_session(&session, mc);
1271
if(ret != 0){
548
1272
return -1;
549
1273
}
1274
1275
if(debug){
1276
fprintf_plus(stderr, "Setting up a TCP connection to %s, port %"
1277
PRIuMAX "\n", ip, (uintmax_t)port);
1278
}
1279
1280
tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
1281
if(tcp_sd < 0){
1282
int e = errno;
1283
perror_plus("socket");
1284
errno = e;
1285
goto mandos_end;
1286
}
1287
1288
if(quit_now){
1289
errno = EINTR;
1290
goto mandos_end;
1291
}
1292
1293
if(af == AF_INET6){
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);
1297
} else { /* IPv4 */
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);
1301
}
1302
if(ret < 0 ){
1303
int e = errno;
1304
perror_plus("inet_pton");
1305
errno = e;
1306
goto mandos_end;
1307
}
550
1308
if(ret == 0){
551
fprintf(stderr, "Bad address: %s\n", ip);
552
return -1;
553
}
554
to.in6.sin6_port = htons(port); /* Spurious warning */
1309
int e = errno;
1310
fprintf_plus(stderr, "Bad address: %s\n", ip);
1311
errno = e;
1312
goto mandos_end;
1313
}
1314
if(af == AF_INET6){
1315
((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
1316
if(IN6_IS_ADDR_LINKLOCAL
1317
(&((struct sockaddr_in6 *)&to)->sin6_addr)){
1318
if(if_index == AVAHI_IF_UNSPEC){
1319
fprintf_plus(stderr, "An IPv6 link-local address is"
1320
" incomplete without a network interface\n");
1321
errno = EINVAL;
1322
goto mandos_end;
1323
}
1324
/* Set the network interface number as scope */
1325
((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
1326
}
1327
} else {
1328
((struct sockaddr_in *)&to)->sin_port = htons(port);
1329
}
555
1330
556
to.in6.sin6_scope_id = (uint32_t)if_index;
1331
if(quit_now){
1332
errno = EINTR;
1333
goto mandos_end;
1334
}
557
1335
558
1336
if(debug){
559
fprintf(stderr, "Connection to: %s, port %" PRIu16 "\n", ip,
560
port);
561
char addrstr[INET6_ADDRSTRLEN] = "";
562
if(inet_ntop(to.in6.sin6_family, &(to.in6.sin6_addr), addrstr,
563
sizeof(addrstr)) == NULL){
564
perror("inet_ntop");
565
} else {
566
if(strcmp(addrstr, ip) != 0){
567
fprintf(stderr, "Canonical address form: %s\n", addrstr);
568
}
569
}
570
}
571
572
ret = connect(tcp_sd, &to.in, sizeof(to));
573
if (ret < 0){
574
perror("connect");
575
return -1;
1337
if(af == AF_INET6 and if_index != AVAHI_IF_UNSPEC){
1338
char interface[IF_NAMESIZE];
1339
if(if_indextoname((unsigned int)if_index, interface) == NULL){
1340
perror_plus("if_indextoname");
1341
} else {
1342
fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIuMAX
1343
"\n", ip, interface, (uintmax_t)port);
1344
}
1345
} else {
1346
fprintf_plus(stderr, "Connection to: %s, port %" PRIuMAX "\n",
1347
ip, (uintmax_t)port);
1348
}
1349
char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
1350
INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
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;
576
1431
}
577
1432
578
1433
const char *out = mandos_protocol_version;
579
1434
written = 0;
580
while (true){
1435
while(true){
581
1436
size_t out_size = strlen(out);
582
ret = TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
583
out_size - written));
584
if (ret == -1){
585
perror("write");
586
retval = -1;
1437
ret = (int)TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
1438
out_size - written));
1439
if(ret == -1){
1440
int e = errno;
1441
perror_plus("write");
1442
errno = e;
587
1443
goto mandos_end;
588
1444
}
589
1445
written += (size_t)ret;
590
1446
if(written < out_size){
591
1447
continue;
592
1448
} else {
593
if (out == mandos_protocol_version){
1449
if(out == mandos_protocol_version){
594
1450
written = 0;
595
1451
out = "\r\n";
596
1452
} else {
597
1453
break;
598
1454
}
599
1455
}
1456
1457
if(quit_now){
1458
errno = EINTR;
1459
goto mandos_end;
1460
}
600
1461
}
601
1462
602
1463
if(debug){
603
fprintf(stderr, "Establishing TLS session with %s\n", ip);
604
}
605
606
gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) tcp_sd);
607
608
do{
609
ret = gnutls_handshake (session);
1464
fprintf_plus(stderr, "Establishing TLS session with %s\n", ip);
1465
}
1466
1467
if(quit_now){
1468
errno = EINTR;
1469
goto mandos_end;
1470
}
1471
1472
/* This casting via intptr_t is to eliminate warning about casting
1473
an int to a pointer type. This is exactly how the GnuTLS Guile
1474
function "set-session-transport-fd!" does it. */
1475
gnutls_transport_set_ptr(session,
1476
(gnutls_transport_ptr_t)(intptr_t)tcp_sd);
1477
1478
if(quit_now){
1479
errno = EINTR;
1480
goto mandos_end;
1481
}
1482
1483
do {
1484
ret = gnutls_handshake(session);
1485
if(quit_now){
1486
errno = EINTR;
1487
goto mandos_end;
1488
}
610
1489
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
611
1490
612
if (ret != GNUTLS_E_SUCCESS){
1491
if(ret != GNUTLS_E_SUCCESS){
613
1492
if(debug){
614
fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
615
gnutls_perror (ret);
1493
fprintf_plus(stderr, "*** GnuTLS Handshake failed ***\n");
1494
gnutls_perror(ret);
616
1495
}
617
retval = -1;
1496
errno = EPROTO;
618
1497
goto mandos_end;
619
1498
}
620
1499
621
1500
/* Read OpenPGP packet that contains the wanted password */
622
1501
623
1502
if(debug){
624
fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
625
ip);
1503
fprintf_plus(stderr, "Retrieving OpenPGP encrypted password from"
1504
" %s\n", ip);
626
1505
}
627
1506
628
1507
while(true){
629
buffer_capacity = adjustbuffer(&buffer, buffer_length,
630
buffer_capacity);
631
if (buffer_capacity == 0){
632
perror("adjustbuffer");
633
retval = -1;
634
goto mandos_end;
635
}
636
637
ret = gnutls_record_recv(session, buffer+buffer_length,
638
BUFFER_SIZE);
639
if (ret == 0){
1508
1509
if(quit_now){
1510
errno = EINTR;
1511
goto mandos_end;
1512
}
1513
1514
buffer_capacity = incbuffer(&buffer, buffer_length,
1515
buffer_capacity);
1516
if(buffer_capacity == 0){
1517
int e = errno;
1518
perror_plus("incbuffer");
1519
errno = e;
1520
goto mandos_end;
1521
}
1522
1523
if(quit_now){
1524
errno = EINTR;
1525
goto mandos_end;
1526
}
1527
1528
sret = gnutls_record_recv(session, buffer+buffer_length,
1529
BUFFER_SIZE);
1530
if(sret == 0){
640
1531
break;
641
1532
}
642
if (ret < 0){
643
switch(ret){
1533
if(sret < 0){
1534
switch(sret){
644
1535
case GNUTLS_E_INTERRUPTED:
645
1536
case GNUTLS_E_AGAIN:
646
1537
break;
647
1538
case GNUTLS_E_REHANDSHAKE:
648
do{
649
ret = gnutls_handshake (session);
1539
do {
1540
ret = gnutls_handshake(session);
1541
1542
if(quit_now){
1543
errno = EINTR;
1544
goto mandos_end;
1545
}
650
1546
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
651
if (ret < 0){
652
fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
653
gnutls_perror (ret);
654
retval = -1;
1547
if(ret < 0){
1548
fprintf_plus(stderr, "*** GnuTLS Re-handshake failed "
1549
"***\n");
1550
gnutls_perror(ret);
1551
errno = EPROTO;
655
1552
goto mandos_end;
656
1553
}
657
1554
break;
658
1555
default:
659
fprintf(stderr, "Unknown error while reading data from"
660
" encrypted session with Mandos server\n");
661
retval = -1;
662
gnutls_bye (session, GNUTLS_SHUT_RDWR);
1556
fprintf_plus(stderr, "Unknown error while reading data from"
1557
" encrypted session with Mandos server\n");
1558
gnutls_bye(session, GNUTLS_SHUT_RDWR);
1559
errno = EIO;
663
1560
goto mandos_end;
664
1561
}
665
1562
} else {
666
buffer_length += (size_t) ret;
1563
buffer_length += (size_t) sret;
667
1564
}
668
1565
}
669
1566
670
1567
if(debug){
671
fprintf(stderr, "Closing TLS session\n");
672
}
673
674
gnutls_bye (session, GNUTLS_SHUT_RDWR);
675
676
if (buffer_length > 0){
677
decrypted_buffer_size = pgp_packet_decrypt(mc, buffer,
678
buffer_length,
679
&decrypted_buffer);
680
if (decrypted_buffer_size >= 0){
1568
fprintf_plus(stderr, "Closing TLS session\n");
1569
}
1570
1571
if(quit_now){
1572
errno = EINTR;
1573
goto mandos_end;
1574
}
1575
1576
do {
1577
ret = gnutls_bye(session, GNUTLS_SHUT_RDWR);
1578
if(quit_now){
1579
errno = EINTR;
1580
goto mandos_end;
1581
}
1582
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
1583
1584
if(buffer_length > 0){
1585
ssize_t decrypted_buffer_size;
1586
decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
1587
&decrypted_buffer, mc);
1588
if(decrypted_buffer_size >= 0){
1589
1590
clearerr(stdout);
681
1591
written = 0;
682
1592
while(written < (size_t) decrypted_buffer_size){
683
ret = (int)fwrite (decrypted_buffer + written, 1,
684
(size_t)decrypted_buffer_size - written,
685
stdout);
1593
if(quit_now){
1594
errno = EINTR;
1595
goto mandos_end;
1596
}
1597
1598
ret = (int)fwrite(decrypted_buffer + written, 1,
1599
(size_t)decrypted_buffer_size - written,
1600
stdout);
686
1601
if(ret == 0 and ferror(stdout)){
1602
int e = errno;
687
1603
if(debug){
688
fprintf(stderr, "Error writing encrypted data: %s\n",
689
strerror(errno));
1604
fprintf_plus(stderr, "Error writing encrypted data: %s\n",
1605
strerror(errno));
690
1606
}
691
retval = -1;
692
break;
1607
errno = e;
1608
goto mandos_end;
693
1609
}
694
1610
written += (size_t)ret;
695
1611
}
696
free(decrypted_buffer);
697
} else {
698
retval = -1;
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
}
1622
retval = 0;
699
1623
}
700
} else {
701
retval = -1;
702
1624
}
703
1625
704
1626
/* Shutdown procedure */
705
1627
706
1628
mandos_end:
707
free(buffer);
708
ret = TEMP_FAILURE_RETRY(close(tcp_sd));
709
if(ret == -1){
710
perror("close");
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
}
1636
int e = errno;
1637
free(decrypted_buffer);
1638
free(buffer);
1639
if(tcp_sd >= 0){
1640
ret = close(tcp_sd);
1641
}
1642
if(ret == -1){
1643
if(e == 0){
1644
e = errno;
1645
}
1646
perror_plus("close");
1647
}
1648
gnutls_deinit(session);
1649
errno = e;
1650
if(quit_now){
1651
errno = EINTR;
1652
retval = -1;
1653
}
711
1654
}
712
gnutls_deinit (session);
713
1655
return retval;
714
1656
}
715
1657
716
1658
static void resolve_callback(AvahiSServiceResolver *r,
717
1659
AvahiIfIndex interface,
718
AVAHI_GCC_UNUSED AvahiProtocol protocol,
1660
AvahiProtocol proto,
719
1661
AvahiResolverEvent event,
720
1662
const char *name,
721
1663
const char *type,
726
1668
AVAHI_GCC_UNUSED AvahiStringList *txt,
727
1669
AVAHI_GCC_UNUSED AvahiLookupResultFlags
728
1670
flags,
729
void* userdata) {
730
mandos_context *mc = userdata;
731
assert(r);
1671
void *mc){
1672
if(r == NULL){
1673
return;
1674
}
732
1675
733
1676
/* Called whenever a service has been resolved successfully or
734
1677
timed out */
735
1678
736
switch (event) {
1679
if(quit_now){
1680
avahi_s_service_resolver_free(r);
1681
return;
1682
}
1683
1684
switch(event){
737
1685
default:
738
1686
case AVAHI_RESOLVER_FAILURE:
739
fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
740
" of type '%s' in domain '%s': %s\n", name, type, domain,
741
avahi_strerror(avahi_server_errno(mc->server)));
1687
fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
1688
"'%s' of type '%s' in domain '%s': %s\n", name, type,
1689
domain,
1690
avahi_strerror(avahi_server_errno
1691
(((mandos_context*)mc)->server)));
742
1692
break;
743
1693
744
1694
case AVAHI_RESOLVER_FOUND:
746
1696
char ip[AVAHI_ADDRESS_STR_MAX];
747
1697
avahi_address_snprint(ip, sizeof(ip), address);
748
1698
if(debug){
749
fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %"
750
PRIu16 ") on port %d\n", name, host_name, ip,
751
interface, port);
1699
fprintf_plus(stderr, "Mandos server \"%s\" found on %s (%s, %"
1700
PRIdMAX ") on port %" PRIu16 "\n", name,
1701
host_name, ip, (intmax_t)interface, port);
752
1702
}
753
int ret = start_mandos_communication(ip, port, interface, mc);
754
if (ret == 0){
755
avahi_simple_poll_quit(mc->simple_poll);
1703
int ret = start_mandos_communication(ip, (in_port_t)port,
1704
interface,
1705
avahi_proto_to_af(proto),
1706
mc);
1707
if(ret == 0){
1708
avahi_simple_poll_quit(simple_poll);
1709
} else {
1710
if(not add_server(ip, (in_port_t)port, interface,
1711
avahi_proto_to_af(proto),
1712
&((mandos_context*)mc)->current_server)){
1713
fprintf_plus(stderr, "Failed to add server \"%s\" to server"
1714
" list\n", name);
1715
}
756
1716
}
757
1717
}
758
1718
}
759
1719
avahi_s_service_resolver_free(r);
760
1720
}
761
1721
762
static void browse_callback( AvahiSServiceBrowser *b,
763
AvahiIfIndex interface,
764
AvahiProtocol protocol,
765
AvahiBrowserEvent event,
766
const char *name,
767
const char *type,
768
const char *domain,
769
AVAHI_GCC_UNUSED AvahiLookupResultFlags
770
flags,
771
void* userdata) {
772
mandos_context *mc = userdata;
773
assert(b);
1722
static void browse_callback(AvahiSServiceBrowser *b,
1723
AvahiIfIndex interface,
1724
AvahiProtocol protocol,
1725
AvahiBrowserEvent event,
1726
const char *name,
1727
const char *type,
1728
const char *domain,
1729
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1730
flags,
1731
void *mc){
1732
if(b == NULL){
1733
return;
1734
}
774
1735
775
1736
/* Called whenever a new services becomes available on the LAN or
776
1737
is removed from the LAN */
777
1738
778
switch (event) {
1739
if(quit_now){
1740
return;
1741
}
1742
1743
switch(event){
779
1744
default:
780
1745
case AVAHI_BROWSER_FAILURE:
781
1746
782
fprintf(stderr, "(Avahi browser) %s\n",
783
avahi_strerror(avahi_server_errno(mc->server)));
784
avahi_simple_poll_quit(mc->simple_poll);
1747
fprintf_plus(stderr, "(Avahi browser) %s\n",
1748
avahi_strerror(avahi_server_errno
1749
(((mandos_context*)mc)->server)));
1750
avahi_simple_poll_quit(simple_poll);
785
1751
return;
786
1752
787
1753
case AVAHI_BROWSER_NEW:
790
1756
the callback function is called the Avahi server will free the
791
1757
resolver for us. */
792
1758
793
if (!(avahi_s_service_resolver_new(mc->server, interface,
794
protocol, name, type, domain,
795
AVAHI_PROTO_INET6, 0,
796
resolve_callback, mc)))
797
fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
798
name, avahi_strerror(avahi_server_errno(mc->server)));
1759
if(avahi_s_service_resolver_new(((mandos_context*)mc)->server,
1760
interface, protocol, name, type,
1761
domain, protocol, 0,
1762
resolve_callback, mc) == NULL)
1763
fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
1764
" %s\n", name,
1765
avahi_strerror(avahi_server_errno
1766
(((mandos_context*)mc)->server)));
799
1767
break;
800
1768
801
1769
case AVAHI_BROWSER_REMOVE:
804
1772
case AVAHI_BROWSER_ALL_FOR_NOW:
805
1773
case AVAHI_BROWSER_CACHE_EXHAUSTED:
806
1774
if(debug){
807
fprintf(stderr, "No Mandos server found, still searching...\n");
1775
fprintf_plus(stderr, "No Mandos server found, still"
1776
" searching...\n");
808
1777
}
809
1778
break;
810
1779
}
811
1780
}
812
1781
1782
/* Signal handler that stops main loop after SIGTERM */
1783
static void handle_sigterm(int sig){
1784
if(quit_now){
1785
return;
1786
}
1787
quit_now = 1;
1788
signal_received = sig;
1789
int old_errno = errno;
1790
/* set main loop to exit */
1791
if(simple_poll != NULL){
1792
avahi_simple_poll_quit(simple_poll);
1793
}
1794
errno = old_errno;
1795
}
1796
1797
__attribute__((nonnull, warn_unused_result))
1798
bool get_flags(const char *ifname, struct ifreq *ifr){
1799
int ret;
1800
int old_errno;
1801
1802
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1803
if(s < 0){
1804
old_errno = errno;
1805
perror_plus("socket");
1806
errno = old_errno;
1807
return false;
1808
}
1809
strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
1810
ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
1811
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1812
if(ret == -1){
1813
if(debug){
1814
old_errno = errno;
1815
perror_plus("ioctl SIOCGIFFLAGS");
1816
errno = old_errno;
1817
}
1818
if((close(s) == -1) and debug){
1819
old_errno = errno;
1820
perror_plus("close");
1821
errno = old_errno;
1822
}
1823
return false;
1824
}
1825
if((close(s) == -1) and debug){
1826
old_errno = errno;
1827
perror_plus("close");
1828
errno = old_errno;
1829
}
1830
return true;
1831
}
1832
1833
__attribute__((nonnull, warn_unused_result))
1834
bool good_flags(const char *ifname, const struct ifreq *ifr){
1835
1836
/* Reject the loopback device */
1837
if(ifr->ifr_flags & IFF_LOOPBACK){
1838
if(debug){
1839
fprintf_plus(stderr, "Rejecting loopback interface \"%s\"\n",
1840
ifname);
1841
}
1842
return false;
1843
}
1844
/* Accept point-to-point devices only if connect_to is specified */
1845
if(connect_to != NULL and (ifr->ifr_flags & IFF_POINTOPOINT)){
1846
if(debug){
1847
fprintf_plus(stderr, "Accepting point-to-point interface"
1848
" \"%s\"\n", ifname);
1849
}
1850
return true;
1851
}
1852
/* Otherwise, reject non-broadcast-capable devices */
1853
if(not (ifr->ifr_flags & IFF_BROADCAST)){
1854
if(debug){
1855
fprintf_plus(stderr, "Rejecting non-broadcast interface"
1856
" \"%s\"\n", ifname);
1857
}
1858
return false;
1859
}
1860
/* Reject non-ARP interfaces (including dummy interfaces) */
1861
if(ifr->ifr_flags & IFF_NOARP){
1862
if(debug){
1863
fprintf_plus(stderr, "Rejecting non-ARP interface \"%s\"\n",
1864
ifname);
1865
}
1866
return false;
1867
}
1868
1869
/* Accept this device */
1870
if(debug){
1871
fprintf_plus(stderr, "Interface \"%s\" is good\n", ifname);
1872
}
1873
return true;
1874
}
1875
1876
/*
1877
* This function determines if a directory entry in /sys/class/net
1878
* corresponds to an acceptable network device.
1879
* (This function is passed to scandir(3) as a filter function.)
1880
*/
1881
__attribute__((nonnull, warn_unused_result))
1882
int good_interface(const struct dirent *if_entry){
1883
if(if_entry->d_name[0] == '.'){
1884
return 0;
1885
}
1886
1887
struct ifreq ifr;
1888
if(not get_flags(if_entry->d_name, &ifr)){
1889
if(debug){
1890
fprintf_plus(stderr, "Failed to get flags for interface "
1891
"\"%s\"\n", if_entry->d_name);
1892
}
1893
return 0;
1894
}
1895
1896
if(not good_flags(if_entry->d_name, &ifr)){
1897
return 0;
1898
}
1899
return 1;
1900
}
1901
1902
/*
1903
* This function determines if a network interface is up.
1904
*/
1905
__attribute__((nonnull, warn_unused_result))
1906
bool interface_is_up(const char *interface){
1907
struct ifreq ifr;
1908
if(not get_flags(interface, &ifr)){
1909
if(debug){
1910
fprintf_plus(stderr, "Failed to get flags for interface "
1911
"\"%s\"\n", interface);
1912
}
1913
return false;
1914
}
1915
1916
return (bool)(ifr.ifr_flags & IFF_UP);
1917
}
1918
1919
/*
1920
* This function determines if a network interface is running
1921
*/
1922
__attribute__((nonnull, warn_unused_result))
1923
bool interface_is_running(const char *interface){
1924
struct ifreq ifr;
1925
if(not get_flags(interface, &ifr)){
1926
if(debug){
1927
fprintf_plus(stderr, "Failed to get flags for interface "
1928
"\"%s\"\n", interface);
1929
}
1930
return false;
1931
}
1932
1933
return (bool)(ifr.ifr_flags & IFF_RUNNING);
1934
}
1935
1936
__attribute__((nonnull, pure, warn_unused_result))
1937
int notdotentries(const struct dirent *direntry){
1938
/* Skip "." and ".." */
1939
if(direntry->d_name[0] == '.'
1940
and (direntry->d_name[1] == '\0'
1941
or (direntry->d_name[1] == '.'
1942
and direntry->d_name[2] == '\0'))){
1943
return 0;
1944
}
1945
return 1;
1946
}
1947
1948
/* Is this directory entry a runnable program? */
1949
__attribute__((nonnull, warn_unused_result))
1950
int runnable_hook(const struct dirent *direntry){
1951
int ret;
1952
size_t sret;
1953
struct stat st;
1954
1955
if((direntry->d_name)[0] == '\0'){
1956
/* Empty name? */
1957
return 0;
1958
}
1959
1960
sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1961
"abcdefghijklmnopqrstuvwxyz"
1962
"0123456789"
1963
"_.-");
1964
if((direntry->d_name)[sret] != '\0'){
1965
/* Contains non-allowed characters */
1966
if(debug){
1967
fprintf_plus(stderr, "Ignoring hook \"%s\" with bad name\n",
1968
direntry->d_name);
1969
}
1970
return 0;
1971
}
1972
1973
ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1974
if(ret == -1){
1975
if(debug){
1976
perror_plus("Could not stat hook");
1977
}
1978
return 0;
1979
}
1980
if(not (S_ISREG(st.st_mode))){
1981
/* Not a regular file */
1982
if(debug){
1983
fprintf_plus(stderr, "Ignoring hook \"%s\" - not a file\n",
1984
direntry->d_name);
1985
}
1986
return 0;
1987
}
1988
if(not (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))){
1989
/* Not executable */
1990
if(debug){
1991
fprintf_plus(stderr, "Ignoring hook \"%s\" - not executable\n",
1992
direntry->d_name);
1993
}
1994
return 0;
1995
}
1996
if(debug){
1997
fprintf_plus(stderr, "Hook \"%s\" is acceptable\n",
1998
direntry->d_name);
1999
}
2000
return 1;
2001
}
2002
2003
__attribute__((nonnull, warn_unused_result))
2004
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
2005
mandos_context *mc){
2006
int ret;
2007
struct timespec now;
2008
struct timespec waited_time;
2009
intmax_t block_time;
2010
2011
while(true){
2012
if(mc->current_server == NULL){
2013
if(debug){
2014
fprintf_plus(stderr, "Wait until first server is found."
2015
" No timeout!\n");
2016
}
2017
ret = avahi_simple_poll_iterate(s, -1);
2018
} else {
2019
if(debug){
2020
fprintf_plus(stderr, "Check current_server if we should run"
2021
" it, or wait\n");
2022
}
2023
/* the current time */
2024
ret = clock_gettime(CLOCK_MONOTONIC, &now);
2025
if(ret == -1){
2026
perror_plus("clock_gettime");
2027
return -1;
2028
}
2029
/* Calculating in ms how long time between now and server
2030
who we visted longest time ago. Now - last seen. */
2031
waited_time.tv_sec = (now.tv_sec
2032
- mc->current_server->last_seen.tv_sec);
2033
waited_time.tv_nsec = (now.tv_nsec
2034
- mc->current_server->last_seen.tv_nsec);
2035
/* total time is 10s/10,000ms.
2036
Converting to s from ms by dividing by 1,000,
2037
and ns to ms by dividing by 1,000,000. */
2038
block_time = ((retry_interval
2039
- ((intmax_t)waited_time.tv_sec * 1000))
2040
- ((intmax_t)waited_time.tv_nsec / 1000000));
2041
2042
if(debug){
2043
fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
2044
block_time);
2045
}
2046
2047
if(block_time <= 0){
2048
ret = start_mandos_communication(mc->current_server->ip,
2049
mc->current_server->port,
2050
mc->current_server->if_index,
2051
mc->current_server->af, mc);
2052
if(ret == 0){
2053
avahi_simple_poll_quit(s);
2054
return 0;
2055
}
2056
ret = clock_gettime(CLOCK_MONOTONIC,
2057
&mc->current_server->last_seen);
2058
if(ret == -1){
2059
perror_plus("clock_gettime");
2060
return -1;
2061
}
2062
mc->current_server = mc->current_server->next;
2063
block_time = 0; /* Call avahi to find new Mandos
2064
servers, but don't block */
2065
}
2066
2067
ret = avahi_simple_poll_iterate(s, (int)block_time);
2068
}
2069
if(ret != 0){
2070
if(ret > 0 or errno != EINTR){
2071
return (ret != 1) ? ret : 0;
2072
}
2073
}
2074
}
2075
}
2076
2077
__attribute__((nonnull))
2078
void run_network_hooks(const char *mode, const char *interface,
2079
const float delay){
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
}
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);
2115
}
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){
2162
perror_plus("asprintf");
2163
_exit(EX_OSERR);
2164
}
2165
ret = setenv("DELAY", delaystring, 1);
2166
if(ret == -1){
2167
free(delaystring);
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;
2236
} else {
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);
2256
}
2257
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;
2263
struct ifreq network;
2264
unsigned int if_index = if_nametoindex(interface);
2265
if(if_index == 0){
2266
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
2267
errno = old_errno;
2268
return ENXIO;
2269
}
2270
2271
if(quit_now){
2272
errno = old_errno;
2273
return EINTR;
2274
}
2275
2276
if(not interface_is_up(interface)){
2277
int ret_errno = 0;
2278
int ioctl_errno = 0;
2279
if(not get_flags(interface, &network)){
2280
ret_errno = errno;
2281
fprintf_plus(stderr, "Failed to get flags for interface "
2282
"\"%s\"\n", interface);
2283
errno = old_errno;
2284
return ret_errno;
2285
}
2286
network.ifr_flags |= IFF_UP; /* set flag */
2287
2288
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
2289
if(sd == -1){
2290
ret_errno = errno;
2291
perror_plus("socket");
2292
errno = old_errno;
2293
return ret_errno;
2294
}
2295
2296
if(quit_now){
2297
ret = close(sd);
2298
if(ret == -1){
2299
perror_plus("close");
2300
}
2301
errno = old_errno;
2302
return EINTR;
2303
}
2304
2305
if(debug){
2306
fprintf_plus(stderr, "Bringing up interface \"%s\"\n",
2307
interface);
2308
}
2309
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
}
2316
2317
#ifdef __linux__
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
}
2329
}
2330
#endif /* __linux__ */
2331
int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
2332
ioctl_errno = errno;
2333
#ifdef __linux__
2334
if(restore_loglevel){
2335
ret_linux = klogctl(7, NULL, 0);
2336
if(ret_linux == -1){
2337
perror_plus("klogctl");
2338
}
2339
}
2340
#endif /* __linux__ */
2341
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
}
2351
2352
/* Close the socket */
2353
ret = close(sd);
2354
if(ret == -1){
2355
perror_plus("close");
2356
}
2357
2358
if(ret_setflags == -1){
2359
errno = ioctl_errno;
2360
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
2361
errno = old_errno;
2362
return ioctl_errno;
2363
}
2364
} else if(debug){
2365
fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
2366
interface);
2367
}
2368
2369
/* Sleep checking until interface is running.
2370
Check every 0.25s, up to total time of delay */
2371
for(int i = 0; i < delay * 4; i++){
2372
if(interface_is_running(interface)){
2373
break;
2374
}
2375
struct timespec sleeptime = { .tv_nsec = 250000000 };
2376
ret = nanosleep(&sleeptime, NULL);
2377
if(ret == -1 and errno != EINTR){
2378
perror_plus("nanosleep");
2379
}
2380
}
2381
2382
errno = old_errno;
2383
return 0;
2384
}
2385
2386
__attribute__((nonnull, warn_unused_result))
2387
int take_down_interface(const char *const interface){
2388
int old_errno = errno;
2389
struct ifreq network;
2390
unsigned int if_index = if_nametoindex(interface);
2391
if(if_index == 0){
2392
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
2393
errno = old_errno;
2394
return ENXIO;
2395
}
2396
if(interface_is_up(interface)){
2397
int ret_errno = 0;
2398
int ioctl_errno = 0;
2399
if(not get_flags(interface, &network) and debug){
2400
ret_errno = errno;
2401
fprintf_plus(stderr, "Failed to get flags for interface "
2402
"\"%s\"\n", interface);
2403
errno = old_errno;
2404
return ret_errno;
2405
}
2406
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
2407
2408
int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
2409
if(sd == -1){
2410
ret_errno = errno;
2411
perror_plus("socket");
2412
errno = old_errno;
2413
return ret_errno;
2414
}
2415
2416
if(debug){
2417
fprintf_plus(stderr, "Taking down interface \"%s\"\n",
2418
interface);
2419
}
2420
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
}
2440
2441
/* Close the socket */
2442
int ret = close(sd);
2443
if(ret == -1){
2444
perror_plus("close");
2445
}
2446
2447
if(ret_setflags == -1){
2448
errno = ioctl_errno;
2449
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
2450
errno = old_errno;
2451
return ioctl_errno;
2452
}
2453
} else if(debug){
2454
fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
2455
interface);
2456
}
2457
2458
errno = old_errno;
2459
return 0;
2460
}
2461
813
2462
int main(int argc, char *argv[]){
814
AvahiSServiceBrowser *sb = NULL;
815
int error;
816
int ret;
817
int exitcode = EXIT_SUCCESS;
818
const char *interface = "eth0";
819
struct ifreq network;
820
int sd;
821
uid_t uid;
822
gid_t gid;
823
char *connect_to = NULL;
824
char tempdir[] = "/tmp/mandosXXXXXX";
825
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
826
const char *seckey = PATHDIR "/" SECKEY;
827
const char *pubkey = PATHDIR "/" PUBKEY;
828
829
mandos_context mc = { .simple_poll = NULL, .server = NULL,
830
.dh_bits = 1024, .priority = "SECURE256"
831
":!CTYPE-X.509:+CTYPE-OPENPGP" };
832
bool gnutls_initalized = false;
833
bool pgpme_initalized = false;
834
835
{
836
struct argp_option options[] = {
837
{ .name = "debug", .key = 128,
838
.doc = "Debug mode", .group = 3 },
839
{ .name = "connect", .key = 'c',
840
.arg = "ADDRESS:PORT",
841
.doc = "Connect directly to a specific Mandos server",
842
.group = 1 },
843
{ .name = "interface", .key = 'i',
844
.arg = "NAME",
845
.doc = "Interface that will be used to search for Mandos"
846
" servers",
847
.group = 1 },
848
{ .name = "seckey", .key = 's',
849
.arg = "FILE",
850
.doc = "OpenPGP secret key file base name",
851
.group = 1 },
852
{ .name = "pubkey", .key = 'p',
853
.arg = "FILE",
854
.doc = "OpenPGP public key file base name",
855
.group = 2 },
856
{ .name = "dh-bits", .key = 129,
857
.arg = "BITS",
858
.doc = "Bit length of the prime number used in the"
859
" Diffie-Hellman key exchange",
860
.group = 2 },
861
{ .name = "priority", .key = 130,
862
.arg = "STRING",
863
.doc = "GnuTLS priority string for the TLS handshake",
864
.group = 1 },
865
{ .name = NULL }
866
};
867
868
error_t parse_opt (int key, char *arg,
869
struct argp_state *state) {
870
/* Get the INPUT argument from `argp_parse', which we know is
871
a pointer to our plugin list pointer. */
872
switch (key) {
873
case 128: /* --debug */
874
debug = true;
875
break;
876
case 'c': /* --connect */
877
connect_to = arg;
878
break;
879
case 'i': /* --interface */
880
interface = arg;
881
break;
882
case 's': /* --seckey */
883
seckey = arg;
884
break;
885
case 'p': /* --pubkey */
886
pubkey = arg;
887
break;
888
case 129: /* --dh-bits */
889
errno = 0;
890
mc.dh_bits = (unsigned int) strtol(arg, NULL, 10);
891
if (errno){
892
perror("strtol");
893
exit(EXIT_FAILURE);
894
}
895
break;
896
case 130: /* --priority */
897
mc.priority = arg;
898
break;
899
case ARGP_KEY_ARG:
900
argp_usage (state);
901
case ARGP_KEY_END:
902
break;
903
default:
904
return ARGP_ERR_UNKNOWN;
905
}
906
return 0;
907
}
908
909
struct argp argp = { .options = options, .parser = parse_opt,
910
.args_doc = "",
911
.doc = "Mandos client -- Get and decrypt"
912
" passwords from a Mandos server" };
913
ret = argp_parse (&argp, argc, argv, 0, 0, NULL);
914
if (ret == ARGP_ERR_UNKNOWN){
915
fprintf(stderr, "Unknown error while parsing arguments\n");
916
exitcode = EXIT_FAILURE;
917
goto end;
918
}
919
}
920
921
/* If the interface is down, bring it up */
922
{
923
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
924
if(sd < 0) {
925
perror("socket");
926
exitcode = EXIT_FAILURE;
927
goto end;
928
}
929
strcpy(network.ifr_name, interface);
930
ret = ioctl(sd, SIOCGIFFLAGS, &network);
931
if(ret == -1){
932
perror("ioctl SIOCGIFFLAGS");
933
exitcode = EXIT_FAILURE;
934
goto end;
935
}
936
if((network.ifr_flags & IFF_UP) == 0){
937
network.ifr_flags |= IFF_UP;
938
ret = ioctl(sd, SIOCSIFFLAGS, &network);
939
if(ret == -1){
940
perror("ioctl SIOCSIFFLAGS");
941
exitcode = EXIT_FAILURE;
942
goto end;
943
}
944
}
945
ret = TEMP_FAILURE_RETRY(close(sd));
946
if(ret == -1){
947
perror("close");
948
}
949
}
950
951
uid = getuid();
952
gid = getgid();
953
954
ret = setuid(uid);
955
if (ret == -1){
956
perror("setuid");
957
}
958
959
setgid(gid);
960
if (ret == -1){
961
perror("setgid");
962
}
963
964
ret = init_gnutls_global(&mc, pubkey, seckey);
965
if (ret == -1){
966
fprintf(stderr, "init_gnutls_global failed\n");
967
exitcode = EXIT_FAILURE;
968
goto end;
969
} else {
970
gnutls_initalized = true;
971
}
972
973
if(mkdtemp(tempdir) == NULL){
974
perror("mkdtemp");
975
tempdir[0] = '\0';
976
goto end;
977
}
978
979
if(not init_gpgme(&mc, pubkey, seckey, tempdir)){
980
fprintf(stderr, "pgpme_initalized failed\n");
981
exitcode = EXIT_FAILURE;
982
goto end;
983
} else {
984
pgpme_initalized = true;
985
}
986
987
if_index = (AvahiIfIndex) if_nametoindex(interface);
988
if(if_index == 0){
989
fprintf(stderr, "No such interface: \"%s\"\n", interface);
990
exit(EXIT_FAILURE);
991
}
992
993
if(connect_to != NULL){
994
/* Connect directly, do not use Zeroconf */
995
/* (Mainly meant for debugging) */
996
char *address = strrchr(connect_to, ':');
997
if(address == NULL){
998
fprintf(stderr, "No colon in address\n");
999
exitcode = EXIT_FAILURE;
1000
goto end;
1001
}
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 };
2476
AvahiSServiceBrowser *sb = NULL;
2477
error_t ret_errno;
2478
int ret;
2479
intmax_t tmpmax;
2480
char *tmp;
2481
int exitcode = EXIT_SUCCESS;
2482
char *interfaces_to_take_down = NULL;
2483
size_t interfaces_to_take_down_size = 0;
2484
char run_tempdir[] = "/run/tmp/mandosXXXXXX";
2485
char old_tempdir[] = "/tmp/mandosXXXXXX";
2486
char *tempdir = NULL;
2487
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
2488
const char *seckey = PATHDIR "/" SECKEY;
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;
2495
char *interfaces_hooks = NULL;
2496
2497
bool gnutls_initialized = false;
2498
bool gpgme_initialized = false;
2499
float delay = 2.5f;
2500
double retry_interval = 10; /* 10s between trying a server and
2501
retrying the same server again */
2502
2503
struct sigaction old_sigterm_action = { .sa_handler = SIG_DFL };
2504
struct sigaction sigterm_action = { .sa_handler = handle_sigterm };
2505
2506
uid = getuid();
2507
gid = getgid();
2508
2509
/* Lower any group privileges we might have, just to be safe */
2510
errno = 0;
2511
ret = setgid(gid);
2512
if(ret == -1){
2513
perror_plus("setgid");
2514
}
2515
2516
/* Lower user privileges (temporarily) */
2517
errno = 0;
2518
ret = seteuid(uid);
2519
if(ret == -1){
2520
perror_plus("seteuid");
2521
}
2522
2523
if(quit_now){
2524
goto end;
2525
}
2526
2527
{
2528
struct argp_option options[] = {
2529
{ .name = "debug", .key = 128,
2530
.doc = "Debug mode", .group = 3 },
2531
{ .name = "connect", .key = 'c',
2532
.arg = "ADDRESS:PORT",
2533
.doc = "Connect directly to a specific Mandos server",
2534
.group = 1 },
2535
{ .name = "interface", .key = 'i',
2536
.arg = "NAME",
2537
.doc = "Network interface that will be used to search for"
2538
" Mandos servers",
2539
.group = 1 },
2540
{ .name = "seckey", .key = 's',
2541
.arg = "FILE",
2542
.doc = "OpenPGP secret key file base name",
2543
.group = 1 },
2544
{ .name = "pubkey", .key = 'p',
2545
.arg = "FILE",
2546
.doc = "OpenPGP public key file base name",
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 },
2564
{ .name = "dh-bits", .key = 129,
2565
.arg = "BITS",
2566
.doc = "Bit length of the prime number used in the"
2567
" Diffie-Hellman key exchange",
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 },
2574
{ .name = "priority", .key = 130,
2575
.arg = "STRING",
2576
.doc = "GnuTLS priority string for the TLS handshake",
2577
.group = 1 },
2578
{ .name = "delay", .key = 131,
2579
.arg = "SECONDS",
2580
.doc = "Maximum delay to wait for interface startup",
2581
.group = 2 },
2582
{ .name = "retry", .key = 132,
2583
.arg = "SECONDS",
2584
.doc = "Retry interval used when denied by the Mandos server",
2585
.group = 2 },
2586
{ .name = "network-hook-dir", .key = 133,
2587
.arg = "DIR",
2588
.doc = "Directory where network hooks are located",
2589
.group = 2 },
2590
/*
2591
* These reproduce what we would get without ARGP_NO_HELP
2592
*/
2593
{ .name = "help", .key = '?',
2594
.doc = "Give this help list", .group = -1 },
2595
{ .name = "usage", .key = -3,
2596
.doc = "Give a short usage message", .group = -1 },
2597
{ .name = "version", .key = 'V',
2598
.doc = "Print program version", .group = -1 },
2599
{ .name = NULL }
2600
};
2601
2602
error_t parse_opt(int key, char *arg,
2603
struct argp_state *state){
1002
2604
errno = 0;
1003
uint16_t port = (uint16_t) strtol(address+1, NULL, 10);
1004
if(errno){
1005
perror("Bad port number");
1006
exitcode = EXIT_FAILURE;
2605
switch(key){
2606
case 128: /* --debug */
2607
debug = true;
2608
break;
2609
case 'c': /* --connect */
2610
connect_to = arg;
2611
break;
2612
case 'i': /* --interface */
2613
ret_errno = argz_add_sep(&mc.interfaces, &mc.interfaces_size,
2614
arg, (int)',');
2615
if(ret_errno != 0){
2616
argp_error(state, "%s", strerror(ret_errno));
2617
}
2618
break;
2619
case 's': /* --seckey */
2620
seckey = arg;
2621
break;
2622
case 'p': /* --pubkey */
2623
pubkey = arg;
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;
2635
case 129: /* --dh-bits */
2636
errno = 0;
2637
tmpmax = strtoimax(arg, &tmp, 10);
2638
if(errno != 0 or tmp == arg or *tmp != '\0'
2639
or tmpmax != (typeof(mc.dh_bits))tmpmax){
2640
argp_error(state, "Bad number of DH bits");
2641
}
2642
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
2643
break;
2644
case 134: /* --dh-params */
2645
dh_params_file = arg;
2646
break;
2647
case 130: /* --priority */
2648
mc.priority = arg;
2649
break;
2650
case 131: /* --delay */
2651
errno = 0;
2652
delay = strtof(arg, &tmp);
2653
if(errno != 0 or tmp == arg or *tmp != '\0'){
2654
argp_error(state, "Bad delay");
2655
}
2656
case 132: /* --retry */
2657
errno = 0;
2658
retry_interval = strtod(arg, &tmp);
2659
if(errno != 0 or tmp == arg or *tmp != '\0'
2660
or (retry_interval * 1000) > INT_MAX
2661
or retry_interval < 0){
2662
argp_error(state, "Bad retry interval");
2663
}
2664
break;
2665
case 133: /* --network-hook-dir */
2666
hookdir = arg;
2667
break;
2668
/*
2669
* These reproduce what we would get without ARGP_NO_HELP
2670
*/
2671
case '?': /* --help */
2672
argp_state_help(state, state->out_stream,
2673
(ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
2674
& ~(unsigned int)ARGP_HELP_EXIT_OK);
2675
case -3: /* --usage */
2676
argp_state_help(state, state->out_stream,
2677
ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
2678
case 'V': /* --version */
2679
fprintf_plus(state->out_stream, "%s\n", argp_program_version);
2680
exit(argp_err_exit_status);
2681
break;
2682
default:
2683
return ARGP_ERR_UNKNOWN;
2684
}
2685
return errno;
2686
}
2687
2688
struct argp argp = { .options = options, .parser = parse_opt,
2689
.args_doc = "",
2690
.doc = "Mandos client -- Get and decrypt"
2691
" passwords from a Mandos server" };
2692
ret_errno = argp_parse(&argp, argc, argv,
2693
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2694
switch(ret_errno){
2695
case 0:
2696
break;
2697
case ENOMEM:
2698
default:
2699
errno = ret_errno;
2700
perror_plus("argp_parse");
2701
exitcode = EX_OSERR;
2702
goto end;
2703
case EINVAL:
2704
exitcode = EX_USAGE;
2705
goto end;
2706
}
2707
}
2708
2709
{
2710
/* Work around Debian bug #633582:
2711
<https://bugs.debian.org/633582> */
2712
2713
/* Re-raise privileges */
2714
ret = raise_privileges();
2715
if(ret != 0){
2716
errno = ret;
2717
perror_plus("Failed to raise privileges");
2718
} else {
2719
struct stat st;
2720
2721
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
2722
int seckey_fd = open(seckey, O_RDONLY);
2723
if(seckey_fd == -1){
2724
perror_plus("open");
2725
} else {
2726
ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
2727
if(ret == -1){
2728
perror_plus("fstat");
2729
} else {
2730
if(S_ISREG(st.st_mode)
2731
and st.st_uid == 0 and st.st_gid == 0){
2732
ret = fchown(seckey_fd, uid, gid);
2733
if(ret == -1){
2734
perror_plus("fchown");
2735
}
2736
}
2737
}
2738
close(seckey_fd);
2739
}
2740
}
2741
2742
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2743
int pubkey_fd = open(pubkey, O_RDONLY);
2744
if(pubkey_fd == -1){
2745
perror_plus("open");
2746
} else {
2747
ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
2748
if(ret == -1){
2749
perror_plus("fstat");
2750
} else {
2751
if(S_ISREG(st.st_mode)
2752
and st.st_uid == 0 and st.st_gid == 0){
2753
ret = fchown(pubkey_fd, uid, gid);
2754
if(ret == -1){
2755
perror_plus("fchown");
2756
}
2757
}
2758
}
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
2785
/* Lower privileges */
2786
ret = lower_privileges();
2787
if(ret != 0){
2788
errno = ret;
2789
perror_plus("Failed to lower privileges");
2790
}
2791
}
2792
}
2793
2794
/* Remove invalid interface names (except "none") */
2795
{
2796
char *interface = NULL;
2797
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2798
interface))){
2799
if(strcmp(interface, "none") != 0
2800
and if_nametoindex(interface) == 0){
2801
if(interface[0] != '\0'){
2802
fprintf_plus(stderr, "Not using nonexisting interface"
2803
" \"%s\"\n", interface);
2804
}
2805
argz_delete(&mc.interfaces, &mc.interfaces_size, interface);
2806
interface = NULL;
2807
}
2808
}
2809
}
2810
2811
/* Run network hooks */
2812
{
2813
if(mc.interfaces != NULL){
2814
interfaces_hooks = malloc(mc.interfaces_size);
2815
if(interfaces_hooks == NULL){
2816
perror_plus("malloc");
1007
2817
goto end;
1008
2818
}
1009
*address = '\0';
1010
address = connect_to;
1011
ret = start_mandos_communication(address, port, if_index, &mc);
1012
if(ret < 0){
1013
exitcode = EXIT_FAILURE;
1014
} else {
1015
exitcode = EXIT_SUCCESS;
1016
}
1017
goto end;
1018
}
1019
1020
if (not debug){
1021
avahi_set_log_function(empty_log);
1022
}
1023
1024
/* Initialize the pseudo-RNG for Avahi */
1025
srand((unsigned int) time(NULL));
1026
1027
/* Allocate main Avahi loop object */
1028
mc.simple_poll = avahi_simple_poll_new();
1029
if (mc.simple_poll == NULL) {
1030
fprintf(stderr, "Avahi: Failed to create simple poll"
1031
" object.\n");
1032
exitcode = EXIT_FAILURE;
1033
goto end;
1034
}
1035
1036
{
1037
AvahiServerConfig config;
1038
/* Do not publish any local Zeroconf records */
1039
avahi_server_config_init(&config);
1040
config.publish_hinfo = 0;
1041
config.publish_addresses = 0;
1042
config.publish_workstation = 0;
1043
config.publish_domain = 0;
1044
1045
/* Allocate a new server */
1046
mc.server = avahi_server_new(avahi_simple_poll_get
1047
(mc.simple_poll), &config, NULL,
1048
NULL, &error);
1049
1050
/* Free the Avahi configuration data */
1051
avahi_server_config_free(&config);
1052
}
1053
1054
/* Check if creating the Avahi server object succeeded */
1055
if (mc.server == NULL) {
1056
fprintf(stderr, "Failed to create Avahi server: %s\n",
1057
avahi_strerror(error));
1058
exitcode = EXIT_FAILURE;
1059
goto end;
1060
}
1061
1062
/* Create the Avahi service browser */
1063
sb = avahi_s_service_browser_new(mc.server, if_index,
1064
AVAHI_PROTO_INET6,
1065
"_mandos._tcp", NULL, 0,
1066
browse_callback, &mc);
1067
if (sb == NULL) {
1068
fprintf(stderr, "Failed to create service browser: %s\n",
1069
avahi_strerror(avahi_server_errno(mc.server)));
1070
exitcode = EXIT_FAILURE;
1071
goto end;
1072
}
1073
1074
/* Run the main loop */
1075
1076
if (debug){
1077
fprintf(stderr, "Starting Avahi loop search\n");
1078
}
1079
1080
avahi_simple_poll_loop(mc.simple_poll);
1081
2819
memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
2820
argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
2821
}
2822
run_network_hooks("start", interfaces_hooks != NULL ?
2823
interfaces_hooks : "", delay);
2824
}
2825
2826
if(not debug){
2827
avahi_set_log_function(empty_log);
2828
}
2829
2830
/* Initialize Avahi early so avahi_simple_poll_quit() can be called
2831
from the signal handler */
2832
/* Initialize the pseudo-RNG for Avahi */
2833
srand((unsigned int) time(NULL));
2834
simple_poll = avahi_simple_poll_new();
2835
if(simple_poll == NULL){
2836
fprintf_plus(stderr,
2837
"Avahi: Failed to create simple poll object.\n");
2838
exitcode = EX_UNAVAILABLE;
2839
goto end;
2840
}
2841
2842
sigemptyset(&sigterm_action.sa_mask);
2843
ret = sigaddset(&sigterm_action.sa_mask, SIGINT);
2844
if(ret == -1){
2845
perror_plus("sigaddset");
2846
exitcode = EX_OSERR;
2847
goto end;
2848
}
2849
ret = sigaddset(&sigterm_action.sa_mask, SIGHUP);
2850
if(ret == -1){
2851
perror_plus("sigaddset");
2852
exitcode = EX_OSERR;
2853
goto end;
2854
}
2855
ret = sigaddset(&sigterm_action.sa_mask, SIGTERM);
2856
if(ret == -1){
2857
perror_plus("sigaddset");
2858
exitcode = EX_OSERR;
2859
goto end;
2860
}
2861
/* Need to check if the handler is SIG_IGN before handling:
2862
| [[info:libc:Initial Signal Actions]] |
2863
| [[info:libc:Basic Signal Handling]] |
2864
*/
2865
ret = sigaction(SIGINT, NULL, &old_sigterm_action);
2866
if(ret == -1){
2867
perror_plus("sigaction");
2868
return EX_OSERR;
2869
}
2870
if(old_sigterm_action.sa_handler != SIG_IGN){
2871
ret = sigaction(SIGINT, &sigterm_action, NULL);
2872
if(ret == -1){
2873
perror_plus("sigaction");
2874
exitcode = EX_OSERR;
2875
goto end;
2876
}
2877
}
2878
ret = sigaction(SIGHUP, NULL, &old_sigterm_action);
2879
if(ret == -1){
2880
perror_plus("sigaction");
2881
return EX_OSERR;
2882
}
2883
if(old_sigterm_action.sa_handler != SIG_IGN){
2884
ret = sigaction(SIGHUP, &sigterm_action, NULL);
2885
if(ret == -1){
2886
perror_plus("sigaction");
2887
exitcode = EX_OSERR;
2888
goto end;
2889
}
2890
}
2891
ret = sigaction(SIGTERM, NULL, &old_sigterm_action);
2892
if(ret == -1){
2893
perror_plus("sigaction");
2894
return EX_OSERR;
2895
}
2896
if(old_sigterm_action.sa_handler != SIG_IGN){
2897
ret = sigaction(SIGTERM, &sigterm_action, NULL);
2898
if(ret == -1){
2899
perror_plus("sigaction");
2900
exitcode = EX_OSERR;
2901
goto end;
2902
}
2903
}
2904
2905
/* If no interfaces were specified, make a list */
2906
if(mc.interfaces == NULL){
2907
struct dirent **direntries = NULL;
2908
/* Look for any good interfaces */
2909
ret = scandir(sys_class_net, &direntries, good_interface,
2910
alphasort);
2911
if(ret >= 1){
2912
/* Add all found interfaces to interfaces list */
2913
for(int i = 0; i < ret; ++i){
2914
ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
2915
direntries[i]->d_name);
2916
if(ret_errno != 0){
2917
errno = ret_errno;
2918
perror_plus("argz_add");
2919
free(direntries[i]);
2920
continue;
2921
}
2922
if(debug){
2923
fprintf_plus(stderr, "Will use interface \"%s\"\n",
2924
direntries[i]->d_name);
2925
}
2926
free(direntries[i]);
2927
}
2928
free(direntries);
2929
} else {
2930
if(ret == 0){
2931
free(direntries);
2932
}
2933
fprintf_plus(stderr, "Could not find a network interface\n");
2934
exitcode = EXIT_FAILURE;
2935
goto end;
2936
}
2937
}
2938
2939
/* Bring up interfaces which are down, and remove any "none"s */
2940
{
2941
char *interface = NULL;
2942
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2943
interface))){
2944
/* If interface name is "none", stop bringing up interfaces.
2945
Also remove all instances of "none" from the list */
2946
if(strcmp(interface, "none") == 0){
2947
argz_delete(&mc.interfaces, &mc.interfaces_size,
2948
interface);
2949
interface = NULL;
2950
while((interface = argz_next(mc.interfaces,
2951
mc.interfaces_size, interface))){
2952
if(strcmp(interface, "none") == 0){
2953
argz_delete(&mc.interfaces, &mc.interfaces_size,
2954
interface);
2955
interface = NULL;
2956
}
2957
}
2958
break;
2959
}
2960
bool interface_was_up = interface_is_up(interface);
2961
errno = bring_up_interface(interface, delay);
2962
if(not interface_was_up){
2963
if(errno != 0){
2964
fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
2965
" %s\n", interface, strerror(errno));
2966
} else {
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
}
2973
}
2974
}
2975
}
2976
if(debug and (interfaces_to_take_down == NULL)){
2977
fprintf_plus(stderr, "No interfaces were brought up\n");
2978
}
2979
}
2980
2981
/* If we only got one interface, explicitly use only that one */
2982
if(argz_count(mc.interfaces, mc.interfaces_size) == 1){
2983
if(debug){
2984
fprintf_plus(stderr, "Using only interface \"%s\"\n",
2985
mc.interfaces);
2986
}
2987
if_index = (AvahiIfIndex)if_nametoindex(mc.interfaces);
2988
}
2989
2990
if(quit_now){
2991
goto end;
2992
}
2993
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
3001
if(ret == -1){
3002
fprintf_plus(stderr, "init_gnutls_global failed\n");
3003
exitcode = EX_UNAVAILABLE;
3004
goto end;
3005
} else {
3006
gnutls_initialized = true;
3007
}
3008
3009
if(quit_now){
3010
goto end;
3011
}
3012
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){
3023
perror_plus("mkdtemp");
3024
goto end;
3025
}
3026
3027
if(quit_now){
3028
goto end;
3029
}
3030
3031
if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
3032
fprintf_plus(stderr, "init_gpgme failed\n");
3033
exitcode = EX_UNAVAILABLE;
3034
goto end;
3035
} else {
3036
gpgme_initialized = true;
3037
}
3038
3039
if(quit_now){
3040
goto end;
3041
}
3042
3043
if(connect_to != NULL){
3044
/* Connect directly, do not use Zeroconf */
3045
/* (Mainly meant for debugging) */
3046
char *address = strrchr(connect_to, ':');
3047
3048
if(address == NULL){
3049
fprintf_plus(stderr, "No colon in address\n");
3050
exitcode = EX_USAGE;
3051
goto end;
3052
}
3053
3054
if(quit_now){
3055
goto end;
3056
}
3057
3058
in_port_t port;
3059
errno = 0;
3060
tmpmax = strtoimax(address+1, &tmp, 10);
3061
if(errno != 0 or tmp == address+1 or *tmp != '\0'
3062
or tmpmax != (in_port_t)tmpmax){
3063
fprintf_plus(stderr, "Bad port number\n");
3064
exitcode = EX_USAGE;
3065
goto end;
3066
}
3067
3068
if(quit_now){
3069
goto end;
3070
}
3071
3072
port = (in_port_t)tmpmax;
3073
*address = '\0';
3074
/* Colon in address indicates IPv6 */
3075
int af;
3076
if(strchr(connect_to, ':') != NULL){
3077
af = AF_INET6;
3078
/* Accept [] around IPv6 address - see RFC 5952 */
3079
if(connect_to[0] == '[' and address[-1] == ']')
3080
{
3081
connect_to++;
3082
address[-1] = '\0';
3083
}
3084
} else {
3085
af = AF_INET;
3086
}
3087
address = connect_to;
3088
3089
if(quit_now){
3090
goto end;
3091
}
3092
3093
while(not quit_now){
3094
ret = start_mandos_communication(address, port, if_index, af,
3095
&mc);
3096
if(quit_now or ret == 0){
3097
break;
3098
}
3099
if(debug){
3100
fprintf_plus(stderr, "Retrying in %d seconds\n",
3101
(int)retry_interval);
3102
}
3103
sleep((unsigned int)retry_interval);
3104
}
3105
3106
if(not quit_now){
3107
exitcode = EXIT_SUCCESS;
3108
}
3109
3110
goto end;
3111
}
3112
3113
if(quit_now){
3114
goto end;
3115
}
3116
3117
{
3118
AvahiServerConfig config;
3119
/* Do not publish any local Zeroconf records */
3120
avahi_server_config_init(&config);
3121
config.publish_hinfo = 0;
3122
config.publish_addresses = 0;
3123
config.publish_workstation = 0;
3124
config.publish_domain = 0;
3125
3126
/* Allocate a new server */
3127
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
3128
&config, NULL, NULL, &ret);
3129
3130
/* Free the Avahi configuration data */
3131
avahi_server_config_free(&config);
3132
}
3133
3134
/* Check if creating the Avahi server object succeeded */
3135
if(mc.server == NULL){
3136
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
3137
avahi_strerror(ret));
3138
exitcode = EX_UNAVAILABLE;
3139
goto end;
3140
}
3141
3142
if(quit_now){
3143
goto end;
3144
}
3145
3146
/* Create the Avahi service browser */
3147
sb = avahi_s_service_browser_new(mc.server, if_index,
3148
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
3149
NULL, 0, browse_callback,
3150
(void *)&mc);
3151
if(sb == NULL){
3152
fprintf_plus(stderr, "Failed to create service browser: %s\n",
3153
avahi_strerror(avahi_server_errno(mc.server)));
3154
exitcode = EX_UNAVAILABLE;
3155
goto end;
3156
}
3157
3158
if(quit_now){
3159
goto end;
3160
}
3161
3162
/* Run the main loop */
3163
3164
if(debug){
3165
fprintf_plus(stderr, "Starting Avahi loop search\n");
3166
}
3167
3168
ret = avahi_loop_with_timeout(simple_poll,
3169
(int)(retry_interval * 1000), &mc);
3170
if(debug){
3171
fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
3172
(ret == 0) ? "successfully" : "with error");
3173
}
3174
1082
3175
end:
1083
1084
if (debug){
1085
fprintf(stderr, "%s exiting\n", argv[0]);
1086
}
1087
1088
/* Cleanup things */
1089
if (sb != NULL)
1090
avahi_s_service_browser_free(sb);
1091
1092
if (mc.server != NULL)
1093
avahi_server_free(mc.server);
1094
1095
if (mc.simple_poll != NULL)
1096
avahi_simple_poll_free(mc.simple_poll);
1097
1098
if (gnutls_initalized){
1099
gnutls_certificate_free_credentials(mc.cred);
1100
gnutls_global_deinit ();
1101
}
1102
1103
if(pgpme_initalized){
1104
gpgme_release(mc.ctx);
1105
}
1106
1107
/* Removes the temp directory used by GPGME */
1108
if(tempdir[0] != '\0'){
1109
DIR *d;
1110
struct dirent *direntry;
1111
d = opendir(tempdir);
1112
if(d == NULL){
1113
perror("opendir");
1114
} else {
1115
while(true){
1116
direntry = readdir(d);
1117
if(direntry == NULL){
1118
break;
1119
}
1120
if (direntry->d_type == DT_REG){
1121
char *fullname = NULL;
1122
ret = asprintf(&fullname, "%s/%s", tempdir,
1123
direntry->d_name);
1124
if(ret < 0){
1125
perror("asprintf");
1126
continue;
1127
}
1128
ret = unlink(fullname);
1129
if(ret == -1){
1130
fprintf(stderr, "unlink(\"%s\"): %s",
1131
fullname, strerror(errno));
1132
}
1133
free(fullname);
1134
}
1135
}
1136
}
1137
ret = rmdir(tempdir);
1138
if(ret == -1){
1139
perror("rmdir");
1140
}
1141
}
1142
1143
return exitcode;
3176
3177
if(debug){
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
}
3185
}
3186
3187
/* Cleanup things */
3188
free(mc.interfaces);
3189
3190
if(sb != NULL)
3191
avahi_s_service_browser_free(sb);
3192
3193
if(mc.server != NULL)
3194
avahi_server_free(mc.server);
3195
3196
if(simple_poll != NULL)
3197
avahi_simple_poll_free(simple_poll);
3198
3199
if(gnutls_initialized){
3200
gnutls_certificate_free_credentials(mc.cred);
3201
gnutls_dh_params_deinit(mc.dh_params);
3202
}
3203
3204
if(gpgme_initialized){
3205
gpgme_release(mc.ctx);
3206
}
3207
3208
/* Cleans up the circular linked list of Mandos servers the client
3209
has seen */
3210
if(mc.current_server != NULL){
3211
mc.current_server->prev->next = NULL;
3212
while(mc.current_server != NULL){
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
3222
free(mc.current_server);
3223
mc.current_server = next;
3224
}
3225
}
3226
3227
/* Re-raise privileges */
3228
{
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
}
3263
}
3264
3265
free(interfaces_to_take_down);
3266
free(interfaces_hooks);
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
3322
/* Removes the GPGME temp directory and all files inside */
3323
if(tempdir != NULL){
3324
clean_dir_at(-1, tempdir, 0);
3325
}
3326
3327
if(quit_now){
3328
sigemptyset(&old_sigterm_action.sa_mask);
3329
old_sigterm_action.sa_handler = SIG_DFL;
3330
ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
3331
&old_sigterm_action,
3332
NULL));
3333
if(ret == -1){
3334
perror_plus("sigaction");
3335
}
3336
do {
3337
ret = raise(signal_received);
3338
} while(ret != 0 and errno == EINTR);
3339
if(ret != 0){
3340
perror_plus("raise");
3341
abort();
3342
}
3343
TEMP_FAILURE_RETRY(pause());
3344
}
3345
3346
return exitcode;
1144
3347
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0