/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: 2019-02-09 23:23:26 UTC
  • mto: (237.7.594 trunk)
  • mto: This revision was merged to the branch mainline in revision 370.
  • Revision ID: teddy@recompile.se-20190209232326-z1z2kzpgfixz7iaj
Add support for using raw public keys in TLS (RFC 7250)

Since GnuTLS removed support for OpenPGP keys in TLS (RFC 6091), and
no other library supports it, we have to change the protocol to use
something else.  We choose to use "raw public keys" (RFC 7250).  Since
we still use OpenPGP keys to decrypt the secret password, this means
that each client will have two keys: One OpenPGP key and one TLS
public/private key, and the key ID of the latter key is used to
identify clients instead of the fingerprint of the OpenPGP key.

Note that this code is still compatible with GnuTLS before version
3.6.0 (when OpenPGP key support was removed).  This commit merely adds
support for using raw pulic keys instead with GnuTLS 3.6.6. or later.

* DBUS-API (Signals/ClientNotFound): Change name of first parameter
                                     from "Fingerprint" to "KeyID".
  (Mandos Client Interface/Properties/KeyID): New.
* INSTALL: Document conflict with GnuTLS 3.6.0 (which removed OpenPGP
           key support) up until 3.6.6, when support for raw public
           keys was added.  Also document new dependency of client on
           "gnutls-bin" package (for certtool).
* Makefile (run-client): Depend on TLS key files, and also pass them
                         as arguments to client.
  (keydir/tls-privkey.pem, keydir/tls-pubkey.pem): New.
  (confdir/clients.conf): Add dependency on TLS public key.
  (purge-client): Add removal of TLS key files.
* clients.conf ([foo]/key_id, [bar]/key_id): New.
* debian/control (Source: mandos/Build-Depends): Also allow
                                                 libgnutls30 (>= 3.6.6)
  (Package: mandos/Depends): - '' -
  (Package: mandos/Description): Alter description to match new
                                 design.
  (Package: mandos-client/Description): - '' -
  (Package: mandos-client/Depends): Move "gnutls-bin | openssl" to
                                    here from "Recommends".
* debian/mandos-client.README.Debian: Add --tls-privkey and
                                      --tls-pubkey options to test
                                      command.
* debian/mandos-client.postinst (create_key): Renamed to "create_keys"
                                             (all callers changed),
                                             and also create TLS key.
* debian/mandos-client.postrm (purge): Also remove TLS key files.
* intro.xml (DESCRIPTION): Describe new dual-key design.
* mandos (GnuTLS): Define different functions depending on whether
                   support for raw public keys is detected.
  (Client.key_id): New attribute.
  (ClientDBus.KeyID_dbus_property): New method.
  (ProxyClient.__init__): Take new "key_id" parameter.
  (ClientHandler.handle): Use key IDs when using raw public keys and
                          use fingerprints when using OpenPGP keys.
  (ClientHandler.peer_certificate): Also handle raw public keys.
  (ClientHandler.key_id): New.
  (MandosServer.handle_ipc): Pass key ID over the pipe IPC.  Also
                             check for key ID matches when looking up
                             clients.
  (main): Default GnuTLS priority string depends on whether we are
          using raw public keys or not.  When unpickling clients, set
          key_id if not set in the pickle.
  (main/MandosDBusService.ClientNotFound): Change name of first
                                           parameter from
                                           "Fingerprint" to "KeyID".
* mandos-clients.conf.xml (OPTIONS): Document new "key_id" option.
  (OPTIONS/secret): Mention new key ID matchning.
  (EXPANSION/RUNTIME EXPANSION): Add new "key_id" option.
  (EXAMPLE): - '' -
* mandos-ctl (tablewords, main/keywords): Add new "KeyID" property.
* mandos-keygen: Create TLS key files.  New "--tls-keytype" (-T)
                 option.  Alter help text to be more clear about key
                 types.  When in password mode, also output "key_id"
                 option.
* mandos-keygen.xml (SYNOPSIS): Add new "--tls-keytype" (-T) option.
  (DESCRIPTION): Alter to match new dual-key design.
  (OVERVIEW): - '' -
  (FILES): Add TLS key files.
* mandos-options.xml (priority): Document new default priority string
                                 when using raw public keys.
* mandos.xml (NETWORK PROTOCOL): Describe new protocol using key ID.
  (BUGS): Remove issue about checking expire times of OpenPGP keys,
          since TLS public keys do not have expiration times.
  (SECURITY/CLIENT): Alter description to match new design.
  (SEE ALSO/GnuTLS): - '' -
  (SEE ALSO): Add reference to RFC 7250, and alter description of when
              RFC 6091 is used.
* overview.xml: Alter text to match new design.
* plugin-runner.xml (EXAMPLE): Add --tls-pubkey and --tls-privkey
                               options to mandos-client options.
* plugins.d/mandos-client.c: Use raw public keys when compiling with
                             supporting GnuTLS versions. Add new
                             "--tls-pubkey" and "--tls-privkey"
                             options (which do nothing if GnuTLS
                             library does not support raw public
                             keys).  Alter text throughout to reflect
                             new design.  Only generate new DH
                             parameters (based on size of OpenPGP key)
                             when using OpenPGP in TLS.  Default
                             GnuTLS priority string depends on whether
                             we are using raw public keys or not.
