/mandos/release

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/splashy.c

  • Committer: Teddy Hogeborn
  • Date: 2019-07-29 16:35:53 UTC
  • mto: This revision was merged to the branch mainline in revision 384.
  • Revision ID: teddy@recompile.se-20190729163553-1i442i2cbx64c537
Make tests and man page examples match

Make the tests test_manual_page_example[1-5] match exactly what is
written in the manual page, and add comments to manual page as
reminders to keep tests and manual page examples in sync.

* mandos-ctl (Test_commands_from_options.test_manual_page_example_1):
  Remove "--verbose" option, since the manual does not have it as the
  first example, and change assertion to match.
* mandos-ctl.xml (EXAMPLE): Add comments to all examples documenting
  which test function they correspond to.  Also remove unnecessary
  quotes from option arguments in fourth example, and clarify language
  slightly in fifth example.

Show diffs side-by-side

added added

removed removed

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