/mandos/release

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

« back to all changes in this revision

Viewing changes to plugins.d/mandos-client.c

* initramfs-tools-hook: Bug fix: Really install user-supplied plugins.
                        Bug fix: Warn about empty plugin directory.

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,
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;
552
534
  size_t written;
553
 
  int retval = -1;
 
535
  int retval = 0;
554
536
  gnutls_session_t session;
555
537
  int pf;                       /* Protocol family */
556
538
  
583
565
  tcp_sd = socket(pf, SOCK_STREAM, 0);
584
566
  if(tcp_sd < 0){
585
567
    perror("socket");
 
568
    retval = -1;
586
569
    goto mandos_end;
587
570
  }
588
571
  
600
583
  }
601
584
  if(ret < 0 ){
602
585
    perror("inet_pton");
 
586
    retval = -1;
603
587
    goto mandos_end;
604
588
  }
605
589
  if(ret == 0){
606
590
    fprintf(stderr, "Bad address: %s\n", ip);
 
591
    retval = -1;
607
592
    goto mandos_end;
608
593
  }
609
594
  if(af == AF_INET6){
617
602
      if(if_index == AVAHI_IF_UNSPEC){
618
603
        fprintf(stderr, "An IPv6 link-local address is incomplete"
619
604
                " without a network interface\n");
 
605
        retval = -1;
620
606
        goto mandos_end;
621
607
      }
622
608
      /* Set the network interface number as scope */
675
661
  }
676
662
  if(ret < 0){
677
663
    perror("connect");
 
664
    retval = -1;
678
665
    goto mandos_end;
679
666
  }
680
667
  
690
677
                                   out_size - written));
691
678
    if(ret == -1){
692
679
      perror("write");
 
680
      retval = -1;
693
681
      goto mandos_end;
694
682
    }
695
683
    written += (size_t)ret;
735
723
      fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
736
724
      gnutls_perror(ret);
737
725
    }
 
726
    retval = -1;
738
727
    goto mandos_end;
739
728
  }
740
729
  
755
744
                                   buffer_capacity);
756
745
    if(buffer_capacity == 0){
757
746
      perror("incbuffer");
 
747
      retval = -1;
758
748
      goto mandos_end;
759
749
    }
760
750
    
783
773
        if(ret < 0){
784
774
          fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
785
775
          gnutls_perror(ret);
 
776
          retval = -1;
786
777
          goto mandos_end;
787
778
        }
788
779
        break;
789
780
      default:
790
781
        fprintf(stderr, "Unknown error while reading data from"
791
782
                " encrypted session with Mandos server\n");
 
783
        retval = -1;
792
784
        gnutls_bye(session, GNUTLS_SHUT_RDWR);
793
785
        goto mandos_end;
794
786
      }
805
797
    goto mandos_end;
806
798
  }
807
799
  
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);
 
800
  gnutls_bye(session, GNUTLS_SHUT_RDWR);
 
801
  
 
802
  if(quit_now){
 
803
    goto mandos_end;
 
804
  }
814
805
  
815
806
  if(buffer_length > 0){
816
807
    ssize_t decrypted_buffer_size;
833
824
            fprintf(stderr, "Error writing encrypted data: %s\n",
834
825
                    strerror(errno));
835
826
          }
836
 
          goto mandos_end;
 
827
          retval = -1;
 
828
          break;
837
829
        }
838
830
        written += (size_t)ret;
839
831
      }
840
 
      retval = 0;
 
832
      free(decrypted_buffer);
 
833
    } else {
 
834
      retval = -1;
841
835
    }
 
836
  } else {
 
837
    retval = -1;
842
838
  }
843
839
  
844
840
  /* Shutdown procedure */
845
841
  
846
842
 mandos_end:
847
 
  free(decrypted_buffer);
848
843
  free(buffer);
849
844
  if(tcp_sd >= 0){
850
845
    ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
976
971
  errno = old_errno;
977
972
}
978
973
 
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+1); /* +1 for final \0 */
1005
 
  flagstring[(size_t)to_read] = '\0';
1006
 
  if(flagstring == NULL){
1007
 
    perror("malloc");
1008
 
    close(flags_fd);
1009
 
    return 0;
1010
 
  }
