/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

* initramfs-tools-script: Abort if plugin-runner is missing.  Removed
                          workaround for Debian bug #633582; the
                          workaround required getopt, which can not be
                          guaranteed.
* plugin-runner.c (main): Work around Debian bug #633582.
* plugins.d/mandos-client.c (main): - '' -

Show diffs side-by-side

added added

removed removed

Lines of Context:
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@fukt.bsnet.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() */
 
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_* */
29
97
#include <avahi-core/core.h>
30
98
#include <avahi-core/lookup.h>
31
99
#include <avahi-core/log.h>
33
101
#include <avahi-common/malloc.h>
34
102
#include <avahi-common/error.h>
35
103
 
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
 
 
54
 
#ifndef CERT_ROOT
55
 
#define CERT_ROOT "/conf/conf.d/cryptkeyreq/"
56
 
#endif
57
 
#define CERTFILE CERT_ROOT "openpgp-client.txt"
58
 
#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
 
59
121
#define BUFFER_SIZE 256
60
 
#define DH_BITS 1024
 
122
 
 
123
#define PATHDIR "/conf/conf.d/mandos"
 
124
#define SECKEY "seckey.txt"
 
125
#define PUBKEY "pubkey.txt"
61
126
 
62
127
bool debug = false;
63
 
 
 
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 */
64
146
typedef struct {
65
 
  gnutls_session_t session;
 
147
  AvahiSimplePoll *simple_poll;
 
148
  AvahiServer *server;
66
149
  gnutls_certificate_credentials_t cred;
 
150
  unsigned int dh_bits;
67
151
  gnutls_dh_params_t dh_params;
68
 
} encrypted_session;
69
 
 
70
 
 
71
 
ssize_t gpg_packet_decrypt (char *packet, size_t packet_size, char **new_packet, char *homedir){
72
 
  gpgme_data_t dh_crypto, dh_plain;
 
152
  const char *priority;
73
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){
74
232
  gpgme_error_t rc;
75
 
  ssize_t ret;
76
 
  size_t new_packet_capacity = 0;
77
 
  size_t new_packet_length = 0;
78
233
  gpgme_engine_info_t engine_info;
79
 
 
80
 
  if (debug){
81
 
    fprintf(stderr, "Attempting to decrypt password from gpg packet\n");
 
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");
82
274
  }
83
275
  
84
276
  /* Init GPGME */
85
277
  gpgme_check_version(NULL);
86
 
  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
  }
87
284
  
88
 
  /* Set GPGME home directory */
89
 
  rc = gpgme_get_engine_info (&engine_info);
90
 
  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){
91
288
    fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
92
289
            gpgme_strsource(rc), gpgme_strerror(rc));
93
 
    return -1;
 
290
    return false;
94
291
  }
95
292
  while(engine_info != NULL){
96
293
    if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){
97
294
      gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,
98
 
                            engine_info->file_name, homedir);
 
295
                            engine_info->file_name, tempdir);
99
296
      break;
100
297
    }
101
298
    engine_info = engine_info->next;
102
299
  }
103
300
  if(engine_info == NULL){
104
 
    fprintf(stderr, "Could not set home dir to %s\n", homedir);
105
 
    return -1;
106
 
  }
107
 
  
108
 
  /* Create new GPGME data buffer from packet buffer */
109
 
  rc = gpgme_data_new_from_mem(&dh_crypto, packet, packet_size, 0);
110
 
  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){
111
341
    fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
112
342
            gpgme_strsource(rc), gpgme_strerror(rc));
113
343
    return -1;
115
345
  
116
346
  /* Create new empty GPGME data buffer for the plaintext */
117
347
  rc = gpgme_data_new(&dh_plain);
118
 
  if (rc != GPG_ERR_NO_ERROR){
 
348
  if(rc != GPG_ERR_NO_ERROR){
119
349
    fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
120
350
            gpgme_strsource(rc), gpgme_strerror(rc));
121
 
    return -1;
122
 
  }
