/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

First version of a somewhat complete D-Bus server interface.  Also
change user/group name to "_mandos".

* debian/mandos.postinst: Rename old "mandos" user and group to
                          "_mandos"; create "_mandos" user and group
                          if none exist.
* debian/mandos-client.postinst: - '' -

* initramfs-tools-hook: Try "_mandos" before "mandos" as user and
                        group name.

* mandos (_datetime_to_dbus_struct): New; was previously local.
  (Client.started): Renamed to "last_started".  All users changed.
  (Client.started): New; boolean.
  (Client.dbus_object_path): New.
  (Client.check_command): Renamed to "checker_command".  All users
                          changed.
  (Client.__init__): Set and use "self.dbus_object_path".  Set
                     "self.started".
  (Client.start): Update "self.started".  Emit "self.PropertyChanged"
                  signals for both "started" and "last_started".
  (Client.stop): Update "self.started".  Emit "self.PropertyChanged"
                 signal for "started".
  (Client.checker_callback): Take additional "command" argument.  All
                             callers changed. Emit
                             "self.PropertyChanged" signal.
  (Client.bump_timeout): Emit "self.PropertyChanged" signal for
                         "last_checked_ok".
  (Client.start_checker): Emit "self.PropertyChanged" signal for
                          "checker_running".
  (Client.stop_checker): Emit "self.PropertyChanged" signal for
                         "checker_running".
  (Client.still_valid): Bug fix: use "getattr(self, started, False)"
                        instead of "self.started" in case this client
                        object is so new that the "started" attribute
                        has not been created yet.
  (Client.IntervalChanged, Client.CheckerIsRunning, Client.GetChecker,
  Client.GetCreated, Client.GetFingerprint, Client.GetHost,
  Client.GetInterval, Client.GetName, Client.GetStarted,
  Client.GetTimeout, Client.StateChanged, Client.TimeoutChanged):
  Removed; all callers changed.
  (Client.CheckerCompleted): Add "condition" and "command" arguments.
                             All callers changed.
  (Client.GetAllProperties, Client.PropertyChanged): New.
  (Client.StillValid): Renamed to "IsStillValid".
  (Client.StartChecker): Changed to its own function to avoid the
                         return value from "Client.start_checker()".
  (Client.Stop): Changed to its own function to avoid the return value
                 from "Client.stop()".
  (main): Try "_mandos" before "mandos" as user and group name.
          Removed inner function "remove_from_clients".  New inner
          class "MandosServer".

Show diffs side-by-side

added added

removed removed

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