/mandos/release

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

« back to all changes in this revision

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

* Makefile (run-client): Add "--network-hook-dir" option.
* plugin-runner.c (main): Only try to work around Debian bug #633582
                          if started as root.
* plugins.d/mandos-client.c (run_network_hooks): Bug fix: Run all
                                                 network hooks, not
                                                 just the first one.
                                                 Also add debug output.
  (main): Only try to work around Debian bug #633582 or run network
          hooks as root if started as root.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/mandos-client.c
1
 
/***
2
 
  This file is part of avahi.
3
 
 
4
 
  avahi is free software; you can redistribute it and/or modify it
5
 
  under the terms of the GNU Lesser General Public License as
6
 
  published by the Free Software Foundation; either version 2.1 of the
7
 
  License, or (at your option) any later version.
8
 
 
9
 
  avahi is distributed in the hope that it will be useful, but WITHOUT
10
 
  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
11
 
  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
12
 
  Public License for more details.
13
 
 
14
 
  You should have received a copy of the GNU Lesser General Public
15
 
  License along with avahi; if not, write to the Free Software
16
 
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
17
 
  USA.
18
 
***/
 
1
/*  -*- coding: utf-8 -*- */
 
2
/*
 
3
 * Mandos-client - get and decrypt data from a Mandos server
 
4
 *
 
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>.
 
30
 */
19
31
 
 
32
/* Needed by GPGME, specifically gpgme_data_seek() */
 
33
#ifndef _LARGEFILE_SOURCE
20
34
#define _LARGEFILE_SOURCE
 
35
#endif
 
36
#ifndef _FILE_OFFSET_BITS
21
37
#define _FILE_OFFSET_BITS 64
22
 
 
23
 
#include <stdio.h>
24
 
#include <assert.h>
25
 
#include <stdlib.h>
26
 
#include <time.h>
27
 
#include <net/if.h>             /* if_nametoindex */
28
 
 
 
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_* */
29
99
#include <avahi-core/core.h>
30
100
#include <avahi-core/lookup.h>
31
101
#include <avahi-core/log.h>
33
103
#include <avahi-common/malloc.h>
34
104
#include <avahi-common/error.h>
35
105
 
36
 
//mandos client part
37
 
#include <sys/types.h>          /* socket(), setsockopt(), inet_pton() */
38
 
#include <sys/socket.h>         /* socket(), setsockopt(), struct sockaddr_in6, struct in6_addr, inet_pton() */
39
 
#include <gnutls/gnutls.h>      /* ALL GNUTLS STUFF */
40
 
#include <gnutls/openpgp.h>     /* gnutls with openpgp stuff */
41
 
 
42
 
#include <unistd.h>             /* close() */
43
 
#include <netinet/in.h>
44
 
#include <stdbool.h>            /* true */
45
 
#include <string.h>             /* memset */
46
 
#include <arpa/inet.h>          /* inet_pton() */
47
 
#include <iso646.h>             /* not */
48
 
 
49
 
// gpgme
50
 
#include <errno.h>              /* perror() */
51
 
#include <gpgme.h>
52
 
 
53
 
// getopt long
54
 
#include <getopt.h>
55
 
 
56
 
#ifndef CERT_ROOT
57
 
#define CERT_ROOT "/conf/conf.d/cryptkeyreq/"
58
 
#endif
59
 
#define CERTFILE CERT_ROOT "openpgp-client.txt"
60
 
#define KEYFILE CERT_ROOT "openpgp-client-key.txt"
 
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
 
61
123
#define BUFFER_SIZE 256
62
 
#define DH_BITS 1024
 
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"
63
129
 
64
130
bool debug = false;
65
 
char *interface = "eth0";
66
 
 
 
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 */
67
150
typedef struct {
68
 
  gnutls_session_t session;
 
151
  AvahiSimplePoll *simple_poll;
 
152
  AvahiServer *server;
69
153
  gnutls_certificate_credentials_t cred;
 
154
  unsigned int dh_bits;
70
155
  gnutls_dh_params_t dh_params;
71
 
} encrypted_session;
72
 
 
73
 
 
74
 
ssize_t gpg_packet_decrypt (char *packet, size_t packet_size, char **new_packet, char *homedir){
75
 
  gpgme_data_t dh_crypto, dh_plain;
 
156
  const char *priority;
76
157
  gpgme_ctx_t ctx;
 
158
  server *current_server;
 
159
} mandos_context;
 
160
 
 
161
/* global context so signal handler can reach it*/
 
162
mandos_context mc = { .simple_poll = NULL, .server = NULL,
 
163
                      .dh_bits = 1024, .priority = "SECURE256"
 
164
                      ":!CTYPE-X.509:+CTYPE-OPENPGP",
 
165
                      .current_server = NULL };
 
166
 
 
167
sig_atomic_t quit_now = 0;
 
168
int signal_received = 0;
 
169
 
 
170
/* Function to use when printing errors */
 
171
void perror_plus(const char *print_text){
 
172
  fprintf(stderr, "Mandos plugin %s: ",
 
173
          program_invocation_short_name);
 
174
  perror(print_text);
 
175
}
 
