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