/mandos/release

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/release

« 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
  • mto: (237.7.594 trunk)
  • mto: This revision was merged to the branch mainline in revision 370.
  • 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-2011 Teddy Hogeborn
13
 
 * Copyright © 2008-2011 Björn Påhlsson
14
 
 * 
15
 
 * This program is free software: you can redistribute it and/or
16
 
 * modify it under the terms of the GNU General Public License as
17
 
 * published by the Free Software Foundation, either version 3 of the
18
 
 * License, or (at your option) any later version.
19
 
 * 
20
 
 * This program is distributed in the hope that it will be useful, but
 
12
 * Copyright © 2008-2018 Teddy Hogeborn
 
13
 * Copyright © 2008-2018 Björn Påhlsson
 
14
 * 
 
15
 * This file is part of Mandos.
 
16
 * 
 
17
 * Mandos is free software: you can redistribute it and/or modify it
 
18
 * under the terms of the GNU General Public License as published by
 
19
 * the Free Software Foundation, either version 3 of the License, or
 
20
 * (at your option) any later version.
 
21
 * 
 
22
 * Mandos is distributed in the hope that it will be useful, but
21
23
 * WITHOUT ANY WARRANTY; without even the implied warranty of
22
24
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
23
25
 * General Public License for more details.
24
26
 * 
25
27
 * You should have received a copy of the GNU General Public License
26
 
 * along with this program.  If not, see
27
 
 * <http://www.gnu.org/licenses/>.
 
28
 * along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
28
29
 * 
29
30
 * Contact the authors at <mandos@recompile.se>.
30
31
 */
32
33
/* Needed by GPGME, specifically gpgme_data_seek() */
33
34
#ifndef _LARGEFILE_SOURCE
34
35
#define _LARGEFILE_SOURCE
35
 
#endif
 
36
#endif  /* not _LARGEFILE_SOURCE */
36
37
#ifndef _FILE_OFFSET_BITS
37
38
#define _FILE_OFFSET_BITS 64
38
 
#endif
 
39
#endif  /* not _FILE_OFFSET_BITS */
39
40
 
40
41
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), asprintf() */
41
42
 
42
43
#include <stdio.h>              /* fprintf(), stderr, fwrite(),
43
 
                                   stdout, ferror(), remove() */
44
 
#include <stdint.h>             /* uint16_t, uint32_t */
 
44
                                   stdout, ferror() */
 
45
#include <stdint.h>             /* uint16_t, uint32_t, intptr_t */
45
46
#include <stddef.h>             /* NULL, size_t, ssize_t */
46
47
#include <stdlib.h>             /* free(), EXIT_SUCCESS, srand(),
47
48
                                   strtof(), abort() */
48
49
#include <stdbool.h>            /* bool, false, true */
49
 
#include <string.h>             /* memset(), strcmp(), strlen(),
50
 
                                   strerror(), asprintf(), strcpy() */
 
50
#include <string.h>             /* strcmp(), strlen(), strerror(),
 
51
                                   asprintf(), strncpy(), strsignal()
 
52
                                */
51
53
#include <sys/ioctl.h>          /* ioctl */
52
54
#include <sys/types.h>          /* socket(), inet_pton(), sockaddr,
53
55
                                   sockaddr_in6, PF_INET6,
55
57
                                   opendir(), DIR */
56
58
#include <sys/stat.h>           /* open(), S_ISREG */
57
59
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
58
 
                                   inet_pton(), connect() */
59
 
#include <fcntl.h>              /* open() */
 
60
                                   inet_pton(), connect(),
 
61
                                   getnameinfo() */
 
62
#include <fcntl.h>              /* open(), unlinkat(), AT_REMOVEDIR */
60
63
#include <dirent.h>             /* opendir(), struct dirent, readdir()
61
64
                                 */
62
65
#include <inttypes.h>           /* PRIu16, PRIdMAX, intmax_t,
63
66
                                   strtoimax() */
64
 
#include <assert.h>             /* assert() */
65
 
#include <errno.h>              /* perror(), errno,
 
67
#include <errno.h>              /* perror(), errno, EINTR, EINVAL,
 
68
                                   EAI_SYSTEM, ENETUNREACH,
 
69
                                   EHOSTUNREACH, ECONNREFUSED, EPROTO,
 
70
                                   EIO, ENOENT, ENXIO, ENOMEM, EISDIR,
 
71
                                   ENOTEMPTY,
66
72
                                   program_invocation_short_name */
67
73
#include <time.h>               /* nanosleep(), time(), sleep() */
68
74
#include <net/if.h>             /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
73
79
                                */
74
80
#include <unistd.h>             /* close(), SEEK_SET, off_t, write(),
75
81
                                   getuid(), getgid(), seteuid(),
76
 
                                   setgid(), pause(), _exit() */
77
 
#include <arpa/inet.h>          /* inet_pton(), htons, inet_ntop() */
 
82
                                   setgid(), pause(), _exit(),
 
83
                                   unlinkat() */
 
84
#include <arpa/inet.h>          /* inet_pton(), htons() */
78
85
#include <iso646.h>             /* not, or, and */
79
86
#include <argp.h>               /* struct argp_option, error_t, struct
80
87
                                   argp_state, struct argp,
88
95
#include <sys/wait.h>           /* waitpid(), WIFEXITED(),
89
96
                                   WEXITSTATUS(), WTERMSIG() */
90
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() */
91
104
 
92
105
#ifdef __linux__
93
106
#include <sys/klog.h>           /* klogctl() */
110
123
                                   gnutls_*
111
124
                                   init_gnutls_session(),
112
125
                                   GNUTLS_* */
 
126
#if GNUTLS_VERSION_NUMBER < 0x030600
113
127
#include <gnutls/openpgp.h>
114
128
                         /* gnutls_certificate_set_openpgp_key_file(),
115
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
116
135
 
117
136
/* GPGME */
118
137
#include <gpgme.h>              /* All GPGME types, constants and
126
145
#define PATHDIR "/conf/conf.d/mandos"
127
146
#define SECKEY "seckey.txt"
128
147
#define PUBKEY "pubkey.txt"
 
148
#define TLS_PRIVKEY "tls-privkey.pem"
 
149
#define TLS_PUBKEY "tls-pubkey.pem"
129
150
#define HOOKDIR "/lib/mandos/network-hooks.d"
130
151
 
131
152
bool debug = false;
135
156
static const char sys_class_net[] = "/sys/class/net";
136
157
char *connect_to = NULL;
137
158
const char *hookdir = HOOKDIR;
 
159
int hookdir_fd = -1;
 
160
uid_t uid = 65534;
 
161
gid_t gid = 65534;
138
162
 
139
163
/* Doubly linked list that need to be circularly linked when used */
140
164
typedef struct server{
141
165
  const char *ip;
142
 
  uint16_t port;
 
166
  in_port_t port;
143
167
  AvahiIfIndex if_index;
144
168
  int af;
145
169
  struct timespec last_seen;
149
173
 
150
174
/* Used for passing in values through the Avahi callback functions */
151
175
typedef struct {
152
 
  AvahiSimplePoll *simple_poll;
153
176
  AvahiServer *server;
154
177
  gnutls_certificate_credentials_t cred;
155
178
  unsigned int dh_bits;
157
180
  const char *priority;
158
181
  gpgme_ctx_t ctx;
159
182
  server *current_server;
 
183
  char *interfaces;
 
184
  size_t interfaces_size;
160
185
} mandos_context;
161
186
 
162
 
/* global context so signal handler can reach it*/
163
 
mandos_context mc = { .simple_poll = NULL, .server = NULL,
164
 
                      .dh_bits = 1024, .priority = "SECURE256"
165
 
                      ":!CTYPE-X.509:+CTYPE-OPENPGP",
166
 
                      .current_server = NULL };
 
187
/* global so signal handler can reach it*/
 
188
AvahiSimplePoll *simple_poll;
167
189
 
168
190
sig_atomic_t quit_now = 0;
169
191
int signal_received = 0;
177
199
  perror(print_text);
178
200
}
179
201
 
180
 
__attribute__((format (gnu_printf, 2, 3)))
 
202
__attribute__((format (gnu_printf, 2, 3), nonnull))
181
203
int fprintf_plus(FILE *stream, const char *format, ...){
182
204
  va_list ap;
183
205
  va_start (ap, format);
184
206
  
185
207
  TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
186
208
                             program_invocation_short_name));
187
 
  return TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
 
209
  return (int)TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
188
210
}
189
211
 
190
212
/*
192
214
 * bytes. "buffer_capacity" is how much is currently allocated,
193
215
 * "buffer_length" is how much is already used.
194
216
 */
 
217
__attribute__((nonnull, warn_unused_result))
195
218
size_t incbuffer(char **buffer, size_t buffer_length,
196
219
                 size_t buffer_capacity){
197
220
  if(buffer_length + BUFFER_SIZE > buffer_capacity){
198
 
    *buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
199
 
    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;
200
227
      return 0;
201
228
    }
 
229
    *buffer = new_buf;
202
230
    buffer_capacity += BUFFER_SIZE;
203
231
  }
204
232
  return buffer_capacity;
205
233
}
206
234
 
207
235
/* Add server to set of servers to retry periodically */
208
 
bool add_server(const char *ip, uint16_t port, AvahiIfIndex if_index,
209
 
                int af){
 
236
__attribute__((nonnull, warn_unused_result))
 
237
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
 
238
                int af, server **current_server){
210
239
  int ret;
211
240
  server *new_server = malloc(sizeof(server));
212
241
  if(new_server == NULL){
219
248
                          .af = af };
220
249
  if(new_server->ip == NULL){
221
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);
222
266
    return false;
223
267
  }
224
268
  /* Special case of first server */
225
 
  if (mc.current_server == NULL){
 
269
  if(*current_server == NULL){
226
270
    new_server->next = new_server;
227
271
    new_server->prev = new_server;
228
 
    mc.current_server = new_server;
229
 
  /* Place the new server last in the list */
 
272
    *current_server = new_server;
230
273
  } else {
231
 
    new_server->next = mc.current_server;
232
 
    new_server->prev = mc.current_server->prev;
 
274
    /* Place the new server last in the list */
 
275
    new_server->next = *current_server;
 
276
    new_server->prev = (*current_server)->prev;
233
277
    new_server->prev->next = new_server;
234
 
    mc.current_server->prev = new_server;
235
 
  }
236
 
  ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);
237
 
  if(ret == -1){
238
 
    perror_plus("clock_gettime");
239
 
    return false;
 
278
    (*current_server)->prev = new_server;
240
279
  }
