/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,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-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() */
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 */
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 */
39
 
#include <stdlib.h>             /* EXIT_SUCCESS, EXIT_FAILURE,
40
 
                                   getenv() */
41
 
#include <stdio.h>              /* fprintf(), stderr, getline(),
42
 
                                   stdin, feof(), fputc()
43
 
                                */
44
 
#include <errno.h>              /* errno, EBADF, ENOTTY, EINVAL,
45
 
                                   EFAULT, EFBIG, EIO, ENOSPC, EINTR
46
 
                                */
47
 
#include <error.h>              /* error() */
48
 
#include <iso646.h>             /* or, not */
49
 
#include <stdbool.h>            /* bool, false, true */
50
 
#include <string.h>             /* strlen, rindex */
51
 
#include <argp.h>               /* struct argp_option, struct
52
 
                                   argp_state, struct argp,
53
 
                                   argp_parse(), error_t,
54
 
                                   ARGP_KEY_ARG, ARGP_KEY_END,
55
 
                                   ARGP_ERR_UNKNOWN */
56
 
#include <sysexits.h>           /* EX_SOFTWARE, EX_OSERR,
57
 
                                   EX_UNAVAILABLE, EX_IOERR, EX_OK */
 
70
#include <sysexits.h>           /* EX_OSERR, EX_USAGE, EX_UNAVAILABLE,
 
71
                                   EX_IOERR, EX_OSFILE, EX_OK */
58
72
 
59
73
volatile sig_atomic_t quit_now = 0;
60
74
int signal_received;
61
75
bool debug = false;
62
76
const char *argp_program_version = "password-prompt " VERSION;
63
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
 
77
const char *argp_program_bug_address = "<mandos@recompile.se>";
 
78
 
 
79
/* Needed for conflict resolution */
 
80
const char plymouth_name[] = "plymouthd";
 
81
 
 
82
/* Function to use when printing errors */
 
83
__attribute__((format (gnu_printf, 3, 4)))
 
84
void error_plus(int status, int errnum, const char *formatstring,
 
85
                ...){
 
86
  va_list ap;
 
87
  char *text;
 
88
  int ret;
 
89
  
 
90
  va_start(ap, formatstring);
 
91
  ret = vasprintf(&text, formatstring, ap);
 
92
  if(ret == -1){
 
93
    fprintf(stderr, "Mandos plugin %s: ",
 
94
            program_invocation_short_name);
 
95
    vfprintf(stderr, formatstring, ap);
 
96
    fprintf(stderr, ": %s\n", strerror(errnum));
 
97
    error(status, errno, "vasprintf while printing error");
 
98
    return;
 
99
  }
 
100
  fprintf(stderr, "Mandos plugin ");
 
101
  error(status, errnum, "%s", text);
 
102
  free(text);
 
103
}
64
104
 
