/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-07-31 19:51:44 UTC
  • mfrom: (24.1.5 mandos)
  • Revision ID: teddy@fukt.bsnet.se-20080731195144-yb37wz2sr1e6b3m4
Merge.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/mandosclient.c
67
67
// getopt long
68
68
#include <getopt.h>
69
69
 
70
 
#ifndef CERT_ROOT
71
 
#define CERT_ROOT "/conf/conf.d/cryptkeyreq/"
72
 
#endif
73
 
#define CERTFILE CERT_ROOT "openpgp-client.txt"
74
 
#define KEYFILE CERT_ROOT "openpgp-client-key.txt"
75
70
#define BUFFER_SIZE 256
76
71
#define DH_BITS 1024
77
72
 
 
73
const char *certdir = "/conf/conf.d/cryptkeyreq/";
 
74
const char *certfile = "openpgp-client.txt";
 
75
const char *certkey = "openpgp-client-key.txt";
 
76
 
78
77
bool debug = false;
79
78
 
80
79
typedef struct {
100
99
  
101
100
  /* Init GPGME */
102
101
  gpgme_check_version(NULL);
103
 
  gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
 
102
  rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
 
103
  if (rc != GPG_ERR_NO_ERROR){
 
104
    fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
 
105
            gpgme_strsource(rc), gpgme_strerror(rc));
 
106
    return -1;
 
107
  }
104
108
  
105
109
  /* Set GPGME home directory */
106
110
  rc = gpgme_get_engine_info (&engine_info);
192
196
  gpgme_data_release(dh_crypto);
193
197
  
194
198
  /* Seek back to the beginning of the GPGME plaintext data buffer */
195
 
  gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET);
196
 
 
 
199
  if (gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET) == -1){
 
200
    perror("pgpme_data_seek");
 
201
  }
 
202
  
197
203
  *new_packet = 0;
198
204
  while(true){
199
205
    if (new_packet_length + BUFFER_SIZE > new_packet_capacity){
252
258
  if(debug){
253
259
    fprintf(stderr, "Initializing GnuTLS\n");
254
260
  }
255
 
  
 
261
 
256
262
  if ((ret = gnutls_global_init ())
257
263
      != GNUTLS_E_SUCCESS) {
258
264
    fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
274
280
  
275
281
  if(debug){
276
282
    fprintf(stderr, "Attempting to use OpenPGP certificate %s"
277
 
            " and keyfile %s as GnuTLS credentials\n", CERTFILE,
278
 
            KEYFILE);
 
283
            " and keyfile %s as GnuTLS credentials\n", certfile,
 
284
            certkey);
279
285
  }
280
286
  
281
287
  ret = gnutls_certificate_set_openpgp_key_file
282
 
    (es->cred, CERTFILE, KEYFILE, GNUTLS_OPENPGP_FMT_BASE64);
 
288
    (es->cred, certfile, certkey, GNUTLS_OPENPGP_FMT_BASE64);
283
289
  if (ret != GNUTLS_E_SUCCESS) {
284
290
    fprintf
285
291
      (stderr, "Error[%d] while reading the OpenPGP key pair ('%s',"
286
292
       " '%s')\n",
287
 
       ret, CERTFILE, KEYFILE);
 
293
       ret, certfile, certkey);
288
294
    fprintf(stdout, "The Error is: %s\n",
289
295
            safer_gnutls_strerror(ret));
290
296
    return -1;
487
493
    decrypted_buffer_size = pgp_packet_decrypt(buffer,
488
494
                                               buffer_length,
489
495
                                               &decrypted_buffer,
490
 
                                               CERT_ROOT);
 
496
                                               certdir);
491
497
    if (decrypted_buffer_size >= 0){
492
498
      while(written < (size_t) decrypted_buffer_size){
493
499
        ret = (int)fwrite (decrypted_buffer + written, 1,
622
628
    }
623
629
}
624
630
 
 
631
/* combinds file name and path and returns the malloced new string. som sane checks could/should be added */
 
632
const char *combinepath(const char *first, const char *second){
 
633
  char *tmp;
 
634
  tmp = malloc(strlen(first) + strlen(second) + 2);
 
635
  if (tmp == NULL){
 
636
    perror("malloc");
 
637
    return NULL;
 
638
  }
 
639
  strcpy(tmp, first);
 
640
  if (first[0] != '\0' and first[strlen(first) - 1] != '/'){
 
641
    strcat(tmp, "/");
 
642
  }
 
643
  strcat(tmp, second);
 
644
  return tmp;
 
645
}
 
646
 
 
647
 
625
648
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
626
649
    AvahiServerConfig config;
627
650
    AvahiSServiceBrowser *sb = NULL;
635
658
    while (true){
636
659
      static struct option long_options[] = {
637
660
        {"debug", no_argument, (int *)&debug, 1},
638
 
        {"connect", required_argument, 0, 'c'},
 
661
        {"connect", required_argument, 0, 'C'},
639
662
        {"interface", required_argument, 0, 'i'},
 
663
        {"certdir", required_argument, 0, 'd'},
 
664
        {"certkey", required_argument, 0, 'c'},
 
665
        {"certfile", required_argument, 0, 'k'},
640
666
        {0, 0, 0, 0} };
641
667
      
642
668
      int option_index = 0;
653
679
      case 'i':
654
680
        interface = optarg;
655
681
        break;
 
682
      case 'C':
 
683
        connect_to = optarg;
 
684
        break;
 
685
      case 'd':
 
686
        certdir = optarg;
 
687
        break;
656
688
      case 'c':
657
 
        connect_to = optarg;
 
689
        certfile = optarg;
 
690
        break;
 
691
      case 'k':
 
692
        certkey = optarg;
658
693
        break;
659
694
      default:
660
695
        exit(EXIT_FAILURE);
661
696
      }
662
697
    }
 
698
 
 
699
    certfile = combinepath(certdir, certfile);
 
700
    if (certfile == NULL){
 
701
      goto exit;
 
702
    }
663
703
    
664
704
    if(interface != NULL){
665
705
      if_index = (AvahiIfIndex) if_nametoindex(interface);
693
733
      }
694
734
    }
695
735
    
 
736
    certkey = combinepath(certdir, certkey);
 
737
    if (certkey == NULL){
 
738
      goto exit;
 
739
    }
 
740
    
696
741
    if (not debug){
697
742
      avahi_set_log_function(empty_log);
698
743
    }
764
809
 
765
810
    if (simple_poll)
766
811
        avahi_simple_poll_free(simple_poll);
767
 
 
 
812
    free(certfile);
 
813
    free(certkey);
 
814
    
768
815
    return returncode;
769
816
}