/mandos/release

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

« back to all changes in this revision

Viewing changes to plugins.d/mandosclient.c

  • Committer: Björn Påhlsson
  • Date: 2008-07-20 02:52:20 UTC
  • Revision ID: belorn@braxen-20080720025220-r5u0388uy9iu23h6
Added following support:
Pluginbased client handler
rewritten Mandos client
       Avahi instead of udp server discovery
       openpgp encrypted key support
Passprompt stand alone application for direct console input
Added logging for Mandos server

Show diffs side-by-side

added added

removed removed

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