/mandos/trunk

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

« back to all changes in this revision

Viewing changes to plugins.d/mandosclient.c

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

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/*  -*- coding: utf-8 -*- */
2
 
/*
3
 
 * Mandos-client - get and decrypt data from a Mandos server
 
1
/* $Id$ */
 
2
 
 
3
/* PLEASE NOTE *
 
4
 * This file demonstrates how to use Avahi's core API, this is
 
5
 * the embeddable mDNS stack for embedded applications.
4
6
 *
5
 
 * This program is partly derived from an example program for an Avahi
6
 
 * service browser, downloaded from
7
 
 * <http://avahi.org/browser/examples/core-browse-services.c>.  This
8
 
 * includes the following functions: "resolve_callback",
9
 
 * "browse_callback", and parts of "main".
10
 
 * 
11
 
 * Everything else is
12
 
 * Copyright © 2008-2011 Teddy Hogeborn
13
 
 * Copyright © 2008-2011 Björn Påhlsson
14
 
 * 
15
 
 * This program is free software: you can redistribute it and/or
16
 
 * modify it under the terms of the GNU General Public License as
17
 
 * published by the Free Software Foundation, either version 3 of the
18
 
 * License, or (at your option) any later version.
19
 
 * 
20
 
 * This program is distributed in the hope that it will be useful, but
21
 
 * WITHOUT ANY WARRANTY; without even the implied warranty of
22
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
23
 
 * General Public License for more details.
24
 
 * 
25
 
 * You should have received a copy of the GNU General Public License
26
 
 * along with this program.  If not, see
27
 
 * <http://www.gnu.org/licenses/>.
28
 
 * 
29
 
 * Contact the authors at <mandos@recompile.se>.
 
7
 * End user applications should *not* use this API and should use
 
8
 * the D-Bus or C APIs, please see
 
9
 * client-browse-services.c and glib-integration.c
 
10
 * 
 
11
 * I repeat, you probably do *not* want to use this example.
30
12
 */
31
13
 
32
 
/* Needed by GPGME, specifically gpgme_data_seek() */
33
 
#ifndef _LARGEFILE_SOURCE
 
14
/***
 
15
  This file is part of avahi.
 
16
 
 
17
  avahi is free software; you can redistribute it and/or modify it
 
18
  under the terms of the GNU Lesser General Public License as
 
19
  published by the Free Software Foundation; either version 2.1 of the
 
20
  License, or (at your option) any later version.
 
21
 
 
22
  avahi is distributed in the hope that it will be useful, but WITHOUT
 
23
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 
24
  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
 
25
  Public License for more details.
 
26
 
 
27
  You should have received a copy of the GNU Lesser General Public
 
28
  License along with avahi; if not, write to the Free Software
 
29
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 
30
  USA.
 
31
***/
 
32
 
34
33
#define _LARGEFILE_SOURCE
35
 
#endif
36
 
#ifndef _FILE_OFFSET_BITS
37
34
#define _FILE_OFFSET_BITS 64
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_* */
 
35
 
 
36
#include <stdio.h>
 
37
#include <assert.h>
 
38
#include <stdlib.h>
 
39
#include <time.h>
 
40
#include <net/if.h>             /* if_nametoindex */
 
41
 
99
42
#include <avahi-core/core.h>
100
43
#include <avahi-core/lookup.h>
101
44
#include <avahi-core/log.h>
103
46
#include <avahi-common/malloc.h>
104
47
#include <avahi-common/error.h>
105
48
 
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_* */
122
 
 
 
49
//mandos client part
 
50
#include <sys/types.h>          /* socket(), setsockopt(), inet_pton() */
 
51
#include <sys/socket.h>         /* socket(), setsockopt(), struct sockaddr_in6, struct in6_addr, inet_pton() */
 
52
#include <gnutls/gnutls.h>      /* ALL GNUTLS STUFF */
 
53
#include <gnutls/openpgp.h>     /* gnutls with openpgp stuff */
 
54
 
 
55
#include <unistd.h>             /* close() */
 
56
#include <netinet/in.h>
 
57
#include <stdbool.h>            /* true */
 
58
#include <string.h>             /* memset */
 
59
#include <arpa/inet.h>          /* inet_pton() */
 
60
#include <iso646.h>             /* not */
 
61
 
 
62
// gpgme
 
63
#include <errno.h>              /* perror() */
 
64
#include <gpgme.h>
 
65
 
 
66
 
 
67
#ifndef CERT_ROOT
 
68
#define CERT_ROOT "/conf/conf.d/cryptkeyreq/"
 
69
#endif
 
70
#define CERTFILE CERT_ROOT "openpgp-client.txt"
 
71
#define KEYFILE CERT_ROOT "openpgp-client-key.txt"
123
72
#define BUFFER_SIZE 256
124
 
 
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"
129
 
 
130
 
bool debug = false;
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 */
 
73
#define DH_BITS 1024
 
74
 
150
75
typedef struct {
151
 
  AvahiSimplePoll *simple_poll;
152
 
  AvahiServer *server;
 
76
  gnutls_session_t session;
153
77
  gnutls_certificate_credentials_t cred;
154
 
  unsigned int dh_bits;
155
78
  gnutls_dh_params_t dh_params;
156
 
  const char *priority;
 
79
} encrypted_session;
 
80
 
 
81
 
 
82
ssize_t gpg_packet_decrypt (char *packet, size_t packet_size, char **new_packet, char *homedir){
 
83
  gpgme_data_t dh_crypto, dh_plain;
157
84
  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){
245
85
  gpgme_error_t rc;
 
86
  ssize_t ret;
 
87
  size_t new_packet_capacity = 0;
 
88
  size_t new_packet_length = 0;
246
89
  gpgme_engine_info_t engine_info;
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");
287
 
  }
288
 
  
 
90
 
289
91
  /* Init GPGME */
290
92
  gpgme_check_version(NULL);
291
 
  rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
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;
296
 
  }
 
93
  gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
297
94
  
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;
 
95
  /* Set GPGME home directory */
 
96
  rc = gpgme_get_engine_info (&engine_info);
 
97
  if (rc != GPG_ERR_NO_ERROR){
 
98
    fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
 
99
            gpgme_strsource(rc), gpgme_strerror(rc));
 
100
    return -1;
304
101
  }
305
102
  while(engine_info != NULL){
306
103
    if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){
307
104
      gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,
308
 
                            engine_info->file_name, tempdir);
 
105
                            engine_info->file_name, homedir);
309
106
      break;
310
107
    }
311
108
    engine_info = engine_info->next;
312
109
  }
313
110
  if(engine_info == NULL){
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));
 
111
    fprintf(stderr, "Could not set home dir to %s\n", homedir);
 
112
    return -1;
 
113
  }
 
114
  
 
115
  /* Create new GPGME data buffer from packet buffer */
 
116
  rc = gpgme_data_new_from_mem(&dh_crypto, packet, packet_size, 0);
 
117
  if (rc != GPG_ERR_NO_ERROR){
 
118
    fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
 
119
            gpgme_strsource(rc), gpgme_strerror(rc));
358
120
    return -1;
359
121
  }
360
122
  
361
123
  /* Create new empty GPGME data buffer for the plaintext */
362
124
  rc = gpgme_data_new(&dh_plain);
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;
393
 
        while(recipient != NULL){
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");
401
 
          recipient = recipient->next;
402
 
        }
403
 
      }
404
 
    }
405
 
    goto decrypt_end;
406
 
  }
407
 
  
408
 
  if(debug){
409
 
    fprintf_plus(stderr, "Decryption of OpenPGP data succeeded\n");
410
 
  }
 
125
  if (rc != GPG_ERR_NO_ERROR){
 
126
    fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
 
127
            gpgme_strsource(rc), gpgme_strerror(rc));
 
128
    return -1;
 
129
  }
 
130
  
 
131
  /* Create new GPGME "context" */
 
132
  rc = gpgme_new(&ctx);
 
133
  if (rc != GPG_ERR_NO_ERROR){
 
134
    fprintf(stderr, "bad gpgme_new: %s: %s\n",
 
135
            gpgme_strsource(rc), gpgme_strerror(rc));
 
136
    return -1;
 
137
  }
 
138
  
 
139
  /* Decrypt data from the FILE pointer to the plaintext data buffer */
 
