/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: 2021-02-01 19:30:45 UTC
  • Revision ID: teddy@recompile.se-20210201193045-lpg6aprpc4srem6k
Fix issue with french translation

Initial white space was missing in both msgid and msgstr of the french
translation, leading to checking tools reporing an incomplete
translation.  The string is a raw command line command, and therefore
did not need translation, so this was never a user-visible issue.

* debian/po/fr.po: Add missing whitespace to the id and translation
  for msgid " mandos-keygen -F/dev/null|grep ^key_id".

Show diffs side-by-side

added added

removed removed

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