* plugins.d/mandos-client.xml (SYNOPSIS): Add new "--tls-privkey" (-t)
                                          and "--tls-pubkey" (-T)
                                          options.
  (DESCRIPTION): Describe new dual-key design.
  (OPTIONS): Document new "--tls-privkey" (-t) and "--tls-pubkey" (-T)
             options.
  (OPTIONS/--dh-bits): No longer necessarily depends on OpenPGP key
                       size.
  (FILES): Add default locations for TLS public and private key files.
  (EXAMPLE): Use new --tls-pubkey and --tls-privkey options.
  (SECURITY): Alter wording slightly to reflect new dual-key design.
  (SEE ALSO/GnuTLS): Alter description to match new design.
  (SEE ALSO): Add reference to RFC 7250, and alter description of when
              RFC 6091 is used.

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,2009 Teddy Hogeborn
6
 
 * Copyright © 2008,2009 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
 
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
14
16
 * WITHOUT ANY WARRANTY; without even the implied warranty of
15
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
18
 * General Public License for more details.
17
19
 * 
18
20
 * You should have received a copy of the GNU General Public License
19
 
 * along with this program.  If not, see
20
 
 * <http://www.gnu.org/licenses/>.
 
21
 * along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
21
22
 * 
22
 
 * Contact the authors at <mandos@fukt.bsnet.se>.
 
23
 * Contact the authors at <mandos@recompile.se>.
23
24
 */
24
25
 
25
26
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), getline(),
26
 
                                   asprintf(), O_CLOEXEC */
 
27
                                   O_CLOEXEC, pipe2() */
27
28
#include <stddef.h>             /* size_t, NULL */
28
29
#include <stdlib.h>             /* malloc(), exit(), EXIT_SUCCESS,
29
30
                                   realloc() */
30
31
#include <stdbool.h>            /* bool, true, false */
31
32
#include <stdio.h>              /* fileno(), fprintf(),
32
 
                                   stderr, STDOUT_FILENO */
33
 
#include <sys/types.h>          /* DIR, fdopendir(), stat(), struct
34
 
                                   stat, waitpid(), WIFEXITED(),
35
 
                                   WEXITSTATUS(), wait(), pid_t,
36
 
                                   uid_t, gid_t, getuid(), getgid(),
37
 
                                   dirfd() */
 
33
                                   stderr, STDOUT_FILENO, fclose() */
 
34
#include <sys/types.h>          /* fstat(), struct stat, waitpid(),
 
35
                                   WIFEXITED(), WEXITSTATUS(), wait(),
 
36
                                   pid_t, uid_t, gid_t, getuid(),
 
37
                                   getgid() */
38
38
#include <sys/select.h>         /* fd_set, select(), FD_ZERO(),
39
39
                                   FD_SET(), FD_ISSET(), FD_CLR */
40
40
#include <sys/wait.h>           /* wait(), waitpid(), WIFEXITED(),
41
 
                                   WEXITSTATUS(), WTERMSIG(),
42
 
                                   WCOREDUMP() */
43
 
#include <sys/stat.h>           /* struct stat, stat(), S_ISREG() */
 
41
                                   WEXITSTATUS(), WTERMSIG() */
 
42
#include <sys/stat.h>           /* struct stat, fstat(), S_ISREG() */
44
43
#include <iso646.h>             /* and, or, not */
45
 
#include <dirent.h>             /* DIR, struct dirent, fdopendir(),
46
 
                                   readdir(), closedir(), dirfd() */
47
 
#include <unistd.h>             /* struct stat, stat(), S_ISREG(),
48
 
                                   fcntl(), setuid(), setgid(),
49
 
                                   F_GETFD, F_SETFD, FD_CLOEXEC,
50
 
                                   access(), pipe(), fork(), close()
51
 
                                   dup2(), STDOUT_FILENO, _exit(),
52
 
                                   execv(), write(), read(),
53
 
                                   close() */
 
44
#include <dirent.h>             /* struct dirent, scandirat() */
 
45
#include <unistd.h>             /* fcntl(), F_GETFD, F_SETFD,
 
46
                                   FD_CLOEXEC, write(), STDOUT_FILENO,
 
47
                                   struct stat, fstat(), close(),
 
48
                                   setgid(), setuid(), S_ISREG(),
 
49
                                   faccessat() pipe2(), fork(),
 
50
                                   _exit(), dup2(), fexecve(), read()
 
51
                                */
54
52
#include <fcntl.h>              /* fcntl(), F_GETFD, F_SETFD,
55
 
                                   FD_CLOEXEC */
56
 
#include <string.h>             /* strsep, strlen(), asprintf(),
57
 
                                   strsignal(), strcmp(), strncmp() */
 
53
                                   FD_CLOEXEC, openat(), scandirat(),
 
54
                                   pipe2() */
 
55
#include <string.h>             /* strsep, strlen(), strsignal(),
 
56
                                   strcmp(), strncmp() */
58
57
#include <errno.h>              /* errno */
59
58
#include <argp.h>               /* struct argp_option, struct
60
59
                                   argp_state, struct argp,
72
71
                                   EX_CONFIG, EX_UNAVAILABLE, EX_OK */
