/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 plugin-runner.c

  • Committer: Teddy Hogeborn
  • Date: 2015-03-10 18:03:38 UTC
  • mto: (237.7.304 trunk)
  • mto: This revision was merged to the branch mainline in revision 325.
  • Revision ID: teddy@recompile.se-20150310180338-pcxw6r2qmw9k6br9
Add ":!RSA" to GnuTLS priority string, to disallow non-DHE kx.

If Mandos was somehow made to use a non-ephemeral Diffie-Hellman key
exchange algorithm in the TLS handshake, any saved network traffic
could then be decrypted later if the Mandos client key was obtained.
By default, Mandos uses ephemeral DH key exchanges which does not have
this problem, but a non-ephemeral key exchange algorithm was still
enabled by default.  The simplest solution is to simply turn that off,
which ensures that Mandos will always use ephemeral DH key exchanges.

There is a "PFS" priority string specifier, but we can't use it because:

1. Security-wise, it is a mix between "NORMAL" and "SECURE128" - it
   enables a lot more algorithms than "SECURE256".

2. It is only available since GnuTLS 3.2.4.

Thanks to Andreas Fischer <af@bantuX.org> for reporting this issue.

Show diffs side-by-side

added added

removed removed

Lines of Context:
2
2
/*
3
3
 * Mandos plugin runner - Run Mandos plugins
4
4
 *
5
 
 * Copyright © 2008-2018 Teddy Hogeborn
6
 
 * Copyright © 2008-2018 Björn Påhlsson
7
 
 * 
8
 
 * This file is part of Mandos.
9
 
 * 
10
 
 * Mandos is free software: you can redistribute it and/or modify it
11
 
 * under the terms of the GNU General Public License as published by
12
 
 * the Free Software Foundation, either version 3 of the License, or
13
 
 * (at your option) any later version.
14
 
 * 
15
 
 * Mandos is distributed in the hope that it will be useful, but
 
5
 * Copyright © 2008-2014 Teddy Hogeborn
 
6
 * Copyright © 2008-2014 Björn Påhlsson
 
7
 * 
 
8
 * This program is free software: you can redistribute it and/or
 
9
 * modify it under the terms of the GNU General Public License as
 
10
 * published by the Free Software Foundation, either version 3 of the
 
11
 * License, or (at your option) any later version.
 
12
 * 
 
13
 * This program is distributed in the hope that it will be useful, but
16
14
 * WITHOUT ANY WARRANTY; without even the implied warranty of
17
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18
16
 * General Public License for more details.
19
17
 * 
20
18
 * You should have received a copy of the GNU General Public License
21
 
 * along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
 
19
 * along with this program.  If not, see
 
20
 * <http://www.gnu.org/licenses/>.
22
21
 * 
23
22
 * Contact the authors at <mandos@recompile.se>.
24
23
 */
38
37
#include <sys/select.h>         /* fd_set, select(), FD_ZERO(),
39
38
                                   FD_SET(), FD_ISSET(), FD_CLR */
40
39
#include <sys/wait.h>           /* wait(), waitpid(), WIFEXITED(),
41
 
                                   WEXITSTATUS(), WTERMSIG() */
 
40
                                   WEXITSTATUS(), WTERMSIG(),
 
41
                                   WCOREDUMP() */
42
42
#include <sys/stat.h>           /* struct stat, fstat(), S_ISREG() */
43
43
#include <iso646.h>             /* and, or, not */
44
44
#include <dirent.h>             /* struct dirent, scandirat() */
76
76
#define BUFFER_SIZE 256
77
77
 
78
78
#define PDIR "/lib/mandos/plugins.d"
79
 
#define PHDIR "/lib/mandos/plugin-helpers"
80
79
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
81
80
 
82
81
const char *argp_program_version = "plugin-runner " VERSION;
348
347
 
349
348
int main(int argc, char *argv[]){
350
349
  char *plugindir = NULL;
351
 
  char *pluginhelperdir = NULL;
352
350
  char *argfile = NULL;
353
351
  FILE *conffp;
354
352
  struct dirent **direntries = NULL;
416
414
      .doc = "Group ID the plugins will run as", .group = 3 },
417
415
    { .name = "debug", .key = 132,
418
416
      .doc = "Debug mode", .group = 4 },
