/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/passprompt.c

  • Committer: Björn Påhlsson
  • Date: 2008-07-20 02:52:20 UTC
  • Revision ID: belorn@braxen-20080720025220-r5u0388uy9iu23h6
Added following support:
Pluginbased client handler
rewritten Mandos client
       Avahi instead of udp server discovery
       openpgp encrypted key support
Passprompt stand alone application for direct console input
Added logging for Mandos server

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/*  -*- coding: utf-8; mode: c; mode: orgtbl -*- */
2
 
/*
3
 
 * Password-prompt - Read a password from the terminal and print it
4
 
 * 
5
 
 * Copyright © 2008-2010 Teddy Hogeborn
6
 
 * Copyright © 2008-2010 Björn Påhlsson
7
 
 * 
8
 
 * This program is free software: you can redistribute it and/or
9
 
 * modify it under the terms of the GNU General Public License as
10
 
 * published by the Free Software Foundation, either version 3 of the
11
 
 * License, or (at your option) any later version.
12
 
 * 
13
 
 * This program is distributed in the hope that it will be useful, but
14
 
 * WITHOUT ANY WARRANTY; without even the implied warranty of
15
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
 
 * General Public License for more details.
17
 
 * 
18
 
 * 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
 
 * 
22
 
 * Contact the authors at <mandos@fukt.bsnet.se>.
23
 
 */
24
 
 
25
1
#define _GNU_SOURCE             /* getline() */
26
 
 
 
2
#define _FORTIFY_SOURCE 2
27
3
#include <termios.h>            /* struct termios, tcsetattr(),
28
4
                                   TCSAFLUSH, tcgetattr(), ECHO */
29
5
#include <unistd.h>             /* struct termios, tcsetattr(),
32
8
#include <signal.h>             /* sig_atomic_t, raise(), struct
33
9
                                   sigaction, sigemptyset(),
34
10
                                   sigaction(), sigaddset(), SIGINT,
35
 
                                   SIGQUIT, SIGHUP, SIGTERM,
36
 
                                   raise() */
37
 
#include <stddef.h>             /* NULL, size_t, ssize_t */
 
11
                                   SIGQUIT, SIGHUP, SIGTERM */
 
12
#include <stddef.h>             /* NULL, size_t */
38
13
#include <sys/types.h>          /* ssize_t */
39
 
#include <stdlib.h>             /* EXIT_SUCCESS, EXIT_FAILURE,
40
 
                                   getenv() */
 
14
#include <stdlib.h>             /* EXIT_SUCCESS, EXIT_FAILURE */
41
15
#include <stdio.h>              /* fprintf(), stderr, getline(),
42
 
                                   stdin, feof(), fputc()
43
 
                                */
44
 
#include <errno.h>              /* errno, EBADF, ENOTTY, EINVAL,
45
 
                                   EFAULT, EFBIG, EIO, ENOSPC, EINTR
46
 
                                */
47
 
#include <error.h>              /* error() */
 
16
                                   stdin, feof(), perror(), fputc(),
 
17
                                   stdout */
 
18
#include <errno.h>              /* errno, EINVAL */
48
19
#include <iso646.h>             /* or, not */
49
20
#include <stdbool.h>            /* bool, false, true */
50
 
#include <string.h>             /* strlen, rindex */
51
 
#include <argp.h>               /* struct argp_option, struct
52
 
                                   argp_state, struct argp,
53
 
                                   argp_parse(), error_t,
54
 
                                   ARGP_KEY_ARG, ARGP_KEY_END,
55
 
                                   ARGP_ERR_UNKNOWN */
56
 
#include <sysexits.h>           /* EX_SOFTWARE, EX_OSERR,
57
 
                                   EX_UNAVAILABLE, EX_IOERR, EX_OK */
58
 
 
59
 
volatile sig_atomic_t quit_now = 0;
60
 
int signal_received;
61
 
bool debug = false;
62
 
const char *argp_program_version = "password-prompt " VERSION;
63
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
64
 
 
65
 