73
72
#include <errno.h>              /* errno */
74
73
#include <error.h>              /* error() */
 
74
#include <fnmatch.h>            /* fnmatch() */
75
75
 
76
76
#define BUFFER_SIZE 256
77
77
 
78
78
#define PDIR "/lib/mandos/plugins.d"
 
79
#define PHDIR "/lib/mandos/plugin-helpers"
79
80
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
80
81
 
81
82
const char *argp_program_version = "plugin-runner " VERSION;
82
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
 
83
const char *argp_program_bug_address = "<mandos@recompile.se>";
83
84
 
84
85
typedef struct plugin{
85
86
  char *name;                   /* can be NULL or any plugin name */
105
106
 
106
107
/* Gets an existing plugin based on name,
107
108
   or if none is found, creates a new one */
 
109
__attribute__((warn_unused_result))
108
110
static plugin *getplugin(char *name){
109
111
  /* Check for existing plugin with that name */
110
112
  for(plugin *p = plugin_list; p != NULL; p = p->next){
171
173
}
172
174
 
173
175
/* Helper function for add_argument and add_environment */
 
176
__attribute__((nonnull, warn_unused_result))
174
177
static bool add_to_char_array(const char *new, char ***array,
175
178
                              int *len){
176
179
  /* Resize the pointed-to array to hold one more pointer */
 
180
  char **new_array = NULL;
177
181
  do {
178
 
    *array = realloc(*array, sizeof(char *)
179
 
                     * (size_t) ((*len) + 2));
180
 
  } while(*array == NULL and errno == EINTR);
 
182
    new_array = realloc(*array, sizeof(char *)
 
183
                        * (size_t) ((*len) + 2));
 
184
  } while(new_array == NULL and errno == EINTR);
181
185
  /* Malloc check */
182
 
  if(*array == NULL){
 
186
  if(new_array == NULL){
183
187
    return false;
184
188
  }
 
189
  *array = new_array;
185
190
  /* Make a copy of the new string */
186
191
  char *copy;
187
192
  do {
199
204
}
200
205
 
201
206
/* Add to a plugin's argument vector */
 
207
__attribute__((nonnull(2), warn_unused_result))
202
208
static bool add_argument(plugin *p, const char *arg){
203
209
  if(p == NULL){
204
210
    return false;
207
213
}
208
214
 
209
215
/* Add to a plugin's environment */
 
216
__attribute__((nonnull(2), warn_unused_result))
210
217
static bool add_environment(plugin *p, const char *def, bool replace){
211
218
  if(p == NULL){
212
219
    return false;
214
221
  /* namelen = length of name of environment variable */
215
222
  size_t namelen = (size_t)(strchrnul(def, '=') - def);
216
223
  /* Search for this environment variable */
217
 
  for(char **e = p->environ; *e != NULL; e++){
218
 
    if(strncmp(*e, def, namelen + 1) == 0){
 
224
  for(char **envdef = p->environ; *envdef != NULL; envdef++){
 
225
    if(strncmp(*envdef, def, namelen + 1) == 0){
219
226
      /* It already exists */
220
227
      if(replace){
221
 
        char *new;
 
228
        char *new_envdef;
222
229
        do {
223
 
          new = realloc(*e, strlen(def) + 1);
224
 
        } while(new == NULL and errno == EINTR);
225
 
        if(new == NULL){
 
230
          new_envdef = realloc(*envdef, strlen(def) + 1);
 
231
        } while(new_envdef == NULL and errno == EINTR);
 
232
        if(new_envdef == NULL){
226
233
          return false;
227
234
        }
228
 
        *e = new;
229
 
        strcpy(*e, def);
 
235
        *envdef = new_envdef;
 
236
        strcpy(*envdef, def);
230
237
      }
231
238
      return true;
232
239
    }
234
241
  return add_to_char_array(def, &(p->environ), &(p->envc));
235
242
}
236
243
 
 
244
#ifndef O_CLOEXEC
237
245
/*
238
246
 * Based on the example in the GNU LibC manual chapter 13.13 "File
239
247
 * Descriptor Flags".
240
248
 | [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
241
249
 */
 
250
__attribute__((warn_unused_result))
242
251
static int set_cloexec_flag(int fd){
243
252
  int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
244
253
  /* If reading the flags failed, return error indication now. */
249
258
  return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
250
259
                                       ret | FD_CLOEXEC));
251
260
}
 
261
#endif  /* not O_CLOEXEC */
252
262
 
253
263
 
254
264
/* Mark processes as completed when they exit, and save their exit
286
296
}
287
297
 
288
298
/* Prints out a password to stdout */
 
299
__attribute__((nonnull, warn_unused_result))
289
300
static bool print_out_password(const char *buffer, size_t length){
290
301
  ssize_t ret;
291
302
  for(size_t written = 0; written < length; written += (size_t)ret){
299
310
}
300
311
 
301
312
/* Removes and free a plugin from the plugin list */
 
313
__attribute__((nonnull))
302
314
static void free_plugin(plugin *plugin_node){
303
315
  
304
316
  for(char **arg = plugin_node->argv; *arg != NULL; arg++){
336
348
 
337
349
int main(int argc, char *argv[]){
338
350
  char *plugindir = NULL;
 
351
  char *pluginhelperdir = NULL;
339
352
  char *argfile = NULL;
340
353
  FILE *conffp;
341
 
  size_t d_name_len;
342
 
  DIR *dir = NULL;
343
 
  struct dirent *dirst;
 
354
  struct dirent **direntries = NULL;
344
355
  struct stat st;
345
356
  fd_set rfds_all;
346
357
  int ret, maxfd = 0;
354
365
                                      .sa_flags = SA_NOCLDSTOP };
355
366
  char **custom_argv = NULL;
356
367
  int custom_argc = 0;
 
368
  int dir_fd = -1;
357
369
  
358
370
  /* Establish a signal handler */
359
371
  sigemptyset(&sigchld_action.sa_mask);
404
416
      .doc = "Group ID the plugins will run as", .group = 3 },
405
417
    { .name = "debug", .key = 132,
406
418
      .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 },
407
423
    /*
408
424
     * These reproduce what we would get without ARGP_NO_HELP
409
425
     */
416
432
    { .name = NULL }
417
433
  };
418
434
  
 
435
  __attribute__((nonnull(3)))
419
436
  error_t parse_opt(int key, char *arg, struct argp_state *state){
420
437
    errno = 0;
421
438
    switch(key){
422
439
      char *tmp;
423
 
      intmax_t tmpmax;
 
440
      intmax_t tmp_id;
424
441
    case 'g':                   /* --global-options */
425
442
      {
426
443
        char *plugin_option;
429
446
            break;
430
447
          }
431
448
        }
 
449
        errno = 0;
432
450
      }
433
451
      break;
434
452
    case 'G':                   /* --global-env */
435
 
      add_environment(getplugin(NULL), arg, true);
 
453
      if(add_environment(getplugin(NULL), arg, true)){
 
454
        errno = 0;
 
455
      }
436
456
      break;
437
457
    case 'o':                   /* --options-for */
438
458
      {
455
475
            break;
456
476
          }
457
477
        }
 
478
        errno = 0;
458
479
      }
459
480
      break;
460
481
    case 'E':                   /* --env-for */
472
493
          errno = EINVAL;
473
494
          break;
474
495
        }
475
 
        add_environment(getplugin(arg), envdef, true);
 
496
        if(add_environment(getplugin(arg), envdef, true)){
 
497
          errno = 0;
 
498
        }
476
499
      }
477
500
      break;
478
501
    case 'd':                   /* --disable */
480
503
        plugin *p = getplugin(arg);
481
504
        if(p != NULL){
482
505
          p->disabled = true;
 
506
          errno = 0;
483
507
        }
484
508
      }
485
509
      break;
488
512
        plugin *p = getplugin(arg);
489
513
        if(p != NULL){
490
514
          p->disabled = false;
 
515
          errno = 0;
491
516
        }
492
517
      }
493
518
      break;
494
519
    case 128:                   /* --plugin-dir */
495
520
      free(plugindir);
496
521
      plugindir = strdup(arg);
 
522
      if(plugindir != NULL){
 
523
        errno = 0;
 
524
      }
497
525
      break;
498
526
    case 129:                   /* --config-file */
499
527
      /* This is already done by parse_opt_config_file() */
500
528
      break;
501
529
    case 130:                   /* --userid */
502
 
      tmpmax = strtoimax(arg, &tmp, 10);
 
530
      tmp_id = strtoimax(arg, &tmp, 10);
503
531
      if(errno != 0 or tmp == arg or *tmp != '\0'
504
 
         or tmpmax != (uid_t)tmpmax){
 
532
         or tmp_id != (uid_t)tmp_id){
505
533
        argp_error(state, "Bad user ID number: \"%s\", using %"
506
534
                   PRIdMAX, arg, (intmax_t)uid);
507
535
        break;
508
536
      }
509
 
      uid = (uid_t)tmpmax;
 
537
      uid = (uid_t)tmp_id;
 
538
      errno = 0;
510
539
      break;
511
540
    case 131:                   /* --groupid */
512
 
      tmpmax = strtoimax(arg, &tmp, 10);
 
541
      tmp_id = strtoimax(arg, &tmp, 10);
513
542
      if(errno != 0 or tmp == arg or *tmp != '\0'
514
 
         or tmpmax != (gid_t)tmpmax){
 
543
         or tmp_id != (gid_t)tmp_id){
515
544
        argp_error(state, "Bad group ID number: \"%s\", using %"
516
545
                   PRIdMAX, arg, (intmax_t)gid);
517
546
        break;
518
547
      }
519
 
      gid = (gid_t)tmpmax;
 
548
      gid = (gid_t)tmp_id;
 
549
      errno = 0;
520
550
      break;
521
551
    case 132:                   /* --debug */
522
552
      debug = true;
523
553
      break;
 
554
    case 133:                   /* --plugin-helper-dir */
 
555
      free(pluginhelperdir);
 
556
      pluginhelperdir = strdup(arg);
 
557
      if(pluginhelperdir != NULL){
 
558
        errno = 0;
 
559
      }
 
560
      break;
524
561
      /*
525
562
       * These reproduce what we would get without ARGP_NO_HELP
526
563
       */
546
583
      if(arg[0] == '\0'){
547
584
        break;
548
585
      }
 
586
      /* FALLTHROUGH */
549
587
    default:
550
588
      return ARGP_ERR_UNKNOWN;
551
589
    }