419
 
    { .name = "plugin-helper-dir", .key = 133,
420
 
      .arg = "DIRECTORY",
421
 
      .doc = "Specify a different plugin helper directory",
422
 
      .group = 2 },
423
417
    /*
424
418
     * These reproduce what we would get without ARGP_NO_HELP
425
419
     */
551
545
    case 132:                   /* --debug */
552
546
      debug = true;
553
547
      break;
554
 
    case 133:                   /* --plugin-helper-dir */
555
 
      free(pluginhelperdir);
556
 
      pluginhelperdir = strdup(arg);
557
 
      if(pluginhelperdir != NULL){
558
 
        errno = 0;
559
 
      }
560
 
      break;
561
548
      /*
562
549
       * These reproduce what we would get without ARGP_NO_HELP
563
550
       */
583
570
      if(arg[0] == '\0'){
584
571
        break;
585
572
      }
586
 
      /* FALLTHROUGH */
587
573
    default:
588
574
      return ARGP_ERR_UNKNOWN;
589
575
    }
615
601
    case 130:                   /* --userid */
616
602
    case 131:                   /* --groupid */
617
603
    case 132:                   /* --debug */
618
 
    case 133:                   /* --plugin-helper-dir */
619
604
    case '?':                   /* --help */
620
605
    case -3:                    /* --usage */
621
606
    case 'V':                   /* --version */
702
687
        custom_argc += 1;
703
688
        {
704
689
          char **new_argv = realloc(custom_argv, sizeof(char *)
705
 
                                    * ((size_t)custom_argc + 1));
 
690
                                    * ((unsigned int)
 
691
                                       custom_argc + 1));
706
692
          if(new_argv == NULL){
707
693
            error(0, errno, "realloc");
708
694
            exitstatus = EX_OSERR;
775
761
    goto fallback;
776
762
  }
777
763
  
778
 
  {
779
 
    char *pluginhelperenv;
780
 
    bool bret = true;
781
 
    ret = asprintf(&pluginhelperenv, "MANDOSPLUGINHELPERDIR=%s",
782
 
                   pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
783
 
    if(ret != -1){
784
 
      bret = add_environment(getplugin(NULL), pluginhelperenv, true);
785
 
    }
786
 
    if(ret == -1 or not bret){
787
 
      error(0, errno, "Failed to set MANDOSPLUGINHELPERDIR"
788
 
            " environment variable to \"%s\" for all plugins\n",
789
 
            pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
790
 
    }
791
 
    if(ret != -1){
792
 
      free(pluginhelperenv);
793
 
    }
794
 
  }
795
 
  
796
764
  if(debug){
797
 
    for(plugin *p = plugin_list; p != NULL; p = p->next){
 
765
    for(plugin *p = plugin_list; p != NULL; p=p->next){
798
766
      fprintf(stderr, "Plugin: %s has %d arguments\n",
799
767
              p->name ? p->name : "Global", p->argc - 1);
800
768
      for(char **a = p->argv; *a != NULL; a++){
809
777
  
810
778
  if(getuid() == 0){
811
779
    /* Work around Debian bug #633582:
812
 
       <https://bugs.debian.org/633582> */
 
780
       <http://bugs.debian.org/633582> */
813
781
    int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
814
782
    if(plugindir_fd == -1){
815
783
      if(errno != ENOENT){
827
795
          }
828
796
        }
829
797
      }
830
 
      close(plugindir_fd);
 
798
      TEMP_FAILURE_RETRY(close(plugindir_fd));
831
799
    }
832
800
  }
833
801
  
892
860
    return 1;
893
861
  }
894
862
  
 
863
#ifdef __GLIBC__
 
864
#if __GLIBC_PREREQ(2, 15)
895
865
  int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
896
866
                             alphasort);
 
867
#else  /* not __GLIBC_PREREQ(2, 15) */
 
868
  int numplugins = scandir(plugindir != NULL ? plugindir : PDIR,
 
869
                           &direntries, good_name, alphasort);
 
870
#endif  /* not __GLIBC_PREREQ(2, 15) */
 
871
#else   /* not __GLIBC__ */
 
872
  int numplugins = scandir(plugindir != NULL ? plugindir : PDIR,
 
873
                           &direntries, good_name, alphasort);
 
874
#endif  /* not __GLIBC__ */
897
875
  if(numplugins == -1){
898
876
    error(0, errno, "Could not scan plugin dir");
899
877
    direntries = NULL;
915
893
    ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
916
894
    if(ret == -1){
917
895
      error(0, errno, "stat");
918
 
      close(plugin_fd);
 
896
      TEMP_FAILURE_RETRY(close(plugin_fd));
919
897
      free(direntries[i]);
920
898
      continue;
921
899
    }
930
908
                plugindir != NULL ? plugindir : PDIR,
931
909
                direntries[i]->d_name);
932
910
      }
933
 
      close(plugin_fd);
 
911
      TEMP_FAILURE_RETRY(close(plugin_fd));
934
912
      free(direntries[i]);
935
913
      continue;
936
914
    }
