/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 plugins.d/password-prompt.c

  • Committer: Teddy Hogeborn
  • Date: 2024-09-09 04:24:39 UTC
  • mto: This revision was merged to the branch mainline in revision 410.
  • Revision ID: teddy@recompile.se-20240909042439-j85mr20uli2hnyis
Eliminate compiler warnings

Many programs use nested functions, which now result in a linker
warning about executable stack.  Hide this warning.  Also, rewrite a
loop in the plymouth plugin to avoid warning about signed overflow.
This change also makes the plugin pick the alphabetically first
process entry instead of the last, in case many plymouth processes are
found (which should be unlikely).

* Makefile (plugin-runner, dracut-module/password-agent,
  plugins.d/password-prompt, plugins.d/mandos-client,
  plugins.d/plymouth): New target; set LDFLAGS to add "-Xlinker
  --no-warn-execstack".
* plugins.d/plymouth.c (get_pid): When no pid files are found, and we
  are looking through the process list, go though it from the start
  instead of from the end, i.e. in normal alphabetical order and not
  in reverse order.

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-2022 Teddy Hogeborn
 
6
 * Copyright © 2008-2019, 2021-2022 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()
45
 
                                */
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 */
55
 
#include <argp.h>               /* struct argp_option, struct
56
 
                                   argp_state, struct argp,
57
 
                                   argp_parse(), error_t,
58
 
                                   ARGP_KEY_ARG, ARGP_KEY_END,
59
 
                                   ARGP_ERR_UNKNOWN */
60
 
#include <sysexits.h>           /* EX_SOFTWARE, EX_OSERR,
61
 
                                   EX_UNAVAILABLE, EX_IOERR, EX_OK */
62
 
#include <fcntl.h>              /* open() */
 
70
#include <sysexits.h>           /* EX_OSERR, EX_USAGE, EX_UNAVAILABLE,
 
71
                                   EX_IOERR, EX_OSFILE, EX_OK */
63
72
 
64
73
volatile sig_atomic_t quit_now = 0;
65
74
int signal_received;
66
75
bool debug = false;
67
76
const char *argp_program_version = "password-prompt " VERSION;
68
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
 
77
const char *argp_program_bug_address = "<mandos@recompile.se>";
69
78
 
70
79
/* Needed for conflict resolution */
71
80
const char plymouth_name[] = "plymouthd";
72
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
}
 
104
 
