/mandos/trunk

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

« back to all changes in this revision

Viewing changes to plugins.d/mandosclient.c

  • Committer: Teddy Hogeborn
  • Date: 2008-08-03 03:33:56 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080803033356-6aemgj0g0hoz91ow
* plugins.d/mandosclient.c (pgp_packet_decrypt): Renamed variables.
                                                 On debug, show
                                                 decrypted plaintext
                                                 in hexadecimal.  Free
                                                 the GPGME data
                                                 buffers even on
                                                 errors.

Show diffs side-by-side

added added

removed removed

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