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