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

  • Committer: Teddy Hogeborn
  • Date: 2015-03-10 18:03:38 UTC
  • 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:
plugin-runner.c
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;
313
312
__attribute__((nonnull))
314
313
static void free_plugin(plugin *plugin_node){
315
314
  
316
 
  free(plugin_node->name);
317
315
  for(char **arg = plugin_node->argv; *arg != NULL; arg++){
318
316
    free(*arg);
319
317
  }
349
347
 
350
348
int main(int argc, char *argv[]){
351
349
  char *plugindir = NULL;
352
 
  char *pluginhelperdir = NULL;
353
350
  char *argfile = NULL;
354
351
  FILE *conffp;
355
352
  struct dirent **direntries = NULL;
417
414
      .doc = "Group ID the plugins will run as", .group = 3 },
418
415
    { .name = "debug", .key = 132,
419
416
      .doc = "Debug mode", .group = 4 },
420
 
    { .name = "plugin-helper-dir", .key = 133,
421
 
      .arg = "DIRECTORY",
422
 
      .doc = "Specify a different plugin helper directory",
423
 
      .group = 2 },
424
417
    /*
425
418
     * These reproduce what we would get without ARGP_NO_HELP
426
419
     */
552
545
    case 132:                   /* --debug */
553
546
      debug = true;
554
547
      break;
555
 
    case 133:                   /* --plugin-helper-dir */
556
 
      free(pluginhelperdir);
557
 
      pluginhelperdir = strdup(arg);
558
 
      if(pluginhelperdir != NULL){
559
 
        errno = 0;
560
 
      }
561
 
      break;
562
548
      /*
563
549
       * These reproduce what we would get without ARGP_NO_HELP
564
550
       */
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");
1105
1084
      goto fallback;
1106
1085
    }
1107
1086
    
1108
 
    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
1109
1101
    
1110
1102
    if(maxfd < new_plugin->fd){
1111
1103
      maxfd = new_plugin->fd;
1114
1106
  
1115
1107
  free(direntries);
1116
1108
  direntries = NULL;
1117
 
  close(dir_fd);
 
1109
  TEMP_FAILURE_RETRY(close(dir_fd));
1118
1110
  dir_fd = -1;
1119
1111
  free_plugin(getplugin(NULL));
1120
1112
  
1160
1152
                      (intmax_t) (proc->pid),
1161
1153
                      WTERMSIG(proc->status),
1162
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));
1163
1158
            }
1164
1159
          }
1165
1160
          
1166
1161
          /* Remove the plugin */
1167
 
          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
1168
1176
          
1169
1177
          /* Block signal while modifying process_list */
1170
1178
          ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1210
1218
      }
1211
1219
      
1212
1220
      /* This process has not completed.  Does it have any output? */
1213
 
      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
1214
1238
        /* This process had nothing to say at this time */
1215
1239
        proc = proc->next;
1216
1240
        continue;
1286
1310
  free(direntries);
1287
1311
  
1288
1312
  if(dir_fd != -1){
1289
 
    close(dir_fd);
 
1313
    TEMP_FAILURE_RETRY(close(dir_fd));
1290
1314
  }
1291
1315
  
1292
1316
  /* Kill the processes */
1312
1336
  free_plugin_list();
1313
1337
  
1314
1338
  free(plugindir);
1315
 
  free(pluginhelperdir);
1316
1339
  free(argfile);
1317
1340
  
1318
1341
  return exitstatus;