123
 
  
124
 
  /* Create new GPGME "context" */
125
 
  rc = gpgme_new(&ctx);
126
 
  if (rc != GPG_ERR_NO_ERROR){
127
 
    fprintf(stderr, "bad gpgme_new: %s: %s\n",
128
 
            gpgme_strsource(rc), gpgme_strerror(rc));
129
 
    return -1;
130
 
  }
131
 
  
132
 
  /* Decrypt data from the FILE pointer to the plaintext data buffer */
133
 
  rc = gpgme_op_decrypt(ctx, dh_crypto, dh_plain);
134
 
  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){
135
359
    fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
136
360
            gpgme_strsource(rc), gpgme_strerror(rc));
137
 
    return -1;
138
 
  }
139
 
 
140
 
  if(debug){
141
 
    fprintf(stderr, "decryption of gpg packet succeeded\n");
142
 
  }
143
 
 
144
 
  if (debug){
145
 
    gpgme_decrypt_result_t result;
146
 
    result = gpgme_op_decrypt_result(ctx);
147
 
    if (result == NULL){
148
 
      fprintf(stderr, "gpgme_op_decrypt_result failed\n");
149
 
    } else {
150
 
      fprintf(stderr, "Unsupported algorithm: %s\n", result->unsupported_algorithm);
151
 
      fprintf(stderr, "Wrong key usage: %d\n", result->wrong_key_usage);
152
 
      if(result->file_name != NULL){
153
 
        fprintf(stderr, "File name: %s\n", result->file_name);
154
 
      }
155
 
      gpgme_recipient_t recipient;
156
 
      recipient = result->recipients;
157
 
      if(recipient){
 
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;
158
377
        while(recipient != NULL){
159
378
          fprintf(stderr, "Public key algorithm: %s\n",
160
379
                  gpgme_pubkey_algo_name(recipient->pubkey_algo));
161
380
          fprintf(stderr, "Key ID: %s\n", recipient->keyid);
162
381
          fprintf(stderr, "Secret key available: %s\n",
163
 
                  recipient->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
 
382
                  recipient->status == GPG_ERR_NO_SECKEY
 
383
                  ? "No" : "Yes");
164
384
          recipient = recipient->next;
165
385
        }
166
386
      }
167
387
    }
 
388
    goto decrypt_end;
168
389
  }
169
390
  
170
 
  /* Delete the GPGME FILE pointer cryptotext data buffer */
171
 
  gpgme_data_release(dh_crypto);
 
391
  if(debug){
 
392
    fprintf(stderr, "Decryption of OpenPGP data succeeded\n");
 
393
  }
172
394
  
173
395
  /* Seek back to the beginning of the GPGME plaintext data buffer */
174
 
  gpgme_data_seek(dh_plain, 0, SEEK_SET);
175
 
 
176
 
  *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;
177
403
  while(true){
178
 
    if (new_packet_length + BUFFER_SIZE > new_packet_capacity){
179
 
      *new_packet = realloc(*new_packet, new_packet_capacity + BUFFER_SIZE);
180
 
      if (*new_packet == NULL){
181
 
        perror("realloc");
182
 
        return -1;
183
 
      }
184
 
      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;
185
411
    }
186
412
    
187
 
    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);
188
415
    /* Print the data, if any */
189
 
    if (ret == 0){
190
 
      /* If password is empty, then a incorrect error will be printed */
 
416
    if(ret == 0){
 
417
      /* EOF */
191
418
      break;
192
419
    }
193
420
    if(ret < 0){
194
 
      perror("gpgme_data_read");
195
 
      return -1;
 
421
      perror_plus("gpgme_data_read");
 
422
      plaintext_length = -1;
 
423
      goto decrypt_end;
196
424
    }
197
 
    new_packet_length += ret;
 
425
    plaintext_length += ret;
198
426
  }
