/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/password-request.c

merge

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/password-request.c
 
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 © 2007-2008 Teddy Hogeborn & Björn Påhlsson
 
13
 * 
 
14
 * This program is free software: you can redistribute it and/or
 
15
 * modify it under the terms of the GNU General Public License as
 
16
 * published by the Free Software Foundation, either version 3 of the
 
17
 * License, or (at your option) any later version.
 
18
 * 
 
19
 * This program is distributed in the hope that it will be useful, but
 
20
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 
21
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
22
 * General Public License for more details.
 
23
 * 
 
24
 * You should have received a copy of the GNU General Public License
 
25
 * along with this program.  If not, see
 
26
 * <http://www.gnu.org/licenses/>.
 
27
 * 
 
28
 * Contact the authors at <mandos@fukt.bsnet.se>.
 
29
 */
 
30
 
 
31
/* Needed by GPGME, specifically gpgme_data_seek() */
 
32
#define _LARGEFILE_SOURCE
 
33
#define _FILE_OFFSET_BITS 64
 
34
 
 
35
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY() */
 
36
 
 
37
#include <stdio.h>              /* fprintf(), stderr, fwrite(), stdout,
 
38
                                   ferror() */
 
39
#include <stdint.h>             /* uint16_t, uint32_t */
 
40
#include <stddef.h>             /* NULL, size_t, ssize_t */
 
41
#include <stdlib.h>             /* free(), EXIT_SUCCESS, EXIT_FAILURE,
 
42
                                   srand() */
 
43
#include <stdbool.h>            /* bool, true */
 
44
#include <string.h>             /* memset(), strcmp(), strlen(),
 
45
                                   strerror(), memcpy(), strcpy() */
 
46
#include <sys/ioctl.h>          /* ioctl */
 
47
#include <net/if.h>             /* ifreq, SIOCGIFFLAGS, SIOCSIFFLAGS,
 
48
                                   IFF_UP */
 
49
#include <sys/types.h>          /* socket(), inet_pton(), sockaddr,
 
50
                                   sockaddr_in6, PF_INET6,
 
51
                                   SOCK_STREAM, INET6_ADDRSTRLEN,
 
52
                                   uid_t, gid_t */
 
53
#include <inttypes.h>           /* PRIu16 */
 
54
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
 
55
                                   struct in6_addr, inet_pton(),
 
56
                                   connect() */
 
57
#include <assert.h>             /* assert() */
 
58
#include <errno.h>              /* perror(), errno */
 
59
#include <time.h>               /* time() */
 
60
#include <net/if.h>             /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
 
61
                                   SIOCSIFFLAGS, if_indextoname(),
 
62
                                   if_nametoindex(), IF_NAMESIZE */
 
63
#include <unistd.h>             /* close(), SEEK_SET, off_t, write(),
 
64
                                   getuid(), getgid(), setuid(),
 
65
                                   setgid() */
 
66
#include <netinet/in.h>
 
67
#include <arpa/inet.h>          /* inet_pton(), htons */
 
68
#include <iso646.h>             /* not, and */
 
69
#include <argp.h>               /* struct argp_option, error_t, struct
 
70
                                   argp_state, struct argp,
 
71
                                   argp_parse(), ARGP_KEY_ARG,
 
72
                                   ARGP_KEY_END, ARGP_ERR_UNKNOWN */
 
73
 
 
74
/* Avahi */
 
75
/* All Avahi types, constants and functions
 
76
 Avahi*, avahi_*,
 
77
 AVAHI_* */
 
78
#include <avahi-core/core.h>
 
79
#include <avahi-core/lookup.h>
 
80
#include <avahi-core/log.h>
 
81
#include <avahi-common/simple-watch.h>
 
82
#include <avahi-common/malloc.h>
 
83
#include <avahi-common/error.h>
 
84
 
 
85
/* GnuTLS */
 
86
#include <gnutls/gnutls.h>      /* All GnuTLS types, constants and functions
 
87
                                   gnutls_*
 
88
                                   init_gnutls_session(),
 
89
                                   GNUTLS_* */
 
90
#include <gnutls/openpgp.h>     /* gnutls_certificate_set_openpgp_key_file(),
 
91
                                   GNUTLS_OPENPGP_FMT_BASE64 */
 
92
 
 
93
/* GPGME */
 
94
#include <gpgme.h>              /* All GPGME types, constants and functions
 
95
                                   gpgme_*
 
96
                                   GPGME_PROTOCOL_OpenPGP,
 
97
                                   GPG_ERR_NO_* */
 
98
 
 
99
#define BUFFER_SIZE 256
 
100
 
 
101
bool debug = false;
 
102
static const char *keydir = "/conf/conf.d/mandos";
 
103
static const char mandos_protocol_version[] = "1";
 
104
const char *argp_program_version = "password-request 1.0";
 
105
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
 
106
 
 
107
/* Used for passing in values through the Avahi callback functions */
 
108
typedef struct {
 
109
  AvahiSimplePoll *simple_poll;
 
110
  AvahiServer *server;
 
111
  gnutls_certificate_credentials_t cred;
 
112
  unsigned int dh_bits;
 
113
  gnutls_dh_params_t dh_params;
 
114
  const char *priority;
 
115
} mandos_context;
 
