/mandos/trunk

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

« back to all changes in this revision

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

  • Committer: Teddy Hogeborn
  • Date: 2016-03-17 20:40:55 UTC
  • Revision ID: teddy@recompile.se-20160317204055-bhsh5xsidq7w5cxu
Client: Fix plymouth agent; broken since 1.7.2.

Fix an very old memory bug in the plymouth agent (which has been
present since its apperance in version 1.2), but which was only
recently detected at run time due to the new -fsanitize=address
compile- time flag, which has been used since version 1.7.2.  This
detection of a memory access violation causes the program to abort,
making the Plymouth graphical boot system unable to accept interactive
input of passwords when using the Mandos client.

* plugins.d/plymouth.c (exec_and_wait): Fix memory allocation bug when
  allocating new_argv.  Also tolerate a zero-length argv.

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