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/splashy.c
- browse files at revision 741
- compare with another revision
- download diff
- download tarball
- view history from revision 741
- Committer: Teddy Hogeborn
- Date: 2015-01-25 00:02:51 UTC
- Revision ID: teddy@recompile.se-20150125000251-j2bw50gfq9smqyxe
mandos.xml (SEE ALSO): Update links.
Update link to GnuPG home page, change reference from TLS 1.1 to TLS
1.2, and change to latest RFC for using OpenPGP keys with TLS (and use
its correct title).
Update link to GnuPG home page, change reference from TLS 1.1 to TLS
1.2, and change to latest RFC for using OpenPGP keys with TLS (and use
its correct title).
- files added:
- DBUS-API
- debian/source
- debian/upstream
- network-hooks.d
- files modified:
- .bzrignore
added
removed
plugins.d/splashy.c
2
2
/*
3
3
* Splashy - Read a password from splashy and output it
4
4
*
5
* Copyright © 2008,2009 Teddy Hogeborn
6
* Copyright © 2008,2009 Björn Påhlsson
5
* Copyright © 2008-2014 Teddy Hogeborn
6
* Copyright © 2008-2014 Björn Påhlsson
7
7
*
8
8
* This program is free software: you can redistribute it and/or
9
9
* modify it under the terms of the GNU General Public License as
19
19
* along with this program. If not, see
20
20
* <http://www.gnu.org/licenses/>.
21
21
*
22
* Contact the authors at <https://www.fukt.bsnet.se/~belorn/> and
23
* <https://www.fukt.bsnet.se/~teddy/>.
22
* Contact the authors at <mandos@recompile.se>.
24
23
*/
25
24
26
#define _GNU_SOURCE /* asprintf() */
25
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
27
26
#include <signal.h> /* sig_atomic_t, struct sigaction,
28
27
sigemptyset(), sigaddset(), SIGINT,
29
28
SIGHUP, SIGTERM, sigaction,
30
29
SIG_IGN, kill(), SIGKILL */
31
30
#include <stddef.h> /* NULL */
32
31
#include <stdlib.h> /* getenv() */
33
#include <stdio.h> /* asprintf(), perror() */
32
#include <stdio.h> /* asprintf(), vasprintf(), vprintf(),
33
fprintf() */
34
34
#include <stdlib.h> /* EXIT_FAILURE, free(),
35
35
EXIT_SUCCESS */
36
36
#include <sys/types.h> /* pid_t, DIR, struct dirent,
41
41
#include <iso646.h> /* not, or, and */
42
42
#include <unistd.h> /* readlink(), fork(), execl(),
43
43
sleep(), dup2() STDERR_FILENO,
44
STDOUT_FILENO, _exit() */
45
#include <string.h> /* memcmp() */
46
#include <errno.h> /* errno */
44
STDOUT_FILENO, _exit(),
45
pause() */
46
#include <string.h> /* memcmp(), strerror() */
47
#include <errno.h> /* errno, EACCES, ENOTDIR, ELOOP,
48
ENOENT, ENAMETOOLONG, EMFILE,
49
ENFILE, ENOMEM, ENOEXEC, EINVAL,
50
E2BIG, EFAULT, EIO, ETXTBSY,
51
EISDIR, ELIBBAD, EPERM, EINTR,
52
ECHILD */
53
#include <error.h> /* error() */
47
54
#include <sys/wait.h> /* waitpid(), WIFEXITED(),
48
55
WEXITSTATUS() */
56
#include <sysexits.h> /* EX_OSERR, EX_OSFILE,
57
EX_UNAVAILABLE */
58
#include <stdarg.h> /* va_list, va_start(), ... */
49
59
50
60
sig_atomic_t interrupted_by_signal = 0;
51
52
static void termination_handler(__attribute__((unused))int signum){
61
int signal_received;
62
63
/* Function to use when printing errors */
64
__attribute__((format (gnu_printf, 3, 4)))
65
void error_plus(int status, int errnum, const char *formatstring,
66
...){
67
va_list ap;
68
char *text;
69
int ret;
70
71
va_start(ap, formatstring);
72
ret = vasprintf(&text, formatstring, ap);
73
if(ret == -1){
74
fprintf(stderr, "Mandos plugin %s: ",
75
program_invocation_short_name);
76
vfprintf(stderr, formatstring, ap);
77
fprintf(stderr, ": ");
78
fprintf(stderr, "%s\n", strerror(errnum));
79
error(status, errno, "vasprintf while printing error");
80
return;
81
}
82
fprintf(stderr, "Mandos plugin ");
83
error(status, errnum, "%s", text);
84
free(text);
85
}
86
87
88
static void termination_handler(int signum){
89
if(interrupted_by_signal){
90
return;
91
}
53
92
interrupted_by_signal = 1;
93
signal_received = signum;
54
94
}
55
95
56
96
int main(__attribute__((unused))int argc,
57
97
__attribute__((unused))char **argv){
58
98
int ret = 0;
99
char *prompt = NULL;
100
DIR *proc_dir = NULL;
101
pid_t splashy_pid = 0;
102
pid_t splashy_command_pid = 0;
103
int exitstatus = EXIT_FAILURE;
59
104
60
105
/* Create prompt string */
61
char *prompt = NULL;
62
106
{
63
107
const char *const cryptsource = getenv("cryptsource");
64
108
const char *const crypttarget = getenv("crypttarget");
81
125
}
82
126
}
83
127
if(ret == -1){
84
return EXIT_FAILURE;
128
prompt = NULL;
129
exitstatus = EX_OSERR;
130
goto failure;
85
131
}
86
132
}
87
133
88
134
/* Find splashy process */
89
pid_t splashy_pid = 0;
90
135
{
91
136
const char splashy_name[] = "/sbin/splashy";
92
DIR *proc_dir = opendir("/proc");
137
proc_dir = opendir("/proc");
93
138
if(proc_dir == NULL){
94
free(prompt);
95
perror("opendir");
96
return EXIT_FAILURE;
139
int e = errno;
140
error_plus(0, errno, "opendir");
141
switch(e){
142
case EACCES:
143
case ENOTDIR:
144
case ELOOP:
145
case ENOENT:
146
default:
147
exitstatus = EX_OSFILE;
148
break;
149
case ENAMETOOLONG:
150
case EMFILE:
151
case ENFILE:
152
case ENOMEM:
153
exitstatus = EX_OSERR;
154
break;
155
}
156
goto failure;
97
157
}
98
158
for(struct dirent *proc_ent = readdir(proc_dir);
99
159
proc_ent != NULL;
119
179
char *exe_link;
120
180
ret = asprintf(&exe_link, "/proc/%s/exe", proc_ent->d_name);
121
181
if(ret == -1){
122
perror("asprintf");
123
free(prompt);
124
closedir(proc_dir);
125
return EXIT_FAILURE;
182
error_plus(0, errno, "asprintf");
183
exitstatus = EX_OSERR;
184
goto failure;
126
185
}
127
186
128
187
/* Check that it refers to a symlink owned by root:root */
133
192
free(exe_link);
134
193
continue;
135
194
}
136
perror("lstat");
195
int e = errno;
196
error_plus(0, errno, "lstat");
137
197
free(exe_link);
138
free(prompt);
139
closedir(proc_dir);
140
return EXIT_FAILURE;
198
switch(e){
199
case EACCES:
200
case ENOTDIR:
201
case ELOOP:
202
default:
203
exitstatus = EX_OSFILE;
204
break;
205
case ENAMETOOLONG:
206
exitstatus = EX_OSERR;
207
break;
208
}
209
goto failure;
141
210
}
142
211
if(not S_ISLNK(exe_stat.st_mode)
143
212
or exe_stat.st_uid != 0
157
226
}
158
227
}
159
228
closedir(proc_dir);
229
proc_dir = NULL;
160
230
}
161
231
if(splashy_pid == 0){
162
free(prompt);
163
return EXIT_FAILURE;
232
exitstatus = EX_UNAVAILABLE;
233
goto failure;
164
234
}
165
235
166
236
/* Set up the signal handler */
169
239
new_action = { .sa_handler = termination_handler,
170
240
.sa_flags = 0 };
171
241
sigemptyset(&new_action.sa_mask);
172
sigaddset(&new_action.sa_mask, SIGINT);
173
sigaddset(&new_action.sa_mask, SIGHUP);
174
sigaddset(&new_action.sa_mask, SIGTERM);
242
ret = sigaddset(&new_action.sa_mask, SIGINT);
243
if(ret == -1){
244
error_plus(0, errno, "sigaddset");
245
exitstatus = EX_OSERR;
246
goto failure;
247
}
248
ret = sigaddset(&new_action.sa_mask, SIGHUP);
249
if(ret == -1){
250
error_plus(0, errno, "sigaddset");
251
exitstatus = EX_OSERR;
252
goto failure;
253
}
254
ret = sigaddset(&new_action.sa_mask, SIGTERM);
255
if(ret == -1){
256
error_plus(0, errno, "sigaddset");
257
exitstatus = EX_OSERR;
258
goto failure;
259
}
175
260
ret = sigaction(SIGINT, NULL, &old_action);
176
261
if(ret == -1){
177
perror("sigaction");
178
free(prompt);
179
return EXIT_FAILURE;
262
error_plus(0, errno, "sigaction");
263
exitstatus = EX_OSERR;
264
goto failure;
180
265
}
181
266
if(old_action.sa_handler != SIG_IGN){
182
267
ret = sigaction(SIGINT, &new_action, NULL);
183
268
if(ret == -1){
184
perror("sigaction");
185
free(prompt);
186
return EXIT_FAILURE;
269
error_plus(0, errno, "sigaction");
270
exitstatus = EX_OSERR;
271
goto failure;
187
272
}
188
273
}
189
274
ret = sigaction(SIGHUP, NULL, &old_action);
190
275
if(ret == -1){
191
perror("sigaction");
192
free(prompt);
193
return EXIT_FAILURE;
276
error_plus(0, errno, "sigaction");
277
exitstatus = EX_OSERR;
278
goto failure;
194
279
}
195
280
if(old_action.sa_handler != SIG_IGN){
196
281
ret = sigaction(SIGHUP, &new_action, NULL);
197
282
if(ret == -1){
198
perror("sigaction");
199
free(prompt);
200
return EXIT_FAILURE;
283
error_plus(0, errno, "sigaction");
284
exitstatus = EX_OSERR;
285
goto failure;
201
286
}
202
287
}
203
288
ret = sigaction(SIGTERM, NULL, &old_action);
204
289
if(ret == -1){
205
perror("sigaction");
206
free(prompt);
207
return EXIT_FAILURE;
290
error_plus(0, errno, "sigaction");
291
exitstatus = EX_OSERR;
292
goto failure;
208
293
}
209
294
if(old_action.sa_handler != SIG_IGN){
210
295
ret = sigaction(SIGTERM, &new_action, NULL);
211
296
if(ret == -1){
212
perror("sigaction");
213
free(prompt);
214
return EXIT_FAILURE;
297
error_plus(0, errno, "sigaction");
298
exitstatus = EX_OSERR;
299
goto failure;
215
300
}
216
301
}
217
302
}
218
303
304
if(interrupted_by_signal){
305
goto failure;
306
}
307
219
308
/* Fork off the splashy command to prompt for password */
220
pid_t splashy_command_pid = 0;
221
if(not interrupted_by_signal){
222
splashy_command_pid = fork();
223
if(splashy_command_pid == -1){
224
if(not interrupted_by_signal){
225
perror("fork");
226
}
227
return EXIT_FAILURE;
228
}
229
/* Child */
230
if(splashy_command_pid == 0){
309
splashy_command_pid = fork();
310
if(splashy_command_pid != 0 and interrupted_by_signal){
311
goto failure;
312
}
313
if(splashy_command_pid == -1){
314
error_plus(0, errno, "fork");
315
exitstatus = EX_OSERR;
316
goto failure;
317
}
318
/* Child */
319
if(splashy_command_pid == 0){
320
if(not interrupted_by_signal){
231
321
const char splashy_command[] = "/sbin/splashy_update";
232
ret = execl(splashy_command, splashy_command, prompt,
233
(char *)NULL);
234
if(not interrupted_by_signal){
235
perror("execl");
322
execl(splashy_command, splashy_command, prompt, (char *)NULL);
323
int e = errno;
324
error_plus(0, errno, "execl");
325
switch(e){
326
case EACCES:
327
case ENOENT:
328
case ENOEXEC:
329
case EINVAL:
330
_exit(EX_UNAVAILABLE);
331
case ENAMETOOLONG:
332
case E2BIG:
333
case ENOMEM:
334
case EFAULT:
335
case EIO:
336
case EMFILE:
337
case ENFILE:
338
case ETXTBSY:
339
default:
340
_exit(EX_OSERR);
341
case ENOTDIR:
342
case ELOOP:
343
case EISDIR:
344
#ifdef ELIBBAD
345
case ELIBBAD: /* Linux only */
346
#endif
347
case EPERM:
348
_exit(EX_OSFILE);
236
349
}
237
free(prompt);
238
_exit(EXIT_FAILURE);
239
350
}
351
free(prompt);
352
_exit(EXIT_FAILURE);
240
353
}
241
354
242
355
/* Parent */
243
356
free(prompt);
357
prompt = NULL;
358
359
if(interrupted_by_signal){
360
goto failure;
361
}
244
362
245
363
/* Wait for command to complete */
246
if(not interrupted_by_signal and splashy_command_pid != 0){
364
{
247
365
int status;
248
ret = waitpid(splashy_command_pid, &status, 0);
366
do {
367
ret = waitpid(splashy_command_pid, &status, 0);
368
} while(ret == -1 and errno == EINTR
369
and not interrupted_by_signal);
370
if(interrupted_by_signal){
371
goto failure;
372
}
249
373
if(ret == -1){
250
if(errno != EINTR){
251
perror("waitpid");
252
}
374
error_plus(0, errno, "waitpid");
253
375
if(errno == ECHILD){
254
376
splashy_command_pid = 0;
255
377
}
256
378
} else {
257
379
/* The child process has exited */
258
380
splashy_command_pid = 0;
259
if(not interrupted_by_signal and WIFEXITED(status)
260
and WEXITSTATUS(status)==0){
381
if(WIFEXITED(status) and WEXITSTATUS(status) == 0){
261
382
return EXIT_SUCCESS;
262
383
}
263
384
}
264
385
}
265
kill(splashy_pid, SIGTERM);
266
if(interrupted_by_signal and splashy_command_pid != 0){
267
kill(splashy_command_pid, SIGTERM);
268
}
269
sleep(2);
270
while(kill(splashy_pid, 0) == 0){
271
kill(splashy_pid, SIGKILL);
272
sleep(1);
273
}
274
pid_t new_splashy_pid = fork();
275
if(new_splashy_pid == 0){
276
/* Child; will become new splashy process */
277
278
/* Make the effective user ID (root) the only user ID instead of
279
the real user ID (_mandos) */
280
ret = setuid(geteuid());
281
if(ret == -1){
282
perror("setuid");
283
}
284
285
setsid();
286
ret = chdir("/");
287
/* if(fork() != 0){ */
288
/* _exit(EXIT_SUCCESS); */
289
/* } */
290
ret = dup2(STDERR_FILENO, STDOUT_FILENO); /* replace our stdout */
291
if(ret == -1){
292
perror("dup2");
293
_exit(EXIT_FAILURE);
294
}
295
296
execl("/sbin/splashy", "/sbin/splashy", "boot", (char *)NULL);
297
if(not interrupted_by_signal){
298
perror("execl");
299
}
300
_exit(EXIT_FAILURE);
301
}
302
303
return EXIT_FAILURE;
386
387
failure:
388
389
free(prompt);
390
391
if(proc_dir != NULL){
392
TEMP_FAILURE_RETRY(closedir(proc_dir));
393
}
394
395
if(splashy_command_pid != 0){
396
TEMP_FAILURE_RETRY(kill(splashy_command_pid, SIGTERM));
397
398
TEMP_FAILURE_RETRY(kill(splashy_pid, SIGTERM));
399
sleep(2);
400
while(TEMP_FAILURE_RETRY(kill(splashy_pid, 0)) == 0){
401
TEMP_FAILURE_RETRY(kill(splashy_pid, SIGKILL));
402
sleep(1);
403
}
404
pid_t new_splashy_pid = (pid_t)TEMP_FAILURE_RETRY(fork());
405
if(new_splashy_pid == 0){
406
/* Child; will become new splashy process */
407
408
/* Make the effective user ID (root) the only user ID instead of
409
the real user ID (_mandos) */
410
ret = setuid(geteuid());
411
if(ret == -1){
412
error_plus(0, errno, "setuid");
413
}
414
415
setsid();
416
ret = chdir("/");
417
if(ret == -1){
418
error_plus(0, errno, "chdir");
419
}
420
/* if(fork() != 0){ */
421
/* _exit(EXIT_SUCCESS); */
422
/* } */
423
ret = dup2(STDERR_FILENO, STDOUT_FILENO); /* replace stdout */
424
if(ret == -1){
425
error_plus(0, errno, "dup2");
426
_exit(EX_OSERR);
427
}
428
429
execl("/sbin/splashy", "/sbin/splashy", "boot", (char *)NULL);
430
{
431
int e = errno;
432
error_plus(0, errno, "execl");
433
switch(e){
434
case EACCES:
435
case ENOENT:
436
case ENOEXEC:
437
default:
438
_exit(EX_UNAVAILABLE);
439
case ENAMETOOLONG:
440
case E2BIG:
441
case ENOMEM:
442
_exit(EX_OSERR);
443
case ENOTDIR:
444
case ELOOP:
445
_exit(EX_OSFILE);
446
}
447
}
448
}
449
}
450
451
if(interrupted_by_signal){
452
struct sigaction signal_action;
453
sigemptyset(&signal_action.sa_mask);
454
signal_action.sa_handler = SIG_DFL;
455
ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
456
&signal_action, NULL));
457
if(ret == -1){
458
error_plus(0, errno, "sigaction");
459
}
460
do {
461
ret = raise(signal_received);
462
} while(ret != 0 and errno == EINTR);
463
if(ret != 0){
464
error_plus(0, errno, "raise");
465
abort();
466
}
467
TEMP_FAILURE_RETRY(pause());
468
}
469
470
return exitstatus;
304
471
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0