241
280
  return true;
242
281
}
243
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
 
244
335
/* 
245
336
 * Initialize GPGME.
246
337
 */
247
 
static bool init_gpgme(const char *seckey, const char *pubkey,
248
 
                       const char *tempdir){
 
338
__attribute__((nonnull, warn_unused_result))
 
339
static bool init_gpgme(const char * const seckey,
 
340
                       const char * const pubkey,
 
341
                       const char * const tempdir,
 
342
                       mandos_context *mc){
249
343
  gpgme_error_t rc;
250
344
  gpgme_engine_info_t engine_info;
251
345
  
252
 
  
253
346
  /*
254
347
   * Helper function to insert pub and seckey to the engine keyring.
255
348
   */
256
 
  bool import_key(const char *filename){
 
349
  bool import_key(const char * const filename){
257
350
    int ret;
258
351
    int fd;
259
352
    gpgme_data_t pgp_data;
264
357
      return false;
265
358
    }
266
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
 
267
410
    rc = gpgme_data_new_from_fd(&pgp_data, fd);
268
411
    if(rc != GPG_ERR_NO_ERROR){
269
412
      fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
271
414
      return false;
272
415
    }
273
416
    
274
 
    rc = gpgme_op_import(mc.ctx, pgp_data);
 
417
    rc = gpgme_op_import(mc->ctx, pgp_data);
275
418
    if(rc != GPG_ERR_NO_ERROR){
276
419
      fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
277
420
                   gpgme_strsource(rc), gpgme_strerror(rc));
278
421
      return false;
279
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
    }
280
498
    
281
 
    ret = (int)TEMP_FAILURE_RETRY(close(fd));
 
499
    ret = close(fd);
282
500
    if(ret == -1){
283
501
      perror_plus("close");
284
502
    }
321
539
  }
322
540
  
323
541
  /* Create new GPGME "context" */
324
 
  rc = gpgme_new(&(mc.ctx));
 
542
  rc = gpgme_new(&(mc->ctx));
325
543
  if(rc != GPG_ERR_NO_ERROR){
326
 
    fprintf_plus(stderr, "Mandos plugin mandos-client: "
327
 
                 "bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
328
 
                 gpgme_strerror(rc));
 
544
    fprintf_plus(stderr, "bad gpgme_new: %s: %s\n",
 
545
                 gpgme_strsource(rc), gpgme_strerror(rc));
329
546
    return false;
330
547
  }
331
548
  
340
557
 * Decrypt OpenPGP data.
341
558
 * Returns -1 on error
342
559
 */
 
560
__attribute__((nonnull, warn_unused_result))
343
561
static ssize_t pgp_packet_decrypt(const char *cryptotext,
344
562
                                  size_t crypto_size,
345
 
                                  char **plaintext){
 
563
                                  char **plaintext,
 
564
                                  mandos_context *mc){
346
565
  gpgme_data_t dh_crypto, dh_plain;
347
566
  gpgme_error_t rc;
348
567
  ssize_t ret;
365
584
  /* Create new empty GPGME data buffer for the plaintext */
366
585
  rc = gpgme_data_new(&dh_plain);
367
586
  if(rc != GPG_ERR_NO_ERROR){
368
 
    fprintf_plus(stderr, "Mandos plugin mandos-client: "
369
 
                 "bad gpgme_data_new: %s: %s\n",
 
587
    fprintf_plus(stderr, "bad gpgme_data_new: %s: %s\n",
370
588
                 gpgme_strsource(rc), gpgme_strerror(rc));
371
589
    gpgme_data_release(dh_crypto);
372
590
    return -1;
374
592
  
375
593
  /* Decrypt data from the cryptotext data buffer to the plaintext
376
594
     data buffer */
377
 
  rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
 
595
  rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
378
596
  if(rc != GPG_ERR_NO_ERROR){
379
597
    fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
380
598
                 gpgme_strsource(rc), gpgme_strerror(rc));
381
599
    plaintext_length = -1;
382
600
    if(debug){
383
601
      gpgme_decrypt_result_t result;
384
 
      result = gpgme_op_decrypt_result(mc.ctx);
 
602
      result = gpgme_op_decrypt_result(mc->ctx);
385
603
      if(result == NULL){
386
604
        fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
387
605
      } else {
388
 
        fprintf_plus(stderr, "Unsupported algorithm: %s\n",
389
 
                     result->unsupported_algorithm);
390
 
        fprintf_plus(stderr, "Wrong key usage: %u\n",
391
 
                     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");
392
612
        if(result->file_name != NULL){
393
613
          fprintf_plus(stderr, "File name: %s\n", result->file_name);
394
614
        }
395
 
        gpgme_recipient_t recipient;
396
 
        recipient = result->recipients;
397
 
        while(recipient != NULL){
 
615
 
 
616
        for(gpgme_recipient_t r = result->recipients; r != NULL;
 
617
            r = r->next){
398
618
          fprintf_plus(stderr, "Public key algorithm: %s\n",
399
 
                       gpgme_pubkey_algo_name
400
 
                       (recipient->pubkey_algo));
401
 
          fprintf_plus(stderr, "Key ID: %s\n", recipient->keyid);
 
619
                       gpgme_pubkey_algo_name(r->pubkey_algo));
 
620
          fprintf_plus(stderr, "Key ID: %s\n", r->keyid);
402
621
          fprintf_plus(stderr, "Secret key available: %s\n",
403
 
                       recipient->status == GPG_ERR_NO_SECKEY
404
 
                       ? "No" : "Yes");
405
 
          recipient = recipient->next;
 
622
                       r->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
406
623
        }
407
624
      }
408
625
    }
464
681
  return plaintext_length;
465
682
}
466
683
 
467
 
static const char * safer_gnutls_strerror(int value){
468
 
  const char *ret = gnutls_strerror(value); /* Spurious warning from
469
 
                                               -Wunreachable-code */
470
 
  if(ret == NULL)
471
 
    ret = "(unknown)";
472
 
  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);
473
695
}
474
696
 
475
697
/* GnuTLS log function callback */
 
698
__attribute__((nonnull))
476
699
static void debuggnutls(__attribute__((unused)) int level,
477
700
                        const char* string){
478
701
  fprintf_plus(stderr, "GnuTLS: %s", string);
479
702
}
480
703
 
 
704
__attribute__((nonnull(1, 2, 4), warn_unused_result))
481
705
static int init_gnutls_global(const char *pubkeyfilename,
482
 
                              const char *seckeyfilename){
 
706
                              const char *seckeyfilename,
 
707
                              const char *dhparamsfilename,
 
708
                              mandos_context *mc){
483
709
  int ret;
484
710
  
485
711
  if(debug){
486
712
    fprintf_plus(stderr, "Initializing GnuTLS\n");
487
713
  }
488
714
  
489
 
  ret = gnutls_global_init();
490
 
  if(ret != GNUTLS_E_SUCCESS){
491
 
    fprintf_plus(stderr, "GnuTLS global_init: %s\n",
492
 
                 safer_gnutls_strerror(ret));
493
 
    return -1;
494
 
  }
495
 
  
496
715
  if(debug){
497
716
    /* "Use a log level over 10 to enable all debugging options."
498
717
     * - GnuTLS manual
502
721
  }
503
722
  
504
723
  /* OpenPGP credentials */
505
 
  ret = gnutls_certificate_allocate_credentials(&mc.cred);
 
724
  ret = gnutls_certificate_allocate_credentials(&mc->cred);
506
725
  if(ret != GNUTLS_E_SUCCESS){
507
726
    fprintf_plus(stderr, "GnuTLS memory error: %s\n",
508
727
                 safer_gnutls_strerror(ret));
509
 
    gnutls_global_deinit();
510
728
    return -1;
511
729
  }
512
730
  
513
731
  if(debug){
514
 
    fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
515
 
                 " secret key %s as GnuTLS credentials\n",
 
732
    fprintf_plus(stderr, "Attempting to use public key %s and"
 
733
                 " private key %s as GnuTLS credentials\n",
516
734
                 pubkeyfilename,
517
735
                 seckeyfilename);
518
736
  }
519
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
520
751
  ret = gnutls_certificate_set_openpgp_key_file
521
 
    (mc.cred, pubkeyfilename, seckeyfilename,
 
752
    (mc->cred, pubkeyfilename, seckeyfilename,
522
753
     GNUTLS_OPENPGP_FMT_BASE64);
 
754
#else
 
755
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
 
756
#endif
523
757
  if(ret != GNUTLS_E_SUCCESS){
524
758
    fprintf_plus(stderr,
525
 
                 "Error[%d] while reading the OpenPGP key pair ('%s',"
 
759
                 "Error[%d] while reading the key pair ('%s',"
526
760
                 " '%s')\n", ret, pubkeyfilename, seckeyfilename);
527
761
    fprintf_plus(stderr, "The GnuTLS error is: %s\n",
528
762
                 safer_gnutls_strerror(ret));
530
764
  }
531
765
  
532
766
  /* GnuTLS server initialization */
533
 
  ret = gnutls_dh_params_init(&mc.dh_params);
 
767
  ret = gnutls_dh_params_init(&mc->dh_params);
534
768
  if(ret != GNUTLS_E_SUCCESS){
535
769
    fprintf_plus(stderr, "Error in GnuTLS DH parameter"
536
770
                 " initialization: %s\n",
537
771
                 safer_gnutls_strerror(ret));
538
772
    goto globalfail;
539
773
  }
540
 
  ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
541
 
  if(ret != GNUTLS_E_SUCCESS){
542
 
    fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
543
 
                 safer_gnutls_strerror(ret));
544
 
    goto globalfail;
545
 
  }
546
 
  
547
 
  gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
 
774
  /* If a Diffie-Hellman parameters file was given, try to use it */
 
775
  if(dhparamsfilename != NULL){
 
776
    gnutls_datum_t params = { .data = NULL, .size = 0 };
 
777
    do {
 
778
      int dhpfile = open(dhparamsfilename, O_RDONLY);
 
779
      if(dhpfile == -1){
 
780
        perror_plus("open");
 
781
        dhparamsfilename = NULL;
 
782
        break;
 
783
      }
 
784
      size_t params_capacity = 0;
 
785
      while(true){
 
786
        params_capacity = incbuffer((char **)&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
  }
548
956
  
549
957
  return 0;
550
958
  
551
959
 globalfail:
552
960
  
553
 
  gnutls_certificate_free_credentials(mc.cred);
554
 
  gnutls_global_deinit();
555
 
  gnutls_dh_params_deinit(mc.dh_params);
 
961
  gnutls_certificate_free_credentials(mc->cred);
 
962
  gnutls_dh_params_deinit(mc->dh_params);
556
963
  return -1;
557
964
}
558
965
 
559
 
static int init_gnutls_session(gnutls_session_t *session){
 
966
__attribute__((nonnull, warn_unused_result))
 
967
static int init_gnutls_session(gnutls_session_t *session,
 
968
                               mandos_context *mc){
560
969
  int ret;
561
970
  /* GnuTLS session creation */
562
971
  do {
563
 
    ret = gnutls_init(session, GNUTLS_SERVER);
 
972
    ret = gnutls_init(session, (GNUTLS_SERVER
 
973
#if GNUTLS_VERSION_NUMBER >= 0x030506
 
974
                                | GNUTLS_NO_TICKETS
 
975
#endif
 
976
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
977
                                | GNUTLS_ENABLE_RAWPK
 
978
#endif
 
979
                                ));
564
980
    if(quit_now){
565
981
      return -1;
566
982
    }
574
990
  {
575
991
    const char *err;
576
992
    do {
577
 
      ret = gnutls_priority_set_direct(*session, mc.priority, &err);
 
993
      ret = gnutls_priority_set_direct(*session, mc->priority, &err);
578
994
      if(quit_now){
579
995
        gnutls_deinit(*session);
580
996
        return -1;
591
1007
  
592
1008
  do {
593
1009
    ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
594
 
                                 mc.cred);
 
1010
                                 mc->cred);
595
1011
    if(quit_now){
596
1012
      gnutls_deinit(*session);
597
1013
      return -1;
607
1023
  /* ignore client certificate if any. */
608
1024
  gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
609
1025
  
610
 
  gnutls_dh_set_prime_bits(*session, mc.dh_bits);
611
 
  
612
1026
  return 0;
613
1027
}
614
1028
 
616
1030
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
617
1031
                      __attribute__((unused)) const char *txt){}
618
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
 
619
1199
/* Called when a Mandos server is found */
620
 
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,
621
1202
                                      AvahiIfIndex if_index,
622
 
                                      int af){
 
1203
                                      int af, mandos_context *mc){
623
1204
  int ret, tcp_sd = -1;
624
1205
  ssize_t sret;
625
 
  union {
626
 
    struct sockaddr_in in;
627
 
    struct sockaddr_in6 in6;
628
 
  } to;
 
1206
  struct sockaddr_storage to;
629
1207
  char *buffer = NULL;
630
1208
  char *decrypted_buffer = NULL;
631
1209
  size_t buffer_length = 0;
634
1212
  int retval = -1;
635
1213
  gnutls_session_t session;
636
1214
  int pf;                       /* Protocol family */
 
1215
  bool route_added = false;
637
1216
  
638
1217
  errno = 0;
639
1218
  
655
1234
    return -1;
656
1235
  }
657
1236
  
658
 
  ret = init_gnutls_session(&session);
 
1237
  /* If the interface is specified and we have a list of interfaces */
 
1238
  if(if_index != AVAHI_IF_UNSPEC and mc->interfaces != NULL){
 
1239
    /* Check if the interface is one of the interfaces we are using */
 
1240
    bool match = false;
 
1241
    {
 
1242
      char *interface = NULL;
 
1243
      while((interface = argz_next(mc->interfaces,
 
1244
                                   mc->interfaces_size,
 
1245
                                   interface))){
 
1246
        if(if_nametoindex(interface) == (unsigned int)if_index){
 
1247
          match = true;
 
1248
          break;
 
1249
        }
 
1250
      }
 
1251
    }
 
1252
    if(not match){
 
1253
      /* This interface does not match any in the list, so we don't
 
1254
         connect to the server */
 
1255
      if(debug){
 
1256
        char interface[IF_NAMESIZE];
 
1257
        if(if_indextoname((unsigned int)if_index, interface) == NULL){
 
1258
          perror_plus("if_indextoname");
 
1259
        } else {
 
1260
          fprintf_plus(stderr, "Skipping server on non-used interface"
 
1261
                       " \"%s\"\n",
 
1262
                       if_indextoname((unsigned int)if_index,
 
1263
                                      interface));
 
1264
        }
 
1265
      }
 
1266
      return -1;
 
1267
    }
 
1268
  }
 
1269
  
 
1270
  ret = init_gnutls_session(&session, mc);
659
1271
  if(ret != 0){
660
1272
    return -1;
661
1273
  }
662
1274
  
663
1275
  if(debug){
664
1276
    fprintf_plus(stderr, "Setting up a TCP connection to %s, port %"
665
 
                 PRIu16 "\n", ip, port);
 
1277
                 PRIuMAX "\n", ip, (uintmax_t)port);
666
1278
  }
667
1279
  
668
 
  tcp_sd = socket(pf, SOCK_STREAM, 0);
 
1280
  tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
669
1281
  if(tcp_sd < 0){
670
1282
    int e = errno;
671
1283
    perror_plus("socket");
678
1290
    goto mandos_end;
679
1291
  }
680
1292
  
681
 
  memset(&to, 0, sizeof(to));
682
1293
  if(af == AF_INET6){
683
 
    to.in6.sin6_family = (sa_family_t)af;
684
 
    ret = inet_pton(af, ip, &to.in6.sin6_addr);
 
1294
    struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)&to;
 
1295
    *to6 = (struct sockaddr_in6){ .sin6_family = (sa_family_t)af };
 
1296
    ret = inet_pton(af, ip, &to6->sin6_addr);
685
1297
  } else {                      /* IPv4 */
686
 
    to.in.sin_family = (sa_family_t)af;
687
 
    ret = inet_pton(af, ip, &to.in.sin_addr);
 
1298
    struct sockaddr_in *to4 = (struct sockaddr_in *)&to;
 
1299
    *to4 = (struct sockaddr_in){ .sin_family = (sa_family_t)af };
 
1300
    ret = inet_pton(af, ip, &to4->sin_addr);
688
1301
  }
689
1302
  if(ret < 0 ){
690
1303
    int e = errno;
699
1312
    goto mandos_end;
700
1313
  }
701
1314
  if(af == AF_INET6){
702
 
    to.in6.sin6_port = htons(port); /* Spurious warnings from
703
 
                                       -Wconversion and
704
 
                                       -Wunreachable-code */
705
 
    
706
 
    if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
707
 
       (&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
708
 
                                -Wunreachable-code*/
 
1315
    ((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
 
1316
    if(IN6_IS_ADDR_LINKLOCAL
 
1317
       (&((struct sockaddr_in6 *)&to)->sin6_addr)){
709
1318
      if(if_index == AVAHI_IF_UNSPEC){
710
1319
        fprintf_plus(stderr, "An IPv6 link-local address is"
711
1320
                     " incomplete without a network interface\n");
713
1322
        goto mandos_end;
714
1323
      }
715
1324
      /* Set the network interface number as scope */
716
 
      to.in6.sin6_scope_id = (uint32_t)if_index;
 
1325
      ((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
717
1326
    }
718
1327
  } else {
719
 
    to.in.sin_port = htons(port); /* Spurious warnings from
720
 
                                     -Wconversion and
721
 
                                     -Wunreachable-code */
 
1328
    ((struct sockaddr_in *)&to)->sin_port = htons(port);
722
1329
  }
723
1330
  
724
1331
  if(quit_now){
732
1339
      if(if_indextoname((unsigned int)if_index, interface) == NULL){
733
1340
        perror_plus("if_indextoname");
734
1341
      } else {
735
 
        fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIu16
736
 
                     "\n", ip, interface, port);
 
1342
        fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIuMAX
 
1343
                     "\n", ip, interface, (uintmax_t)port);
737
1344
      }
738
1345
    } else {
739
 
      fprintf_plus(stderr, "Connection to: %s, port %" PRIu16 "\n",
740
 
                   ip, port);
 
1346
      fprintf_plus(stderr, "Connection to: %s, port %" PRIuMAX "\n",
 
1347
                   ip, (uintmax_t)port);
741
1348
    }
742
1349
    char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
743
1350
                 INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
744
 
    const char *pcret;
745
 
    if(af == AF_INET6){
746
 
      pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
747
 
                        sizeof(addrstr));
748
 
    } else {
749
 
      pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
750
 
                        sizeof(addrstr));
751
 
    }
752
 
    if(pcret == NULL){
753
 
      perror_plus("inet_ntop");
754
 
    } else {
755
 
      if(strcmp(addrstr, ip) != 0){
756
 
        fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
757
 
      }
758
 
    }
759
 
  }
760
 
  
761
 
  if(quit_now){
762
 
    errno = EINTR;
763
 
    goto mandos_end;
764
 
  }
765
 
  
766
 
  if(af == AF_INET6){
767
 
    ret = connect(tcp_sd, &to.in6, sizeof(to));
768
 
  } else {
769
 
    ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
770
 
  }
771
 
  if(ret < 0){
772
 
    if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
773
 
      int e = errno;
774
 
      perror_plus("connect");
775
 
      errno = e;
776
 
    }
777
 
    goto mandos_end;
778
 
  }
779
 
  
780
 
  if(quit_now){
781
 
    errno = EINTR;
782
 
    goto mandos_end;
 
1351
    if(af == AF_INET6){
 
1352
      ret = getnameinfo((struct sockaddr *)&to,
 
1353
                        sizeof(struct sockaddr_in6),
 
1354
                        addrstr, sizeof(addrstr), NULL, 0,
 
1355
                        NI_NUMERICHOST);
 
1356
    } else {
 
1357
      ret = getnameinfo((struct sockaddr *)&to,
 
1358
                        sizeof(struct sockaddr_in),
 
1359
                        addrstr, sizeof(addrstr), NULL, 0,
 
1360
                        NI_NUMERICHOST);
 
1361
    }
 
1362
    if(ret == EAI_SYSTEM){
 
1363
      perror_plus("getnameinfo");
 
1364
    } else if(ret != 0) {
 
1365
      fprintf_plus(stderr, "getnameinfo: %s", gai_strerror(ret));
 
1366
    } else if(strcmp(addrstr, ip) != 0){
 
1367
      fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
 
1368
    }
 
1369
  }
 
1370
  
 
1371
  if(quit_now){
 
1372
    errno = EINTR;
 
1373
    goto mandos_end;
 
1374
  }
 
1375
  
 
1376
  while(true){
 
1377
    if(af == AF_INET6){
 
1378
      ret = connect(tcp_sd, (struct sockaddr *)&to,
 
1379
                    sizeof(struct sockaddr_in6));
 
1380
    } else {
 
1381
      ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
 
1382
                    sizeof(struct sockaddr_in));
 
1383
    }
 
1384
    if(ret < 0){
 
1385
      if(((errno == ENETUNREACH) or (errno == EHOSTUNREACH))
 
1386
         and if_index != AVAHI_IF_UNSPEC
 
1387
         and connect_to == NULL
 
1388
         and not route_added and
 
1389
         ((af == AF_INET6 and not
 
1390
           IN6_IS_ADDR_LINKLOCAL(&(((struct sockaddr_in6 *)
 
1391
                                    &to)->sin6_addr)))
 
1392
          or (af == AF_INET and
 
1393
              /* Not a a IPv4LL address */
 
1394
              (ntohl(((struct sockaddr_in *)&to)->sin_addr.s_addr)
 
1395
               & 0xFFFF0000L) != 0xA9FE0000L))){
 
1396
        /* Work around Avahi bug - Avahi does not announce link-local
 
1397
           addresses if it has a global address, so local hosts with
 
1398
           *only* a link-local address (e.g. Mandos clients) cannot
 
1399
           connect to a Mandos server announced by Avahi on a server
 
1400
           host with a global address.  Work around this by retrying
 
1401
           with an explicit route added with the server's address.
 
1402
           
 
1403
           Avahi bug reference:
 
1404
           https://lists.freedesktop.org/archives/avahi/2010-February/001833.html
 
1405
           https://bugs.debian.org/587961
 
1406
        */
 
1407
        if(debug){
 
1408
          fprintf_plus(stderr, "Mandos server unreachable, trying"
 
1409
                       " direct route\n");
 
1410
        }
 
1411
        int e = errno;
 
1412
        route_added = add_local_route(ip, if_index);
 
1413
        if(route_added){
 
1414
          continue;
 
1415
        }
 
1416
        errno = e;
 
1417
      }
 
1418
      if(errno != ECONNREFUSED or debug){
 
1419
        int e = errno;
 
1420
        perror_plus("connect");
 
1421
        errno = e;
 
1422
      }
 
1423
      goto mandos_end;
 
1424
    }
 
1425
    
 
1426
    if(quit_now){
 
1427
      errno = EINTR;
 
1428
      goto mandos_end;
 
1429
    }
 
1430
    break;
783
1431
  }
784
1432
  
785
1433
  const char *out = mandos_protocol_version;
821
1469
    goto mandos_end;
822
1470
  }
823
1471
  
824
 
  /* Spurious warning from -Wint-to-pointer-cast */
825
 
  gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
 
1472
  /* This casting via intptr_t is to eliminate warning about casting
 
1473
     an int to a pointer type.  This is exactly how the GnuTLS Guile
 
1474
     function "set-session-transport-fd!" does it. */
 
1475
  gnutls_transport_set_ptr(session,
 
1476
                           (gnutls_transport_ptr_t)(intptr_t)tcp_sd);
826
1477
  
827
1478
  if(quit_now){
828
1479
    errno = EINTR;
933
1584
  if(buffer_length > 0){
934
1585
    ssize_t decrypted_buffer_size;
935
1586
    decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
936
 
                                               &decrypted_buffer);
 
1587
                                               &decrypted_buffer, mc);
937
1588
    if(decrypted_buffer_size >= 0){
938
1589
      
 
1590
      clearerr(stdout);
939
1591
      written = 0;
940
1592
      while(written < (size_t) decrypted_buffer_size){
941
1593
        if(quit_now){
957
1609
        }
958
1610
        written += (size_t)ret;
959
1611
      }
 
1612
      ret = fflush(stdout);
 
1613
      if(ret != 0){
 
1614
        int e = errno;
 
1615
        if(debug){
 
1616
          fprintf_plus(stderr, "Error writing encrypted data: %s\n",
 
1617
                       strerror(errno));
 
1618
        }
 
1619
        errno = e;
 
1620
        goto mandos_end;
 
1621
      }
960
1622
      retval = 0;
961
1623
    }
962
1624
  }
965
1627
  
966
1628
 mandos_end:
967
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
    }
968
1636
    int e = errno;
969
1637
    free(decrypted_buffer);
970
1638
    free(buffer);
971
1639
    if(tcp_sd >= 0){
972
 
      ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
 
1640
      ret = close(tcp_sd);
973
1641
    }
974
1642
    if(ret == -1){
975
1643
      if(e == 0){
1000
1668
                             AVAHI_GCC_UNUSED AvahiStringList *txt,
1001
1669
                             AVAHI_GCC_UNUSED AvahiLookupResultFlags
1002
1670
                             flags,
1003
 
                             AVAHI_GCC_UNUSED void* userdata){
1004
 
  assert(r);
 
1671
                             void *mc){
 
1672
  if(r == NULL){
 
1673
    return;
 
1674
  }
1005
1675
  
1006
1676
  /* Called whenever a service has been resolved successfully or
1007
1677
     timed out */
1008
1678
  
1009
1679
  if(quit_now){
 
1680
    avahi_s_service_resolver_free(r);
1010
1681
    return;
1011
1682
  }
1012
1683
  
1016
1687
    fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
1017
1688
                 "'%s' of type '%s' in domain '%s': %s\n", name, type,
1018
1689
                 domain,
1019
 
                 avahi_strerror(avahi_server_errno(mc.server)));
 
1690
                 avahi_strerror(avahi_server_errno
 
1691
                                (((mandos_context*)mc)->server)));
1020
1692
    break;
1021
1693
    
1022
1694
  case AVAHI_RESOLVER_FOUND:
1028
1700
                     PRIdMAX ") on port %" PRIu16 "\n", name,
1029
1701
                     host_name, ip, (intmax_t)interface, port);
1030
1702
      }
1031
 
      int ret = start_mandos_communication(ip, port, interface,
1032
 
                                           avahi_proto_to_af(proto));
 
1703
      int ret = start_mandos_communication(ip, (in_port_t)port,
 
1704
                                           interface,
 
1705
                                           avahi_proto_to_af(proto),
 
1706
                                           mc);
1033
1707
      if(ret == 0){
1034
 
        avahi_simple_poll_quit(mc.simple_poll);
 
1708
        avahi_simple_poll_quit(simple_poll);
1035
1709
      } else {
1036
 
        if(not add_server(ip, port, interface,
1037
 
                          avahi_proto_to_af(proto))){
 
1710
        if(not add_server(ip, (in_port_t)port, interface,
 
1711
                          avahi_proto_to_af(proto),
 
1712
                          &((mandos_context*)mc)->current_server)){
1038
1713
          fprintf_plus(stderr, "Failed to add server \"%s\" to server"
1039
1714
                       " list\n", name);
1040
1715
        }
1053
1728
                            const char *domain,
1054
1729
                            AVAHI_GCC_UNUSED AvahiLookupResultFlags
1055
1730
                            flags,
1056
 
                            AVAHI_GCC_UNUSED void* userdata){
1057
 
  assert(b);
 
1731
                            void *mc){
 
1732
  if(b == NULL){
 
1733
    return;
 
1734
  }
1058
1735
  
1059
1736
  /* Called whenever a new services becomes available on the LAN or
1060
1737
     is removed from the LAN */
1068
1745
  case AVAHI_BROWSER_FAILURE:
1069
1746
    
1070
1747
    fprintf_plus(stderr, "(Avahi browser) %s\n",
1071
 
                 avahi_strerror(avahi_server_errno(mc.server)));
1072
 
    avahi_simple_poll_quit(mc.simple_poll);
 
1748
                 avahi_strerror(avahi_server_errno
 
1749
                                (((mandos_context*)mc)->server)));
 
1750
    avahi_simple_poll_quit(simple_poll);
1073
1751
    return;
1074
1752
    
1075
1753
  case AVAHI_BROWSER_NEW:
1078
1756
       the callback function is called the Avahi server will free the
1079
1757
       resolver for us. */
1080
1758
    
1081
 
    if(avahi_s_service_resolver_new(mc.server, interface, protocol,
1082
 
                                    name, type, domain, protocol, 0,
1083
 
                                    resolve_callback, NULL) == NULL)
 
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)
1084
1763
      fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
1085
1764
                   " %s\n", name,
1086
 
                   avahi_strerror(avahi_server_errno(mc.server)));
 