176
 
 
177
int fprintf_plus(FILE *stream, const char *format, ...){
 
178
  va_list ap;
 
179
  va_start (ap, format);
 
180
  
 
181
  TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
 
182
                             program_invocation_short_name));
 
183
  return TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
 
184
}
 
185
 
 
186
/*
 
187
 * Make additional room in "buffer" for at least BUFFER_SIZE more
 
188
 * bytes. "buffer_capacity" is how much is currently allocated,
 
189
 * "buffer_length" is how much is already used.
 
190
 */
 
191
size_t incbuffer(char **buffer, size_t buffer_length,
 
192
                 size_t buffer_capacity){
 
193
  if(buffer_length + BUFFER_SIZE > buffer_capacity){
 
194
    *buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
 
195
    if(buffer == NULL){
 
196
      return 0;
 
197
    }
 
198
    buffer_capacity += BUFFER_SIZE;
 
199
  }
 
200
  return buffer_capacity;
 
201
}
 
202
 
 
203
/* Add server to set of servers to retry periodically */
 
204
int add_server(const char *ip, uint16_t port, AvahiIfIndex if_index,
 
205
               int af){
 
206
  int ret;
 
207
  server *new_server = malloc(sizeof(server));
 
208
  if(new_server == NULL){
 
209
    perror_plus("malloc");
 
210
    return -1;
 
211
  }
 
212
  *new_server = (server){ .ip = strdup(ip),
 
213
                          .port = port,
 
214
                          .if_index = if_index,
 
215
                          .af = af };
 
216
  if(new_server->ip == NULL){
 
217
    perror_plus("strdup");
 
218
    return -1;
 
219
  }
 
220
  /* Special case of first server */
 
221
  if (mc.current_server == NULL){
 
222
    new_server->next = new_server;
 
223
    new_server->prev = new_server;
 
224
    mc.current_server = new_server;
 
225
  /* Place the new server last in the list */
 
226
  } else {
 
227
    new_server->next = mc.current_server;
 
228
    new_server->prev = mc.current_server->prev;
 
229
    new_server->prev->next = new_server;
 
230
    mc.current_server->prev = new_server;
 
231
  }
 
232
  ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);
 
233
  if(ret == -1){
 
234
    perror_plus("clock_gettime");
 
235
    return -1;
 
236
  }
 
237
  return 0;
 
238
}
 
239
 
 
240
/* 
 
241
 * Initialize GPGME.
 
242
 */
 
243
static bool init_gpgme(const char *seckey, const char *pubkey,
 
244
                       const char *tempdir){
77
245
  gpgme_error_t rc;
78
 
  ssize_t ret;
79
 
  size_t new_packet_capacity = 0;
80
 
  size_t new_packet_length = 0;
81
246
  gpgme_engine_info_t engine_info;
82
 
 
83
 
  if (debug){
84
 
    fprintf(stderr, "Attempting to decrypt password from gpg packet\n");
 
247
  
 
248
  
 
249
  /*
 
250
   * Helper function to insert pub and seckey to the engine keyring.
 
251
   */
 
252
  bool import_key(const char *filename){
 
253
    int ret;
 
254
    int fd;
 
255
    gpgme_data_t pgp_data;
 
256
    
 
257
    fd = (int)TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
 
258
    if(fd == -1){
 
259
      perror_plus("open");
 
260
      return false;
 
261
    }
 
262
    
 
263
    rc = gpgme_data_new_from_fd(&pgp_data, fd);
 
264
    if(rc != GPG_ERR_NO_ERROR){
 
265
      fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
 
266
                   gpgme_strsource(rc), gpgme_strerror(rc));
 
267
      return false;
 
268
    }
 
269
    
 
270
    rc = gpgme_op_import(mc.ctx, pgp_data);
 
271
    if(rc != GPG_ERR_NO_ERROR){
 
272
      fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
 
273
                   gpgme_strsource(rc), gpgme_strerror(rc));
 
274
      return false;
 
275
    }
 
276
    
 
277
    ret = (int)TEMP_FAILURE_RETRY(close(fd));
 
278
    if(ret == -1){
 
279
      perror_plus("close");
 
280
    }
 
281
    gpgme_data_release(pgp_data);
 
282
    return true;
 
283
  }
 
284
  
 
285
  if(debug){
 
286
    fprintf_plus(stderr, "Initializing GPGME\n");
85
287
  }
86
288
  
87
289
  /* Init GPGME */
88
290
  gpgme_check_version(NULL);
89
 
  gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
 
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
  }
90
297
  
91
 
  /* Set GPGME home directory */
92
 
  rc = gpgme_get_engine_info (&engine_info);
93
 
  if (rc != GPG_ERR_NO_ERROR){
94
 
    fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
95
 
            gpgme_strsource(rc), gpgme_strerror(rc));
96
 
    return -1;
 
298
  /* Set GPGME home directory for the OpenPGP engine only */
 
299
  rc = gpgme_get_engine_info(&engine_info);
 
