/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,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-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() */
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(), perror(), fputc()
43
 
                                */
44
 
#include <errno.h>              /* errno, EBADF, ENOTTY, EINVAL,
45
 
                                   EFAULT, EFBIG, EIO, ENOSPC, EINTR
46
 
                                */
47
 
#include <iso646.h>             /* or, not */
48
 
#include <stdbool.h>            /* bool, false, true */
49
 
#include <string.h>             /* strlen, rindex */
50
 
#include <argp.h>               /* struct argp_option, struct
51
 
                                   argp_state, struct argp,
52
 
                                   argp_parse(), error_t,
53
 
                                   ARGP_KEY_ARG, ARGP_KEY_END,
54
 
                                   ARGP_ERR_UNKNOWN */
55
 
#include <sysexits.h>           /* EX_SOFTWARE, EX_OSERR,
56
 
                                   EX_UNAVAILABLE, EX_IOERR, EX_OK */
 
70
#include <sysexits.h>           /* EX_OSERR, EX_USAGE, EX_UNAVAILABLE,
 
71
                                   EX_IOERR, EX_OSFILE, EX_OK */
57
72
 
58
73
volatile sig_atomic_t quit_now = 0;
59
74
int signal_received;
60
75
bool debug = false;
61
76
const char *argp_program_version = "password-prompt " VERSION;
62
 
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
}
63
104
 