1765
                   avahi_strerror(avahi_server_errno
 
1766
                                  (((mandos_context*)mc)->server)));
1087
1767
    break;
1088
1768
    
1089
1769
  case AVAHI_BROWSER_REMOVE:
1108
1788
  signal_received = sig;
1109
1789
  int old_errno = errno;
1110
1790
  /* set main loop to exit */
1111
 
  if(mc.simple_poll != NULL){
1112
 
    avahi_simple_poll_quit(mc.simple_poll);
 
1791
  if(simple_poll != NULL){
 
1792
    avahi_simple_poll_quit(simple_poll);
1113
1793
  }
1114
1794
  errno = old_errno;
1115
1795
}
1116
1796
 
 
1797
__attribute__((nonnull, warn_unused_result))
1117
1798
bool get_flags(const char *ifname, struct ifreq *ifr){
1118
1799
  int ret;
 
1800
  int old_errno;
1119
1801
  
1120
1802
  int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1121
1803
  if(s < 0){
 
1804
    old_errno = errno;
1122
1805
    perror_plus("socket");
 
1806
    errno = old_errno;
1123
1807
    return false;
1124
1808
  }
1125
 
  strcpy(ifr->ifr_name, ifname);
 
1809
  strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
 
1810
  ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
1126
1811
  ret = ioctl(s, SIOCGIFFLAGS, ifr);
1127
1812
  if(ret == -1){
1128
1813
    if(debug){
 
1814
      old_errno = errno;
1129
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;
1130
1822
    }
1131
1823
    return false;
1132
1824
  }
 
1825
  if((close(s) == -1) and debug){
 
1826
    old_errno = errno;
 
1827
    perror_plus("close");
 
1828
    errno = old_errno;
 
1829
  }
1133
1830
  return true;
1134
1831
}
1135
1832
 
 
1833
__attribute__((nonnull, warn_unused_result))
1136
1834
bool good_flags(const char *ifname, const struct ifreq *ifr){
1137
1835
  
1138
1836
  /* Reject the loopback device */
1180
1878
 * corresponds to an acceptable network device.
1181
1879
 * (This function is passed to scandir(3) as a filter function.)
1182
1880
 */
 
1881
__attribute__((nonnull, warn_unused_result))
1183
1882
int good_interface(const struct dirent *if_entry){
1184
1883
  if(if_entry->d_name[0] == '.'){
1185
1884
    return 0;
1201
1900
}
1202
1901
 
1203
1902
/* 
1204
 
 * This function determines if a directory entry in /sys/class/net
1205
 
 * corresponds to an acceptable network device which is up.
1206
 
 * (This function is passed to scandir(3) as a filter function.)
1207
 
 */
1208
 
int up_interface(const struct dirent *if_entry){
1209
 
  if(if_entry->d_name[0] == '.'){
1210
 
    return 0;
1211
 
  }
1212
 
  
1213
 
  struct ifreq ifr;
1214
 
  if(not get_flags(if_entry->d_name, &ifr)){
1215
 
    if(debug){
1216
 
      fprintf_plus(stderr, "Failed to get flags for interface "
1217
 
                   "\"%s\"\n", if_entry->d_name);
1218
 
    }
1219
 
    return 0;
1220
 
  }
1221
 
  
1222
 
  /* Reject down interfaces */
1223
 
  if(not (ifr.ifr_flags & IFF_UP)){
1224
 
    if(debug){
1225
 
      fprintf_plus(stderr, "Rejecting down interface \"%s\"\n",
1226
 
                   if_entry->d_name);
1227
 
    }
1228
 
    return 0;
1229
 
  }
1230
 
  
1231
 
  /* Reject non-running interfaces */
1232
 
  if(not (ifr.ifr_flags & IFF_RUNNING)){
1233
 
    if(debug){
1234
 
      fprintf_plus(stderr, "Rejecting non-running interface \"%s\"\n",
1235
 
                   if_entry->d_name);
1236
 
    }
1237
 
    return 0;
1238
 
  }
1239
 
  
1240
 
  if(not good_flags(if_entry->d_name, &ifr)){
1241
 
    return 0;
1242
 
  }
1243
 
  return 1;
1244
 
}
1245
 
 
 
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))
1246
1937
int notdotentries(const struct dirent *direntry){
1247
1938
  /* Skip "." and ".." */
1248
1939
  if(direntry->d_name[0] == '.'
1255
1946
}
1256
1947
 
1257
1948
/* Is this directory entry a runnable program? */
 
1949
__attribute__((nonnull, warn_unused_result))
1258
1950
int runnable_hook(const struct dirent *direntry){
1259
1951
  int ret;
1260
1952
  size_t sret;
1268
1960
  sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1269
1961
                "abcdefghijklmnopqrstuvwxyz"
1270
1962
                "0123456789"
1271
 
                "_-");
 
1963
                "_.-");