938
916
    plugin *p = getplugin(direntries[i]->d_name);
939
917
    if(p == NULL){
940
918
      error(0, errno, "getplugin");
941
 
      close(plugin_fd);
 
919
      TEMP_FAILURE_RETRY(close(plugin_fd));
942
920
      free(direntries[i]);
943
921
      continue;
944
922
    }
947
925
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
948
926
                direntries[i]->d_name);
949
927
      }
950
 
      close(plugin_fd);
 
928
      TEMP_FAILURE_RETRY(close(plugin_fd));
951
929
      free(direntries[i]);
952
930
      continue;
953
931
    }
993
971
    if(pipefd[0] >= FD_SETSIZE){
994
972
      fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
995
973
              FD_SETSIZE);
996
 
      close(pipefd[0]);
997
 
      close(pipefd[1]);
 
974
      TEMP_FAILURE_RETRY(close(pipefd[0]));
 
975
      TEMP_FAILURE_RETRY(close(pipefd[1]));
998
976
      exitstatus = EX_OSERR;
999
977
      free(direntries[i]);
1000
978
      goto fallback;
1004
982
    ret = set_cloexec_flag(pipefd[0]);
1005
983
    if(ret < 0){
1006
984
      error(0, errno, "set_cloexec_flag");
1007
 
      close(pipefd[0]);
1008
 
      close(pipefd[1]);
 
985
      TEMP_FAILURE_RETRY(close(pipefd[0]));
 
986
      TEMP_FAILURE_RETRY(close(pipefd[1]));
1009
987
      exitstatus = EX_OSERR;
1010
988
      free(direntries[i]);
1011
989
      goto fallback;
1013
991
    ret = set_cloexec_flag(pipefd[1]);
1014
992
    if(ret < 0){
1015
993
      error(0, errno, "set_cloexec_flag");
1016
 
      close(pipefd[0]);
1017
 
      close(pipefd[1]);
 
994
      TEMP_FAILURE_RETRY(close(pipefd[0]));
 
995
      TEMP_FAILURE_RETRY(close(pipefd[1]));
1018
996
      exitstatus = EX_OSERR;
1019
997
      free(direntries[i]);
1020
998
      goto fallback;
1039
1017
      error(0, errno, "fork");
1040
1018
      TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1041
1019
                                     &sigchld_action.sa_mask, NULL));
1042
 
      close(pipefd[0]);
1043
 
      close(pipefd[1]);
 
1020
      TEMP_FAILURE_RETRY(close(pipefd[0]));
 
1021
      TEMP_FAILURE_RETRY(close(pipefd[1]));
1044
1022
      exitstatus = EX_OSERR;
1045
1023
      free(direntries[i]);
1046
1024
      goto fallback;
1074
1052
      /* no return */
1075
1053
    }
1076
1054
    /* Parent process */
1077
 
    close(pipefd[1]);           /* Close unused write end of pipe */
1078
 
    close(plugin_fd);
 
1055
    TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
 
1056
                                             pipe */
 
1057
    TEMP_FAILURE_RETRY(close(plugin_fd));
1079
1058
    plugin *new_plugin = getplugin(direntries[i]->d_name);
1080
1059
    if(new_plugin == NULL){
1081
1060
      error(0, errno, "getplugin");
1093
1072
    
1094
1073
    new_plugin->pid = pid;
1095
1074
    new_plugin->fd = pipefd[0];
1096
 
 
1097
 
    if(debug){
1098
 
      fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
1099
 
              new_plugin->name, (intmax_t) (new_plugin->pid));
1100
 
    }
1101
 
 
 
