/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

  • Committer: Teddy Hogeborn
  • Date: 2008-09-03 17:34:29 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080903173429-db2mjtddf7mgbx8z
* plugins.d/password-request.xml (OVERVIEW): Refer to
                                             password-prompt(8) by
                                             name.
  (SECURITY): Improved wording.  Add paragraph about insecurity of
              ping.
  (SEE ALSO): Add references to cryptsetup(8) and crypttab(5).
              Changed to be a <variablelist> and added text.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/password-request.c
281
281
    }
282
282
    plaintext_length += ret;
283
283
  }
284
 
 
 
284
  
285
285
  if(debug){
286
286
    fprintf(stderr, "Decrypted password is: ");
287
287
    for(ssize_t i = 0; i < plaintext_length; i++){
348
348
  }
349
349
  
350
350
  if(debug){
351
 
    fprintf(stderr, "Attempting to use OpenPGP certificate %s"
352
 
            " and keyfile %s as GnuTLS credentials\n", pubkeyfilename,
 
351
    fprintf(stderr, "Attempting to use OpenPGP public key %s and"
 
352
            " secret key %s as GnuTLS credentials\n", pubkeyfilename,
353
353
            seckeyfilename);
354
354
  }
355
355
  
360
360
    fprintf(stderr,
361
361
            "Error[%d] while reading the OpenPGP key pair ('%s',"
362
362
            " '%s')\n", ret, pubkeyfilename, seckeyfilename);
363
 
    fprintf(stdout, "The GnuTLS error is: %s\n",
 
363
    fprintf(stderr, "The GnuTLS error is: %s\n",
364
364
            safer_gnutls_strerror(ret));
365
365
    goto globalfail;
366
366
  }
380
380
  }
381
381
  
382
382
  gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
383
 
 
 
383
  
384
384
  return 0;
385
 
 
 
385
  
386
386
 globalfail:
387
 
 
 
387
  
388
388
  gnutls_certificate_free_credentials(mc->cred);
389
389
  gnutls_global_deinit();
390
390
  return -1;
391
 
 
392
391
}
393
392
 
394
393
static int init_gnutls_session(mandos_context *mc,
466
465
    perror("socket");
467
466
    return -1;
468
467
  }
469
 
 
 
468
  
470
469
  if(debug){
471
470
    if(if_indextoname((unsigned int)if_index, interface) == NULL){
472
471
      perror("if_indextoname");
511
510
    perror("connect");
512
511
    return -1;
513
512
  }
514
 
 
 
513
  
515
514
  const char *out = mandos_protocol_version;
516
515
  written = 0;
517
516
  while (true){
535
534
      }
536
535
    }
537
536
  }
538
 
 
 
537
  
539
538
  if(debug){
540
539
    fprintf(stderr, "Establishing TLS session with %s\n", ip);
541
540
  }
542
541
  
543
542
  gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) tcp_sd);
544
 
 
 
543
  
545
544
  do{
546
545
    ret = gnutls_handshake (session);
547
546
  } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
561
560
    fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
562
561
            ip);
563
562
  }
564
 
 
 
563
  
565
564
  while(true){
566
565
    buffer_capacity = adjustbuffer(&buffer, buffer_length,
567
566
                                   buffer_capacity);
774
773
    const char *pubkeyname = "pubkey.txt";
775
774
    const char *seckeyname = "seckey.txt";
776
775
    mandos_context mc = { .simple_poll = NULL, .server = NULL,
777
 
                          .dh_bits = 1024, .priority = "SECURE256"};
 
776
                          .dh_bits = 1024, .priority = "SECURE256"
 
777
                          ":!CTYPE-X.509:+CTYPE-OPENPGP" };
778
778
    bool gnutls_initalized = false;
779
779
    
780
780
    {
782
782
        { .name = "debug", .key = 128,
783
783
          .doc = "Debug mode", .group = 3 },
784
784
        { .name = "connect", .key = 'c',
785
 
          .arg = "IP",
786
 
          .doc = "Connect directly to a sepcified mandos server",
 
785
          .arg = "ADDRESS:PORT",
 
786
          .doc = "Connect directly to a specific Mandos server",
787
787
          .group = 1 },
788
788
        { .name = "interface", .key = 'i',
789
 
          .arg = "INTERFACE",
790
 
          .doc = "Interface that Avahi will conntect through",
 
789
          .arg = "NAME",
 
790
          .doc = "Interface that will be used to search for Mandos"
 
791
          " servers",
791
792
          .group = 1 },
792
793
        { .name = "keydir", .key = 'd',
793
 
          .arg = "KEYDIR",
794
 
          .doc = "Directory where the openpgp keyring is",
 
794
          .arg = "DIRECTORY",
 
795
          .doc = "Directory to read the OpenPGP key files from",
795
796
          .group = 1 },
796
797
        { .name = "seckey", .key = 's',
797
 
          .arg = "SECKEY",
798
 
          .doc = "Secret openpgp key for gnutls authentication",
 
798
          .arg = "FILE",
 
799
          .doc = "OpenPGP secret key file base name",
799
800
          .group = 1 },
800
801
        { .name = "pubkey", .key = 'p',
801
 
          .arg = "PUBKEY",
802
 
          .doc = "Public openpgp key for gnutls authentication",
 
802
          .arg = "FILE",
 
803
          .doc = "OpenPGP public key file base name",
803
804
          .group = 2 },
804
805
        { .name = "dh-bits", .key = 129,
805
806
          .arg = "BITS",
806
 
          .doc = "dh-bits to use in gnutls communication",
 
807
          .doc = "Bit length of the prime number used in the"
 
808
          " Diffie-Hellman key exchange",
807
809
          .group = 2 },
808
810
        { .name = "priority", .key = 130,
809
 
          .arg = "PRIORITY",
810
 
          .doc = "GNUTLS priority", .group = 1 },
 
811
          .arg = "STRING",
 
812
          .doc = "GnuTLS priority string for the TLS handshake",
 
813
          .group = 1 },
