/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:
plugins.d/splashy.c
 
1
/*  -*- coding: utf-8 -*- */
 
2
/*
 
3
 * Passprompt - Read a password from splashy and output it
 
4
 * 
 
5
 * Copyright © 2008 Teddy Hogeborn
 
6
 * Copyright © 2008 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 <https://www.fukt.bsnet.se/~belorn/> and
 
23
 * <https://www.fukt.bsnet.se/~teddy/>.
 
24
 */
 
25
 
1
26
#define _GNU_SOURCE             /* asprintf() */
2
27
#include <signal.h>             /* sig_atomic_t, struct sigaction,
3
 
                                   sigemptyset(), sigaddset(),
4
 
                                   sigaction, SIGINT, SIG_IGN, SIGHUP,
5
 
                                   SIGTERM, kill(), SIGKILL */
 
28
                                   sigemptyset(), sigaddset(), SIGINT,
 
29
                                   SIGHUP, SIGTERM, sigaction,
 
30
                                   SIG_IGN, kill(), SIGKILL */
6
31
#include <stddef.h>             /* NULL */
7
32
#include <stdlib.h>             /* getenv() */
8
33
#include <stdio.h>              /* asprintf(), perror() */
9
 
#include <stdlib.h>             /* EXIT_FAILURE, EXIT_SUCCESS,
10
 
                                   strtoul(), free() */
 
34
#include <stdlib.h>             /* EXIT_FAILURE, free(), strtoul(),
 
35
                                   EXIT_SUCCESS */
11
36
#include <sys/types.h>          /* pid_t, DIR, struct dirent,
12
37
                                   ssize_t */
13
38
#include <dirent.h>             /* opendir(), readdir(), closedir() */
 
39
#include <sys/stat.h>           /* struct stat, lstat(), S_ISLNK */
 
40
#include <iso646.h>             /* not, or, and */
14
41
#include <unistd.h>             /* readlink(), fork(), execl(),
15
 
                                   _exit */
 
42
                                   sleep(), dup2() STDERR_FILENO,
 
43
                                   STDOUT_FILENO, _exit() */
16
44
#include <string.h>             /* memcmp() */
17
 
#include <iso646.h>             /* and */
18
45
#include <errno.h>              /* errno */
19
46
#include <sys/wait.h>           /* waitpid(), WIFEXITED(),
20
47
                                   WEXITSTATUS() */
25
52
  interrupted_by_signal = 1;
26
53
}
27
54
 
28
 