140
  rc = gpgme_op_decrypt(ctx, dh_crypto, dh_plain);
 
141
  if (rc != GPG_ERR_NO_ERROR){
 
142
    fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
 
143
            gpgme_strsource(rc), gpgme_strerror(rc));
 
144
    return -1;
 
145
  }
 
146
  
 
147
/*   gpgme_decrypt_result_t result; */
 
148
/*   result = gpgme_op_decrypt_result(ctx); */
 
149
/*   fprintf(stderr, "Unsupported algorithm: %s\n", result->unsupported_algorithm); */
 
150
/*   fprintf(stderr, "Wrong key usage: %d\n", result->wrong_key_usage); */
 
151
/*   if(result->file_name != NULL){ */
 
152
/*     fprintf(stderr, "File name: %s\n", result->file_name); */
 
153
/*   } */
 
154
/*   gpgme_recipient_t recipient; */
 
155
/*   recipient = result->recipients; */
 
156
/*   if(recipient){ */
 
157
/*     while(recipient != NULL){ */
 
158
/*       fprintf(stderr, "Public key algorithm: %s\n", */
 
159
/*            gpgme_pubkey_algo_name(recipient->pubkey_algo)); */
 
160
/*       fprintf(stderr, "Key ID: %s\n", recipient->keyid); */
 
161
/*       fprintf(stderr, "Secret key available: %s\n", */
 
162
/*            recipient->status == GPG_ERR_NO_SECKEY ? "No" : "Yes"); */
 
163
/*       recipient = recipient->next; */
 
164
/*     } */
 
165
/*   } */
 
166
 
 
167
  /* Delete the GPGME FILE pointer cryptotext data buffer */
 
168
  gpgme_data_release(dh_crypto);
411
169
  
412
170
  /* Seek back to the beginning of the GPGME plaintext data buffer */
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;
417
 
  }
418
 
  
419
 
  *plaintext = NULL;
 
171
  gpgme_data_seek(dh_plain, 0, SEEK_SET);
 
172
 
 
173
  *new_packet = 0;
420
174
  while(true){
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;
 
175
    if (new_packet_length + BUFFER_SIZE > new_packet_capacity){
 
176
      *new_packet = realloc(*new_packet, new_packet_capacity + BUFFER_SIZE);
 
177
      if (*new_packet == NULL){
 
178
        perror("realloc");
 
179
        return -1;
 
180
      }
 
181
      new_packet_capacity += BUFFER_SIZE;
428
182
    }
429
183
    
430
 
    ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
431
 
                          BUFFER_SIZE);
 
184
    ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length, BUFFER_SIZE);
432
185
    /* Print the data, if any */
433
 
    if(ret == 0){
434
 
      /* EOF */
 
186
    if (ret == 0){
 
187
      /* If password is empty, then a incorrect error will be printed */
435
188
      break;
436
189
    }
437
190
    if(ret < 0){
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);
457
 
  
458
 
  /* Delete the GPGME plaintext data buffer */
 
191
      perror("gpgme_data_read");
 
192
      return -1;
 
193
    }
 
194
    new_packet_length += ret;
 
195
  }
 
196
 
 
197
   /* Delete the GPGME plaintext data buffer */
459
198
  gpgme_data_release(dh_plain);
460
 
  return plaintext_length;
 
199
  return new_packet_length;
461
200
}
462
201
 
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)
 
202
static const char * safer_gnutls_strerror (int value) {
 
203
  const char *ret = gnutls_strerror (value);
 
204
  if (ret == NULL)
467
205
    ret = "(unknown)";
468
206
  return ret;
469
207
}
470
208
 
471
 
/* GnuTLS log function callback */
472
 
static void debuggnutls(__attribute__((unused)) int level,
473
 
                        const char* string){
474
 
  fprintf_plus(stderr, "GnuTLS: %s", string);
 
209
void debuggnutls(int level, const char* string){
 
210
  fprintf(stderr, "%s", string);
475
211
}
476
212
 
477
 
static int init_gnutls_global(const char *pubkeyfilename,
478
 
                              const char *seckeyfilename){
 
213
int initgnutls(encrypted_session *es){
 
214
  const char *err;
479
215
  int ret;
480
216
  
481
 
  if(debug){
482
 
    fprintf_plus(stderr, "Initializing GnuTLS\n");
483
 
  }
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));
489
 
    return -1;
490
 
  }
491
 
  
492
 
  if(debug){
493
 
    /* "Use a log level over 10 to enable all debugging options."
494
 
     * - GnuTLS manual
495
 
     */
496
 
    gnutls_global_set_log_level(11);
497
 
    gnutls_global_set_log_function(debuggnutls);
498
 
  }
499
 
  
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();
506
 
    return -1;
507
 
  }
508
 
  
509
 
  if(debug){
510
 
    fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
511
 
                 " secret key %s as GnuTLS credentials\n",
512
 
                 pubkeyfilename,
513
 
                 seckeyfilename);
514
 
  }
515
 
  
 
217
  if ((ret = gnutls_global_init ())
 
218
      != GNUTLS_E_SUCCESS) {
 
219
    fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
 
220
    return -1;
 
221
  }
 
222
 
 
223
  /* Uncomment to enable full debuggin on the gnutls library */
 
224
  /*   gnutls_global_set_log_level(11); */
 
225
  /*   gnutls_global_set_log_function(debuggnutls); */
 
226
 
 
227
 
 
228
  /* openpgp credentials */
 
229
  if ((ret = gnutls_certificate_allocate_credentials (&es->cred))
 
230
      != GNUTLS_E_SUCCESS) {
 
231
    fprintf (stderr, "memory error: %s\n", safer_gnutls_strerror(ret));
 
232
    return -1;
 
233
  }
 
234
 
516
235
  ret = gnutls_certificate_set_openpgp_key_file
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);
600
 
    return -1;
601
 
  }
602
 
  
 
236
    (es->cred, CERTFILE, KEYFILE, GNUTLS_OPENPGP_FMT_BASE64);
 
237
  if (ret != GNUTLS_E_SUCCESS) {
 
238
    fprintf
 
239
      (stderr, "Error[%d] while reading the OpenPGP key pair ('%s', '%s')\n",
 
240
       ret, CERTFILE, KEYFILE);
 
241
    fprintf(stdout, "The Error is: %s\n",
 
242
            safer_gnutls_strerror(ret));
 
243
    return -1;
 
244
  }
 
245
 
 
246
  //Gnutls server initialization
 
247
  if ((ret = gnutls_dh_params_init (&es->dh_params))
 
248
      != GNUTLS_E_SUCCESS) {
 
249
    fprintf (stderr, "Error in dh parameter initialization: %s\n",
 
250
             safer_gnutls_strerror(ret));
 
251
    return -1;
 
252
  }
 
253
 
 
254
  if ((ret = gnutls_dh_params_generate2 (es->dh_params, DH_BITS))
 
255
      != GNUTLS_E_SUCCESS) {
 
256
    fprintf (stderr, "Error in prime generation: %s\n",
 
257
             safer_gnutls_strerror(ret));
 
258
    return -1;
 
259
  }
 
260
 
 
261
  gnutls_certificate_set_dh_params (es->cred, es->dh_params);
 
262
 
 
263
  // Gnutls session creation
 
264
  if ((ret = gnutls_init (&es->session, GNUTLS_SERVER))
 
265
      != GNUTLS_E_SUCCESS){
 
266
    fprintf(stderr, "Error in gnutls session initialization: %s\n",
 
267
            safer_gnutls_strerror(ret));
 
268
  }
 
269
 
 
270
  if ((ret = gnutls_priority_set_direct (es->session, "NORMAL", &err))
 
271
      != GNUTLS_E_SUCCESS) {
 
272
    fprintf(stderr, "Syntax error at: %s\n", err);
 
273
    fprintf(stderr, "Gnutls error: %s\n",
 
274
            safer_gnutls_strerror(ret));
 
275
    return -1;
 
276
  }
 
277
 
 
278
  if ((ret = gnutls_credentials_set
 
279
       (es->session, GNUTLS_CRD_CERTIFICATE, es->cred))
 
280
      != GNUTLS_E_SUCCESS) {
 
281
    fprintf(stderr, "Error setting a credentials set: %s\n",
 
282
            safer_gnutls_strerror(ret));
 
283
    return -1;
 
284
  }
 
