/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-02-09 23:23:26 UTC
  • Revision ID: teddy@recompile.se-20190209232326-z1z2kzpgfixz7iaj
Add support for using raw public keys in TLS (RFC 7250)

Since GnuTLS removed support for OpenPGP keys in TLS (RFC 6091), and
no other library supports it, we have to change the protocol to use
something else.  We choose to use "raw public keys" (RFC 7250).  Since
we still use OpenPGP keys to decrypt the secret password, this means
that each client will have two keys: One OpenPGP key and one TLS
public/private key, and the key ID of the latter key is used to
identify clients instead of the fingerprint of the OpenPGP key.

Note that this code is still compatible with GnuTLS before version
3.6.0 (when OpenPGP key support was removed).  This commit merely adds
support for using raw pulic keys instead with GnuTLS 3.6.6. or later.

* DBUS-API (Signals/ClientNotFound): Change name of first parameter
                                     from "Fingerprint" to "KeyID".
  (Mandos Client Interface/Properties/KeyID): New.
* INSTALL: Document conflict with GnuTLS 3.6.0 (which removed OpenPGP
           key support) up until 3.6.6, when support for raw public
           keys was added.  Also document new dependency of client on
           "gnutls-bin" package (for certtool).
* Makefile (run-client): Depend on TLS key files, and also pass them
                         as arguments to client.
  (keydir/tls-privkey.pem, keydir/tls-pubkey.pem): New.
  (confdir/clients.conf): Add dependency on TLS public key.
  (purge-client): Add removal of TLS key files.
* clients.conf ([foo]/key_id, [bar]/key_id): New.
* debian/control (Source: mandos/Build-Depends): Also allow
                                                 libgnutls30 (>= 3.6.6)
  (Package: mandos/Depends): - '' -
  (Package: mandos/Description): Alter description to match new
                                 design.
  (Package: mandos-client/Description): - '' -
  (Package: mandos-client/Depends): Move "gnutls-bin | openssl" to
                                    here from "Recommends".
* debian/mandos-client.README.Debian: Add --tls-privkey and
                                      --tls-pubkey options to test
                                      command.
* debian/mandos-client.postinst (create_key): Renamed to "create_keys"
                                             (all callers changed),
                                             and also create TLS key.
* debian/mandos-client.postrm (purge): Also remove TLS key files.
* intro.xml (DESCRIPTION): Describe new dual-key design.
* mandos (GnuTLS): Define different functions depending on whether
                   support for raw public keys is detected.
  (Client.key_id): New attribute.
  (ClientDBus.KeyID_dbus_property): New method.
  (ProxyClient.__init__): Take new "key_id" parameter.
  (ClientHandler.handle): Use key IDs when using raw public keys and
                          use fingerprints when using OpenPGP keys.
  (ClientHandler.peer_certificate): Also handle raw public keys.
  (ClientHandler.key_id): New.
  (MandosServer.handle_ipc): Pass key ID over the pipe IPC.  Also
                             check for key ID matches when looking up
                             clients.
  (main): Default GnuTLS priority string depends on whether we are
          using raw public keys or not.  When unpickling clients, set
          key_id if not set in the pickle.
  (main/MandosDBusService.ClientNotFound): Change name of first
                                           parameter from
                                           "Fingerprint" to "KeyID".
* mandos-clients.conf.xml (OPTIONS): Document new "key_id" option.
  (OPTIONS/secret): Mention new key ID matchning.
  (EXPANSION/RUNTIME EXPANSION): Add new "key_id" option.
  (EXAMPLE): - '' -
* mandos-ctl (tablewords, main/keywords): Add new "KeyID" property.
* mandos-keygen: Create TLS key files.  New "--tls-keytype" (-T)
                 option.  Alter help text to be more clear about key
                 types.  When in password mode, also output "key_id"
                 option.
* mandos-keygen.xml (SYNOPSIS): Add new "--tls-keytype" (-T) option.
  (DESCRIPTION): Alter to match new dual-key design.
  (OVERVIEW): - '' -
  (FILES): Add TLS key files.
* mandos-options.xml (priority): Document new default priority string
                                 when using raw public keys.
