/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 at recompile
  • Date: 2020-12-03 20:30:45 UTC
  • Revision ID: teddy@recompile.se-20201203203045-iqd6nq9y5nwalh1x
Minor fix of a test function

In dracut-module/password-agent, the test function
test_send_password_to_socket_EMSGSIZE() (which tests that the
send_password_to_socket() task function aborts properly when getting
EMSGSIZE when writing to the password socket), part of the test code
is supposed to find a message size which definitely does trigger
EMSGSIZE when send()ing to a socket.  Without a "break" in the proper
place, however, the size given is always exactly 1024 bytes too large.

This is very probably not a problem, since a too large message will
still be too large if it is increased by 1024 bytes, and send(2) in
practice checks the size before reading the buffer.  The biggest issue
would be if some version of send(2) would try to look at the last 1024
bytes of the message buffer before checking the message size; this
would then lead to a buffer over-read when running this test function.
(But even then there would be no security implications since the tests
are not run in the normal operation of the program.)

* dracut-module/password-agent.c
  (test_send_password_to_socket_EMSGSIZE): Break out early when ssret
  < 0 and errno == EMSGSIZE; don't allow loop to increase message_size
  again.

Show diffs side-by-side

added added

removed removed

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