285
 
603
286
  /* ignore client certificate if any. */
604
 
  gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
 
287
  gnutls_certificate_server_set_request (es->session, GNUTLS_CERT_IGNORE);
605
288
  
606
 
  gnutls_dh_set_prime_bits(*session, mc.dh_bits);
 
289
  gnutls_dh_set_prime_bits (es->session, DH_BITS);
607
290
  
608
291
  return 0;
609
292
}
610
293
 
611
 
/* Avahi log function callback */
612
 
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
613
 
                      __attribute__((unused)) const char *txt){}
 
294
void empty_log(AvahiLogLevel level, const char *txt){}
614
295
 
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;
 
296
int start_mandos_communcation(char *ip, uint16_t port){
 
297
  int ret, tcp_sd;
 
298
  struct sockaddr_in6 to;
 
299
  struct in6_addr ip_addr;
 
300
  encrypted_session es;
625
301
  char *buffer = NULL;
626
 
  char *decrypted_buffer = NULL;
 
302
  char *decrypted_buffer;
627
303
  size_t buffer_length = 0;
628
304
  size_t buffer_capacity = 0;
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
 
  }
 
305
  ssize_t decrypted_buffer_size;
 
306
  int retval = 0;
 
307
 
 
308
  
 
309
  tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
 
310
  if(tcp_sd < 0) {
 
311
    perror("socket");
 
312
    return -1;
 
313
  }
 
314
  
 
315
  ret = setsockopt(tcp_sd, SOL_SOCKET, SO_BINDTODEVICE, "eth0", 5);
 
316
  if(tcp_sd < 0) {
 
317
    perror("setsockopt bindtodevice");
 
318
    return -1;
 
319
  }
 
320
  
 
321
  memset(&to,0,sizeof(to));
 
322
  to.sin6_family = AF_INET6;
 
323
  ret = inet_pton(AF_INET6, ip, &ip_addr);
 
324
  if (ret < 0 ){
 
325
    perror("inet_pton");
 
326
    return -1;
 
327
  }  
691
328
  if(ret == 0){
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){
837
 
    if(debug){
838
 
      fprintf_plus(stderr, "*** GnuTLS Handshake failed ***\n");
839
 
      gnutls_perror(ret);
840
 
    }
841
 
    errno = EPROTO;
842
 
    goto mandos_end;
843
 
  }
844
 
  
845
 
  /* Read OpenPGP packet that contains the wanted password */
846
 
  
847
 
  if(debug){
848
 
    fprintf_plus(stderr, "Retrieving OpenPGP encrypted password from"
849
 
                 " %s\n", ip);
850
 
  }
851
 
  
852
 
  while(true){
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){
 
329
    fprintf(stderr, "Bad address: %s\n", ip);
 
330
    return -1;
 
331
  }
 
332
  to.sin6_port = htons(port);
 
333
  to.sin6_scope_id = if_nametoindex("eth0");
 
334
  
 
335
  ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
 
336
  if (ret < 0){
 
337
    perror("connect");
 
338
    return -1;
 
339
  }
 
340
  
 
341
  ret = initgnutls (&es);
 
342
  if (ret != 0){
 
343
    retval = -1;
 
344
    return -1;
 
345
  }
 
346
    
 
347
  
 
348
  gnutls_transport_set_ptr (es.session, (gnutls_transport_ptr_t) tcp_sd);
 
349
 
 
350
  ret = gnutls_handshake (es.session);
 
351
  
 
352
  if (ret != GNUTLS_E_SUCCESS){
 
353
    fprintf(stderr, "\n*** Handshake failed ***\n");
 
354
    gnutls_perror (ret);
 
355
    retval = -1;
 
356
    goto exit;
 
357
  }
 
358
 
 
359
  //retrive password
 
360
  while(true){
 
361
    if (buffer_length + BUFFER_SIZE > buffer_capacity){
 
362
      buffer = realloc(buffer, buffer_capacity + BUFFER_SIZE);
 
363
      if (buffer == NULL){
 
364
        perror("realloc");
 
365
        goto exit;
 
366
      }
 
367
      buffer_capacity += BUFFER_SIZE;
 
368
    }
 
369
    
 
370
    ret = gnutls_record_recv
 
371
      (es.session, buffer+buffer_length, BUFFER_SIZE);
 
372
    if (ret == 0){
876
373
      break;
877
374
    }
878
 
    if(sret < 0){
879
 
      switch(sret){
 
375
    if (ret < 0){
 
376
      switch(ret){
880
377
      case GNUTLS_E_INTERRUPTED:
881
378
      case GNUTLS_E_AGAIN:
882
379
        break;
883
380
      case GNUTLS_E_REHANDSHAKE:
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;
 
381
        ret = gnutls_handshake (es.session);
 
382
        if (ret < 0){
 
383
          fprintf(stderr, "\n*** Handshake failed ***\n");
 
384
          gnutls_perror (ret);
 
385
          retval = -1;
 
386
          goto exit;
898
387
        }
899
388
        break;
900
389
      default:
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;
 
390
        fprintf(stderr, "Unknown error while reading data from encrypted session with mandos server\n");
 
391
        retval = -1;
 
392
        gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
 
393
        goto exit;
906
394
      }
907
395
    } else {
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;
936
 
      while(written < (size_t) decrypted_buffer_size){
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);
945
 
        if(ret == 0 and ferror(stdout)){
946
 
          int e = errno;
947
 
          if(debug){
948
 
            fprintf_plus(stderr, "Error writing encrypted data: %s\n",
949
 
                         strerror(errno));
950
 
          }
951
 
          errno = e;
952
 
          goto mandos_end;
953
 
        }
954
 
        written += (size_t)ret;
955
 
      }
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;
 
396
      buffer_length += ret;
 
397
    }
 
398
  }
 
399
 
 
400
  if (buffer_length > 0){
 
401
    if ((decrypted_buffer_size = gpg_packet_decrypt(buffer, buffer_length, &decrypted_buffer, CERT_ROOT)) == 0){
980
402
      retval = -1;
 
403
    } else {
 
404
      fwrite (decrypted_buffer, 1, decrypted_buffer_size, stdout);
 
405
      free(decrypted_buffer);
981
406
    }
982
407
  }
 
408
 
 
409
  free(buffer);
 
410
 
 
411
  //shutdown procedure
 
412
  gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
 
413
 exit:
 
414
  close(tcp_sd);
 
415
  gnutls_deinit (es.session);
 
416
  gnutls_certificate_free_credentials (es.cred);
 
417
  gnutls_global_deinit ();
983
418
  return retval;
984
419
}
985
420
 
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);
1001
 
  
1002
 
  /* Called whenever a service has been resolved successfully or
1003
 
     timed out */
1004
 
  
1005
 
  if(quit_now){
1006
 
    return;
1007
 
  }
1008
 
  
1009
 
  switch(event){
1010
 
  default:
1011
 
  case AVAHI_RESOLVER_FAILURE:
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)));
1016
 
    break;
1017
 
    
1018
 
  case AVAHI_RESOLVER_FOUND:
1019
 
    {
1020
 
      char ip[AVAHI_ADDRESS_STR_MAX];
1021
 
      avahi_address_snprint(ip, sizeof(ip), address);
1022
 
      if(debug){
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);
1026
 
      }
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));
1034
 
      }
1035
 
    }
1036
 
  }
1037
 
  avahi_s_service_resolver_free(r);
1038
 
}
1039
 
 
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[i];
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
 
      if(debug){
1399
 
        fprintf_plus(stderr, "Running network hook \"%s\"\n",
1400
 
                     direntry->d_name);
1401
 
      }
1402
 
      pid_t hook_pid = fork();