1011
 
  while(to_read > 0){
1012
 
    ssret = (ssize_t)TEMP_FAILURE_RETRY(read(flags_fd, flagstring,
1013
 
                                             (size_t)to_read));
1014
 
    if(ssret == -1){
1015
 
      perror("read");
1016
 
      free(flagstring);
1017
 
      close(flags_fd);
1018
 
      return 0;
1019
 
    }
1020
 
    to_read -= ssret;
1021
 
    if(ssret == 0){
1022
 
      break;
1023
 
    }
1024
 
  }
1025
 
  close(flags_fd);
1026
 
  intmax_t tmpmax;
1027
 
  char *tmp;
1028
 
  errno = 0;
1029
 
  tmpmax = strtoimax(flagstring, &tmp, 0);
1030
 
  if(errno != 0 or tmp == flagstring or (*tmp != '\0'
1031
 
                                         and not (isspace(*tmp)))
1032
 
     or tmpmax != (ifreq_flags)tmpmax){
1033
 
    if(debug){
1034
 
      fprintf(stderr, "Invalid flags \"%s\" for interface \"%s\"\n",
1035
 
              flagstring, if_entry->d_name);
1036
 
    }
1037
 
    free(flagstring);
1038
 
    return 0;
1039
 
  }
1040
 
  free(flagstring);
1041
 
  ifreq_flags flags = (ifreq_flags)tmpmax;
1042
 
  /* Reject the loopback device */
1043
 
  if(flags & IFF_LOOPBACK){
1044
 
    if(debug){
1045
 
      fprintf(stderr, "Rejecting loopback interface \"%s\"\n",
1046
 
              if_entry->d_name);
1047
 
    }
1048
 
    return 0;
1049
 
  }
1050
 
  /* Accept point-to-point devices only if connect_to is specified */
1051
 
  if(connect_to != NULL and (flags & IFF_POINTOPOINT)){
1052
 
    if(debug){
1053
 
      fprintf(stderr, "Accepting point-to-point interface \"%s\"\n",
1054
 
              if_entry->d_name);
1055
 
    }
1056
 
    return 1;
1057
 
  }
1058
 
  /* Otherwise, reject non-broadcast-capable devices */
1059
 
  if(not (flags & IFF_BROADCAST)){
1060
 
    if(debug){
1061
 
      fprintf(stderr, "Rejecting non-broadcast interface \"%s\"\n",
1062
 
              if_entry->d_name);
1063
 
    }
1064
 
    return 0;
1065
 
  }
1066
 
  /* Accept this device */
1067
 
  if(debug){
1068
 
    fprintf(stderr, "Interface \"%s\" is acceptable\n",
1069
 
            if_entry->d_name);
1070
 
  }
1071
 
  return 1;