1272
1964
  if((direntry->d_name)[sret] != '\0'){
1273
1965
    /* Contains non-allowed characters */
1274
1966
    if(debug){
1278
1970
    return 0;
1279
1971
  }
1280
1972
  
1281
 
  char *fullname = NULL;
1282
 
  ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1283
 
  if(ret < 0){
1284
 
    perror_plus("asprintf");
1285
 
    return 0;
1286
 
  }
1287
 
  
1288
 
  ret = stat(fullname, &st);
 
1973
  ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1289
1974
  if(ret == -1){
1290
1975
    if(debug){
1291
1976
      perror_plus("Could not stat hook");
1315
2000
  return 1;
1316
2001
}
1317
2002
 
1318
 
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval){
 
2003
__attribute__((nonnull, warn_unused_result))
 
2004
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
 
2005
                            mandos_context *mc){
1319
2006
  int ret;
1320
2007
  struct timespec now;
1321
2008
  struct timespec waited_time;
1322
2009
  intmax_t block_time;
1323
2010
  
1324
2011
  while(true){
1325
 
    if(mc.current_server == NULL){
1326
 
      if (debug){
 
2012
    if(mc->current_server == NULL){
 
2013
      if(debug){
1327
2014
        fprintf_plus(stderr, "Wait until first server is found."
1328
2015
                     " No timeout!\n");
1329
2016
      }
1330
2017
      ret = avahi_simple_poll_iterate(s, -1);
1331
2018
    } else {
1332
 
      if (debug){
 
2019
      if(debug){
1333
2020
        fprintf_plus(stderr, "Check current_server if we should run"
1334
2021
                     " it, or wait\n");
1335
2022
      }
1342
2029
      /* Calculating in ms how long time between now and server
1343
2030
         who we visted longest time ago. Now - last seen.  */
1344
2031
      waited_time.tv_sec = (now.tv_sec
1345
 
                            - mc.current_server->last_seen.tv_sec);
 
2032
                            - mc->current_server->last_seen.tv_sec);
1346
2033
      waited_time.tv_nsec = (now.tv_nsec
1347
 
                             - mc.current_server->last_seen.tv_nsec);
 
2034
                             - mc->current_server->last_seen.tv_nsec);
1348
2035
      /* total time is 10s/10,000ms.
1349
2036
         Converting to s from ms by dividing by 1,000,
1350
2037
         and ns to ms by dividing by 1,000,000. */
1352
2039
                     - ((intmax_t)waited_time.tv_sec * 1000))
1353
2040
                    - ((intmax_t)waited_time.tv_nsec / 1000000));
1354
2041
      
1355
 
      if (debug){
 
2042
      if(debug){
1356
2043
        fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1357
2044
                     block_time);
1358
2045
      }
1359
2046
      
1360
2047
      if(block_time <= 0){
1361
 
        ret = start_mandos_communication(mc.current_server->ip,
1362
 
                                         mc.current_server->port,
1363
 
                                         mc.current_server->if_index,
1364
 
                                         mc.current_server->af);
 
2048
        ret = start_mandos_communication(mc->current_server->ip,
 
2049
                                         mc->current_server->port,
 
2050
                                         mc->current_server->if_index,
 
2051
                                         mc->current_server->af, mc);
1365
2052
        if(ret == 0){
1366
 
          avahi_simple_poll_quit(mc.simple_poll);
 
2053
          avahi_simple_poll_quit(s);
1367
2054
          return 0;
1368
2055
        }
1369
2056
        ret = clock_gettime(CLOCK_MONOTONIC,
1370
 
                            &mc.current_server->last_seen);
 
2057
                            &mc->current_server->last_seen);
1371
2058
        if(ret == -1){
1372
2059
          perror_plus("clock_gettime");
1373
2060
          return -1;
1374
2061
        }
1375
 
        mc.current_server = mc.current_server->next;
 
2062
        mc->current_server = mc->current_server->next;
1376
2063
        block_time = 0;         /* Call avahi to find new Mandos
1377
2064
                                   servers, but don't block */
1378
2065
      }
1380
2067
      ret = avahi_simple_poll_iterate(s, (int)block_time);
1381
2068
    }
1382
2069
    if(ret != 0){
1383
 
      if (ret > 0 or errno != EINTR){
 
2070
      if(ret > 0 or errno != EINTR){
1384
2071
        return (ret != 1) ? ret : 0;
1385
2072
      }
1386
2073
    }
1387
2074
  }
1388
2075
}
1389
2076
 