* mandos.xml (NETWORK PROTOCOL): Describe new protocol using key ID.
  (BUGS): Remove issue about checking expire times of OpenPGP keys,
          since TLS public keys do not have expiration times.
  (SECURITY/CLIENT): Alter description to match new design.
  (SEE ALSO/GnuTLS): - '' -
  (SEE ALSO): Add reference to RFC 7250, and alter description of when
              RFC 6091 is used.
* overview.xml: Alter text to match new design.
* plugin-runner.xml (EXAMPLE): Add --tls-pubkey and --tls-privkey
                               options to mandos-client options.
* plugins.d/mandos-client.c: Use raw public keys when compiling with
                             supporting GnuTLS versions. Add new
                             "--tls-pubkey" and "--tls-privkey"
                             options (which do nothing if GnuTLS
                             library does not support raw public
                             keys).  Alter text throughout to reflect
                             new design.  Only generate new DH
                             parameters (based on size of OpenPGP key)
                             when using OpenPGP in TLS.  Default
                             GnuTLS priority string depends on whether
                             we are using raw public keys or not.
* plugins.d/mandos-client.xml (SYNOPSIS): Add new "--tls-privkey" (-t)
                                          and "--tls-pubkey" (-T)
                                          options.
  (DESCRIPTION): Describe new dual-key design.
  (OPTIONS): Document new "--tls-privkey" (-t) and "--tls-pubkey" (-T)
             options.
  (OPTIONS/--dh-bits): No longer necessarily depends on OpenPGP key
                       size.
  (FILES): Add default locations for TLS public and private key files.
  (EXAMPLE): Use new --tls-pubkey and --tls-privkey options.
  (SECURITY): Alter wording slightly to reflect new dual-key design.
  (SEE ALSO/GnuTLS): Alter description to match new design.
  (SEE ALSO): Add reference to RFC 7250, and alter description of when
              RFC 6091 is used.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/*  -*- coding: utf-8 -*- */
 
1
/*  -*- coding: utf-8; mode: c; mode: orgtbl -*- */
2
2
/*
3
 
 * Passprompt - Read a password from the terminal and print it
4
 
 *
5
 
 * Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
6
 
 * 
7
 
 * This program is free software: you can redistribute it and/or
8
 
 * modify it under the terms of the GNU General Public License as
9
 
 * published by the Free Software Foundation, either version 3 of the
10
 
 * License, or (at your option) any later version.
11
 
 * 
12
 
 * This program is distributed in the hope that it will be useful, but
 
3
 * Password-prompt - Read a password from the terminal and print it
 
4
 * 
 
5
 * Copyright © 2008-2018 Teddy Hogeborn
 
6
 * Copyright © 2008-2018 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
13
16
 * WITHOUT ANY WARRANTY; without even the implied warranty of
14
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
18
 * General Public License for more details.
16
19
 * 
17
20
 * You should have received a copy of the GNU General Public License
18
 
 * along with this program.  If not, see
19
 
 * <http://www.gnu.org/licenses/>.
 
21
 * along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
20
22
 * 
21
 
 * Contact the authors at <https://www.fukt.bsnet.se/~belorn/> and
22
 
 * <https://www.fukt.bsnet.se/~teddy/>.
 
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
 
                                   SIGQUIT, SIGHUP, SIGTERM */
 
36
                                   SIGQUIT, SIGHUP, SIGTERM,
 
37
                                   raise() */
36
38
#include <stddef.h>             /* NULL, size_t, ssize_t */
37
 
#include <sys/types.h>          /* ssize_t */
 
39
#include <sys/types.h>          /* ssize_t, struct dirent, pid_t,
 
40
                                   ssize_t, open() */
38
41
#include <stdlib.h>             /* EXIT_SUCCESS, EXIT_FAILURE,
39
 
                                   getopt_long */
 
42
                                   getenv(), free() */
 
43
#include <dirent.h>             /* scandir(), alphasort() */
40
44
#include <stdio.h>              /* fprintf(), stderr, getline(),
41
 
                                   stdin, feof(), perror(), fputc(),
42
 
                                   stdout, getopt_long */
43
 
#include <errno.h>              /* errno, EINVAL */
 
45
                                   stdin, feof(), fputc(), vfprintf(),
 
46
                                   vasprintf() */
 
47
#include <errno.h>              /* errno, EBADF, ENOTTY, EINVAL,
 
48
                                   EFAULT, EFBIG, EIO, ENOSPC, EINTR
 
49
                                */
 