1075
    
1102
1076
    /* Unblock SIGCHLD so signal handler can be run if this process
1103
1077
       has already completed */
1104
1078
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1110
1084
      goto fallback;
1111
1085
    }
1112
1086
    
1113
 
    FD_SET(new_plugin->fd, &rfds_all);
 
1087
#if defined (__GNUC__) and defined (__GLIBC__)
 
1088
#if not __GLIBC_PREREQ(2, 16)
 
1089
#pragma GCC diagnostic push
 
1090
#pragma GCC diagnostic ignored "-Wsign-conversion"
 
1091
#endif
 
1092
#endif
 
1093
    FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
 
1094
                                          -Wconversion in GNU libc
 
1095
                                          before 2.16 */
 
1096
#if defined (__GNUC__) and defined (__GLIBC__)
 
1097
#if not __GLIBC_PREREQ(2, 16)
 
1098
#pragma GCC diagnostic pop
 
1099
#endif
 
1100
#endif
1114
1101
    
1115
1102
    if(maxfd < new_plugin->fd){
1116
1103
      maxfd = new_plugin->fd;
1119
1106
  
1120
1107
  free(direntries);
1121
1108
  direntries = NULL;
1122
 
  close(dir_fd);
 
1109
  TEMP_FAILURE_RETRY(close(dir_fd));
1123
1110
  dir_fd = -1;
1124
1111
  free_plugin(getplugin(NULL));
1125
1112
  
1165
1152
                      (intmax_t) (proc->pid),
1166
1153
                      WTERMSIG(proc->status),
1167
1154
                      strsignal(WTERMSIG(proc->status)));
 
1155
            } else if(WCOREDUMP(proc->status)){
 
1156
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
 
1157
                      " core\n", proc->name, (intmax_t) (proc->pid));
1168
1158
            }
1169
1159
          }
1170
1160
          
1171
1161
          /* Remove the plugin */
1172
 
          FD_CLR(proc->fd, &rfds_all);
 
1162
#if defined (__GNUC__) and defined (__GLIBC__)
 
1163
#if not __GLIBC_PREREQ(2, 16)
 
1164
#pragma GCC diagnostic push
 
1165
#pragma GCC diagnostic ignored "-Wsign-conversion"
 
1166
#endif
 
1167
#endif
 
1168
          FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
 
1169
                                          -Wconversion in GNU libc
 
1170
                                          before 2.16 */
 
1171
#if defined (__GNUC__) and defined (__GLIBC__)
 
1172
#if not __GLIBC_PREREQ(2, 16)
 
1173
#pragma GCC diagnostic pop
 
1174
#endif
 
1175
#endif
1173
1176
          
1174
1177
          /* Block signal while modifying process_list */
1175
1178
          ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1215
1218
      }
1216
1219
      
1217
1220
      /* This process has not completed.  Does it have any output? */
1218
 
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
 
1221
#if defined (__GNUC__) and defined (__GLIBC__)
 
1222
#if not __GLIBC_PREREQ(2, 16)
 
1223
#pragma GCC diagnostic push
 
1224
#pragma GCC diagnostic ignored "-Wsign-conversion"
 
1225
#endif
 
1226
#endif
 
1227
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){ /* Spurious
 
1228
                                                         warning from
 
1229
                                                         -Wconversion
 
1230
                                                         in GNU libc
 
1231
                                                         before
 
1232
                                                         2.16 */
 
1233
#if defined (__GNUC__) and defined (__GLIBC__)
 
1234
#if not __GLIBC_PREREQ(2, 16)
 
1235
#pragma GCC diagnostic pop
 
1236
#endif
 
1237
#endif
1219
1238
        /* This process had nothing to say at this time */
1220
1239
        proc = proc->next;
1221
1240
        continue;
1291
1310
  free(direntries);
1292
1311
  
1293
1312
  if(dir_fd != -1){
1294
 
    close(dir_fd);
 
1313
    TEMP_FAILURE_RETRY(close(dir_fd));
1295
1314
  }
1296
1315
  
1297
1316
  /* Kill the processes */
1317
1336
  free_plugin_list();
1318
1337
  
1319
1338
  free(plugindir);
1320
 
  free(pluginhelperdir);
1321
1339
  free(argfile);
1322
1340
  
1323
1341
  return exitstatus;