1390
 
bool run_network_hooks(const char *mode, const char *interface,
 
2077
__attribute__((nonnull))
 
2078
void run_network_hooks(const char *mode, const char *interface,
1391
2079
                       const float delay){
1392
 
  struct dirent **direntries;
1393
 
  struct dirent *direntry;
1394
 
  int ret;
1395
 
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
1396
 
                         alphasort);
 
2080
  struct dirent **direntries = NULL;
 
2081
  if(hookdir_fd == -1){
 
2082
    hookdir_fd = open(hookdir, O_RDONLY | O_DIRECTORY | O_PATH
 
2083
                      | O_CLOEXEC);
 
2084
    if(hookdir_fd == -1){
 
2085
      if(errno == ENOENT){
 
2086
        if(debug){
 
2087
          fprintf_plus(stderr, "Network hook directory \"%s\" not"
 
2088
                       " found\n", hookdir);
 
2089
        }
 
2090
      } else {
 
2091
        perror_plus("open");
 
2092
      }
 
2093
      return;
 
2094
    }
 
2095
  }
 
2096
  int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
 
2097
  if(devnull == -1){
 
2098
    perror_plus("open(\"/dev/null\", O_RDONLY)");
 
2099
    return;
 
2100
  }
 
2101
  int numhooks = scandirat(hookdir_fd, ".", &direntries,
 
2102
                           runnable_hook, alphasort);
1397
2103
  if(numhooks == -1){
1398
2104
    perror_plus("scandir");
1399
 
  } else {
1400
 
    int devnull = open("/dev/null", O_RDONLY);
1401
 
    for(int i = 0; i < numhooks; i++){
1402
 
      direntry = direntries[i];
1403
 
      char *fullname = NULL;
1404
 
      ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1405
 
      if(ret < 0){
 
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){
1406
2162
        perror_plus("asprintf");
1407
 
        continue;
1408
 
      }
1409
 
      if(debug){
1410
 
        fprintf_plus(stderr, "Running network hook \"%s\"\n",
1411
 
                     direntry->d_name);
1412
 
      }
1413
 
      pid_t hook_pid = fork();
1414
 
      if(hook_pid == 0){
1415
 
        /* Child */
1416
 
        /* Raise privileges */
1417
 
        errno = 0;
1418
 
        ret = seteuid(0);
1419
 
        if(ret == -1){
1420
 
          perror_plus("seteuid");
1421
 
        }
1422
 
        /* Raise privileges even more */
1423
 
        errno = 0;
1424
 
        ret = setuid(0);
1425
 
        if(ret == -1){
1426
 
          perror_plus("setuid");
1427
 
        }
1428
 
        /* Set group */
1429
 
        errno = 0;
1430
 
        ret = setgid(0);
1431
 
        if(ret == -1){
1432
 
          perror_plus("setgid");
1433
 
        }
1434
 
        /* Reset supplementary groups */
1435
 
        errno = 0;
1436
 
        ret = setgroups(0, NULL);
1437
 
        if(ret == -1){
1438
 
          perror_plus("setgroups");
1439
 
        }
1440
 
        dup2(devnull, STDIN_FILENO);
1441
 
        close(devnull);
1442
 
        dup2(STDERR_FILENO, STDOUT_FILENO);
1443
 
        ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1444
 
        if(ret == -1){
1445
 
          perror_plus("setenv");
1446
 
          _exit(EX_OSERR);
1447
 
        }
1448
 
        ret = setenv("DEVICE", interface, 1);
1449
 
        if(ret == -1){
1450
 
          perror_plus("setenv");
1451
 
          _exit(EX_OSERR);
1452
 
        }
1453
 
        ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
1454
 
        if(ret == -1){
1455
 
          perror_plus("setenv");
1456
 
          _exit(EX_OSERR);
1457
 
        }
1458
 
        ret = setenv("MODE", mode, 1);
1459
 
        if(ret == -1){
1460
 
          perror_plus("setenv");
1461
 
          _exit(EX_OSERR);
1462
 
        }
1463
 
        char *delaystring;
1464
 
        ret = asprintf(&delaystring, "%f", delay);
1465
 
        if(ret == -1){
1466
 
          perror_plus("asprintf");
1467
 
          _exit(EX_OSERR);
1468
 
        }
1469
 
        ret = setenv("DELAY", delaystring, 1);
1470
 
        if(ret == -1){
1471
 
          free(delaystring);
1472
 
          perror_plus("setenv");
1473
 
          _exit(EX_OSERR);
1474
 
        }
 
2163
        _exit(EX_OSERR);
 
2164
      }
 
2165
      ret = setenv("DELAY", delaystring, 1);
 
2166
      if(ret == -1){
1475
2167
        free(delaystring);
1476
 
        if(connect_to != NULL){
1477
 
          ret = setenv("CONNECT", connect_to, 1);
1478
 
          if(ret == -1){
1479
 
            perror_plus("setenv");
1480
 
            _exit(EX_OSERR);
1481
 
          }
1482
 
        }
1483
 
        if(execl(fullname, direntry->d_name, mode, NULL) == -1){
1484
 
          perror_plus("execl");
1485
 
          _exit(EXIT_FAILURE);
1486
 
        }
1487
 
      } else {
1488
 
        int status;
1489
 
        if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1490
 
          perror_plus("waitpid");
1491
 
          free(fullname);
1492
 
          continue;
1493
 
        }
1494
 
        if(WIFEXITED(status)){
1495
 
          if(WEXITSTATUS(status) != 0){
1496
 
            fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1497
 
                         " with status %d\n", direntry->d_name,
1498
 
                         WEXITSTATUS(status));
1499
 
            free(fullname);
1500
 
            continue;
1501
 
          }
1502
 
        } else if(WIFSIGNALED(status)){
1503
 
          fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1504
 
                       " signal %d\n", direntry->d_name,
1505
 
                       WTERMSIG(status));
1506
 
          free(fullname);
1507
 
          continue;
1508
 
        } else {
1509
 
          fprintf_plus(stderr, "Warning: network hook \"%s\""
1510
 
                       " crashed\n", direntry->d_name);
1511
 
          free(fullname);
1512
 
          continue;
1513
 
        }
1514
 
      }
