/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: 2019-03-12 20:13:34 UTC
  • Revision ID: teddy@recompile.se-20190312201334-my3htrprewjosuw5
mandos-ctl: Refactor

* mandos-ctl: Reorder everything into logical order; put main() first,
              and put every subsequent definition as soon as possible
              after its first use, except superclasses which need to
              be placed before the classes inheriting from them.
              Reorder all tests to match.

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 Teddy Hogeborn
 
6
 * Copyright © 2008-2019 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
#define _GNU_SOURCE             /* getline(), asprintf() */
26
27
 
27
 
#include <termios.h>            /* struct termios, tcsetattr(),
 
28
#include <termios.h>            /* struct termios, tcsetattr(),
28
29
                                   TCSAFLUSH, tcgetattr(), ECHO */
29
30
#include <unistd.h>             /* struct termios, tcsetattr(),
30
31
                                   STDIN_FILENO, TCSAFLUSH,
31
 
                                   tcgetattr(), ECHO */
 
32
                                   tcgetattr(), ECHO, readlink() */
32
33
#include <signal.h>             /* sig_atomic_t, raise(), struct
33
34
                                   sigaction, sigemptyset(),
34
35
                                   sigaction(), sigaddset(), SIGINT,
35
36
                                   SIGQUIT, SIGHUP, SIGTERM,
36
37
                                   raise() */
37
38
#include <stddef.h>             /* NULL, size_t, ssize_t */
38
 
#include <sys/types.h>          /* ssize_t */
 
39
#include <sys/types.h>          /* ssize_t, struct dirent, pid_t,
 
40
                                   ssize_t, open() */
39
41
#include <stdlib.h>             /* EXIT_SUCCESS, EXIT_FAILURE,
40
 
                                   getenv() */
 
42
                                   getenv(), free() */
 
43
#include <dirent.h>             /* scandir(), alphasort() */
41
44
#include <stdio.h>              /* fprintf(), stderr, getline(),
42
 
                                   stdin, feof(), perror(), fputc()
43
 
                                */
 
45
                                   stdin, feof(), fputc(), vfprintf(),
 
46
                                   vasprintf() */
44
47
#include <errno.h>              /* errno, EBADF, ENOTTY, EINVAL,
45
48
                                   EFAULT, EFBIG, EIO, ENOSPC, EINTR
46
49
                                */
 
50
#include <error.h>              /* error() */
47
51
#include <iso646.h>             /* or, not */
48
52
#include <stdbool.h>            /* bool, false, true */
49
 
#include <string.h>             /* strlen, rindex, strncmp, strcmp */
 
53
#include <inttypes.h>           /* strtoumax() */
 
54
#include <sys/stat.h>           /* struct stat, lstat(), open() */
 
55
#include <string.h>             /* strlen, rindex, memcmp, strerror()
 
56
                                 */
50
57
#include <argp.h>               /* struct argp_option, struct
51
58
                                   argp_state, struct argp,
52
59
                                   argp_parse(), error_t,
54
61
                                   ARGP_ERR_UNKNOWN */
55
62
#include <sysexits.h>           /* EX_SOFTWARE, EX_OSERR,
56
63
                                   EX_UNAVAILABLE, EX_IOERR, EX_OK */
 
64
#include <fcntl.h>              /* open() */
 
65
#include <stdarg.h>             /* va_list, va_start(), ... */
57
66
 
58
67
volatile sig_atomic_t quit_now = 0;
59
68
int signal_received;
60
69
bool debug = false;
61
70
const char *argp_program_version = "password-prompt " VERSION;
62
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
 
71
const char *argp_program_bug_address = "<mandos@recompile.se>";
 
72
 
 
73
/* Needed for conflict resolution */
 
74
const char plymouth_name[] = "plymouthd";
 
75
 
 
76
/* Function to use when printing errors */
 
77
__attribute__((format (gnu_printf, 3, 4)))
 