64
105
static void termination_handler(int signum){
65
106
  if(quit_now){
69
110
  signal_received = signum;
70
111
}
71
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
 
72
240
int main(int argc, char **argv){
73
 
  ssize_t ret;
 
241
  ssize_t sret;
 
242
  int ret;
74
243
  size_t n;
75
244
  struct termios t_new, t_old;
76
245
  char *buffer = NULL;
77
246
  char *prefix = NULL;
 
247
  char *prompt = NULL;
78
248
  int status = EXIT_SUCCESS;
79
249
  struct sigaction old_action,
80
250
    new_action = { .sa_handler = termination_handler,
84
254
      { .name = "prefix", .key = 'p',
85
255
        .arg = "PREFIX", .flags = 0,
86
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 },
87
260
      { .name = "debug", .key = 128,
88
261
        .doc = "Debug mode", .group = 3 },
89
262
      /*
98
271
      { .name = NULL }
99
272
    };
100
273
    
 
274
    __attribute__((nonnull(3)))
101
275
    error_t parse_opt (int key, char *arg, struct argp_state *state){
102
276
      errno = 0;
103
277
      switch (key){
104
 
      case 'p':
 
278
      case 'p':                 /* --prefix */
105
279
        prefix = arg;
106
280
        break;
107
 
      case 128:
 
281
      case 128:                 /* --debug */
108
282
        debug = true;
109
283
        break;
 
284
      case 129:                 /* --prompt */
 
285
        prompt = arg;
 
286
        break;
110
287
        /*
111
288
         * These reproduce what we would get without ARGP_NO_HELP
112
289
         */
114
291
        argp_state_help(state, state->out_stream,
115
292
                        (ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
116
293
                        & ~(unsigned int)ARGP_HELP_EXIT_OK);
 
294
        __builtin_unreachable();
117
295
      case -3:                  /* --usage */
118
296
        argp_state_help(state, state->out_stream,
119
297
                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
 
298
        __builtin_unreachable();
120
299
      case 'V':                 /* --version */
121
300
        fprintf(state->out_stream, "%s\n", argp_program_version);
122
301
        exit(argp_err_exit_status);
139
318
    case ENOMEM:
140
319
    default:
141
320
      errno = ret;
142
 
      perror("argp_parse");
 
321
      error_plus(0, errno, "argp_parse");
143
322
      return EX_OSERR;
144
323
    case EINVAL:
145
324
      return EX_USAGE;
149
328
  if(debug){
150
329
    fprintf(stderr, "Starting %s\n", argv[0]);
151
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
  
152
339
  if(debug){
153
340
    fprintf(stderr, "Storing current terminal attributes\n");
154
341
  }
155
342
  
156
343
  if(tcgetattr(STDIN_FILENO, &t_old) != 0){
157
344
    int e = errno;
158
 
    perror("tcgetattr");
 
345
    error_plus(0, errno, "tcgetattr");
159
346
    switch(e){
160
347
    case EBADF:
161
348
    case ENOTTY:
168
355
  sigemptyset(&new_action.sa_mask);
169
356
  ret = sigaddset(&new_action.sa_mask, SIGINT);
170
357
  if(ret == -1){
171
 
    perror("sigaddset");
 
358
    error_plus(0, errno, "sigaddset");
172
359
    return EX_OSERR;
173
360
  }
174
361
  ret = sigaddset(&new_action.sa_mask, SIGHUP);
175
362
  if(ret == -1){
176
 
    perror("sigaddset");
 
363
    error_plus(0, errno, "sigaddset");
177
364
    return EX_OSERR;
178
365
  }
179
366
  ret = sigaddset(&new_action.sa_mask, SIGTERM);
180
367
  if(ret == -1){
181
 
    perror("sigaddset");
 
368
    error_plus(0, errno, "sigaddset");
182
369
    return EX_OSERR;
183
370
  }
184
371
  /* Need to check if the handler is SIG_IGN before handling:
187
374
  */
188
375
  ret = sigaction(SIGINT, NULL, &old_action);
189
376
  if(ret == -1){
190
 
    perror("sigaction");
 
377
    error_plus(0, errno, "sigaction");
191
378
    return EX_OSERR;
192
379
  }
193
380
  if(old_action.sa_handler != SIG_IGN){
194
381
    ret = sigaction(SIGINT, &new_action, NULL);
195
382
    if(ret == -1){
196
 
      perror("sigaction");
 
383
      error_plus(0, errno, "sigaction");
197
384
      return EX_OSERR;
198
385
    }
199
386
  }
200
387
  ret = sigaction(SIGHUP, NULL, &old_action);
201
388
  if(ret == -1){
202
 
    perror("sigaction");
 
389
    error_plus(0, errno, "sigaction");
203
390
    return EX_OSERR;
204
391
  }
205
392
  if(old_action.sa_handler != SIG_IGN){
206
393
    ret = sigaction(SIGHUP, &new_action, NULL);
207
394
    if(ret == -1){
208
 
      perror("sigaction");
 
395
      error_plus(0, errno, "sigaction");
209
396
      return EX_OSERR;
210
397
    }
211
398
  }
212
399
  ret = sigaction(SIGTERM, NULL, &old_action);
213
400
  if(ret == -1){
214
 
    perror("sigaction");
 
401
    error_plus(0, errno, "sigaction");
215
402
    return EX_OSERR;
216
403
  }
217
404
  if(old_action.sa_handler != SIG_IGN){
218
405
    ret = sigaction(SIGTERM, &new_action, NULL);
219
406
    if(ret == -1){
220
 
      perror("sigaction");
 
407
      error_plus(0, errno, "sigaction");
221
408
      return EX_OSERR;
222
409
    }
223
410
  }
231
418
  t_new.c_lflag &= ~(tcflag_t)ECHO;
232
419
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_new) != 0){
233
420
    int e = errno;
234
 
    perror("tcsetattr-echo");
 
421
    error_plus(0, errno, "tcsetattr-echo");
235
422
    switch(e){
236
423
    case EBADF:
237
424
    case ENOTTY:
257
444
    if(prefix){
258
445
      fprintf(stderr, "%s ", prefix);
259
446
    }
260
 
    {
 
447
    if(prompt != NULL){
 
448
      fprintf(stderr, "%s: ", prompt);
 
449
    } else {
261
450
      const char *cryptsource = getenv("CRYPTTAB_SOURCE");
262
451
      const char *crypttarget = getenv("CRYPTTAB_NAME");
263
452
      /* Before cryptsetup 1.1.0~rc2 */
286
475
        }
287
476
      }
288
477
    }
289
 
    ret = getline(&buffer, &n, stdin);
290
 
    if(ret > 0){
 
478
    sret = getline(&buffer, &n, stdin);
 
479
    if(sret > 0){
291
480
      status = EXIT_SUCCESS;
292
481
      /* Make n = data size instead of allocated buffer size */
293
 
      n = (size_t)ret;
 
482
      n = (size_t)sret;
294
483
      /* Strip final newline */
295
484
      if(n > 0 and buffer[n-1] == '\n'){
296
485
        buffer[n-1] = '\0';     /* not strictly necessary */
298
487
      }
299
488
      size_t written = 0;
300
489
      while(written < n){
301
 
        ret = write(STDOUT_FILENO, buffer + written, n - written);
302
 
        if(ret < 0){
 
490
        sret = write(STDOUT_FILENO, buffer + written, n - written);
 
491
        if(sret < 0){
303
492
          int e = errno;
304
 
          perror("write");
 
493
          error_plus(0, errno, "write");
305
494
          switch(e){
306
495
          case EBADF:
307
496
          case EFAULT:
318
507
          }
319
508
          break;
320
509
        }
321
 
        written += (size_t)ret;
 
510
        written += (size_t)sret;
322
511
      }
323
 
      ret = close(STDOUT_FILENO);
324
 
      if(ret == -1){
 
512
      sret = close(STDOUT_FILENO);
 
513
      if(sret == -1){
325
514
        int e = errno;
326
 
        perror("close");
 
515
        error_plus(0, errno, "close");
327
516
        switch(e){
328
517
        case EBADF:
329
518
          status = EX_OSFILE;
336
525
      }
337
526
      break;
338
527
    }
339
 
    if(ret < 0){
 
528
    if(sret < 0){
340
529
      int e = errno;
341
 
      if(errno != EINTR and not feof(stdin)){
342
 
        perror("getline");
343
 
        switch(e){
344
 
        case EBADF:
345
 
          status = EX_UNAVAILABLE;
346
 
        case EIO:
347
 
        case EINVAL:
348
 
        default:
349
 
          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
          }
350
543
          break;
 
544
        } else {
 
545
          clearerr(stdin);
351
546
        }
352
 
        break;
353
547
      }
354
548
    }
355
 
    /* if(ret == 0), then the only sensible thing to do is to retry to
356
 
       read from stdin */
 
549
    /* if(sret == 0), then the only sensible thing to do is to retry
 
550
       to read from stdin */
357
551
    fputc('\n', stderr);
358
552
    if(debug and not quit_now){
359
553
      /* If quit_now is nonzero, we were interrupted by a signal, and
368
562
    fprintf(stderr, "Restoring terminal attributes\n");
369
563
  }
370
564
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_old) != 0){
371
 
    perror("tcsetattr+echo");
 
565
    error_plus(0, errno, "tcsetattr+echo");
372
566
  }
373
567
  
374
568
  if(quit_now){
376
570
    old_action.sa_handler = SIG_DFL;
377
571
    ret = sigaction(signal_received, &old_action, NULL);
378
572
    if(ret == -1){
379
 
      perror("sigaction");
 
573
      error_plus(0, errno, "sigaction");
380
574
    }
381
575
    raise(signal_received);
382
576
  }