/mandos/release

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

« back to all changes in this revision

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

* network-hooks.d: New directory.
* network-hooks.d/bridge: New example hook.
* network-hooks.d/bridge.conf: Config file for bridge example hook.

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