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