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
- 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,2009 Teddy Hogeborn
6
* Copyright © 2008,2009 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
1
#define _GNU_SOURCE /* getline() */
26
2
#define _FORTIFY_SOURCE 2
27
3
#include <termios.h> /* struct termios, tcsetattr(),
28
4
TCSAFLUSH, tcgetattr(), ECHO */
29
5
#include <unistd.h> /* struct termios, tcsetattr(),
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 */
11
SIGQUIT, SIGHUP, SIGTERM */
12
#include <stddef.h> /* NULL, size_t */
38
13
#include <sys/types.h> /* ssize_t */
39
#include <stdlib.h> /* EXIT_SUCCESS, EXIT_FAILURE,
40
getenv() */
14
#include <stdlib.h> /* EXIT_SUCCESS, EXIT_FAILURE */
41
15
#include <stdio.h> /* fprintf(), stderr, getline(),
42
stdin, feof(), fputc()
43
*/
44
#include <errno.h> /* errno, EBADF, ENOTTY, EINVAL,
45
EFAULT, EFBIG, EIO, ENOSPC, EINTR
46
*/
47
#include <error.h> /* error() */
16
stdin, feof(), perror(), fputc(),
17
stdout */
18
#include <errno.h> /* errno, EINVAL */
48
19
#include <iso646.h> /* or, not */
49
20
#include <stdbool.h> /* bool, false, true */
50
#include <string.h> /* strlen, rindex */
51
#include <argp.h> /* struct argp_option, struct
52
argp_state, struct argp,
53
argp_parse(), error_t,
54
ARGP_KEY_ARG, ARGP_KEY_END,
55
ARGP_ERR_UNKNOWN */
56
#include <sysexits.h> /* EX_SOFTWARE, EX_OSERR,
57
EX_UNAVAILABLE, EX_IOERR, EX_OK */
58
59
volatile sig_atomic_t quit_now = 0;
60
int signal_received;
61
bool debug = false;
62
const char *argp_program_version = "password-prompt " VERSION;
63
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
64
65
static void termination_handler(int signum){
66
if(quit_now){
67
return;
68
}
69
quit_now = 1;
70
signal_received = signum;
21
22
volatile bool quit_now = false;
23
24
void termination_handler(int signum){
25
quit_now = true;
71
26
}
72
27
73
28
int main(int argc, char **argv){
74
ssize_t sret;
75
int ret;
29
ssize_t ret = -1;
76
30
size_t n;
77
31
struct termios t_new, t_old;
78
32
char *buffer = NULL;
79
char *prefix = NULL;
80
33
int status = EXIT_SUCCESS;
81
34
struct sigaction old_action,
82
35
new_action = { .sa_handler = termination_handler,
83
36
.sa_flags = 0 };
84
{
85
struct argp_option options[] = {
86
{ .name = "prefix", .key = 'p',
87
.arg = "PREFIX", .flags = 0,
88
.doc = "Prefix shown before the prompt", .group = 2 },
89
{ .name = "debug", .key = 128,
90
.doc = "Debug mode", .group = 3 },
91
/*
92
* These reproduce what we would get without ARGP_NO_HELP
93
*/
94
{ .name = "help", .key = '?',
95
.doc = "Give this help list", .group = -1 },
96
{ .name = "usage", .key = -3,
97
.doc = "Give a short usage message", .group = -1 },
98
{ .name = "version", .key = 'V',
99
.doc = "Print program version", .group = -1 },
100
{ .name = NULL }
101
};
102
103
error_t parse_opt (int key, char *arg, struct argp_state *state){
104
errno = 0;
105
switch (key){
106
case 'p':
107
prefix = arg;
108
break;
109
case 128:
110
debug = true;
111
break;
112
/*
113
* These reproduce what we would get without ARGP_NO_HELP
114
*/
115
case '?': /* --help */
116
argp_state_help(state, state->out_stream,
117
(ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
118
& ~(unsigned int)ARGP_HELP_EXIT_OK);
119
case -3: /* --usage */
120
argp_state_help(state, state->out_stream,
121
ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
122
case 'V': /* --version */
123
fprintf(state->out_stream, "%s\n", argp_program_version);
124
exit(argp_err_exit_status);
125
break;
126
default:
127
return ARGP_ERR_UNKNOWN;
128
}
129
return errno;
130
}
131
132
struct argp argp = { .options = options, .parser = parse_opt,
133
.args_doc = "",
134
.doc = "Mandos password-prompt -- Read and"
135
" output a password" };
136
ret = argp_parse(&argp, argc, argv,
137
ARGP_IN_ORDER | ARGP_NO_HELP, NULL, NULL);
138
switch(ret){
139
case 0:
140
break;
141
case ENOMEM:
142
default:
143
errno = ret;
144
error(0, errno, "argp_parse");
145
return EX_OSERR;
146
case EINVAL:
147
return EX_USAGE;
148
}
149
}
150
151
if(debug){
152
fprintf(stderr, "Starting %s\n", argv[0]);
153
}
154
if(debug){
155
fprintf(stderr, "Storing current terminal attributes\n");
156
}
157
158
if(tcgetattr(STDIN_FILENO, &t_old) != 0){
159
int e = errno;
160
error(0, errno, "tcgetattr");
161
switch(e){
162
case EBADF:
163
case ENOTTY:
164
return EX_UNAVAILABLE;
165
default:
166
return EX_OSERR;
167
}
37
38
if (tcgetattr(STDIN_FILENO, &t_old) != 0){
39
return EXIT_FAILURE;
168
40
}
169
41
170
42
sigemptyset(&new_action.sa_mask);
171
ret = sigaddset(&new_action.sa_mask, SIGINT);
172
if(ret == -1){
173
error(0, errno, "sigaddset");
174
return EX_OSERR;
175
}
176
ret = sigaddset(&new_action.sa_mask, SIGHUP);
177
if(ret == -1){
178
error(0, errno, "sigaddset");
179
return EX_OSERR;
180
}
181
ret = sigaddset(&new_action.sa_mask, SIGTERM);
182
if(ret == -1){
183
error(0, errno, "sigaddset");
184
return EX_OSERR;
185
}
186
/* Need to check if the handler is SIG_IGN before handling:
187
| [[info:libc:Initial Signal Actions]] |
188
| [[info:libc:Basic Signal Handling]] |
189
*/
190
ret = sigaction(SIGINT, NULL, &old_action);
191
if(ret == -1){
192
error(0, errno, "sigaction");
193
return EX_OSERR;
194
}
195
if(old_action.sa_handler != SIG_IGN){
196
ret = sigaction(SIGINT, &new_action, NULL);
197
if(ret == -1){
198
error(0, errno, "sigaction");
199
return EX_OSERR;
200
}
201
}
202
ret = sigaction(SIGHUP, NULL, &old_action);
203
if(ret == -1){
204
error(0, errno, "sigaction");
205
return EX_OSERR;
206
}
207
if(old_action.sa_handler != SIG_IGN){
208
ret = sigaction(SIGHUP, &new_action, NULL);
209
if(ret == -1){
210
error(0, errno, "sigaction");
211
return EX_OSERR;
212
}
213
}
214
ret = sigaction(SIGTERM, NULL, &old_action);
215
if(ret == -1){
216
error(0, errno, "sigaction");
217
return EX_OSERR;
218
}
219
if(old_action.sa_handler != SIG_IGN){
220
ret = sigaction(SIGTERM, &new_action, NULL);
221
if(ret == -1){
222
error(0, errno, "sigaction");
223
return EX_OSERR;
224
}
225
}
226
227
228
if(debug){
229
fprintf(stderr, "Removing echo flag from terminal attributes\n");
230
}
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);
231
59
232
60
t_new = t_old;
233
t_new.c_lflag &= ~(tcflag_t)ECHO;
234
if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_new) != 0){
235
int e = errno;
236
error(0, errno, "tcsetattr-echo");
237
switch(e){
238
case EBADF:
239
case ENOTTY:
240
return EX_UNAVAILABLE;
241
case EINVAL:
242
default:
243
return EX_OSERR;
244
}
61
t_new.c_lflag &= ~ECHO;
62
if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_new) != 0){
63
perror("tcsetattr-echo");
64
return EXIT_FAILURE;
245
65
}
246
66
247
if(debug){
248
fprintf(stderr, "Waiting for input from stdin \n");
249
}
250
67
while(true){
251
if(quit_now){
252
if(debug){
253
fprintf(stderr, "Interrupted by signal, exiting.\n");
254
}
68
if (quit_now){
255
69
status = EXIT_FAILURE;
256
70
break;
257
71
}
258
259
if(prefix){
260
fprintf(stderr, "%s ", prefix);
261
}
262
{
263
const char *cryptsource = getenv("CRYPTTAB_SOURCE");
264
const char *crypttarget = getenv("CRYPTTAB_NAME");
265
/* Before cryptsetup 1.1.0~rc2 */
266
if(cryptsource == NULL){
267
cryptsource = getenv("cryptsource");
268
}
269
if(crypttarget == NULL){
270
crypttarget = getenv("crypttarget");
271
}
272
const char *const prompt1 = "Unlocking the disk";
273
const char *const prompt2 = "Enter passphrase";
274
if(cryptsource == NULL){
275
if(crypttarget == NULL){
276
fprintf(stderr, "%s to unlock the disk: ", prompt2);
277
} else {
278
fprintf(stderr, "%s (%s)\n%s: ", prompt1, crypttarget,
279
prompt2);
280
}
281
} else {
282
if(crypttarget == NULL){
283
fprintf(stderr, "%s %s\n%s: ", prompt1, cryptsource,
284
prompt2);
285
} else {
286
fprintf(stderr, "%s %s (%s)\n%s: ", prompt1, cryptsource,
287
crypttarget, prompt2);
288
}
289
}
290
}
291
sret = getline(&buffer, &n, stdin);
292
if(sret > 0){
72
fprintf(stderr, "Password: ");
73
ret = getline(&buffer, &n, stdin);
74
if (ret > 0){
75
fprintf(stdout, "%s", buffer);
293
76
status = EXIT_SUCCESS;
294
/* Make n = data size instead of allocated buffer size */
295
n = (size_t)sret;
296
/* Strip final newline */
297
if(n > 0 and buffer[n-1] == '\n'){
298
buffer[n-1] = '\0'; /* not strictly necessary */
299
n--;
300
}
301
size_t written = 0;
302
while(written < n){
303
sret = write(STDOUT_FILENO, buffer + written, n - written);
304
if(sret < 0){
305
int e = errno;
306
error(0, errno, "write");
307
switch(e){
308
case EBADF:
309
case EFAULT:
310
case EINVAL:
311
case EFBIG:
312
case EIO:
313
case ENOSPC:
314
default:
315
status = EX_IOERR;
316
break;
317
case EINTR:
318
status = EXIT_FAILURE;
319
break;
320
}
321
break;
322
}
323
written += (size_t)sret;
324
}
325
sret = close(STDOUT_FILENO);
326
if(sret == -1){
327
int e = errno;
328
error(0, errno, "close");
329
switch(e){
330
case EBADF:
331
status = EX_OSFILE;
332
break;
333
case EIO:
334
default:
335
status = EX_IOERR;
336
break;
337
}
338
}
339
77
break;
340
78
}
341
if(sret < 0){
342
int e = errno;
343
if(errno != EINTR and not feof(stdin)){
344
error(0, errno, "getline");
345
switch(e){
346
case EBADF:
347
status = EX_UNAVAILABLE;
348
case EIO:
349
case EINVAL:
350
default:
351
status = EX_IOERR;
352
break;
353
}
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;
354
84
break;
355
85
}
356
86
}
357
/* if(sret == 0), then the only sensible thing to do is to retry to
358
read from stdin */
359
fputc('\n', stderr);
360
if(debug and not quit_now){
361
/* If quit_now is nonzero, we were interrupted by a signal, and
362
will print that later, so no need to show this too. */
363
fprintf(stderr, "getline() returned 0, retrying.\n");
364
}
365
}
366
367
free(buffer);
368
369
if(debug){
370
fprintf(stderr, "Restoring terminal attributes\n");
371
}
372
if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_old) != 0){
373
error(0, errno, "tcsetattr+echo");
374
}
375
376
if(quit_now){
377
sigemptyset(&old_action.sa_mask);
378
old_action.sa_handler = SIG_DFL;
379
ret = sigaction(signal_received, &old_action, NULL);
380
if(ret == -1){
381
error(0, errno, "sigaction");
382
}
383
raise(signal_received);
384
}
385
386
if(debug){
387
fprintf(stderr, "%s is exiting with status %d\n", argv[0],
388
status);
389
}
390
if(status == EXIT_SUCCESS or status == EX_OK){
391
fputc('\n', stderr);
87
fputc('\n', stderr);
88
}
89
90
if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_old) != 0){
91
perror("tcsetattr+echo");
392
92
}
393
93
394
94
return status;
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0