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