570
608
    case 129:                   /* --config-file */
571
609
      free(argfile);
572
610
      argfile = strdup(arg);
 
611
      if(argfile != NULL){
 
612
        errno = 0;
 
613
      }
573
614
      break;
574
615
    case 130:                   /* --userid */
575
616
    case 131:                   /* --groupid */
576
617
    case 132:                   /* --debug */
 
618
    case 133:                   /* --plugin-helper-dir */
577
619
    case '?':                   /* --help */
578
620
    case -3:                    /* --usage */
579
621
    case 'V':                   /* --version */
658
700
        }
659
701
        
660
702
        custom_argc += 1;
661
 
        custom_argv = realloc(custom_argv, sizeof(char *)
662
 
                              * ((unsigned int) custom_argc + 1));
663
 
        if(custom_argv == NULL){
664
 
          error(0, errno, "realloc");
665
 
          exitstatus = EX_OSERR;
666
 
          free(org_line);
667
 
          goto fallback;
 
703
        {
 
704
          char **new_argv = realloc(custom_argv, sizeof(char *)
 
705
                                    * ((size_t)custom_argc + 1));
 
706
          if(new_argv == NULL){
 
707
            error(0, errno, "realloc");
 
708
            exitstatus = EX_OSERR;
 
709
            free(new_arg);
 
710
            free(org_line);
 
711
            goto fallback;
 
712
          } else {
 
713
            custom_argv = new_argv;
 
714
          }
668
715
        }
669
716
        custom_argv[custom_argc-1] = new_arg;
670
717
        custom_argv[custom_argc] = NULL;
728
775
    goto fallback;
729
776
  }