static void termination_handler(int signum){
66
 
  if(quit_now){
67
 
    return;
68
 
  }
69
 
  quit_now = 1;
70
 
  signal_received = signum;
 
21
 
 
22
volatile bool quit_now = false;
 
23
 
 
24
void termination_handler(int signum){
 
25
  quit_now = true;
71
26
}
72
27
 
73
28
int main(int argc, char **argv){
74
 
  ssize_t sret;
75
 
  int ret;
 
29
  ssize_t ret = -1;
76
30
  size_t n;
77
31
  struct termios t_new, t_old;
78
32
  char *buffer = NULL;
79
 
  char *prefix = NULL;
80
33
  int status = EXIT_SUCCESS;
81
34
  struct sigaction old_action,
82
35
    new_action = { .sa_handler = termination_handler,
83
36
                   .sa_flags = 0 };
84
 
  {
85
 
    struct argp_option options[] = {
86
 
      { .name = "prefix", .key = 'p',
87
 
        .arg = "PREFIX", .flags = 0,
88
 
        .doc = "Prefix shown before the prompt", .group = 2 },
89
 
      { .name = "debug", .key = 128,
90
 
        .doc = "Debug mode", .group = 3 },
91
 
      /*
92
 
       * These reproduce what we would get without ARGP_NO_HELP
93
 
       */
94
 
      { .name = "help", .key = '?',
95
 
        .doc = "Give this help list", .group = -1 },
96
 
      { .name = "usage", .key = -3,
97
 
        .doc = "Give a short usage message", .group = -1 },
98
 
      { .name = "version", .key = 'V',
99
 
        .doc = "Print program version", .group = -1 },
100
 
      { .name = NULL }
101
 
    };
102
 
    
103
 
    error_t parse_opt (int key, char *arg, struct argp_state *state){
104
 
      errno = 0;
105
 
      switch (key){
106
 
      case 'p':
107
 
        prefix = arg;
108
 
        break;
109
 
      case 128:
110
 
        debug = true;
111
 
        break;
112
 
        /*
113
 
         * These reproduce what we would get without ARGP_NO_HELP
114
 
         */
115
 
      case '?':                 /* --help */
116
 
        argp_state_help(state, state->out_stream,
117
 
                        (ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
118
 
                        & ~(unsigned int)ARGP_HELP_EXIT_OK);
119
 
      case -3:                  /* --usage */
120
 
        argp_state_help(state, state->out_stream,
121
 
                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
122
 
      case 'V':                 /* --version */
123
 
        fprintf(state->out_stream, "%s\n", argp_program_version);
124
 
        exit(argp_err_exit_status);
125
 
        break;
126
 
      default:
127
 
        return ARGP_ERR_UNKNOWN;
128
 
      }
129
 
      return errno;
130
 
    }
131
 
    
132
 
    struct argp argp = { .options = options, .parser = parse_opt,
133
 
                         .args_doc = "",
134
 
                         .doc = "Mandos password-prompt -- Read and"
135
 
                         " output a password" };
136
 
    ret = argp_parse(&argp, argc, argv,
137
 
                     ARGP_IN_ORDER | ARGP_NO_HELP, NULL, NULL);
138
 
    switch(ret){
139
 
    case 0:
140
 
      break;
141
 
    case ENOMEM:
142
 
    default:
143
 
      errno = ret;
144
 
      error(0, errno, "argp_parse");
145
 
      return EX_OSERR;
146
 
    case EINVAL:
147
 
      return EX_USAGE;
148
 
    }
149
 
  }
150
 
  
151
 
  if(debug){
152
 
    fprintf(stderr, "Starting %s\n", argv[0]);
153
 
  }
154
 
  if(debug){
155
 
    fprintf(stderr, "Storing current terminal attributes\n");
156
 
  }
157
 
  
158
 
  if(tcgetattr(STDIN_FILENO, &t_old) != 0){
159
 
    int e = errno;
160
 
    error(0, errno, "tcgetattr");
161
 
    switch(e){
162
 
    case EBADF:
163
 
    case ENOTTY:
164
 
      return EX_UNAVAILABLE;
165
 
    default:
166
 
      return EX_OSERR;
167
 
    }
 
37
  
 
38
  if (tcgetattr(STDIN_FILENO, &t_old) != 0){
 
39
    return EXIT_FAILURE;
168
40
  }
169
41
  
170
42
  sigemptyset(&new_action.sa_mask);
171
 
  ret = sigaddset(&new_action.sa_mask, SIGINT);
172
 
  if(ret == -1){
173
 
    error(0, errno, "sigaddset");
174
 
    return EX_OSERR;
175
 
  }
176
 
  ret = sigaddset(&new_action.sa_mask, SIGHUP);
177
 
  if(ret == -1){
178
 
    error(0, errno, "sigaddset");
179
 
    return EX_OSERR;
180
 
  }
181
 
  ret = sigaddset(&new_action.sa_mask, SIGTERM);
182
 
  if(ret == -1){
183
 
    error(0, errno, "sigaddset");
184
 
    return EX_OSERR;
185
 
  }
186
 
  /* Need to check if the handler is SIG_IGN before handling:
187
 
     | [[info:libc:Initial Signal Actions]] |
188
 
     | [[info:libc:Basic Signal Handling]]  |
189
 
  */
190
 
  ret = sigaction(SIGINT, NULL, &old_action);
191
 
  if(ret == -1){
192
 
    error(0, errno, "sigaction");
193
 
    return EX_OSERR;
194
 
  }
195
 
  if(old_action.sa_handler != SIG_IGN){
196
 
    ret = sigaction(SIGINT, &new_action, NULL);
197
 
    if(ret == -1){
198
 
      error(0, errno, "sigaction");
199
 
      return EX_OSERR;
200
 
    }
201
 
  }
202
 
  ret = sigaction(SIGHUP, NULL, &old_action);
203
 
  if(ret == -1){
204
 
    error(0, errno, "sigaction");
205
 
    return EX_OSERR;
206
 
  }
207
 
  if(old_action.sa_handler != SIG_IGN){
208
 
    ret = sigaction(SIGHUP, &new_action, NULL);
209
 
    if(ret == -1){
210
 
      error(0, errno, "sigaction");
211
 
      return EX_OSERR;
212
 
    }
213
 
  }
214
 
  ret = sigaction(SIGTERM, NULL, &old_action);
215
 
  if(ret == -1){
216
 
    error(0, errno, "sigaction");
217
 
    return EX_OSERR;
218
 
  }
219
 
  if(old_action.sa_handler != SIG_IGN){
220
 
    ret = sigaction(SIGTERM, &new_action, NULL);
221
 
    if(ret == -1){
222
 
      error(0, errno, "sigaction");
223
 
      return EX_OSERR;
224
 
    }
225
 
  }
226
 
  
227
 
  
228
 
  if(debug){
229
 
    fprintf(stderr, "Removing echo flag from terminal attributes\n");
230
 
  }
 
43
  sigaddset(&new_action.sa_mask, SIGINT);
 
44
  sigaddset(&new_action.sa_mask, SIGQUIT);
 
45
  sigaddset(&new_action.sa_mask, SIGHUP);
 
46
  sigaddset(&new_action.sa_mask, SIGTERM);
 
47
  sigaction(SIGINT, NULL, &old_action);
 
48
  if (old_action.sa_handler != SIG_IGN)
 
49
    sigaction(SIGINT, &new_action, NULL);
 
50
  sigaction(SIGQUIT, NULL, &old_action);
 
51
  if (old_action.sa_handler != SIG_IGN)
 
52
    sigaction(SIGQUIT, &new_action, NULL);
 
53
  sigaction(SIGHUP, NULL, &old_action);
 
54
  if (old_action.sa_handler != SIG_IGN)
 
55
    sigaction(SIGHUP, &new_action, NULL);
 
56
  sigaction(SIGTERM, NULL, &old_action);
 
57
  if (old_action.sa_handler != SIG_IGN)
 
58
    sigaction(SIGTERM, &new_action, NULL);
231
59
  
232
60
  t_new = t_old;
233
 
  t_new.c_lflag &= ~(tcflag_t)ECHO;
234
 
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_new) != 0){
235
 
    int e = errno;
236
 
    error(0, errno, "tcsetattr-echo");
237
 
    switch(e){
238
 
    case EBADF:
239
 
    case ENOTTY:
240
 
      return EX_UNAVAILABLE;
241
 
    case EINVAL:
242
 
    default:
243
 
      return EX_OSERR;
244
 
    }
 
61
  t_new.c_lflag &= ~ECHO;
 
62
  if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_new) != 0){
 
63
    perror("tcsetattr-echo");
 
64
    return EXIT_FAILURE;
245
65
  }
246
66
  
247
 
  if(debug){
248
 
    fprintf(stderr, "Waiting for input from stdin \n");
249
 
  }
250
67
  while(true){
251
 
    if(quit_now){
252
 
      if(debug){
253
 
        fprintf(stderr, "Interrupted by signal, exiting.\n");
254
 
      }
 
68
    if (quit_now){
255
69
      status = EXIT_FAILURE;
256
70
      break;
257
71
    }
258
 
 
259
 
    if(prefix){
260
 
      fprintf(stderr, "%s ", prefix);
261
 
    }
262
 
    {
263
 
      const char *cryptsource = getenv("CRYPTTAB_SOURCE");
264
 
      const char *crypttarget = getenv("CRYPTTAB_NAME");
265
 
      /* Before cryptsetup 1.1.0~rc2 */
266
 
      if(cryptsource == NULL){
267
 
        cryptsource = getenv("cryptsource");
268
 
      }
269
 
      if(crypttarget == NULL){
270
 
        crypttarget = getenv("crypttarget");
271
 
      }
272
 
      const char *const prompt1 = "Unlocking the disk";
273
 
      const char *const prompt2 = "Enter passphrase";
274
 
      if(cryptsource == NULL){
275
 
        if(crypttarget == NULL){
276
 
          fprintf(stderr, "%s to unlock the disk: ", prompt2);
277
 
        } else {
278
 
          fprintf(stderr, "%s (%s)\n%s: ", prompt1, crypttarget,
279
 
                  prompt2);
280
 
        }
281
 
      } else {
282
 
        if(crypttarget == NULL){
283
 
          fprintf(stderr, "%s %s\n%s: ", prompt1, cryptsource,
284
 
                  prompt2);
285
 
        } else {
286
 
          fprintf(stderr, "%s %s (%s)\n%s: ", prompt1, cryptsource,
287
 
                  crypttarget, prompt2);
288
 
        }
289
 
      }
290
 
    }
291
 
    sret = getline(&buffer, &n, stdin);
292
 
    if(sret > 0){
 
72
    fprintf(stderr, "Password: ");
 
73
    ret = getline(&buffer, &n, stdin);
 
74
    if (ret > 0){
 
75
      fprintf(stdout, "%s", buffer);
293
76
      status = EXIT_SUCCESS;
294
 
      /* Make n = data size instead of allocated buffer size */
295
 
      n = (size_t)sret;
296
 
      /* Strip final newline */
297
 
      if(n > 0 and buffer[n-1] == '\n'){
298
 
        buffer[n-1] = '\0';     /* not strictly necessary */
299
 
        n--;
300
 
      }
301
 
      size_t written = 0;
302
 
      while(written < n){
303
 
        sret = write(STDOUT_FILENO, buffer + written, n - written);
304
 
        if(sret < 0){
305
 
          int e = errno;
306
 
          error(0, errno, "write");
307
 
          switch(e){
308
 
          case EBADF:
309
 
          case EFAULT:
310
 
          case EINVAL:
311
 
          case EFBIG:
312
 
          case EIO:
313
 
          case ENOSPC:
314
 
          default:
315
 
            status = EX_IOERR;
316
 
            break;
317
 
          case EINTR:
318
 
            status = EXIT_FAILURE;
319
 
            break;
320
 
          }
321
 
          break;
322
 
        }
323
 
        written += (size_t)sret;
324
 
      }
325
 
      sret = close(STDOUT_FILENO);
326
 
      if(sret == -1){
327
 
        int e = errno;
328
 
        error(0, errno, "close");
329
 
        switch(e){
330
 
        case EBADF:
331
 
          status = EX_OSFILE;
332
 
          break;
333
 
        case EIO:
334
 
        default:
335
 
          status = EX_IOERR;
336
 
          break;
337
 
        }
338
 
      }
339
77
      break;
340
78
    }
341
 
    if(sret < 0){
342
 
      int e = errno;
343
 
      if(errno != EINTR and not feof(stdin)){
344
 
        error(0, errno, "getline");
345
 
        switch(e){
346
 
        case EBADF:
347
 
          status = EX_UNAVAILABLE;
348
 
        case EIO:
349
 
        case EINVAL:
350
 
        default:
351
 
          status = EX_IOERR;
352
 
          break;
353
 
        }
 
79
    // ret == 0 makes no other sence than to retry to read from stdin
 
80
    if (ret < 0){
 
81
      if (errno != EINTR and not feof(stdin)){
 
82
        perror("getline");
 
83
        status = EXIT_FAILURE;
354
84
        break;
355
85
      }
356
86
    }
357
 
    /* if(sret == 0), then the only sensible thing to do is to retry to
358
 
       read from stdin */
359
 
    fputc('\n', stderr);
360
 
    if(debug and not quit_now){
361
 
      /* If quit_now is nonzero, we were interrupted by a signal, and
362
 
         will print that later, so no need to show this too. */
363
 
      fprintf(stderr, "getline() returned 0, retrying.\n");
364
 
    }
365
 
  }
366
 
  
367
 
  free(buffer);
368
 
  
369
 
  if(debug){
370
 
    fprintf(stderr, "Restoring terminal attributes\n");
371
 
  }
372
 
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_old) != 0){
373
 
    error(0, errno, "tcsetattr+echo");
374
 
  }
375
 
  
376
 
  if(quit_now){
377
 
    sigemptyset(&old_action.sa_mask);
378
 
    old_action.sa_handler = SIG_DFL;
379
 
    ret = sigaction(signal_received, &old_action, NULL);
380
 
    if(ret == -1){
381
 
      error(0, errno, "sigaction");
382
 
    }
383
 
    raise(signal_received);
384
 
  }
385
 
  
386
 
  if(debug){
387
 
    fprintf(stderr, "%s is exiting with status %d\n", argv[0],
388
 
            status);
389
 
  }
390
 
  if(status == EXIT_SUCCESS or status == EX_OK){
391
 
    fputc('\n', stderr);
 
87
    fputc('\n', stderr);
 
88
  }
 
89
 
 
90
  if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_old) != 0){
 
91
    perror("tcsetattr+echo");
392
92
  }
393
93
  
394
94
  return status;