300
  if(rc != GPG_ERR_NO_ERROR){
 
301
    fprintf_plus(stderr, "bad gpgme_get_engine_info: %s: %s\n",
 
302
                 gpgme_strsource(rc), gpgme_strerror(rc));
 
303
    return false;
97
304
  }
98
305
  while(engine_info != NULL){
99
306
    if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){
100
307
      gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,
101
 
                            engine_info->file_name, homedir);
 
308
                            engine_info->file_name, tempdir);
102
309
      break;
103
310
    }
104
311
    engine_info = engine_info->next;
105
312
  }
106
313
  if(engine_info == NULL){
107
 
    fprintf(stderr, "Could not set home dir to %s\n", homedir);
108
 
    return -1;
109
 
  }
110
 
  
111
 
  /* Create new GPGME data buffer from packet buffer */
112
 
  rc = gpgme_data_new_from_mem(&dh_crypto, packet, packet_size, 0);
113
 
  if (rc != GPG_ERR_NO_ERROR){
114
 
    fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
115
 
            gpgme_strsource(rc), gpgme_strerror(rc));
 
314
    fprintf_plus(stderr, "Could not set GPGME home dir to %s\n",
 
315
                 tempdir);
 
316
    return false;
 
317
  }
 
318
  
 
319
  /* Create new GPGME "context" */
 
320
  rc = gpgme_new(&(mc.ctx));
 
321
  if(rc != GPG_ERR_NO_ERROR){
 
322
    fprintf_plus(stderr, "Mandos plugin mandos-client: "
 
323
                 "bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
 
324
                 gpgme_strerror(rc));
 
325
    return false;
 
326
  }
 
327
  
 
328
  if(not import_key(pubkey) or not import_key(seckey)){
 
329
    return false;
 
330
  }
 
331
  
 
332
  return true;
 
333
}
 
334
 
 
335
/* 
 
336
 * Decrypt OpenPGP data.
 
337
 * Returns -1 on error
 
338
 */
 
339
static ssize_t pgp_packet_decrypt(const char *cryptotext,
 
340
                                  size_t crypto_size,
 
341
                                  char **plaintext){
 
342
  gpgme_data_t dh_crypto, dh_plain;
 
343
  gpgme_error_t rc;
 
344
  ssize_t ret;
 
345
  size_t plaintext_capacity = 0;
 
346
  ssize_t plaintext_length = 0;
 
347
  
 
348
  if(debug){
 
349
    fprintf_plus(stderr, "Trying to decrypt OpenPGP data\n");
 
350
  }
 
351
  
 
352
  /* Create new GPGME data buffer from memory cryptotext */
 
353
  rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
 
354
                               0);
 
355
  if(rc != GPG_ERR_NO_ERROR){
 
356
    fprintf_plus(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
 
357
                 gpgme_strsource(rc), gpgme_strerror(rc));
116
358
    return -1;
117
359
  }
118
360
  
119
361
  /* Create new empty GPGME data buffer for the plaintext */
120
362
  rc = gpgme_data_new(&dh_plain);
121
 
  if (rc != GPG_ERR_NO_ERROR){
122
 
    fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
123
 
            gpgme_strsource(rc), gpgme_strerror(rc));
124
 
    return -1;
125
 
  }
126
 
  
127
 
  /* Create new GPGME "context" */
128
 
  rc = gpgme_new(&ctx);
129
 
  if (rc != GPG_ERR_NO_ERROR){
130
 
    fprintf(stderr, "bad gpgme_new: %s: %s\n",
131
 
            gpgme_strsource(rc), gpgme_strerror(rc));
132
 
    return -1;
133
 
  }
134
 
  
135
 
  /* Decrypt data from the FILE pointer to the plaintext data buffer */
136
 
  rc = gpgme_op_decrypt(ctx, dh_crypto, dh_plain);
137
 
  if (rc != GPG_ERR_NO_ERROR){
138
 
    fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
139
 
            gpgme_strsource(rc), gpgme_strerror(rc));
140
 
    return -1;
141
 
  }
142
 
 
143
 
  if(debug){
144
 
    fprintf(stderr, "decryption of gpg packet succeeded\n");
145
 
  }