199
 
 
 
427
  
200
428
  if(debug){
201
 
    fprintf(stderr, "decrypted password is: %s\n", *new_packet);
 
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");
202
434
  }
203
 
 
204
 
   /* Delete the GPGME plaintext data buffer */
 
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 */
205
442
  gpgme_data_release(dh_plain);
206
 
  return new_packet_length;
 
443
  return plaintext_length;
207
444
}
208
445
 
209
 
static const char * safer_gnutls_strerror (int value) {
210
 
  const char *ret = gnutls_strerror (value);
211
 
  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)
212
450
    ret = "(unknown)";
213
451
  return ret;
214
452
}
215
453
 
216
 
void debuggnutls(int level, const char* string){
217
 
  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);
218
458
}
219
459
 
220
 
int initgnutls(encrypted_session *es){
221
 
  const char *err;
 
460
static int init_gnutls_global(const char *pubkeyfilename,
 
461
                              const char *seckeyfilename){
222
462
  int ret;
223
 
 
 
463
  
224
464
  if(debug){
225
 
    fprintf(stderr, "Initializing gnutls\n");
 
465
    fprintf(stderr, "Initializing GnuTLS\n");
226
466
  }
227
 
 
228
467
  
229
 
  if ((ret = gnutls_global_init ())
230
 
      != GNUTLS_E_SUCCESS) {
231
 
    fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
 
468
  ret = gnutls_global_init();
 
469
  if(ret != GNUTLS_E_SUCCESS){
 
470
    fprintf(stderr, "GnuTLS global_init: %s\n",
 
471
            safer_gnutls_strerror(ret));
232
472
    return -1;
233
473
  }
234
 
 
235
 
  if (debug){
 
474
  
 
475
  if(debug){
 
476
    /* "Use a log level over 10 to enable all debugging options."
 
477
     * - GnuTLS manual
 
478
     */
236
479
    gnutls_global_set_log_level(11);
237
480
    gnutls_global_set_log_function(debuggnutls);
238
481
  }
239
482
  
240
 
 
241
 
  /* openpgp credentials */
242
 
  if ((ret = gnutls_certificate_allocate_credentials (&es->cred))
243
 
      != GNUTLS_E_SUCCESS) {
244
 
    fprintf (stderr, "memory error: %s\n", safer_gnutls_strerror(ret));
 
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();
245
489
    return -1;
246
490
  }
247
 
 
 
491
  
248
492
  if(debug){
249
 
    fprintf(stderr, "Attempting to use openpgp certificate %s"
250
 
            " and keyfile %s as gnutls credentials\n", CERTFILE, KEYFILE);
 
493
    fprintf(stderr, "Attempting to use OpenPGP public key %s and"
 
494
            " secret key %s as GnuTLS credentials\n", pubkeyfilename,
 
495
            seckeyfilename);
251
496
  }
252
 
 
 
497
  
253
498
  ret = gnutls_certificate_set_openpgp_key_file
254
 
    (es->cred, CERTFILE, KEYFILE, GNUTLS_OPENPGP_FMT_BASE64);
255
 
  if (ret != GNUTLS_E_SUCCESS) {
256
 
    fprintf
257
 
      (stderr, "Error[%d] while reading the OpenPGP key pair ('%s', '%s')\n",
258
 
       ret, CERTFILE, KEYFILE);
259
 
    fprintf(stdout, "The Error is: %s\n",
260
 
            safer_gnutls_strerror(ret));
261
 
    return -1;
262
 
  }
263
 
 
264
 
  //Gnutls server initialization
265
 
  if ((ret = gnutls_dh_params_init (&es->dh_params))
266
 
      != GNUTLS_E_SUCCESS) {
267
 
    fprintf (stderr, "Error in dh parameter initialization: %s\n",
268
 
             safer_gnutls_strerror(ret));
269
 
    return -1;
270
 
  }
271
 
 
272
 
  if ((ret = gnutls_dh_params_generate2 (es->dh_params, DH_BITS))
273
 
      != GNUTLS_E_SUCCESS) {
274
 
    fprintf (stderr, "Error in prime generation: %s\n",
275
 
             safer_gnutls_strerror(ret));
276
 
    return -1;
277
 
  }
278
 
 
279
 
  gnutls_certificate_set_dh_params (es->cred, es->dh_params);
280
 
 
281
 
  // Gnutls session creation
282
 
  if ((ret = gnutls_init (&es->session, GNUTLS_SERVER))
283
 
      != GNUTLS_E_SUCCESS){
284
 
    fprintf(stderr, "Error in gnutls session initialization: %s\n",
285
 
            safer_gnutls_strerror(ret));
286
 
  }
287
 
 
288
 
  if ((ret = gnutls_priority_set_direct (es->session, "NORMAL", &err))
289
 
      != GNUTLS_E_SUCCESS) {
290
 
    fprintf(stderr, "Syntax error at: %s\n", err);
291
 
    fprintf(stderr, "Gnutls error: %s\n",
292
 
            safer_gnutls_strerror(ret));
293
 
    return -1;
294
 
  }
295
 
 
296
 
  if ((ret = gnutls_credentials_set
297
 
       (es->session, GNUTLS_CRD_CERTIFICATE, es->cred))
298
 
      != GNUTLS_E_SUCCESS) {
299
 
    fprintf(stderr, "Error setting a credentials set: %s\n",
300
 
            safer_gnutls_strerror(ret));
301
 
    return -1;
302
 
  }
303
 
 
 
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
  
304
583
  /* ignore client certificate if any. */
305
 
  gnutls_certificate_server_set_request (es->session, GNUTLS_CERT_IGNORE);
 
584
  gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
306
585
  
307
 
  gnutls_dh_set_prime_bits (es->session, DH_BITS);
 
586
  gnutls_dh_set_prime_bits(*session, mc.dh_bits);
308
587
  
309
588
  return 0;
310
589
}
311
590
 
312
 
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){}
313
594
 
314
 
int start_mandos_communcation(char *ip, uint16_t port){
315
 
  int ret, tcp_sd;
316
 
  struct sockaddr_in6 to;
317
 
  struct in6_addr ip_addr;
318
 
  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;
319
605
  char *buffer = NULL;
320
 
  char *decrypted_buffer;
 
606
  char *decrypted_buffer = NULL;
321
607
  size_t buffer_length = 0;
322
608
  size_t buffer_capacity = 0;
323
 
  ssize_t decrypted_buffer_size;
324
 
  int retval = 0;
325
 
  const char interface[] = "eth0";
326
 
 
327
 
  if(debug){
328
 
    fprintf(stderr, "Setting up a tcp connection to %s\n", ip);
329
 
  }
330
 
  
331
 
  tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
332
 
  if(tcp_sd < 0) {
333
 
    perror("socket");
334
 
    return -1;
335
 
  }
336
 
 
337
 
  if(debug){
338
 
    fprintf(stderr, "Binding to interface %s\n", interface);
339
 
  }
340
 
 
341
 
  ret = setsockopt(tcp_sd, SOL_SOCKET, SO_BINDTODEVICE, interface, 5);
342
 
  if(tcp_sd < 0) {
343
 
    perror("setsockopt bindtodevice");
344
 
    return -1;
345
 
  }
346
 
  
347
 
  memset(&to,0,sizeof(to));
348
 
  to.sin6_family = AF_INET6;
349
 
  ret = inet_pton(AF_INET6, ip, &ip_addr);
350
 
  if (ret < 0 ){
351
 
    perror("inet_pton");
352
 
    return -1;
353
 
  }  
 
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
  }
354
671
  if(ret == 0){
 
672
    int e = errno;
355
673
    fprintf(stderr, "Bad address: %s\n", ip);
356
 
    return -1;
357
 
  }
358
 
  to.sin6_port = htons(port);
359
 
  to.sin6_scope_id = if_nametoindex(interface);
360
 
 
361
 
  if(debug){
362
 
    fprintf(stderr, "Connection to: %s\n", ip);
363
 
  }
364
 
  
365
 
  ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
366
 
  if (ret < 0){
367
 
    perror("connect");
368
 
    return -1;
369
 
  }
370
 
  
371
 
  ret = initgnutls (&es);
372
 
  if (ret != 0){
373
 
    retval = -1;
374
 
    return -1;
375
 
  }
376
 
    
377
 
  
378
 
  gnutls_transport_set_ptr (es.session, (gnutls_transport_ptr_t) tcp_sd);
379
 
 
380
 
  if(debug){
381
 
    fprintf(stderr, "Establishing tls session with %s\n", ip);
382
 
  }
383
 
 
384
 
  
385
 
  ret = gnutls_handshake (es.session);
386
 
  
387
 
  if (ret != GNUTLS_E_SUCCESS){
388
 
    fprintf(stderr, "\n*** Handshake failed ***\n");
389
 
    gnutls_perror (ret);
390
 
    retval = -1;
391
 
    goto exit;
392
 
  }
393
 
 
394
 
  //Retrieve gpg packet that contains the wanted password
395
 
 
396
 
  if(debug){
397
 
    fprintf(stderr, "Retrieving pgp encrypted password from %s\n", ip);
398
 
  }
399
 
 
400
 
  while(true){
401
 
    if (buffer_length + BUFFER_SIZE > buffer_capacity){
402
 
      buffer = realloc(buffer, buffer_capacity + BUFFER_SIZE);
403
 
      if (buffer == NULL){
404
 
        perror("realloc");
405
 
        goto exit;
406
 
      }
407
 
      buffer_capacity += BUFFER_SIZE;
408
 
    }
409
 
    
410
 
    ret = gnutls_record_recv
411
 
      (es.session, buffer+buffer_length, BUFFER_SIZE);
412
 
    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){
413
856
      break;
414
857
    }
415
 
    if (ret < 0){
416
 
      switch(ret){
 
858
    if(sret < 0){
 
859
      switch(sret){
417
860
      case GNUTLS_E_INTERRUPTED:
418
861
      case GNUTLS_E_AGAIN:
419
862
        break;
420
863
      case GNUTLS_E_REHANDSHAKE:
421
 
        ret = gnutls_handshake (es.session);
422
 
        if (ret < 0){
423
 
          fprintf(stderr, "\n*** Handshake failed ***\n");
424
 
          gnutls_perror (ret);
425
 
          retval = -1;
426
 
          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;
427
877
        }
428
878
        break;
429
879
      default:
430
 
        fprintf(stderr, "Unknown error while reading data from encrypted session with mandos server\n");
431
 
        retval = -1;
432
 
        gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
433
 
        goto exit;
434
 
      }
435
 
    } else {
436
 
      buffer_length += ret;
437
 
    }
438
 
  }
439
 
  
440
 
  if (buffer_length > 0){
441
 
    if ((decrypted_buffer_size = gpg_packet_decrypt(buffer, buffer_length, &decrypted_buffer, CERT_ROOT)) >= 0){
442
 
      fwrite (decrypted_buffer, 1, decrypted_buffer_size, stdout);
443
 
      free(decrypted_buffer);
444
 
    } else {
 
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;
 
885
      }
 
886
    } else {
 
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;
445
960
      retval = -1;
446
961
    }
447
962
  }
448
 
 
449
 
  //shutdown procedure
450
 
 
451
 
  if(debug){
452
 
    fprintf(stderr, "Closing tls session\n");
453
 
  }
454
 
 
455
 
  free(buffer);
456
 
  gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
457
 
 exit:
458
 
  close(tcp_sd);
459
 
  gnutls_deinit (es.session);
460
 
  gnutls_certificate_free_credentials (es.cred);
461
 
  gnutls_global_deinit ();
462
963
  return retval;
463
964
}
464
965
 
465
 
static AvahiSimplePoll *simple_poll = NULL;
466
 
static AvahiServer *server = NULL;
467
 
 
468
 
static void resolve_callback(
469
 
    AvahiSServiceResolver *r,
470
 
    AVAHI_GCC_UNUSED AvahiIfIndex interface,
471
 
    AVAHI_GCC_UNUSED AvahiProtocol protocol,
472
 
    AvahiResolverEvent event,
473
 
    const char *name,
474
 
    const char *type,
475
 
    const char *domain,
476
 
    const char *host_name,
477
 
    const AvahiAddress *address,
478
 
    uint16_t port,
479
 
    AvahiStringList *txt,
480
 
    AvahiLookupResultFlags flags,
481
 
    AVAHI_GCC_UNUSED void* userdata) {
482
 
    
483
 
    assert(r);
484
 
 
485
 
    /* Called whenever a service has been resolved successfully or timed out */
486
 
 
487
 
    switch (event) {
488
 
        case AVAHI_RESOLVER_FAILURE:
489
 
            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)));