int main(__attribute__((unused))int argc, char **argv){
 
55
int main(__attribute__((unused))int argc,
 
56
         __attribute__((unused))char **argv){
29
57
  int ret = 0;
30
58
  
31
59
  /* Create prompt string */
76
104
      }
77
105
      /* Find the executable name by doing readlink() on the
78
106
         /proc/<pid>/exe link */
79
 
      char *exe_link;
80
 
      ret = asprintf(&exe_link, "/proc/%s/exe", proc_ent->d_name);
81
 
      if(ret == -1){
82
 
        perror("asprintf");
83
 
        free(prompt);
84
 
        closedir(proc_dir);
85
 
        return EXIT_FAILURE;
86
 
      }
87
107
      char exe_target[sizeof(splashy_name)];
88
 
      ssize_t sret = readlink(exe_link, exe_target,
89
 
                              sizeof(exe_target));
90
 
      free(exe_link);
 
108
      ssize_t sret;
 
109
      {
 
110
        char *exe_link;
 
111
        ret = asprintf(&exe_link, "/proc/%s/exe", proc_ent->d_name);
 
112
        if(ret == -1){
 
113
          perror("asprintf");
 
114
          free(prompt);
 
115
          closedir(proc_dir);
 
116
          return EXIT_FAILURE;
 
117
        }
 
118
        
 
119
        /* Check that it refers to a symlink owned by root:root */
 
120
        struct stat exe_stat;
 
121
        ret = lstat(exe_link, &exe_stat);
 
122
        if(ret == -1){
 
123
          perror("lstat");
 
124
          free(exe_link);
 
125
          free(prompt);
 
126
          closedir(proc_dir);
 
127
          return EXIT_FAILURE;
 
128
        }
 
129
        if(not S_ISLNK(exe_stat.st_mode)
 
130
           or exe_stat.st_uid != 0
 
131
           or exe_stat.st_gid != 0){
 
132
          free(exe_link);
 
133
          continue;
 
134
        }
 
135
        
 
136
        sret = readlink(exe_link, exe_target, sizeof(exe_target));
 
137
        free(exe_link);
 
138
      }
91
139
      if((sret == ((ssize_t)sizeof(exe_target)-1))
92
140
         and (memcmp(splashy_name, exe_target,
93
141
                     sizeof(exe_target)-1) == 0)){
117
165
      free(prompt);
118
166
      return EXIT_FAILURE;
119
167
    }
120
 
    if (old_action.sa_handler != SIG_IGN){
 
168
    if(old_action.sa_handler != SIG_IGN){
121
169
      ret = sigaction(SIGINT, &new_action, NULL);
122
170
      if(ret == -1){
123
171
        perror("sigaction");
131
179
      free(prompt);
132
180
      return EXIT_FAILURE;
133
181
    }
134
 
    if (old_action.sa_handler != SIG_IGN){
 
182
    if(old_action.sa_handler != SIG_IGN){
135
183
      ret = sigaction(SIGHUP, &new_action, NULL);
136
184
      if(ret == -1){
137
185
        perror("sigaction");
145
193
      free(prompt);
146
194
      return EXIT_FAILURE;
147
195
    }
148
 
    if (old_action.sa_handler != SIG_IGN){
 
196
    if(old_action.sa_handler != SIG_IGN){
149
197
      ret = sigaction(SIGTERM, &new_action, NULL);
150
198
      if(ret == -1){
151
199
        perror("sigaction");
170
218
      const char splashy_command[] = "/sbin/splashy_update";
171
219
      ret = execl(splashy_command, splashy_command, prompt,
172
220
                  (char *)NULL);
173
 
      if(not interrupted_by_signal and errno != ENOENT){
174
 
        /* Don't report "File not found", since splashy might not be
175
 
           installed. */
 
221
      if(not interrupted_by_signal){
176
222
        perror("execl");
177
223
      }
178
224
      free(prompt);
179
 
      return EXIT_FAILURE;
 
225
      _exit(EXIT_FAILURE);
180
226
    }
181
227
  }
182
228
  
184
230
  free(prompt);
185
231
  
186
232
  /* Wait for command to complete */
187
 
  int status;
188
 
  while(not interrupted_by_signal){
189
 
    waitpid(splashy_command_pid, &status, 0);
190
 
    if(not interrupted_by_signal
191
 
       and WIFEXITED(status) and WEXITSTATUS(status)==0){
192
 
      return EXIT_SUCCESS;
 
233
  if(not interrupted_by_signal and splashy_command_pid != 0){
 
234
    int status;
 
235
    ret = waitpid(splashy_command_pid, &status, 0);
 
236
    if(ret == -1){
 
237
      if(errno != EINTR){
 
238
        perror("waitpid");
 
239
      }
 
240
      if(errno == ECHILD){
 
241
        splashy_command_pid = 0;
 
242
      }
 
243
    } else {
 
244
      /* The child process has exited */
 
245
      splashy_command_pid = 0;
 
246
      if(not interrupted_by_signal and WIFEXITED(status)
 
247
         and WEXITSTATUS(status)==0){
 
248
        return EXIT_SUCCESS;
 
249
      }
193
250
    }
194
251
  }
195
252
  kill(splashy_pid, SIGTERM);
196
 
  if(interrupted_by_signal){
 
253
  if(interrupted_by_signal and splashy_command_pid != 0){
197
254
    kill(splashy_command_pid, SIGTERM);
198
255
  }
199
 
  
 
256
  sleep(2);
 
257
  while(kill(splashy_pid, 0) == 0){
 
258
    kill(splashy_pid, SIGKILL);
 
259
    sleep(1);
 
260
  }
200
261
  pid_t new_splashy_pid = fork();
201
262
  if(new_splashy_pid == 0){
202
263
    /* Child; will become new splashy process */
203
 
    while(kill(splashy_pid, 0)){
204
 
      sleep(2);
205
 
      kill(splashy_pid, SIGKILL);
206
 
      sleep(1);
 
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");
207
270
    }
 
271
    
 
272
    setsid();
 
273
    ret = chdir("/");
 
274
/*     if(fork() != 0){ */
 
275
/*       _exit(EXIT_SUCCESS); */
 
276
/*     } */
208
277
    ret = dup2(STDERR_FILENO, STDOUT_FILENO); /* replace our stdout */
209
278
    if(ret == -1){
210
279
      perror("dup2");
211
280
      _exit(EXIT_FAILURE);
212
281
    }
 
282
    
213
283
    execl("/sbin/splashy", "/sbin/splashy", "boot", (char *)NULL);
 
284
    if(not interrupted_by_signal){
 
285
      perror("execl");
 
286
    }
 
287
    _exit(EXIT_FAILURE);
214
288
  }
215
289
  
216
290
  return EXIT_FAILURE;