/mandos/trunk

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

« back to all changes in this revision

Viewing changes to plugins.d/password-prompt.c

  • Committer: Teddy Hogeborn
  • Date: 2021-02-03 23:10:42 UTC
  • Revision ID: teddy@recompile.se-20210203231042-2z3egrvpo1zt7nej
mandos-ctl: Fix bad test for command.Remove and related minor issues

The test for command.Remove removes all clients from the spy server,
and then loops over all clients, looking for the corresponding Remove
command as recorded by the spy server.  But since since there aren't
any clients left after they were removed, no assertions are made, and
the test therefore does nothing.  Fix this.

In tests for command.Approve and command.Deny, add checks that clients
were not somehow removed by the command (in which case, likewise, no
assertions are made).

Add related checks to TestPropertySetterCmd.runTest; i.e. test that a
sequence is not empty before looping over it and making assertions.

* mandos-ctl (TestBaseCommands.test_Remove): Save a copy of the
  original "clients" dict, and loop over those instead.  Add assertion
  that all clients were indeed removed.  Also fix the code which looks
  for the Remove command, which now needs to actually work.
  (TestBaseCommands.test_Approve, TestBaseCommands.test_Deny): Add
  assertion that there are still clients before looping over them.
  (TestPropertySetterCmd.runTest): Add assertion that the list of
  values to get is not empty before looping over them.  Also add check
  that there are still clients before looping over clients.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/password-prompt.c
2
2
/*
3
3
 * Password-prompt - Read a password from the terminal and print it
4
4
 * 
5
 
 * Copyright © 2008-2010 Teddy Hogeborn
6
 
 * Copyright © 2008-2010 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-2019, 2021 Teddy Hogeborn
 
6
 * Copyright © 2008-2019, 2021 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
 
#define _GNU_SOURCE             /* getline(), asprintf() */
26
 
 
27
 
#include <termios.h>            /* struct termios, tcsetattr(),
28
 
                                   TCSAFLUSH, tcgetattr(), ECHO */
29
 
#include <unistd.h>             /* struct termios, tcsetattr(),
30
 
                                   STDIN_FILENO, TCSAFLUSH,
31
 
                                   tcgetattr(), ECHO, readlink() */
32
 
#include <signal.h>             /* sig_atomic_t, raise(), struct
33
 
                                   sigaction, sigemptyset(),
34
 
                                   sigaction(), sigaddset(), SIGINT,
35
 
                                   SIGQUIT, SIGHUP, SIGTERM,
 
26
#define _GNU_SOURCE             /* vasprintf(),
 
27
                                   program_invocation_short_name,
 
28
                                   asprintf(), getline() */
 
29
#include <sys/types.h>          /* sig_atomic_t, pid_t */
 
30
#include <stdbool.h>            /* bool, false, true */
 
31
#include <argp.h>               /* argp_program_version,
 
32
                                   argp_program_bug_address,
 
33
                                   struct argp_option,
 
34
                                   struct argp_state, argp_state_help,
 
35
                                   ARGP_HELP_STD_HELP,
 
36
                                   ARGP_HELP_EXIT_ERR,
 
37
                                   ARGP_HELP_EXIT_OK, ARGP_HELP_USAGE,
 
38
                                   argp_err_exit_status,
 
39
                                   ARGP_ERR_UNKNOWN, argp_parse(),
 
40
                                   ARGP_IN_ORDER, ARGP_NO_HELP */
 
41
#include <stdarg.h>             /* va_list, va_start(), vfprintf() */
 
42
#include <stdio.h>              /* vasprintf(), fprintf(), stderr,
 
43
                                   vfprintf(), asprintf(), getline(),
 
44
                                   stdin, feof(), clearerr(),
 
45
                                   fputc() */
 
46
#include <errno.h>              /* program_invocation_short_name,
 
47
                                   errno, ENOENT, error_t, ENOMEM,
 
48
                                   EINVAL, EBADF, ENOTTY, EFAULT,
 
49
                                   EFBIG, EIO, ENOSPC, EINTR */
 
50
#include <string.h>             /* strerror(), strrchr(), strcmp() */
 
51
#include <error.h>              /* error() */
 
52
#include <stdlib.h>             /* free(), realloc(), EXIT_SUCCESS,
 