1515
 
      free(fullname);
1516
 
      if(debug){
1517
 
        fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1518
 
                     direntry->d_name);
1519
 
      }
1520
 
    }
1521
 
    close(devnull);
1522
 
  }
1523
 
  return true;
 
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;
1524
2460
}
1525
2461
 
1526
2462
int main(int argc, char *argv[]){
 
2463
  mandos_context mc = { .server = NULL, .dh_bits = 0,
 
2464
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
2465
                        .priority = "SECURE128:!CTYPE-X.509"
 
2466
                        ":+CTYPE-RAWPK:!RSA:!VERS-ALL:+VERS-TLS1.3"
 
2467
                        ":%PROFILE_ULTRA",
 
2468
#elif GNUTLS_VERSION_NUMBER < 0x030600
 
2469
                        .priority = "SECURE256:!CTYPE-X.509"
 
2470
                        ":+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256",
 
2471
#else
 
2472
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
 
2473
#endif
 
2474
                        .current_server = NULL, .interfaces = NULL,
 
2475
                        .interfaces_size = 0 };
1527
2476
  AvahiSServiceBrowser *sb = NULL;
1528
 
  int error;
 
2477
  error_t ret_errno;
1529
2478
  int ret;
1530
2479
  intmax_t tmpmax;
1531
2480
  char *tmp;
1532
2481
  int exitcode = EXIT_SUCCESS;
1533
 
  const char *interface = "";
1534
 
  struct ifreq network;
1535
 
  int sd = -1;
1536
 
  bool take_down_interface = false;
1537
 
  uid_t uid;
1538
 
  gid_t gid;
1539
 
  char tempdir[] = "/tmp/mandosXXXXXX";
1540
 
  bool tempdir_created = false;
 
2482
  char *interfaces_to_take_down = NULL;
 
2483
  size_t interfaces_to_take_down_size = 0;
 
2484
  char run_tempdir[] = "/run/tmp/mandosXXXXXX";
 
2485
  char old_tempdir[] = "/tmp/mandosXXXXXX";
 
2486
  char *tempdir = NULL;
1541
2487
  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1542
2488
  const char *seckey = PATHDIR "/" SECKEY;
1543
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;
1544
2496
  
1545
2497
  bool gnutls_initialized = false;
1546
2498
  bool gpgme_initialized = false;
1592
2544
      { .name = "pubkey", .key = 'p',
1593
2545
        .arg = "FILE",
1594
2546
        .doc = "OpenPGP public key file base name",
1595
 
        .group = 2 },
 
2547
        .group = 1 },
 
2548
      { .name = "tls-privkey", .key = 't',
 
2549
        .arg = "FILE",
 
2550
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
2551
        .doc = "TLS private key file base name",
 
2552
#else
 
2553
        .doc = "Dummy; ignored (requires GnuTLS 3.6.6)",
 
2554
#endif
 
2555
        .group = 1 },
 
2556
      { .name = "tls-pubkey", .key = 'T',
 
2557
        .arg = "FILE",
 
2558
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
2559
        .doc = "TLS public key file base name",
 
2560
#else
 
2561
        .doc = "Dummy; ignored (requires GnuTLS 3.6.6)",
 
2562
#endif
 
2563
        .group = 1 },
1596
2564
      { .name = "dh-bits", .key = 129,
1597
2565
        .arg = "BITS",
1598
2566
        .doc = "Bit length of the prime number used in the"
1599
2567
        " Diffie-Hellman key exchange",
1600
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 },
1601
2574
      { .name = "priority", .key = 130,
1602
2575
        .arg = "STRING",
1603
2576
        .doc = "GnuTLS priority string for the TLS handshake",
1637
2610
        connect_to = arg;
1638
2611
        break;
1639
2612
      case 'i':                 /* --interface */
1640
 
        interface = arg;
 
2613
        ret_errno = argz_add_sep(&mc.interfaces, &mc.interfaces_size,
 
2614
                                 arg, (int)',');
 
2615
        if(ret_errno != 0){
 
2616
          argp_error(state, "%s", strerror(ret_errno));
 
2617
        }
1641
2618
        break;
1642
2619
      case 's':                 /* --seckey */
1643
2620
        seckey = arg;
1645
2622
      case 'p':                 /* --pubkey */
1646
2623
        pubkey = arg;
1647
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;
1648
2635
      case 129:                 /* --dh-bits */
1649
2636
        errno = 0;
1650
2637
        tmpmax = strtoimax(arg, &tmp, 10);
1654
2641
        }
1655
2642
        mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
1656
2643
        break;
 
2644
      case 134:                 /* --dh-params */
 
2645
        dh_params_file = arg;
 
2646
        break;
1657
2647
      case 130:                 /* --priority */
1658
2648
        mc.priority = arg;
1659
2649
        break;
1699
2689
                         .args_doc = "",
1700
2690
                         .doc = "Mandos client -- Get and decrypt"
1701
2691
                         " passwords from a Mandos server" };
1702
 
    ret = argp_parse(&argp, argc, argv,
1703
 
                     ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
1704
 
    switch(ret){
 
2692
    ret_errno = argp_parse(&argp, argc, argv,
 
2693
                           ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
 
2694
    switch(ret_errno){
1705
2695
    case 0:
1706
2696
      break;
1707
2697
    case ENOMEM:
1708
2698
    default:
1709
 
      errno = ret;
 
2699
      errno = ret_errno;
1710
2700
      perror_plus("argp_parse");
1711
2701
      exitcode = EX_OSERR;
1712
2702
      goto end;
1715
2705
      goto end;
1716
2706
    }
1717
2707
  }
1718
 
    
 
2708
  
1719
2709
  {
1720
2710
    /* Work around Debian bug #633582:
1721
 
       <http://bugs.debian.org/633582> */
 
2711
       <https://bugs.debian.org/633582> */
1722
2712
    
1723
 
    /* Re-raise priviliges */
1724
 
    errno = 0;
1725
 
    ret = seteuid(0);
1726
 
    if(ret == -1){
1727
 
      perror_plus("seteuid");
 
2713
    /* Re-raise privileges */
 
2714
    ret = raise_privileges();
 
2715
    if(ret != 0){
 
2716
      errno = ret;
 
2717
      perror_plus("Failed to raise privileges");
1728
2718
    } else {
1729
2719
      struct stat st;
1730
2720
      
1745
2735
              }
1746
2736
            }
1747
2737
          }
1748
 
          TEMP_FAILURE_RETRY(close(seckey_fd));
 
2738
          close(seckey_fd);
1749
2739
        }
1750
2740
      }
1751
 
    
 
2741
      
1752
2742
      if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
1753
2743
        int pubkey_fd = open(pubkey, O_RDONLY);
1754
2744
        if(pubkey_fd == -1){
1766
2756
              }
1767
2757
            }
1768
2758
          }
1769
 
          TEMP_FAILURE_RETRY(close(pubkey_fd));
1770
 
        }
1771
 
      }
1772
 
    
 
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
      
1773
2785
      /* Lower privileges */
1774
 
      errno = 0;
1775
 
      ret = seteuid(uid);
1776
 
      if(ret == -1){
1777
 
        perror_plus("seteuid");
 
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;
1778
2807
      }
1779
2808
    }
1780
2809
  }
1781
2810
  
1782
2811
  /* Run network hooks */
1783
 
  if(not run_network_hooks("start", interface, delay)){
1784
 
    goto end;
 
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);
1785
2824
  }
1786
2825
  
1787
2826
  if(not debug){
1788
2827
    avahi_set_log_function(empty_log);
1789
2828
  }
1790
2829
  