78
void error_plus(int status, int errnum, const char *formatstring,
 
79
                ...){
 
80
  va_list ap;
 
81
  char *text;
 
82
  int ret;
 
83
  
 
84
  va_start(ap, formatstring);
 
85
  ret = vasprintf(&text, formatstring, ap);
 
86
  if(ret == -1){
 
87
    fprintf(stderr, "Mandos plugin %s: ",
 
88
            program_invocation_short_name);
 
89
    vfprintf(stderr, formatstring, ap);
 
90
    fprintf(stderr, ": %s\n", strerror(errnum));
 
91
    error(status, errno, "vasprintf while printing error");
 
92
    return;
 
93
  }
 
94
  fprintf(stderr, "Mandos plugin ");
 
95
  error(status, errnum, "%s", text);
 
96
  free(text);
 
97
}
63
98
 
64
99
static void termination_handler(int signum){
65
100
  if(quit_now){
69
104
  signal_received = signum;
70
105
}
71
106
 
 
107
bool conflict_detection(void){
 
108
 
 
109
  /* plymouth conflicts with password-prompt since both want to read
 
110
     from the terminal.  Password-prompt will exit if it detects
 
111
     plymouth since plymouth performs the same functionality.
 
112
   */
 
113
  __attribute__((nonnull))
 
114
  int is_plymouth(const struct dirent *proc_entry){
 
115
    int ret;
 
116
    int cl_fd;
 
117
    {
 
118
      uintmax_t proc_id;
 
119
      char *tmp;
 
120
      errno = 0;
 
121
      proc_id = strtoumax(proc_entry->d_name, &tmp, 10);
 
122
      
 
123
      if(errno != 0 or *tmp != '\0'
 
124
         or proc_id != (uintmax_t)((pid_t)proc_id)){
 
125
        return 0;
 
126
      }
 
127
    }
 
128
    
 
129
    char *cmdline_filename;
 
130
    ret = asprintf(&cmdline_filename, "/proc/%s/cmdline",
 
131
                   proc_entry->d_name);
 
132
    if(ret == -1){
 
133
      error_plus(0, errno, "asprintf");
 
134
      return 0;
 
135
    }
 
136
    
 
137
    /* Open /proc/<pid>/cmdline */
 
138
    cl_fd = open(cmdline_filename, O_RDONLY);
 
139
    free(cmdline_filename);
 
140
    if(cl_fd == -1){
 
141
      if(errno != ENOENT){
 
142
        error_plus(0, errno, "open");
 
143
      }
 
144
      return 0;
 
145
    }
 
146
    
 
147
    char *cmdline = NULL;
 
148
    {
 
149
      size_t cmdline_len = 0;
 
150
      size_t cmdline_allocated = 0;
 
151
      char *tmp;
 
152
      const size_t blocksize = 1024;
 
153
      ssize_t sret;
 
154
      do {
 
155
        /* Allocate more space? */
 
156
        if(cmdline_len + blocksize + 1 > cmdline_allocated){
 
157
          tmp = realloc(cmdline, cmdline_allocated + blocksize + 1);
 
158
          if(tmp == NULL){
 
159
            error_plus(0, errno, "realloc");
 
160
            free(cmdline);
 
161
            close(cl_fd);
 
162
            return 0;
 
163
          }
 
164
          cmdline = tmp;
 
165
          cmdline_allocated += blocksize;
 
166
        }
 
167
        
 
168
        /* Read data */
 
169
        sret = read(cl_fd, cmdline + cmdline_len,
 
170
                    cmdline_allocated - cmdline_len);
 
171
        if(sret == -1){
 
172
          error_plus(0, errno, "read");
 
173
          free(cmdline);
 
174
          close(cl_fd);
 
175
          return 0;
 
176
        }
 
177
        cmdline_len += (size_t)sret;
 
178
      } while(sret != 0);
 
179
      ret = close(cl_fd);
 
180
      if(ret == -1){
 
181
        error_plus(0, errno, "close");
 
182
        free(cmdline);
 
183
        return 0;
 
184
      }
 
185
      cmdline[cmdline_len] = '\0'; /* Make sure it is terminated */
 
186
    }
 
187
    /* we now have cmdline */
 
188
    
 
189
    /* get basename */
 
190
    char *cmdline_base = strrchr(cmdline, '/');
 
191
    if(cmdline_base != NULL){
 
192
      cmdline_base += 1;                /* skip the slash */
 
193
    } else {
 
194
      cmdline_base = cmdline;
 
195
    }
 
196
    
 
197
    if(strcmp(cmdline_base, plymouth_name) != 0){
 
198
      if(debug){
 
199
        fprintf(stderr, "\"%s\" is not \"%s\"\n", cmdline_base,
 
200
                plymouth_name);
 
201
      }
 
202
      free(cmdline);
 
203
      return 0;
 
204
    }
 
205
    if(debug){
 
206
      fprintf(stderr, "\"%s\" equals \"%s\"\n", cmdline_base,
 
207
              plymouth_name);
 
208
    }
 
209
    free(cmdline);
 
210
    return 1;
 
211
  }
 
212
  
 
213
  struct dirent **direntries = NULL;
 
214
  int ret;
 
215
  ret = scandir("/proc", &direntries, is_plymouth, alphasort);
 
216
  if(ret == -1){
 
217
    error_plus(1, errno, "scandir");
 
218
  }
 
219
  {
 
220
    int i = ret;
 
221
    while(i--){
 
222
      free(direntries[i]);
 
223
    }
 
224
  }
 
225
  free(direntries);
 
226
  return ret > 0;
 
227
}
 
228
 
 
229
 
72
230
int main(int argc, char **argv){
73
 
  ssize_t ret;
 
231
  ssize_t sret;
 
232
  int ret;
74
233
  size_t n;
75
234
  struct termios t_new, t_old;
76
235
  char *buffer = NULL;
98
257
      { .name = NULL }
99
258
    };
100
259
    
 
260
    __attribute__((nonnull(3)))
101
261
    error_t parse_opt (int key, char *arg, struct argp_state *state){
102
262
      errno = 0;
103
263
      switch (key){
114
274
        argp_state_help(state, state->out_stream,
115
275
                        (ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
116
276
                        & ~(unsigned int)ARGP_HELP_EXIT_OK);
 
277
        __builtin_unreachable();
117
278
      case -3:                  /* --usage */
118
279
        argp_state_help(state, state->out_stream,
119
280
                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
 
281
        __builtin_unreachable();
120
282
      case 'V':                 /* --version */
121
283
        fprintf(state->out_stream, "%s\n", argp_program_version);
122
284
        exit(argp_err_exit_status);
139
301
    case ENOMEM:
140
302
    default:
141
303
      errno = ret;
142
 
      perror("argp_parse");
 
304
      error_plus(0, errno, "argp_parse");
143
305
      return EX_OSERR;
144
306
    case EINVAL:
145
307
      return EX_USAGE;
149
311
  if(debug){
150
312
    fprintf(stderr, "Starting %s\n", argv[0]);
151
313
  }
 
314
 
 
315
  if(conflict_detection()){
 
316
    if(debug){
 
317
      fprintf(stderr, "Stopping %s because of conflict\n", argv[0]);
 
318
    }
 
319
    return EXIT_FAILURE;
 
320
  }
 
321
  
152
322
  if(debug){
153
323
    fprintf(stderr, "Storing current terminal attributes\n");
154
324
  }
155
325
  
156
326
  if(tcgetattr(STDIN_FILENO, &t_old) != 0){
157
327
    int e = errno;
158
 
    perror("tcgetattr");
 
328
    error_plus(0, errno, "tcgetattr");
159
329
    switch(e){
160
330
    case EBADF:
161
331
    case ENOTTY:
168
338
  sigemptyset(&new_action.sa_mask);
169
339
  ret = sigaddset(&new_action.sa_mask, SIGINT);
170
340
  if(ret == -1){
171
 
    perror("sigaddset");
 
341
    error_plus(0, errno, "sigaddset");
172
342
    return EX_OSERR;
173
343
  }
174
344
  ret = sigaddset(&new_action.sa_mask, SIGHUP);
175
345
  if(ret == -1){
176
 
    perror("sigaddset");
 
346
    error_plus(0, errno, "sigaddset");
177
347
    return EX_OSERR;
178
348
  }
179
349
  ret = sigaddset(&new_action.sa_mask, SIGTERM);
180
350
  if(ret == -1){
181
 
    perror("sigaddset");
 
351
    error_plus(0, errno, "sigaddset");
182
352
    return EX_OSERR;
183
353
  }
184
354
  /* Need to check if the handler is SIG_IGN before handling:
187
357
  */
188
358
  ret = sigaction(SIGINT, NULL, &old_action);
189
359
  if(ret == -1){
190
 
    perror("sigaction");
 
360
    error_plus(0, errno, "sigaction");
191
361
    return EX_OSERR;
192
362
  }
193
363
  if(old_action.sa_handler != SIG_IGN){
194
364
    ret = sigaction(SIGINT, &new_action, NULL);
195
365
    if(ret == -1){
196
 
      perror("sigaction");
 
366
      error_plus(0, errno, "sigaction");
197
367
      return EX_OSERR;
198
368
    }
199
369
  }
200
370
  ret = sigaction(SIGHUP, NULL, &old_action);
201
371
  if(ret == -1){
202
 
    perror("sigaction");
 
372
    error_plus(0, errno, "sigaction");
203
373
    return EX_OSERR;
204
374
  }
205
375
  if(old_action.sa_handler != SIG_IGN){
206
376
    ret = sigaction(SIGHUP, &new_action, NULL);
207
377
    if(ret == -1){
208
 
      perror("sigaction");
 
378
      error_plus(0, errno, "sigaction");
209
379
      return EX_OSERR;
210
380
    }
211
381
  }
212
382
  ret = sigaction(SIGTERM, NULL, &old_action);
213
383
  if(ret == -1){
214
 
    perror("sigaction");
 
384
    error_plus(0, errno, "sigaction");
215
385
    return EX_OSERR;
216
386
  }
217
387
  if(old_action.sa_handler != SIG_IGN){
218
388
    ret = sigaction(SIGTERM, &new_action, NULL);
219
389
    if(ret == -1){
220
 
      perror("sigaction");
 
390
      error_plus(0, errno, "sigaction");
221
391
      return EX_OSERR;
222
392
    }
223
393
  }
231
401
  t_new.c_lflag &= ~(tcflag_t)ECHO;
232
402
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_new) != 0){
233
403
    int e = errno;
234
 
    perror("tcsetattr-echo");
 
404
    error_plus(0, errno, "tcsetattr-echo");
235
405
    switch(e){
236
406
    case EBADF:
237
407
    case ENOTTY:
258
428
      fprintf(stderr, "%s ", prefix);
259
429
    }
260
430
    {
261
 
      const char *cryptsource = getenv("cryptsource");
262
 
      const char *crypttarget = getenv("crypttarget");
263
 
      const char *const prompt
264
 
        = "Enter passphrase to unlock the disk";
 
431
      const char *cryptsource = getenv("CRYPTTAB_SOURCE");
 
432
      const char *crypttarget = getenv("CRYPTTAB_NAME");
 
433
      /* Before cryptsetup 1.1.0~rc2 */
 
434
      if(cryptsource == NULL){
 
435
        cryptsource = getenv("cryptsource");
 
436
      }
 
437
      if(crypttarget == NULL){
 
438
        crypttarget = getenv("crypttarget");
 
439
      }
 
440
      const char *const prompt1 = "Unlocking the disk";
 
441
      const char *const prompt2 = "Enter passphrase";
265
442
      if(cryptsource == NULL){
266
443
        if(crypttarget == NULL){
267
 
          fprintf(stderr, "%s: ", prompt);
 
444
          fprintf(stderr, "%s to unlock the disk: ", prompt2);
268
445
        } else {
269
 
          fprintf(stderr, "%s (%s): ", prompt, crypttarget);
 
446
          fprintf(stderr, "%s (%s)\n%s: ", prompt1, crypttarget,
 
447
                  prompt2);
270
448
        }
271
449
      } else {
272
450
        if(crypttarget == NULL){
273
 
          fprintf(stderr, "%s %s: ", prompt, cryptsource);
 
451
          fprintf(stderr, "%s %s\n%s: ", prompt1, cryptsource,
 
452
                  prompt2);
274
453
        } else {
275
 
          fprintf(stderr, "%s %s (%s): ", prompt, cryptsource,
276
 
                  crypttarget);
 
454
          fprintf(stderr, "%s %s (%s)\n%s: ", prompt1, cryptsource,
 
455
                  crypttarget, prompt2);
277
456
        }
278
457
      }
279
458
    }
280
 
    ret = getline(&buffer, &n, stdin);
281
 
    if(ret > 0){
 
459
    sret = getline(&buffer, &n, stdin);
 
460
    if(sret > 0){
282
461
      status = EXIT_SUCCESS;
283
462
      /* Make n = data size instead of allocated buffer size */
284
 
      n = (size_t)ret;
 
463
      n = (size_t)sret;
285
464
      /* Strip final newline */
286
465
      if(n > 0 and buffer[n-1] == '\n'){
287
466
        buffer[n-1] = '\0';     /* not strictly necessary */
289
468
      }
290
469
      size_t written = 0;
291
470
      while(written < n){
292
 
        ret = write(STDOUT_FILENO, buffer + written, n - written);
293
 
        if(ret < 0){
 
471
        sret = write(STDOUT_FILENO, buffer + written, n - written);
 
472
        if(sret < 0){
294
473
          int e = errno;
295
 
          perror("write");
 
474
          error_plus(0, errno, "write");
296
475
          switch(e){
297
476
          case EBADF:
298
477
          case EFAULT:
309
488
          }
310
489
          break;
311
490
        }
312
 
        written += (size_t)ret;
 
491
        written += (size_t)sret;
313
492
      }
314
 
      ret = close(STDOUT_FILENO);
315
 
      if(ret == -1){
 
493
      sret = close(STDOUT_FILENO);
 
494
      if(sret == -1){
316
495
        int e = errno;
317
 
        perror("close");
 
496
        error_plus(0, errno, "close");
318
497
        switch(e){
319
498
        case EBADF:
320
499
          status = EX_OSFILE;
327
506
      }
328
507
      break;
329
508
    }
330
 
    if(ret < 0){
 
509
    if(sret < 0){
331
510
      int e = errno;
332
511
      if(errno != EINTR and not feof(stdin)){
333
 
        perror("getline");
 
512
        error_plus(0, errno, "getline");
334
513
        switch(e){
335
514
        case EBADF:
336
515
          status = EX_UNAVAILABLE;
 
516
          break;
337
517
        case EIO:
338
518
        case EINVAL:
339
519
        default:
343
523
        break;
344
524
      }
345
525
    }
346
 
    /* if(ret == 0), then the only sensible thing to do is to retry to
347
 
       read from stdin */
 
526
    /* if(sret == 0), then the only sensible thing to do is to retry
 
527
       to read from stdin */
348
528
    fputc('\n', stderr);
349
529
    if(debug and not quit_now){
350
530
      /* If quit_now is nonzero, we were interrupted by a signal, and
359
539
    fprintf(stderr, "Restoring terminal attributes\n");
360
540
  }
361
541
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_old) != 0){
362
 
    perror("tcsetattr+echo");
 
542
    error_plus(0, errno, "tcsetattr+echo");
363
543
  }
364
544
  
365
545
  if(quit_now){
367
547
    old_action.sa_handler = SIG_DFL;
368
548
    ret = sigaction(signal_received, &old_action, NULL);
369
549
    if(ret == -1){
370
 
      perror("sigaction");
 
550
      error_plus(0, errno, "sigaction");
371
551
    }
372
552
    raise(signal_received);
373
553
  }