1403
 
      if(hook_pid == 0){
1404
 
        /* Child */
1405
 
        dup2(devnull, STDIN_FILENO);
1406
 
        close(devnull);
1407
 
        dup2(STDERR_FILENO, STDOUT_FILENO);
1408
 
        ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1409
 
        if(ret == -1){
1410
 
          perror_plus("setenv");
1411
 
          return false;
1412
 
        }
1413
 
        ret = setenv("DEVICE", interface, 1);
1414
 
        if(ret == -1){
1415
 
          perror_plus("setenv");
1416
 
          return false;
1417
 
        }
1418
 
        ret = setenv("VERBOSE", debug ? "1" : "0", 1);
1419
 
        if(ret == -1){
1420
 
          perror_plus("setenv");
1421
 
          return false;
1422
 
        }
1423
 
        ret = setenv("MODE", mode, 1);
1424
 
        if(ret == -1){
1425
 
          perror_plus("setenv");
1426
 
          return false;
1427
 
        }
1428
 
        char *delaystring;
1429
 
        ret = asprintf(&delaystring, "%f", delay);
1430
 
        if(ret == -1){
1431
 
          perror_plus("asprintf");
1432
 
          return false;
1433
 
        }
1434
 
        ret = setenv("DELAY", delaystring, 1);
1435
 
        if(ret == -1){
1436
 
          free(delaystring);
1437
 
          perror_plus("setenv");
1438
 
          return false;
1439
 
        }
1440
 
        free(delaystring);
1441
 
        ret = execl(fullname, direntry->d_name, mode, NULL);
1442
 
        perror_plus("execl");
1443
 
      } else {
1444
 
        int status;
1445
 
        if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1446
 
          perror_plus("waitpid");
1447
 
          free(fullname);
1448
 
          continue;
1449
 
        }
1450
 
        if(WIFEXITED(status)){
1451
 
          if(WEXITSTATUS(status) != 0){
1452
 
            fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1453
 
                         " with status %d\n", direntry->d_name,
1454
 
                         WEXITSTATUS(status));
1455
 
            free(fullname);
1456
 
            continue;
1457
 
          }
1458
 
        } else if(WIFSIGNALED(status)){
1459
 
          fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1460
 
                       " signal %d\n", direntry->d_name,
1461
 
                       WTERMSIG(status));
1462
 
          free(fullname);
1463
 
          continue;
1464
 
        } else {
1465
 
          fprintf_plus(stderr, "Warning: network hook \"%s\""
1466
 
                       " crashed\n", direntry->d_name);
1467
 
          free(fullname);
1468
 
          continue;
1469
 
        }
1470
 
      }
1471
 
      free(fullname);
1472
 
      if(quit_now){
1473
 
        break;
1474
 
      }
1475
 
    }
1476
 
    close(devnull);
1477
 
  }
1478
 
  return true;
1479
 
}
1480
 
 
1481
 