730
777
  
 
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
  
731
796
  if(debug){
732
 
    for(plugin *p = plugin_list; p != NULL; p=p->next){
 
797
    for(plugin *p = plugin_list; p != NULL; p = p->next){
733
798
      fprintf(stderr, "Plugin: %s has %d arguments\n",
734
799
              p->name ? p->name : "Global", p->argc - 1);
735
800
      for(char **a = p->argv; *a != NULL; a++){
742
807
    }
743
808
  }
744
809
  
745
 
  /* Strip permissions down to nobody */
746
 
  setgid(gid);
 
810
  if(getuid() == 0){
 
811
    /* Work around Debian bug #633582:
 
812
       <https://bugs.debian.org/633582> */
 
813
    int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
 
814
    if(plugindir_fd == -1){
 
815
      if(errno != ENOENT){
 
816
        error(0, errno, "open(\"" PDIR "\")");
 
817
      }
 
818
    } else {
 
819
      ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
 
820
      if(ret == -1){
 
821
        error(0, errno, "fstat");
 
822
      } else {
 
823
        if(S_ISDIR(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
 
824
          ret = fchown(plugindir_fd, uid, gid);
 
825
          if(ret == -1){
 
826
            error(0, errno, "fchown");
 
827
          }
 
828
        }
 
829
      }
 
830
      close(plugindir_fd);
 
831
    }
 
832
  }
 
833
  
 
834
  /* Lower permissions */
 
835
  ret = setgid(gid);
747
836
  if(ret == -1){
748
837
    error(0, errno, "setgid");
749
838
  }
754
843
  
755
844
  /* Open plugin directory with close_on_exec flag */
756
845
  {
757
 
    int dir_fd = -1;
758
 
    if(plugindir == NULL){
759
 
      dir_fd = open(PDIR, O_RDONLY |
760
 
#ifdef O_CLOEXEC
761
 
                    O_CLOEXEC
762
 
#else  /* not O_CLOEXEC */
763
 
                    0
764
 
#endif  /* not O_CLOEXEC */
765
 
                    );
766
 
    } else {
767
 
      dir_fd = open(plugindir, O_RDONLY |
768
 
#ifdef O_CLOEXEC
769
 
                    O_CLOEXEC
770
 
#else  /* not O_CLOEXEC */
771
 
                    0
772
 
#endif  /* not O_CLOEXEC */
773
 
                    );
774
 
    }
 
846
    dir_fd = open(plugindir != NULL ? plugindir : PDIR, O_RDONLY |
 
847
#ifdef O_CLOEXEC
 
848
                  O_CLOEXEC
 
849
#else  /* not O_CLOEXEC */
 
850
                  0
 
851
#endif  /* not O_CLOEXEC */
 
852
                  );
775
853
    if(dir_fd == -1){
776
854
      error(0, errno, "Could not open plugin dir");
777
855
      exitstatus = EX_UNAVAILABLE;
783
861
    ret = set_cloexec_flag(dir_fd);
784
862
    if(ret < 0){
785
863
      error(0, errno, "set_cloexec_flag");
786
 
      TEMP_FAILURE_RETRY(close(dir_fd));
787
864
      exitstatus = EX_OSERR;
788
865
      goto fallback;
789
866
    }
790
867
#endif  /* O_CLOEXEC */
791
 
    
792
 
    dir = fdopendir(dir_fd);
793
 
    if(dir == NULL){
794
 
      error(0, errno, "Could not open plugin dir");
795
 
      TEMP_FAILURE_RETRY(close(dir_fd));
796
 
      exitstatus = EX_OSERR;
797
 
      goto fallback;
 
868
  }
 
869
  
 
870
  int good_name(const struct dirent * const dirent){
 
871
    const char * const patterns[] = { ".*", "#*#", "*~", "*.dpkg-new",
 
872
                                      "*.dpkg-old", "*.dpkg-bak",
 
873
                                      "*.dpkg-divert", NULL };
 
874
#ifdef __GNUC__
 
875
#pragma GCC diagnostic push
 
876
#pragma GCC diagnostic ignored "-Wcast-qual"
 
877
#endif
 
878
    for(const char **pat = (const char **)patterns;
 
879
        *pat != NULL; pat++){
 
880
#ifdef __GNUC__
 
881
#pragma GCC diagnostic pop
 
882
#endif
 
883
      if(fnmatch(*pat, dirent->d_name, FNM_FILE_NAME | FNM_PERIOD)
 
884
         != FNM_NOMATCH){
 
885
        if(debug){
 
886
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
 
887
                    " matching pattern %s\n", dirent->d_name, *pat);
 
888
        }
 
889
        return 0;
 
890
      }
798
891
    }
 
892
    return 1;
 
893
  }
 
894
  
 
895
  int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
 
896
                             alphasort);
 
897
  if(numplugins == -1){
 
898
    error(0, errno, "Could not scan plugin dir");
 
899
    direntries = NULL;
 
900
    exitstatus = EX_OSERR;
 
901
    goto fallback;
799
902
  }
800
903
  
801
904
  FD_ZERO(&rfds_all);
802
905
  
803
906
  /* Read and execute any executable in the plugin directory*/
804
 
  while(true){
805
 
    do {
806
 
      dirst = readdir(dir);
807
 
    } while(dirst == NULL and errno == EINTR);
808
 
    
809
 
    /* All directory entries have been processed */
810
 
    if(dirst == NULL){
811
 
      if(errno == EBADF){
812
 
        error(0, errno, "readdir");
813
 
        exitstatus = EX_IOERR;
814
 
        goto fallback;
815
 
      }
816
 
      break;
817
 
    }
818
 
    
819
 
    d_name_len = strlen(dirst->d_name);
820
 
    
821
 
    /* Ignore dotfiles, backup files and other junk */
822
 
    {
823
 
      bool bad_name = false;
824
 
      
825
 
      const char const *bad_prefixes[] = { ".", "#", NULL };
826
 
      
827
 
      const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
828
 
                                           ".dpkg-old",
829
 
                                           ".dpkg-bak",
830
 
                                           ".dpkg-divert", NULL };
831
 
      for(const char **pre = bad_prefixes; *pre != NULL; pre++){
832
 
        size_t pre_len = strlen(*pre);
833
 
        if((d_name_len >= pre_len)
834
 
           and strncmp((dirst->d_name), *pre, pre_len) == 0){
835
 
          if(debug){
836
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
837
 
                    " with bad prefix %s\n", dirst->d_name, *pre);
838
 
          }
839
 
          bad_name = true;
840
 
          break;
841
 
        }
842
 
      }
843
 
      if(bad_name){
844
 
        continue;
845
 
      }
846
 
      for(const char **suf = bad_suffixes; *suf != NULL; suf++){
847
 
        size_t suf_len = strlen(*suf);
848
 
        if((d_name_len >= suf_len)
849
 
           and (strcmp((dirst->d_name) + d_name_len-suf_len, *suf)
850
 
                == 0)){
851
 
          if(debug){
852
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
853
 
                    " with bad suffix %s\n", dirst->d_name, *suf);
854
 
          }
855
 
          bad_name = true;
856
 
          break;
857
 
        }
858
 
      }
859
 
      
860
 
      if(bad_name){
861
 
        continue;
862
 
      }
863
 
    }
864
 
    
865
 
    char *filename;
866
 
    if(plugindir == NULL){
867
 
      ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, PDIR "/%s",
868
 
                                             dirst->d_name));
