/mandos/trunk

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

  • 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.

Show diffs side-by-side

added added

removed removed

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