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