int main(int argc, char *argv[]){
1482
 
  AvahiSServiceBrowser *sb = NULL;
1483
 
  int error;
1484
 
  int ret;
1485
 
  intmax_t tmpmax;
1486
 
  char *tmp;
1487
 
  int exitcode = EXIT_SUCCESS;
1488
 
  const char *interface = "";
1489
 
  struct ifreq network;
1490
 
  int sd = -1;
1491
 
  bool take_down_interface = false;
1492
 
  uid_t uid;
1493
 
  gid_t gid;
1494
 
  char tempdir[] = "/tmp/mandosXXXXXX";
1495
 
  bool tempdir_created = false;
1496
 
  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1497
 
  const char *seckey = PATHDIR "/" SECKEY;
1498
 
  const char *pubkey = PATHDIR "/" PUBKEY;
1499
 
  
1500
 
  bool gnutls_initialized = false;
1501
 
  bool gpgme_initialized = false;
1502
 
  float delay = 2.5f;
1503
 
  double retry_interval = 10; /* 10s between trying a server and
1504
 
                                 retrying the same server again */
1505
 
  
1506
 
  struct sigaction old_sigterm_action = { .sa_handler = SIG_DFL };
1507
 
  struct sigaction sigterm_action = { .sa_handler = handle_sigterm };
1508
 
  
1509
 
  uid = getuid();
1510
 
  gid = getgid();
1511
 
  
1512
 
  /* Lower any group privileges we might have, just to be safe */
1513
 
  errno = 0;
1514
 
  ret = setgid(gid);
1515
 
  if(ret == -1){
1516
 
    perror_plus("setgid");
1517
 
  }
1518
 
  
1519
 
  /* Lower user privileges (temporarily) */
1520
 
  errno = 0;
1521
 
  ret = seteuid(uid);
1522
 
  if(ret == -1){
1523
 
    perror_plus("seteuid");
1524
 
  }
1525
 
  
1526
 
  if(quit_now){
1527
 
    goto end;
1528
 
  }
1529
 
  
1530
 
  {
1531
 
    struct argp_option options[] = {
1532
 
      { .name = "debug", .key = 128,
1533
 
        .doc = "Debug mode", .group = 3 },
1534
 
      { .name = "connect", .key = 'c',
1535
 
        .arg = "ADDRESS:PORT",
1536
 
        .doc = "Connect directly to a specific Mandos server",
1537
 
        .group = 1 },
1538
 
      { .name = "interface", .key = 'i',
1539
 
        .arg = "NAME",
1540
 
        .doc = "Network interface that will be used to search for"
1541
 
        " Mandos servers",
1542
 
        .group = 1 },
1543
 
      { .name = "seckey", .key = 's',
1544
 
        .arg = "FILE",
1545
 
        .doc = "OpenPGP secret key file base name",
1546
 
        .group = 1 },
1547
 
      { .name = "pubkey", .key = 'p',
1548
 
        .arg = "FILE",
1549
 
        .doc = "OpenPGP public key file base name",
1550
 
        .group = 2 },
1551
 
      { .name = "dh-bits", .key = 129,
1552
 
        .arg = "BITS",
1553
 
        .doc = "Bit length of the prime number used in the"
1554
 
        " Diffie-Hellman key exchange",
1555
 
        .group = 2 },
1556
 
      { .name = "priority", .key = 130,
1557
 
        .arg = "STRING",
1558
 
        .doc = "GnuTLS priority string for the TLS handshake",
1559
 
        .group = 1 },
1560
 
      { .name = "delay", .key = 131,
1561
 
        .arg = "SECONDS",
1562
 
        .doc = "Maximum delay to wait for interface startup",
1563
 
        .group = 2 },
1564
 
      { .name = "retry", .key = 132,
1565
 
        .arg = "SECONDS",
1566
 
        .doc = "Retry interval used when denied by the mandos server",
1567
 
        .group = 2 },
1568
 
      { .name = "network-hook-dir", .key = 133,
1569
 
        .arg = "DIR",
1570
 
        .doc = "Directory where network hooks are located",
1571
 
        .group = 2 },
1572
 
      /*
1573
 
       * These reproduce what we would get without ARGP_NO_HELP
1574
 
       */
1575
 
      { .name = "help", .key = '?',
1576
 
        .doc = "Give this help list", .group = -1 },
1577
 
      { .name = "usage", .key = -3,
1578
 
        .doc = "Give a short usage message", .group = -1 },
1579
 
      { .name = "version", .key = 'V',
1580
 
        .doc = "Print program version", .group = -1 },
1581
 
      { .name = NULL }
1582
 
    };
1583
 
    
1584
 
    error_t parse_opt(int key, char *arg,
1585
 
                      struct argp_state *state){
1586
 
      errno = 0;
1587
 
      switch(key){
1588
 
      case 128:                 /* --debug */
1589
 
        debug = true;
1590
 
        break;
1591
 
      case 'c':                 /* --connect */
1592
 
        connect_to = arg;
1593
 
        break;
1594
 
      case 'i':                 /* --interface */
1595
 
        interface = arg;
1596
 
        break;
1597
 
      case 's':                 /* --seckey */
1598
 
        seckey = arg;
1599
 
        break;
1600
 
      case 'p':                 /* --pubkey */
1601
 
        pubkey = arg;
1602
 
        break;
1603
 
      case 129:                 /* --dh-bits */
1604
 
        errno = 0;
1605
 
        tmpmax = strtoimax(arg, &tmp, 10);
1606
 
        if(errno != 0 or tmp == arg or *tmp != '\0'
1607
 
           or tmpmax != (typeof(mc.dh_bits))tmpmax){
1608
 
          argp_error(state, "Bad number of DH bits");
1609
 
        }
1610
 
        mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
1611
 
        break;
1612
 
      case 130:                 /* --priority */
1613
 
        mc.priority = arg;
1614
 
        break;
1615
 
      case 131:                 /* --delay */
1616
 
        errno = 0;
1617
 
        delay = strtof(arg, &tmp);
1618
 
        if(errno != 0 or tmp == arg or *tmp != '\0'){
1619
 
          argp_error(state, "Bad delay");
1620
 
        }
1621
 
      case 132:                 /* --retry */
1622
 
        errno = 0;
1623
 
        retry_interval = strtod(arg, &tmp);
1624
 
        if(errno != 0 or tmp == arg or *tmp != '\0'
1625
 
           or (retry_interval * 1000) > INT_MAX
1626
 
           or retry_interval < 0){
1627
 
          argp_error(state, "Bad retry interval");
1628
 
        }
1629
 
        break;
1630
 
      case 133:                 /* --network-hook-dir */
1631
 
        hookdir = arg;
1632
 
        break;
1633
 
        /*
1634
 
         * These reproduce what we would get without ARGP_NO_HELP
1635
 
         */
1636
 
      case '?':                 /* --help */
1637
 
        argp_state_help(state, state->out_stream,
1638
 
                        (ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
1639
 
                        & ~(unsigned int)ARGP_HELP_EXIT_OK);
1640
 
      case -3:                  /* --usage */
1641
 
        argp_state_help(state, state->out_stream,
1642
 
                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
1643
 
      case 'V':                 /* --version */
1644
 
        fprintf_plus(state->out_stream,
1645
 
                     "Mandos plugin mandos-client: ");
1646
 
        fprintf_plus(state->out_stream, "%s\n", argp_program_version);
1647
 
        exit(argp_err_exit_status);
1648
 
        break;
1649
 
      default:
1650
 
        return ARGP_ERR_UNKNOWN;
1651
 
      }
1652
 
      return errno;
1653
 
    }
1654
 
    
1655
 
    struct argp argp = { .options = options, .parser = parse_opt,
1656
 
                         .args_doc = "",
1657
 
                         .doc = "Mandos client -- Get and decrypt"
1658
 
                         " passwords from a Mandos server" };
1659
 
    ret = argp_parse(&argp, argc, argv,
1660
 
                     ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
1661
 
    switch(ret){
1662
 
    case 0:
1663
 
      break;
1664
 
    case ENOMEM:
1665
 
    default:
1666
 
      errno = ret;
1667
 
      perror_plus("argp_parse");
1668
 
      exitcode = EX_OSERR;
1669
 
      goto end;
1670
 
    case EINVAL:
1671
 
      exitcode = EX_USAGE;
1672
 
      goto end;
1673
 
    }
1674
 
  }
1675
 
    
1676
 
  if(getuid() == 0){
1677
 
    /* Work around Debian bug #633582:
1678
 
       <http://bugs.debian.org/633582> */
1679
 
    struct stat st;
1680
 
    
1681
 
    /* Re-raise priviliges */
1682
 
    errno = 0;
1683
 
    ret = seteuid(0);
1684
 
    if(ret == -1){
1685
 
      perror_plus("seteuid");
1686
 
    }
1687
 
    
1688
 
    if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
1689
 
      int seckey_fd = open(seckey, O_RDONLY);
1690
 
      if(seckey_fd == -1){
1691
 
        perror_plus("open");
1692
 
      } else {
1693
 
        ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
1694
 
        if(ret == -1){
1695
 
          perror_plus("fstat");
1696
 
        } else {
1697
 
          if(S_ISREG(st.st_mode)
1698
 
             and st.st_uid == 0 and st.st_gid == 0){
1699
 
            ret = fchown(seckey_fd, uid, gid);
1700
 
            if(ret == -1){
1701
 
              perror_plus("fchown");
1702
 
            }
1703
 
          }
1704
 
        }
1705
 
        TEMP_FAILURE_RETRY(close(seckey_fd));
1706
 
      }
1707
 
    }
1708
 
    
1709
 
    if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
1710
 
      int pubkey_fd = open(pubkey, O_RDONLY);
1711
 
      if(pubkey_fd == -1){
1712
 
        perror_plus("open");
1713
 
      } else {
1714
 
        ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
1715
 
        if(ret == -1){
1716
 
          perror_plus("fstat");
1717
 
        } else {
1718
 
          if(S_ISREG(st.st_mode)
1719
 
             and st.st_uid == 0 and st.st_gid == 0){
1720
 
            ret = fchown(pubkey_fd, uid, gid);
1721
 
            if(ret == -1){
1722
 
              perror_plus("fchown");
1723
 
            }
1724
 
          }
1725
 
        }
1726
 
        TEMP_FAILURE_RETRY(close(pubkey_fd));
1727
 
      }
1728
 
    }
1729
 
    
1730
 
    /* Lower privileges */
1731
 
    errno = 0;
1732
 
    ret = seteuid(uid);
1733
 
    if(ret == -1){
1734
 
      perror_plus("seteuid");
1735
 
    }
1736
 
  }
1737
 
  
1738
 
  /* Run network hooks */
1739
 
  {
1740
 
    if(getuid() == 0){
1741
 
      /* Re-raise priviliges */
1742
 
      errno = 0;
1743
 
      ret = seteuid(0);
1744
 
      if(ret == -1){
1745
 
        perror_plus("seteuid");
1746
 
      }
1747
 
    }
1748
 
    if(not run_network_hooks("start", interface, delay)){
1749
 
      goto end;
1750
 
    }
1751
 
    if(getuid() == 0){
1752
 
      /* Lower privileges */
1753
 
      errno = 0;
1754
 
      ret = seteuid(uid);
1755
 
      if(ret == -1){
1756
 
        perror_plus("seteuid");
1757
 
      }
1758
 
    }
1759
 
  }
1760
 
  
1761
 
  if(not debug){
 
421
static AvahiSimplePoll *simple_poll = NULL;
 
422
static AvahiServer *server = NULL;
 
423
 
 
424
static void resolve_callback(
 
425
    AvahiSServiceResolver *r,
 
426
    AVAHI_GCC_UNUSED AvahiIfIndex interface,
 
427
    AVAHI_GCC_UNUSED AvahiProtocol protocol,
 
428
    AvahiResolverEvent event,
 
429
    const char *name,
 
430
    const char *type,
 
431
    const char *domain,
 
432
    const char *host_name,
 
433
    const AvahiAddress *address,
 
434
    uint16_t port,
 
435
    AvahiStringList *txt,
 
436
    AvahiLookupResultFlags flags,
 
437
    AVAHI_GCC_UNUSED void* userdata) {
 
438
    
 
439
    assert(r);
 
440
 
 
441
    /* Called whenever a service has been resolved successfully or timed out */
 
442
 
 
443
    switch (event) {
 
444
        case AVAHI_RESOLVER_FAILURE:
 
445
            fprintf(stderr, "(Resolver) Failed to resolve service '%s' of type '%s' in domain '%s': %s\n", name, type, domain, avahi_strerror(avahi_server_errno(server)));
 
446
            break;
 
447
 
 
448
        case AVAHI_RESOLVER_FOUND: {
 
449
          char ip[AVAHI_ADDRESS_STR_MAX];
 
450
            avahi_address_snprint(ip, sizeof(ip), address);
 
451
            int ret = start_mandos_communcation(ip, port);
 
452
            if (ret == 0){
 
453
              exit(EXIT_SUCCESS);
 
454
            } else {
 
455
              exit(EXIT_FAILURE);
 
456
            }
 
457
        }
 
458
    }
 
459
    avahi_s_service_resolver_free(r);
 
460
}
 
461
 
 
462
static void browse_callback(
 
463
    AvahiSServiceBrowser *b,
 
464
    AvahiIfIndex interface,
 
465
    AvahiProtocol protocol,
 
466
    AvahiBrowserEvent event,
 
467
    const char *name,
 
468
    const char *type,
 
469
    const char *domain,
 
470
    AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
 
471
    void* userdata) {
 
472
    
 
473
    AvahiServer *s = userdata;
 
474
    assert(b);
 
475
 
 
476
    /* Called whenever a new services becomes available on the LAN or is removed from the LAN */
 
477
 
 
478
    switch (event) {
 
479
 
 
480
        case AVAHI_BROWSER_FAILURE:
 
481
            
 
482
            fprintf(stderr, "(Browser) %s\n", avahi_strerror(avahi_server_errno(server)));
 
483
            avahi_simple_poll_quit(simple_poll);
 
484
            return;
 
485
 
 
486
        case AVAHI_BROWSER_NEW:
 
487
            /* We ignore the returned resolver object. In the callback
 
488
               function we free it. If the server is terminated before
 
489
               the callback function is called the server will free
 
490
               the resolver for us. */
 
491
            
 
492
            if (!(avahi_s_service_resolver_new(s, interface, protocol, name, type, domain, AVAHI_PROTO_INET6, 0, resolve_callback, s)))
 
493
                fprintf(stderr, "Failed to resolve service '%s': %s\n", name, avahi_strerror(avahi_server_errno(s)));
 
494
            
 
495
            break;
 
496
 
 
497
        case AVAHI_BROWSER_REMOVE:
 
498
            break;
 
499
 
 
500
        case AVAHI_BROWSER_ALL_FOR_NOW:
 
501
        case AVAHI_BROWSER_CACHE_EXHAUSTED:
 
502
            break;
 
503
    }
 
504
}
 
505
 
 
506
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
 
507
    AvahiServerConfig config;
 
508
    AvahiSServiceBrowser *sb = NULL;
 
509
    int error;
 
510
    int ret = 1;
 
511
 
1762
512
    avahi_set_log_function(empty_log);
1763
 
  }
1764
 
  
1765
 
  if(interface[0] == '\0'){
1766
 
    struct dirent **direntries;
1767
 
    /* First look for interfaces that are up */
1768
 
    ret = scandir(sys_class_net, &direntries, up_interface,
1769
 
                  alphasort);
1770
 
    if(ret == 0){
1771
 
      /* No up interfaces, look for any good interfaces */
1772
 
      free(direntries);
1773
 
      ret = scandir(sys_class_net, &direntries, good_interface,
1774
 
                    alphasort);
1775
 
    }
1776
 
    if(ret >= 1){
1777
 
      /* Pick the first interface returned */
1778
 
      interface = strdup(direntries[0]->d_name);
1779
 
      if(debug){
1780
 
        fprintf_plus(stderr, "Using interface \"%s\"\n", interface);
1781
 
      }
1782
 
      if(interface == NULL){
1783
 
        perror_plus("malloc");
1784
 
        free(direntries);
1785
 
        exitcode = EXIT_FAILURE;
1786
 
        goto end;
1787
 
      }
1788
 
      free(direntries);
1789
 
    } else {
1790
 
      free(direntries);
1791
 
      fprintf_plus(stderr, "Could not find a network interface\n");
1792
 
      exitcode = EXIT_FAILURE;
1793
 
      goto end;
1794
 
    }
1795
 
  }
1796
 
  
1797
 
  /* Initialize Avahi early so avahi_simple_poll_quit() can be called
1798
 
     from the signal handler */
1799
 
  /* Initialize the pseudo-RNG for Avahi */
1800
 
  srand((unsigned int) time(NULL));
1801
 
  mc.simple_poll = avahi_simple_poll_new();
1802
 
  if(mc.simple_poll == NULL){
1803
 
    fprintf_plus(stderr,
1804
 
                 "Avahi: Failed to create simple poll object.\n");
1805
 
    exitcode = EX_UNAVAILABLE;
1806
 
    goto end;
1807
 
  }
1808
 
  
1809
 
  sigemptyset(&sigterm_action.sa_mask);
1810
 
  ret = sigaddset(&sigterm_action.sa_mask, SIGINT);
1811
 
  if(ret == -1){
1812
 
    perror_plus("sigaddset");
1813
 
    exitcode = EX_OSERR;
1814
 
    goto end;
1815
 
  }
1816
 
  ret = sigaddset(&sigterm_action.sa_mask, SIGHUP);
1817
 
  if(ret == -1){
1818
 
    perror_plus("sigaddset");
1819
 
    exitcode = EX_OSERR;
1820
 
    goto end;
1821
 
  }
1822
 
  ret = sigaddset(&sigterm_action.sa_mask, SIGTERM);
1823
 
  if(ret == -1){
1824
 
    perror_plus("sigaddset");
1825
 
    exitcode = EX_OSERR;
1826
 
    goto end;
1827
 
  }
1828
 
  /* Need to check if the handler is SIG_IGN before handling:
1829
 
     | [[info:libc:Initial Signal Actions]] |
1830
 
     | [[info:libc:Basic Signal Handling]]  |
1831
 
  */
1832
 
  ret = sigaction(SIGINT, NULL, &old_sigterm_action);
1833
 
  if(ret == -1){
1834
 
    perror_plus("sigaction");
1835
 
    return EX_OSERR;
1836
 
  }
1837
 
  if(old_sigterm_action.sa_handler != SIG_IGN){
1838
 
    ret = sigaction(SIGINT, &sigterm_action, NULL);
1839
 
    if(ret == -1){
1840
 
      perror_plus("sigaction");
1841
 
      exitcode = EX_OSERR;
1842
 
      goto end;
1843
 
    }
1844
 
  }
1845
 
  ret = sigaction(SIGHUP, NULL, &old_sigterm_action);
1846
 
  if(ret == -1){
1847
 
    perror_plus("sigaction");
1848
 
    return EX_OSERR;
1849
 
  }
1850
 
  if(old_sigterm_action.sa_handler != SIG_IGN){
1851
 
    ret = sigaction(SIGHUP, &sigterm_action, NULL);
1852
 
    if(ret == -1){
1853
 
      perror_plus("sigaction");
1854
 
      exitcode = EX_OSERR;
1855
 
      goto end;
1856
 
    }
1857
 
  }
1858
 
  ret = sigaction(SIGTERM, NULL, &old_sigterm_action);
1859
 
  if(ret == -1){
1860
 
    perror_plus("sigaction");
1861
 
    return EX_OSERR;
1862
 
  }
1863
 
  if(old_sigterm_action.sa_handler != SIG_IGN){
1864
 
    ret = sigaction(SIGTERM, &sigterm_action, NULL);
1865
 
    if(ret == -1){
1866
 
      perror_plus("sigaction");
1867
 
      exitcode = EX_OSERR;
1868
 
      goto end;
1869
 
    }
1870
 
  }
1871
 
  
1872
 
  /* If the interface is down, bring it up */
1873
 
  if(strcmp(interface, "none") != 0){
1874
 
    if_index = (AvahiIfIndex) if_nametoindex(interface);
1875
 
    if(if_index == 0){
1876
 
      fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1877
 
      exitcode = EX_UNAVAILABLE;
1878
 
      goto end;
1879
 
    }
1880
 
    
1881
 
    if(quit_now){
1882
 
      goto end;
1883
 
    }
1884
 
    
1885
 
    /* Re-raise priviliges */
1886
 
    errno = 0;
1887
 
    ret = seteuid(0);
1888
 
    if(ret == -1){
1889
 
      perror_plus("seteuid");
1890
 
    }
1891
 
    
1892
 
#ifdef __linux__
1893
 
    /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1894
 
       messages about the network interface to mess up the prompt */
1895
 
    ret = klogctl(8, NULL, 5);
1896
 
    bool restore_loglevel = true;
1897
 
    if(ret == -1){
1898
 
      restore_loglevel = false;
1899
 
      perror_plus("klogctl");
1900
 
    }
1901
 
#endif  /* __linux__ */
1902
 
    
1903
 
    sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1904
 
    if(sd < 0){
1905
 
      perror_plus("socket");
1906
 
      exitcode = EX_OSERR;
1907
 
#ifdef __linux__
1908
 
      if(restore_loglevel){
1909
 
        ret = klogctl(7, NULL, 0);
1910
 
        if(ret == -1){
1911
 
          perror_plus("klogctl");
1912
 
        }
1913
 
      }
1914
 
#endif  /* __linux__ */
1915
 
      /* Lower privileges */
1916
 
      errno = 0;
1917
 
      ret = seteuid(uid);
1918
 
      if(ret == -1){
1919
 
        perror_plus("seteuid");
1920
 
      }
1921
 
      goto end;
1922
 
    }
1923
 
    strcpy(network.ifr_name, interface);
1924
 
    ret = ioctl(sd, SIOCGIFFLAGS, &network);
1925
 
    if(ret == -1){
1926
 
      perror_plus("ioctl SIOCGIFFLAGS");
1927
 
#ifdef __linux__
1928
 
      if(restore_loglevel){
1929
 
        ret = klogctl(7, NULL, 0);
1930
 
        if(ret == -1){
1931
 
          perror_plus("klogctl");
1932
 
        }
1933
 
      }
1934
 
#endif  /* __linux__ */
1935
 
      exitcode = EX_OSERR;
1936
 
      /* Lower privileges */
1937
 
      errno = 0;
1938
 
      ret = seteuid(uid);
1939
 
      if(ret == -1){
1940
 
        perror_plus("seteuid");
1941
 
      }
1942
 
      goto end;
1943
 
    }
1944
 
    if((network.ifr_flags & IFF_UP) == 0){
1945
 
      network.ifr_flags |= IFF_UP;
1946
 
      take_down_interface = true;
1947
 
      ret = ioctl(sd, SIOCSIFFLAGS, &network);
1948
 
      if(ret == -1){
1949
 
        take_down_interface = false;
1950
 
        perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1951
 
        exitcode = EX_OSERR;
1952
 
#ifdef __linux__
1953
 
        if(restore_loglevel){
1954
 
          ret = klogctl(7, NULL, 0);
1955
 
          if(ret == -1){
1956
 
            perror_plus("klogctl");
1957
 
          }
1958
 
        }
1959
 
#endif  /* __linux__ */
1960
 
        /* Lower privileges */
1961
 
        errno = 0;
1962
 
        ret = seteuid(uid);
1963
 
        if(ret == -1){
1964
 
          perror_plus("seteuid");
1965
 
        }
1966
 
        goto end;
1967
 
      }
1968
 
    }
1969
 
    /* Sleep checking until interface is running.
1970
 
       Check every 0.25s, up to total time of delay */
1971
 
    for(int i=0; i < delay * 4; i++){
1972
 
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
1973
 
      if(ret == -1){
1974
 
        perror_plus("ioctl SIOCGIFFLAGS");
1975
 
      } else if(network.ifr_flags & IFF_RUNNING){
1976
 
        break;
1977
 
      }
1978
 
      struct timespec sleeptime = { .tv_nsec = 250000000 };
1979
 
      ret = nanosleep(&sleeptime, NULL);
1980
 
      if(ret == -1 and errno != EINTR){
1981
 
        perror_plus("nanosleep");
1982
 
      }
1983
 
    }
1984
 
    if(not take_down_interface){
1985
 
      /* We won't need the socket anymore */
1986
 
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
1987
 
      if(ret == -1){
1988
 
        perror_plus("close");
1989
 
      }
1990
 
    }
1991
 
#ifdef __linux__
1992
 
    if(restore_loglevel){
1993
 
      /* Restores kernel loglevel to default */
1994
 
      ret = klogctl(7, NULL, 0);
1995
 
      if(ret == -1){
1996
 
        perror_plus("klogctl");
1997
 
      }
1998
 
    }
1999
 
#endif  /* __linux__ */
2000
 
    /* Lower privileges */
2001
 
    errno = 0;
2002
 
    /* Lower privileges */
2003
 
    ret = seteuid(uid);
2004
 
    if(ret == -1){
2005
 
      perror_plus("seteuid");
2006
 
    }
2007
 
  }
2008
 
  
2009
 
  if(quit_now){
2010
 
    goto end;
2011
 
  }
2012
 
  
2013
 
  ret = init_gnutls_global(pubkey, seckey);
2014
 
  if(ret == -1){
2015
 
    fprintf_plus(stderr, "init_gnutls_global failed\n");
2016
 
    exitcode = EX_UNAVAILABLE;
2017
 
    goto end;
2018
 
  } else {
2019
 
    gnutls_initialized = true;
2020
 
  }
2021
 
  
2022
 
  if(quit_now){
2023
 
    goto end;
2024
 
  }
2025
 
  
2026
 
  if(mkdtemp(tempdir) == NULL){
2027
 
    perror_plus("mkdtemp");
2028
 
    goto end;
2029
 
  }
2030
 
  tempdir_created = true;
2031
 
  
2032
 
  if(quit_now){
2033
 
    goto end;
2034
 
  }
2035
 
  
2036
 
  if(not init_gpgme(pubkey, seckey, tempdir)){
2037
 
    fprintf_plus(stderr, "init_gpgme failed\n");
2038
 
    exitcode = EX_UNAVAILABLE;
2039
 
    goto end;
2040
 
  } else {
2041
 
    gpgme_initialized = true;
2042
 
  }
2043
 
  
2044
 
  if(quit_now){
2045
 
    goto end;
2046
 
  }
2047
 
  
2048
 
  if(connect_to != NULL){
2049
 
    /* Connect directly, do not use Zeroconf */
2050
 
    /* (Mainly meant for debugging) */
2051
 
    char *address = strrchr(connect_to, ':');
2052
 
    if(address == NULL){
2053
 
      fprintf_plus(stderr, "No colon in address\n");
2054
 
      exitcode = EX_USAGE;
2055
 
      goto end;
2056
 
    }
2057
 
    
2058
 
    if(quit_now){
2059
 
      goto end;
2060
 
    }
2061
 
    
2062
 
    uint16_t port;
2063
 
    errno = 0;
2064
 
    tmpmax = strtoimax(address+1, &tmp, 10);
2065
 
    if(errno != 0 or tmp == address+1 or *tmp != '\0'
2066
 
       or tmpmax != (uint16_t)tmpmax){
2067
 
      fprintf_plus(stderr, "Bad port number\n");
2068
 
      exitcode = EX_USAGE;
2069
 
      goto end;
2070
 
    }
2071
 
  
2072
 
    if(quit_now){
2073
 
      goto end;
2074
 
    }
2075
 
    
2076
 
    port = (uint16_t)tmpmax;
2077
 
    *address = '\0';
2078
 
    /* Colon in address indicates IPv6 */
2079
 
    int af;
2080
 
    if(strchr(connect_to, ':') != NULL){
2081
 
      af = AF_INET6;
2082
 
      /* Accept [] around IPv6 address - see RFC 5952 */
2083
 
      if(connect_to[0] == '[' and address[-1] == ']')
2084
 
        {
2085
 
          connect_to++;
2086
 
          address[-1] = '\0';
2087
 
        }
2088
 
    } else {
2089
 
      af = AF_INET;
2090
 
    }
2091
 
    address = connect_to;
2092
 
    
2093
 
    if(quit_now){
2094
 
      goto end;
2095
 
    }
2096
 
    
2097
 
    while(not quit_now){
2098
 
      ret = start_mandos_communication(address, port, if_index, af);
2099
 
      if(quit_now or ret == 0){
2100
 
        break;
2101
 
      }
2102
 
      if(debug){
2103
 
        fprintf_plus(stderr, "Retrying in %d seconds\n",
2104
 
                     (int)retry_interval);
2105
 
      }
2106
 
      sleep((int)retry_interval);
2107
 
    }
2108
 
    
2109
 
    if (not quit_now){
2110
 
      exitcode = EXIT_SUCCESS;
2111
 
    }
2112
 
    
2113
 
    goto end;
2114
 
  }
2115
 
  
2116
 
  if(quit_now){
2117
 
    goto end;
2118
 
  }
2119
 
  
2120
 
  {
2121
 
    AvahiServerConfig config;
2122
 
    /* Do not publish any local Zeroconf records */
 
513
    
 
514
    /* Initialize the psuedo-RNG */
 
515
    srand(time(NULL));
 
516
 
 
517
    /* Allocate main loop object */
 
518
    if (!(simple_poll = avahi_simple_poll_new())) {
 
519
        fprintf(stderr, "Failed to create simple poll object.\n");
 
520
        goto fail;
 
521
    }
 
522
 
 
523
    /* Do not publish any local records */
2123
524
    avahi_server_config_init(&config);
2124
525
    config.publish_hinfo = 0;
2125
526
    config.publish_addresses = 0;
2126
527
    config.publish_workstation = 0;
2127
528
    config.publish_domain = 0;
 
529
 
 
530
/*     /\* Set a unicast DNS server for wide area DNS-SD *\/ */
 
531
/*     avahi_address_parse("193.11.177.11", AVAHI_PROTO_UNSPEC, &config.wide_area_servers[0]); */
 
532
/*     config.n_wide_area_servers = 1; */
 
533
/*     config.enable_wide_area = 1; */
2128
534
    
2129
535
    /* Allocate a new server */
2130
 
    mc.server = avahi_server_new(avahi_simple_poll_get
2131
 
                                 (mc.simple_poll), &config, NULL,
2132
 
                                 NULL, &error);
2133
 
    
2134
 
    /* Free the Avahi configuration data */
 
536
    server = avahi_server_new(avahi_simple_poll_get(simple_poll), &config, NULL, NULL, &error);
 
537
 
 
538
    /* Free the configuration data */
2135
539
    avahi_server_config_free(&config);
2136
 
  }
2137
 
  
2138
 
  /* Check if creating the Avahi server object succeeded */
2139
 
  if(mc.server == NULL){
2140
 
    fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2141
 
                 avahi_strerror(error));
2142
 
    exitcode = EX_UNAVAILABLE;
2143
 
    goto end;
2144
 
  }
2145
 
  
2146
 
  if(quit_now){
2147
 
    goto end;
2148
 
  }
2149
 
  
2150
 
  /* Create the Avahi service browser */
2151
 
  sb = avahi_s_service_browser_new(mc.server, if_index,
2152
 
                                   AVAHI_PROTO_UNSPEC, "_mandos._tcp",
2153
 
                                   NULL, 0, browse_callback, NULL);
2154
 
  if(sb == NULL){
2155
 
    fprintf_plus(stderr, "Failed to create service browser: %s\n",
2156
 
                 avahi_strerror(avahi_server_errno(mc.server)));
2157
 
    exitcode = EX_UNAVAILABLE;
2158
 
    goto end;
2159
 
  }
2160
 
  
2161
 
  if(quit_now){
2162
 
    goto end;
2163
 
  }
2164
 
  
2165
 
  /* Run the main loop */
2166
 
  
2167
 
  if(debug){
2168
 
    fprintf_plus(stderr, "Starting Avahi loop search\n");
2169
 
  }
2170
 
 
2171
 
  ret = avahi_loop_with_timeout(mc.simple_poll,
2172
 
                                (int)(retry_interval * 1000));
2173
 
  if(debug){
2174
 
    fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
2175
 
                 (ret == 0) ? "successfully" : "with error");
2176
 
  }
