/mandos/trunk

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

« back to all changes in this revision

Viewing changes to plugins.d/mandos-client.c

  • Committer: Teddy Hogeborn
  • Date: 2019-04-09 19:33:36 UTC
  • Revision ID: teddy@recompile.se-20190409193336-6sddo74ybosqog38
Installation: Fix UMASK even if set by some other initramfs hook

* Makefile (install-client-nokey): Install initramfs-tools-conf-hook
               as "/usr/share/initramfs-tools/conf-hooks.d/zz-mandos".
* debian/mandos-client.dirs: Add
  "usr/share/initramfs-tools/conf-hooks.d".
* initramfs-tools-conf-hook: New.

Show diffs side-by-side

added added

removed removed

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