1791
 
  if(interface[0] == '\0'){
1792
 
    struct dirent **direntries;
1793
 
    /* First look for interfaces that are up */
1794
 
    ret = scandir(sys_class_net, &direntries, up_interface,
1795
 
                  alphasort);
1796
 
    if(ret == 0){
1797
 
      /* No up interfaces, look for any good interfaces */
1798
 
      free(direntries);
1799
 
      ret = scandir(sys_class_net, &direntries, good_interface,
1800
 
                    alphasort);
1801
 
    }
1802
 
    if(ret >= 1){
1803
 
      /* Pick the first interface returned */
1804
 
      interface = strdup(direntries[0]->d_name);
1805
 
      if(debug){
1806
 
        fprintf_plus(stderr, "Using interface \"%s\"\n", interface);
1807
 
      }
1808
 
      if(interface == NULL){
1809
 
        perror_plus("malloc");
1810
 
        free(direntries);
1811
 
        exitcode = EXIT_FAILURE;
1812
 
        goto end;
1813
 
      }
1814
 
      free(direntries);
1815
 
    } else {
1816
 
      free(direntries);
1817
 
      fprintf_plus(stderr, "Could not find a network interface\n");
1818
 
      exitcode = EXIT_FAILURE;
1819
 
      goto end;
1820
 
    }
1821
 
  }
1822
 
  
1823
2830
  /* Initialize Avahi early so avahi_simple_poll_quit() can be called
1824
2831
     from the signal handler */
1825
2832
  /* Initialize the pseudo-RNG for Avahi */
1826
2833
  srand((unsigned int) time(NULL));
1827
 
  mc.simple_poll = avahi_simple_poll_new();
1828
 
  if(mc.simple_poll == NULL){
 
2834
  simple_poll = avahi_simple_poll_new();
 
2835
  if(simple_poll == NULL){
1829
2836
    fprintf_plus(stderr,
1830
2837
                 "Avahi: Failed to create simple poll object.\n");
1831
2838
    exitcode = EX_UNAVAILABLE;
1895
2902
    }
1896
2903
  }
1897
2904
  
1898
 
  /* If the interface is down, bring it up */
1899
 
  if(strcmp(interface, "none") != 0){
1900
 
    if_index = (AvahiIfIndex) if_nametoindex(interface);
1901
 
    if(if_index == 0){
1902
 
      fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1903
 
      exitcode = EX_UNAVAILABLE;
1904
 
      goto end;
1905
 
    }
1906
 
    
1907
 
    if(quit_now){
1908
 
      goto end;
1909
 
    }
1910
 
    
1911
 
    /* Re-raise priviliges */
1912
 
    errno = 0;
1913
 
    ret = seteuid(0);
1914
 
    if(ret == -1){
1915
 
      perror_plus("seteuid");
1916
 
    }
1917
 
    
1918
 
#ifdef __linux__
1919
 
    /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1920
 
       messages about the network interface to mess up the prompt */
1921
 
    ret = klogctl(8, NULL, 5);
1922
 
    bool restore_loglevel = true;
1923
 
    if(ret == -1){
1924
 
      restore_loglevel = false;
1925
 
      perror_plus("klogctl");
1926
 
    }
1927
 
#endif  /* __linux__ */
1928
 
    
1929
 
    sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1930
 
    if(sd < 0){
1931
 
      perror_plus("socket");
1932
 
      exitcode = EX_OSERR;
1933
 
#ifdef __linux__
1934
 
      if(restore_loglevel){
1935
 
        ret = klogctl(7, NULL, 0);
1936
 
        if(ret == -1){
1937
 
          perror_plus("klogctl");
1938
 
        }
1939
 
      }
1940
 
#endif  /* __linux__ */
1941
 
      /* Lower privileges */
1942
 
      errno = 0;
1943
 
      ret = seteuid(uid);
1944
 
      if(ret == -1){
1945
 
        perror_plus("seteuid");
1946
 
      }
1947
 
      goto end;
1948
 
    }
1949
 
    strcpy(network.ifr_name, interface);
1950
 
    ret = ioctl(sd, SIOCGIFFLAGS, &network);
1951
 
    if(ret == -1){
1952
 
      perror_plus("ioctl SIOCGIFFLAGS");
1953
 
#ifdef __linux__
1954
 
      if(restore_loglevel){
1955
 
        ret = klogctl(7, NULL, 0);
1956
 
        if(ret == -1){
1957
 
          perror_plus("klogctl");
1958
 
        }
1959
 
      }
1960
 
#endif  /* __linux__ */
1961
 
      exitcode = EX_OSERR;
1962
 
      /* Lower privileges */
1963
 
      errno = 0;
1964
 
      ret = seteuid(uid);
1965
 
      if(ret == -1){
1966
 
        perror_plus("seteuid");
1967
 
      }
1968
 
      goto end;
1969
 
    }
1970
 
    if((network.ifr_flags & IFF_UP) == 0){
1971
 
      network.ifr_flags |= IFF_UP;
1972
 
      take_down_interface = true;
1973
 
      ret = ioctl(sd, SIOCSIFFLAGS, &network);
1974
 
      if(ret == -1){
1975
 
        take_down_interface = false;
1976
 
        perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1977
 
        exitcode = EX_OSERR;
1978
 
#ifdef __linux__
1979
 
        if(restore_loglevel){
1980
 
          ret = klogctl(7, NULL, 0);
1981
 
          if(ret == -1){
1982
 
            perror_plus("klogctl");
 
2905
  /* If no interfaces were specified, make a list */
 
2906
  if(mc.interfaces == NULL){
 
2907
    struct dirent **direntries = NULL;
 
2908
    /* Look for any good interfaces */
 
2909
    ret = scandir(sys_class_net, &direntries, good_interface,
 
2910
                  alphasort);
 
2911
    if(ret >= 1){
 
2912
      /* Add all found interfaces to interfaces list */
 
2913
      for(int i = 0; i < ret; ++i){
 
2914
        ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
 
2915
                             direntries[i]->d_name);
 
2916
        if(ret_errno != 0){
 
2917
          errno = ret_errno;
 
2918
          perror_plus("argz_add");
 
2919
          free(direntries[i]);
 
2920
          continue;
 
2921
        }
 
2922
        if(debug){
 
2923
          fprintf_plus(stderr, "Will use interface \"%s\"\n",
 
2924
                       direntries[i]->d_name);
 
2925
        }
 
2926
        free(direntries[i]);
 
2927
      }
 
2928
      free(direntries);
 
2929
    } else {
 
2930
      if(ret == 0){
 
2931
        free(direntries);
 
2932
      }
 
2933
      fprintf_plus(stderr, "Could not find a network interface\n");
 
2934
      exitcode = EXIT_FAILURE;
 
2935
      goto end;
 
2936
    }
 
2937
  }
 
2938
  
 
2939
  /* Bring up interfaces which are down, and remove any "none"s */
 
2940
  {
 
2941
    char *interface = NULL;
 
2942
    while((interface = argz_next(mc.interfaces, mc.interfaces_size,
 
2943
                                 interface))){
 
2944
      /* If interface name is "none", stop bringing up interfaces.
 
2945
         Also remove all instances of "none" from the list */
 
2946
      if(strcmp(interface, "none") == 0){
 
2947
        argz_delete(&mc.interfaces, &mc.interfaces_size,
 
2948
                    interface);
 
2949
        interface = NULL;
 
2950
        while((interface = argz_next(mc.interfaces,
 
2951
                                     mc.interfaces_size, interface))){
 
2952
          if(strcmp(interface, "none") == 0){
 
2953
            argz_delete(&mc.interfaces, &mc.interfaces_size,
 
2954
                        interface);
 
2955
            interface = NULL;
1983
2956
          }
1984
2957
        }
1985
 
#endif  /* __linux__ */
1986
 
        /* Lower privileges */
1987
 
        errno = 0;
1988
 
        ret = seteuid(uid);
1989
 
        if(ret == -1){
1990
 
          perror_plus("seteuid");
1991
 
        }
1992
 
        goto end;
1993
 
      }
1994
 
    }
1995
 
    /* Sleep checking until interface is running.
1996
 
       Check every 0.25s, up to total time of delay */
1997
 
    for(int i=0; i < delay * 4; i++){
1998
 
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
1999
 
      if(ret == -1){
2000
 
        perror_plus("ioctl SIOCGIFFLAGS");
2001
 
      } else if(network.ifr_flags & IFF_RUNNING){
2002
2958
        break;
2003
2959
      }
2004
 
      struct timespec sleeptime = { .tv_nsec = 250000000 };
2005
 
      ret = nanosleep(&sleeptime, NULL);
2006
 
      if(ret == -1 and errno != EINTR){
2007
 
        perror_plus("nanosleep");
2008
 
      }
2009
 
    }
2010
 
    if(not take_down_interface){
2011
 
      /* We won't need the socket anymore */
2012
 
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
2013
 
      if(ret == -1){
2014
 
        perror_plus("close");
2015
 
      }
2016
 
    }
2017
 
#ifdef __linux__
2018
 
    if(restore_loglevel){
2019
 
      /* Restores kernel loglevel to default */
2020
 
      ret = klogctl(7, NULL, 0);
2021
 
      if(ret == -1){
2022
 
        perror_plus("klogctl");
2023
 
      }
2024
 
    }
2025
 
#endif  /* __linux__ */
2026
 
    /* Lower privileges */
2027
 
    errno = 0;
2028
 
    /* Lower privileges */
2029
 
    ret = seteuid(uid);
2030
 
    if(ret == -1){
2031
 
      perror_plus("seteuid");
2032
 
    }
 
2960
      bool interface_was_up = interface_is_up(interface);
 
2961
      errno = bring_up_interface(interface, delay);
 
2962
      if(not interface_was_up){
 
2963
        if(errno != 0){
 
2964
          fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
 
2965
                       " %s\n", interface, strerror(errno));
 
2966
        } else {
 
2967
          errno = argz_add(&interfaces_to_take_down,
 
2968
                           &interfaces_to_take_down_size,
 
2969
                           interface);
 
2970
          if(errno != 0){
 
2971
            perror_plus("argz_add");
 
2972
          }
 
2973
        }
 
2974
      }
 
2975
    }
 
2976
    if(debug and (interfaces_to_take_down == NULL)){
 
2977
      fprintf_plus(stderr, "No interfaces were brought up\n");
 
2978
    }
 
2979
  }
 
2980
  
 
2981
  /* If we only got one interface, explicitly use only that one */
 
2982
  if(argz_count(mc.interfaces, mc.interfaces_size) == 1){
 
2983
    if(debug){
 
2984
      fprintf_plus(stderr, "Using only interface \"%s\"\n",
 
2985
                   mc.interfaces);
 
2986
    }
 
2987
    if_index = (AvahiIfIndex)if_nametoindex(mc.interfaces);
2033
2988
  }
2034
2989
  
2035
2990
  if(quit_now){
2036
2991
    goto end;
2037
2992
  }
2038
2993
  
2039
 
  ret = init_gnutls_global(pubkey, seckey);
 
2994
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
2995
  ret = init_gnutls_global(tls_pubkey, tls_privkey, dh_params_file, &mc);
 
2996
#elif GNUTLS_VERSION_NUMBER < 0x030600
 
2997
  ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
 
2998
#else
 
2999
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
 
3000
#endif
2040
3001
  if(ret == -1){
2041
3002
    fprintf_plus(stderr, "init_gnutls_global failed\n");
2042
3003
    exitcode = EX_UNAVAILABLE;
2049
3010
    goto end;
2050
3011
  }
2051
3012
  
2052
 
  if(mkdtemp(tempdir) == NULL){
 
3013
  /* Try /run/tmp before /tmp */
 
3014
  tempdir = mkdtemp(run_tempdir);
 
3015
  if(tempdir == NULL and errno == ENOENT){
 
3016
      if(debug){
 
3017
        fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
 
3018
                     run_tempdir, old_tempdir);
 
3019
      }
 
3020
      tempdir = mkdtemp(old_tempdir);
 
3021
  }
 
3022
  if(tempdir == NULL){
2053
3023
    perror_plus("mkdtemp");
2054
3024
    goto end;
2055
3025
  }
2056
 
  tempdir_created = true;
2057
3026
  
2058
3027
  if(quit_now){
2059
3028
    goto end;
2060
3029
  }
2061
3030
  
2062
 
  if(not init_gpgme(pubkey, seckey, tempdir)){
 
3031
  if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
2063
3032
    fprintf_plus(stderr, "init_gpgme failed\n");
2064
3033
    exitcode = EX_UNAVAILABLE;
2065
3034
    goto end;
2075
3044
    /* Connect directly, do not use Zeroconf */
2076
3045
    /* (Mainly meant for debugging) */
2077
3046
    char *address = strrchr(connect_to, ':');
 
3047
    
2078
3048
    if(address == NULL){
2079
3049
      fprintf_plus(stderr, "No colon in address\n");
2080
3050
      exitcode = EX_USAGE;
2085
3055
      goto end;
2086
3056
    }
2087
3057
    
2088
 
    uint16_t port;
 
3058
    in_port_t port;
2089
3059
    errno = 0;
2090
3060
    tmpmax = strtoimax(address+1, &tmp, 10);
2091
3061
    if(errno != 0 or tmp == address+1 or *tmp != '\0'
2092
 
       or tmpmax != (uint16_t)tmpmax){
 
3062
       or tmpmax != (in_port_t)tmpmax){
2093
3063
      fprintf_plus(stderr, "Bad port number\n");
2094
3064
      exitcode = EX_USAGE;
2095
3065
      goto end;
2096
3066
    }
2097
 
  
 
3067
    
2098
3068
    if(quit_now){
2099
3069
      goto end;
2100
3070
    }
2101
3071
    
2102
 
    port = (uint16_t)tmpmax;
 
3072
    port = (in_port_t)tmpmax;
2103
3073
    *address = '\0';
2104
3074
    /* Colon in address indicates IPv6 */
2105
3075
    int af;
2121
3091
    }
2122
3092
    
2123
3093
    while(not quit_now){
2124
 
      ret = start_mandos_communication(address, port, if_index, af);
 
3094
      ret = start_mandos_communication(address, port, if_index, af,
 
3095
                                       &mc);
2125
3096
      if(quit_now or ret == 0){
2126
3097
        break;
2127
3098
      }
2129
3100
        fprintf_plus(stderr, "Retrying in %d seconds\n",
2130
3101
                     (int)retry_interval);
2131
3102
      }
2132
 
      sleep((int)retry_interval);
 
3103
      sleep((unsigned int)retry_interval);
2133
3104
    }
2134
3105
    
2135
 
    if (not quit_now){
 
3106
    if(not quit_now){
2136
3107
      exitcode = EXIT_SUCCESS;
2137
3108
    }
2138
3109
    
2153
3124
    config.publish_domain = 0;
2154
3125
    
2155
3126
    /* Allocate a new server */
2156
 
    mc.server = avahi_server_new(avahi_simple_poll_get
2157
 
                                 (mc.simple_poll), &config, NULL,
2158
 
                                 NULL, &error);
 
3127
    mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
 
3128
                                 &config, NULL, NULL, &ret);
2159
3129
    
2160
3130
    /* Free the Avahi configuration data */
2161
3131
    avahi_server_config_free(&config);
2164
3134
  /* Check if creating the Avahi server object succeeded */
2165
3135
  if(mc.server == NULL){
2166
3136
    fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2167
 
                 avahi_strerror(error));
 
3137
                 avahi_strerror(ret));
