/mandos/trunk

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

« back to all changes in this revision

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

  • Committer: Teddy Hogeborn
  • Date: 2011-07-27 17:58:27 UTC
  • mto: (237.4.29 release)
  • mto: This revision was merged to the branch mainline in revision 490.
  • Revision ID: teddy@fukt.bsnet.se-20110727175827-nrd1ysjl4jrh6qw1
Tags: version-1.3.1-1
* Makefile (version): Changed to "1.3.1".
* NEWS (Version 1.3.1): New entry.
* debian/changelog (1.3.1-1): - '' -

Show diffs side-by-side

added added

removed removed

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