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
- 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
- network-hooks.d
- 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
__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, ": ");
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
int is_plymouth(const struct dirent *proc_entry){
114
int ret;
115
int cl_fd;
116
{
117
uintmax_t maxvalue;
118
char *tmp;
119
errno = 0;
120
maxvalue = strtoumax(proc_entry->d_name, &tmp, 10);
121
122
if(errno != 0 or *tmp != '\0'
123
or maxvalue != (uintmax_t)((pid_t)maxvalue)){
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(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(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(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(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(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(1, errno, "scandir");
217
}
218
free(direntries);
219
return ret > 0;
220
}
221
21
22
volatile bool quit_now = false;
23
24
void termination_handler(int signum){
25
quit_now = true;
26
}
222
27
223
28
int main(int argc, char **argv){
224
ssize_t sret;
225
int ret;
29
ssize_t ret = -1;
226
30
size_t n;
227
31
struct termios t_new, t_old;
228
32
char *buffer = NULL;
229
char *prefix = NULL;
230
33
int status = EXIT_SUCCESS;
231
34
struct sigaction old_action,
232
35
new_action = { .sa_handler = termination_handler,
233
36
.sa_flags = 0 };
234
{
235
struct argp_option options[] = {
236
{ .name = "prefix", .key = 'p',
237
.arg = "PREFIX", .flags = 0,
238
.doc = "Prefix shown before the prompt", .group = 2 },
239
{ .name = "debug", .key = 128,
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 },
250
{ .name = NULL }
251
};
252
253
error_t parse_opt (int key, char *arg, struct argp_state *state){
254
errno = 0;
255
switch (key){
256
case 'p':
257
prefix = arg;
258
break;
259
case 128:
260
debug = true;
261
break;
262
/*
263
* These reproduce what we would get without ARGP_NO_HELP
264
*/
265
case '?': /* --help */
266
argp_state_help(state, state->out_stream,
267
(ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
268
& ~(unsigned int)ARGP_HELP_EXIT_OK);
269
case -3: /* --usage */
270
argp_state_help(state, state->out_stream,
271
ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
272
case 'V': /* --version */
273
fprintf(state->out_stream, "%s\n", argp_program_version);
274
exit(argp_err_exit_status);
275
break;
276
default:
277
return ARGP_ERR_UNKNOWN;
278
}
279
return errno;
280
}
281
282
struct argp argp = { .options = options, .parser = parse_opt,
283
.args_doc = "",
284
.doc = "Mandos password-prompt -- Read and"
285
" output a password" };
286
ret = argp_parse(&argp, argc, argv,
287
ARGP_IN_ORDER | ARGP_NO_HELP, NULL, NULL);
288
switch(ret){
289
case 0:
290
break;
291
case ENOMEM:
292
default:
293
errno = ret;
294
error(0, errno, "argp_parse");
295
return EX_OSERR;
296
case EINVAL:
297
return EX_USAGE;
298
}
299
}
300
37
301
if(debug){
302
fprintf(stderr, "Starting %s\n", argv[0]);
303
}
304
305
if (conflict_detection()){
306
if(debug){
307
fprintf(stderr, "Stopping %s because of conflict\n", argv[0]);
308
}
38
if (tcgetattr(STDIN_FILENO, &t_old) != 0){
309
39
return EXIT_FAILURE;
310
40
}
311
41
312
if(debug){
313
fprintf(stderr, "Storing current terminal attributes\n");
314
}
315
316
if(tcgetattr(STDIN_FILENO, &t_old) != 0){
317
int e = errno;
318
error(0, errno, "tcgetattr");
319
switch(e){
320
case EBADF:
321
case ENOTTY:
322
return EX_UNAVAILABLE;
323
default:
324
return EX_OSERR;
325
}
326
}
327
328
42
sigemptyset(&new_action.sa_mask);
329
ret = sigaddset(&new_action.sa_mask, SIGINT);
330
if(ret == -1){
331
error(0, errno, "sigaddset");
332
return EX_OSERR;
333
}
334
ret = sigaddset(&new_action.sa_mask, SIGHUP);
335
if(ret == -1){
336
error(0, errno, "sigaddset");
337
return EX_OSERR;
338
}
339
ret = sigaddset(&new_action.sa_mask, SIGTERM);
340
if(ret == -1){
341
error(0, errno, "sigaddset");
342
return EX_OSERR;
343
}
344
/* Need to check if the handler is SIG_IGN before handling:
345
| [[info:libc:Initial Signal Actions]] |
346
| [[info:libc:Basic Signal Handling]] |
347
*/
348
ret = sigaction(SIGINT, NULL, &old_action);
349
if(ret == -1){
350
error(0, errno, "sigaction");
351
return EX_OSERR;
352
}
353
if(old_action.sa_handler != SIG_IGN){
354
ret = sigaction(SIGINT, &new_action, NULL);
355
if(ret == -1){
356
error(0, errno, "sigaction");
357
return EX_OSERR;
358
}
359
}
360
ret = sigaction(SIGHUP, NULL, &old_action);
361
if(ret == -1){
362
error(0, errno, "sigaction");
363
return EX_OSERR;
364
}
365
if(old_action.sa_handler != SIG_IGN){
366
ret = sigaction(SIGHUP, &new_action, NULL);
367
if(ret == -1){
368
error(0, errno, "sigaction");
369
return EX_OSERR;
370
}
371
}
372
ret = sigaction(SIGTERM, NULL, &old_action);
373
if(ret == -1){
374
error(0, errno, "sigaction");
375
return EX_OSERR;
376
}
377
if(old_action.sa_handler != SIG_IGN){
378
ret = sigaction(SIGTERM, &new_action, NULL);
379
if(ret == -1){
380
error(0, errno, "sigaction");
381
return EX_OSERR;
382
}
383
}
384
385
386
if(debug){
387
fprintf(stderr, "Removing echo flag from terminal attributes\n");
388
}
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);
389
59
390
60
t_new = t_old;
391
t_new.c_lflag &= ~(tcflag_t)ECHO;
392
if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_new) != 0){
393
int e = errno;
394
error(0, errno, "tcsetattr-echo");
395
switch(e){
396
case EBADF:
397
case ENOTTY:
398
return EX_UNAVAILABLE;
399
case EINVAL:
400
default:
401
return EX_OSERR;
402
}
61
t_new.c_lflag &= ~ECHO;
62
if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_new) != 0){
63
perror("tcsetattr-echo");
64
return EXIT_FAILURE;
403
65
}
404
66
405
if(debug){
406
fprintf(stderr, "Waiting for input from stdin \n");
407
}
408
67
while(true){
409
if(quit_now){
410
if(debug){
411
fprintf(stderr, "Interrupted by signal, exiting.\n");
412
}
68
if (quit_now){
413
69
status = EXIT_FAILURE;
414
70
break;
415
71
}
416
417
if(prefix){
418
fprintf(stderr, "%s ", prefix);
419
}
420
{
421
const char *cryptsource = getenv("CRYPTTAB_SOURCE");
422
const char *crypttarget = getenv("CRYPTTAB_NAME");
423
/* Before cryptsetup 1.1.0~rc2 */
424
if(cryptsource == NULL){
425
cryptsource = getenv("cryptsource");
426
}
427
if(crypttarget == NULL){
428
crypttarget = getenv("crypttarget");
429
}
430
const char *const prompt1 = "Unlocking the disk";
431
const char *const prompt2 = "Enter passphrase";
432
if(cryptsource == NULL){
433
if(crypttarget == NULL){
434
fprintf(stderr, "%s to unlock the disk: ", prompt2);
435
} else {
436
fprintf(stderr, "%s (%s)\n%s: ", prompt1, crypttarget,
437
prompt2);
438
}
439
} else {
440
if(crypttarget == NULL){
441
fprintf(stderr, "%s %s\n%s: ", prompt1, cryptsource,
442
prompt2);
443
} else {
444
fprintf(stderr, "%s %s (%s)\n%s: ", prompt1, cryptsource,
445
crypttarget, prompt2);
446
}
447
}
448
}
449
sret = getline(&buffer, &n, stdin);
450
if(sret > 0){
72
fprintf(stderr, "Password: ");
73
ret = getline(&buffer, &n, stdin);
74
if (ret > 0){
75
fprintf(stdout, "%s", buffer);
451
76
status = EXIT_SUCCESS;
452
/* Make n = data size instead of allocated buffer size */
453
n = (size_t)sret;
454
/* Strip final newline */
455
if(n > 0 and buffer[n-1] == '\n'){
456
buffer[n-1] = '\0'; /* not strictly necessary */
457
n--;
458
}
459
size_t written = 0;
460
while(written < n){
461
sret = write(STDOUT_FILENO, buffer + written, n - written);
462
if(sret < 0){
463
int e = errno;
464
error(0, errno, "write");
465
switch(e){
466
case EBADF:
467
case EFAULT:
468
case EINVAL:
469
case EFBIG:
470
case EIO:
471
case ENOSPC:
472
default:
473
status = EX_IOERR;
474
break;
475
case EINTR:
476
status = EXIT_FAILURE;
477
break;
478
}
479
break;
480
}
481
written += (size_t)sret;
482
}
483
sret = close(STDOUT_FILENO);
484
if(sret == -1){
485
int e = errno;
486
error(0, errno, "close");
487
switch(e){
488
case EBADF:
489
status = EX_OSFILE;
490
break;
491
case EIO:
492
default:
493
status = EX_IOERR;
494
break;
495
}
496
}
497
77
break;
498
78
}
499
if(sret < 0){
500
int e = errno;
501
if(errno != EINTR and not feof(stdin)){
502
error(0, errno, "getline");
503
switch(e){
504
case EBADF:
505
status = EX_UNAVAILABLE;
506
case EIO:
507
case EINVAL:
508
default:
509
status = EX_IOERR;
510
break;
511
}
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;
512
84
break;
513
85
}
514
86
}
515
/* if(sret == 0), then the only sensible thing to do is to retry
516
to read from stdin */
517
fputc('\n', stderr);
518
if(debug and not quit_now){
519
/* If quit_now is nonzero, we were interrupted by a signal, and
520
will print that later, so no need to show this too. */
521
fprintf(stderr, "getline() returned 0, retrying.\n");
522
}
523
}
524
525
free(buffer);
526
527
if(debug){
528
fprintf(stderr, "Restoring terminal attributes\n");
529
}
530
if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_old) != 0){
531
error(0, errno, "tcsetattr+echo");
532
}
533
534
if(quit_now){
535
sigemptyset(&old_action.sa_mask);
536
old_action.sa_handler = SIG_DFL;
537
ret = sigaction(signal_received, &old_action, NULL);
538
if(ret == -1){
539
error(0, errno, "sigaction");
540
}
541
raise(signal_received);
542
}
543
544
if(debug){
545
fprintf(stderr, "%s is exiting with status %d\n", argv[0],
546
status);
547
}
548
if(status == EXIT_SUCCESS or status == EX_OK){
549
fputc('\n', stderr);
87
fputc('\n', stderr);
88
}
89
90
if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_old) != 0){
91
perror("tcsetattr+echo");
550
92
}
551
93
552
94
return status;
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0