1072
 
}
1073
 
 
1074
974
int main(int argc, char *argv[]){
1075
975
  AvahiSServiceBrowser *sb = NULL;
1076
976
  int error;
1078
978
  intmax_t tmpmax;
1079
979
  char *tmp;
1080
980
  int exitcode = EXIT_SUCCESS;
1081
 
  const char *interface = "";
 
981
  const char *interface = "eth0";
1082
982
  struct ifreq network;
1083
983
  int sd = -1;
1084
984
  bool take_down_interface = false;
1085
985
  uid_t uid;
1086
986
  gid_t gid;
 
987
  char *connect_to = NULL;
1087
988
  char tempdir[] = "/tmp/mandosXXXXXX";
1088
989
  bool tempdir_created = false;
1089
990
  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1094
995
  bool gpgme_initialized = false;
1095
996
  float delay = 2.5f;
1096
997
  
1097
 
  struct sigaction old_sigterm_action = { .sa_handler = SIG_DFL };
 
998
  struct sigaction old_sigterm_action;
1098
999
  struct sigaction sigterm_action = { .sa_handler = handle_sigterm };
1099
1000
  
1100
 
  uid = getuid();
1101
 
  gid = getgid();
1102
 
  
1103
 
  /* Lower any group privileges we might have, just to be safe */
1104
 
  errno = 0;
1105
 
  ret = setgid(gid);
1106
 
  if(ret == -1){
1107
 
    perror("setgid");
1108
 
  }
1109
 
  
1110
 
  /* Lower user privileges (temporarily) */
1111
 
  errno = 0;
1112
 
  ret = seteuid(uid);
1113
 
  if(ret == -1){
1114
 
    perror("seteuid");
1115
 
  }
1116
 
  
1117
 
  if(quit_now){
1118
 
    goto end;
1119
 
  }
1120
 
  
1121
1001
  {
1122
1002
    struct argp_option options[] = {
1123
1003
      { .name = "debug", .key = 128,
1219
1099
  if(not debug){
1220
1100
    avahi_set_log_function(empty_log);
1221
1101
  }
1222
 
 
1223
 
  if(interface[0] == '\0'){
1224
 
    struct dirent **direntries;
1225
 
    ret = scandir(sys_class_net, &direntries, good_interface,
1226
 
                  alphasort);
1227
 
    if(ret >= 1){
1228
 
      /* Pick the first good interface */
1229
 
      interface = strdup(direntries[0]->d_name);
1230
 
      if(debug){
1231
 
        fprintf(stderr, "Using interface \"%s\"\n", interface);
1232
 
      }
1233
 
      if(interface == NULL){
1234
 
        perror("malloc");
1235
 
        free(direntries);
1236
 
        exitcode = EXIT_FAILURE;
1237
 
        goto end;
1238
 
      }
1239
 
      free(direntries);
1240
 
    } else {
1241
 
      free(direntries);
1242
 
      fprintf(stderr, "Could not find a network interface\n");
1243
 
      exitcode = EXIT_FAILURE;
1244
 
      goto end;
1245
 
    }
1246
 
  }
1247
1102
  
1248
1103
  /* Initialize Avahi early so avahi_simple_poll_quit() can be called
1249
1104
     from the signal handler */
1320
1175
  }
1321
1176
  
1322
1177
  /* If the interface is down, bring it up */
1323
 
  if(strcmp(interface, "none") != 0){
 
1178
  if(interface[0] != '\0'){
1324
1179
    if_index = (AvahiIfIndex) if_nametoindex(interface);
1325
1180
    if(if_index == 0){
1326
1181
      fprintf(stderr, "No such interface: \"%s\"\n", interface);
1332
1187
      goto end;
1333
1188
    }
1334
1189
    
1335
 
    /* Re-raise priviliges */
1336
 
    errno = 0;
1337
 
    ret = seteuid(0);
1338
 
    if(ret == -1){
1339
 
      perror("seteuid");
1340
 
    }
1341
 
    
1342
1190
#ifdef __linux__
1343
1191
    /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1344
1192
       messages to mess up the prompt */
1362
1210
        }
1363
1211
      }
1364
1212
#endif  /* __linux__ */
1365
 
      /* Lower privileges */
1366
 
      errno = 0;
1367
 
      ret = seteuid(uid);
1368
 
      if(ret == -1){
1369
 
        perror("seteuid");
1370
 
      }
1371
1213
      goto end;
1372
1214
    }
1373
1215
    strcpy(network.ifr_name, interface);
1383
1225
      }
1384
1226
#endif  /* __linux__ */
1385
1227
      exitcode = EXIT_FAILURE;
1386
 
      /* Lower privileges */
1387
 
      errno = 0;
1388
 
      ret = seteuid(uid);
1389
 
      if(ret == -1){
1390
 
        perror("seteuid");
1391
 
      }
1392
1228
      goto end;
1393
1229
    }
1394
1230
    if((network.ifr_flags & IFF_UP) == 0){
1397
1233
      ret = ioctl(sd, SIOCSIFFLAGS, &network);
1398
1234
      if(ret == -1){
1399
1235
        take_down_interface = false;
1400
 
        perror("ioctl SIOCSIFFLAGS +IFF_UP");
 
1236
        perror("ioctl SIOCSIFFLAGS");
1401
1237
        exitcode = EXIT_FAILURE;
1402
1238
#ifdef __linux__
1403
1239
        if(restore_loglevel){
1407
1243
          }
1408
1244
        }
1409
1245
#endif  /* __linux__ */
1410
 
        /* Lower privileges */
1411
 
        errno = 0;
1412
 
        ret = seteuid(uid);
1413
 
        if(ret == -1){
1414
 
          perror("seteuid");
1415
 
        }
1416
1246
        goto end;
1417
1247
      }