50
#include <error.h>              /* error() */
44
51
#include <iso646.h>             /* or, not */
45
52
#include <stdbool.h>            /* bool, false, true */
46
 
#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
                                 */
47
57
#include <argp.h>               /* struct argp_option, struct
48
58
                                   argp_state, struct argp,
49
59
                                   argp_parse(), error_t,
50
60
                                   ARGP_KEY_ARG, ARGP_KEY_END,
51
61
                                   ARGP_ERR_UNKNOWN */
 
62
#include <sysexits.h>           /* EX_SOFTWARE, EX_OSERR,
 
63
                                   EX_UNAVAILABLE, EX_IOERR, EX_OK */
 
64
#include <fcntl.h>              /* open() */
 
65
#include <stdarg.h>             /* va_list, va_start(), ... */
52
66
 
53
 
volatile bool quit_now = false;
 
67
volatile sig_atomic_t quit_now = 0;
 
68
int signal_received;
54
69
bool debug = false;
55
 
const char *argp_program_version = "password-prompt 1.0";
56
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
57
 
 
58
 
static void termination_handler(__attribute__((unused))int signum){
59
 
  quit_now = true;
60
 
}
 
70
const char *argp_program_version = "password-prompt " VERSION;
 
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
}
 
98
 
 
99
static void termination_handler(int signum){
 
100
  if(quit_now){
 
101
    return;
 
102
  }
 
103
  quit_now = 1;
 
104
  signal_received = signum;
 
105
}
 
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
 
61
229
 
62
230
int main(int argc, char **argv){
63
 
  ssize_t ret;
 
231
  ssize_t sret;
 
232
  int ret;
64
233
  size_t n;
65
234
  struct termios t_new, t_old;
66
235
  char *buffer = NULL;
73
242
    struct argp_option options[] = {
74
243
      { .name = "prefix", .key = 'p',
75
244
        .arg = "PREFIX", .flags = 0,
76
 
        .doc = "Prefix used before the passprompt", .group = 2 },
 
245
        .doc = "Prefix shown before the prompt", .group = 2 },
77
246
      { .name = "debug", .key = 128,
78
247
        .doc = "Debug mode", .group = 3 },
 
248
      /*
 
249
       * These reproduce what we would get without ARGP_NO_HELP
 
250
       */
 
251
      { .name = "help", .key = '?',
 
252
        .doc = "Give this help list", .group = -1 },
 
253
      { .name = "usage", .key = -3,
 
254
        .doc = "Give a short usage message", .group = -1 },
 
255
      { .name = "version", .key = 'V',
 
256
        .doc = "Print program version", .group = -1 },
79
257
      { .name = NULL }
80
258
    };