116
 
 
117
/*
 
118
 * Make room in "buffer" for at least BUFFER_SIZE additional bytes.
 
119
 * "buffer_capacity" is how much is currently allocated,
 
120
 * "buffer_length" is how much is already used.
 
121
 */
 
122
size_t adjustbuffer(char **buffer, size_t buffer_length,
 
123
                  size_t buffer_capacity){
 
124
  if (buffer_length + BUFFER_SIZE > buffer_capacity){
 
125
    *buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
 
126
    if (buffer == NULL){
 
127
      return 0;
 
128
    }
 
129
    buffer_capacity += BUFFER_SIZE;
 
130
  }
 
131
  return buffer_capacity;
 
132
}
 
133
 
 
134
/* 
 
135
 * Decrypt OpenPGP data using keyrings in HOMEDIR.
 
136
 * Returns -1 on error
 
137
 */
 
138
static ssize_t pgp_packet_decrypt (const char *cryptotext,
 
139
                                   size_t crypto_size,
 
140
                                   char **plaintext,
 
141
                                   const char *homedir){
 
142
  gpgme_data_t dh_crypto, dh_plain;
 
143
  gpgme_ctx_t ctx;
 
144
  gpgme_error_t rc;
 
145
  ssize_t ret;
 
146
  size_t plaintext_capacity = 0;
 
147
  ssize_t plaintext_length = 0;
 
148
  gpgme_engine_info_t engine_info;
 
149
  
 
150
  if (debug){
 
151
    fprintf(stderr, "Trying to decrypt OpenPGP data\n");
 
152
  }
 
153
  
 
154
  /* Init GPGME */
 
155
  gpgme_check_version(NULL);
 
156
  rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
 
157
  if (rc != GPG_ERR_NO_ERROR){
 
158
    fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
 
159
            gpgme_strsource(rc), gpgme_strerror(rc));
 
160
    return -1;
 
161
  }
 
162
  
 
163
  /* Set GPGME home directory for the OpenPGP engine only */
 
164
  rc = gpgme_get_engine_info (&engine_info);
 
165
  if (rc != GPG_ERR_NO_ERROR){
 
166
    fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
 
167
            gpgme_strsource(rc), gpgme_strerror(rc));
 
168
    return -1;
 
169
  }
 
170
  while(engine_info != NULL){
 
171
    if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){
 
172
      gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,
 
173
                            engine_info->file_name, homedir);
 
174
      break;
 
175
    }
 
176
    engine_info = engine_info->next;
 
177
  }
 
178
  if(engine_info == NULL){
 
179
    fprintf(stderr, "Could not set GPGME home dir to %s\n", homedir);
 
180
    return -1;
 
181
  }
 
182
  
 
183
  /* Create new GPGME data buffer from memory cryptotext */
 
184
  rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
 
185
                               0);
 
186
  if (rc != GPG_ERR_NO_ERROR){
 
187
    fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
 
188
            gpgme_strsource(rc), gpgme_strerror(rc));
 
189
    return -1;
 
190
  }
 
191
  
 
192
  /* Create new empty GPGME data buffer for the plaintext */
 
193
  rc = gpgme_data_new(&dh_plain);
 
194
  if (rc != GPG_ERR_NO_ERROR){
 
195
    fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
 
196
            gpgme_strsource(rc), gpgme_strerror(rc));
 
197
    gpgme_data_release(dh_crypto);
 
198
    return -1;
 
199
  }
 
200
  
 
201
  /* Create new GPGME "context" */
 
202
  rc = gpgme_new(&ctx);
 
203
  if (rc != GPG_ERR_NO_ERROR){
 
204
    fprintf(stderr, "bad gpgme_new: %s: %s\n",
 
205
            gpgme_strsource(rc), gpgme_strerror(rc));
 
206
    plaintext_length = -1;
 
207
    goto decrypt_end;
 
208
  }
 
209
  
 
210
  /* Decrypt data from the cryptotext data buffer to the plaintext
 
211
     data buffer */
 
212
  rc = gpgme_op_decrypt(ctx, dh_crypto, dh_plain);
 
213
  if (rc != GPG_ERR_NO_ERROR){
 
214
    fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
 
215
            gpgme_strsource(rc), gpgme_strerror(rc));
 
216
    plaintext_length = -1;
 
217
    goto decrypt_end;
 
218
  }
 
219
  
 
220
  if(debug){
 
221
    fprintf(stderr, "Decryption of OpenPGP data succeeded\n");
 
222
  }
 
223
  
 
224
  if (debug){
 
225
    gpgme_decrypt_result_t result;
 
226
    result = gpgme_op_decrypt_result(ctx);
 
227
    if (result == NULL){
 
228
      fprintf(stderr, "gpgme_op_decrypt_result failed\n");
 
229
    } else {
 
230
      fprintf(stderr, "Unsupported algorithm: %s\n",
 
231
              result->unsupported_algorithm);
 
232
      fprintf(stderr, "Wrong key usage: %u\n",
 
233
              result->wrong_key_usage);
 
234
      if(result->file_name != NULL){
 
235
        fprintf(stderr, "File name: %s\n", result->file_name);
 
236
      }
 
237
      gpgme_recipient_t recipient;
 
238
      recipient = result->recipients;
 
239
      if(recipient){
 
240
        while(recipient != NULL){
 
241
          fprintf(stderr, "Public key algorithm: %s\n",
 
242
                  gpgme_pubkey_algo_name(recipient->pubkey_algo));
 
243
          fprintf(stderr, "Key ID: %s\n", recipient->keyid);
 
244
          fprintf(stderr, "Secret key available: %s\n",
 
245
                  recipient->status == GPG_ERR_NO_SECKEY
 
246
                  ? "No" : "Yes");
 
247
          recipient = recipient->next;
 
248
        }
 
249
      }
 
250
    }
 
251
  }
 
