/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: 2015-01-25 00:02:51 UTC
  • Revision ID: teddy@recompile.se-20150125000251-j2bw50gfq9smqyxe
mandos.xml (SEE ALSO): Update links.

Update link to GnuPG home page, change reference from TLS 1.1 to TLS
1.2, and change to latest RFC for using OpenPGP keys with TLS (and use
its correct title).

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