/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/mandos-client.c

  • Committer: Teddy Hogeborn
  • Date: 2017-08-20 16:20:54 UTC
  • mto: (237.7.594 trunk)
  • mto: This revision was merged to the branch mainline in revision 360.
  • Revision ID: teddy@recompile.se-20170820162054-jwig602syxx2k4l0
Alter copyright notices slightly.  Actual license is unchanged!

This alters all copyright notices to use the Free Software
Foundation's recommendations for license notices; from
<https://www.gnu.org/licenses/gpl-howto.html>:

  For programs that are more than one file, it is better to replace
  “this program” with the name of the program, and begin the statement
  with a line saying “This file is part of NAME”.

* DBUS-API: Use program name "Mandos" explicitly in license notice.
* debian/copyright: - '' -
* initramfs-unpack: - '' -
* legalnotice.xml: - '' -
* mandos: - '' -
* mandos-ctl: - '' -
* mandos-keygen: - '' -
* mandos-monitor: - '' -
* plugin-helpers/mandos-client-iprouteadddel.c: - '' -
* plugin-runner.c: - '' -
* plugins.d/askpass-fifo.c: - '' -
* plugins.d/mandos-client.c: - '' -
* plugins.d/password-prompt.c: - '' -
* plugins.d/plymouth.c: - '' -
* plugins.d/splashy.c: - '' -
* plugins.d/usplash.c: - '' -

Show diffs side-by-side

added added

removed removed

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