65
105
static void termination_handler(int signum){
66
106
  if(quit_now){
70
110
  signal_received = signum;
71
111
}
72
112
 
 
113
bool conflict_detection(void){
 
114
 
 
115
  /* plymouth conflicts with password-prompt since both want to read
 
116
     from the terminal.  Password-prompt will exit if it detects
 
117
     plymouth since plymouth performs the same functionality.
 
118
   */
 
119
  if(access("/run/plymouth/pid", R_OK) == 0){
 
120
    return true;
 
121
  }
 
122
  
 
123
  __attribute__((nonnull))
 
124
  int is_plymouth(const struct dirent *proc_entry){
 
125
    int ret;
 
126
    int cl_fd;
 
127
    {
 
128
      uintmax_t proc_id;
 
129
      char *tmp;
 
130
      errno = 0;
 
131
      proc_id = strtoumax(proc_entry->d_name, &tmp, 10);
 
132
      
 
133
      if(errno != 0 or *tmp != '\0'
 
134
         or proc_id != (uintmax_t)((pid_t)proc_id)){
 
135
        return 0;
 
136
      }
 
137
    }
 
138
    
 
139
    char *cmdline_filename;
 
140
    ret = asprintf(&cmdline_filename, "/proc/%s/cmdline",
 
141
                   proc_entry->d_name);
 
142
    if(ret == -1){
 
143
      error_plus(0, errno, "asprintf");
 
144
      return 0;
 
145
    }
 
146
    
 
147
    /* Open /proc/<pid>/cmdline */
 
148
    cl_fd = open(cmdline_filename, O_RDONLY);
 
149
    free(cmdline_filename);
 
150
    if(cl_fd == -1){
 
151
      if(errno != ENOENT){
 
152
        error_plus(0, errno, "open");
 
153
      }
 
154
      return 0;
 
155
    }
 
156
    
 
157
    char *cmdline = NULL;
 
158
    {
 
159
      size_t cmdline_len = 0;
 
160
      size_t cmdline_allocated = 0;
 
161
      char *tmp;
 
162
      const size_t blocksize = 1024;
 
163
      ssize_t sret;
 
164
      do {
 
165
        /* Allocate more space? */
 
166
        if(cmdline_len + blocksize + 1 > cmdline_allocated){
 
167
          tmp = realloc(cmdline, cmdline_allocated + blocksize + 1);
 
168
          if(tmp == NULL){
 
169
            error_plus(0, errno, "realloc");
 
170
            free(cmdline);
 
171
            close(cl_fd);
 
172
            return 0;
 
173
          }
 
174
          cmdline = tmp;
 
175
          cmdline_allocated += blocksize;
 
176
        }
 
177
        
 
178
        /* Read data */
 
179
        sret = read(cl_fd, cmdline + cmdline_len,
 
180
                    cmdline_allocated - cmdline_len);
 
181
        if(sret == -1){
 
182
          error_plus(0, errno, "read");
 
183
          free(cmdline);
 
184
          close(cl_fd);
 
185
          return 0;
 
186
        }
 
187
        cmdline_len += (size_t)sret;
 
188
      } while(sret != 0);
 
189
      ret = close(cl_fd);
 
190
      if(ret == -1){
 
191
        error_plus(0, errno, "close");
 
192
        free(cmdline);
 
193
        return 0;
 
194
      }
 
195
      cmdline[cmdline_len] = '\0'; /* Make sure it is terminated */
 
196
    }
 
197
    /* we now have cmdline */
 
198
    
 
199
    /* get basename */
 
200
    char *cmdline_base = strrchr(cmdline, '/');
 
201
    if(cmdline_base != NULL){
 
202
      cmdline_base += 1;                /* skip the slash */
 
203
    } else {
 
204
      cmdline_base = cmdline;
 
205
    }
 
206
    
 
207
    if(strcmp(cmdline_base, plymouth_name) != 0){
 
208
      if(debug){
 
209
        fprintf(stderr, "\"%s\" is not \"%s\"\n", cmdline_base,
 
210
                plymouth_name);
 
211
      }
 
212
      free(cmdline);
 
213
      return 0;
 
214
    }
 
215
    if(debug){
 
216
      fprintf(stderr, "\"%s\" equals \"%s\"\n", cmdline_base,
 
217
              plymouth_name);
 
218
    }
 
219
    free(cmdline);
 
220
    return 1;
 
221
  }
 
222
  
 
223
  struct dirent **direntries = NULL;
 
224
  int ret;
 
225
  ret = scandir("/proc", &direntries, is_plymouth, alphasort);
 
226
  if(ret == -1){
 
227
    error_plus(1, errno, "scandir");
 
228
  }
 
229
  {
 
230
    int i = ret;
 
231
    while(i--){
 
232
      free(direntries[i]);
 
233
    }
 
234
  }
 
235
  free(direntries);
 
236
  return ret > 0;
 
237
}
 
238
 
 
239
 
73
240
int main(int argc, char **argv){
74
241
  ssize_t sret;
75
242
  int ret;
77
244
  struct termios t_new, t_old;
78
245
  char *buffer = NULL;
79
246
  char *prefix = NULL;
 
247
  char *prompt = NULL;
80
248
  int status = EXIT_SUCCESS;
81
249
  struct sigaction old_action,
82
250
    new_action = { .sa_handler = termination_handler,
86
254
      { .name = "prefix", .key = 'p',
87
255
        .arg = "PREFIX", .flags = 0,
88
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 },
89
260
      { .name = "debug", .key = 128,
90
261
        .doc = "Debug mode", .group = 3 },
91
262
      /*
100
271
      { .name = NULL }
101
272
    };
102
273
    
 
274
    __attribute__((nonnull(3)))
103
275
    error_t parse_opt (int key, char *arg, struct argp_state *state){
104
276
      errno = 0;
105
277
      switch (key){
106
 
      case 'p':
 
278
      case 'p':                 /* --prefix */
107
279
        prefix = arg;
108
280
        break;
109
 
      case 128:
 
281
      case 128:                 /* --debug */
110
282
        debug = true;
111
283
        break;
 
284
      case 129:                 /* --prompt */
 
285
        prompt = arg;
 
286
        break;
112
287
        /*
113
288
         * These reproduce what we would get without ARGP_NO_HELP
114
289
         */
116
291
        argp_state_help(state, state->out_stream,
117
292
                        (ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
118
293
                        & ~(unsigned int)ARGP_HELP_EXIT_OK);
 
294
        __builtin_unreachable();
119
295
      case -3:                  /* --usage */
120
296
        argp_state_help(state, state->out_stream,
121
297
                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
 
298
        __builtin_unreachable();
122
299
      case 'V':                 /* --version */
123
300
        fprintf(state->out_stream, "%s\n", argp_program_version);
124
301
        exit(argp_err_exit_status);
141
318
    case ENOMEM:
142
319
    default:
143
320
      errno = ret;
144
 
      error(0, errno, "argp_parse");
 
321
      error_plus(0, errno, "argp_parse");
145
322
      return EX_OSERR;
146
323
    case EINVAL:
147
324
      return EX_USAGE;
151
328
  if(debug){
152
329
    fprintf(stderr, "Starting %s\n", argv[0]);
153
330
  }
 
331
 
 
332
  if(conflict_detection()){
 
333
    if(debug){
 
334
      fprintf(stderr, "Stopping %s because of conflict\n", argv[0]);
 
335
    }
 
336
    return EXIT_FAILURE;
 
337
  }
 
338
  
154
339
  if(debug){
155
340
    fprintf(stderr, "Storing current terminal attributes\n");
156
341
  }
157
342
  
158
343
  if(tcgetattr(STDIN_FILENO, &t_old) != 0){
159
344
    int e = errno;
160
 
    error(0, errno, "tcgetattr");
 
345
    error_plus(0, errno, "tcgetattr");
161
346
    switch(e){
162
347
    case EBADF:
163
348
    case ENOTTY:
170
355
  sigemptyset(&new_action.sa_mask);
171
356
  ret = sigaddset(&new_action.sa_mask, SIGINT);
172
357
  if(ret == -1){
173
 
    error(0, errno, "sigaddset");
 
358
    error_plus(0, errno, "sigaddset");
174
359
    return EX_OSERR;
175
360
  }
176
361
  ret = sigaddset(&new_action.sa_mask, SIGHUP);
177
362
  if(ret == -1){
178
 
    error(0, errno, "sigaddset");
 
363
    error_plus(0, errno, "sigaddset");
179
364
    return EX_OSERR;
180
365
  }
181
366
  ret = sigaddset(&new_action.sa_mask, SIGTERM);
182
367
  if(ret == -1){
183
 
    error(0, errno, "sigaddset");
 
368
    error_plus(0, errno, "sigaddset");
184
369
    return EX_OSERR;
185
370
  }
186
371
  /* Need to check if the handler is SIG_IGN before handling:
189
374
  */
190
375
  ret = sigaction(SIGINT, NULL, &old_action);
191
376
  if(ret == -1){
192
 
    error(0, errno, "sigaction");
 
377
    error_plus(0, errno, "sigaction");
193
378
    return EX_OSERR;
194
379
  }
195
380
  if(old_action.sa_handler != SIG_IGN){
196
381
    ret = sigaction(SIGINT, &new_action, NULL);
197
382
    if(ret == -1){
198
 
      error(0, errno, "sigaction");
 
383
      error_plus(0, errno, "sigaction");
199
384
      return EX_OSERR;
200
385
    }
201
386
  }
202
387
  ret = sigaction(SIGHUP, NULL, &old_action);
203
388
  if(ret == -1){
204
 
    error(0, errno, "sigaction");
 
389
    error_plus(0, errno, "sigaction");
205
390
    return EX_OSERR;
206
391
  }
207
392
  if(old_action.sa_handler != SIG_IGN){
208
393
    ret = sigaction(SIGHUP, &new_action, NULL);
209
394
    if(ret == -1){
210
 
      error(0, errno, "sigaction");
 
395
      error_plus(0, errno, "sigaction");
211
396
      return EX_OSERR;
212
397
    }
213
398
  }
214
399
  ret = sigaction(SIGTERM, NULL, &old_action);
215
400
  if(ret == -1){
216
 
    error(0, errno, "sigaction");
 
401
    error_plus(0, errno, "sigaction");
217
402
    return EX_OSERR;
218
403
  }
219
404
  if(old_action.sa_handler != SIG_IGN){
220
405
    ret = sigaction(SIGTERM, &new_action, NULL);
221
406
    if(ret == -1){
222
 
      error(0, errno, "sigaction");
 
407
      error_plus(0, errno, "sigaction");
223
408
      return EX_OSERR;
224
409
    }
225
410
  }
233
418
  t_new.c_lflag &= ~(tcflag_t)ECHO;
234
419
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_new) != 0){
235
420
    int e = errno;
236
 
    error(0, errno, "tcsetattr-echo");
 
421
    error_plus(0, errno, "tcsetattr-echo");
237
422
    switch(e){
238
423
    case EBADF:
239
424
    case ENOTTY:
259
444
    if(prefix){
260
445
      fprintf(stderr, "%s ", prefix);
261
446
    }
262
 
    {
 
447
    if(prompt != NULL){
 
448
      fprintf(stderr, "%s: ", prompt);
 
449
    } else {
263
450
      const char *cryptsource = getenv("CRYPTTAB_SOURCE");
264
451
      const char *crypttarget = getenv("CRYPTTAB_NAME");
265
452
      /* Before cryptsetup 1.1.0~rc2 */
303
490
        sret = write(STDOUT_FILENO, buffer + written, n - written);
304
491
        if(sret < 0){
305
492
          int e = errno;
306
 
          error(0, errno, "write");
 
493
          error_plus(0, errno, "write");
307
494
          switch(e){
308
495
          case EBADF:
309
496
          case EFAULT:
325
512
      sret = close(STDOUT_FILENO);
326
513
      if(sret == -1){
327
514
        int e = errno;
328
 
        error(0, errno, "close");
 
515
        error_plus(0, errno, "close");
329
516
        switch(e){
330
517
        case EBADF:
331
518
          status = EX_OSFILE;
340
527
    }
341
528
    if(sret < 0){
342
529
      int e = errno;
343
 
      if(errno != EINTR and not feof(stdin)){
344
 
        error(0, errno, "getline");
345
 
        switch(e){
346
 
        case EBADF:
347
 
          status = EX_UNAVAILABLE;
348
 
        case EIO:
349
 
        case EINVAL:
350
 
        default:
351
 
          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
          }
352
543
          break;
 
544
        } else {
 
545
          clearerr(stdin);
353
546
        }
354
 
        break;
355
547
      }
356
548
    }
357
 
    /* if(sret == 0), then the only sensible thing to do is to retry to
358
 
       read from stdin */
 
549
    /* if(sret == 0), then the only sensible thing to do is to retry
 
550
       to read from stdin */
359
551
    fputc('\n', stderr);
360
552
    if(debug and not quit_now){
361
553
      /* If quit_now is nonzero, we were interrupted by a signal, and
370
562
    fprintf(stderr, "Restoring terminal attributes\n");
371
563
  }
372
564
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_old) != 0){
373
 
    error(0, errno, "tcsetattr+echo");
 
565
    error_plus(0, errno, "tcsetattr+echo");
374
566
  }
375
567
  
376
568
  if(quit_now){
378
570
    old_action.sa_handler = SIG_DFL;
379
571
    ret = sigaction(signal_received, &old_action, NULL);
380
572
    if(ret == -1){
381
 
      error(0, errno, "sigaction");
 
573
      error_plus(0, errno, "sigaction");
382
574
    }
383
575
    raise(signal_received);
384
576
  }