2177
 
  
2178
 
 end:
2179
 
  
2180
 
  if(debug){
2181
 
    fprintf_plus(stderr, "%s exiting\n", argv[0]);
2182
 
  }
2183
 
  
2184
 
  /* Cleanup things */
2185
 
  if(sb != NULL)
2186
 
    avahi_s_service_browser_free(sb);
2187
 
  
2188
 
  if(mc.server != NULL)
2189
 
    avahi_server_free(mc.server);
2190
 
  
2191
 
  if(mc.simple_poll != NULL)
2192
 
    avahi_simple_poll_free(mc.simple_poll);
2193
 
  
2194
 
  if(gnutls_initialized){
2195
 
    gnutls_certificate_free_credentials(mc.cred);
2196
 
    gnutls_global_deinit();
2197
 
    gnutls_dh_params_deinit(mc.dh_params);
2198
 
  }
2199
 
  
2200
 
  if(gpgme_initialized){
2201
 
    gpgme_release(mc.ctx);
2202
 
  }
2203
 
 
2204
 
  /* Cleans up the circular linked list of Mandos servers the client
2205
 
     has seen */
2206
 
  if(mc.current_server != NULL){
2207
 
    mc.current_server->prev->next = NULL;
2208
 
    while(mc.current_server != NULL){
2209
 
      server *next = mc.current_server->next;
2210
 
      free(mc.current_server);
2211
 
      mc.current_server = next;
2212
 
    }
2213
 
  }