490
 
            break;
491
 
 
492
 
        case AVAHI_RESOLVER_FOUND: {
493
 
          char ip[AVAHI_ADDRESS_STR_MAX];
494
 
            avahi_address_snprint(ip, sizeof(ip), address);
495
 
            if(debug){
496
 
              fprintf(stderr, "Mandos server found at %s on port %d\n", ip, port);
497
 
            }
498
 
            int ret = start_mandos_communcation(ip, port);
499
 
            if (ret == 0){
500
 
              exit(EXIT_SUCCESS);
501
 
            } else {
502
 
              exit(EXIT_FAILURE);
503
 
            }
504
 
        }
505
 
    }
506
 
    avahi_s_service_resolver_free(r);
507
 
}
508
 
 
509
 
static void browse_callback(
510
 
    AvahiSServiceBrowser *b,
511
 
    AvahiIfIndex interface,
512
 
    AvahiProtocol protocol,
513
 
    AvahiBrowserEvent event,
514
 
    const char *name,
515
 
    const char *type,
516
 
    const char *domain,
517
 
    AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
518
 
    void* userdata) {
519
 
    
520
 
    AvahiServer *s = userdata;
521
 
    assert(b);
522
 
 
523
 
    /* Called whenever a new services becomes available on the LAN or is removed from the LAN */
524
 
 
525
 
    switch (event) {
526
 
 
527
 
        case AVAHI_BROWSER_FAILURE:
528
 
            
529
 
            fprintf(stderr, "(Browser) %s\n", avahi_strerror(avahi_server_errno(server)));
530
 
            avahi_simple_poll_quit(simple_poll);
531
 
            return;
532
 
 
533
 
        case AVAHI_BROWSER_NEW:
534
 
            /* We ignore the returned resolver object. In the callback
535
 
               function we free it. If the server is terminated before
536
 
               the callback function is called the server will free
537
 
               the resolver for us. */
538
 
            
539
 
            if (!(avahi_s_service_resolver_new(s, interface, protocol, name, type, domain, AVAHI_PROTO_INET6, 0, resolve_callback, s)))
540
 
                fprintf(stderr, "Failed to resolve service '%s': %s\n", name, avahi_strerror(avahi_server_errno(s)));
541
 
            
542
 
            break;
543
 
 
544
 
        case AVAHI_BROWSER_REMOVE:
545
 
            break;
546
 
 
547
 
        case AVAHI_BROWSER_ALL_FOR_NOW:
548
 
        case AVAHI_BROWSER_CACHE_EXHAUSTED:
549
 
            break;
550
 
    }
551
 
}
552
 
 
553
 
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
  {
554
1865
    AvahiServerConfig config;
555
 
    AvahiSServiceBrowser *sb = NULL;
556
 
    const char db[] = "--debug";
557
 
    int error;
558
 
    int ret = 1;
559
 
    int returncode = EXIT_SUCCESS;
560
 
    char *basename = rindex(argv[0], '/');
561
 
    if(basename == NULL){
562
 
      basename = argv[0];
563
 
    } else {
564
 
      basename++;
565
 
    }
566
 
    
567
 
    char *program_name = malloc(strlen(basename) + sizeof(db));
568
 
 
569
 
    if (program_name == NULL){
570
 
      perror("argv[0]");
571
 
      return EXIT_FAILURE;
572
 
    }
573
 
    
574
 
    program_name[0] = '\0';
575
 
    
576
 
    for (int i = 1; i < argc; i++){
577
 
      if (not strncmp(argv[i], db, 5)){
578
 
          strcat(strcat(strcat(program_name, db ), "="), basename);
579
 
          if(not strcmp(argv[i], db) or not strcmp(argv[i], program_name)){
580
 
            debug = true;
581
 
          }
582
 
        }
583
 
    }
584
 
    free(program_name);
585
 
 
586
 
    if (not debug){
587
 
      avahi_set_log_function(empty_log);
588
 
    }
589
 
    
590
 
    /* Initialize the psuedo-RNG */
591
 
    srand(time(NULL));
592
 
 
593
 
    /* Allocate main loop object */
594
 
    if (!(simple_poll = avahi_simple_poll_new())) {
595
 
        fprintf(stderr, "Failed to create simple poll object.\n");
596
 
        
597
 
        goto exit;
598
 
    }
599
 
 
600
 
    /* Do not publish any local records */
 
1866
    /* Do not publish any local Zeroconf records */
601
1867
    avahi_server_config_init(&config);
602
1868
    config.publish_hinfo = 0;
603
1869
    config.publish_addresses = 0;
604
1870
    config.publish_workstation = 0;
605
1871
    config.publish_domain = 0;
606
 
 
 
1872
    
607
1873
    /* Allocate a new server */
608
 
    server = avahi_server_new(avahi_simple_poll_get(simple_poll), &config, NULL, NULL, &error);
609
 
 
610
 
    /* 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 */
611
1879
    avahi_server_config_free(&config);
612
 
 
613
 
    /* Check if creating the server object succeeded */
614
 
    if (!server) {
615
 
        fprintf(stderr, "Failed to create server: %s\n", avahi_strerror(error));
616
 
        returncode = EXIT_FAILURE;
617
 
        goto exit;
618
 
    }
619
 
    
620
 
    /* Create the service browser */
621
 
    if (!(sb = avahi_s_service_browser_new(server, if_nametoindex("eth0"), AVAHI_PROTO_INET6, "_mandos._tcp", NULL, 0, browse_callback, server))) {
622
 
        fprintf(stderr, "Failed to create service browser: %s\n", avahi_strerror(avahi_server_errno(server)));
623
 
        returncode = EXIT_FAILURE;
624
 
        goto exit;
625
 
    }
626
 
    
627
 
    /* Run the main loop */
628
 
 
629
 
    if (debug){
630
 
      fprintf(stderr, "Starting avahi loop search\n");
631
 
    }
632
 
    
633
 
    avahi_simple_poll_loop(simple_poll);
634
 
    
635
 
exit:
636
 
 
637
 
    if (debug){
638
 
      fprintf(stderr, "%s exiting\n", argv[0]);
639
 
    }
640
 
    
641
 
    /* Cleanup things */
642
 
    if (sb)
643
 
        avahi_s_service_browser_free(sb);
644
 
    
645
 
    if (server)
646
 
        avahi_server_free(server);
647
 
 
648
 
    if (simple_poll)
649
 
        avahi_simple_poll_free(simple_poll);
650
 
 
651
 
    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;
652
2047
}