/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: 2015-03-10 18:03:38 UTC
  • Revision ID: teddy@recompile.se-20150310180338-pcxw6r2qmw9k6br9
Add ":!RSA" to GnuTLS priority string, to disallow non-DHE kx.

If Mandos was somehow made to use a non-ephemeral Diffie-Hellman key
exchange algorithm in the TLS handshake, any saved network traffic
could then be decrypted later if the Mandos client key was obtained.
By default, Mandos uses ephemeral DH key exchanges which does not have
this problem, but a non-ephemeral key exchange algorithm was still
enabled by default.  The simplest solution is to simply turn that off,
which ensures that Mandos will always use ephemeral DH key exchanges.

There is a "PFS" priority string specifier, but we can't use it because:

1. Security-wise, it is a mix between "NORMAL" and "SECURE128" - it
   enables a lot more algorithms than "SECURE256".

2. It is only available since GnuTLS 3.2.4.

Thanks to Andreas Fischer <af@bantuX.org> for reporting this issue.

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