2214
 
  
2215
 
  /* Re-raise priviliges */
2216
 
  {
2217
 
    if(getuid() == 0){
2218
 
      errno = 0;
2219
 
      ret = seteuid(0);
2220
 
      if(ret == -1){
2221
 
        perror_plus("seteuid");
2222
 
      }
2223
 
    }
2224
 
    /* Run network hooks */
2225
 
    if(not run_network_hooks("stop", interface, delay)){
2226
 
      goto end;
2227
 
    }
2228
 
    
2229
 
    /* Take down the network interface */
2230
 
    if(take_down_interface and geteuid() == 0){
2231
 
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
2232
 
      if(ret == -1){
2233
 
        perror_plus("ioctl SIOCGIFFLAGS");
2234
 
      } else if(network.ifr_flags & IFF_UP){
2235
 
        network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
2236
 
        ret = ioctl(sd, SIOCSIFFLAGS, &network);
2237
 
        if(ret == -1){
2238
 
          perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
2239
 
        }
2240
 
      }
2241
 
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
2242
 
      if(ret == -1){
2243
 
        perror_plus("close");
2244
 
      }
2245
 
    }
2246
 
  }
2247
 
  if(getuid() == 0){
2248
 
    /* Lower privileges permanently */
2249
 
    errno = 0;
2250
 
    ret = setuid(uid);
2251
 
    if(ret == -1){
2252
 
      perror_plus("setuid");
2253
 
    }
2254
 
  }