252
  
 
253
  /* Seek back to the beginning of the GPGME plaintext data buffer */
 
254
  if (gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET) == -1){
 
255
    perror("pgpme_data_seek");
 
256
    plaintext_length = -1;
 
257
    goto decrypt_end;
 
258
  }
 
259
  
 
260
  *plaintext = NULL;
 
261
  while(true){
 
262
    plaintext_capacity = adjustbuffer(plaintext,
 
263
                                      (size_t)plaintext_length,
 
264
                                      plaintext_capacity);
 
265
    if (plaintext_capacity == 0){
 
266
        perror("adjustbuffer");
 
267
        plaintext_length = -1;
 
268
        goto decrypt_end;
 
269
    }
 
270
    
 
271
    ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
 
272
                          BUFFER_SIZE);
 
273
    /* Print the data, if any */
 
274
    if (ret == 0){
 
275
      /* EOF */
 
276
      break;
 
277
    }
 
278
    if(ret < 0){
 
279
      perror("gpgme_data_read");
 
280
      plaintext_length = -1;
 
281
      goto decrypt_end;
 
282
    }
 
283
    plaintext_length += ret;
 
284
  }
 
285
 
 
286
  if(debug){
 
287
    fprintf(stderr, "Decrypted password is: ");
 
288
    for(ssize_t i = 0; i < plaintext_length; i++){
 
289
      fprintf(stderr, "%02hhX ", (*plaintext)[i]);
 
290
    }
 
291
    fprintf(stderr, "\n");
 
292
  }
 
293
  
 
294
 decrypt_end:
 
295
  
 
296
  /* Delete the GPGME cryptotext data buffer */
 
297
  gpgme_data_release(dh_crypto);
 
298
  
 
299
  /* Delete the GPGME plaintext data buffer */
 
300
  gpgme_data_release(dh_plain);
 
301
  return plaintext_length;
 
302
}
 
303
 
 
304
static const char * safer_gnutls_strerror (int value) {
 
305
  const char *ret = gnutls_strerror (value);
 
306
  if (ret == NULL)
 
307
    ret = "(unknown)";
 
308
  return ret;
 
309
}
 
310
 
 
311
/* GnuTLS log function callback */
 
312
static void debuggnutls(__attribute__((unused)) int level,
 
313
                        const char* string){
 
314
  fprintf(stderr, "GnuTLS: %s", string);
 
315
}
 
316
 
 
317
static int init_gnutls_global(mandos_context *mc,
 
318
                              const char *pubkeyfile,
 
319
                              const char *seckeyfile){
 
320
  int ret;
 
321
  
 
322
  if(debug){
 
323
    fprintf(stderr, "Initializing GnuTLS\n");
 
324
  }
 
325
  
 
326
  ret = gnutls_global_init();
 
327
  if (ret != GNUTLS_E_SUCCESS) {
 
328
    fprintf (stderr, "GnuTLS global_init: %s\n",
 
329
             safer_gnutls_strerror(ret));
 
330
    return -1;
 
331
  }
 
332
  
 
333
  if (debug){
 
334
    /* "Use a log level over 10 to enable all debugging options."
 
335
     * - GnuTLS manual
 
336
     */
 
337
    gnutls_global_set_log_level(11);
 
338
    gnutls_global_set_log_function(debuggnutls);
 
339
  }
 
340
  
 
341
  /* OpenPGP credentials */
 
342
  gnutls_certificate_allocate_credentials(&mc->cred);
 
343
  if (ret != GNUTLS_E_SUCCESS){
 
344
    fprintf (stderr, "GnuTLS memory error: %s\n",
 
345
             safer_gnutls_strerror(ret));
 
346
    gnutls_global_deinit ();
 
347
    return -1;
 
348
  }
 
349
  
 
350
  if(debug){
 
351
    fprintf(stderr, "Attempting to use OpenPGP certificate %s"
 
352
            " and keyfile %s as GnuTLS credentials\n", pubkeyfile,
 
353
            seckeyfile);
 
354
  }
 
355
  
 
356
  ret = gnutls_certificate_set_openpgp_key_file
 
357
    (mc->cred, pubkeyfile, seckeyfile, GNUTLS_OPENPGP_FMT_BASE64);
 
358
  if (ret != GNUTLS_E_SUCCESS) {
 
359
    fprintf(stderr,
 
360
            "Error[%d] while reading the OpenPGP key pair ('%s',"
 
361
            " '%s')\n", ret, pubkeyfile, seckeyfile);
 
362
    fprintf(stdout, "The GnuTLS error is: %s\n",
 
363
            safer_gnutls_strerror(ret));
 
364
    goto globalfail;
 
365
  }
 
366
  
 
367
  /* GnuTLS server initialization */
 
368
  ret = gnutls_dh_params_init(&mc->dh_params);
 
369
  if (ret != GNUTLS_E_SUCCESS) {
 
370
    fprintf (stderr, "Error in GnuTLS DH parameter initialization:"
 
371
             " %s\n", safer_gnutls_strerror(ret));
 
372
    goto globalfail;
 
373
  }
 
374
  ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
 
375
  if (ret != GNUTLS_E_SUCCESS) {
 
376
    fprintf (stderr, "Error in GnuTLS prime generation: %s\n",
 
377
             safer_gnutls_strerror(ret));
 
378
    goto globalfail;
 
379
  }
 
380
  
 
381
  gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
 
382
 
 
383
  return 0;
 
384
 
 
385
 globalfail:
 
386
 
 
387
  gnutls_certificate_free_credentials(mc->cred);
 
388
  gnutls_global_deinit();
 
389
  return -1;
 
390
 
 
391
}
 
