/mandos/trunk

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

« back to all changes in this revision

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

  • Committer: Teddy Hogeborn
  • Date: 2019-02-10 03:50:20 UTC
  • Revision ID: teddy@recompile.se-20190210035020-nttr1tybgwwixueu
Show debconf note about new TLS key IDs

If mandos-client did not see TLS keys and had to create them, or if
mandos sees GnuTLS version 3.6.6 or later, show an important notice on
package installation about the importance of adding the new key_id
options to clients.conf on the Mandos server.

* debian/control (Package: mandos, Package: mandos-client): Depend on
                                                            debconf.
* debian/mandos-client.lintian-overrides: Override warnings.
* debian/mandos-client.postinst (create_keys): Show notice if new TLS
                                               key files were created.
* debian/mandos-client.templates: New.
* debian/mandos.lintian-overrides: Override warnings.
* debian/mandos.postinst (configure): If GnuTLS 3.6.6 or later is
                                      detected, show an important
                                      notice (once) about the new
                                      key_id option required in
                                      clients.conf.
* debian/mandos.templates: New.

Show diffs side-by-side

added added

removed removed

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