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/usplash.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/usplash.c
1
/* -*- coding: utf-8 -*- */
2
/*
3
* Usplash - Read a password from usplash and output 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
#define _GNU_SOURCE /* asprintf(), TEMP_FAILURE_RETRY() */
26
#include <signal.h> /* sig_atomic_t, struct sigaction,
27
sigemptyset(), sigaddset(), SIGINT,
28
SIGHUP, SIGTERM, sigaction(),
29
SIG_IGN, kill(), SIGKILL */
30
#include <stdbool.h> /* bool, false, true */
31
#include <fcntl.h> /* open(), O_WRONLY, O_RDONLY */
32
#include <iso646.h> /* and, or, not*/
33
#include <errno.h> /* errno, EINTR */
34
#include <error.h>
35
#include <sys/types.h> /* size_t, ssize_t, pid_t, DIR, struct
36
dirent */
37
#include <stddef.h> /* NULL */
38
#include <string.h> /* strlen(), memcmp() */
39
#include <stdio.h> /* asprintf()*/
40
#include <unistd.h> /* close(), write(), readlink(),
41
read(), STDOUT_FILENO, sleep(),
42
fork(), setuid(), geteuid(),
43
setsid(), chdir(), dup2(),
44
STDERR_FILENO, execv() */
45
#include <stdlib.h> /* free(), EXIT_FAILURE, realloc(),
46
EXIT_SUCCESS, malloc(), _exit(),
47
getenv() */
48
#include <dirent.h> /* opendir(), readdir(), closedir() */
49
#include <inttypes.h> /* intmax_t, strtoimax() */
50
#include <sys/stat.h> /* struct stat, lstat(), S_ISLNK */
51
#include <sysexits.h> /* EX_OSERR, EX_UNAVAILABLE */
52
#include <argz.h> /* argz_count(), argz_extract() */
53
54
sig_atomic_t interrupted_by_signal = 0;
55
int signal_received;
56
const char usplash_name[] = "/sbin/usplash";
57
58
static void termination_handler(int signum){
59
if(interrupted_by_signal){
60
return;
61
}
62
interrupted_by_signal = 1;
63
signal_received = signum;
64
}
65
66
static bool usplash_write(int *fifo_fd_r,
67
const char *cmd, const char *arg){
68
/*
69
* usplash_write(&fd, "TIMEOUT", "15") will write "TIMEOUT 15\0"
70
* usplash_write(&fd, "PULSATE", NULL) will write "PULSATE\0"
71
* SEE ALSO
72
* usplash_write(8)
73
*/
74
int ret;
75
if(*fifo_fd_r == -1){
76
ret = open("/dev/.initramfs/usplash_fifo", O_WRONLY);
77
if(ret == -1){
78
return false;
79
}
80
*fifo_fd_r = ret;
81
}
82
83
const char *cmd_line;
84
size_t cmd_line_len;
85
char *cmd_line_alloc = NULL;
86
if(arg == NULL){
87
cmd_line = cmd;
88
cmd_line_len = strlen(cmd) + 1;
89
} else {
90
do {
91
ret = asprintf(&cmd_line_alloc, "%s %s", cmd, arg);
92
if(ret == -1){
93
int e = errno;
94
TEMP_FAILURE_RETRY(close(*fifo_fd_r));
95
errno = e;
96
return false;
97
}
98
} while(ret == -1);
99
cmd_line = cmd_line_alloc;
100
cmd_line_len = (size_t)ret + 1;
101
}
102
103
size_t written = 0;
104
ssize_t sret = 0;
105
while(written < cmd_line_len){
106
sret = write(*fifo_fd_r, cmd_line + written,
107
cmd_line_len - written);
108
if(sret == -1){
109
int e = errno;
110
TEMP_FAILURE_RETRY(close(*fifo_fd_r));
111
free(cmd_line_alloc);
112
errno = e;
113
return false;
114
}
115
written += (size_t)sret;
116
}
117
free(cmd_line_alloc);
118
119
return true;
120
}
121
122
/* Create prompt string */
123
char *makeprompt(void){
124
int ret = 0;
125
char *prompt;
126
const char *const cryptsource = getenv("cryptsource");
127
const char *const crypttarget = getenv("crypttarget");
128
const char prompt_start[] = "Enter passphrase to unlock the disk";
129
130
if(cryptsource == NULL){
131
if(crypttarget == NULL){
132
ret = asprintf(&prompt, "%s: ", prompt_start);
133
} else {
134
ret = asprintf(&prompt, "%s (%s): ", prompt_start,
135
crypttarget);
136
}
137
} else {
138
if(crypttarget == NULL){
139
ret = asprintf(&prompt, "%s %s: ", prompt_start, cryptsource);
140
} else {
141
ret = asprintf(&prompt, "%s %s (%s): ", prompt_start,
142
cryptsource, crypttarget);
143
}
144
}
145
if(ret == -1){
146
return NULL;
147
}
148
return prompt;
149
}
150
151
pid_t find_usplash(char **cmdline_r, size_t *cmdline_len_r){
152
int ret = 0;
153
ssize_t sret = 0;
154
char *cmdline = NULL;
155
size_t cmdline_len = 0;
156
DIR *proc_dir = opendir("/proc");
157
if(proc_dir == NULL){
158
error(0, errno, "opendir");
159
return -1;
160
}
161
errno = 0;
162
for(struct dirent *proc_ent = readdir(proc_dir);
163
proc_ent != NULL;
164
proc_ent = readdir(proc_dir)){
165
pid_t pid;
166
{
167
intmax_t tmpmax;
168
char *tmp;
169
tmpmax = strtoimax(proc_ent->d_name, &tmp, 10);
170
if(errno != 0 or tmp == proc_ent->d_name or *tmp != '\0'
171
or tmpmax != (pid_t)tmpmax){
172
/* Not a process */
173
errno = 0;
174
continue;
175
}
176
pid = (pid_t)tmpmax;
177
}
178
/* Find the executable name by doing readlink() on the
179
/proc/<pid>/exe link */
180
char exe_target[sizeof(usplash_name)];
181
{
182
/* create file name string */
183
char *exe_link;
184
ret = asprintf(&exe_link, "/proc/%s/exe", proc_ent->d_name);
185
if(ret == -1){
186
error(0, errno, "asprintf");
187
goto fail_find_usplash;
188
}
189
190
/* Check that it refers to a symlink owned by root:root */
191
struct stat exe_stat;
192
ret = lstat(exe_link, &exe_stat);
193
if(ret == -1){
194
if(errno == ENOENT){
195
free(exe_link);
196
continue;
197
}
198
error(0, errno, "lstat");
199
free(exe_link);
200
goto fail_find_usplash;
201
}
202
if(not S_ISLNK(exe_stat.st_mode)
203
or exe_stat.st_uid != 0
204
or exe_stat.st_gid != 0){
205
free(exe_link);
206
continue;
207
}
208
209
sret = readlink(exe_link, exe_target, sizeof(exe_target));
210
free(exe_link);
211
}
212
/* Compare executable name */
213
if((sret != ((ssize_t)sizeof(exe_target)-1))
214
or (memcmp(usplash_name, exe_target,
215
sizeof(exe_target)-1) != 0)){
216
/* Not it */
217
continue;
218
}
219
/* Found usplash */
220
/* Read and save the command line of usplash in "cmdline" */
221
{
222
/* Open /proc/<pid>/cmdline */
223
int cl_fd;
224
{
225
char *cmdline_filename;
226
ret = asprintf(&cmdline_filename, "/proc/%s/cmdline",
227
proc_ent->d_name);
228
if(ret == -1){
229
error(0, errno, "asprintf");
230
goto fail_find_usplash;
231
}
232
cl_fd = open(cmdline_filename, O_RDONLY);
233
free(cmdline_filename);
234
if(cl_fd == -1){
235
error(0, errno, "open");
236
goto fail_find_usplash;
237
}
238
}
239
size_t cmdline_allocated = 0;
240
char *tmp;
241
const size_t blocksize = 1024;
242
do {
243
/* Allocate more space? */
244
if(cmdline_len + blocksize > cmdline_allocated){
245
tmp = realloc(cmdline, cmdline_allocated + blocksize);
246
if(tmp == NULL){
247
error(0, errno, "realloc");
248
close(cl_fd);
249
goto fail_find_usplash;
250
}
251
cmdline = tmp;
252
cmdline_allocated += blocksize;
253
}
254
/* Read data */
255
sret = read(cl_fd, cmdline + cmdline_len,
256
cmdline_allocated - cmdline_len);
257
if(sret == -1){
258
error(0, errno, "read");
259
close(cl_fd);
260
goto fail_find_usplash;
261
}
262
cmdline_len += (size_t)sret;
263
} while(sret != 0);
264
ret = close(cl_fd);
265
if(ret == -1){
266
error(0, errno, "close");
267
goto fail_find_usplash;
268
}
269
}
270
/* Close directory */
271
ret = closedir(proc_dir);
272
if(ret == -1){
273
error(0, errno, "closedir");
274
goto fail_find_usplash;
275
}
276
/* Success */
277
*cmdline_r = cmdline;
278
*cmdline_len_r = cmdline_len;
279
return pid;
280
}
281
282
fail_find_usplash:
283
284
free(cmdline);
285
if(proc_dir != NULL){
286
int e = errno;
287
closedir(proc_dir);
288
errno = e;
289
}
290
return 0;
291
}
292
293
int main(__attribute__((unused))int argc,
294
__attribute__((unused))char **argv){
295
int ret = 0;
296
ssize_t sret;
297
int fifo_fd = -1;
298
int outfifo_fd = -1;
299
char *buf = NULL;
300
size_t buf_len = 0;
301
pid_t usplash_pid = -1;
302
bool usplash_accessed = false;
303
int status = EXIT_FAILURE; /* Default failure exit status */
304
305
char *prompt = makeprompt();
306
if(prompt == NULL){
307
status = EX_OSERR;
308
goto failure;
309
}
310
311
/* Find usplash process */
312
char *cmdline = NULL;
313
size_t cmdline_len = 0;
314
usplash_pid = find_usplash(&cmdline, &cmdline_len);
315
if(usplash_pid == 0){
316
status = EX_UNAVAILABLE;
317
goto failure;
318
}
319
320
/* Set up the signal handler */
321
{
322
struct sigaction old_action,
323
new_action = { .sa_handler = termination_handler,
324
.sa_flags = 0 };
325
sigemptyset(&new_action.sa_mask);
326
ret = sigaddset(&new_action.sa_mask, SIGINT);
327
if(ret == -1){
328
error(0, errno, "sigaddset");
329
status = EX_OSERR;
330
goto failure;
331
}
332
ret = sigaddset(&new_action.sa_mask, SIGHUP);
333
if(ret == -1){
334
error(0, errno, "sigaddset");
335
status = EX_OSERR;
336
goto failure;
337
}
338
ret = sigaddset(&new_action.sa_mask, SIGTERM);
339
if(ret == -1){
340
error(0, errno, "sigaddset");
341
status = EX_OSERR;
342
goto failure;
343
}
344
ret = sigaction(SIGINT, NULL, &old_action);
345
if(ret == -1){
346
if(errno != EINTR){
347
error(0, errno, "sigaction");
348
status = EX_OSERR;
349
}
350
goto failure;
351
}
352
if(old_action.sa_handler != SIG_IGN){
353
ret = sigaction(SIGINT, &new_action, NULL);
354
if(ret == -1){
355
if(errno != EINTR){
356
error(0, errno, "sigaction");
357
status = EX_OSERR;
358
}
359
goto failure;
360
}
361
}
362
ret = sigaction(SIGHUP, NULL, &old_action);
363
if(ret == -1){
364
if(errno != EINTR){
365
error(0, errno, "sigaction");
366
status = EX_OSERR;
367
}
368
goto failure;
369
}
370
if(old_action.sa_handler != SIG_IGN){
371
ret = sigaction(SIGHUP, &new_action, NULL);
372
if(ret == -1){
373
if(errno != EINTR){
374
error(0, errno, "sigaction");
375
status = EX_OSERR;
376
}
377
goto failure;
378
}
379
}
380
ret = sigaction(SIGTERM, NULL, &old_action);
381
if(ret == -1){
382
if(errno != EINTR){
383
error(0, errno, "sigaction");
384
status = EX_OSERR;
385
}
386
goto failure;
387
}
388
if(old_action.sa_handler != SIG_IGN){
389
ret = sigaction(SIGTERM, &new_action, NULL);
390
if(ret == -1){
391
if(errno != EINTR){
392
error(0, errno, "sigaction");
393
status = EX_OSERR;
394
}
395
goto failure;
396
}
397
}
398
}
399
400
usplash_accessed = true;
401
/* Write command to FIFO */
402
if(not usplash_write(&fifo_fd, "TIMEOUT", "0")){
403
if(errno != EINTR){
404
error(0, errno, "usplash_write");
405
status = EX_OSERR;
406
}
407
goto failure;
408
}
409
410
if(interrupted_by_signal){
411
goto failure;
412
}
413
414
if(not usplash_write(&fifo_fd, "INPUTQUIET", prompt)){
415
if(errno != EINTR){
416
error(0, errno, "usplash_write");
417
status = EX_OSERR;
418
}
419
goto failure;
420
}
421
422
if(interrupted_by_signal){
423
goto failure;
424
}
425
426
free(prompt);
427
prompt = NULL;
428
429
/* Read reply from usplash */
430
/* Open FIFO */
431
outfifo_fd = open("/dev/.initramfs/usplash_outfifo", O_RDONLY);
432
if(outfifo_fd == -1){
433
if(errno != EINTR){
434
error(0, errno, "open");
435
status = EX_OSERR;
436
}
437
goto failure;
438
}
439
440
if(interrupted_by_signal){
441
goto failure;
442
}
443
444
/* Read from FIFO */
445
size_t buf_allocated = 0;
446
const size_t blocksize = 1024;
447
do {
448
/* Allocate more space */
449
if(buf_len + blocksize > buf_allocated){
450
char *tmp = realloc(buf, buf_allocated + blocksize);
451
if(tmp == NULL){
452
if(errno != EINTR){
453
error(0, errno, "realloc");
454
status = EX_OSERR;
455
}
456
goto failure;
457
}
458
buf = tmp;
459
buf_allocated += blocksize;
460
}
461
sret = read(outfifo_fd, buf + buf_len,
462
buf_allocated - buf_len);
463
if(sret == -1){
464
if(errno != EINTR){
465
error(0, errno, "read");
466
status = EX_OSERR;
467
}
468
TEMP_FAILURE_RETRY(close(outfifo_fd));
469
goto failure;
470
}
471
if(interrupted_by_signal){
472
break;
473
}
474
475
buf_len += (size_t)sret;
476
} while(sret != 0);
477
ret = close(outfifo_fd);
478
if(ret == -1){
479
if(errno != EINTR){
480
error(0, errno, "close");
481
status = EX_OSERR;
482
}
483
goto failure;
484
}
485
outfifo_fd = -1;
486
487
if(interrupted_by_signal){
488
goto failure;
489
}
490
491
if(not usplash_write(&fifo_fd, "TIMEOUT", "15")){
492
if(errno != EINTR){
493
error(0, errno, "usplash_write");
494
status = EX_OSERR;
495
}
496
goto failure;
497
}
498
499
if(interrupted_by_signal){
500
goto failure;
501
}
502
503
ret = close(fifo_fd);
504
if(ret == -1){
505
if(errno != EINTR){
506
error(0, errno, "close");
507
status = EX_OSERR;
508
}
509
goto failure;
510
}
511
fifo_fd = -1;
512
513
/* Print password to stdout */
514
size_t written = 0;
515
while(written < buf_len){
516
do {
517
sret = write(STDOUT_FILENO, buf + written, buf_len - written);
518
if(sret == -1){
519
if(errno != EINTR){
520
error(0, errno, "write");
521
status = EX_OSERR;
522
}
523
goto failure;
524
}
525
} while(sret == -1);
526
527
if(interrupted_by_signal){
528
goto failure;
529
}
530
written += (size_t)sret;
531
}
532
free(buf);
533
buf = NULL;
534
535
if(interrupted_by_signal){
536
goto failure;
537
}
538
539
free(cmdline);
540
return EXIT_SUCCESS;
541
542
failure:
543
544
free(buf);
545
546
free(prompt);
547
548
/* If usplash was never accessed, we can stop now */
549
if(not usplash_accessed){
550
return status;
551
}
552
553
/* Close FIFO */
554
if(fifo_fd != -1){
555
ret = (int)TEMP_FAILURE_RETRY(close(fifo_fd));
556
if(ret == -1 and errno != EINTR){
557
error(0, errno, "close");
558
}
559
fifo_fd = -1;
560
}
561
562
/* Close output FIFO */
563
if(outfifo_fd != -1){
564
ret = (int)TEMP_FAILURE_RETRY(close(outfifo_fd));
565
if(ret == -1){
566
error(0, errno, "close");
567
}
568
}
569
570
/* Create argv for new usplash*/
571
char **cmdline_argv = malloc((argz_count(cmdline, cmdline_len) + 1)
572
* sizeof(char *)); /* Count args */
573
if(cmdline_argv == NULL){
574
error(0, errno, "malloc");
575
return status;
576
}
577
argz_extract(cmdline, cmdline_len, cmdline_argv); /* Create argv */
578
579
/* Kill old usplash */
580
kill(usplash_pid, SIGTERM);
581
sleep(2);
582
while(kill(usplash_pid, 0) == 0){
583
kill(usplash_pid, SIGKILL);
584
sleep(1);
585
}
586
587
pid_t new_usplash_pid = fork();
588
if(new_usplash_pid == 0){
589
/* Child; will become new usplash process */
590
591
/* Make the effective user ID (root) the only user ID instead of
592
the real user ID (_mandos) */
593
ret = setuid(geteuid());
594
if(ret == -1){
595
error(0, errno, "setuid");
596
}
597
598
setsid();
599
ret = chdir("/");
600
if(ret == -1){
601
error(0, errno, "chdir");
602
_exit(EX_OSERR);
603
}
604
/* if(fork() != 0){ */
605
/* _exit(EXIT_SUCCESS); */
606
/* } */
607
ret = dup2(STDERR_FILENO, STDOUT_FILENO); /* replace our stdout */
608
if(ret == -1){
609
error(0, errno, "dup2");
610
_exit(EX_OSERR);
611
}
612
613
execv(usplash_name, cmdline_argv);
614
if(not interrupted_by_signal){
615
error(0, errno, "execv");
616
}
617
free(cmdline);
618
free(cmdline_argv);
619
_exit(EX_OSERR);
620
}
621
free(cmdline);
622
free(cmdline_argv);
623
sleep(2);
624
if(not usplash_write(&fifo_fd, "PULSATE", NULL)){
625
if(errno != EINTR){
626
error(0, errno, "usplash_write");
627
}
628
}
629
630
/* Close FIFO (again) */
631
if(fifo_fd != -1){
632
ret = (int)TEMP_FAILURE_RETRY(close(fifo_fd));
633
if(ret == -1 and errno != EINTR){
634
error(0, errno, "close");
635
}
636
fifo_fd = -1;
637
}
638
639
if(interrupted_by_signal){
640
struct sigaction signal_action = { .sa_handler = SIG_DFL };
641
sigemptyset(&signal_action.sa_mask);
642
ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
643
&signal_action, NULL));
644
if(ret == -1){
645
error(0, errno, "sigaction");
646
}
647
do {
648
ret = raise(signal_received);
649
} while(ret != 0 and errno == EINTR);
650
if(ret != 0){
651
error(0, errno, "raise");
652
abort();
653
}
654
TEMP_FAILURE_RETRY(pause());
655
}
656
657
return status;
658
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0