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 541
- compare with another revision
- download diff
- download tarball
- view history from revision 541
- Committer: Teddy Hogeborn
- Date: 2011-12-31 20:07:11 UTC
- mfrom: (535.1.9 wireless-network-hook)
- Revision ID: teddy@recompile.se-20111231200711-6dli3r8drftem57r
Merge new wireless network hook. Fix bridge network hook to use
hardware addresses instead of interface names. Implement and document
new "CONNECT" environment variable for network hooks.
hardware addresses instead of interface names. Implement and document
new "CONNECT" environment variable for network hooks.
- files added:
- DBUS-API
- debian/source
- network-hooks.d
- files removed:
- debian/mandos-client.config
- files modified:
- .bzrignore
added
removed
plugins.d/splashy.c
1
1
/* -*- coding: utf-8 -*- */
2
2
/*
3
* Passprompt - Read a password from splashy and output it
3
* Splashy - Read a password from splashy and output it
4
4
*
5
* Copyright © 2008 Teddy Hogeborn
6
* Copyright © 2008 Björn Påhlsson
5
* Copyright © 2008-2011 Teddy Hogeborn
6
* Copyright © 2008-2011 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() */
34
#include <stdlib.h> /* EXIT_FAILURE, free(), strtoul(),
32
#include <stdio.h> /* asprintf(), vasprintf(), vprintf(),
33
fprintf() */
34
#include <stdlib.h> /* EXIT_FAILURE, free(),
35
35
EXIT_SUCCESS */
36
36
#include <sys/types.h> /* pid_t, DIR, struct dirent,
37
37
ssize_t */
38
38
#include <dirent.h> /* opendir(), readdir(), closedir() */
39
#include <inttypes.h> /* intmax_t, strtoimax() */
39
40
#include <sys/stat.h> /* struct stat, lstat(), S_ISLNK */
40
41
#include <iso646.h> /* not, or, and */
41
42
#include <unistd.h> /* readlink(), fork(), execl(),
42
43
sleep(), dup2() STDERR_FILENO,
43
STDOUT_FILENO, _exit() */
44
#include <string.h> /* memcmp() */
45
#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() */
46
54
#include <sys/wait.h> /* waitpid(), WIFEXITED(),
47
55
WEXITSTATUS() */
56
#include <sysexits.h> /* EX_OSERR, EX_OSFILE,
57
EX_UNAVAILABLE */
58
#include <stdarg.h> /* va_list, va_start(), ... */
48
59
49
60
sig_atomic_t interrupted_by_signal = 0;
50
51
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
}
52
92
interrupted_by_signal = 1;
93
signal_received = signum;
53
94
}
54
95
55
96
int main(__attribute__((unused))int argc,
56
97
__attribute__((unused))char **argv){
57
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;
58
104
59
105
/* Create prompt string */
60
char *prompt = NULL;
61
106
{
62
107
const char *const cryptsource = getenv("cryptsource");
63
108
const char *const crypttarget = getenv("crypttarget");
80
125
}
81
126
}
82
127
if(ret == -1){
83
return EXIT_FAILURE;
128
prompt = NULL;
129
exitstatus = EX_OSERR;
130
goto failure;
84
131
}
85
132
}
86
133
87
134
/* Find splashy process */
88
pid_t splashy_pid = 0;
89
135
{
90
136
const char splashy_name[] = "/sbin/splashy";
91
DIR *proc_dir = opendir("/proc");
137
proc_dir = opendir("/proc");
92
138
if(proc_dir == NULL){
93
free(prompt);
94
perror("opendir");
95
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;
96
157
}
97
158
for(struct dirent *proc_ent = readdir(proc_dir);
98
159
proc_ent != NULL;
99
160
proc_ent = readdir(proc_dir)){
100
pid_t pid = (pid_t) strtoul(proc_ent->d_name, NULL, 10);
101
if(pid == 0){
102
/* Not a process */
103
continue;
161
pid_t pid;
162
{
163
intmax_t tmpmax;
164
char *tmp;
165
errno = 0;
166
tmpmax = strtoimax(proc_ent->d_name, &tmp, 10);
167
if(errno != 0 or tmp == proc_ent->d_name or *tmp != '\0'
168
or tmpmax != (pid_t)tmpmax){
169
/* Not a process */
170
continue;
171
}
172
pid = (pid_t)tmpmax;
104
173
}
105
174
/* Find the executable name by doing readlink() on the
106
175
/proc/<pid>/exe link */
110
179
char *exe_link;
111
180
ret = asprintf(&exe_link, "/proc/%s/exe", proc_ent->d_name);
112
181
if(ret == -1){
113
perror("asprintf");
114
free(prompt);
115
closedir(proc_dir);
116
return EXIT_FAILURE;
182
error_plus(0, errno, "asprintf");
183
exitstatus = EX_OSERR;
184
goto failure;
117
185
}
118
186
119
187
/* Check that it refers to a symlink owned by root:root */
120
188
struct stat exe_stat;
121
189
ret = lstat(exe_link, &exe_stat);
122
190
if(ret == -1){
123
perror("lstat");
191
if(errno == ENOENT){
192
free(exe_link);
193
continue;
194
}
195
int e = errno;
196
error_plus(0, errno, "lstat");
124
197
free(exe_link);
125
free(prompt);
126
closedir(proc_dir);
127
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;
128
210
}
129
211
if(not S_ISLNK(exe_stat.st_mode)
130
212
or exe_stat.st_uid != 0
144
226
}
145
227
}
146
228
closedir(proc_dir);
229
proc_dir = NULL;
147
230
}
148
231
if(splashy_pid == 0){
149
free(prompt);
150
return EXIT_FAILURE;
232
exitstatus = EX_UNAVAILABLE;
233
goto failure;
151
234
}
152
235
153
236
/* Set up the signal handler */
156
239
new_action = { .sa_handler = termination_handler,
157
240
.sa_flags = 0 };
158
241
sigemptyset(&new_action.sa_mask);
159
sigaddset(&new_action.sa_mask, SIGINT);
160
sigaddset(&new_action.sa_mask, SIGHUP);
161
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
}
162
260
ret = sigaction(SIGINT, NULL, &old_action);
163
261
if(ret == -1){
164
perror("sigaction");
165
free(prompt);
166
return EXIT_FAILURE;
262
error_plus(0, errno, "sigaction");
263
exitstatus = EX_OSERR;
264
goto failure;
167
265
}
168
266
if(old_action.sa_handler != SIG_IGN){
169
267
ret = sigaction(SIGINT, &new_action, NULL);
170
268
if(ret == -1){
171
perror("sigaction");
172
free(prompt);
173
return EXIT_FAILURE;
269
error_plus(0, errno, "sigaction");
270
exitstatus = EX_OSERR;
271
goto failure;
174
272
}
175
273
}
176
274
ret = sigaction(SIGHUP, NULL, &old_action);
177
275
if(ret == -1){
178
perror("sigaction");
179
free(prompt);
180
return EXIT_FAILURE;
276
error_plus(0, errno, "sigaction");
277
exitstatus = EX_OSERR;
278
goto failure;
181
279
}
182
280
if(old_action.sa_handler != SIG_IGN){
183
281
ret = sigaction(SIGHUP, &new_action, NULL);
184
282
if(ret == -1){
185
perror("sigaction");
186
free(prompt);
187
return EXIT_FAILURE;
283
error_plus(0, errno, "sigaction");
284
exitstatus = EX_OSERR;
285
goto failure;
188
286
}
189
287
}
190
288
ret = sigaction(SIGTERM, NULL, &old_action);
191
289
if(ret == -1){
192
perror("sigaction");
193
free(prompt);
194
return EXIT_FAILURE;
290
error_plus(0, errno, "sigaction");
291
exitstatus = EX_OSERR;
292
goto failure;
195
293
}
196
294
if(old_action.sa_handler != SIG_IGN){
197
295
ret = sigaction(SIGTERM, &new_action, NULL);
198
296
if(ret == -1){
199
perror("sigaction");
200
free(prompt);
201
return EXIT_FAILURE;
297
error_plus(0, errno, "sigaction");
298
exitstatus = EX_OSERR;
299
goto failure;
202
300
}
203
301
}
204
302
}
205
303
304
if(interrupted_by_signal){
305
goto failure;
306
}
307
206
308
/* Fork off the splashy command to prompt for password */
207
pid_t splashy_command_pid = 0;
208
if(not interrupted_by_signal){
209
splashy_command_pid = fork();
210
if(splashy_command_pid == -1){
211
if(not interrupted_by_signal){
212
perror("fork");
213
}
214
return EXIT_FAILURE;
215
}
216
/* Child */
217
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){
218
321
const char splashy_command[] = "/sbin/splashy_update";
219
ret = execl(splashy_command, splashy_command, prompt,
220
(char *)NULL);
221
if(not interrupted_by_signal){
222
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);
223
349
}
224
free(prompt);
225
_exit(EXIT_FAILURE);
226
350
}
351
free(prompt);
352
_exit(EXIT_FAILURE);
227
353
}
228
354
229
355
/* Parent */
230
356
free(prompt);
357
prompt = NULL;
358
359
if(interrupted_by_signal){
360
goto failure;
361
}
231
362
232
363
/* Wait for command to complete */
233
if(not interrupted_by_signal and splashy_command_pid != 0){
364
{
234
365
int status;
235
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
}
236
373
if(ret == -1){
237
if(errno != EINTR){
238
perror("waitpid");
239
}
374
error_plus(0, errno, "waitpid");
240
375
if(errno == ECHILD){
241
376
splashy_command_pid = 0;
242
377
}
243
378
} else {
244
379
/* The child process has exited */
245
380
splashy_command_pid = 0;
246
if(not interrupted_by_signal and WIFEXITED(status)
247
and WEXITSTATUS(status)==0){
381
if(WIFEXITED(status) and WEXITSTATUS(status) == 0){
248
382
return EXIT_SUCCESS;
249
383
}
250
384
}
251
385
}
252
kill(splashy_pid, SIGTERM);
253
if(interrupted_by_signal and splashy_command_pid != 0){
254
kill(splashy_command_pid, SIGTERM);
255
}
256
sleep(2);
257
while(kill(splashy_pid, 0) == 0){
258
kill(splashy_pid, SIGKILL);
259
sleep(1);
260
}
261
pid_t new_splashy_pid = fork();
262
if(new_splashy_pid == 0){
263
/* Child; will become new splashy process */
264
265
/* Make the effective user ID (root) the only user ID instead of
266
the real user ID (mandos) */
267
ret = setuid(geteuid());
268
if(ret == -1){
269
perror("setuid");
270
}
271
272
setsid();
273
ret = chdir("/");
274
/* if(fork() != 0){ */
275
/* _exit(EXIT_SUCCESS); */
276
/* } */
277
ret = dup2(STDERR_FILENO, STDOUT_FILENO); /* replace our stdout */
278
if(ret == -1){
279
perror("dup2");
280
_exit(EXIT_FAILURE);
281
}
282
283
execl("/sbin/splashy", "/sbin/splashy", "boot", (char *)NULL);
284
if(not interrupted_by_signal){
285
perror("execl");
286
}
287
_exit(EXIT_FAILURE);
288
}
289
290
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;
291
471
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0