To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to plugins.d/mandos-client.c
- browse files at revision 962
- compare with another revision
- download diff
- download tarball
- view history from revision 962
- Committer: Teddy Hogeborn
- Date: 2019-02-09 23:23:26 UTC
- Revision ID: teddy@recompile.se-20190209232326-z1z2kzpgfixz7iaj
Add support for using raw public keys in TLS (RFC 7250)
Since GnuTLS removed support for OpenPGP keys in TLS (RFC 6091), and
no other library supports it, we have to change the protocol to use
something else. We choose to use "raw public keys" (RFC 7250). Since
we still use OpenPGP keys to decrypt the secret password, this means
that each client will have two keys: One OpenPGP key and one TLS
public/private key, and the key ID of the latter key is used to
identify clients instead of the fingerprint of the OpenPGP key.
Note that this code is still compatible with GnuTLS before version
3.6.0 (when OpenPGP key support was removed). This commit merely adds
support for using raw pulic keys instead with GnuTLS 3.6.6. or later.
* DBUS-API (Signals/ClientNotFound): Change name of first parameter
from "Fingerprint" to "KeyID".
(Mandos Client Interface/Properties/KeyID): New.
* INSTALL: Document conflict with GnuTLS 3.6.0 (which removed OpenPGP
key support) up until 3.6.6, when support for raw public
keys was added. Also document new dependency of client on
"gnutls-bin" package (for certtool).
* Makefile (run-client): Depend on TLS key files, and also pass them
as arguments to client.
(keydir/tls-privkey.pem, keydir/tls-pubkey.pem): New.
(confdir/clients.conf): Add dependency on TLS public key.
(purge-client): Add removal of TLS key files.
* clients.conf ([foo]/key_id, [bar]/key_id): New.
* debian/control (Source: mandos/Build-Depends): Also allow
libgnutls30 (>= 3.6.6)
(Package: mandos/Depends): - '' -
(Package: mandos/Description): Alter description to match new
design.
(Package: mandos-client/Description): - '' -
(Package: mandos-client/Depends): Move "gnutls-bin | openssl" to
here from "Recommends".
* debian/mandos-client.README.Debian: Add --tls-privkey and
--tls-pubkey options to test
command.
* debian/mandos-client.postinst (create_key): Renamed to "create_keys"
(all callers changed),
and also create TLS key.
* debian/mandos-client.postrm (purge): Also remove TLS key files.
* intro.xml (DESCRIPTION): Describe new dual-key design.
* mandos (GnuTLS): Define different functions depending on whether
support for raw public keys is detected.
(Client.key_id): New attribute.
(ClientDBus.KeyID_dbus_property): New method.
(ProxyClient.__init__): Take new "key_id" parameter.
(ClientHandler.handle): Use key IDs when using raw public keys and
use fingerprints when using OpenPGP keys.
(ClientHandler.peer_certificate): Also handle raw public keys.
(ClientHandler.key_id): New.
(MandosServer.handle_ipc): Pass key ID over the pipe IPC. Also
check for key ID matches when looking up
clients.
(main): Default GnuTLS priority string depends on whether we are
using raw public keys or not. When unpickling clients, set
key_id if not set in the pickle.
(main/MandosDBusService.ClientNotFound): Change name of first
parameter from
"Fingerprint" to "KeyID".
* mandos-clients.conf.xml (OPTIONS): Document new "key_id" option.
(OPTIONS/secret): Mention new key ID matchning.
(EXPANSION/RUNTIME EXPANSION): Add new "key_id" option.
(EXAMPLE): - '' -
* mandos-ctl (tablewords, main/keywords): Add new "KeyID" property.
* mandos-keygen: Create TLS key files. New "--tls-keytype" (-T)
option. Alter help text to be more clear about key
types. When in password mode, also output "key_id"
option.
* mandos-keygen.xml (SYNOPSIS): Add new "--tls-keytype" (-T) option.
(DESCRIPTION): Alter to match new dual-key design.
(OVERVIEW): - '' -
(FILES): Add TLS key files.
* mandos-options.xml (priority): Document new default priority string
when using raw public keys.
* mandos.xml (NETWORK PROTOCOL): Describe new protocol using key ID.
(BUGS): Remove issue about checking expire times of OpenPGP keys,
since TLS public keys do not have expiration times.
(SECURITY/CLIENT): Alter description to match new design.
(SEE ALSO/GnuTLS): - '' -
(SEE ALSO): Add reference to RFC 7250, and alter description of when
RFC 6091 is used.
* overview.xml: Alter text to match new design.
* plugin-runner.xml (EXAMPLE): Add --tls-pubkey and --tls-privkey
options to mandos-client options.
* plugins.d/mandos-client.c: Use raw public keys when compiling with
supporting GnuTLS versions. Add new
"--tls-pubkey" and "--tls-privkey"
options (which do nothing if GnuTLS
library does not support raw public
keys). Alter text throughout to reflect
new design. Only generate new DH
parameters (based on size of OpenPGP key)
when using OpenPGP in TLS. Default
GnuTLS priority string depends on whether
we are using raw public keys or not.
* plugins.d/mandos-client.xml (SYNOPSIS): Add new "--tls-privkey" (-t)
and "--tls-pubkey" (-T)
options.
(DESCRIPTION): Describe new dual-key design.
(OPTIONS): Document new "--tls-privkey" (-t) and "--tls-pubkey" (-T)
options.
(OPTIONS/--dh-bits): No longer necessarily depends on OpenPGP key
size.
(FILES): Add default locations for TLS public and private key files.
(EXAMPLE): Use new --tls-pubkey and --tls-privkey options.
(SECURITY): Alter wording slightly to reflect new dual-key design.
(SEE ALSO/GnuTLS): Alter description to match new design.
(SEE ALSO): Add reference to RFC 7250, and alter description of when
RFC 6091 is used.
Since GnuTLS removed support for OpenPGP keys in TLS (RFC 6091), and
no other library supports it, we have to change the protocol to use
something else. We choose to use "raw public keys" (RFC 7250). Since
we still use OpenPGP keys to decrypt the secret password, this means
that each client will have two keys: One OpenPGP key and one TLS
public/private key, and the key ID of the latter key is used to
identify clients instead of the fingerprint of the OpenPGP key.
Note that this code is still compatible with GnuTLS before version
3.6.0 (when OpenPGP key support was removed). This commit merely adds
support for using raw pulic keys instead with GnuTLS 3.6.6. or later.
* DBUS-API (Signals/ClientNotFound): Change name of first parameter
from "Fingerprint" to "KeyID".
(Mandos Client Interface/Properties/KeyID): New.
* INSTALL: Document conflict with GnuTLS 3.6.0 (which removed OpenPGP
key support) up until 3.6.6, when support for raw public
keys was added. Also document new dependency of client on
"gnutls-bin" package (for certtool).
* Makefile (run-client): Depend on TLS key files, and also pass them
as arguments to client.
(keydir/tls-privkey.pem, keydir/tls-pubkey.pem): New.
(confdir/clients.conf): Add dependency on TLS public key.
(purge-client): Add removal of TLS key files.
* clients.conf ([foo]/key_id, [bar]/key_id): New.
* debian/control (Source: mandos/Build-Depends): Also allow
libgnutls30 (>= 3.6.6)
(Package: mandos/Depends): - '' -
(Package: mandos/Description): Alter description to match new
design.
(Package: mandos-client/Description): - '' -
(Package: mandos-client/Depends): Move "gnutls-bin | openssl" to
here from "Recommends".
* debian/mandos-client.README.Debian: Add --tls-privkey and
--tls-pubkey options to test
command.
* debian/mandos-client.postinst (create_key): Renamed to "create_keys"
(all callers changed),
and also create TLS key.
* debian/mandos-client.postrm (purge): Also remove TLS key files.
* intro.xml (DESCRIPTION): Describe new dual-key design.
* mandos (GnuTLS): Define different functions depending on whether
support for raw public keys is detected.
(Client.key_id): New attribute.
(ClientDBus.KeyID_dbus_property): New method.
(ProxyClient.__init__): Take new "key_id" parameter.
(ClientHandler.handle): Use key IDs when using raw public keys and
use fingerprints when using OpenPGP keys.
(ClientHandler.peer_certificate): Also handle raw public keys.
(ClientHandler.key_id): New.
(MandosServer.handle_ipc): Pass key ID over the pipe IPC. Also
check for key ID matches when looking up
clients.
(main): Default GnuTLS priority string depends on whether we are
using raw public keys or not. When unpickling clients, set
key_id if not set in the pickle.
(main/MandosDBusService.ClientNotFound): Change name of first
parameter from
"Fingerprint" to "KeyID".
* mandos-clients.conf.xml (OPTIONS): Document new "key_id" option.
(OPTIONS/secret): Mention new key ID matchning.
(EXPANSION/RUNTIME EXPANSION): Add new "key_id" option.
(EXAMPLE): - '' -
* mandos-ctl (tablewords, main/keywords): Add new "KeyID" property.
* mandos-keygen: Create TLS key files. New "--tls-keytype" (-T)
option. Alter help text to be more clear about key
types. When in password mode, also output "key_id"
option.
* mandos-keygen.xml (SYNOPSIS): Add new "--tls-keytype" (-T) option.
(DESCRIPTION): Alter to match new dual-key design.
(OVERVIEW): - '' -
(FILES): Add TLS key files.
* mandos-options.xml (priority): Document new default priority string
when using raw public keys.
* mandos.xml (NETWORK PROTOCOL): Describe new protocol using key ID.
(BUGS): Remove issue about checking expire times of OpenPGP keys,
since TLS public keys do not have expiration times.
(SECURITY/CLIENT): Alter description to match new design.
(SEE ALSO/GnuTLS): - '' -
(SEE ALSO): Add reference to RFC 7250, and alter description of when
RFC 6091 is used.
* overview.xml: Alter text to match new design.
* plugin-runner.xml (EXAMPLE): Add --tls-pubkey and --tls-privkey
options to mandos-client options.
* plugins.d/mandos-client.c: Use raw public keys when compiling with
supporting GnuTLS versions. Add new
"--tls-pubkey" and "--tls-privkey"
options (which do nothing if GnuTLS
library does not support raw public
keys). Alter text throughout to reflect
new design. Only generate new DH
parameters (based on size of OpenPGP key)
when using OpenPGP in TLS. Default
GnuTLS priority string depends on whether
we are using raw public keys or not.
* plugins.d/mandos-client.xml (SYNOPSIS): Add new "--tls-privkey" (-t)
and "--tls-pubkey" (-T)
options.
(DESCRIPTION): Describe new dual-key design.
(OPTIONS): Document new "--tls-privkey" (-t) and "--tls-pubkey" (-T)
options.
(OPTIONS/--dh-bits): No longer necessarily depends on OpenPGP key
size.
(FILES): Add default locations for TLS public and private key files.
(EXAMPLE): Use new --tls-pubkey and --tls-privkey options.
(SECURITY): Alter wording slightly to reflect new dual-key design.
(SEE ALSO/GnuTLS): Alter description to match new design.
(SEE ALSO): Add reference to RFC 7250, and alter description of when
RFC 6091 is used.
- files added:
- bugs.xml
- debian/upstream
- network-hooks.d
- plugin-helpers
- files removed:
- initramfs-tools-hook-conf
- files modified:
- .bzrignore
added
removed
plugins.d/mandos-client.c
9
9
* "browse_callback", and parts of "main".
10
10
*
11
11
* Everything else is
12
* Copyright © 2008-2011 Teddy Hogeborn
13
* Copyright © 2008-2011 Björn Påhlsson
14
*
15
* This program is free software: you can redistribute it and/or
16
* modify it under the terms of the GNU General Public License as
17
* published by the Free Software Foundation, either version 3 of the
18
* License, or (at your option) any later version.
19
*
20
* This program is distributed in the hope that it will be useful, but
12
* Copyright © 2008-2018 Teddy Hogeborn
13
* Copyright © 2008-2018 Björn Påhlsson
14
*
15
* This file is part of Mandos.
16
*
17
* Mandos is free software: you can redistribute it and/or modify it
18
* under the terms of the GNU General Public License as published by
19
* the Free Software Foundation, either version 3 of the License, or
20
* (at your option) any later version.
21
*
22
* Mandos is distributed in the hope that it will be useful, but
21
23
* WITHOUT ANY WARRANTY; without even the implied warranty of
22
24
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23
25
* General Public License for more details.
24
26
*
25
27
* You should have received a copy of the GNU General Public License
26
* along with this program. If not, see
27
* <http://www.gnu.org/licenses/>.
28
* along with Mandos. If not, see <http://www.gnu.org/licenses/>.
28
29
*
29
30
* Contact the authors at <mandos@recompile.se>.
30
31
*/
32
33
/* Needed by GPGME, specifically gpgme_data_seek() */
33
34
#ifndef _LARGEFILE_SOURCE
34
35
#define _LARGEFILE_SOURCE
35
#endif
36
#endif /* not _LARGEFILE_SOURCE */
36
37
#ifndef _FILE_OFFSET_BITS
37
38
#define _FILE_OFFSET_BITS 64
38
#endif
39
#endif /* not _FILE_OFFSET_BITS */
39
40
40
41
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
41
42
42
43
#include <stdio.h> /* fprintf(), stderr, fwrite(),
43
stdout, ferror(), remove() */
44
#include <stdint.h> /* uint16_t, uint32_t */
44
stdout, ferror() */
45
#include <stdint.h> /* uint16_t, uint32_t, intptr_t */
45
46
#include <stddef.h> /* NULL, size_t, ssize_t */
46
47
#include <stdlib.h> /* free(), EXIT_SUCCESS, srand(),
47
48
strtof(), abort() */
48
49
#include <stdbool.h> /* bool, false, true */
49
#include <string.h> /* memset(), strcmp(), strlen(),
50
strerror(), asprintf(), strcpy() */
50
#include <string.h> /* strcmp(), strlen(), strerror(),
51
asprintf(), strncpy(), strsignal()
52
*/
51
53
#include <sys/ioctl.h> /* ioctl */
52
54
#include <sys/types.h> /* socket(), inet_pton(), sockaddr,
53
55
sockaddr_in6, PF_INET6,
54
56
SOCK_STREAM, uid_t, gid_t, open(),
55
57
opendir(), DIR */
56
#include <sys/stat.h> /* open() */
58
#include <sys/stat.h> /* open(), S_ISREG */
57
59
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
58
inet_pton(), connect() */
59
#include <fcntl.h> /* open() */
60
inet_pton(), connect(),
61
getnameinfo() */
62
#include <fcntl.h> /* open(), unlinkat(), AT_REMOVEDIR */
60
63
#include <dirent.h> /* opendir(), struct dirent, readdir()
61
64
*/
62
65
#include <inttypes.h> /* PRIu16, PRIdMAX, intmax_t,
63
66
strtoimax() */
64
#include <assert.h> /* assert() */
65
#include <errno.h> /* perror(), errno,
67
#include <errno.h> /* perror(), errno, EINTR, EINVAL,
68
EAI_SYSTEM, ENETUNREACH,
69
EHOSTUNREACH, ECONNREFUSED, EPROTO,
70
EIO, ENOENT, ENXIO, ENOMEM, EISDIR,
71
ENOTEMPTY,
66
72
program_invocation_short_name */
67
73
#include <time.h> /* nanosleep(), time(), sleep() */
68
74
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
73
79
*/
74
80
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
75
81
getuid(), getgid(), seteuid(),
76
setgid(), pause() */
77
#include <arpa/inet.h> /* inet_pton(), htons, inet_ntop() */
82
setgid(), pause(), _exit(),
83
unlinkat() */
84
#include <arpa/inet.h> /* inet_pton(), htons() */
78
85
#include <iso646.h> /* not, or, and */
79
86
#include <argp.h> /* struct argp_option, error_t, struct
80
87
argp_state, struct argp,
85
92
raise() */
86
93
#include <sysexits.h> /* EX_OSERR, EX_USAGE, EX_UNAVAILABLE,
87
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() */
88
104
89
105
#ifdef __linux__
90
106
#include <sys/klog.h> /* klogctl() */
107
123
gnutls_*
108
124
init_gnutls_session(),
109
125
GNUTLS_* */
126
#if GNUTLS_VERSION_NUMBER < 0x030600
110
127
#include <gnutls/openpgp.h>
111
/* gnutls_certificate_set_openpgp_key_file(),
112
GNUTLS_OPENPGP_FMT_BASE64 */
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
113
135
114
136
/* GPGME */
115
137
#include <gpgme.h> /* All GPGME types, constants and
123
145
#define PATHDIR "/conf/conf.d/mandos"
124
146
#define SECKEY "seckey.txt"
125
147
#define PUBKEY "pubkey.txt"
148
#define TLS_PRIVKEY "tls-privkey.pem"
149
#define TLS_PUBKEY "tls-pubkey.pem"
126
150
#define HOOKDIR "/lib/mandos/network-hooks.d"
127
151
128
152
bool debug = false;
131
155
const char *argp_program_bug_address = "<mandos@recompile.se>";
132
156
static const char sys_class_net[] = "/sys/class/net";
133
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;
134
162
135
163
/* Doubly linked list that need to be circularly linked when used */
136
164
typedef struct server{
137
165
const char *ip;
138
uint16_t port;
166
in_port_t port;
139
167
AvahiIfIndex if_index;
140
168
int af;
141
169
struct timespec last_seen;
145
173
146
174
/* Used for passing in values through the Avahi callback functions */
147
175
typedef struct {
148
AvahiSimplePoll *simple_poll;
149
176
AvahiServer *server;
150
177
gnutls_certificate_credentials_t cred;
151
178
unsigned int dh_bits;
153
180
const char *priority;
154
181
gpgme_ctx_t ctx;
155
182
server *current_server;
183
char *interfaces;
184
size_t interfaces_size;
156
185
} mandos_context;
157
186
158
/* global context so signal handler can reach it*/
159
mandos_context mc = { .simple_poll = NULL, .server = NULL,
160
.dh_bits = 1024, .priority = "SECURE256"
161
":!CTYPE-X.509:+CTYPE-OPENPGP",
162
.current_server = NULL };
187
/* global so signal handler can reach it*/
188
AvahiSimplePoll *simple_poll;
163
189
164
190
sig_atomic_t quit_now = 0;
165
191
int signal_received = 0;
166
192
167
193
/* Function to use when printing errors */
168
194
void perror_plus(const char *print_text){
195
int e = errno;
169
196
fprintf(stderr, "Mandos plugin %s: ",
170
197
program_invocation_short_name);
198
errno = e;
171
199
perror(print_text);
172
200
}
173
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
174
212
/*
175
213
* Make additional room in "buffer" for at least BUFFER_SIZE more
176
214
* bytes. "buffer_capacity" is how much is currently allocated,
177
215
* "buffer_length" is how much is already used.
178
216
*/
217
__attribute__((nonnull, warn_unused_result))
179
218
size_t incbuffer(char **buffer, size_t buffer_length,
180
size_t buffer_capacity){
219
size_t buffer_capacity){
181
220
if(buffer_length + BUFFER_SIZE > buffer_capacity){
182
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
183
if(buffer == NULL){
221
char *new_buf = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
222
if(new_buf == NULL){
223
int old_errno = errno;
224
free(*buffer);
225
errno = old_errno;
226
*buffer = NULL;
184
227
return 0;
185
228
}
229
*buffer = new_buf;
186
230
buffer_capacity += BUFFER_SIZE;
187
231
}
188
232
return buffer_capacity;
189
233
}
190
234
191
235
/* Add server to set of servers to retry periodically */
192
int add_server(const char *ip, uint16_t port,
193
AvahiIfIndex if_index,
194
int af){
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){
195
239
int ret;
196
240
server *new_server = malloc(sizeof(server));
197
241
if(new_server == NULL){
198
242
perror_plus("malloc");
199
return -1;
243
return false;
200
244
}
201
245
*new_server = (server){ .ip = strdup(ip),
202
.port = port,
203
.if_index = if_index,
204
.af = af };
246
.port = port,
247
.if_index = if_index,
248
.af = af };
205
249
if(new_server->ip == NULL){
206
250
perror_plus("strdup");
207
return -1;
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;
208
267
}
209
268
/* Special case of first server */
210
if (mc.current_server == NULL){
269
if(*current_server == NULL){
211
270
new_server->next = new_server;
212
271
new_server->prev = new_server;
213
mc.current_server = new_server;
214
/* Place the new server last in the list */
272
*current_server = new_server;
215
273
} else {
216
new_server->next = mc.current_server;
217
new_server->prev = mc.current_server->prev;
274
/* Place the new server last in the list */
275
new_server->next = *current_server;
276
new_server->prev = (*current_server)->prev;
218
277
new_server->prev->next = new_server;
219
mc.current_server->prev = new_server;
220
}
221
ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);
222
if(ret == -1){
223
perror_plus("clock_gettime");
224
return -1;
225
}
226
return 0;
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;
227
333
}
228
334
229
335
/*
230
336
* Initialize GPGME.
231
337
*/
232
static bool init_gpgme(const char *seckey,
233
const char *pubkey, const char *tempdir){
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){
234
343
gpgme_error_t rc;
235
344
gpgme_engine_info_t engine_info;
236
345
237
238
346
/*
239
347
* Helper function to insert pub and seckey to the engine keyring.
240
348
*/
241
bool import_key(const char *filename){
349
bool import_key(const char * const filename){
242
350
int ret;
243
351
int fd;
244
352
gpgme_data_t pgp_data;
249
357
return false;
250
358
}
251
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
252
410
rc = gpgme_data_new_from_fd(&pgp_data, fd);
253
411
if(rc != GPG_ERR_NO_ERROR){
254
fprintf(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
255
gpgme_strsource(rc), gpgme_strerror(rc));
412
fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
413
gpgme_strsource(rc), gpgme_strerror(rc));
256
414
return false;
257
415
}
258
416
259
rc = gpgme_op_import(mc.ctx, pgp_data);
417
rc = gpgme_op_import(mc->ctx, pgp_data);
260
418
if(rc != GPG_ERR_NO_ERROR){
261
fprintf(stderr, "bad gpgme_op_import: %s: %s\n",
262
gpgme_strsource(rc), gpgme_strerror(rc));
419
fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
420
gpgme_strsource(rc), gpgme_strerror(rc));
263
421
return false;
264
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
}
265
498
266
ret = (int)TEMP_FAILURE_RETRY(close(fd));
499
ret = close(fd);
267
500
if(ret == -1){
268
501
perror_plus("close");
269
502
}
272
505
}
273
506
274
507
if(debug){
275
fprintf(stderr, "Initializing GPGME\n");
508
fprintf_plus(stderr, "Initializing GPGME\n");
276
509
}
277
510
278
511
/* Init GPGME */
279
512
gpgme_check_version(NULL);
280
513
rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
281
514
if(rc != GPG_ERR_NO_ERROR){
282
fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
283
gpgme_strsource(rc), gpgme_strerror(rc));
515
fprintf_plus(stderr, "bad gpgme_engine_check_version: %s: %s\n",
516
gpgme_strsource(rc), gpgme_strerror(rc));
284
517
return false;
285
518
}
286
519
287
520
/* Set GPGME home directory for the OpenPGP engine only */
288
521
rc = gpgme_get_engine_info(&engine_info);
289
522
if(rc != GPG_ERR_NO_ERROR){
290
fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
291
gpgme_strsource(rc), gpgme_strerror(rc));
523
fprintf_plus(stderr, "bad gpgme_get_engine_info: %s: %s\n",
524
gpgme_strsource(rc), gpgme_strerror(rc));
292
525
return false;
293
526
}
294
527
while(engine_info != NULL){
300
533
engine_info = engine_info->next;
301
534
}
302
535
if(engine_info == NULL){
303
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);
304
538
return false;
305
539
}
306
540
307
541
/* Create new GPGME "context" */
308
rc = gpgme_new(&(mc.ctx));
542
rc = gpgme_new(&(mc->ctx));
309
543
if(rc != GPG_ERR_NO_ERROR){
310
fprintf(stderr, "bad gpgme_new: %s: %s\n",
311
gpgme_strsource(rc), gpgme_strerror(rc));
544
fprintf_plus(stderr, "bad gpgme_new: %s: %s\n",
545
gpgme_strsource(rc), gpgme_strerror(rc));
312
546
return false;
313
547
}
314
548
323
557
* Decrypt OpenPGP data.
324
558
* Returns -1 on error
325
559
*/
560
__attribute__((nonnull, warn_unused_result))
326
561
static ssize_t pgp_packet_decrypt(const char *cryptotext,
327
562
size_t crypto_size,
328
char **plaintext){
563
char **plaintext,
564
mandos_context *mc){
329
565
gpgme_data_t dh_crypto, dh_plain;
330
566
gpgme_error_t rc;
331
567
ssize_t ret;
333
569
ssize_t plaintext_length = 0;
334
570
335
571
if(debug){
336
fprintf(stderr, "Trying to decrypt OpenPGP data\n");
572
fprintf_plus(stderr, "Trying to decrypt OpenPGP data\n");
337
573
}
338
574
339
575
/* Create new GPGME data buffer from memory cryptotext */
340
576
rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
341
577
0);
342
578
if(rc != GPG_ERR_NO_ERROR){
343
fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
344
gpgme_strsource(rc), gpgme_strerror(rc));
579
fprintf_plus(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
580
gpgme_strsource(rc), gpgme_strerror(rc));
345
581
return -1;
346
582
}
347
583
348
584
/* Create new empty GPGME data buffer for the plaintext */
349
585
rc = gpgme_data_new(&dh_plain);
350
586
if(rc != GPG_ERR_NO_ERROR){
351
fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
352
gpgme_strsource(rc), gpgme_strerror(rc));
587
fprintf_plus(stderr, "bad gpgme_data_new: %s: %s\n",
588
gpgme_strsource(rc), gpgme_strerror(rc));
353
589
gpgme_data_release(dh_crypto);
354
590
return -1;
355
591
}
356
592
357
593
/* Decrypt data from the cryptotext data buffer to the plaintext
358
594
data buffer */
359
rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
595
rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
360
596
if(rc != GPG_ERR_NO_ERROR){
361
fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
362
gpgme_strsource(rc), gpgme_strerror(rc));
597
fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
598
gpgme_strsource(rc), gpgme_strerror(rc));
363
599
plaintext_length = -1;
364
600
if(debug){
365
601
gpgme_decrypt_result_t result;
366
result = gpgme_op_decrypt_result(mc.ctx);
602
result = gpgme_op_decrypt_result(mc->ctx);
367
603
if(result == NULL){
368
fprintf(stderr, "gpgme_op_decrypt_result failed\n");
604
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
369
605
} else {
370
fprintf(stderr, "Unsupported algorithm: %s\n",
371
result->unsupported_algorithm);
372
fprintf(stderr, "Wrong key usage: %u\n",
373
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");
374
612
if(result->file_name != NULL){
375
fprintf(stderr, "File name: %s\n", result->file_name);
613
fprintf_plus(stderr, "File name: %s\n", result->file_name);
376
614
}
377
gpgme_recipient_t recipient;
378
recipient = result->recipients;
379
while(recipient != NULL){
380
fprintf(stderr, "Public key algorithm: %s\n",
381
gpgme_pubkey_algo_name(recipient->pubkey_algo));
382
fprintf(stderr, "Key ID: %s\n", recipient->keyid);
383
fprintf(stderr, "Secret key available: %s\n",
384
recipient->status == GPG_ERR_NO_SECKEY
385
? "No" : "Yes");
386
recipient = recipient->next;
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");
387
623
}
388
624
}
389
625
}
391
627
}
392
628
393
629
if(debug){
394
fprintf(stderr, "Decryption of OpenPGP data succeeded\n");
630
fprintf_plus(stderr, "Decryption of OpenPGP data succeeded\n");
395
631
}
396
632
397
633
/* Seek back to the beginning of the GPGME plaintext data buffer */
404
640
*plaintext = NULL;
405
641
while(true){
406
642
plaintext_capacity = incbuffer(plaintext,
407
(size_t)plaintext_length,
408
plaintext_capacity);
643
(size_t)plaintext_length,
644
plaintext_capacity);
409
645
if(plaintext_capacity == 0){
410
perror_plus("incbuffer");
411
plaintext_length = -1;
412
goto decrypt_end;
646
perror_plus("incbuffer");
647
plaintext_length = -1;
648
goto decrypt_end;
413
649
}
414
650
415
651
ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
428
664
}
429
665
430
666
if(debug){
431
fprintf(stderr, "Decrypted password is: ");
667
fprintf_plus(stderr, "Decrypted password is: ");
432
668
for(ssize_t i = 0; i < plaintext_length; i++){
433
669
fprintf(stderr, "%02hhX ", (*plaintext)[i]);
434
670
}
445
681
return plaintext_length;
446
682
}
447
683
448
static const char * safer_gnutls_strerror(int value){
449
const char *ret = gnutls_strerror(value); /* Spurious warning from
450
-Wunreachable-code */
451
if(ret == NULL)
452
ret = "(unknown)";
453
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);
454
695
}
455
696
456
697
/* GnuTLS log function callback */
698
__attribute__((nonnull))
457
699
static void debuggnutls(__attribute__((unused)) int level,
458
700
const char* string){
459
fprintf(stderr, "GnuTLS: %s", string);
701
fprintf_plus(stderr, "GnuTLS: %s", string);
460
702
}
461
703
704
__attribute__((nonnull(1, 2, 4), warn_unused_result))
462
705
static int init_gnutls_global(const char *pubkeyfilename,
463
const char *seckeyfilename){
706
const char *seckeyfilename,
707
const char *dhparamsfilename,
708
mandos_context *mc){
464
709
int ret;
465
710
466
711
if(debug){
467
fprintf(stderr, "Initializing GnuTLS\n");
468
}
469
470
ret = gnutls_global_init();
471
if(ret != GNUTLS_E_SUCCESS){
472
fprintf(stderr, "GnuTLS global_init: %s\n",
473
safer_gnutls_strerror(ret));
474
return -1;
712
fprintf_plus(stderr, "Initializing GnuTLS\n");
475
713
}
476
714
477
715
if(debug){
483
721
}
484
722
485
723
/* OpenPGP credentials */
486
ret = gnutls_certificate_allocate_credentials(&mc.cred);
724
ret = gnutls_certificate_allocate_credentials(&mc->cred);
487
725
if(ret != GNUTLS_E_SUCCESS){
488
fprintf(stderr, "GnuTLS memory error: %s\n",
489
safer_gnutls_strerror(ret));
490
gnutls_global_deinit();
726
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
727
safer_gnutls_strerror(ret));
491
728
return -1;
492
729
}
493
730
494
731
if(debug){
495
fprintf(stderr, "Attempting to use OpenPGP public key %s and"
496
" secret key %s as GnuTLS credentials\n", pubkeyfilename,
497
seckeyfilename);
732
fprintf_plus(stderr, "Attempting to use public key %s and"
733
" private key %s as GnuTLS credentials\n",
734
pubkeyfilename,
735
seckeyfilename);
498
736
}
499
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
500
751
ret = gnutls_certificate_set_openpgp_key_file
501
(mc.cred, pubkeyfilename, seckeyfilename,
752
(mc->cred, pubkeyfilename, seckeyfilename,
502
753
GNUTLS_OPENPGP_FMT_BASE64);
754
#else
755
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
756
#endif
503
757
if(ret != GNUTLS_E_SUCCESS){
504
fprintf(stderr,
505
"Error[%d] while reading the OpenPGP key pair ('%s',"
506
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
507
fprintf(stderr, "The GnuTLS error is: %s\n",
508
safer_gnutls_strerror(ret));
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));
509
763
goto globalfail;
510
764
}
511
765
512
766
/* GnuTLS server initialization */
513
ret = gnutls_dh_params_init(&mc.dh_params);
514
if(ret != GNUTLS_E_SUCCESS){
515
fprintf(stderr, "Error in GnuTLS DH parameter initialization:"
516
" %s\n", safer_gnutls_strerror(ret));
517
goto globalfail;
518
}
519
ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
520
if(ret != GNUTLS_E_SUCCESS){
521
fprintf(stderr, "Error in GnuTLS prime generation: %s\n",
522
safer_gnutls_strerror(ret));
523
goto globalfail;
524
}
525
526
gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
767
ret = gnutls_dh_params_init(&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
}
527
956
528
957
return 0;
529
958
530
959
globalfail:
531
960
532
gnutls_certificate_free_credentials(mc.cred);
533
gnutls_global_deinit();
534
gnutls_dh_params_deinit(mc.dh_params);
961
gnutls_certificate_free_credentials(mc->cred);
962
gnutls_dh_params_deinit(mc->dh_params);
535
963
return -1;
536
964
}
537
965
538
static int init_gnutls_session(gnutls_session_t *session){
966
__attribute__((nonnull, warn_unused_result))
967
static int init_gnutls_session(gnutls_session_t *session,
968
mandos_context *mc){
539
969
int ret;
540
970
/* GnuTLS session creation */
541
971
do {
542
ret = gnutls_init(session, GNUTLS_SERVER);
972
ret = gnutls_init(session, (GNUTLS_SERVER
973
#if GNUTLS_VERSION_NUMBER >= 0x030506
974
| GNUTLS_NO_TICKETS
975
#endif
976
#if GNUTLS_VERSION_NUMBER >= 0x030606
977
| GNUTLS_ENABLE_RAWPK
978
#endif
979
));
543
980
if(quit_now){
544
981
return -1;
545
982
}
546
983
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
547
984
if(ret != GNUTLS_E_SUCCESS){
548
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
549
safer_gnutls_strerror(ret));
985
fprintf_plus(stderr,
986
"Error in GnuTLS session initialization: %s\n",
987
safer_gnutls_strerror(ret));
550
988
}
551
989
552
990
{
553
991
const char *err;
554
992
do {
555
ret = gnutls_priority_set_direct(*session, mc.priority, &err);
993
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
556
994
if(quit_now){
557
995
gnutls_deinit(*session);
558
996
return -1;
559
997
}
560
998
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
561
999
if(ret != GNUTLS_E_SUCCESS){
562
fprintf(stderr, "Syntax error at: %s\n", err);
563
fprintf(stderr, "GnuTLS error: %s\n",
564
safer_gnutls_strerror(ret));
1000
fprintf_plus(stderr, "Syntax error at: %s\n", err);
1001
fprintf_plus(stderr, "GnuTLS error: %s\n",
1002
safer_gnutls_strerror(ret));
565
1003
gnutls_deinit(*session);
566
1004
return -1;
567
1005
}
569
1007
570
1008
do {
571
1009
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
572
mc.cred);
1010
mc->cred);
573
1011
if(quit_now){
574
1012
gnutls_deinit(*session);
575
1013
return -1;
576
1014
}
577
1015
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
578
1016
if(ret != GNUTLS_E_SUCCESS){
579
fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
580
safer_gnutls_strerror(ret));
1017
fprintf_plus(stderr, "Error setting GnuTLS credentials: %s\n",
1018
safer_gnutls_strerror(ret));
581
1019
gnutls_deinit(*session);
582
1020
return -1;
583
1021
}
585
1023
/* ignore client certificate if any. */
586
1024
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
587
1025
588
gnutls_dh_set_prime_bits(*session, mc.dh_bits);
589
590
1026
return 0;
591
1027
}
592
1028
594
1030
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
595
1031
__attribute__((unused)) const char *txt){}
596
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
597
1199
/* Called when a Mandos server is found */
598
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,
599
1202
AvahiIfIndex if_index,
600
int af){
1203
int af, mandos_context *mc){
601
1204
int ret, tcp_sd = -1;
602
1205
ssize_t sret;
603
union {
604
struct sockaddr_in in;
605
struct sockaddr_in6 in6;
606
} to;
1206
struct sockaddr_storage to;
607
1207
char *buffer = NULL;
608
1208
char *decrypted_buffer = NULL;
609
1209
size_t buffer_length = 0;
612
1212
int retval = -1;
613
1213
gnutls_session_t session;
614
1214
int pf; /* Protocol family */
1215
bool route_added = false;
615
1216
616
1217
errno = 0;
617
1218
628
1229
pf = PF_INET;
629
1230
break;
630
1231
default:
631
fprintf(stderr, "Bad address family: %d\n", af);
1232
fprintf_plus(stderr, "Bad address family: %d\n", af);
632
1233
errno = EINVAL;
633
1234
return -1;
634
1235
}
635
1236
636
ret = init_gnutls_session(&session);
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
}
1266
return -1;
1267
}
1268
}
1269
1270
ret = init_gnutls_session(&session, mc);
637
1271
if(ret != 0){
638
1272
return -1;
639
1273
}
640
1274
641
1275
if(debug){
642
fprintf(stderr, "Setting up a TCP connection to %s, port %" PRIu16
643
"\n", ip, port);
1276
fprintf_plus(stderr, "Setting up a TCP connection to %s, port %"
1277
PRIuMAX "\n", ip, (uintmax_t)port);
644
1278
}
645
1279
646
tcp_sd = socket(pf, SOCK_STREAM, 0);
1280
tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
647
1281
if(tcp_sd < 0){
648
1282
int e = errno;
649
1283
perror_plus("socket");
656
1290
goto mandos_end;
657
1291
}
658
1292
659
memset(&to, 0, sizeof(to));
660
1293
if(af == AF_INET6){
661
to.in6.sin6_family = (sa_family_t)af;
662
ret = inet_pton(af, ip, &to.in6.sin6_addr);
1294
struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)&to;
1295
*to6 = (struct sockaddr_in6){ .sin6_family = (sa_family_t)af };
1296
ret = inet_pton(af, ip, &to6->sin6_addr);
663
1297
} else { /* IPv4 */
664
to.in.sin_family = (sa_family_t)af;
665
ret = inet_pton(af, ip, &to.in.sin_addr);
1298
struct sockaddr_in *to4 = (struct sockaddr_in *)&to;
1299
*to4 = (struct sockaddr_in){ .sin_family = (sa_family_t)af };
1300
ret = inet_pton(af, ip, &to4->sin_addr);
666
1301
}
667
1302
if(ret < 0 ){
668
1303
int e = errno;
672
1307
}
673
1308
if(ret == 0){
674
1309
int e = errno;
675
fprintf(stderr, "Bad address: %s\n", ip);
1310
fprintf_plus(stderr, "Bad address: %s\n", ip);
676
1311
errno = e;
677
1312
goto mandos_end;
678
1313
}
679
1314
if(af == AF_INET6){
680
to.in6.sin6_port = htons(port); /* Spurious warnings from
681
-Wconversion and
682
-Wunreachable-code */
683
684
if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
685
(&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
686
-Wunreachable-code*/
1315
((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
1316
if(IN6_IS_ADDR_LINKLOCAL
1317
(&((struct sockaddr_in6 *)&to)->sin6_addr)){
687
1318
if(if_index == AVAHI_IF_UNSPEC){
688
fprintf(stderr, "An IPv6 link-local address is incomplete"
689
" without a network interface\n");
1319
fprintf_plus(stderr, "An IPv6 link-local address is"
1320
" incomplete without a network interface\n");
690
1321
errno = EINVAL;
691
1322
goto mandos_end;
692
1323
}
693
1324
/* Set the network interface number as scope */
694
to.in6.sin6_scope_id = (uint32_t)if_index;
1325
((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
695
1326
}
696
1327
} else {
697
to.in.sin_port = htons(port); /* Spurious warnings from
698
-Wconversion and
699
-Wunreachable-code */
1328
((struct sockaddr_in *)&to)->sin_port = htons(port);
700
1329
}
701
1330
702
1331
if(quit_now){
710
1339
if(if_indextoname((unsigned int)if_index, interface) == NULL){
711
1340
perror_plus("if_indextoname");
712
1341
} else {
713
fprintf(stderr, "Connection to: %s%%%s, port %" PRIu16 "\n",
714
ip, interface, port);
1342
fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIuMAX
1343
"\n", ip, interface, (uintmax_t)port);
715
1344
}
716
1345
} else {
717
fprintf(stderr, "Connection to: %s, port %" PRIu16 "\n", ip,
718
port);
1346
fprintf_plus(stderr, "Connection to: %s, port %" PRIuMAX "\n",
1347
ip, (uintmax_t)port);
719
1348
}
720
1349
char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
721
1350
INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
722
const char *pcret;
723
if(af == AF_INET6){
724
pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
725
sizeof(addrstr));
726
} else {
727
pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
728
sizeof(addrstr));
729
}
730
if(pcret == NULL){
731
perror_plus("inet_ntop");
732
} else {
733
if(strcmp(addrstr, ip) != 0){
734
fprintf(stderr, "Canonical address form: %s\n", addrstr);
735
}
736
}
737
}
738
739
if(quit_now){
740
errno = EINTR;
741
goto mandos_end;
742
}
743
744
if(af == AF_INET6){
745
ret = connect(tcp_sd, &to.in6, sizeof(to));
746
} else {
747
ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
748
}
749
if(ret < 0){
750
if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
751
int e = errno;
752
perror_plus("connect");
753
errno = e;
754
}
755
goto mandos_end;
756
}
757
758
if(quit_now){
759
errno = EINTR;
760
goto mandos_end;
1351
if(af == AF_INET6){
1352
ret = getnameinfo((struct sockaddr *)&to,
1353
sizeof(struct sockaddr_in6),
1354
addrstr, sizeof(addrstr), NULL, 0,
1355
NI_NUMERICHOST);
1356
} else {
1357
ret = getnameinfo((struct sockaddr *)&to,
1358
sizeof(struct sockaddr_in),
1359
addrstr, sizeof(addrstr), NULL, 0,
1360
NI_NUMERICHOST);
1361
}
1362
if(ret == EAI_SYSTEM){
1363
perror_plus("getnameinfo");
1364
} else if(ret != 0) {
1365
fprintf_plus(stderr, "getnameinfo: %s", gai_strerror(ret));
1366
} else if(strcmp(addrstr, ip) != 0){
1367
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
1368
}
1369
}
1370
1371
if(quit_now){
1372
errno = EINTR;
1373
goto mandos_end;
1374
}
1375
1376
while(true){
1377
if(af == AF_INET6){
1378
ret = connect(tcp_sd, (struct sockaddr *)&to,
1379
sizeof(struct sockaddr_in6));
1380
} else {
1381
ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
1382
sizeof(struct sockaddr_in));
1383
}
1384
if(ret < 0){
1385
if(((errno == ENETUNREACH) or (errno == EHOSTUNREACH))
1386
and if_index != AVAHI_IF_UNSPEC
1387
and connect_to == NULL
1388
and not route_added and
1389
((af == AF_INET6 and not
1390
IN6_IS_ADDR_LINKLOCAL(&(((struct sockaddr_in6 *)
1391
&to)->sin6_addr)))
1392
or (af == AF_INET and
1393
/* Not a a IPv4LL address */
1394
(ntohl(((struct sockaddr_in *)&to)->sin_addr.s_addr)
1395
& 0xFFFF0000L) != 0xA9FE0000L))){
1396
/* Work around Avahi bug - Avahi does not announce link-local
1397
addresses if it has a global address, so local hosts with
1398
*only* a link-local address (e.g. Mandos clients) cannot
1399
connect to a Mandos server announced by Avahi on a server
1400
host with a global address. Work around this by retrying
1401
with an explicit route added with the server's address.
1402
1403
Avahi bug reference:
1404
https://lists.freedesktop.org/archives/avahi/2010-February/001833.html
1405
https://bugs.debian.org/587961
1406
*/
1407
if(debug){
1408
fprintf_plus(stderr, "Mandos server unreachable, trying"
1409
" direct route\n");
1410
}
1411
int e = errno;
1412
route_added = add_local_route(ip, if_index);
1413
if(route_added){
1414
continue;
1415
}
1416
errno = e;
1417
}
1418
if(errno != ECONNREFUSED or debug){
1419
int e = errno;
1420
perror_plus("connect");
1421
errno = e;
1422
}
1423
goto mandos_end;
1424
}
1425
1426
if(quit_now){
1427
errno = EINTR;
1428
goto mandos_end;
1429
}
1430
break;
761
1431
}
762
1432
763
1433
const char *out = mandos_protocol_version;
765
1435
while(true){
766
1436
size_t out_size = strlen(out);
767
1437
ret = (int)TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
768
out_size - written));
1438
out_size - written));
769
1439
if(ret == -1){
770
1440
int e = errno;
771
1441
perror_plus("write");
791
1461
}
792
1462
793
1463
if(debug){
794
fprintf(stderr, "Establishing TLS session with %s\n", ip);
1464
fprintf_plus(stderr, "Establishing TLS session with %s\n", ip);
795
1465
}
796
1466
797
1467
if(quit_now){
799
1469
goto mandos_end;
800
1470
}
801
1471
802
/* Spurious warning from -Wint-to-pointer-cast */
803
gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
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);
804
1477
805
1478
if(quit_now){
806
1479
errno = EINTR;
817
1490
818
1491
if(ret != GNUTLS_E_SUCCESS){
819
1492
if(debug){
820
fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
1493
fprintf_plus(stderr, "*** GnuTLS Handshake failed ***\n");
821
1494
gnutls_perror(ret);
822
1495
}
823
1496
errno = EPROTO;
827
1500
/* Read OpenPGP packet that contains the wanted password */
828
1501
829
1502
if(debug){
830
fprintf(stderr, "Retrieving OpenPGP encrypted password from %s\n",
831
ip);
1503
fprintf_plus(stderr, "Retrieving OpenPGP encrypted password from"
1504
" %s\n", ip);
832
1505
}
833
1506
834
1507
while(true){
839
1512
}
840
1513
841
1514
buffer_capacity = incbuffer(&buffer, buffer_length,
842
buffer_capacity);
1515
buffer_capacity);
843
1516
if(buffer_capacity == 0){
844
1517
int e = errno;
845
1518
perror_plus("incbuffer");
872
1545
}
873
1546
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
874
1547
if(ret < 0){
875
fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
1548
fprintf_plus(stderr, "*** GnuTLS Re-handshake failed "
1549
"***\n");
876
1550
gnutls_perror(ret);
877
1551
errno = EPROTO;
878
1552
goto mandos_end;
879
1553
}
880
1554
break;
881
1555
default:
882
fprintf(stderr, "Unknown error while reading data from"
883
" encrypted session with Mandos server\n");
1556
fprintf_plus(stderr, "Unknown error while reading data from"
1557
" encrypted session with Mandos server\n");
884
1558
gnutls_bye(session, GNUTLS_SHUT_RDWR);
885
1559
errno = EIO;
886
1560
goto mandos_end;
891
1565
}
892
1566
893
1567
if(debug){
894
fprintf(stderr, "Closing TLS session\n");
1568
fprintf_plus(stderr, "Closing TLS session\n");
895
1569
}
896
1570
897
1571
if(quit_now){
909
1583
910
1584
if(buffer_length > 0){
911
1585
ssize_t decrypted_buffer_size;
912
decrypted_buffer_size = pgp_packet_decrypt(buffer,
913
buffer_length,
914
&decrypted_buffer);
1586
decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
1587
&decrypted_buffer, mc);
915
1588
if(decrypted_buffer_size >= 0){
916
1589
1590
clearerr(stdout);
917
1591
written = 0;
918
1592
while(written < (size_t) decrypted_buffer_size){
919
1593
if(quit_now){
927
1601
if(ret == 0 and ferror(stdout)){
928
1602
int e = errno;
929
1603
if(debug){
930
fprintf(stderr, "Error writing encrypted data: %s\n",
931
strerror(errno));
1604
fprintf_plus(stderr, "Error writing encrypted data: %s\n",
1605
strerror(errno));
932
1606
}
933
1607
errno = e;
934
1608
goto mandos_end;
935
1609
}
936
1610
written += (size_t)ret;
937
1611
}
1612
ret = fflush(stdout);
1613
if(ret != 0){
1614
int e = errno;
1615
if(debug){
1616
fprintf_plus(stderr, "Error writing encrypted data: %s\n",
1617
strerror(errno));
1618
}
1619
errno = e;
1620
goto mandos_end;
1621
}
938
1622
retval = 0;
939
1623
}
940
1624
}
943
1627
944
1628
mandos_end:
945
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
}
946
1636
int e = errno;
947
1637
free(decrypted_buffer);
948
1638
free(buffer);
949
1639
if(tcp_sd >= 0){
950
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
1640
ret = close(tcp_sd);
951
1641
}
952
1642
if(ret == -1){
953
1643
if(e == 0){
978
1668
AVAHI_GCC_UNUSED AvahiStringList *txt,
979
1669
AVAHI_GCC_UNUSED AvahiLookupResultFlags
980
1670
flags,
981
AVAHI_GCC_UNUSED void* userdata){
982
assert(r);
1671
void *mc){
1672
if(r == NULL){
1673
return;
1674
}
983
1675
984
1676
/* Called whenever a service has been resolved successfully or
985
1677
timed out */
986
1678
987
1679
if(quit_now){
1680
avahi_s_service_resolver_free(r);
988
1681
return;
989
1682
}
990
1683
991
1684
switch(event){
992
1685
default:
993
1686
case AVAHI_RESOLVER_FAILURE:
994
fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
995
" of type '%s' in domain '%s': %s\n", name, type, domain,
996
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)));
997
1692
break;
998
1693
999
1694
case AVAHI_RESOLVER_FOUND:
1001
1696
char ip[AVAHI_ADDRESS_STR_MAX];
1002
1697
avahi_address_snprint(ip, sizeof(ip), address);
1003
1698
if(debug){
1004
fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %"
1005
PRIdMAX ") on port %" PRIu16 "\n", name, host_name,
1006
ip, (intmax_t)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);
1007
1702
}
1008
int ret = start_mandos_communication(ip, port, interface,
1009
avahi_proto_to_af(proto));
1703
int ret = start_mandos_communication(ip, (in_port_t)port,
1704
interface,
1705
avahi_proto_to_af(proto),
1706
mc);
1010
1707
if(ret == 0){
1011
avahi_simple_poll_quit(mc.simple_poll);
1708
avahi_simple_poll_quit(simple_poll);
1012
1709
} else {
1013
ret = add_server(ip, port, interface,
1014
avahi_proto_to_af(proto));
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
}
1015
1716
}
1016
1717
}
1017
1718
}
1027
1728
const char *domain,
1028
1729
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1029
1730
flags,
1030
AVAHI_GCC_UNUSED void* userdata){
1031
assert(b);
1731
void *mc){
1732
if(b == NULL){
1733
return;
1734
}
1032
1735
1033
1736
/* Called whenever a new services becomes available on the LAN or
1034
1737
is removed from the LAN */
1041
1744
default:
1042
1745
case AVAHI_BROWSER_FAILURE:
1043
1746
1044
fprintf(stderr, "(Avahi browser) %s\n",
1045
avahi_strerror(avahi_server_errno(mc.server)));
1046
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);
1047
1751
return;
1048
1752
1049
1753
case AVAHI_BROWSER_NEW:
1052
1756
the callback function is called the Avahi server will free the
1053
1757
resolver for us. */
1054
1758
1055
if(avahi_s_service_resolver_new(mc.server, interface, protocol,
1056
name, type, domain, protocol, 0,
1057
resolve_callback, NULL) == NULL)
1058
fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
1059
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)));
1060
1767
break;
1061
1768
1062
1769
case AVAHI_BROWSER_REMOVE:
1065
1772
case AVAHI_BROWSER_ALL_FOR_NOW:
1066
1773
case AVAHI_BROWSER_CACHE_EXHAUSTED:
1067
1774
if(debug){
1068
fprintf(stderr, "No Mandos server found, still searching...\n");
1775
fprintf_plus(stderr, "No Mandos server found, still"
1776
" searching...\n");
1069
1777
}
1070
1778
break;
1071
1779
}
1080
1788
signal_received = sig;
1081
1789
int old_errno = errno;
1082
1790
/* set main loop to exit */
1083
if(mc.simple_poll != NULL){
1084
avahi_simple_poll_quit(mc.simple_poll);
1791
if(simple_poll != NULL){
1792
avahi_simple_poll_quit(simple_poll);
1085
1793
}
1086
1794
errno = old_errno;
1087
1795
}
1088
1796
1797
__attribute__((nonnull, warn_unused_result))
1089
1798
bool get_flags(const char *ifname, struct ifreq *ifr){
1090
1799
int ret;
1800
int old_errno;
1091
1801
1092
1802
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1093
1803
if(s < 0){
1804
old_errno = errno;
1094
1805
perror_plus("socket");
1806
errno = old_errno;
1095
1807
return false;
1096
1808
}
1097
strcpy(ifr->ifr_name, ifname);
1809
strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
1810
ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
1098
1811
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1099
1812
if(ret == -1){
1100
1813
if(debug){
1814
old_errno = errno;
1101
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;
1102
1822
}
1103
1823
return false;
1104
1824
}
1825
if((close(s) == -1) and debug){
1826
old_errno = errno;
1827
perror_plus("close");
1828
errno = old_errno;
1829
}
1105
1830
return true;
1106
1831
}
1107
1832
1833
__attribute__((nonnull, warn_unused_result))
1108
1834
bool good_flags(const char *ifname, const struct ifreq *ifr){
1109
1835
1110
1836
/* Reject the loopback device */
1111
1837
if(ifr->ifr_flags & IFF_LOOPBACK){
1112
1838
if(debug){
1113
fprintf(stderr, "Rejecting loopback interface \"%s\"\n",
1114
ifname);
1839
fprintf_plus(stderr, "Rejecting loopback interface \"%s\"\n",
1840
ifname);
1115
1841
}
1116
1842
return false;
1117
1843
}
1118
1844
/* Accept point-to-point devices only if connect_to is specified */
1119
1845
if(connect_to != NULL and (ifr->ifr_flags & IFF_POINTOPOINT)){
1120
1846
if(debug){
1121
fprintf(stderr, "Accepting point-to-point interface \"%s\"\n",
1122
ifname);
1847
fprintf_plus(stderr, "Accepting point-to-point interface"
1848
" \"%s\"\n", ifname);
1123
1849
}
1124
1850
return true;
1125
1851
}
1126
1852
/* Otherwise, reject non-broadcast-capable devices */
1127
1853
if(not (ifr->ifr_flags & IFF_BROADCAST)){
1128
1854
if(debug){
1129
fprintf(stderr, "Rejecting non-broadcast interface \"%s\"\n",
1130
ifname);
1855
fprintf_plus(stderr, "Rejecting non-broadcast interface"
1856
" \"%s\"\n", ifname);
1131
1857
}
1132
1858
return false;
1133
1859
}
1134
1860
/* Reject non-ARP interfaces (including dummy interfaces) */
1135
1861
if(ifr->ifr_flags & IFF_NOARP){
1136
1862
if(debug){
1137
fprintf(stderr, "Rejecting non-ARP interface \"%s\"\n", ifname);
1863
fprintf_plus(stderr, "Rejecting non-ARP interface \"%s\"\n",
1864
ifname);
1138
1865
}
1139
1866
return false;
1140
1867
}
1141
1868
1142
1869
/* Accept this device */
1143
1870
if(debug){
1144
fprintf(stderr, "Interface \"%s\" is good\n", ifname);
1871
fprintf_plus(stderr, "Interface \"%s\" is good\n", ifname);
1145
1872
}
1146
1873
return true;
1147
1874
}
1151
1878
* corresponds to an acceptable network device.
1152
1879
* (This function is passed to scandir(3) as a filter function.)
1153
1880
*/
1881
__attribute__((nonnull, warn_unused_result))
1154
1882
int good_interface(const struct dirent *if_entry){
1155
int ret;
1156
1883
if(if_entry->d_name[0] == '.'){
1157
1884
return 0;
1158
1885
}
1886
1159
1887
struct ifreq ifr;
1160
1161
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
}
1162
1893
return 0;
1163
1894
}
1164
1895
1169
1900
}
1170
1901
1171
1902
/*
1172
* This function determines if a directory entry in /sys/class/net
1173
* corresponds to an acceptable network device which is up.
1174
* (This function is passed to scandir(3) as a filter function.)
1175
*/
1176
int up_interface(const struct dirent *if_entry){
1177
ssize_t ssret;
1178
char *flagname = NULL;
1179
if(if_entry->d_name[0] == '.'){
1180
return 0;
1181
}
1182
int ret = asprintf(&flagname, "%s/%s/flags", sys_class_net,
1183
if_entry->d_name);
1184
if(ret < 0){
1185
perror_plus("asprintf");
1186
return 0;
1187
}
1188
int flags_fd = (int)TEMP_FAILURE_RETRY(open(flagname, O_RDONLY));
1189
if(flags_fd == -1){
1190
perror_plus("open");
1191
free(flagname);
1192
return 0;
1193
}
1194
free(flagname);
1195
typedef short ifreq_flags; /* ifreq.ifr_flags in netdevice(7) */
1196
/* read line from flags_fd */
1197
ssize_t to_read = 2+(sizeof(ifreq_flags)*2)+1; /* "0x1003\n" */
1198
char *flagstring = malloc((size_t)to_read+1); /* +1 for final \0 */
1199
flagstring[(size_t)to_read] = '\0';
1200
if(flagstring == NULL){
1201
perror_plus("malloc");
1202
close(flags_fd);
1203
return 0;
1204
}
1205
while(to_read > 0){
1206
ssret = (ssize_t)TEMP_FAILURE_RETRY(read(flags_fd, flagstring,
1207
(size_t)to_read));
1208
if(ssret == -1){
1209
perror_plus("read");
1210
free(flagstring);
1211
close(flags_fd);
1212
return 0;
1213
}
1214
to_read -= ssret;
1215
if(ssret == 0){
1216
break;
1217
}
1218
}
1219
close(flags_fd);
1220
intmax_t tmpmax;
1221
char *tmp;
1222
errno = 0;
1223
tmpmax = strtoimax(flagstring, &tmp, 0);
1224
if(errno != 0 or tmp == flagstring or (*tmp != '\0'
1225
and not (isspace(*tmp)))
1226
or tmpmax != (ifreq_flags)tmpmax){
1227
if(debug){
1228
fprintf(stderr, "Invalid flags \"%s\" for interface \"%s\"\n",
1229
flagstring, if_entry->d_name);
1230
}
1231
free(flagstring);
1232
return 0;
1233
}
1234
free(flagstring);
1235
ifreq_flags flags = (ifreq_flags)tmpmax;
1236
/* Reject the loopback device */
1237
if(flags & IFF_LOOPBACK){
1238
if(debug){
1239
fprintf(stderr, "Rejecting loopback interface \"%s\"\n",
1240
if_entry->d_name);
1241
}
1242
return 0;
1243
}
1244
1245
/* Reject down interfaces */
1246
if(not (flags & IFF_UP)){
1247
return 0;
1248
}
1249
1250
/* Accept point-to-point devices only if connect_to is specified */
1251
if(connect_to != NULL and (flags & IFF_POINTOPOINT)){
1252
if(debug){
1253
fprintf(stderr, "Accepting point-to-point interface \"%s\"\n",
1254
if_entry->d_name);
1255
}
1256
return 1;
1257
}
1258
/* Otherwise, reject non-broadcast-capable devices */
1259
if(not (flags & IFF_BROADCAST)){
1260
if(debug){
1261
fprintf(stderr, "Rejecting non-broadcast interface \"%s\"\n",
1262
if_entry->d_name);
1263
}
1264
return 0;
1265
}
1266
/* Reject non-ARP interfaces (including dummy interfaces) */
1267
if(flags & IFF_NOARP){
1268
if(debug){
1269
fprintf(stderr, "Rejecting non-ARP interface \"%s\"\n",
1270
if_entry->d_name);
1271
}
1272
return 0;
1273
}
1274
/* Accept this device */
1275
if(debug){
1276
fprintf(stderr, "Interface \"%s\" is acceptable\n",
1277
if_entry->d_name);
1278
}
1279
return 1;
1280
}
1281
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))
1282
1937
int notdotentries(const struct dirent *direntry){
1283
1938
/* Skip "." and ".." */
1284
1939
if(direntry->d_name[0] == '.'
1291
1946
}
1292
1947
1293
1948
/* Is this directory entry a runnable program? */
1949
__attribute__((nonnull, warn_unused_result))
1294
1950
int runnable_hook(const struct dirent *direntry){
1295
1951
int ret;
1952
size_t sret;
1296
1953
struct stat st;
1297
1954
1298
1955
if((direntry->d_name)[0] == '\0'){
1300
1957
return 0;
1301
1958
}
1302
1959
1303
/* Save pointer to last character */
1304
char *end = strchr(direntry->d_name, '\0')-1;
1305
1306
if(*end == '~'){
1307
/* Backup name~ */
1308
return 0;
1309
}
1310
1311
if(((direntry->d_name)[0] == '#')
1312
and (*end == '#')){
1313
/* Temporary #name# */
1314
return 0;
1315
}
1316
1317
/* XXX more rules here */
1318
1319
ret = stat(direntry->d_name, &st);
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);
1320
1974
if(ret == -1){
1321
1975
if(debug){
1322
perror_plus("Could not stat plugin");
1976
perror_plus("Could not stat hook");
1323
1977
}
1324
1978
return 0;
1325
1979
}
1326
if(not (st.st_mode & S_ISREG)){
1980
if(not (S_ISREG(st.st_mode))){
1327
1981
/* Not a regular file */
1982
if(debug){
1983
fprintf_plus(stderr, "Ignoring hook \"%s\" - not a file\n",
1984
direntry->d_name);
1985
}
1328
1986
return 0;
1329
1987
}
1330
1988
if(not (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))){
1331
1989
/* Not executable */
1990
if(debug){
1991
fprintf_plus(stderr, "Ignoring hook \"%s\" - not executable\n",
1992
direntry->d_name);
1993
}
1332
1994
return 0;
1333
1995
}
1996
if(debug){
1997
fprintf_plus(stderr, "Hook \"%s\" is acceptable\n",
1998
direntry->d_name);
1999
}
1334
2000
return 1;
1335
2001
}
1336
2002
1337
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval){
2003
__attribute__((nonnull, warn_unused_result))
2004
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
2005
mandos_context *mc){
1338
2006
int ret;
1339
2007
struct timespec now;
1340
2008
struct timespec waited_time;
1341
2009
intmax_t block_time;
1342
2010
1343
2011
while(true){
1344
if(mc.current_server == NULL){
1345
if (debug){
1346
fprintf(stderr,
1347
"Wait until first server is found. No timeout!\n");
2012
if(mc->current_server == NULL){
2013
if(debug){
2014
fprintf_plus(stderr, "Wait until first server is found."
2015
" No timeout!\n");
1348
2016
}
1349
2017
ret = avahi_simple_poll_iterate(s, -1);
1350
2018
} else {
1351
if (debug){
1352
fprintf(stderr, "Check current_server if we should run it,"
1353
" or wait\n");
2019
if(debug){
2020
fprintf_plus(stderr, "Check current_server if we should run"
2021
" it, or wait\n");
1354
2022
}
1355
2023
/* the current time */
1356
2024
ret = clock_gettime(CLOCK_MONOTONIC, &now);
1361
2029
/* Calculating in ms how long time between now and server
1362
2030
who we visted longest time ago. Now - last seen. */
1363
2031
waited_time.tv_sec = (now.tv_sec
1364
- mc.current_server->last_seen.tv_sec);
2032
- mc->current_server->last_seen.tv_sec);
1365
2033
waited_time.tv_nsec = (now.tv_nsec
1366
- mc.current_server->last_seen.tv_nsec);
2034
- mc->current_server->last_seen.tv_nsec);
1367
2035
/* total time is 10s/10,000ms.
1368
2036
Converting to s from ms by dividing by 1,000,
1369
2037
and ns to ms by dividing by 1,000,000. */
1371
2039
- ((intmax_t)waited_time.tv_sec * 1000))
1372
2040
- ((intmax_t)waited_time.tv_nsec / 1000000));
1373
2041
1374
if (debug){
1375
fprintf(stderr, "Blocking for %" PRIdMAX " ms\n", block_time);
2042
if(debug){
2043
fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
2044
block_time);
1376
2045
}
1377
2046
1378
2047
if(block_time <= 0){
1379
ret = start_mandos_communication(mc.current_server->ip,
1380
mc.current_server->port,
1381
mc.current_server->if_index,
1382
mc.current_server->af);
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);
1383
2052
if(ret == 0){
1384
avahi_simple_poll_quit(mc.simple_poll);
2053
avahi_simple_poll_quit(s);
1385
2054
return 0;
1386
2055
}
1387
2056
ret = clock_gettime(CLOCK_MONOTONIC,
1388
&mc.current_server->last_seen);
2057
&mc->current_server->last_seen);
1389
2058
if(ret == -1){
1390
2059
perror_plus("clock_gettime");
1391
2060
return -1;
1392
2061
}
1393
mc.current_server = mc.current_server->next;
2062
mc->current_server = mc->current_server->next;
1394
2063
block_time = 0; /* Call avahi to find new Mandos
1395
2064
servers, but don't block */
1396
2065
}
1398
2067
ret = avahi_simple_poll_iterate(s, (int)block_time);
1399
2068
}
1400
2069
if(ret != 0){
1401
if (ret > 0 or errno != EINTR) {
2070
if(ret > 0 or errno != EINTR){
1402
2071
return (ret != 1) ? ret : 0;
1403
2072
}
1404
2073
}
1405
2074
}
1406
2075
}
1407
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
1408
2462
int main(int argc, char *argv[]){
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 };
1409
2476
AvahiSServiceBrowser *sb = NULL;
1410
int error;
2477
error_t ret_errno;
1411
2478
int ret;
1412
2479
intmax_t tmpmax;
1413
2480
char *tmp;
1414
2481
int exitcode = EXIT_SUCCESS;
1415
const char *interface = "";
1416
struct ifreq network;
1417
int sd = -1;
1418
bool take_down_interface = false;
1419
uid_t uid;
1420
gid_t gid;
1421
char tempdir[] = "/tmp/mandosXXXXXX";
1422
bool tempdir_created = false;
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;
1423
2487
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1424
2488
const char *seckey = PATHDIR "/" SECKEY;
1425
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;
1426
2496
1427
2497
bool gnutls_initialized = false;
1428
2498
bool gpgme_initialized = false;
1474
2544
{ .name = "pubkey", .key = 'p',
1475
2545
.arg = "FILE",
1476
2546
.doc = "OpenPGP public key file base name",
1477
.group = 2 },
2547
.group = 1 },
2548
{ .name = "tls-privkey", .key = 't',
2549
.arg = "FILE",
2550
#if GNUTLS_VERSION_NUMBER >= 0x030606
2551
.doc = "TLS private key file base name",
2552
#else
2553
.doc = "Dummy; ignored (requires GnuTLS 3.6.6)",
2554
#endif
2555
.group = 1 },
2556
{ .name = "tls-pubkey", .key = 'T',
2557
.arg = "FILE",
2558
#if GNUTLS_VERSION_NUMBER >= 0x030606
2559
.doc = "TLS public key file base name",
2560
#else
2561
.doc = "Dummy; ignored (requires GnuTLS 3.6.6)",
2562
#endif
2563
.group = 1 },
1478
2564
{ .name = "dh-bits", .key = 129,
1479
2565
.arg = "BITS",
1480
2566
.doc = "Bit length of the prime number used in the"
1481
2567
" Diffie-Hellman key exchange",
1482
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 },
1483
2574
{ .name = "priority", .key = 130,
1484
2575
.arg = "STRING",
1485
2576
.doc = "GnuTLS priority string for the TLS handshake",
1490
2581
.group = 2 },
1491
2582
{ .name = "retry", .key = 132,
1492
2583
.arg = "SECONDS",
1493
.doc = "Retry interval used when denied by the mandos server",
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",
1494
2589
.group = 2 },
1495
2590
/*
1496
2591
* These reproduce what we would get without ARGP_NO_HELP
1515
2610
connect_to = arg;
1516
2611
break;
1517
2612
case 'i': /* --interface */
1518
interface = arg;
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
}
1519
2618
break;
1520
2619
case 's': /* --seckey */
1521
2620
seckey = arg;
1523
2622
case 'p': /* --pubkey */
1524
2623
pubkey = arg;
1525
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;
1526
2635
case 129: /* --dh-bits */
1527
2636
errno = 0;
1528
2637
tmpmax = strtoimax(arg, &tmp, 10);
1532
2641
}
1533
2642
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
1534
2643
break;
2644
case 134: /* --dh-params */
2645
dh_params_file = arg;
2646
break;
1535
2647
case 130: /* --priority */
1536
2648
mc.priority = arg;
1537
2649
break;
1550
2662
argp_error(state, "Bad retry interval");
1551
2663
}
1552
2664
break;
2665
case 133: /* --network-hook-dir */
2666
hookdir = arg;
2667
break;
1553
2668
/*
1554
2669
* These reproduce what we would get without ARGP_NO_HELP
1555
2670
*/
1561
2676
argp_state_help(state, state->out_stream,
1562
2677
ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
1563
2678
case 'V': /* --version */
1564
fprintf(state->out_stream, "%s\n", argp_program_version);
2679
fprintf_plus(state->out_stream, "%s\n", argp_program_version);
1565
2680
exit(argp_err_exit_status);
1566
2681
break;
1567
2682
default:
1574
2689
.args_doc = "",
1575
2690
.doc = "Mandos client -- Get and decrypt"
1576
2691
" passwords from a Mandos server" };
1577
ret = argp_parse(&argp, argc, argv,
1578
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
1579
switch(ret){
2692
ret_errno = argp_parse(&argp, argc, argv,
2693
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2694
switch(ret_errno){
1580
2695
case 0:
1581
2696
break;
1582
2697
case ENOMEM:
1583
2698
default:
1584
errno = ret;
2699
errno = ret_errno;
1585
2700
perror_plus("argp_parse");
1586
2701
exitcode = EX_OSERR;
1587
2702
goto end;
1590
2705
goto end;
1591
2706
}
1592
2707
}
1593
2708
1594
2709
{
1595
2710
/* Work around Debian bug #633582:
1596
<http://bugs.debian.org/633582> */
1597
struct stat st;
1598
1599
/* Re-raise priviliges */
1600
errno = 0;
1601
ret = seteuid(0);
1602
if(ret == -1){
1603
perror_plus("seteuid");
1604
}
1605
1606
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
1607
int seckey_fd = open(seckey, O_RDONLY);
1608
if(seckey_fd == -1){
1609
perror_plus("open");
1610
} else {
1611
ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
1612
if(ret == -1){
1613
perror_plus("fstat");
1614
} else {
1615
if(S_ISREG(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
1616
ret = fchown(seckey_fd, uid, gid);
1617
if(ret == -1){
1618
perror_plus("fchown");
1619
}
1620
}
1621
}
1622
TEMP_FAILURE_RETRY(close(seckey_fd));
1623
}
1624
}
1625
1626
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
1627
int pubkey_fd = open(pubkey, O_RDONLY);
1628
if(pubkey_fd == -1){
1629
perror_plus("open");
1630
} else {
1631
ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
1632
if(ret == -1){
1633
perror_plus("fstat");
1634
} else {
1635
if(S_ISREG(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
1636
ret = fchown(pubkey_fd, uid, gid);
1637
if(ret == -1){
1638
perror_plus("fchown");
1639
}
1640
}
1641
}
1642
TEMP_FAILURE_RETRY(close(pubkey_fd));
1643
}
1644
}
1645
1646
/* Lower privileges */
1647
errno = 0;
1648
ret = seteuid(uid);
1649
if(ret == -1){
1650
perror_plus("seteuid");
1651
}
1652
}
1653
1654
/* Find network hooks and run them */
1655
{
1656
struct dirent **direntries;
1657
struct dirent *direntry;
1658
int numhooks = scandir(HOOKDIR, &direntries, runnable_hook,
1659
alphasort);
1660
int devnull = open("/dev/null", O_RDONLY);
1661
for(int i = 0; i < numhooks; i++){
1662
direntry = direntries[0];
1663
char *fullname = NULL;
1664
ret = asprintf(&fullname, "%s/%s", tempdir,
1665
direntry->d_name);
1666
if(ret < 0){
1667
perror_plus("asprintf");
1668
continue;
1669
}
1670
pid_t hook_pid = fork();
1671
if(hook_pid == 0){
1672
/* Child */
1673
dup2(devnull, STDIN_FILENO);
1674
close(devnull);
1675
dup2(STDERR_FILENO, STDOUT_FILENO);
1676
setenv("DEVICE", interface, 1);
1677
setenv("VERBOSE", debug ? "1" : "0", 1);
1678
setenv("MODE", "start", 1);
1679
/* setenv( XXX more here */
1680
ret = execl(fullname, direntry->d_name, "start");
1681
perror_plus("execl");
1682
}
1683
free(fullname);
1684
if(quit_now){
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");
1685
2817
goto end;
1686
2818
}
2819
memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
2820
argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
1687
2821
}
1688
close(devnull);
2822
run_network_hooks("start", interfaces_hooks != NULL ?
2823
interfaces_hooks : "", delay);
1689
2824
}
1690
2825
1691
2826
if(not debug){
1692
2827
avahi_set_log_function(empty_log);
1693
2828
}
1694
2829
1695
if(interface[0] == '\0'){
1696
struct dirent **direntries;
1697
ret = scandir(sys_class_net, &direntries, good_interface,
1698
alphasort);
1699
if(ret >= 1){
1700
/* Pick the first good interface */
1701
interface = strdup(direntries[0]->d_name);
1702
if(debug){
1703
fprintf(stderr, "Using interface \"%s\"\n", interface);
1704
}
1705
if(interface == NULL){
1706
perror_plus("malloc");
1707
free(direntries);
1708
exitcode = EXIT_FAILURE;
1709
goto end;
1710
}
1711
free(direntries);
1712
} else {
1713
free(direntries);
1714
fprintf(stderr, "Could not find a network interface\n");
1715
exitcode = EXIT_FAILURE;
1716
goto end;
1717
}
1718
}
1719
1720
2830
/* Initialize Avahi early so avahi_simple_poll_quit() can be called
1721
2831
from the signal handler */
1722
2832
/* Initialize the pseudo-RNG for Avahi */
1723
2833
srand((unsigned int) time(NULL));
1724
mc.simple_poll = avahi_simple_poll_new();
1725
if(mc.simple_poll == NULL){
1726
fprintf(stderr, "Avahi: Failed to create simple poll object.\n");
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");
1727
2838
exitcode = EX_UNAVAILABLE;
1728
2839
goto end;
1729
2840
}
1791
2902
}
1792
2903
}
1793
2904
1794
/* If the interface is down, bring it up */
1795
if(strcmp(interface, "none") != 0){
1796
if_index = (AvahiIfIndex) if_nametoindex(interface);
1797
if(if_index == 0){
1798
fprintf(stderr, "No such interface: \"%s\"\n", interface);
1799
exitcode = EX_UNAVAILABLE;
1800
goto end;
1801
}
1802
1803
if(quit_now){
1804
goto end;
1805
}
1806
1807
/* Re-raise priviliges */
1808
errno = 0;
1809
ret = seteuid(0);
1810
if(ret == -1){
1811
perror_plus("seteuid");
1812
}
1813
1814
#ifdef __linux__
1815
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1816
messages about the network interface to mess up the prompt */
1817
ret = klogctl(8, NULL, 5);
1818
bool restore_loglevel = true;
1819
if(ret == -1){
1820
restore_loglevel = false;
1821
perror_plus("klogctl");
1822
}
1823
#endif /* __linux__ */
1824
1825
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1826
if(sd < 0){
1827
perror_plus("socket");
1828
exitcode = EX_OSERR;
1829
#ifdef __linux__
1830
if(restore_loglevel){
1831
ret = klogctl(7, NULL, 0);
1832
if(ret == -1){
1833
perror_plus("klogctl");
1834
}
1835
}
1836
#endif /* __linux__ */
1837
/* Lower privileges */
1838
errno = 0;
1839
ret = seteuid(uid);
1840
if(ret == -1){
1841
perror_plus("seteuid");
1842
}
1843
goto end;
1844
}
1845
strcpy(network.ifr_name, interface);
1846
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1847
if(ret == -1){
1848
perror_plus("ioctl SIOCGIFFLAGS");
1849
#ifdef __linux__
1850
if(restore_loglevel){
1851
ret = klogctl(7, NULL, 0);
1852
if(ret == -1){
1853
perror_plus("klogctl");
1854
}
1855
}
1856
#endif /* __linux__ */
1857
exitcode = EX_OSERR;
1858
/* Lower privileges */
1859
errno = 0;
1860
ret = seteuid(uid);
1861
if(ret == -1){
1862
perror_plus("seteuid");
1863
}
1864
goto end;
1865
}
1866
if((network.ifr_flags & IFF_UP) == 0){
1867
network.ifr_flags |= IFF_UP;
1868
take_down_interface = true;
1869
ret = ioctl(sd, SIOCSIFFLAGS, &network);
1870
if(ret == -1){
1871
take_down_interface = false;
1872
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1873
exitcode = EX_OSERR;
1874
#ifdef __linux__
1875
if(restore_loglevel){
1876
ret = klogctl(7, NULL, 0);
1877
if(ret == -1){
1878
perror_plus("klogctl");
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;
1879
2956
}
1880
2957
}
1881
#endif /* __linux__ */
1882
/* Lower privileges */
1883
errno = 0;
1884
ret = seteuid(uid);
1885
if(ret == -1){
1886
perror_plus("seteuid");
1887
}
1888
goto end;
1889
}
1890
}
1891
/* Sleep checking until interface is running.
1892
Check every 0.25s, up to total time of delay */
1893
for(int i=0; i < delay * 4; i++){
1894
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1895
if(ret == -1){
1896
perror_plus("ioctl SIOCGIFFLAGS");
1897
} else if(network.ifr_flags & IFF_RUNNING){
1898
2958
break;
1899
2959
}
1900
struct timespec sleeptime = { .tv_nsec = 250000000 };
1901
ret = nanosleep(&sleeptime, NULL);
1902
if(ret == -1 and errno != EINTR){
1903
perror_plus("nanosleep");
1904
}
1905
}
1906
if(not take_down_interface){
1907
/* We won't need the socket anymore */
1908
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1909
if(ret == -1){
1910
perror_plus("close");
1911
}
1912
}
1913
#ifdef __linux__
1914
if(restore_loglevel){
1915
/* Restores kernel loglevel to default */
1916
ret = klogctl(7, NULL, 0);
1917
if(ret == -1){
1918
perror_plus("klogctl");
1919
}
1920
}
1921
#endif /* __linux__ */
1922
/* Lower privileges */
1923
errno = 0;
1924
if(take_down_interface){
1925
/* Lower privileges */
1926
ret = seteuid(uid);
1927
if(ret == -1){
1928
perror_plus("seteuid");
1929
}
1930
} else {
1931
/* Lower privileges permanently */
1932
ret = setuid(uid);
1933
if(ret == -1){
1934
perror_plus("setuid");
1935
}
1936
}
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);
1937
2988
}
1938
2989
1939
2990
if(quit_now){
1940
2991
goto end;
1941
2992
}
1942
2993
1943
ret = init_gnutls_global(pubkey, seckey);
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
1944
3001
if(ret == -1){
1945
fprintf(stderr, "init_gnutls_global failed\n");
3002
fprintf_plus(stderr, "init_gnutls_global failed\n");
1946
3003
exitcode = EX_UNAVAILABLE;
1947
3004
goto end;
1948
3005
} else {
1953
3010
goto end;
1954
3011
}
1955
3012
1956
if(mkdtemp(tempdir) == NULL){
3013
/* Try /run/tmp before /tmp */
3014
tempdir = mkdtemp(run_tempdir);
3015
if(tempdir == NULL and errno == ENOENT){
3016
if(debug){
3017
fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
3018
run_tempdir, old_tempdir);
3019
}
3020
tempdir = mkdtemp(old_tempdir);
3021
}
3022
if(tempdir == NULL){
1957
3023
perror_plus("mkdtemp");
1958
3024
goto end;
1959
3025
}
1960
tempdir_created = true;
1961
3026
1962
3027
if(quit_now){
1963
3028
goto end;
1964
3029
}
1965
3030
1966
if(not init_gpgme(pubkey, seckey, tempdir)){
1967
fprintf(stderr, "init_gpgme failed\n");
3031
if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
3032
fprintf_plus(stderr, "init_gpgme failed\n");
1968
3033
exitcode = EX_UNAVAILABLE;
1969
3034
goto end;
1970
3035
} else {
1979
3044
/* Connect directly, do not use Zeroconf */
1980
3045
/* (Mainly meant for debugging) */
1981
3046
char *address = strrchr(connect_to, ':');
3047
1982
3048
if(address == NULL){
1983
fprintf(stderr, "No colon in address\n");
3049
fprintf_plus(stderr, "No colon in address\n");
1984
3050
exitcode = EX_USAGE;
1985
3051
goto end;
1986
3052
}
1989
3055
goto end;
1990
3056
}
1991
3057
1992
uint16_t port;
3058
in_port_t port;
1993
3059
errno = 0;
1994
3060
tmpmax = strtoimax(address+1, &tmp, 10);
1995
3061
if(errno != 0 or tmp == address+1 or *tmp != '\0'
1996
or tmpmax != (uint16_t)tmpmax){
1997
fprintf(stderr, "Bad port number\n");
3062
or tmpmax != (in_port_t)tmpmax){
3063
fprintf_plus(stderr, "Bad port number\n");
1998
3064
exitcode = EX_USAGE;
1999
3065
goto end;
2000
3066
}
2001
3067
2002
3068
if(quit_now){
2003
3069
goto end;
2004
3070
}
2005
3071
2006
port = (uint16_t)tmpmax;
3072
port = (in_port_t)tmpmax;
2007
3073
*address = '\0';
2008
3074
/* Colon in address indicates IPv6 */
2009
3075
int af;
2025
3091
}
2026
3092
2027
3093
while(not quit_now){
2028
ret = start_mandos_communication(address, port, if_index, af);
3094
ret = start_mandos_communication(address, port, if_index, af,
3095
&mc);
2029
3096
if(quit_now or ret == 0){
2030
3097
break;
2031
3098
}
2032
3099
if(debug){
2033
fprintf(stderr, "Retrying in %d seconds\n",
2034
(int)retry_interval);
3100
fprintf_plus(stderr, "Retrying in %d seconds\n",
3101
(int)retry_interval);
2035
3102
}
2036
sleep((int)retry_interval);
3103
sleep((unsigned int)retry_interval);
2037
3104
}
2038
3105
2039
if (not quit_now){
3106
if(not quit_now){
2040
3107
exitcode = EXIT_SUCCESS;
2041
3108
}
2042
3109
2057
3124
config.publish_domain = 0;
2058
3125
2059
3126
/* Allocate a new server */
2060
mc.server = avahi_server_new(avahi_simple_poll_get
2061
(mc.simple_poll), &config, NULL,
2062
NULL, &error);
3127
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
3128
&config, NULL, NULL, &ret);
2063
3129
2064
3130
/* Free the Avahi configuration data */
2065
3131
avahi_server_config_free(&config);
2067
3133
2068
3134
/* Check if creating the Avahi server object succeeded */
2069
3135
if(mc.server == NULL){
2070
fprintf(stderr, "Failed to create Avahi server: %s\n",
2071
avahi_strerror(error));
3136
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
3137
avahi_strerror(ret));
2072
3138
exitcode = EX_UNAVAILABLE;
2073
3139
goto end;
2074
3140
}
2080
3146
/* Create the Avahi service browser */
2081
3147
sb = avahi_s_service_browser_new(mc.server, if_index,
2082
3148
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
2083
NULL, 0, browse_callback, NULL);
3149
NULL, 0, browse_callback,
3150
(void *)&mc);
2084
3151
if(sb == NULL){
2085
fprintf(stderr, "Failed to create service browser: %s\n",
2086
avahi_strerror(avahi_server_errno(mc.server)));
3152
fprintf_plus(stderr, "Failed to create service browser: %s\n",
3153
avahi_strerror(avahi_server_errno(mc.server)));
2087
3154
exitcode = EX_UNAVAILABLE;
2088
3155
goto end;
2089
3156
}
2095
3162
/* Run the main loop */
2096
3163
2097
3164
if(debug){
2098
fprintf(stderr, "Starting Avahi loop search\n");
3165
fprintf_plus(stderr, "Starting Avahi loop search\n");
2099
3166
}
2100
2101
ret = avahi_loop_with_timeout(mc.simple_poll,
2102
(int)(retry_interval * 1000));
3167
3168
ret = avahi_loop_with_timeout(simple_poll,
3169
(int)(retry_interval * 1000), &mc);
2103
3170
if(debug){
2104
fprintf(stderr, "avahi_loop_with_timeout exited %s\n",
2105
(ret == 0) ? "successfully" : "with error");
3171
fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
3172
(ret == 0) ? "successfully" : "with error");
2106
3173
}
2107
3174
2108
3175
end:
2109
3176
2110
3177
if(debug){
2111
fprintf(stderr, "%s exiting\n", argv[0]);
3178
if(signal_received){
3179
fprintf_plus(stderr, "%s exiting due to signal %d: %s\n",
3180
argv[0], signal_received,
3181
strsignal(signal_received));
3182
} else {
3183
fprintf_plus(stderr, "%s exiting\n", argv[0]);
3184
}
2112
3185
}
2113
3186
2114
3187
/* Cleanup things */
3188
free(mc.interfaces);
3189
2115
3190
if(sb != NULL)
2116
3191
avahi_s_service_browser_free(sb);
2117
3192
2118
3193
if(mc.server != NULL)
2119
3194
avahi_server_free(mc.server);
2120
3195
2121
if(mc.simple_poll != NULL)
2122
avahi_simple_poll_free(mc.simple_poll);
3196
if(simple_poll != NULL)
3197
avahi_simple_poll_free(simple_poll);
2123
3198
2124
3199
if(gnutls_initialized){
2125
3200
gnutls_certificate_free_credentials(mc.cred);
2126
gnutls_global_deinit();
2127
3201
gnutls_dh_params_deinit(mc.dh_params);
2128
3202
}
2129
3203
2130
3204
if(gpgme_initialized){
2131
3205
gpgme_release(mc.ctx);
2132
3206
}
2133
3207
2134
3208
/* Cleans up the circular linked list of Mandos servers the client
2135
3209
has seen */
2136
3210
if(mc.current_server != NULL){
2137
3211
mc.current_server->prev->next = NULL;
2138
3212
while(mc.current_server != NULL){
2139
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
2140
3222
free(mc.current_server);
2141
3223
mc.current_server = next;
2142
3224
}
2143
3225
}
2144
3226
2145
/* XXX run network hooks "stop" here */
2146
2147
/* Take down the network interface */
2148
if(take_down_interface){
2149
/* Re-raise priviliges */
2150
errno = 0;
2151
ret = seteuid(0);
2152
if(ret == -1){
2153
perror_plus("seteuid");
2154
}
2155
if(geteuid() == 0){
2156
ret = ioctl(sd, SIOCGIFFLAGS, &network);
2157
if(ret == -1){
2158
perror_plus("ioctl SIOCGIFFLAGS");
2159
} else if(network.ifr_flags & IFF_UP) {
2160
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
2161
ret = ioctl(sd, SIOCSIFFLAGS, &network);
2162
if(ret == -1){
2163
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
2164
}
2165
}
2166
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2167
if(ret == -1){
2168
perror_plus("close");
2169
}
2170
/* Lower privileges permanently */
2171
errno = 0;
2172
ret = setuid(uid);
2173
if(ret == -1){
2174
perror_plus("setuid");
2175
}
2176
}
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);
2177
3320
}
2178
3321
2179
3322
/* Removes the GPGME temp directory and all files inside */
2180
if(tempdir_created){
2181
struct dirent **direntries = NULL;
2182
struct dirent *direntry = NULL;
2183
int numentries = scandir(tempdir, &direntries, notdotentries,
2184
alphasort);
2185
if (numentries > 0){
2186
for(int i = 0; i < numentries; i++){
2187
direntry = direntries[i];
2188
char *fullname = NULL;
2189
ret = asprintf(&fullname, "%s/%s", tempdir,
2190
direntry->d_name);
2191
if(ret < 0){
2192
perror_plus("asprintf");
2193
continue;
2194
}
2195
ret = remove(fullname);
2196
if(ret == -1){
2197
fprintf(stderr, "remove(\"%s\"): %s\n", fullname,
2198
strerror(errno));
2199
}
2200
free(fullname);
2201
}
2202
}
2203
2204
/* need to clean even if 0 because man page doesn't specify */
2205
free(direntries);
2206
if (numentries == -1){
2207
perror_plus("scandir");
2208
}
2209
ret = rmdir(tempdir);
2210
if(ret == -1 and errno != ENOENT){
2211
perror_plus("rmdir");
2212
}
3323
if(tempdir != NULL){
3324
clean_dir_at(-1, tempdir, 0);
2213
3325
}
2214
3326
2215
3327
if(quit_now){
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0