53
                                   EXIT_FAILURE, getenv() */
 
54
#include <unistd.h>             /* access(), R_OK, ssize_t, close(),
 
55
                                   read(), STDIN_FILENO, write(),
 
56
                                   STDOUT_FILENO */
 
57
#include <dirent.h>             /* struct dirent, scandir(),
 
58
                                   alphasort() */
 
59
#include <inttypes.h>           /* uintmax_t, strtoumax() */
 
60
#include <iso646.h>             /* or, and, not */
 
61
#include <fcntl.h>              /* open(), O_RDONLY */
 
62
#include <stddef.h>             /* NULL, size_t */
 
63
#include <termios.h>            /* struct termios, tcgetattr(),
 
64
                                   tcflag_t, ECHO, tcsetattr(),
 
65
                                   TCSAFLUSH */
 
66
#include <signal.h>             /* struct sigaction, sigemptyset(),
 
67
                                   sigaddset(), SIGINT, SIGHUP,
 
68
                                   SIGTERM, SIG_IGN, SIG_DFL,
36
69
                                   raise() */
37
 
#include <stddef.h>             /* NULL, size_t, ssize_t */
38
 
#include <sys/types.h>          /* ssize_t, struct dirent, pid_t,
39
 
                                   ssize_t, open() */
40
 
#include <stdlib.h>             /* EXIT_SUCCESS, EXIT_FAILURE,
41
 
                                   getenv(), free() */
42
 
#include <dirent.h>             /* scandir(), alphasort() */
43
 
#include <stdio.h>              /* fprintf(), stderr, getline(),
44
 
                                   stdin, feof(), fputc(), vfprintf(),
45
 
                                   vasprintf() */
46
 
#include <errno.h>              /* errno, EBADF, ENOTTY, EINVAL,
47
 
                                   EFAULT, EFBIG, EIO, ENOSPC, EINTR
48
 
                                */
49
 
#include <error.h>              /* error() */
50
 
#include <iso646.h>             /* or, not */
51
 
#include <stdbool.h>            /* bool, false, true */
52
 
#include <inttypes.h>           /* strtoumax() */
53
 
#include <sys/stat.h>           /* struct stat, lstat(), open() */
54
 
#include <string.h>             /* strlen, rindex, memcmp, strerror()
55
 
                                 */
56
 
#include <argp.h>               /* struct argp_option, struct
57
 
                                   argp_state, struct argp,
58
 
                                   argp_parse(), error_t,
59
 
                                   ARGP_KEY_ARG, ARGP_KEY_END,
60
 
                                   ARGP_ERR_UNKNOWN */
61
 
#include <sysexits.h>           /* EX_SOFTWARE, EX_OSERR,
62
 
                                   EX_UNAVAILABLE, EX_IOERR, EX_OK */
63
 
#include <fcntl.h>              /* open() */
64
 
#include <stdarg.h>             /* va_list, va_start(), ... */
 
70
#include <sysexits.h>           /* EX_OSERR, EX_USAGE, EX_UNAVAILABLE,
 
71
                                   EX_IOERR, EX_OSFILE, EX_OK */
65
72
 
66
73
volatile sig_atomic_t quit_now = 0;
67
74
int signal_received;
68
75
bool debug = false;
69
76
const char *argp_program_version = "password-prompt " VERSION;
70
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
 
77
const char *argp_program_bug_address = "<mandos@recompile.se>";
71
78
 
72
79
/* Needed for conflict resolution */
73
80
const char plymouth_name[] = "plymouthd";
74
81
 
75
82
/* Function to use when printing errors */
 