811
814
        { .name = NULL }
812
815
      };
813
 
 
814
816
      
815
817
      error_t parse_opt (int key, char *arg,
816
818
                         struct argp_state *state) {
817
819
        /* Get the INPUT argument from `argp_parse', which we know is
818
820
           a pointer to our plugin list pointer. */
819
821
        switch (key) {
820
 
        case 128:
 
822
        case 128:               /* --debug */
821
823
          debug = true;
822
824
          break;
823
 
        case 'c':
 
825
        case 'c':               /* --connect */
824
826
          connect_to = arg;
825
827
          break;
826
 
        case 'i':
 
828
        case 'i':               /* --interface */
827
829
          interface = arg;
828
830
          break;
829
 
        case 'd':
 
831
        case 'd':               /* --keydir */
830
832
          keydir = arg;
831
833
          break;
832
 
        case 's':
 
834
        case 's':               /* --seckey */
833
835
          seckeyname = arg;
834
836
          break;
835
 
        case 'p':
 
837
        case 'p':               /* --pubkey */
836
838
          pubkeyname = arg;
837
839
          break;
838
 
        case 129:
 
840
        case 129:               /* --dh-bits */
839
841
          errno = 0;
840
842
          mc.dh_bits = (unsigned int) strtol(arg, NULL, 10);
841
843
          if (errno){
843
845
            exit(EXIT_FAILURE);
844
846
          }
845
847
          break;
846
 
        case 130:
 
848
        case 130:               /* --priority */
847
849
          mc.priority = arg;
848
850
          break;
849
851
        case ARGP_KEY_ARG:
855
857
        }
856
858
        return 0;
857
859
      }
858
 
 
 
860
      
859
861
      struct argp argp = { .options = options, .parser = parse_opt,
860
862
                           .args_doc = "",
861
863
                           .doc = "Mandos client -- Get and decrypt"
862
 
                           " passwords from mandos server" };
 
864
                           " passwords from a Mandos server" };
863
865
      ret = argp_parse (&argp, argc, argv, 0, 0, NULL);
864
866
      if (ret == ARGP_ERR_UNKNOWN){
865
867
        fprintf(stderr, "Unknown error while parsing arguments\n");
867
869
        goto end;
868
870
      }
869
871
    }
870
 
      
 
872
    
871
873
    pubkeyfilename = combinepath(keydir, pubkeyname);
872
874
    if (pubkeyfilename == NULL){
873
875
      perror("combinepath");
881
883
      exitcode = EXIT_FAILURE;
882
884
      goto end;
883
885
    }
884
 
 
 
886
    
885
887
    ret = init_gnutls_global(&mc, pubkeyfilename, seckeyfilename);
886
888
    if (ret == -1){
887
889
      fprintf(stderr, "init_gnutls_global failed\n");
979
981
        exitcode = EXIT_FAILURE;
980
982
        goto end;
981
983
    }
982
 
 
 
984
    
983
985
    {
984
986
      AvahiServerConfig config;
985
987
      /* Do not publish any local Zeroconf records */
988
990
      config.publish_addresses = 0;
989
991
      config.publish_workstation = 0;
990
992
      config.publish_domain = 0;
991
 
 
 
993
      
992
994
      /* Allocate a new server */
993
995
      mc.server = avahi_server_new(avahi_simple_poll_get
994
996
                                   (mc.simple_poll), &config, NULL,
995
997
                                   NULL, &error);
996
 
    
 
998
      
997
999
      /* Free the Avahi configuration data */
998
1000
      avahi_server_config_free(&config);
999
1001
    }
1019
1021
    }
1020
1022
    
1021
1023
    /* Run the main loop */
1022
 
 
 
1024
    
1023
1025
    if (debug){
1024
1026
      fprintf(stderr, "Starting Avahi loop search\n");
1025
1027
    }
1027
1029
    avahi_simple_poll_loop(mc.simple_poll);
1028
1030
    
1029
1031
 end:
1030
 
 
 
1032
    
1031
1033
    if (debug){
1032
1034
      fprintf(stderr, "%s exiting\n", argv[0]);
1033
1035
    }
1038
1040
    
1039
1041
    if (mc.server != NULL)
1040
1042
        avahi_server_free(mc.server);
1041
 
 
 
1043
    
1042
1044
    if (mc.simple_poll != NULL)
1043
1045
        avahi_simple_poll_free(mc.simple_poll);
1044
1046
    free(pubkeyfilename);
1045
1047
    free(seckeyfilename);
1046
 
 
 
1048
    
1047
1049
    if (gnutls_initalized){
1048
1050
      gnutls_certificate_free_credentials(mc.cred);
1049
1051
      gnutls_global_deinit ();