392
 
 
393
static int init_gnutls_session(mandos_context *mc,
 
394
                               gnutls_session_t *session){
 
395
  int ret;
 
396
  /* GnuTLS session creation */
 
397
  ret = gnutls_init(session, GNUTLS_SERVER);
 
398
  if (ret != GNUTLS_E_SUCCESS){
 
399
    fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
 
400
            safer_gnutls_strerror(ret));
 
401
  }
 
402
  
 
403
  {
 
404
    const char *err;
 
405
    ret = gnutls_priority_set_direct(*session, mc->priority, &err);
 
406
    if (ret != GNUTLS_E_SUCCESS) {
 
407
      fprintf(stderr, "Syntax error at: %s\n", err);
 
408
      fprintf(stderr, "GnuTLS error: %s\n",
 
409
              safer_gnutls_strerror(ret));
 
410
      gnutls_deinit (*session);
 
411
      return -1;
 
412
    }
 
413
  }
 
414
  
 
415
  ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
 
416
                               mc->cred);
 
417
  if (ret != GNUTLS_E_SUCCESS) {
 
418
    fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
 
419
            safer_gnutls_strerror(ret));
 
420
    gnutls_deinit (*session);
 
421
    return -1;
 
422
  }
 
423
  
 
424
  /* ignore client certificate if any. */
 
425
  gnutls_certificate_server_set_request (*session,
 
426
                                         GNUTLS_CERT_IGNORE);
 
427
  
 
428
  gnutls_dh_set_prime_bits (*session, mc->dh_bits);
 
429
  
 
430
  return 0;
 
431
}
 
432
 
 
433
/* Avahi log function callback */
 
434
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
 
435
                      __attribute__((unused)) const char *txt){}
 
436
 
 
437
/* Called when a Mandos server is found */
 
438
static int start_mandos_communication(const char *ip, uint16_t port,
 
439
                                      AvahiIfIndex if_index,
 
440
                                      mandos_context *mc){
 
441
  int ret, tcp_sd;
 
442
  union { struct sockaddr in; struct sockaddr_in6 in6; } to;
 
443
  char *buffer = NULL;
 
444
  char *decrypted_buffer;
 
445
  size_t buffer_length = 0;
 
446
  size_t buffer_capacity = 0;
 
447
  ssize_t decrypted_buffer_size;
 
448
  size_t written;
 
449
  int retval = 0;
 
450
  char interface[IF_NAMESIZE];
 
451
  gnutls_session_t session;
 
452
  
 
453
  ret = init_gnutls_session (mc, &session);
 
454
  if (ret != 0){
 
455
    return -1;
 
456
  }
 
457
  
 
458
  if(debug){
 
459
    fprintf(stderr, "Setting up a tcp connection to %s, port %" PRIu16
 
460
            "\n", ip, port);
 
461
  }
 
462
  
 
463
  tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
 
464
  if(tcp_sd < 0) {
 
465
    perror("socket");
 
466
    return -1;
 
467
  }
 
468
 
 
469
  if(debug){
 
470
    if(if_indextoname((unsigned int)if_index, interface) == NULL){
 
471
      perror("if_indextoname");
 
472
      return -1;
 
473
    }
 
474
    fprintf(stderr, "Binding to interface %s\n", interface);
 
475
  }
 
476
  
 
477
  memset(&to,0,sizeof(to));     /* Spurious warning */
 
478
  to.in6.sin6_family = AF_INET6;
 
479
  /* It would be nice to have a way to detect if we were passed an
 
480
     IPv4 address here.   Now we assume an IPv6 address. */
 
481
  ret = inet_pton(AF_INET6, ip, &to.in6.sin6_addr);
 
482
  if (ret < 0 ){
 
483
    perror("inet_pton");
 
484
    return -1;
 
485
  }
 
486
  if(ret == 0){
 
487
    fprintf(stderr, "Bad address: %s\n", ip);
 
488
    return -1;
 
489
  }
 
490
  to.in6.sin6_port = htons(port);       /* Spurious warning */
 
491
  
 
492
  to.in6.sin6_scope_id = (uint32_t)if_index;
 
493
  
 
494
  if(debug){
 
495
    fprintf(stderr, "Connection to: %s, port %" PRIu16 "\n", ip,
 
496
            port);
 
497
    char addrstr[INET6_ADDRSTRLEN] = "";
 
498
    if(inet_ntop(to.in6.sin6_family, &(to.in6.sin6_addr), addrstr,
 
499
                 sizeof(addrstr)) == NULL){
 
500
      perror("inet_ntop");
 
501
    } else {
 
502
      if(strcmp(addrstr, ip) != 0){
 
503
        fprintf(stderr, "Canonical address form: %s\n", addrstr);
 
504
      }
 
505
    }
 
506
  }
 
507
  
 
508
  ret = connect(tcp_sd, &to.in, sizeof(to));
 
509
  if (ret < 0){
 
510
    perror("connect");
 
511
    return -1;
 
512
  }
 
513
 
 
514
  const char *out = mandos_protocol_version;
 
515
  written = 0;
 
516
  while (true){
 
517
    size_t out_size = strlen(out);
 
518
    ret = TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
 
519
                                   out_size - written));
 
