/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/mandos-client.c

  • Committer: Teddy Hogeborn
  • Date: 2009-09-05 01:46:42 UTC
  • Revision ID: teddy@fukt.bsnet.se-20090905014642-36108sqop1ci0z0m
* plugins.d/mandos-client.c (start_mandos_communication): Check
                                                         "quit_now"
                                                         throughout.
                                                         Always close
                                                         socket and
                                                         deinit GnuTLS
                                                         properly.
  (browse_callback): Return immediately if "quit_now" is set.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/mandos-client.c
44
44
#include <stdint.h>             /* uint16_t, uint32_t */
45
45
#include <stddef.h>             /* NULL, size_t, ssize_t */
46
46
#include <stdlib.h>             /* free(), EXIT_SUCCESS, EXIT_FAILURE,
47
 
                                   srand(), strtof(), abort() */
 
47
                                   srand(), strtof() */
48
48
#include <stdbool.h>            /* bool, false, true */
49
49
#include <string.h>             /* memset(), strcmp(), strlen(),
50
50
                                   strerror(), asprintf(), strcpy() */
71
71
                                   INET_ADDRSTRLEN, INET6_ADDRSTRLEN
72
72
                                */
73
73
#include <unistd.h>             /* close(), SEEK_SET, off_t, write(),
74
 
                                   getuid(), getgid(), seteuid(),
75
 
                                   setgid(), pause() */
 
74
                                   getuid(), getgid(), setuid(),
 
75
                                   setgid() */
76
76
#include <arpa/inet.h>          /* inet_pton(), htons */
77
77
#include <iso646.h>             /* not, or, and */
78
78
#include <argp.h>               /* struct argp_option, error_t, struct
125
125
static const char mandos_protocol_version[] = "1";
126
126
const char *argp_program_version = "mandos-client " VERSION;
127
127
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
128
 
static const char sys_class_net[] = "/sys/class/net";
129
 
char *connect_to = NULL;
130
128
 
131
129
/* Used for passing in values through the Avahi callback functions */
132
130
typedef struct {
144
142
                      .dh_bits = 1024, .priority = "SECURE256"
145
143
                      ":!CTYPE-X.509:+CTYPE-OPENPGP" };
146
144
 
147
 
sig_atomic_t quit_now = 0;
148
 
int signal_received = 0;
149
 
 
150
145
/*
151
146
 * Make additional room in "buffer" for at least BUFFER_SIZE more
152
147
 * bytes. "buffer_capacity" is how much is currently allocated,
169
164
 */
170
165
static bool init_gpgme(const char *seckey,
171
166
                       const char *pubkey, const char *tempdir){
 
167
  int ret;
172
168
  gpgme_error_t rc;
173
169
  gpgme_engine_info_t engine_info;
174
170
  
177
173
   * Helper function to insert pub and seckey to the engine keyring.
178
174
   */
179
175
  bool import_key(const char *filename){
180
 
    int ret;
181
176
    int fd;
182
177
    gpgme_data_t pgp_data;
183
178
    
479
474
static int init_gnutls_session(gnutls_session_t *session){
480
475
  int ret;
481
476
  /* GnuTLS session creation */
482
 
  do {
483
 
    ret = gnutls_init(session, GNUTLS_SERVER);
484
 
    if(quit_now){
485
 
      return -1;
486
 
    }
487
 
  } while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
 
477
  ret = gnutls_init(session, GNUTLS_SERVER);
488
478
  if(ret != GNUTLS_E_SUCCESS){
489
479
    fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
490
480
            safer_gnutls_strerror(ret));
492
482
  
493
483
  {
494
484
    const char *err;
495
 
    do {
496
 
      ret = gnutls_priority_set_direct(*session, mc.priority, &err);
497
 
      if(quit_now){
498
 
        gnutls_deinit(*session);
499
 
        return -1;
500
 
      }
501
 
    } while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
 
485
    ret = gnutls_priority_set_direct(*session, mc.priority, &err);
502
486
    if(ret != GNUTLS_E_SUCCESS){
503
487
      fprintf(stderr, "Syntax error at: %s\n", err);
504
488
      fprintf(stderr, "GnuTLS error: %s\n",
508
492
    }
509
493
  }
510
494
  
511
 
  do {
512
 
    ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
513
 
                                 mc.cred);
514
 
    if(quit_now){
515
 
      gnutls_deinit(*session);
516
 
      return -1;
517
 
    }
518
 
  } while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
 
495
  ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
 
496
                               mc.cred);
519
497
  if(ret != GNUTLS_E_SUCCESS){
520
498
    fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
521
499
            safer_gnutls_strerror(ret));
524
502
  }
525
503
  
526
504
  /* ignore client certificate if any. */
527
 
  gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
 
505
  gnutls_certificate_server_set_request(*session,
 
506
                                        GNUTLS_CERT_IGNORE);
528
507
  
529
508
  gnutls_dh_set_prime_bits(*session, mc.dh_bits);
530
509
  
535
514
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
536
515
                      __attribute__((unused)) const char *txt){}
