/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/mandosclient.c

  • Committer: Teddy Hogeborn
  • Date: 2008-08-03 03:33:56 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080803033356-6aemgj0g0hoz91ow
* plugins.d/mandosclient.c (pgp_packet_decrypt): Renamed variables.
                                                 On debug, show
                                                 decrypted plaintext
                                                 in hexadecimal.  Free
                                                 the GPGME data
                                                 buffers even on
                                                 errors.

Show diffs side-by-side

added added

removed removed

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