2168
3138
    exitcode = EX_UNAVAILABLE;
2169
3139
    goto end;
2170
3140
  }
2176
3146
  /* Create the Avahi service browser */
2177
3147
  sb = avahi_s_service_browser_new(mc.server, if_index,
2178
3148
                                   AVAHI_PROTO_UNSPEC, "_mandos._tcp",
2179
 
                                   NULL, 0, browse_callback, NULL);
 
3149
                                   NULL, 0, browse_callback,
 
3150
                                   (void *)&mc);
2180
3151
  if(sb == NULL){
2181
3152
    fprintf_plus(stderr, "Failed to create service browser: %s\n",
2182
3153
                 avahi_strerror(avahi_server_errno(mc.server)));
2193
3164
  if(debug){
2194
3165
    fprintf_plus(stderr, "Starting Avahi loop search\n");
2195
3166
  }
2196
 
 
2197
 
  ret = avahi_loop_with_timeout(mc.simple_poll,
2198
 
                                (int)(retry_interval * 1000));
 
3167
  
 
3168
  ret = avahi_loop_with_timeout(simple_poll,
 
3169
                                (int)(retry_interval * 1000), &mc);
2199
3170
  if(debug){
2200
3171
    fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
2201
3172
                 (ret == 0) ? "successfully" : "with error");
2204
3175
 end:
2205
3176
  
2206
3177
  if(debug){
2207
 
    fprintf_plus(stderr, "%s exiting\n", argv[0]);
 
3178
    if(signal_received){
 
3179
      fprintf_plus(stderr, "%s exiting due to signal %d: %s\n",
 
3180
                   argv[0], signal_received,
 
3181
                   strsignal(signal_received));
 
3182
    } else {
 
3183
      fprintf_plus(stderr, "%s exiting\n", argv[0]);
 
3184
    }
2208
3185
  }
2209
3186
  
2210
3187
  /* Cleanup things */
 
3188
  free(mc.interfaces);
 
3189
  
2211
3190
  if(sb != NULL)
2212
3191
    avahi_s_service_browser_free(sb);
2213
3192
  
2214
3193
  if(mc.server != NULL)
2215
3194
    avahi_server_free(mc.server);
2216
3195
  
2217
 
  if(mc.simple_poll != NULL)
2218
 
    avahi_simple_poll_free(mc.simple_poll);
 
3196
  if(simple_poll != NULL)
 
3197
    avahi_simple_poll_free(simple_poll);
2219
3198
  
2220
3199
  if(gnutls_initialized){
2221
3200
    gnutls_certificate_free_credentials(mc.cred);
2222
 
    gnutls_global_deinit();
2223
3201
    gnutls_dh_params_deinit(mc.dh_params);
2224
3202
  }
2225
3203
  
2233
3211
    mc.current_server->prev->next = NULL;
2234
3212
    while(mc.current_server != NULL){
2235
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
2236
3222
      free(mc.current_server);
2237
3223
      mc.current_server = next;
2238
3224
    }
2239
3225
  }
2240
3226
  
2241
 
  /* Run network hooks */
2242
 
  run_network_hooks("stop", interface, delay);
2243
 
  
2244
 
  /* Re-raise priviliges */
 
3227
  /* Re-raise privileges */
2245
3228
  {
2246
 
    errno = 0;
2247
 
    ret = seteuid(0);
2248
 
    if(ret == -1){
2249
 
      perror_plus("seteuid");
 
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
      }
2250
3256
    }
2251
3257
    
2252
 
    /* Take down the network interface */
2253
 
    if(take_down_interface and geteuid() == 0){
2254
 
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
2255
 
      if(ret == -1){
2256
 
        perror_plus("ioctl SIOCGIFFLAGS");
2257
 
      } else if(network.ifr_flags & IFF_UP){
2258
 
        network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
2259
 
        ret = ioctl(sd, SIOCSIFFLAGS, &network);
2260
 
        if(ret == -1){
2261
 
          perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
2262
 
        }
2263
 
      }
2264
 
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
2265
 
      if(ret == -1){
2266
 
        perror_plus("close");
2267
 
      }
 
3258
    ret = lower_privileges_permanently();
 
3259
    if(ret != 0){
 
3260
      errno = ret;
 
3261
      perror_plus("Failed to lower privileges permanently");
2268
3262
    }
2269
3263
  }
2270
 
  /* Lower privileges permanently */
2271
 
  errno = 0;
2272
 
  ret = setuid(uid);
2273
 
  if(ret == -1){
2274
 
    perror_plus("setuid");
 
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);
2275
3320
  }
2276
3321
  
2277
3322
  /* Removes the GPGME temp directory and all files inside */
2278
 
  if(tempdir_created){
2279
 
    struct dirent **direntries = NULL;
2280
 
    struct dirent *direntry = NULL;
2281
 
    int numentries = scandir(tempdir, &direntries, notdotentries,
2282
 
                             alphasort);
2283
 
    if (numentries > 0){
2284
 
      for(int i = 0; i < numentries; i++){
2285
 
        direntry = direntries[i];
2286
 
        char *fullname = NULL;
2287
 
        ret = asprintf(&fullname, "%s/%s", tempdir,
2288
 
                       direntry->d_name);
2289
 
        if(ret < 0){
2290
 
          perror_plus("asprintf");
2291
 
          continue;
2292
 
        }
2293
 
        ret = remove(fullname);
2294
 
        if(ret == -1){
2295
 
          fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2296
 
                       strerror(errno));
2297
 
        }
2298
 
        free(fullname);
2299
 
      }
2300
 
    }
2301
 
 
2302
 
    /* need to clean even if 0 because man page doesn't specify */
2303
 
    free(direntries);
2304
 
    if (numentries == -1){
2305
 
      perror_plus("scandir");
2306
 
    }
2307
 
    ret = rmdir(tempdir);
2308
 
    if(ret == -1 and errno != ENOENT){
2309
 
      perror_plus("rmdir");
2310
 
    }
 
3323
  if(tempdir != NULL){
 
3324
    clean_dir_at(-1, tempdir, 0);
2311
3325
  }
2312
3326
  
2313
3327
  if(quit_now){