537
516
 
 
517
sig_atomic_t quit_now = 0;
 
518
int signal_received = 0;
 
519
 
538
520
/* Called when a Mandos server is found */
539
521
static int start_mandos_communication(const char *ip, uint16_t port,
540
522
                                      AvahiIfIndex if_index,
546
528
    struct sockaddr_in6 in6;
547
529
  } to;
548
530
  char *buffer = NULL;
549
 
  char *decrypted_buffer = NULL;
 
531
  char *decrypted_buffer;
550
532
  size_t buffer_length = 0;
551
533
  size_t buffer_capacity = 0;
 
534
  ssize_t decrypted_buffer_size;
552
535
  size_t written;
553
 
  int retval = -1;
 
536
  int retval = 0;
554
537
  gnutls_session_t session;
555
538
  int pf;                       /* Protocol family */
556
539
  
583
566
  tcp_sd = socket(pf, SOCK_STREAM, 0);
584
567
  if(tcp_sd < 0){
585
568
    perror("socket");
 
569
    retval = -1;
586
570
    goto mandos_end;
587
571
  }
588
572
  
600
584
  }
601
585
  if(ret < 0 ){
602
586
    perror("inet_pton");
 
587
    retval = -1;
603
588
    goto mandos_end;
604
589
  }
605
590
  if(ret == 0){
606
591
    fprintf(stderr, "Bad address: %s\n", ip);
 
592
    retval = -1;
607
593
    goto mandos_end;
608
594
  }
609
595
  if(af == AF_INET6){
617
603
      if(if_index == AVAHI_IF_UNSPEC){
618
604
        fprintf(stderr, "An IPv6 link-local address is incomplete"
619
605
                " without a network interface\n");
 
606
        retval = -1;
620
607
        goto mandos_end;
621
608
      }
622
609
      /* Set the network interface number as scope */
675
662
  }
676
663
  if(ret < 0){
677
664
    perror("connect");
 
665
    retval = -1;
678
666
    goto mandos_end;
679
667
  }
680
668
  
690
678
                                   out_size - written));
691
679
    if(ret == -1){
692
680
      perror("write");
 
681
      retval = -1;
693
682
      goto mandos_end;
694
683
    }
695
684
    written += (size_t)ret;
723
712
    goto mandos_end;
724
713
  }
725
714
  
726
 
  do {
 
715
  do{
727
716
    ret = gnutls_handshake(session);
728
717
    if(quit_now){
729
718
      goto mandos_end;
735
724
      fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
736
725
      gnutls_perror(ret);
737
726
    }
 
727
    retval = -1;
738
728
    goto mandos_end;
739
729
  }
740
730
  
755
745
                                   buffer_capacity);
756
746
    if(buffer_capacity == 0){
757
747
      perror("incbuffer");
 
748
      retval = -1;
758
749
      goto mandos_end;
759
750
    }
760
751
    
773
764
      case GNUTLS_E_AGAIN:
774
765
        break;
775
766
      case GNUTLS_E_REHANDSHAKE:
776
 
        do {
 
767
        do{
777
768
          ret = gnutls_handshake(session);
778
769
          
779
770
          if(quit_now){
783
774
        if(ret < 0){
784
775
          fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
785
776
          gnutls_perror(ret);
 
777
          retval = -1;
786
778
          goto mandos_end;
787
779
        }
788
780
        break;
789
781
      default:
790
782
        fprintf(stderr, "Unknown error while reading data from"
791
783
                " encrypted session with Mandos server\n");
 
784
        retval = -1;
792
785
        gnutls_bye(session, GNUTLS_SHUT_RDWR);
793
786
        goto mandos_end;
794
787
      }
805
798
    goto mandos_end;
806
799
  }
807
800
  
808
 
  do {
809
 
    ret = gnutls_bye(session, GNUTLS_SHUT_RDWR);
810
 
    if(quit_now){
811
 
      goto mandos_end;
812
 
    }
813
 
  } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
 
801
  gnutls_bye(session, GNUTLS_SHUT_RDWR);
 
802
  
 
803
  if(quit_now){
 
804
    goto mandos_end;
 
805
  }
814
806
  
815
807
  if(buffer_length > 0){
816
 
    ssize_t decrypted_buffer_size;
817
808
    decrypted_buffer_size = pgp_packet_decrypt(buffer,
818
809
                                               buffer_length,
819
810
                                               &decrypted_buffer);
820
811
    if(decrypted_buffer_size >= 0){
821
 
      
822
812
      written = 0;
823
813
      while(written < (size_t) decrypted_buffer_size){
824
814
        if(quit_now){
833
823
            fprintf(stderr, "Error writing encrypted data: %s\n",
834
824
                    strerror(errno));
835
825
          }
836
 
          goto mandos_end;
 
826
          retval = -1;
 
827
          break;
837
828
        }
838
829
        written += (size_t)ret;
839
830
      }
840
 
      retval = 0;
 
831
      free(decrypted_buffer);
 
832
    } else {
 
833
      retval = -1;
841
834
    }
 
835
  } else {
 
836
    retval = -1;
842
837
  }