146
 
 
147
 
  if (debug){
148
 
    gpgme_decrypt_result_t result;
149
 
    result = gpgme_op_decrypt_result(ctx);
150
 
    if (result == NULL){
151
 
      fprintf(stderr, "gpgme_op_decrypt_result failed\n");
152
 
    } else {
153
 
      fprintf(stderr, "Unsupported algorithm: %s\n", result->unsupported_algorithm);
154
 
      fprintf(stderr, "Wrong key usage: %d\n", result->wrong_key_usage);
155
 
      if(result->file_name != NULL){
156
 
        fprintf(stderr, "File name: %s\n", result->file_name);
157
 
      }
158
 
      gpgme_recipient_t recipient;
159
 
      recipient = result->recipients;
160
 
      if(recipient){
 
363
  if(rc != GPG_ERR_NO_ERROR){
 
364
    fprintf_plus(stderr, "Mandos plugin mandos-client: "
 
365
                 "bad gpgme_data_new: %s: %s\n",
 
366
                 gpgme_strsource(rc), gpgme_strerror(rc));
 
367
    gpgme_data_release(dh_crypto);
 
368
    return -1;
 
369
  }
 
370
  
 
371
  /* Decrypt data from the cryptotext data buffer to the plaintext
 
372
     data buffer */
 
373
  rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
 
374
  if(rc != GPG_ERR_NO_ERROR){
 
375
    fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
 
376
                 gpgme_strsource(rc), gpgme_strerror(rc));
 
377
    plaintext_length = -1;
 
378
    if(debug){
 
379
      gpgme_decrypt_result_t result;
 
380
      result = gpgme_op_decrypt_result(mc.ctx);
 
381
      if(result == NULL){
 
382
        fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
 
383
      } else {
 
384
        fprintf_plus(stderr, "Unsupported algorithm: %s\n",
 
385
                     result->unsupported_algorithm);
 
386
        fprintf_plus(stderr, "Wrong key usage: %u\n",
 
387
                     result->wrong_key_usage);
 
388
        if(result->file_name != NULL){
 
389
          fprintf_plus(stderr, "File name: %s\n", result->file_name);
 
390
        }
 
391
        gpgme_recipient_t recipient;
 
392
        recipient = result->recipients;
161
393
        while(recipient != NULL){
162
 
          fprintf(stderr, "Public key algorithm: %s\n",
163
 
                  gpgme_pubkey_algo_name(recipient->pubkey_algo));
164
 
          fprintf(stderr, "Key ID: %s\n", recipient->keyid);
165
 
          fprintf(stderr, "Secret key available: %s\n",
166
 
                  recipient->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
 
394
          fprintf_plus(stderr, "Public key algorithm: %s\n",
 
395
                       gpgme_pubkey_algo_name
 
396
                       (recipient->pubkey_algo));
 
397
          fprintf_plus(stderr, "Key ID: %s\n", recipient->keyid);
 
398
          fprintf_plus(stderr, "Secret key available: %s\n",
 
399
                       recipient->status == GPG_ERR_NO_SECKEY
 
400
                       ? "No" : "Yes");
167
401
          recipient = recipient->next;
168
402
        }
169
403
      }
170
404
    }
 
405
    goto decrypt_end;
171
406
  }
172
407
  
173
 
  /* Delete the GPGME FILE pointer cryptotext data buffer */
174
 
  gpgme_data_release(dh_crypto);
 
408
  if(debug){
 
409
    fprintf_plus(stderr, "Decryption of OpenPGP data succeeded\n");
 
410
  }
175
411
  
176
412
  /* Seek back to the beginning of the GPGME plaintext data buffer */
177
 
  gpgme_data_seek(dh_plain, 0, SEEK_SET);
178
 
 
179
 
  *new_packet = 0;
 
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;
180
420
  while(true){
181
 
    if (new_packet_length + BUFFER_SIZE > new_packet_capacity){
182
 
      *new_packet = realloc(*new_packet, new_packet_capacity + BUFFER_SIZE);
183
 
      if (*new_packet == NULL){
184
 
        perror("realloc");
185
 
        return -1;
186
 
      }
187
 
      new_packet_capacity += BUFFER_SIZE;
 
421
    plaintext_capacity = incbuffer(plaintext,
 
422
                                   (size_t)plaintext_length,
 
423
                                   plaintext_capacity);
 
424
    if(plaintext_capacity == 0){
 
425
      perror_plus("incbuffer");
 
426
      plaintext_length = -1;
 
427
      goto decrypt_end;
188
428
    }
189
429
    
190
 
    ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length, BUFFER_SIZE);
 
430
    ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
 
431
                          BUFFER_SIZE);
191
432
    /* Print the data, if any */
192
 
    if (ret == 0){
193
 
      /* If password is empty, then a incorrect error will be printed */
 
433
    if(ret == 0){
 
434
      /* EOF */
194
435
      break;
195
436
    }
196
437
    if(ret < 0){
197
 
      perror("gpgme_data_read");
198
 
      return -1;
199
 
    }
200
 
    new_packet_length += ret;
201
 
  }
202
 
 
203
 
  /* FIXME: check characters before printing to screen so to not print
204
 
     terminal control characters */
205
 
  /*   if(debug){ */
206
 
  /*     fprintf(stderr, "decrypted password is: "); */
207
 
  /*     fwrite(*new_packet, 1, new_packet_length, stderr); */
208
 
  /*     fprintf(stderr, "\n"); */
209
 
  /*   } */
 
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);
210
457
  
211
458
  /* Delete the GPGME plaintext data buffer */
212
459
  gpgme_data_release(dh_plain);
213
 
  return new_packet_length;
 
460
  return plaintext_length;
214
461
}
215
462
 
216
 
static const char * safer_gnutls_strerror (int value) {
217
 
  const char *ret = gnutls_strerror (value);
218
 
  if (ret == NULL)
 
463
static const char * safer_gnutls_strerror(int value){
 
464
  const char *ret = gnutls_strerror(value); /* Spurious warning from
 
465
                                               -Wunreachable-code */
 
466
  if(ret == NULL)
219
467
    ret = "(unknown)";
220
468
  return ret;
221
469
}
222
470
 
223
 
void debuggnutls(int level, const char* string){
224
 
  fprintf(stderr, "%s", string);
 
471
/* GnuTLS log function callback */
 
472
static void debuggnutls(__attribute__((unused)) int level,
 
473
                        const char* string){
 
474
  fprintf_plus(stderr, "GnuTLS: %s", string);
225
475
}
226
476
 
227
 
int initgnutls(encrypted_session *es){
228
 
  const char *err;
 
477
static int init_gnutls_global(const char *pubkeyfilename,
 
478
                              const char *seckeyfilename){
229
479
  int ret;
230
 
 
 
480
  
231
481
  if(debug){
232
 
    fprintf(stderr, "Initializing gnutls\n");
 
482
    fprintf_plus(stderr, "Initializing GnuTLS\n");
233
483
  }
234
 
 
235
484
  
236
 
  if ((ret = gnutls_global_init ())
237
 
      != GNUTLS_E_SUCCESS) {
238
 
    fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
 
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));
239
489
    return -1;
240
490
  }
241
 
 
242
 
  if (debug){
 
491
  
 
492
  if(debug){
 
493
    /* "Use a log level over 10 to enable all debugging options."
 
494
     * - GnuTLS manual
 
495
     */
243
496
    gnutls_global_set_log_level(11);
244
497
    gnutls_global_set_log_function(debuggnutls);
245
498
  }
246
499
  
247
 
 
248
 
  /* openpgp credentials */
249
 
  if ((ret = gnutls_certificate_allocate_credentials (&es->cred))
250
 
      != GNUTLS_E_SUCCESS) {
251
 
    fprintf (stderr, "memory error: %s\n", safer_gnutls_strerror(ret));
 
500
  /* OpenPGP credentials */
 
501
  ret = gnutls_certificate_allocate_credentials(&mc.cred);
 
502
  if(ret != GNUTLS_E_SUCCESS){
 
503
    fprintf_plus(stderr, "GnuTLS memory error: %s\n",
 
504
                 safer_gnutls_strerror(ret));
 
505
    gnutls_global_deinit();
252
506
    return -1;
253
507
  }
254
 
 
 
508
  
255
509
  if(debug){
256
 
    fprintf(stderr, "Attempting to use openpgp certificate %s"
257
 
            " and keyfile %s as gnutls credentials\n", CERTFILE, KEYFILE);
 
510
    fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
 
511
                 " secret key %s as GnuTLS credentials\n",
 
512
                 pubkeyfilename,
 
513
                 seckeyfilename);
258
514
  }
259
 
 
 
515
  
260
516
  ret = gnutls_certificate_set_openpgp_key_file
261
 
    (es->cred, CERTFILE, KEYFILE, GNUTLS_OPENPGP_FMT_BASE64);
262
 
  if (ret != GNUTLS_E_SUCCESS) {
263
 
    fprintf
264
 
      (stderr, "Error[%d] while reading the OpenPGP key pair ('%s', '%s')\n",
265
 
       ret, CERTFILE, KEYFILE);
266
 
    fprintf(stdout, "The Error is: %s\n",
267
 
            safer_gnutls_strerror(ret));
268
 
    return -1;
269
 
  }
270
 
 
271
 
  //Gnutls server initialization
272
 
  if ((ret = gnutls_dh_params_init (&es->dh_params))
273
 
      != GNUTLS_E_SUCCESS) {
274
 
    fprintf (stderr, "Error in dh parameter initialization: %s\n",
275
 
             safer_gnutls_strerror(ret));
276
 
    return -1;
277
 
  }
278
 
 
279
 
  if ((ret = gnutls_dh_params_generate2 (es->dh_params, DH_BITS))
280
 
      != GNUTLS_E_SUCCESS) {
281
 
    fprintf (stderr, "Error in prime generation: %s\n",
282
 
             safer_gnutls_strerror(ret));
283
 
    return -1;
284
 
  }
285
 
 
286
 
  gnutls_certificate_set_dh_params (es->cred, es->dh_params);
287
 
 
288
 
  // Gnutls session creation
289
 
  if ((ret = gnutls_init (&es->session, GNUTLS_SERVER))
290
 
      != GNUTLS_E_SUCCESS){
291
 
    fprintf(stderr, "Error in gnutls session initialization: %s\n",
292
 
            safer_gnutls_strerror(ret));
293
 
  }
294
 
 
295
 
  if ((ret = gnutls_priority_set_direct (es->session, "NORMAL", &err))
296
 
      != GNUTLS_E_SUCCESS) {
297
 
    fprintf(stderr, "Syntax error at: %s\n", err);
298
 
    fprintf(stderr, "Gnutls error: %s\n",
299
 
            safer_gnutls_strerror(ret));
300
 
    return -1;
301
 
  }
302
 
 
303
 
  if ((ret = gnutls_credentials_set
304
 
       (es->session, GNUTLS_CRD_CERTIFICATE, es->cred))
305
 
      != GNUTLS_E_SUCCESS) {
306
 
    fprintf(stderr, "Error setting a credentials set: %s\n",
307
 
            safer_gnutls_strerror(ret));
308
 
    return -1;
309
 
  }
310
 
 
 
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
  
311
603
  /* ignore client certificate if any. */
312
 
  gnutls_certificate_server_set_request (es->session, GNUTLS_CERT_IGNORE);
 
604
  gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
313
605
  
314
 
  gnutls_dh_set_prime_bits (es->session, DH_BITS);
 
606
  gnutls_dh_set_prime_bits(*session, mc.dh_bits);
315
607
  
316
608
  return 0;
317
609
}
318
610
 
319
 
void empty_log(AvahiLogLevel level, const char *txt){}
 
611
/* Avahi log function callback */
 
612
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
 
613
                      __attribute__((unused)) const char *txt){}
320
614
 
321
 
int start_mandos_communcation(char *ip, uint16_t port){
322
 
  int ret, tcp_sd;
323
 
  struct sockaddr_in6 to;
324
 
  struct in6_addr ip_addr;
325
 
  encrypted_session es;
 
615
/* Called when a Mandos server is found */
 
616
static int start_mandos_communication(const char *ip, uint16_t port,
 
617
                                      AvahiIfIndex if_index,
 
618
                                      int af){
 
619
  int ret, tcp_sd = -1;
 
620
  ssize_t sret;
 
621
  union {
 
622
    struct sockaddr_in in;
 
623
    struct sockaddr_in6 in6;
 
624
  } to;
326
625
  char *buffer = NULL;
327
 
  char *decrypted_buffer;
 
626
  char *decrypted_buffer = NULL;
328
627
  size_t buffer_length = 0;
329
628
  size_t buffer_capacity = 0;
330
 
  ssize_t decrypted_buffer_size;
331
 
  int retval = 0;
332
 
 
333
 
  if(debug){
334
 
    fprintf(stderr, "Setting up a tcp connection to %s\n", ip);
335
 
  }
336
 
  
337
 
  tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
338
 
  if(tcp_sd < 0) {
339
 
    perror("socket");
340
 
    return -1;
341
 
  }
342
 
 
343
 
  if(debug){
344
 
    fprintf(stderr, "Binding to interface %s\n", interface);
345
 
  }
346
 
 
347
 
  ret = setsockopt(tcp_sd, SOL_SOCKET, SO_BINDTODEVICE, interface, 5);
348
 
  if(tcp_sd < 0) {
349
 
    perror("setsockopt bindtodevice");
350
 
    return -1;
351
 
  }
352
 
  
353
 
  memset(&to,0,sizeof(to));
354
 
  to.sin6_family = AF_INET6;
355
 
  ret = inet_pton(AF_INET6, ip, &ip_addr);
356
 
  if (ret < 0 ){
357
 
    perror("inet_pton");
358
 
    return -1;
359
 
  }  
 
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
  }
360
691
  if(ret == 0){
361
 
    fprintf(stderr, "Bad address: %s\n", ip);
362
 
    return -1;
363
 
  }
364
 
  to.sin6_port = htons(port);
365
 
  to.sin6_scope_id = if_nametoindex(interface);
366
 
 
367
 
  if(debug){
368
 
    fprintf(stderr, "Connection to: %s\n", ip);
369
 
  }
370
 
  
371
 
  ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
372
 
  if (ret < 0){
373
 
    perror("connect");
374
 
    return -1;
375
 
  }
376
 
  
377
 
  ret = initgnutls (&es);
378
 
  if (ret != 0){
379
 
    retval = -1;
380
 
    return -1;
381
 
  }
382
 
    
383
 
  
384
 
  gnutls_transport_set_ptr (es.session, (gnutls_transport_ptr_t) tcp_sd);
385
 
 
386
 
  if(debug){
387
 
    fprintf(stderr, "Establishing tls session with %s\n", ip);
388
 
  }
389
 
 
390
 
  
391
 
  ret = gnutls_handshake (es.session);
392
 
  
393
 
  if (ret != GNUTLS_E_SUCCESS){
394
 
    fprintf(stderr, "\n*** Handshake failed ***\n");
395
 
    gnutls_perror (ret);
396
 
    retval = -1;
397
 
    goto exit;
398
 
  }
399
 
 
400
 
  //Retrieve gpg packet that contains the wanted password
401
 
 
402
 
  if(debug){
403
 
    fprintf(stderr, "Retrieving pgp encrypted password from %s\n", ip);
404
 
  }
405
 
 
406
 
  while(true){
407
 
    if (buffer_length + BUFFER_SIZE > buffer_capacity){
408
 
      buffer = realloc(buffer, buffer_capacity + BUFFER_SIZE);
409
 
      if (buffer == NULL){
410
 
        perror("realloc");
411
 
        goto exit;
412
 
      }
413
 
      buffer_capacity += BUFFER_SIZE;
414
 
    }
415
 
    
416
 
    ret = gnutls_record_recv
417
 
      (es.session, buffer+buffer_length, BUFFER_SIZE);
418
 
    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){
419
876
      break;
420
877
    }
421
 
    if (ret < 0){
422
 
      switch(ret){
 
878
    if(sret < 0){
 
879
      switch(sret){
423
880
      case GNUTLS_E_INTERRUPTED:
424
881
      case GNUTLS_E_AGAIN:
425
882
        break;
426
883
      case GNUTLS_E_REHANDSHAKE:
427
 
        ret = gnutls_handshake (es.session);
428
 
        if (ret < 0){
429
 
          fprintf(stderr, "\n*** Handshake failed ***\n");
430
 
          gnutls_perror (ret);
431
 
          retval = -1;
432
 
          goto exit;
 
884
        do {
 
885
          ret = gnutls_handshake(session);
 
886
          
 
887
          if(quit_now){
 
888
            errno = EINTR;
 
889
            goto mandos_end;
 
890
          }
 
891
        } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
 
892
        if(ret < 0){
 
893
          fprintf_plus(stderr, "*** GnuTLS Re-handshake failed "
 
894
                       "***\n");
 
895
          gnutls_perror(ret);
 
896
          errno = EPROTO;
 
897
          goto mandos_end;
433
898
        }
434
899
        break;
435
900
      default:
436
 
        fprintf(stderr, "Unknown error while reading data from encrypted session with mandos server\n");
437
 
        retval = -1;
438
 
        gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
439
 
        goto exit;
440
 
      }
441
 
    } else {
442
 
      buffer_length += ret;
443
 
    }
444
 
  }
445
 
  
446
 
  if (buffer_length > 0){
447
 
    if ((decrypted_buffer_size = gpg_packet_decrypt(buffer, buffer_length, &decrypted_buffer, CERT_ROOT)) >= 0){
448
 
      fwrite (decrypted_buffer, 1, decrypted_buffer_size, stdout);
449
 
      free(decrypted_buffer);
450
 
    } else {
 
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;
 
906
      }
 
907
    } 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;
451
980
      retval = -1;
452
981
    }
453
982
  }
454
 
 
455
 
  //shutdown procedure
456
 
 
457
 
  if(debug){
458
 
    fprintf(stderr, "Closing tls session\n");
459
 
  }
460
 
 
461
 
  free(buffer);
462
 
  gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
463
 
 exit:
464
 
  close(tcp_sd);
465
 
  gnutls_deinit (es.session);
466
 
  gnutls_certificate_free_credentials (es.cred);
467
 
  gnutls_global_deinit ();
468
983
  return retval;
469
984
}
470
985
 
471
 
static AvahiSimplePoll *simple_poll = NULL;
472
 
static AvahiServer *server = NULL;
473
 
 
474
 
static void resolve_callback(
475
 
    AvahiSServiceResolver *r,
476
 
    AVAHI_GCC_UNUSED AvahiIfIndex interface,
477
 
    AVAHI_GCC_UNUSED AvahiProtocol protocol,
478
 
    AvahiResolverEvent event,
479
 
    const char *name,
480
 
    const char *type,
481
 
    const char *domain,
482
 
    const char *host_name,
483
 
    const AvahiAddress *address,
484
 
    uint16_t port,
485
 
    AvahiStringList *txt,
486
 
    AvahiLookupResultFlags flags,
487
 
    AVAHI_GCC_UNUSED void* userdata) {
488
 
    
489
 
    assert(r);
490
 
 
491
 
    /* Called whenever a service has been resolved successfully or timed out */
492
 
 
493
 
    switch (event) {
494
 
        case AVAHI_RESOLVER_FAILURE:
495
 
            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)));
496
 
            break;
497
 
 
498
 
        case AVAHI_RESOLVER_FOUND: {
499
 
          char ip[AVAHI_ADDRESS_STR_MAX];
500
 
            avahi_address_snprint(ip, sizeof(ip), address);
501
 
            if(debug){
502
 
              fprintf(stderr, "Mandos server found at %s on port %d\n", ip, port);
503
 
            }
504
 
            int ret = start_mandos_communcation(ip, port);
505
 
            if (ret == 0){
506
 
              exit(EXIT_SUCCESS);
507
 
            } else {
508
 
              exit(EXIT_FAILURE);
509
 
            }
510
 
        }
511
 
    }