2255
 
  
2256
 
  /* Removes the GPGME temp directory and all files inside */
2257
 
  if(tempdir_created){
2258
 
    struct dirent **direntries = NULL;
2259
 
    struct dirent *direntry = NULL;
2260
 
    int numentries = scandir(tempdir, &direntries, notdotentries,
2261
 
                             alphasort);
2262
 
    if (numentries > 0){
2263
 
      for(int i = 0; i < numentries; i++){
2264
 
        direntry = direntries[i];
2265
 
        char *fullname = NULL;
2266
 
        ret = asprintf(&fullname, "%s/%s", tempdir,
2267
 
                       direntry->d_name);
2268
 
        if(ret < 0){
2269
 
          perror_plus("asprintf");
2270
 
          continue;
2271
 
        }
2272
 
        ret = remove(fullname);
2273
 
        if(ret == -1){
2274
 
          fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2275
 
                       strerror(errno));
2276
 
        }
2277
 
        free(fullname);
2278
 
      }
2279
 
    }
2280
 
 
2281
 
    /* need to clean even if 0 because man page doesn't specify */
2282
 
    free(direntries);
2283
 
    if (numentries == -1){
2284
 
      perror_plus("scandir");
2285
 
    }
2286
 
    ret = rmdir(tempdir);
2287
 
    if(ret == -1 and errno != ENOENT){
2288
 
      perror_plus("rmdir");
2289
 
    }
2290
 
  }
2291
 
  
2292
 
  if(quit_now){
2293
 
    sigemptyset(&old_sigterm_action.sa_mask);
2294
 
    old_sigterm_action.sa_handler = SIG_DFL;
2295
 
    ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
2296
 
                                            &old_sigterm_action,
2297
 
                                            NULL));
2298
 
    if(ret == -1){
2299
 
      perror_plus("sigaction");
2300
 
    }
2301
 
    do {
2302
 
      ret = raise(signal_received);
2303
 
    } while(ret != 0 and errno == EINTR);
2304
 
    if(ret != 0){
2305
 
      perror_plus("raise");
2306
 
      abort();
2307
 
    }
2308
 
    TEMP_FAILURE_RETRY(pause());
2309
 
  }
2310
 
  
2311
 
  return exitcode;
 
540
 
 
541
    /* Check wether creating the server object succeeded */
 
542
    if (!server) {
 
543
        fprintf(stderr, "Failed to create server: %s\n", avahi_strerror(error));
 
544
        goto fail;
 
545
    }
 
546
    
 
547
    /* Create the service browser */
 
548
    if (!(sb = avahi_s_service_browser_new(server, if_nametoindex("eth0"), AVAHI_PROTO_INET6, "_mandos._tcp", NULL, 0, browse_callback, server))) {
 
549
        fprintf(stderr, "Failed to create service browser: %s\n", avahi_strerror(avahi_server_errno(server)));
 
550
        goto fail;
 
551
    }
 
552
    
 
553
    /* Run the main loop */
 
554
    avahi_simple_poll_loop(simple_poll);
 
555
    
 
556
    ret = 0;
 
557
    
 
558
fail:
 
559
    
 
560
    /* Cleanup things */
 
561
    if (sb)
 
562
        avahi_s_service_browser_free(sb);
 
563
    
 
564
    if (server)
 
565
        avahi_server_free(server);
 
566
 
 
567
    if (simple_poll)
 
568
        avahi_simple_poll_free(simple_poll);
 
569
 
 
570
    return ret;
2312
571
}