869
 
    } else {
870
 
      ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, "%s/%s",
871
 
                                             plugindir,
872
 
                                             dirst->d_name));
873
 
    }
874
 
    if(ret < 0){
875
 
      error(0, errno, "asprintf");
 
907
  for(int i = 0; i < numplugins; i++){
 
908
    
 
909
    int plugin_fd = openat(dir_fd, direntries[i]->d_name, O_RDONLY);
 
910
    if(plugin_fd == -1){
 
911
      error(0, errno, "Could not open plugin");
 
912
      free(direntries[i]);
876
913
      continue;
877
914
    }
878
 
    
879
 
    ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));
 
915
    ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
880
916
    if(ret == -1){
881
917
      error(0, errno, "stat");
882
 
      free(filename);
 
918
      close(plugin_fd);
 
919
      free(direntries[i]);
883
920
      continue;
884
921
    }
885
922
    
886
923
    /* Ignore non-executable files */
887
924
    if(not S_ISREG(st.st_mode)
888
 
       or (TEMP_FAILURE_RETRY(access(filename, X_OK)) != 0)){
 
925
       or (TEMP_FAILURE_RETRY(faccessat(dir_fd, direntries[i]->d_name,
 
926
                                        X_OK, 0)) != 0)){
889
927
      if(debug){
890
 
        fprintf(stderr, "Ignoring plugin dir entry \"%s\""
891
 
                " with bad type or mode\n", filename);
 
928
        fprintf(stderr, "Ignoring plugin dir entry \"%s/%s\""
 
929
                " with bad type or mode\n",
 
930
                plugindir != NULL ? plugindir : PDIR,
 
931
                direntries[i]->d_name);
892
932
      }
893
 
      free(filename);
 
933
      close(plugin_fd);
 
934
      free(direntries[i]);
894
935
      continue;
895
936
    }