520
    if (ret == -1){
 
521
      perror("write");
 
522
      retval = -1;
 
523
      goto mandos_end;
 
524
    }
 
525
    written += (size_t)ret;
 
526
    if(written < out_size){
 
527
      continue;
 
528
    } else {
 
529
      if (out == mandos_protocol_version){
 
530
        written = 0;
 
531
        out = "\r\n";
 
532
      } else {
 
533
        break;
 
534
      }
 
535
    }
 
536
  }
 
537
 
 
538
  if(debug){
 
539
    fprintf(stderr, "Establishing TLS session with %s\n", ip);
 
540
  }
 
541
  
 
542
  gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) tcp_sd);
 
543
 
 
544
  do{
 
545
    ret = gnutls_handshake (session);
 
546
  } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
 
547
  
 
548
  if (ret != GNUTLS_E_SUCCESS){
 
549
    if(debug){
 
550
      fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
 
551
      gnutls_perror (ret);
 
552
    }
 
553
    retval = -1;
 
554
    goto mandos_end;
 
555
  }
 
556
  
 
557
  /* Read OpenPGP packet that contains the wanted password */
 
558
  
 
559
  if(debug){
 
560
    fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
 
561
            ip);
 
562
  }
 
563
 
 
564
  while(true){
 
565
    buffer_capacity = adjustbuffer(&buffer, buffer_length,
 
566
                                   buffer_capacity);
 
567
    if (buffer_capacity == 0){
 
568
      perror("adjustbuffer");
 
569
      retval = -1;
 
570
      goto mandos_end;
 
571
    }
 
572
    
 
573
    ret = gnutls_record_recv(session, buffer+buffer_length,
 
574
                             BUFFER_SIZE);
 
575
    if (ret == 0){
 
576
      break;
 
577
    }
 
578
    if (ret < 0){
 
579
      switch(ret){
 
580
      case GNUTLS_E_INTERRUPTED:
 
581
      case GNUTLS_E_AGAIN:
 
582
        break;
 
583
      case GNUTLS_E_REHANDSHAKE:
 
584
        do{
 
585
          ret = gnutls_handshake (session);
 
586
        } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
 
587
        if (ret < 0){
 
588
          fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
 
589
          gnutls_perror (ret);
 
590
          retval = -1;
 
591
          goto mandos_end;
 
592
        }
 
593
        break;
 
594
      default:
 
595
        fprintf(stderr, "Unknown error while reading data from"
 
596
                " encrypted session with Mandos server\n");
 
597
        retval = -1;
 
598
        gnutls_bye (session, GNUTLS_SHUT_RDWR);
 
599
        goto mandos_end;
 
600
      }
 
601
    } else {
 
602
      buffer_length += (size_t) ret;
 
603
    }
 
604
  }
 
605
  
 
606
  if(debug){
 
607
    fprintf(stderr, "Closing TLS session\n");
 
608
  }
 
609
  
 
610
  gnutls_bye (session, GNUTLS_SHUT_RDWR);
 
611
  
 
612
  if (buffer_length > 0){
 
613
    decrypted_buffer_size = pgp_packet_decrypt(buffer,
 
614
                                               buffer_length,
 
615
                                               &decrypted_buffer,
 
616
                                               keydir);
 
617
    if (decrypted_buffer_size >= 0){
 
618
      written = 0;
 
619
      while(written < (size_t) decrypted_buffer_size){
 
620
        ret = (int)fwrite (decrypted_buffer + written, 1,
 
621
                           (size_t)decrypted_buffer_size - written,
 
622
                           stdout);
 
623
        if(ret == 0 and ferror(stdout)){
 
624
          if(debug){
 
625
            fprintf(stderr, "Error writing encrypted data: %s\n",
 
626
                    strerror(errno));
 
627
          }
 
628
          retval = -1;
 
629
          break;
 
630
        }
 
631
        written += (size_t)ret;
 
632
      }
 
633
      free(decrypted_buffer);
 
634
    } else {
 
635
      retval = -1;
 
636
    }
 
637
  }
 
638
  
 
639
  /* Shutdown procedure */
 
640
  
 
641
 mandos_end:
 
642
  free(buffer);
 
643
  close(tcp_sd);
 
644
  gnutls_deinit (session);
 
645
  return retval;
 
646
}
 