83
__attribute__((format (gnu_printf, 3, 4)))
76
84
void error_plus(int status, int errnum, const char *formatstring,
77
85
                ...){
78
86
  va_list ap;
81
89
  
82
90
  va_start(ap, formatstring);
83
91
  ret = vasprintf(&text, formatstring, ap);
84
 
  if (ret == -1){
 
92
  if(ret == -1){
85
93
    fprintf(stderr, "Mandos plugin %s: ",
86
94
            program_invocation_short_name);
87
95
    vfprintf(stderr, formatstring, ap);
88
 
    fprintf(stderr, ": ");
89
 
    fprintf(stderr, "%s\n", strerror(errnum));
 
96
    fprintf(stderr, ": %s\n", strerror(errnum));
90
97
    error(status, errno, "vasprintf while printing error");
91
98
    return;
92
99
  }
109
116
     from the terminal.  Password-prompt will exit if it detects
110
117
     plymouth since plymouth performs the same functionality.
111
118
   */
 
119
  if(access("/run/plymouth/pid", R_OK) == 0){
 
120
    return true;
 
121
  }
 
122
  
 
123
  __attribute__((nonnull))
112
124
  int is_plymouth(const struct dirent *proc_entry){
113
125
    int ret;
114
126
    int cl_fd;
115
127
    {
116
 
      uintmax_t maxvalue;
 
128
      uintmax_t proc_id;
117
129
      char *tmp;
118
130
      errno = 0;
119
 
      maxvalue = strtoumax(proc_entry->d_name, &tmp, 10);
 
131
      proc_id = strtoumax(proc_entry->d_name, &tmp, 10);
120
132
      
121
133
      if(errno != 0 or *tmp != '\0'
122
 
         or maxvalue != (uintmax_t)((pid_t)maxvalue)){
 
134
         or proc_id != (uintmax_t)((pid_t)proc_id)){
123
135
        return 0;
124
136
      }
125
137
    }
128
140
    ret = asprintf(&cmdline_filename, "/proc/%s/cmdline",
129
141
                   proc_entry->d_name);
130
142
    if(ret == -1){
131
 
      error(0, errno, "asprintf");
 
143
      error_plus(0, errno, "asprintf");
132
144
      return 0;
133
145
    }
134
146
    
137
149
    free(cmdline_filename);
138
150
    if(cl_fd == -1){
139
151
      if(errno != ENOENT){
140
 
        error(0, errno, "open");
 
152
        error_plus(0, errno, "open");
141
153
      }
142
154
      return 0;
143
155
    }
154
166
        if(cmdline_len + blocksize + 1 > cmdline_allocated){
155
167
          tmp = realloc(cmdline, cmdline_allocated + blocksize + 1);
156
168
          if(tmp == NULL){
157
 
            error(0, errno, "realloc");
 
169
            error_plus(0, errno, "realloc");
158
170
            free(cmdline);
159
171
            close(cl_fd);
160
172
            return 0;
167
179
        sret = read(cl_fd, cmdline + cmdline_len,
168
180
                    cmdline_allocated - cmdline_len);
169
181
        if(sret == -1){
170
 
          error(0, errno, "read");
 
182
          error_plus(0, errno, "read");
171
183
          free(cmdline);
172
184
          close(cl_fd);
173
185
          return 0;
176
188
      } while(sret != 0);
177
189
      ret = close(cl_fd);
178
190
      if(ret == -1){
179
 
        error(0, errno, "close");
 
191
        error_plus(0, errno, "close");
180
192
        free(cmdline);
181
193
        return 0;
182
194
      }
211
223
  struct dirent **direntries = NULL;
212
224
  int ret;
213
225
  ret = scandir("/proc", &direntries, is_plymouth, alphasort);
214
 
  if (ret == -1){
215
 
    error(1, errno, "scandir");
 
226
  if(ret == -1){
 
227
    error_plus(1, errno, "scandir");
 
228
  }
 
229
  {
 
230
    int i = ret;
 
231
    while(i--){
 
232
      free(direntries[i]);
 
233
    }
216
234
  }
217
235
  free(direntries);
218
236
  return ret > 0;
226
244
  struct termios t_new, t_old;
227
245
  char *buffer = NULL;
228
246
  char *prefix = NULL;
 
247
  char *prompt = NULL;
229
248
  int status = EXIT_SUCCESS;
230
249
  struct sigaction old_action,
231
250
    new_action = { .sa_handler = termination_handler,
235
254
      { .name = "prefix", .key = 'p',
236
255
        .arg = "PREFIX", .flags = 0,
237
256
        .doc = "Prefix shown before the prompt", .group = 2 },
 
257
      { .name = "prompt", .key = 129,
 
258
        .arg = "PROMPT", .flags = 0,
 
259
        .doc = "The prompt to show", .group = 2 },
238
260
      { .name = "debug", .key = 128,
239
261
        .doc = "Debug mode", .group = 3 },
240
262
      /*
249
271
      { .name = NULL }
250
272
    };
251
273
    
 
274
    __attribute__((nonnull(3)))
252
275
    error_t parse_opt (int key, char *arg, struct argp_state *state){
253
276
      errno = 0;
254
277
      switch (key){
255
 
      case 'p':
 
278
      case 'p':                 /* --prefix */
256
279
        prefix = arg;
257
280
        break;
258
 
      case 128:
 
281
      case 128:                 /* --debug */
259
282
        debug = true;
260
283
        break;
 
284
      case 129:                 /* --prompt */
 
285
        prompt = arg;
 
286
        break;
261
287
        /*
262
288
         * These reproduce what we would get without ARGP_NO_HELP
263
289
         */
265
291
        argp_state_help(state, state->out_stream,
266
292
                        (ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
267
293
                        & ~(unsigned int)ARGP_HELP_EXIT_OK);
 
294
        __builtin_unreachable();
268
295
      case -3:                  /* --usage */
269
296
        argp_state_help(state, state->out_stream,
270
297
                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
 
298
        __builtin_unreachable();
271
299
      case 'V':                 /* --version */
272
300
        fprintf(state->out_stream, "%s\n", argp_program_version);
273
301
        exit(argp_err_exit_status);
290
318
    case ENOMEM:
291
319
    default:
292
320
      errno = ret;
293
 
      error(0, errno, "argp_parse");
 
321
      error_plus(0, errno, "argp_parse");
294
322
      return EX_OSERR;
295
323
    case EINVAL:
296
324
      return EX_USAGE;
301
329
    fprintf(stderr, "Starting %s\n", argv[0]);
302
330
  }
303
331
 
304
 
  if (conflict_detection()){
 
332
  if(conflict_detection()){
305
333
    if(debug){
306
334
      fprintf(stderr, "Stopping %s because of conflict\n", argv[0]);
307
335
    }
314
342
  
315
343
  if(tcgetattr(STDIN_FILENO, &t_old) != 0){
316
344
    int e = errno;
317
 
    error(0, errno, "tcgetattr");
 
345
    error_plus(0, errno, "tcgetattr");
318
346
    switch(e){
319
347
    case EBADF:
320
348
    case ENOTTY:
327
355
  sigemptyset(&new_action.sa_mask);
328
356
  ret = sigaddset(&new_action.sa_mask, SIGINT);
329
357
  if(ret == -1){
330
 
    error(0, errno, "sigaddset");
 
358
    error_plus(0, errno, "sigaddset");
331
359
    return EX_OSERR;
332
360
  }
333
361
  ret = sigaddset(&new_action.sa_mask, SIGHUP);
334
362
  if(ret == -1){
335
 
    error(0, errno, "sigaddset");
 
363
    error_plus(0, errno, "sigaddset");
336
364
    return EX_OSERR;
337
365
  }
338
366
  ret = sigaddset(&new_action.sa_mask, SIGTERM);
339
367
  if(ret == -1){
340
 
    error(0, errno, "sigaddset");
 
368
    error_plus(0, errno, "sigaddset");
341
369
    return EX_OSERR;
342
370
  }
343
371
  /* Need to check if the handler is SIG_IGN before handling:
346
374
  */
347
375
  ret = sigaction(SIGINT, NULL, &old_action);
348
376
  if(ret == -1){
349
 
    error(0, errno, "sigaction");
 
377
    error_plus(0, errno, "sigaction");
350
378
    return EX_OSERR;
351
379
  }
352
380
  if(old_action.sa_handler != SIG_IGN){
353
381
    ret = sigaction(SIGINT, &new_action, NULL);
354
382
    if(ret == -1){
355
 
      error(0, errno, "sigaction");
 
383
      error_plus(0, errno, "sigaction");
356
384
      return EX_OSERR;
357
385
    }
358
386
  }
359
387
  ret = sigaction(SIGHUP, NULL, &old_action);
360
388
  if(ret == -1){
361
 
    error(0, errno, "sigaction");
 
389
    error_plus(0, errno, "sigaction");
362
390
    return EX_OSERR;
363
391
  }
364
392
  if(old_action.sa_handler != SIG_IGN){
365
393
    ret = sigaction(SIGHUP, &new_action, NULL);
366
394
    if(ret == -1){
367
 
      error(0, errno, "sigaction");
 
395
      error_plus(0, errno, "sigaction");
368
396
      return EX_OSERR;
369
397
    }
370
398
  }
371
399
  ret = sigaction(SIGTERM, NULL, &old_action);
372
400
  if(ret == -1){
373
 
    error(0, errno, "sigaction");
 
401
    error_plus(0, errno, "sigaction");
374
402
    return EX_OSERR;
375
403
  }
376
404
  if(old_action.sa_handler != SIG_IGN){
377
405
    ret = sigaction(SIGTERM, &new_action, NULL);
378
406
    if(ret == -1){
379
 
      error(0, errno, "sigaction");
 
407
      error_plus(0, errno, "sigaction");
380
408
      return EX_OSERR;
381
409
    }
382
410
  }
390
418
  t_new.c_lflag &= ~(tcflag_t)ECHO;
391
419
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_new) != 0){
392
420
    int e = errno;
393
 
    error(0, errno, "tcsetattr-echo");
 
421
    error_plus(0, errno, "tcsetattr-echo");
394
422
    switch(e){
395
423
    case EBADF:
396
424
    case ENOTTY:
416
444
    if(prefix){
417
445
      fprintf(stderr, "%s ", prefix);
418
446
    }
419
 
    {
 
447
    if(prompt != NULL){
 
448
      fprintf(stderr, "%s: ", prompt);
 
449
    } else {
420
450
      const char *cryptsource = getenv("CRYPTTAB_SOURCE");
421
451
      const char *crypttarget = getenv("CRYPTTAB_NAME");
422
452
      /* Before cryptsetup 1.1.0~rc2 */
460
490
        sret = write(STDOUT_FILENO, buffer + written, n - written);
461
491
        if(sret < 0){
462
492
          int e = errno;
463
 
          error(0, errno, "write");
 
493
          error_plus(0, errno, "write");
464
494
          switch(e){
465
495
          case EBADF:
466
496
          case EFAULT:
482
512
      sret = close(STDOUT_FILENO);
483
513
      if(sret == -1){
484
514
        int e = errno;
485
 
        error(0, errno, "close");
 
515
        error_plus(0, errno, "close");
486
516
        switch(e){
487
517
        case EBADF:
488
518
          status = EX_OSFILE;
497
527
    }
498
528
    if(sret < 0){
499
529
      int e = errno;
500
 
      if(errno != EINTR and not feof(stdin)){
501
 
        error(0, errno, "getline");
502
 
        switch(e){
503
 
        case EBADF:
504
 
          status = EX_UNAVAILABLE;
505
 
        case EIO:
506
 
        case EINVAL:
507
 
        default:
508
 
          status = EX_IOERR;
 
530
      if(errno != EINTR){
 
531
        if(not feof(stdin)){
 
532
          error_plus(0, errno, "getline");
 
533
          switch(e){
 
534
          case EBADF:
 
535
            status = EX_UNAVAILABLE;
 
536
            break;
 
537
          case EIO:
 
538
          case EINVAL:
 
539
          default:
 
540
            status = EX_IOERR;
 
541
            break;
 
542
          }
509
543
          break;
 
544
        } else {
 
545
          clearerr(stdin);
510
546
        }
511
 
        break;
512
547
      }
513
548
    }
514
549
    /* if(sret == 0), then the only sensible thing to do is to retry
527
562
    fprintf(stderr, "Restoring terminal attributes\n");
528
563
  }
529
564
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_old) != 0){
530
 
    error(0, errno, "tcsetattr+echo");
 
565
    error_plus(0, errno, "tcsetattr+echo");
531
566
  }
532
567
  
533
568
  if(quit_now){
535
570
    old_action.sa_handler = SIG_DFL;
536
571
    ret = sigaction(signal_received, &old_action, NULL);
537
572
    if(ret == -1){
538
 
      error(0, errno, "sigaction");
 
573
      error_plus(0, errno, "sigaction");
539
574
    }
540
575
    raise(signal_received);
541
576
  }