73
105
static void termination_handler(int signum){
74
106
  if(quit_now){
75
107
    return;
84
116
     from the terminal.  Password-prompt will exit if it detects
85
117
     plymouth since plymouth performs the same functionality.
86
118
   */
 
119
  if(access("/run/plymouth/pid", R_OK) == 0){
 
120
    return true;
 
121
  }
 
122
  
 
123
  __attribute__((nonnull))
87
124
  int is_plymouth(const struct dirent *proc_entry){
88
125
    int ret;
89
126
    int cl_fd;
90
127
    {
91
 
      uintmax_t maxvalue;
 
128
      uintmax_t proc_id;
92
129
      char *tmp;
93
130
      errno = 0;
94
 
      maxvalue = strtoumax(proc_entry->d_name, &tmp, 10);
 
131
      proc_id = strtoumax(proc_entry->d_name, &tmp, 10);
95
132
      
96
133
      if(errno != 0 or *tmp != '\0'
97
 
         or maxvalue != (uintmax_t)((pid_t)maxvalue)){
 
134
         or proc_id != (uintmax_t)((pid_t)proc_id)){
98
135
        return 0;
99
136
      }
100
137
    }
103
140
    ret = asprintf(&cmdline_filename, "/proc/%s/cmdline",
104
141
                   proc_entry->d_name);
105
142
    if(ret == -1){
106
 
      error(0, errno, "asprintf");
 
143
      error_plus(0, errno, "asprintf");
107
144
      return 0;
108
145
    }
109
146
    
111
148
    cl_fd = open(cmdline_filename, O_RDONLY);
112
149
    free(cmdline_filename);
113
150
    if(cl_fd == -1){
114
 
      error(0, errno, "open");
 
151
      if(errno != ENOENT){
 
152
        error_plus(0, errno, "open");
 
153
      }
115
154
      return 0;
116
155
    }
117
156
    
127
166
        if(cmdline_len + blocksize + 1 > cmdline_allocated){
128
167
          tmp = realloc(cmdline, cmdline_allocated + blocksize + 1);
129
168
          if(tmp == NULL){
130
 
            error(0, errno, "realloc");
 
169
            error_plus(0, errno, "realloc");
131
170
            free(cmdline);
132
171
            close(cl_fd);
133
172
            return 0;
140
179
        sret = read(cl_fd, cmdline + cmdline_len,
141
180
                    cmdline_allocated - cmdline_len);
142
181
        if(sret == -1){
143
 
          error(0, errno, "read");
 
182
          error_plus(0, errno, "read");
144
183
          free(cmdline);
145
184
          close(cl_fd);
146
185
          return 0;
149
188
      } while(sret != 0);
150
189
      ret = close(cl_fd);
151
190
      if(ret == -1){
152
 
        error(0, errno, "close");
 
191
        error_plus(0, errno, "close");
153
192
        free(cmdline);
154
193
        return 0;
155
194
      }
181
220
    return 1;
182
221
  }
183
222
  
184
 
  struct dirent **direntries;
 
223
  struct dirent **direntries = NULL;
185
224
  int ret;
186
225
  ret = scandir("/proc", &direntries, is_plymouth, alphasort);
187
 
  if (ret == -1){
188
 
    error(1, errno, "scandir");
189
 
  }
 
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);
190
236
  return ret > 0;
191
237
}
192
238
 
198
244
  struct termios t_new, t_old;
199
245
  char *buffer = NULL;
200
246
  char *prefix = NULL;
 
247
  char *prompt = NULL;
201
248
  int status = EXIT_SUCCESS;
202
249
  struct sigaction old_action,
203
250
    new_action = { .sa_handler = termination_handler,
207
254
      { .name = "prefix", .key = 'p',
208
255
        .arg = "PREFIX", .flags = 0,
209
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 },
210
260
      { .name = "debug", .key = 128,
211
261
        .doc = "Debug mode", .group = 3 },
212
262
      /*
221
271
      { .name = NULL }
222
272
    };
223
273
    
 
274
    __attribute__((nonnull(3)))
224
275
    error_t parse_opt (int key, char *arg, struct argp_state *state){
225
276
      errno = 0;
226
277
      switch (key){
227
 
      case 'p':
 
278
      case 'p':                 /* --prefix */
228
279
        prefix = arg;
229
280
        break;
230
 
      case 128:
 
281
      case 128:                 /* --debug */
231
282
        debug = true;
232
283
        break;
 
284
      case 129:                 /* --prompt */
 
285
        prompt = arg;
 
286
        break;
233
287
        /*
234
288
         * These reproduce what we would get without ARGP_NO_HELP
235
289
         */
237
291
        argp_state_help(state, state->out_stream,
238
292
                        (ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
239
293
                        & ~(unsigned int)ARGP_HELP_EXIT_OK);
 
294
        __builtin_unreachable();
240
295
      case -3:                  /* --usage */
241
296
        argp_state_help(state, state->out_stream,
242
297
                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
 
298
        __builtin_unreachable();
243
299
      case 'V':                 /* --version */
244
300
        fprintf(state->out_stream, "%s\n", argp_program_version);
245
301
        exit(argp_err_exit_status);
262
318
    case ENOMEM:
263
319
    default:
264
320
      errno = ret;
265
 
      error(0, errno, "argp_parse");
 
321
      error_plus(0, errno, "argp_parse");
266
322
      return EX_OSERR;
267
323
    case EINVAL:
268
324
      return EX_USAGE;
273
329
    fprintf(stderr, "Starting %s\n", argv[0]);
274
330
  }
275
331
 
276
 
  if (conflict_detection()){
 
332
  if(conflict_detection()){
277
333
    if(debug){
278
334
      fprintf(stderr, "Stopping %s because of conflict\n", argv[0]);
279
335
    }
286
342
  
287
343
  if(tcgetattr(STDIN_FILENO, &t_old) != 0){
288
344
    int e = errno;
289
 
    error(0, errno, "tcgetattr");
 
345
    error_plus(0, errno, "tcgetattr");
290
346
    switch(e){
291
347
    case EBADF:
292
348
    case ENOTTY:
299
355
  sigemptyset(&new_action.sa_mask);
300
356
  ret = sigaddset(&new_action.sa_mask, SIGINT);
301
357
  if(ret == -1){
302
 
    error(0, errno, "sigaddset");
 
358
    error_plus(0, errno, "sigaddset");
303
359
    return EX_OSERR;
304
360
  }
305
361
  ret = sigaddset(&new_action.sa_mask, SIGHUP);
306
362
  if(ret == -1){
307
 
    error(0, errno, "sigaddset");
 
363
    error_plus(0, errno, "sigaddset");
308
364
    return EX_OSERR;
309
365
  }
310
366
  ret = sigaddset(&new_action.sa_mask, SIGTERM);
311
367
  if(ret == -1){
312
 
    error(0, errno, "sigaddset");
 
368
    error_plus(0, errno, "sigaddset");
313
369
    return EX_OSERR;
314
370
  }
315
371
  /* Need to check if the handler is SIG_IGN before handling:
318
374
  */
319
375
  ret = sigaction(SIGINT, NULL, &old_action);
320
376
  if(ret == -1){
321
 
    error(0, errno, "sigaction");
 
377
    error_plus(0, errno, "sigaction");
322
378
    return EX_OSERR;
323
379
  }
324
380
  if(old_action.sa_handler != SIG_IGN){
325
381
    ret = sigaction(SIGINT, &new_action, NULL);
326
382
    if(ret == -1){
327
 
      error(0, errno, "sigaction");
 
383
      error_plus(0, errno, "sigaction");
328
384
      return EX_OSERR;
329
385
    }
330
386
  }
331
387
  ret = sigaction(SIGHUP, NULL, &old_action);
332
388
  if(ret == -1){
333
 
    error(0, errno, "sigaction");
 
389
    error_plus(0, errno, "sigaction");
334
390
    return EX_OSERR;
335
391
  }
336
392
  if(old_action.sa_handler != SIG_IGN){
337
393
    ret = sigaction(SIGHUP, &new_action, NULL);
338
394
    if(ret == -1){
339
 
      error(0, errno, "sigaction");
 
395
      error_plus(0, errno, "sigaction");
340
396
      return EX_OSERR;
341
397
    }
342
398
  }
343
399
  ret = sigaction(SIGTERM, NULL, &old_action);
344
400
  if(ret == -1){
345
 
    error(0, errno, "sigaction");
 
401
    error_plus(0, errno, "sigaction");
346
402
    return EX_OSERR;
347
403
  }
348
404
  if(old_action.sa_handler != SIG_IGN){
349
405
    ret = sigaction(SIGTERM, &new_action, NULL);
350
406
    if(ret == -1){
351
 
      error(0, errno, "sigaction");
 
407
      error_plus(0, errno, "sigaction");
352
408
      return EX_OSERR;
353
409
    }
354
410
  }
362
418
  t_new.c_lflag &= ~(tcflag_t)ECHO;
363
419
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_new) != 0){
364
420
    int e = errno;
365
 
    error(0, errno, "tcsetattr-echo");
 
421
    error_plus(0, errno, "tcsetattr-echo");
366
422
    switch(e){
367
423
    case EBADF:
368
424
    case ENOTTY:
388
444
    if(prefix){
389
445
      fprintf(stderr, "%s ", prefix);
390
446
    }
391
 
    {
 
447
    if(prompt != NULL){
 
448
      fprintf(stderr, "%s: ", prompt);
 
449
    } else {
392
450
      const char *cryptsource = getenv("CRYPTTAB_SOURCE");
393
451
      const char *crypttarget = getenv("CRYPTTAB_NAME");
394
452
      /* Before cryptsetup 1.1.0~rc2 */
432
490
        sret = write(STDOUT_FILENO, buffer + written, n - written);
433
491
        if(sret < 0){
434
492
          int e = errno;
435
 
          error(0, errno, "write");
 
493
          error_plus(0, errno, "write");
436
494
          switch(e){
437
495
          case EBADF:
438
496
          case EFAULT:
454
512
      sret = close(STDOUT_FILENO);
455
513
      if(sret == -1){
456
514
        int e = errno;
457
 
        error(0, errno, "close");
 
515
        error_plus(0, errno, "close");
458
516
        switch(e){
459
517
        case EBADF:
460
518
          status = EX_OSFILE;
469
527
    }
470
528
    if(sret < 0){
471
529
      int e = errno;
472
 
      if(errno != EINTR and not feof(stdin)){
473
 
        error(0, errno, "getline");
474
 
        switch(e){
475
 
        case EBADF:
476
 
          status = EX_UNAVAILABLE;
477
 
        case EIO:
478
 
        case EINVAL:
479
 
        default:
480
 
          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
          }
481
543
          break;
 
544
        } else {
 
545
          clearerr(stdin);
482
546
        }
483
 
        break;
484
547
      }
485
548
    }
486
549
    /* if(sret == 0), then the only sensible thing to do is to retry
499
562
    fprintf(stderr, "Restoring terminal attributes\n");
500
563
  }
501
564
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_old) != 0){
502
 
    error(0, errno, "tcsetattr+echo");
 
565
    error_plus(0, errno, "tcsetattr+echo");
503
566
  }
504
567
  
505
568
  if(quit_now){
507
570
    old_action.sa_handler = SIG_DFL;
508
571
    ret = sigaction(signal_received, &old_action, NULL);
509
572
    if(ret == -1){
510
 
      error(0, errno, "sigaction");
 
573
      error_plus(0, errno, "sigaction");
511
574
    }
512
575
    raise(signal_received);
513
576
  }