512
 
    avahi_s_service_resolver_free(r);
513
 
}
514
 
 
515
 
static void browse_callback(
516
 
    AvahiSServiceBrowser *b,
517
 
    AvahiIfIndex interface,
518
 
    AvahiProtocol protocol,
519
 
    AvahiBrowserEvent event,
520
 
    const char *name,
521
 
    const char *type,
522
 
    const char *domain,
523
 
    AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
524
 
    void* userdata) {
525
 
    
526
 
    AvahiServer *s = userdata;
527
 
    assert(b);
528
 
 
529
 
    /* Called whenever a new services becomes available on the LAN or is removed from the LAN */
530
 
 
531
 
    switch (event) {
532
 
 
533
 
        case AVAHI_BROWSER_FAILURE:
534
 
            
535
 
            fprintf(stderr, "(Browser) %s\n", avahi_strerror(avahi_server_errno(server)));
536
 
            avahi_simple_poll_quit(simple_poll);
537
 
            return;
538
 
 
539
 
        case AVAHI_BROWSER_NEW:
540
 
            /* We ignore the returned resolver object. In the callback
541
 
               function we free it. If the server is terminated before
542
 
               the callback function is called the server will free
543
 
               the resolver for us. */
544
 
            
545
 
            if (!(avahi_s_service_resolver_new(s, interface, protocol, name, type, domain, AVAHI_PROTO_INET6, 0, resolve_callback, s)))
546
 
                fprintf(stderr, "Failed to resolve service '%s': %s\n", name, avahi_strerror(avahi_server_errno(s)));
547
 
            
548
 
            break;
549
 
 
550
 
        case AVAHI_BROWSER_REMOVE:
551
 
            break;
552
 
 
553
 
        case AVAHI_BROWSER_ALL_FOR_NOW:
554
 
        case AVAHI_BROWSER_CACHE_EXHAUSTED:
555
 
            break;
556
 
    }
557
 
}
558
 
 
559
 
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
 
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){
 
1762
    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
  {
560
2121
    AvahiServerConfig config;
561
 
    AvahiSServiceBrowser *sb = NULL;
562
 
    int error;
563
 
    int ret;
564
 
    int returncode = EXIT_SUCCESS;
565
 
 
566
 
    while (true){
567
 
      static struct option long_options[] = {
568
 
        {"debug", no_argument, (int *)&debug, 1},
569
 
        {"interface", required_argument, 0, 'i'},
570
 
        {0, 0, 0, 0} };
571
 
 
572
 
      int option_index = 0;
573
 
      ret = getopt_long (argc, argv, "i:", long_options, &option_index);
574
 
 
575
 
      if (ret == -1){
576
 
        break;
577
 
      }
578
 
      
579
 
      switch(ret){
580
 
      case 0:
581
 
        break;
582
 
      case 'i':
583
 
        interface = optarg;
584
 
        break;
585
 
      default:
586
 
        exit(EXIT_FAILURE);
587
 
      }
588
 
    }
589
 
    
590
 
    if (not debug){
591
 
      avahi_set_log_function(empty_log);
592
 
    }
593
 
    
594
 
    /* Initialize the psuedo-RNG */
595
 
    srand(time(NULL));
596
 
 
597
 
    /* Allocate main loop object */
598
 
    if (!(simple_poll = avahi_simple_poll_new())) {
599
 
        fprintf(stderr, "Failed to create simple poll object.\n");
600
 
        
601
 
        goto exit;
602
 
    }
603
 
 
604
 
    /* Do not publish any local records */
 
2122
    /* Do not publish any local Zeroconf records */
605
2123
    avahi_server_config_init(&config);
606
2124
    config.publish_hinfo = 0;
607
2125
    config.publish_addresses = 0;
608
2126
    config.publish_workstation = 0;
609
2127
    config.publish_domain = 0;
610
 
 
 
2128
    
611
2129
    /* Allocate a new server */
612
 
    server = avahi_server_new(avahi_simple_poll_get(simple_poll), &config, NULL, NULL, &error);
613
 
 
614
 
    /* Free the configuration data */
 
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 */
615
2135
    avahi_server_config_free(&config);
616
 
 
617
 
    /* Check if creating the server object succeeded */
618
 
    if (!server) {
619
 
        fprintf(stderr, "Failed to create server: %s\n", avahi_strerror(error));
620
 
        returncode = EXIT_FAILURE;
621
 
        goto exit;
622
 
    }
623
 
    
624
 
    /* Create the service browser */
625
 
    if (!(sb = avahi_s_service_browser_new(server, if_nametoindex("eth0"), AVAHI_PROTO_INET6, "_mandos._tcp", NULL, 0, browse_callback, server))) {
626
 
        fprintf(stderr, "Failed to create service browser: %s\n", avahi_strerror(avahi_server_errno(server)));
627
 
        returncode = EXIT_FAILURE;
628
 
        goto exit;
629
 
    }
630
 
    
631
 
    /* Run the main loop */
632
 
 
633
 
    if (debug){
634
 
      fprintf(stderr, "Starting avahi loop search\n");
635
 
    }
636
 
    
637
 
    avahi_simple_poll_loop(simple_poll);
638
 
    
639
 
exit:
640
 
 
641
 
    if (debug){
642
 
      fprintf(stderr, "%s exiting\n", argv[0]);
643
 
    }
644
 
    
645
 
    /* Cleanup things */
646
 
    if (sb)
647
 
        avahi_s_service_browser_free(sb);
648
 
    
649
 
    if (server)
650
 
        avahi_server_free(server);
651
 
 
652
 
    if (simple_poll)
653
 
        avahi_simple_poll_free(simple_poll);
654
 
 
655
 
    return returncode;
 
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;
656
2312
}