647
 
 
648
static void resolve_callback(AvahiSServiceResolver *r,
 
649
                             AvahiIfIndex interface,
 
650
                             AVAHI_GCC_UNUSED AvahiProtocol protocol,
 
651
                             AvahiResolverEvent event,
 
652
                             const char *name,
 
653
                             const char *type,
 
654
                             const char *domain,
 
655
                             const char *host_name,
 
656
                             const AvahiAddress *address,
 
657
                             uint16_t port,
 
658
                             AVAHI_GCC_UNUSED AvahiStringList *txt,
 
659
                             AVAHI_GCC_UNUSED AvahiLookupResultFlags
 
660
                             flags,
 
661
                             void* userdata) {
 
662
  mandos_context *mc = userdata;
 
663
  assert(r);                    /* Spurious warning */
 
664
  
 
665
  /* Called whenever a service has been resolved successfully or
 
666
     timed out */
 
667
  
 
668
  switch (event) {
 
669
  default:
 
670
  case AVAHI_RESOLVER_FAILURE:
 
671
    fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
 
672
            " of type '%s' in domain '%s': %s\n", name, type, domain,
 
673
            avahi_strerror(avahi_server_errno(mc->server)));
 
674
    break;
 
675
    
 
676
  case AVAHI_RESOLVER_FOUND:
 
677
    {
 
678
      char ip[AVAHI_ADDRESS_STR_MAX];
 
679
      avahi_address_snprint(ip, sizeof(ip), address);
 
680
      if(debug){
 
681
        fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %"
 
682
                PRIu16 ") on port %d\n", name, host_name, ip,
 
683
                interface, port);
 
684
      }
 
685
      int ret = start_mandos_communication(ip, port, interface, mc);
 
686
      if (ret == 0){
 
687
        exit(EXIT_SUCCESS);
 
688
      }
 
689
    }
 
690
  }
 
691
  avahi_s_service_resolver_free(r);
 
692
}
 
693
 
 
694
static void browse_callback( AvahiSServiceBrowser *b,
 
695
                             AvahiIfIndex interface,
 
696
                             AvahiProtocol protocol,
 
697
                             AvahiBrowserEvent event,
 
698
                             const char *name,
 
699
                             const char *type,
 
700
                             const char *domain,
 
701
                             AVAHI_GCC_UNUSED AvahiLookupResultFlags
 
702
                             flags,
 
703
                             void* userdata) {
 
704
  mandos_context *mc = userdata;
 
705
  assert(b);                    /* Spurious warning */
 
706
  
 
707
  /* Called whenever a new services becomes available on the LAN or
 
708
     is removed from the LAN */
 
709
  
 
710
  switch (event) {
 
711
  default:
 
712
  case AVAHI_BROWSER_FAILURE:
 
713
    
 
714
    fprintf(stderr, "(Avahi browser) %s\n",
 
715
            avahi_strerror(avahi_server_errno(mc->server)));
 
716
    avahi_simple_poll_quit(mc->simple_poll);
 
717
    return;
 
718
    
 
719
  case AVAHI_BROWSER_NEW:
 
720
    /* We ignore the returned Avahi resolver object. In the callback
 
721
       function we free it. If the Avahi server is terminated before
 
722
       the callback function is called the Avahi server will free the
 
723
       resolver for us. */
 
724
    
 
725
    if (!(avahi_s_service_resolver_new(mc->server, interface,
 
726
                                       protocol, name, type, domain,
 
727
                                       AVAHI_PROTO_INET6, 0,
 
728
                                       resolve_callback, mc)))
 
729
      fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
 
730
              name, avahi_strerror(avahi_server_errno(mc->server)));
 
731
    break;
 
732
    
 
733
  case AVAHI_BROWSER_REMOVE:
 
734
    break;
 
735
    
 
736
  case AVAHI_BROWSER_ALL_FOR_NOW:
 
737
  case AVAHI_BROWSER_CACHE_EXHAUSTED:
 
738
    if(debug){
 
739
      fprintf(stderr, "No Mandos server found, still searching...\n");
 
740
    }
 
741
    break;
 
742
  }
 
743
}
 
744
 
 
745
/* Combines file name and path and returns the malloced new
 
746
   string. some sane checks could/should be added */
 
747
static const char *combinepath(const char *first, const char *second){
 
748
  size_t f_len = strlen(first);
 
749
  size_t s_len = strlen(second);
 
750
  char *tmp = malloc(f_len + s_len + 2);
 
751
  if (tmp == NULL){
 
752
    return NULL;
 
753
  }
 
754
  if(f_len > 0){
 
755
    memcpy(tmp, first, f_len);  /* Spurious warning */
 
756
  }
 
757
  tmp[f_len] = '/';
 
758
  if(s_len > 0){
 
759
    memcpy(tmp + f_len + 1, second, s_len); /* Spurious warning */
 
760
  }
 
761
  tmp[f_len + 1 + s_len] = '\0';
 
762
  return tmp;
 
763
}
 