896
937
    
897
 
    plugin *p = getplugin(dirst->d_name);
 
938
    plugin *p = getplugin(direntries[i]->d_name);
898
939
    if(p == NULL){
899
940
      error(0, errno, "getplugin");
900
 
      free(filename);
 
941
      close(plugin_fd);
 
942
      free(direntries[i]);
901
943
      continue;
902
944
    }
903
945
    if(p->disabled){
904
946
      if(debug){
905
947
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
906
 
                dirst->d_name);
 
948
                direntries[i]->d_name);
907
949
      }
908
 
      free(filename);
 
950
      close(plugin_fd);
 
951
      free(direntries[i]);
909
952
      continue;
910
953
    }
911
954
    {
925
968
        }
926
969
      }
927
970
    }
928
 
    /* If this plugin has any environment variables, we will call
929
 
       using execve and need to duplicate the environment from this
930
 
       process, too. */
 
971
    /* If this plugin has any environment variables, we need to
 
972
       duplicate the environment from this process, too. */
931
973
    if(p->environ[0] != NULL){
932
974
      for(char **e = environ; *e != NULL; e++){
933
975
        if(not add_environment(p, *e, false)){
937
979
    }
938
980
    
939
981
    int pipefd[2];
 
982
#ifndef O_CLOEXEC
940
983
    ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
 
984
#else  /* O_CLOEXEC */
 
985
    ret = (int)TEMP_FAILURE_RETRY(pipe2(pipefd, O_CLOEXEC));
 
986
#endif  /* O_CLOEXEC */
941
987
    if(ret == -1){
942
988
      error(0, errno, "pipe");
943
989
      exitstatus = EX_OSERR;
944
 
      goto fallback;
945
 
    }
 
990
      free(direntries[i]);
 
991
      goto fallback;
 
992
    }
 
993
    if(pipefd[0] >= FD_SETSIZE){
 
994
      fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
 
995
              FD_SETSIZE);
 
996
      close(pipefd[0]);
 
997
      close(pipefd[1]);
 
998
      exitstatus = EX_OSERR;
 
999
      free(direntries[i]);
 
1000
      goto fallback;
 
1001
    }
 
1002
#ifndef O_CLOEXEC
946
1003
    /* Ask OS to automatic close the pipe on exec */
947
1004
    ret = set_cloexec_flag(pipefd[0]);
948
1005
    if(ret < 0){
949
1006
      error(0, errno, "set_cloexec_flag");
 
1007
      close(pipefd[0]);
 
1008
      close(pipefd[1]);
950
1009
      exitstatus = EX_OSERR;
 
1010
      free(direntries[i]);
951
1011
      goto fallback;
952
1012
    }
953
1013
    ret = set_cloexec_flag(pipefd[1]);
954
1014
    if(ret < 0){
955
1015
      error(0, errno, "set_cloexec_flag");
 
1016
      close(pipefd[0]);
 
1017
      close(pipefd[1]);
956
1018
      exitstatus = EX_OSERR;
 
1019
      free(direntries[i]);
957
1020
      goto fallback;
958
1021
    }
 
1022
#endif  /* not O_CLOEXEC */
959
1023
    /* Block SIGCHLD until process is safely in process list */
960
1024
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
961
1025
                                              &sigchld_action.sa_mask,
963
1027
    if(ret < 0){
964
1028
      error(0, errno, "sigprocmask");
965
1029
      exitstatus = EX_OSERR;
 
1030
      free(direntries[i]);
966
1031
      goto fallback;
967
1032
    }
968
1033
    /* Starting a new process to be watched */
972
1037
    } while(pid == -1 and errno == EINTR);
973
1038
    if(pid == -1){
974
1039
      error(0, errno, "fork");
 
1040
      TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
 
1041
                                     &sigchld_action.sa_mask, NULL));
 
1042
      close(pipefd[0]);
 
1043
      close(pipefd[1]);
975
1044
      exitstatus = EX_OSERR;
 
1045
      free(direntries[i]);
976
1046
      goto fallback;
977
1047
    }
978
1048
    if(pid == 0){
994
1064
        _exit(EX_OSERR);
995
1065
      }
996
1066
      
997
 
      if(dirfd(dir) < 0){
998
 
        /* If dir has no file descriptor, we could not set FD_CLOEXEC
999
 
           above and must now close it manually here. */
1000
 
        closedir(dir);
1001
 
      }