843
838
  
844
839
  /* Shutdown procedure */
845
840
  
846
841
 mandos_end:
847
 
  free(decrypted_buffer);
848
842
  free(buffer);
849
843
  if(tcp_sd >= 0){
850
844
    ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
976
970
  errno = old_errno;
977
971
}
978
972
 
979
 
/* 
980
 
 * This function determines if a directory entry in /sys/class/net
981
 
 * corresponds to an acceptable network device.
982
 
 * (This function is passed to scandir(3) as a filter function.)
983
 
 */
984
 
int good_interface(const struct dirent *if_entry){
985
 
  ssize_t ssret;
986
 
  char *flagname = NULL;
987
 
  int ret = asprintf(&flagname, "%s/%s/flags", sys_class_net,
988
 
                     if_entry->d_name);
989
 
  if(ret < 0){
990
 
    perror("asprintf");
991
 
    return 0;
992
 
  }
993
 
  if(if_entry->d_name[0] == '.'){
994
 
    return 0;
995
 
  }
996
 
  int flags_fd = (int)TEMP_FAILURE_RETRY(open(flagname, O_RDONLY));
997
 
  if(flags_fd == -1){
998
 
    perror("open");
999
 
    return 0;
1000
 
  }
1001
 
  typedef short ifreq_flags;    /* ifreq.ifr_flags in netdevice(7) */
1002
 
  /* read line from flags_fd */
1003
 
  ssize_t to_read = (sizeof(ifreq_flags)*2)+3; /* "0x1003\n" */
1004
 
  char *flagstring = malloc((size_t)to_read);
1005
 
  if(flagstring == NULL){
1006
 
    perror("malloc");
1007
 
    close(flags_fd);
1008
 
    return 0;
1009
 
  }
1010
 
  while(to_read > 0){
1011
 
    ssret = (ssize_t)TEMP_FAILURE_RETRY(read(flags_fd, flagstring,
1012
 
                                             (size_t)to_read));
1013
 
    if(ssret == -1){
1014
 
      perror("read");
1015
 
      free(flagstring);
1016
 
      close(flags_fd);
1017
 
      return 0;
1018
 
    }
1019
 
    to_read -= ssret;
1020
 
    if(ssret == 0){
1021
 
      break;
1022
 
    }
1023
 
  }
1024
 
  close(flags_fd);
1025
 
  intmax_t tmpmax;
1026
 
  char *tmp;
1027
 
  errno = 0;
1028
 
  tmpmax = strtoimax(flagstring, &tmp, 0);
1029
 
  if(errno != 0 or tmp == flagstring or (*tmp != '\0'
1030
 
                                         and not (isspace(*tmp)))
1031
 
     or tmpmax != (ifreq_flags)tmpmax){
1032
 
    free(flagstring);
1033
 
    return 0;
1034
 
  }
1035
 
  free(flagstring);
1036
 
  ifreq_flags flags = (ifreq_flags)tmpmax;
1037
 
  /* Reject the loopback device */
1038
 
  if(flags & IFF_LOOPBACK){
1039
 
    return 0;
1040
 
  }
1041
 
  /* Accept point-to-point devices only if connect_to is specified */
1042
 
  if(connect_to != NULL and (flags & IFF_POINTOPOINT)){
1043
 
    return 1;
1044
 
  }
1045
 
  /* Otherwise, reject non-broadcast-capable devices */
1046
 
  if(not (flags & IFF_BROADCAST)){
1047
 
    return 0;
1048
 
  }
1049
 
  /* Accept this device */
1050
 
  return 1;
1051
 
}
1052
 
 
1053
973
int main(int argc, char *argv[]){
1054
974
  AvahiSServiceBrowser *sb = NULL;
1055
975
  int error;
1057
977
  intmax_t tmpmax;
1058
978
  char *tmp;
1059
979
  int exitcode = EXIT_SUCCESS;
1060
 
  const char *interface = "";
 
980
  const char *interface = "eth0";
1061
981
  struct ifreq network;
1062
982
  int sd = -1;
1063
983
  bool take_down_interface = false;
1064
984
  uid_t uid;
1065
985
  gid_t gid;
 
986
  char *connect_to = NULL;
1066
987
  char tempdir[] = "/tmp/mandosXXXXXX";
1067
988
  bool tempdir_created = false;
1068
989
  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1073
994
  bool gpgme_initialized = false;
1074
995
  float delay = 2.5f;
1075
996
  
1076
 
  struct sigaction old_sigterm_action = { .sa_handler = SIG_DFL };
 
997
  struct sigaction old_sigterm_action;
1077
998
  struct sigaction sigterm_action = { .sa_handler = handle_sigterm };
1078
999
  
1079
 
  uid = getuid();
1080
 
  gid = getgid();
1081
 
  
1082
 
  /* Lower any group privileges we might have, just to be safe */
1083
 
  errno = 0;
1084
 
  ret = setgid(gid);
1085
 
  if(ret == -1){
1086
 
    perror("setgid");
1087
 
  }
1088
 
  
1089
 
  /* Lower user privileges (temporarily) */
1090
 
  errno = 0;
1091
 
  ret = seteuid(uid);
1092
 
  if(ret == -1){
1093
 
    perror("seteuid");
1094
 
  }
1095
 
  
1096
 
  if(quit_now){
1097
 
    goto end;
1098
 
  }
1099
 
  
1100
1000
  {
1101
1001
    struct argp_option options[] = {
1102
1002
      { .name = "debug", .key = 128,
1198
1098
  if(not debug){
1199
1099
    avahi_set_log_function(empty_log);
1200
1100
  }
1201
 
 
1202
 
  if(interface[0] == '\0'){
1203
 
    struct dirent **direntries;
1204
 
    ret = scandir(sys_class_net, &direntries, good_interface,
1205
 
                  alphasort);
1206
 
    if(ret >= 1){
1207
 
      /* Pick the first good interface */
1208
 
      interface = strdup(direntries[0]->d_name);
1209
 
      if(interface == NULL){
1210
 
        perror("malloc");
1211
 
        free(direntries);
1212
 
        exitcode = EXIT_FAILURE;
1213
 
        goto end;
1214
 
      }
1215
 
      free(direntries);
1216
 
    } else {
1217
 
      free(direntries);
1218
 
      fprintf(stderr, "Could not find a network interface\n");
1219
 
      exitcode = EXIT_FAILURE;
1220
 
      goto end;
1221
 
    }
1222
 
  }
1223
1101
  
1224
1102
  /* Initialize Avahi early so avahi_simple_poll_quit() can be called
1225
1103
     from the signal handler */
1296
1174
  }
1297
1175
  
1298
1176
  /* If the interface is down, bring it up */
1299
 
  if(strcmp(interface, "none") != 0){
 
1177
  if(interface[0] != '\0'){
1300
1178
    if_index = (AvahiIfIndex) if_nametoindex(interface);
1301
1179
    if(if_index == 0){
1302
1180
      fprintf(stderr, "No such interface: \"%s\"\n", interface);
1308
1186
      goto end;
1309
1187
    }
1310
1188
    
1311
 
    /* Re-raise priviliges */
1312
 
    errno = 0;
1313
 
    ret = seteuid(0);
1314
 
    if(ret == -1){
1315
 
      perror("seteuid");
1316
 
    }
1317
 
    
1318
1189
#ifdef __linux__
1319
1190
    /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1320
1191
       messages to mess up the prompt */
1338
1209
        }
1339
1210
      }
1340
1211
#endif  /* __linux__ */
1341
 
      /* Lower privileges */
1342
 
      errno = 0;
1343
 
      ret = seteuid(uid);
1344
 
      if(ret == -1){
1345
 
        perror("seteuid");
1346
 
      }
1347
1212
      goto end;
1348
1213
    }
1349
1214
    strcpy(network.ifr_name, interface);
1359
1224
      }
1360
1225
#endif  /* __linux__ */
1361
1226
      exitcode = EXIT_FAILURE;
1362
 
      /* Lower privileges */
1363
 
      errno = 0;
1364
 
      ret = seteuid(uid);
1365
 
      if(ret == -1){
1366
 
        perror("seteuid");
1367
 
      }
1368
1227
      goto end;
1369
1228
    }
