/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
34
34
 
35
35
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY() */
36
36
 
37
 
#include <stdio.h>
 
37
#include <stdio.h>              /* fprintf(), stderr, fwrite(), stdout, ferror() */
 
38
#include <stdint.h>             /* uint16_t, uint32_t */
 
39
#include <stddef.h>             /* NULL, size_t, ssize_t */
 
40
#include <stdlib.h>             /* free() */
 
41
#include <stdbool.h>            /* bool, true */
 
42
#include <string.h>             /* memset(), strcmp(), strlen, strerror() */
 
43
#include <sys/ioctl.h>          /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
 
44
                                   SIOCSIFFLAGS */
 
45
#include <sys/types.h>          /* socket(), inet_pton(), sockaddr,
 
46
                                   sockaddr_in6, PF_INET6, SOCK_STREAM, INET6_ADDRSTRLEN */
 
47
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
 
48
                                   struct in6_addr, inet_pton(),
 
49
                                   connect() */
38
50
#include <assert.h>
39
 
#include <stdlib.h>
 
51
#include <errno.h>              /* perror() */
40
52
#include <time.h>
41
 
#include <net/if.h>             /* if_nametoindex */
42
 
#include <sys/ioctl.h>          /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
43
 
                                   SIOCSIFFLAGS */
44
53
#include <net/if.h>             /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
45
 
                                   SIOCSIFFLAGS */
46
 
 
47
 
#include <avahi-core/core.h>
48
 
#include <avahi-core/lookup.h>
49
 
#include <avahi-core/log.h>
50
 
#include <avahi-common/simple-watch.h>
51
 
#include <avahi-common/malloc.h>
52
 
#include <avahi-common/error.h>
53
 
 
54
 
/* Mandos client part */
55
 
#include <sys/types.h>          /* socket(), inet_pton() */
56
 
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
57
 
                                   struct in6_addr, inet_pton() */
58
 
#include <gnutls/gnutls.h>      /* All GnuTLS stuff */
59
 
#include <gnutls/openpgp.h>     /* GnuTLS with openpgp stuff */
60
 
 
61
 
#include <unistd.h>             /* close() */
 
54
                                   SIOCSIFFLAGS, if_indextoname(),
 
55
                                   if_nametoindex(), IF_NAMESIZE */
 
56
#include <unistd.h>             /* close(), SEEK_SET, off_t, write()*/
62
57
#include <netinet/in.h>
63
 
#include <stdbool.h>            /* true */
64
 
#include <string.h>             /* memset */
65
 
#include <arpa/inet.h>          /* inet_pton() */
 
58
#include <arpa/inet.h>          /* inet_pton(), htons */
66
59
#include <iso646.h>             /* not */
67
 
#include <net/if.h>             /* IF_NAMESIZE */
68
60
#include <argp.h>               /* struct argp_option,
69
61
                                   struct argp_state, struct argp,
70
62
                                   argp_parse() */
 
63
 
 
64
/* Avahi */
 
65
#include <avahi-core/core.h>    /* AvahiSimplePoll, AvahiServer,
 
66
                                   AvahiIfIndex */
 
67
#include <avahi-core/lookup.h>
 
68
#include <avahi-core/log.h>     /* AvahiLogLevel */
 
69
#include <avahi-common/simple-watch.h>
 
70
#include <avahi-common/malloc.h>
 
71
#include <avahi-common/error.h>
 
72
 
 
73
/* GnuTLS */
 
74
#include <gnutls/gnutls.h>      /* gnutls_certificate_credentials_t,
 
75
                                   gnutls_dh_params_t,
 
76
                                   gnutls_strerror(),
 
77
                                   gnutls_global_init(),
 
78
                                   gnutls_global_set_log_level(),
 
79
                                   gnutls_global_set_log_function(),
 
80
                                   gnutls_certificate_allocate_credentials(),
 
81
                                   gnutls_global_deinit(),
 
82
                                   gnutls_dh_params_init(),
 
83
                                   gnutls_dh_params_generate(),
 
84
                                   gnutls_certificate_set_dh_params(),
 
85
                                   gnutls_certificate_free_credentials(),
 
86
                                   gnutls_session_t, gnutls_init(),
 
87
                                   gnutls_priority_set_direct(),
 
88
                                   gnutls_deinit(),
 
89
                                   gnutls_credentials_set(),
 
90
                                   gnutls_certificate_server_set_request(),
 
91
                                   gnutls_dh_set_prime_bits(),
 
92
                                   gnutls_transport_set_ptr(),
 
93
                                   gnutls_transport_ptr_t,
 
94
                                   gnutls_handshake(),
 
95
                                   gnutls_record_recv()
 
96
                                   gnutls_perror(), gnutls_bye(),
 
97
                                   init_gnutls_session(),
 
98
                                   GNUTLS_E_SUCCESS,
 
99
                                   GNUTLS_CRD_CERTIFICATE,
 
100
                                   GNUTLS_CERT_IGNORE,
 
101
                                   GNUTLS_E_INTERRUPTED,
 
102
                                   GNUTLS_E_AGAIN,
 
103
                                   GNUTLS_E_REHANDSHAKE,
 