1002
 
      if(p->environ[0] == NULL){
1003
 
        if(execv(filename, p->argv) < 0){
1004
 
          error(0, errno, "execv for %s", filename);
1005
 
          _exit(EX_OSERR);
1006
 
        }
1007
 
      } else {
1008
 
        if(execve(filename, p->argv, p->environ) < 0){
1009
 
          error(0, errno, "execve for %s", filename);
1010
 
          _exit(EX_OSERR);
1011
 
        }
 
1067
      if(fexecve(plugin_fd, p->argv,
 
1068
                (p->environ[0] != NULL) ? p->environ : environ) < 0){
 
1069
        error(0, errno, "fexecve for %s/%s",
 
1070
              plugindir != NULL ? plugindir : PDIR,
 
1071
              direntries[i]->d_name);
 
1072
        _exit(EX_OSERR);
1012
1073
      }
1013
1074
      /* no return */
1014
1075
    }
1015
1076
    /* Parent process */
1016
 
    TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
1017
 
                                             pipe */
1018
 
    free(filename);
1019
 
    plugin *new_plugin = getplugin(dirst->d_name);
 
1077
    close(pipefd[1]);           /* Close unused write end of pipe */
 
1078
    close(plugin_fd);
 
1079
    plugin *new_plugin = getplugin(direntries[i]->d_name);
1020
1080
    if(new_plugin == NULL){
1021
1081
      error(0, errno, "getplugin");
1022
1082
      ret = (int)(TEMP_FAILURE_RETRY
1026
1086
        error(0, errno, "sigprocmask");
1027
1087
      }
1028
1088
      exitstatus = EX_OSERR;
 
1089
      free(direntries[i]);
1029
1090
      goto fallback;
1030
1091
    }
 
1092
    free(direntries[i]);
1031
1093
    
1032
1094
    new_plugin->pid = pid;
1033
1095
    new_plugin->fd = pipefd[0];
1034
 
    
 
1096
 
 
1097
    if(debug){
 
1098
      fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
 
1099
              new_plugin->name, (intmax_t) (new_plugin->pid));
 
1100
    }
 
1101
 
1035
1102
    /* Unblock SIGCHLD so signal handler can be run if this process
1036
1103
       has already completed */
1037
1104
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1043
1110
      goto fallback;
1044
1111
    }
1045
1112
    
1046
 
    FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
1047
 
                                          -Wconversion */
 
1113
    FD_SET(new_plugin->fd, &rfds_all);
1048
1114
    
1049
1115
    if(maxfd < new_plugin->fd){
1050
1116
      maxfd = new_plugin->fd;
1051
1117
    }
1052
1118
  }
1053
1119
  
1054
 
  TEMP_FAILURE_RETRY(closedir(dir));
1055
 
  dir = NULL;
 
1120
  free(direntries);
 
1121
  direntries = NULL;
 
1122
  close(dir_fd);
 
1123
  dir_fd = -1;
1056
1124
  free_plugin(getplugin(NULL));
1057
1125
  
1058
1126
  for(plugin *p = plugin_list; p != NULL; p = p->next){
1097
1165
                      (intmax_t) (proc->pid),
1098
1166
                      WTERMSIG(proc->status),
1099
1167
                      strsignal(WTERMSIG(proc->status)));
1100
 
            } else if(WCOREDUMP(proc->status)){
1101
 
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1102
 
                      " core\n", proc->name, (intmax_t) (proc->pid));
1103
1168
            }
1104
1169
          }
1105
1170
          
1106
1171
          /* Remove the plugin */
1107
 
          FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
1108
 
                                          -Wconversion */
 
1172
          FD_CLR(proc->fd, &rfds_all);
1109
1173
          
1110
1174
          /* Block signal while modifying process_list */
1111
1175
          ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1151
1215
      }
1152
1216
      
1153
1217
      /* This process has not completed.  Does it have any output? */
1154
 
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){ /* Spurious
1155
 
                                                         warning from
1156
 
                                                         -Wconversion */
 
1218
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1157
1219
        /* This process had nothing to say at this time */
1158
1220
        proc = proc->next;
1159
1221
        continue;
1160
1222
      }
1161
1223
      /* Before reading, make the process' data buffer large enough */
1162
1224
      if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1163
 
        proc->buffer = realloc(proc->buffer, proc->buffer_size
1164
 
                               + (size_t) BUFFER_SIZE);
1165
 
        if(proc->buffer == NULL){
 
1225
        char *new_buffer = realloc(proc->buffer, proc->buffer_size
 
1226
                                   + (size_t) BUFFER_SIZE);
 
1227
        if(new_buffer == NULL){
1166
1228
          error(0, errno, "malloc");
1167
1229
          exitstatus = EX_OSERR;
1168
1230
          goto fallback;
1169
1231
        }
 
1232
        proc->buffer = new_buffer;
1170
1233
        proc->buffer_size += BUFFER_SIZE;
1171
1234
      }
1172
1235
      /* Read from the process */
1225
1288
    free(custom_argv);
1226
1289
  }
1227
1290
  
1228
 
  if(dir != NULL){
1229
 
    closedir(dir);
 
1291
  free(direntries);
 
1292
  
 
1293
  if(dir_fd != -1){
 
1294
    close(dir_fd);
1230
1295
  }
1231
1296
  
1232
1297
  /* Kill the processes */
1252
1317
  free_plugin_list();
1253
1318
  
1254
1319
  free(plugindir);
 
1320
  free(pluginhelperdir);
1255
1321
  free(argfile);
1256
1322
  
1257
1323
  return exitstatus;