1370
1229
    if((network.ifr_flags & IFF_UP) == 0){
1383
1242
          }
1384
1243
        }
1385
1244
#endif  /* __linux__ */
1386
 
        /* Lower privileges */
1387
 
        errno = 0;
1388
 
        ret = seteuid(uid);
1389
 
        if(ret == -1){
1390
 
          perror("seteuid");
1391
 
        }
1392
1245
        goto end;
1393
1246
      }
1394
1247
    }
1422
1275
      }
1423
1276
    }
1424
1277
#endif  /* __linux__ */
1425
 
    /* Lower privileges */
1426
 
    errno = 0;
1427
 
    if(take_down_interface){
1428
 
      /* Lower privileges */
1429
 
      ret = seteuid(uid);
1430
 
      if(ret == -1){
1431
 
        perror("seteuid");
1432
 
      }
1433
 
    } else {
1434
 
      /* Lower privileges permanently */
1435
 
      ret = setuid(uid);
1436
 
      if(ret == -1){
1437
 
        perror("setuid");
1438
 
      }
1439
 
    }
 
1278
  }
 
1279
  
 
1280
  if(quit_now){
 
1281
    goto end;
 
1282
  }
 
1283
  
 
1284
  uid = getuid();
 
1285
  gid = getgid();
 