81
 
  
82
 
    error_t parse_opt (int key, char *arg, struct argp_state *state) {
83
 
      /* Get the INPUT argument from `argp_parse', which we know is a
84
 
         pointer to our plugin list pointer. */
85
 
      switch (key) {
 
259
    
 
260
    __attribute__((nonnull(3)))
 
261
    error_t parse_opt (int key, char *arg, struct argp_state *state){
 
262
      errno = 0;
 
263
      switch (key){
86
264
      case 'p':
87
265
        prefix = arg;
88
266
        break;
89
267
      case 128:
90
268
        debug = true;
91
269
        break;
92
 
      case ARGP_KEY_ARG:
93
 
        argp_usage (state);
94
 
        break;
95
 
      case ARGP_KEY_END:
 
270
        /*
 
271
         * These reproduce what we would get without ARGP_NO_HELP
 
272
         */
 
273
      case '?':                 /* --help */
 
274
        argp_state_help(state, state->out_stream,
 
275
                        (ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
 
276
                        & ~(unsigned int)ARGP_HELP_EXIT_OK);
 
277
      case -3:                  /* --usage */
 
278
        argp_state_help(state, state->out_stream,
 
279
                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
 
280
      case 'V':                 /* --version */
 
281
        fprintf(state->out_stream, "%s\n", argp_program_version);
 
282
        exit(argp_err_exit_status);
96
283
        break;
97
284
      default:
98
285
        return ARGP_ERR_UNKNOWN;
99
286
      }
100
 
      return 0;
 
287
      return errno;
101
288
    }
102
 
  
 
289
    
103
290
    struct argp argp = { .options = options, .parser = parse_opt,
104
291
                         .args_doc = "",
105
 
                         .doc = "Mandos Passprompt -- Provides a passprompt" };
106
 
    ret = argp_parse (&argp, argc, argv, 0, 0, NULL);
107
 
    if (ret == ARGP_ERR_UNKNOWN){
108
 
      fprintf(stderr, "Unknown error while parsing arguments\n");
109
 
      return EXIT_FAILURE;
 
292
                         .doc = "Mandos password-prompt -- Read and"
 
293
                         " output a password" };
 
294
    ret = argp_parse(&argp, argc, argv,
 
295
                     ARGP_IN_ORDER | ARGP_NO_HELP, NULL, NULL);
 
296
    switch(ret){
 
297
    case 0:
 
298
      break;
 
299
    case ENOMEM:
 
300
    default:
 
301
      errno = ret;
 
302
      error_plus(0, errno, "argp_parse");
 
303
      return EX_OSERR;
 
304
    case EINVAL:
 
305
      return EX_USAGE;
110
306
    }
111
307
  }
112
 
    
113
 
  if (debug){
 
308
  
 
309
  if(debug){
114
310
    fprintf(stderr, "Starting %s\n", argv[0]);
115
311
  }
116
 
  if (debug){
 
312
 
 
313
  if(conflict_detection()){
 
314
    if(debug){
 
315
      fprintf(stderr, "Stopping %s because of conflict\n", argv[0]);
 
316
    }
 
317
    return EXIT_FAILURE;
 
318
  }
 
319
  
 
320
  if(debug){
117
321
    fprintf(stderr, "Storing current terminal attributes\n");
118
322
  }
119
323
  
120
 
  if (tcgetattr(STDIN_FILENO, &t_old) != 0){
121
 
    return EXIT_FAILURE;
 
324
  if(tcgetattr(STDIN_FILENO, &t_old) != 0){
 
325
    int e = errno;
 
326
    error_plus(0, errno, "tcgetattr");
 
327
    switch(e){
 
328
    case EBADF:
 
329
    case ENOTTY:
 
330
      return EX_UNAVAILABLE;
 
331
    default:
 
332
      return EX_OSERR;
 
333
    }
122
334
  }
123
335
  
124
336
  sigemptyset(&new_action.sa_mask);
125
 
  sigaddset(&new_action.sa_mask, SIGINT);
126
 
  sigaddset(&new_action.sa_mask, SIGHUP);
127
 
  sigaddset(&new_action.sa_mask, SIGTERM);
 
337
  ret = sigaddset(&new_action.sa_mask, SIGINT);
 
338
  if(ret == -1){
 
339
    error_plus(0, errno, "sigaddset");
 
340
    return EX_OSERR;
 
341
  }
 
342
  ret = sigaddset(&new_action.sa_mask, SIGHUP);
 
343
  if(ret == -1){
 
344
    error_plus(0, errno, "sigaddset");
 
345
    return EX_OSERR;
 
346
  }
 
347
  ret = sigaddset(&new_action.sa_mask, SIGTERM);
 
348
  if(ret == -1){
 
349
    error_plus(0, errno, "sigaddset");
 
350
    return EX_OSERR;
 
351
  }
 
352
  /* Need to check if the handler is SIG_IGN before handling:
 
353
     | [[info:libc:Initial Signal Actions]] |
 
354
     | [[info:libc:Basic Signal Handling]]  |
 
355
  */
128
356
  ret = sigaction(SIGINT, NULL, &old_action);
129
357
  if(ret == -1){
130
 
    perror("sigaction");
131
 
    return EXIT_FAILURE;
 
358
    error_plus(0, errno, "sigaction");
 
359
    return EX_OSERR;
132
360
  }
133
 
  if (old_action.sa_handler != SIG_IGN){
 
361
  if(old_action.sa_handler != SIG_IGN){
134
362
    ret = sigaction(SIGINT, &new_action, NULL);
135
363
    if(ret == -1){
136
 
      perror("sigaction");
137
 
      return EXIT_FAILURE;
 
364
      error_plus(0, errno, "sigaction");
 
365
      return EX_OSERR;
138
366
    }
139
367
  }
140
368
  ret = sigaction(SIGHUP, NULL, &old_action);
141
369
  if(ret == -1){
142
 
    perror("sigaction");
143
 
    return EXIT_FAILURE;
 
370
    error_plus(0, errno, "sigaction");
 
371
    return EX_OSERR;
144
372
  }
145
 
  if (old_action.sa_handler != SIG_IGN){
 
373
  if(old_action.sa_handler != SIG_IGN){
146
374
    ret = sigaction(SIGHUP, &new_action, NULL);
147
375
    if(ret == -1){
148
 
      perror("sigaction");
149
 
      return EXIT_FAILURE;
 
376
      error_plus(0, errno, "sigaction");
 
377
      return EX_OSERR;
150
378
    }
151
379
  }
152
380
  ret = sigaction(SIGTERM, NULL, &old_action);
153
381
  if(ret == -1){
154
 
    perror("sigaction");
155
 
    return EXIT_FAILURE;
 
382
    error_plus(0, errno, "sigaction");
 
383
    return EX_OSERR;
156
384
  }
157
 
  if (old_action.sa_handler != SIG_IGN){
 
385
  if(old_action.sa_handler != SIG_IGN){
158
386
    ret = sigaction(SIGTERM, &new_action, NULL);
159
387
    if(ret == -1){
160
 
      perror("sigaction");
161
 
      return EXIT_FAILURE;
 
388
      error_plus(0, errno, "sigaction");
 
389
      return EX_OSERR;
162
390
    }
163
391
  }
164
392
  
165
393
  
166
 
  if (debug){
 
394
  if(debug){
167
395
    fprintf(stderr, "Removing echo flag from terminal attributes\n");
168
396
  }
169
397
  
170
398
  t_new = t_old;
171
 
  t_new.c_lflag &= ~ECHO;
172
 
  if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_new) != 0){
173
 
    perror("tcsetattr-echo");
174
 
    return EXIT_FAILURE;
 
399
  t_new.c_lflag &= ~(tcflag_t)ECHO;
 
400
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_new) != 0){
 
401
    int e = errno;
 
402
    error_plus(0, errno, "tcsetattr-echo");
 
403
    switch(e){
 
404
    case EBADF:
 
405
    case ENOTTY:
 
406
      return EX_UNAVAILABLE;
 
407
    case EINVAL:
 
408
    default:
 
409
      return EX_OSERR;
 
410
    }
175
411
  }
176
 
 
177
 
  if (debug){
 
412
  
 
413
  if(debug){
178
414
    fprintf(stderr, "Waiting for input from stdin \n");
179
415
  }
180
416
  while(true){
181
 
    if (quit_now){
 
417
    if(quit_now){
 
418
      if(debug){
 
419
        fprintf(stderr, "Interrupted by signal, exiting.\n");
 
420
      }
182
421
      status = EXIT_FAILURE;
183
422
      break;
184
423
    }
185
424
 
186
425
    if(prefix){
187
 
      fprintf(stderr, "%s Password: ", prefix);
188
 
    } else {
189
 
      fprintf(stderr, "Password: ");
190
 
    }      
191
 
    ret = getline(&buffer, &n, stdin);
192
 
    if (ret > 0){
193
 
      fprintf(stdout, "%s", buffer);
 
426
      fprintf(stderr, "%s ", prefix);
 
427
    }
 
428
    {
 
429
      const char *cryptsource = getenv("CRYPTTAB_SOURCE");
 
430
      const char *crypttarget = getenv("CRYPTTAB_NAME");
 
431
      /* Before cryptsetup 1.1.0~rc2 */
 
432
      if(cryptsource == NULL){
 
433
        cryptsource = getenv("cryptsource");
 
434
      }
 
435
      if(crypttarget == NULL){
 
436
        crypttarget = getenv("crypttarget");
 
437
      }
 
438
      const char *const prompt1 = "Unlocking the disk";
 
439
      const char *const prompt2 = "Enter passphrase";
 
440
      if(cryptsource == NULL){
 
441
        if(crypttarget == NULL){
 
442
          fprintf(stderr, "%s to unlock the disk: ", prompt2);
 
443
        } else {
 
444
          fprintf(stderr, "%s (%s)\n%s: ", prompt1, crypttarget,
 
445
                  prompt2);
 
446
        }
 
447
      } else {
 
448
        if(crypttarget == NULL){
 
449
          fprintf(stderr, "%s %s\n%s: ", prompt1, cryptsource,
 
450
                  prompt2);
 
451
        } else {
 
452
          fprintf(stderr, "%s %s (%s)\n%s: ", prompt1, cryptsource,
 
453
                  crypttarget, prompt2);
 
454
        }
 
455
      }
 
456
    }
 
457
    sret = getline(&buffer, &n, stdin);
 
458
    if(sret > 0){
194
459
      status = EXIT_SUCCESS;
 
460
      /* Make n = data size instead of allocated buffer size */
 
461
      n = (size_t)sret;
 
462
      /* Strip final newline */
 
463
      if(n > 0 and buffer[n-1] == '\n'){
 
464
        buffer[n-1] = '\0';     /* not strictly necessary */
 
465
        n--;
 
466
      }
 
467
      size_t written = 0;
 
468
      while(written < n){
 
469
        sret = write(STDOUT_FILENO, buffer + written, n - written);
 
470
        if(sret < 0){
 
471
          int e = errno;
 
472
          error_plus(0, errno, "write");
 
473
          switch(e){
 
474
          case EBADF:
 
475
          case EFAULT:
 
476
          case EINVAL:
 
477
          case EFBIG:
 
478
          case EIO:
 
479
          case ENOSPC:
 
480
          default:
 
481
            status = EX_IOERR;
 
482
            break;
 
483
          case EINTR:
 
484
            status = EXIT_FAILURE;
 
485
            break;
 
486
          }
 
487
          break;
 
488
        }
 
489
        written += (size_t)sret;
 
490
      }
 
491
      sret = close(STDOUT_FILENO);
 
492
      if(sret == -1){
 
493
        int e = errno;
 
494
        error_plus(0, errno, "close");
 
495
        switch(e){
 
496
        case EBADF:
 
497
          status = EX_OSFILE;
 
498
          break;
 
499
        case EIO:
 
500
        default:
 
501
          status = EX_IOERR;
 
502
          break;
 
503
        }
 
504
      }
195
505
      break;
196
506
    }
197
 
    if (ret < 0){
198
 
      if (errno != EINTR and not feof(stdin)){
199
 
        perror("getline");
200
 
        status = EXIT_FAILURE;
 
507
    if(sret < 0){
 
508
      int e = errno;
 
509
      if(errno != EINTR and not feof(stdin)){
 
510
        error_plus(0, errno, "getline");
 
511
        switch(e){
 
512
        case EBADF:
 
513
          status = EX_UNAVAILABLE;
 
514
          break;
 
515
        case EIO:
 
516
        case EINVAL:
 
517
        default:
 
518
          status = EX_IOERR;
 
519
          break;
 
520
        }
201
521
        break;
202
522
      }
203
523
    }
204
 
    /* if(ret == 0), then the only sensible thing to do is to retry to
205
 
       read from stdin */
 
524
    /* if(sret == 0), then the only sensible thing to do is to retry
 
525
       to read from stdin */
206
526
    fputc('\n', stderr);
 
527
    if(debug and not quit_now){
 
528
      /* If quit_now is nonzero, we were interrupted by a signal, and
 
529
         will print that later, so no need to show this too. */
 
530
      fprintf(stderr, "getline() returned 0, retrying.\n");
 
531
    }
207
532
  }
208
533
  
209
 
  if (debug){
 
534
  free(buffer);
 
535
  
 
536
  if(debug){
210
537
    fprintf(stderr, "Restoring terminal attributes\n");
211
538
  }
212
 
  if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_old) != 0){
213
 
    perror("tcsetattr+echo");
214
 
  }
215
 
  
216
 
  if (debug){
217
 
    fprintf(stderr, "%s is exiting\n", argv[0]);
 
539
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_old) != 0){
 
540
    error_plus(0, errno, "tcsetattr+echo");
 
541
  }
 
542
  
 
543
  if(quit_now){
 
544
    sigemptyset(&old_action.sa_mask);
 
545
    old_action.sa_handler = SIG_DFL;
 
546
    ret = sigaction(signal_received, &old_action, NULL);
 
547
    if(ret == -1){
 
548
      error_plus(0, errno, "sigaction");
 
549
    }
 
550
    raise(signal_received);
 
551
  }
 
552
  
 
553
  if(debug){
 
554
    fprintf(stderr, "%s is exiting with status %d\n", argv[0],
 
555
            status);
 
556
  }
 
557
  if(status == EXIT_SUCCESS or status == EX_OK){
 
558
    fputc('\n', stderr);
218
559
  }
219
560
  
220
561
  return status;