104
                                   GNUTLS_SHUT_RDWR, */
 
105
#include <gnutls/openpgp.h> /* gnutls_certificate_set_openpgp_key_file(),
 
106
                               GNUTLS_OPENPGP_FMT_BASE64 */
 
107
 
71
108
/* GPGME */
72
 
#include <errno.h>              /* perror() */
73
 
#include <gpgme.h>
 
109
#include <gpgme.h>              /* gpgme_data_t, gpgme_ctx_t,
 
110
                                   gpgme_error_t, gpgme_engine_info_t,
 
111
                                   gpgme_check_version(),
 
112
                                   gpgme_engine_check_version(),
 
113
                                   gpgme_strsource(),
 
114
                                   gpgme_strerror(),
 
115
                                   gpgme_get_engine_info(),
 
116
                                   gpgme_set_engine_info(),
 
117
                                   gpgme_data_new_from_mem(),
 
118
                                   gpgme_data_new(), gpgme_new(),
 
119
                                   gpgme_op_decrypt(),
 
120
                                   gpgme_decrypt_result_t,
 
121
                                   gpgme_op_decrypt_result(),
 
122
                                   gpgme_recipient_t,
 
123
                                   gpgme_pubkey_algo_name(),
 
124
                                   gpgme_data_seek(),
 
125
                                   gpgme_data_read(),
 
126
                                   gpgme_data_release()
 
127
                                   GPGME_PROTOCOL_OpenPGP,
 
128
                                   GPG_ERR_NO_ERROR,
 
129
                                   GPG_ERR_NO_SECKEY, */
74
130
 
75
131
#define BUFFER_SIZE 256
76
132
 
319
375
      != GNUTLS_E_SUCCESS) {
320
376
    fprintf (stderr, "GnuTLS memory error: %s\n",
321
377
             safer_gnutls_strerror(ret));
 
378
    gnutls_global_deinit ();
322
379
    return -1;
323
380
  }
324
381
  
336
393
            " '%s')\n", ret, pubkeyfile, seckeyfile);
337
394
    fprintf(stdout, "The GnuTLS error is: %s\n",
338
395
            safer_gnutls_strerror(ret));
339
 
    return -1;
 
396
    goto globalfail;
340
397
  }
341
398
  
342
399
  /* GnuTLS server initialization */
344
401
  if (ret != GNUTLS_E_SUCCESS) {
345
402
    fprintf (stderr, "Error in GnuTLS DH parameter initialization:"
346
403
             " %s\n", safer_gnutls_strerror(ret));
347
 
    return -1;
 
404
    goto globalfail;
348
405
  }
349
406
  ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
350
407
  if (ret != GNUTLS_E_SUCCESS) {
351
408
    fprintf (stderr, "Error in GnuTLS prime generation: %s\n",
352
409
             safer_gnutls_strerror(ret));
353
 
    return -1;
 
410
    goto globalfail;
354
411
  }
355
412
  
356
413
  gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
357
414
 
358
415
  return 0;
 
416
 
 
417
 globalfail:
 
418
 
 
419
  gnutls_certificate_free_credentials(mc->cred);
 
420
  gnutls_global_deinit();
 
421
  return -1;
 
422
 
359
423
}
360
424
 
361
425
static int init_gnutls_session(mandos_context *mc,
375
439
      fprintf(stderr, "Syntax error at: %s\n", err);
376
440
      fprintf(stderr, "GnuTLS error: %s\n",
377
441
              safer_gnutls_strerror(ret));
 
442
      gnutls_deinit (*session);
378
443
      return -1;
379
444
    }
380
445
  }
384
449
  if (ret != GNUTLS_E_SUCCESS) {
385
450
    fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
386
451
            safer_gnutls_strerror(ret));
 
452
    gnutls_deinit (*session);
387
453
    return -1;
388
454
  }
389
455
  
603
669
  free(buffer);
604
670
  close(tcp_sd);
605
671
  gnutls_deinit (session);
606
 
  gnutls_certificate_free_credentials (mc->cred);
607
 
  gnutls_global_deinit ();
608
672
  return retval;
609
673
}
610
674
 
741
805
    const char *seckeyfile = "seckey.txt";
742
806
    mandos_context mc = { .simple_poll = NULL, .server = NULL,
743
807
                          .dh_bits = 1024, .priority = "SECURE256"};
 
808
    bool gnutls_initalized = false;
744
809
    
745
810
    {
746
811
      struct argp_option options[] = {
846
911
    if (ret == -1){
847
912
      fprintf(stderr, "init_gnutls_global\n");
848
913
      goto end;
 
914
    } else {
 
915
      gnutls_initalized = true;
849
916
    }
850
917
 
851
918
    uid = getuid();
1000
1067
        avahi_simple_poll_free(mc.simple_poll);
1001
1068
    free(pubkeyfile);
1002
1069
    free(seckeyfile);
 
1070
 
 
1071
    if (gnutls_initalized){
 
1072
      gnutls_certificate_free_credentials (mc.cred);
 
1073
      gnutls_global_deinit ();
 
1074
    }
1003
1075
    
1004
1076
    return exitcode;
1005
1077
}