1286
  
 
1287
  errno = 0;
 
1288
  setgid(gid);
 
1289
  if(ret == -1){
 
1290
    perror("setgid");
 
1291
  }
 
1292
  
 
1293
  ret = setuid(uid);
 
1294
  if(ret == -1){
 
1295
    perror("setuid");
1440
1296
  }
1441
1297
  
1442
1298
  if(quit_now){
1616
1472
  
1617
1473
  /* Take down the network interface */
1618
1474
  if(take_down_interface){
1619
 
    /* Re-raise priviliges */
1620
 
    errno = 0;
1621
 
    ret = seteuid(0);
 
1475
    ret = ioctl(sd, SIOCGIFFLAGS, &network);
1622
1476
    if(ret == -1){
1623
 
      perror("seteuid");
 
1477
      perror("ioctl SIOCGIFFLAGS");
 
1478
    } else if(network.ifr_flags & IFF_UP) {
 
1479
      network.ifr_flags &= ~IFF_UP; /* clear flag */
 
1480
      ret = ioctl(sd, SIOCSIFFLAGS, &network);
 
1481
      if(ret == -1){
 
1482
        perror("ioctl SIOCSIFFLAGS");
 
1483
      }
1624
1484
    }
1625
 
    if(geteuid() == 0){
1626
 
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
1627
 
      if(ret == -1){
1628
 
        perror("ioctl SIOCGIFFLAGS");
1629
 
      } else if(network.ifr_flags & IFF_UP) {
1630
 
        network.ifr_flags &= ~IFF_UP; /* clear flag */
1631
 
        ret = ioctl(sd, SIOCSIFFLAGS, &network);
1632
 
        if(ret == -1){
1633
 
          perror("ioctl SIOCSIFFLAGS");
1634
 
        }
1635
 
      }
1636
 
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
1637
 
      if(ret == -1){
1638
 
        perror("close");
1639
 
      }
1640
 
      /* Lower privileges permanently */
1641
 
      errno = 0;
1642
 
      ret = setuid(uid);
1643
 
      if(ret == -1){
1644
 
        perror("setuid");
1645
 
      }
 
1485
    ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
1486
    if(ret == -1){
 
1487
      perror("close");
1646
1488
    }
1647
1489
  }
1648
1490
  
1693
1535
  if(quit_now){
1694
1536
    sigemptyset(&old_sigterm_action.sa_mask);
1695
1537
    old_sigterm_action.sa_handler = SIG_DFL;
1696
 
    ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
1697
 
                                            &old_sigterm_action,
1698
 
                                            NULL));
 
1538
    ret = sigaction(signal_received, &old_sigterm_action, NULL);
1699
1539
    if(ret == -1){
1700
1540
      perror("sigaction");
1701
1541
    }
1702
 
    do {
1703
 
      ret = raise(signal_received);
1704
 
    } while(ret != 0 and errno == EINTR);
1705
 
    if(ret != 0){
1706
 
      perror("raise");
1707
 
      abort();
1708
 
    }
1709
 
    TEMP_FAILURE_RETRY(pause());
 
1542
    raise(signal_received);
1710
1543
  }
1711
1544
  
1712
1545
  return exitcode;