764
 
 
765
 
 
766
int main(int argc, char *argv[]){
 
767
    AvahiSServiceBrowser *sb = NULL;
 
768
    int error;
 
769
    int ret;
 
770
    int exitcode = EXIT_SUCCESS;
 
771
    const char *interface = "eth0";
 
772
    struct ifreq network;
 
773
    int sd;
 
774
    uid_t uid;
 
775
    gid_t gid;
 
776
    char *connect_to = NULL;
 
777
    AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
 
778
    const char *pubkeyfile = "pubkey.txt";
 
779
    const char *seckeyfile = "seckey.txt";
 
780
    mandos_context mc = { .simple_poll = NULL, .server = NULL,
 
781
                          .dh_bits = 1024, .priority = "SECURE256"};
 
782
    bool gnutls_initalized = false;
 
783
    
 
784
    {
 
785
      struct argp_option options[] = {
 
786
        { .name = "debug", .key = 128,
 
787
          .doc = "Debug mode", .group = 3 },
 
788
        { .name = "connect", .key = 'c',
 
789
          .arg = "IP",
 
790
          .doc = "Connect directly to a sepcified mandos server",
 
791
          .group = 1 },
 
792
        { .name = "interface", .key = 'i',
 
793
          .arg = "INTERFACE",
 
794
          .doc = "Interface that Avahi will conntect through",
 
795
          .group = 1 },
 
796
        { .name = "keydir", .key = 'd',
 
797
          .arg = "KEYDIR",
 
798
          .doc = "Directory where the openpgp keyring is",
 
799
          .group = 1 },
 
800
        { .name = "seckey", .key = 's',
 
801
          .arg = "SECKEY",
 
802
          .doc = "Secret openpgp key for gnutls authentication",
 
803
          .group = 1 },
 
804
        { .name = "pubkey", .key = 'p',
 
805
          .arg = "PUBKEY",
 
806
          .doc = "Public openpgp key for gnutls authentication",
 
807
          .group = 2 },
 
808
        { .name = "dh-bits", .key = 129,
 
809
          .arg = "BITS",
 
810
          .doc = "dh-bits to use in gnutls communication",
 
811
          .group = 2 },
 
812
        { .name = "priority", .key = 130,
 
813
          .arg = "PRIORITY",
 
814
          .doc = "GNUTLS priority", .group = 1 },
 
815
        { .name = NULL }
 
816
      };
 
817
 
 
818
      
 
819
      error_t parse_opt (int key, char *arg,
 
820
                         struct argp_state *state) {
 
821
        /* Get the INPUT argument from `argp_parse', which we know is
 
822
           a pointer to our plugin list pointer. */
 
823
        switch (key) {
 
824
        case 128:
 
825
          debug = true;
 
826
          break;
 
827
        case 'c':
 
828
          connect_to = arg;
 
829
          break;
 
830
        case 'i':
 
831
          interface = arg;
 
832
          break;
 
833
        case 'd':
 
834
          keydir = arg;
 
835
          break;
 
836
        case 's':
 
837
          seckeyfile = arg;
 
838
          break;
 
839
        case 'p':
 
840
          pubkeyfile = arg;
 
841
          break;
 
842
        case 129:
 
843
          errno = 0;
 
844
          mc.dh_bits = (unsigned int) strtol(arg, NULL, 10);
 
845
          if (errno){
 
846
            perror("strtol");
 
847
            exit(EXIT_FAILURE);
 
848
          }
 
849
          break;
 
850
        case 130:
 
851
          mc.priority = arg;
 
852
          break;
 
853
        case ARGP_KEY_ARG:
 
854
          argp_usage (state);
 
855
          break;
 
856
          case ARGP_KEY_END:
 
857
            break;
 
858
        default:
 
859
          return ARGP_ERR_UNKNOWN;
 
860
        }
 
861
        return 0;
 
862
      }
 
863
 
 
864
      struct argp argp = { .options = options, .parser = parse_opt,
 
865
                           .args_doc = "",
 
866
                           .doc = "Mandos client -- Get and decrypt"
 
867
                           " passwords from mandos server" };
 
868
      ret = argp_parse (&argp, argc, argv, 0, 0, NULL);
 
869
      if (ret == ARGP_ERR_UNKNOWN){
 
870
        fprintf(stderr, "Unkown error while parsing arguments\n");
 
871
        exitcode = EXIT_FAILURE;
 
872
        goto end;
 
873
      }
 
874
    }
 
875
      
 
876
    pubkeyfile = combinepath(keydir, pubkeyfile);
 
877
    if (pubkeyfile == NULL){
 
878
      perror("combinepath");
 
879
      exitcode = EXIT_FAILURE;
 
880
      goto end;
 
881
    }
 
882
    
 
883
    seckeyfile = combinepath(keydir, seckeyfile);
 
884
    if (seckeyfile == NULL){
 
885
      perror("combinepath");
 
886
      goto end;
 
887
    }
 
888
 
 
889
    ret = init_gnutls_global(&mc, pubkeyfile, seckeyfile);
 
890
    if (ret == -1){
 
891
      fprintf(stderr, "init_gnutls_global\n");
 
892
      goto end;
 
893
    } else {
 
894
      gnutls_initalized = true;
 
895
    }
 
896
 
 
897
    uid = getuid();
 
898
    gid = getgid();
 
899
 
 
900
    ret = setuid(uid);
 
901
    if (ret == -1){
 
902
      perror("setuid");
 
903
    }
 
904
    
 
905
    setgid(gid);
 
906
    if (ret == -1){
 
907
      perror("setgid");
 
908
    }
 
909
    
 
910
    if_index = (AvahiIfIndex) if_nametoindex(interface);
 
911
    if(if_index == 0){
 
912
      fprintf(stderr, "No such interface: \"%s\"\n", interface);
 
913
      exit(EXIT_FAILURE);
 
914
    }
 
915
    
 
916
    if(connect_to != NULL){
 
917
      /* Connect directly, do not use Zeroconf */
 
918
      /* (Mainly meant for debugging) */
 
919
      char *address = strrchr(connect_to, ':');
 
920
      if(address == NULL){
 
921
        fprintf(stderr, "No colon in address\n");
 
922
        exitcode = EXIT_FAILURE;
 
923
        goto end;
 
924
      }
 
925
      errno = 0;
 
926
      uint16_t port = (uint16_t) strtol(address+1, NULL, 10);
 
927
      if(errno){
 
928
        perror("Bad port number");
 
929
        exitcode = EXIT_FAILURE;
 
930
        goto end;
 
931
      }
 
932
      *address = '\0';
 
933
      address = connect_to;
 
934
      ret = start_mandos_communication(address, port, if_index, &mc);
 
935
      if(ret < 0){
 
936
        exitcode = EXIT_FAILURE;
 
937
      } else {
 
938
        exitcode = EXIT_SUCCESS;
 
939
      }
 
940
      goto end;
 
941
    }
 
942
    
 
943
    /* If the interface is down, bring it up */
 
944
    {
 
945
      sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
946
      if(sd < 0) {
 
947
        perror("socket");
 
948
        exitcode = EXIT_FAILURE;
 
949
        goto end;
 
950
      }
 
951
      strcpy(network.ifr_name, interface); /* Spurious warning */
 
952
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
 
953
      if(ret == -1){
 
954
        perror("ioctl SIOCGIFFLAGS");
 
955
        exitcode = EXIT_FAILURE;
 
956
        goto end;
 
957
      }
 
958
      if((network.ifr_flags & IFF_UP) == 0){
 
959
        network.ifr_flags |= IFF_UP;
 
960
        ret = ioctl(sd, SIOCSIFFLAGS, &network);
 
961
        if(ret == -1){
 
962
          perror("ioctl SIOCSIFFLAGS");
 
963
          exitcode = EXIT_FAILURE;
 
964
          goto end;
 
965
        }
 
966
      }
 
967
      close(sd);
 
968
    }
 
969
    
 
970
    if (not debug){
 
971
      avahi_set_log_function(empty_log);
 
972
    }
 
973
    
 
974
    /* Initialize the pseudo-RNG for Avahi */
 
975
    srand((unsigned int) time(NULL));
 
976
    
 
977
    /* Allocate main Avahi loop object */
 
978
    mc.simple_poll = avahi_simple_poll_new();
 
979
    if (mc.simple_poll == NULL) {
 
980
        fprintf(stderr, "Avahi: Failed to create simple poll"
 
981
                " object.\n");
 
982
        exitcode = EXIT_FAILURE;
 
983
        goto end;
 
984
    }
 
985
 
 
986
    {
 
987
      AvahiServerConfig config;
 
988
      /* Do not publish any local Zeroconf records */
 
989
      avahi_server_config_init(&config);
 
990
      config.publish_hinfo = 0;
 
991
      config.publish_addresses = 0;
 
992
      config.publish_workstation = 0;
 
993
      config.publish_domain = 0;
 
994
 
 
995
      /* Allocate a new server */
 
996
      mc.server = avahi_server_new(avahi_simple_poll_get
 
997
                                   (mc.simple_poll), &config, NULL,
 
998
                                   NULL, &error);
 
999
    
 
1000
      /* Free the Avahi configuration data */
 
1001
      avahi_server_config_free(&config);
 
1002
    }
 
1003
    
 
1004
    /* Check if creating the Avahi server object succeeded */
 
1005
    if (mc.server == NULL) {
 
1006
        fprintf(stderr, "Failed to create Avahi server: %s\n",
 
1007
                avahi_strerror(error));
 
1008
        exitcode = EXIT_FAILURE;
 
1009
        goto end;
 
1010
    }
 
1011
    
 
1012
    /* Create the Avahi service browser */
 
1013
    sb = avahi_s_service_browser_new(mc.server, if_index,
 
1014
                                     AVAHI_PROTO_INET6,
 
1015
                                     "_mandos._tcp", NULL, 0,
 
1016
                                     browse_callback, &mc);
 
1017
    if (sb == NULL) {
 
1018
        fprintf(stderr, "Failed to create service browser: %s\n",
 
1019
                avahi_strerror(avahi_server_errno(mc.server)));
 
1020
        exitcode = EXIT_FAILURE;
 
1021
        goto end;
 
1022
    }
 
1023
    
 
1024
    /* Run the main loop */
 
1025
 
 
1026
    if (debug){
 
1027
      fprintf(stderr, "Starting Avahi loop search\n");
 
1028
    }
 
1029
    
 
1030
    avahi_simple_poll_loop(mc.simple_poll);
 
1031
    
 
1032
 end:
 
1033
 
 
1034
    if (debug){
 
1035
      fprintf(stderr, "%s exiting\n", argv[0]);
 
1036
    }
 
1037
    
 
1038
    /* Cleanup things */
 
1039
    if (sb != NULL)
 
1040
        avahi_s_service_browser_free(sb);
 
1041
    
 
1042
    if (mc.server != NULL)
 
1043
        avahi_server_free(mc.server);
 
1044
 
 
1045
    if (mc.simple_poll != NULL)
 
1046
        avahi_simple_poll_free(mc.simple_poll);
 
1047
    free(pubkeyfile);
 
1048
    free(seckeyfile);
 
1049
 
 
1050
    if (gnutls_initalized){
 
1051
      gnutls_certificate_free_credentials(mc.cred);
 
1052
      gnutls_global_deinit ();
 
1053
    }
 
1054
    
 
1055
    return exitcode;
 
1056
}