1418
1248
    }
1446
1276
      }
1447
1277
    }
1448
1278
#endif  /* __linux__ */
1449
 
    /* Lower privileges */
1450
 
    errno = 0;
1451
 
    if(take_down_interface){
1452
 
      /* Lower privileges */
1453
 
      ret = seteuid(uid);
1454
 
      if(ret == -1){
1455
 
        perror("seteuid");
1456
 
      }
1457
 
    } else {
1458
 
      /* Lower privileges permanently */
1459
 
      ret = setuid(uid);
1460
 
      if(ret == -1){
1461
 
        perror("setuid");
1462
 
      }
1463
 
    }
 
1279
  }
 
1280
  
 
1281
  if(quit_now){
 
1282
    goto end;
 
1283
  }
 
1284
  
 
1285
  uid = getuid();
 
1286
  gid = getgid();
 
1287
  
 
1288
  errno = 0;
 
1289
  setgid(gid);
 
1290
  if(ret == -1){
 
1291
    perror("setgid");
 
1292
  }
 
1293
  
 
1294
  ret = setuid(uid);
 
1295
  if(ret == -1){
 
1296
    perror("setuid");
1464
1297
  }
1465
1298
  
1466
1299
  if(quit_now){
1640
1473
  
1641
1474
  /* Take down the network interface */
1642
1475
  if(take_down_interface){
1643
 
    /* Re-raise priviliges */
1644
 
    errno = 0;
1645
 
    ret = seteuid(0);
 
1476
    ret = ioctl(sd, SIOCGIFFLAGS, &network);
1646
1477
    if(ret == -1){
1647
 
      perror("seteuid");
 
1478
      perror("ioctl SIOCGIFFLAGS");
 
1479
    } else if(network.ifr_flags & IFF_UP) {
 
1480
      network.ifr_flags &= ~IFF_UP; /* clear flag */
 
1481
      ret = ioctl(sd, SIOCSIFFLAGS, &network);
 
1482
      if(ret == -1){
 
1483
        perror("ioctl SIOCSIFFLAGS");
 
1484
      }
1648
1485
    }
1649
 
    if(geteuid() == 0){
1650
 
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
1651
 
      if(ret == -1){
1652
 
        perror("ioctl SIOCGIFFLAGS");
1653
 
      } else if(network.ifr_flags & IFF_UP) {
1654
 
        network.ifr_flags &= ~IFF_UP; /* clear flag */
1655
 
        ret = ioctl(sd, SIOCSIFFLAGS, &network);
1656
 
        if(ret == -1){
1657
 
          perror("ioctl SIOCSIFFLAGS -IFF_UP");
1658
 
        }
1659
 
      }
1660
 
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
1661
 
      if(ret == -1){
1662
 
        perror("close");
1663
 
      }
1664
 
      /* Lower privileges permanently */
1665
 
      errno = 0;
1666
 
      ret = setuid(uid);
1667
 
      if(ret == -1){
1668
 
        perror("setuid");
1669
 
      }
 
1486
    ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
1487
    if(ret == -1){
 
1488
      perror("close");
1670
1489
    }
1671
1490
  }
1672
1491
  
1717
1536
  if(quit_now){
1718
1537
    sigemptyset(&old_sigterm_action.sa_mask);
1719
1538
    old_sigterm_action.sa_handler = SIG_DFL;
1720
 
    ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
1721
 
                                            &old_sigterm_action,
1722
 
                                            NULL));
 
1539
    ret = sigaction(signal_received, &old_sigterm_action, NULL);
1723
1540
    if(ret == -1){
1724
1541
      perror("sigaction");
1725
1542
    }
1726
 
    do {
1727
 
      ret = raise(signal_received);
1728
 
    } while(ret != 0 and errno == EINTR);
1729
 
    if(ret != 0){
1730
 
      perror("raise");
1731
 
      abort();
1732
 
    }
1733
 
    TEMP_FAILURE_RETRY(pause());
 
1543
    raise(signal_received);
1734
1544
  }
1735
1545
  
1736
1546
  return exitcode;