/mandos/trunk

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

  • Committer: Teddy Hogeborn
  • Date: 2015-07-20 03:03:33 UTC
  • Revision ID: teddy@recompile.se-20150720030333-203m2aeblypcsfte
Bug fix for GnuTLS 3: be compatible with old 2048-bit DSA keys.

The mandos-keygen program in Mandos version 1.6.0 and older generated
2048-bit DSA keys, and when GnuTLS uses these it has trouble
connecting using the Mandos default priority string.  This was
previously fixed in Mandos 1.6.2, but the bug reappeared when using
GnuTLS 3, so the default priority string has to change again; this
time also the Mandos client has to change its default, so now the
server and the client should use the same default priority string:

SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256

* mandos (main/server_defaults): Changed default priority string.
* mandos-options.xml (/section/para[id="priority_compat"]): Removed.
  (/section/para[id="priority"]): Changed default priority string.
* mandos.conf ([DEFAULT]/priority): - '' -
* mandos.conf.xml (OPTIONS/priority): Refer to the id "priority"
                                      instead of "priority_compat".
* mandos.xml (OPTIONS/--priority): - '' -
* plugins.d/mandos-client.c (main): Changed default priority string.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/usplash.c
2
2
/*
3
3
 * Usplash - Read a password from usplash 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             /* asprintf(), TEMP_FAILURE_RETRY() */
27
26
#include <signal.h>             /* sig_atomic_t, struct sigaction,
28
27
                                   sigemptyset(), sigaddset(), SIGINT,
29
28
                                   SIGHUP, SIGTERM, sigaction(),
32
31
#include <fcntl.h>              /* open(), O_WRONLY, O_RDONLY */
33
32
#include <iso646.h>             /* and, or, not*/
34
33
#include <errno.h>              /* errno, EINTR */
 
34
#include <error.h>
35
35
#include <sys/types.h>          /* size_t, ssize_t, pid_t, DIR, struct
36
36
                                   dirent */
37
37
#include <stddef.h>             /* NULL */
38
 
#include <string.h>             /* strlen(), memcmp() */
39
 
#include <stdio.h>              /* asprintf(), perror() */
 
38
#include <string.h>             /* strlen(), memcmp(), strerror() */
 
39
#include <stdio.h>              /* asprintf(), vasprintf(), vprintf(),
 
40
                                   fprintf() */
40
41
#include <unistd.h>             /* close(), write(), readlink(),
41
42
                                   read(), STDOUT_FILENO, sleep(),
42
43
                                   fork(), setuid(), geteuid(),
43
44
                                   setsid(), chdir(), dup2(),
44
45
                                   STDERR_FILENO, execv() */
45
 
#include <stdlib.h>             /* free(), EXIT_FAILURE, strtoul(),
46
 
                                   realloc(), EXIT_SUCCESS, malloc(),
47
 
                                   _exit() */
48
 
#include <stdlib.h>             /* getenv() */
 
46
#include <stdlib.h>             /* free(), EXIT_FAILURE, realloc(),
 
47
                                   EXIT_SUCCESS, malloc(), _exit(),
 
48
                                   getenv() */
49
49
#include <dirent.h>             /* opendir(), readdir(), closedir() */
 
50
#include <inttypes.h>           /* intmax_t, strtoimax() */
50
51
#include <sys/stat.h>           /* struct stat, lstat(), S_ISLNK */
 
52
#include <sysexits.h>           /* EX_OSERR, EX_UNAVAILABLE */
 
53
#include <argz.h>               /* argz_count(), argz_extract() */
 
54
#include <stdarg.h>             /* va_list, va_start(), ... */
51
55
 
52
56
sig_atomic_t interrupted_by_signal = 0;
53
 
 
54
 
static void termination_handler(__attribute__((unused))int signum){
 
57
int signal_received;
 
58
const char usplash_name[] = "/sbin/usplash";
 
59
 
 
60
/* Function to use when printing errors */
 
61
__attribute__((format (gnu_printf, 3, 4)))
 
62
void error_plus(int status, int errnum, const char *formatstring,
 
63
                ...){
 
64
  va_list ap;
 
65
  char *text;
 
66
  int ret;
 
67
  
 
68
  va_start(ap, formatstring);
 
69
  ret = vasprintf(&text, formatstring, ap);
 
70
  if(ret == -1){
 
71
    fprintf(stderr, "Mandos plugin %s: ",
 
72
            program_invocation_short_name);
 
73
    vfprintf(stderr, formatstring, ap);
 
74
    fprintf(stderr, ": ");
 
75
    fprintf(stderr, "%s\n", strerror(errnum));
 
76
    error(status, errno, "vasprintf while printing error");
 
77
    return;
 
78
  }
 
79
  fprintf(stderr, "Mandos plugin ");
 
80
  error(status, errnum, "%s", text);
 
81
  free(text);
 
82
}
 
83
 
 
84
static void termination_handler(int signum){
 
85
  if(interrupted_by_signal){
 
86
    return;
 
87
  }
55
88
  interrupted_by_signal = 1;
 
89
  signal_received = signum;
56
90
}
57
91
 
58
 
static bool usplash_write(const char *cmd, const char *arg){
 
92
static bool usplash_write(int *fifo_fd_r,
 
93
                          const char *cmd, const char *arg){
59
94
  /* 
60
 
   * usplash_write("TIMEOUT", "15") will write "TIMEOUT 15\0"
61
 
   * usplash_write("PULSATE", NULL) will write "PULSATE\0"
 
95
   * usplash_write(&fd, "TIMEOUT", "15") will write "TIMEOUT 15\0"
 
96
   * usplash_write(&fd, "PULSATE", NULL) will write "PULSATE\0"
62
97
   * SEE ALSO
63
98
   *         usplash_write(8)
64
99
   */
65
100
  int ret;
66
 
  int fifo_fd;
67
 
  do{
68
 
    fifo_fd = open("/dev/.initramfs/usplash_fifo", O_WRONLY);
69
 
    if(fifo_fd == -1 and (errno != EINTR or interrupted_by_signal)){
 
101
  if(*fifo_fd_r == -1){
 
102
    ret = open("/dev/.initramfs/usplash_fifo", O_WRONLY);
 
103
    if(ret == -1){
70
104
      return false;
71
105
    }
72
 
  }while(fifo_fd == -1);
 
106
    *fifo_fd_r = ret;
 
107
  }
73
108
  
74
109
  const char *cmd_line;
75
110
  size_t cmd_line_len;
76
111
  char *cmd_line_alloc = NULL;
77
112
  if(arg == NULL){
78
113
    cmd_line = cmd;
79
 
    cmd_line_len = strlen(cmd);
80
 
  }else{
81
 
    do{
 
114
    cmd_line_len = strlen(cmd) + 1;
 
115
  } else {
 
116
    do {
82
117
      ret = asprintf(&cmd_line_alloc, "%s %s", cmd, arg);
83
 
      if(ret == -1 and (errno != EINTR or interrupted_by_signal)){
 
118
      if(ret == -1){
84
119
        int e = errno;
85
 
        close(fifo_fd);
 
120
        close(*fifo_fd_r);
86
121
        errno = e;
87
122
        return false;
88
123
      }
89
 
    }while(ret == -1);
 
124
    } while(ret == -1);
90
125
    cmd_line = cmd_line_alloc;
91
126
    cmd_line_len = (size_t)ret + 1;
92
127
  }
93
128
  
94
129
  size_t written = 0;
95
130
  ssize_t sret = 0;
96
 
  while(not interrupted_by_signal and written < cmd_line_len){
97
 
    sret = write(fifo_fd, cmd_line + written,
 
131
  while(written < cmd_line_len){
 
132
    sret = write(*fifo_fd_r, cmd_line + written,
98
133
                 cmd_line_len - written);
99
134
    if(sret == -1){
100
 
      if(errno != EINTR or interrupted_by_signal){
101
 
        int e = errno;
102
 
        close(fifo_fd);
103
 
        free(cmd_line_alloc);
104
 
        errno = e;
105
 
        return false;
106
 
      } else {
107
 
        continue;
108
 
      }
 
135
      int e = errno;
 
136
      close(*fifo_fd_r);
 
137
      free(cmd_line_alloc);
 
138
      errno = e;
 
139
      return false;
109
140
    }
110
141
    written += (size_t)sret;
111
142
  }
112
143
  free(cmd_line_alloc);
113
 
  do{
114
 
    ret = close(fifo_fd);
115
 
    if(ret == -1 and (errno != EINTR or interrupted_by_signal)){
116
 
      return false;
117
 
    }
118
 
  }while(ret == -1);
119
 
  if(interrupted_by_signal){
120
 
    return false;
121
 
  }
 
144
  
122
145
  return true;
123
146
}
124
147
 
 
148
/* Create prompt string */
 
149
char *makeprompt(void){
 
150
  int ret = 0;
 
151
  char *prompt;
 
152
  const char *const cryptsource = getenv("cryptsource");
 
153
  const char *const crypttarget = getenv("crypttarget");
 
154
  const char prompt_start[] = "Enter passphrase to unlock the disk";
 
155
  
 
156
  if(cryptsource == NULL){
 
157
    if(crypttarget == NULL){
 
158
      ret = asprintf(&prompt, "%s: ", prompt_start);
 
159
    } else {
 
160
      ret = asprintf(&prompt, "%s (%s): ", prompt_start,
 
161
                     crypttarget);
 
162
    }
 
163
  } else {
 
164
    if(crypttarget == NULL){
 
165
      ret = asprintf(&prompt, "%s %s: ", prompt_start, cryptsource);
 
166
    } else {
 
167
      ret = asprintf(&prompt, "%s %s (%s): ", prompt_start,
 
168
                     cryptsource, crypttarget);
 
169
    }
 
170
  }
 
171
  if(ret == -1){
 
172
    return NULL;
 
173
  }
 
174
  return prompt;
 
175
}
 
176
 
 
177
pid_t find_usplash(char **cmdline_r, size_t *cmdline_len_r){
 
178
  int ret = 0;
 
179
  ssize_t sret = 0;
 
180
  char *cmdline = NULL;
 
181
  size_t cmdline_len = 0;
 
182
  DIR *proc_dir = opendir("/proc");
 
183
  if(proc_dir == NULL){
 
184
    error_plus(0, errno, "opendir");
 
185
    return -1;
 
186
  }
 
187
  errno = 0;
 
188
  for(struct dirent *proc_ent = readdir(proc_dir);
 
189
      proc_ent != NULL;
 
190
      proc_ent = readdir(proc_dir)){
 
191
    pid_t pid;
 
192
    {
 
193
      intmax_t tmpmax;
 
194
      char *tmp;
 
195
      tmpmax = strtoimax(proc_ent->d_name, &tmp, 10);
 
196
      if(errno != 0 or tmp == proc_ent->d_name or *tmp != '\0'
 
197
         or tmpmax != (pid_t)tmpmax){
 
198
        /* Not a process */
 
199
        errno = 0;
 
200
        continue;
 
201
      }
 
202
      pid = (pid_t)tmpmax;
 
203
    }
 
204
    /* Find the executable name by doing readlink() on the
 
205
       /proc/<pid>/exe link */
 
206
    char exe_target[sizeof(usplash_name)];
 
207
    {
 
208
      /* create file name string */
 
209
      char *exe_link;
 
210
      ret = asprintf(&exe_link, "/proc/%s/exe", proc_ent->d_name);
 
211
      if(ret == -1){
 
212
        error_plus(0, errno, "asprintf");
 
213
        goto fail_find_usplash;
 
214
      }
 
215
      
 
216
      /* Check that it refers to a symlink owned by root:root */
 
217
      struct stat exe_stat;
 
218
      ret = lstat(exe_link, &exe_stat);
 
219
      if(ret == -1){
 
220
        if(errno == ENOENT){
 
221
          free(exe_link);
 
222
          continue;
 
223
        }
 
224
        error_plus(0, errno, "lstat");
 
225
        free(exe_link);
 
226
        goto fail_find_usplash;
 
227
      }
 
228
      if(not S_ISLNK(exe_stat.st_mode)
 
229
         or exe_stat.st_uid != 0
 
230
         or exe_stat.st_gid != 0){
 
231
        free(exe_link);
 
232
        continue;
 
233
      }
 
234
        
 
235
      sret = readlink(exe_link, exe_target, sizeof(exe_target));
 
236
      free(exe_link);
 
237
    }
 
238
    /* Compare executable name */
 
239
    if((sret != ((ssize_t)sizeof(exe_target)-1))
 
240
       or (memcmp(usplash_name, exe_target,
 
241
                  sizeof(exe_target)-1) != 0)){
 
242
      /* Not it */
 
243
      continue;
 
244
    }
 
245
    /* Found usplash */
 
246
    /* Read and save the command line of usplash in "cmdline" */
 
247
    {
 
248
      /* Open /proc/<pid>/cmdline  */
 
249
      int cl_fd;
 
250
      {
 
251
        char *cmdline_filename;
 
252
        ret = asprintf(&cmdline_filename, "/proc/%s/cmdline",
 
253
                       proc_ent->d_name);
 
254
        if(ret == -1){
 
255
          error_plus(0, errno, "asprintf");
 
256
          goto fail_find_usplash;
 
257
        }
 
258
        cl_fd = open(cmdline_filename, O_RDONLY);
 
259
        free(cmdline_filename);
 
260
        if(cl_fd == -1){
 
261
          error_plus(0, errno, "open");
 
262
          goto fail_find_usplash;
 
263
        }
 
264
      }
 
265
      size_t cmdline_allocated = 0;
 
266
      char *tmp;
 
267
      const size_t blocksize = 1024;
 
268
      do {
 
269
        /* Allocate more space? */
 
270
        if(cmdline_len + blocksize > cmdline_allocated){
 
271
          tmp = realloc(cmdline, cmdline_allocated + blocksize);
 
272
          if(tmp == NULL){
 
273
            error_plus(0, errno, "realloc");
 
274
            close(cl_fd);
 
275
            goto fail_find_usplash;
 
276
          }
 
277
          cmdline = tmp;
 
278
          cmdline_allocated += blocksize;
 
279
        }
 
280
        /* Read data */
 
281
        sret = read(cl_fd, cmdline + cmdline_len,
 
282
                    cmdline_allocated - cmdline_len);
 
283
        if(sret == -1){
 
284
          error_plus(0, errno, "read");
 
285
          close(cl_fd);
 
286
          goto fail_find_usplash;
 
287
        }
 
288
        cmdline_len += (size_t)sret;
 
289
      } while(sret != 0);
 
290
      ret = close(cl_fd);
 
291
      if(ret == -1){
 
292
        error_plus(0, errno, "close");
 
293
        goto fail_find_usplash;
 
294
      }
 
295
    }
 
296
    /* Close directory */
 
297
    ret = closedir(proc_dir);
 
298
    if(ret == -1){
 
299
      error_plus(0, errno, "closedir");
 
300
      goto fail_find_usplash;
 
301
    }
 
302
    /* Success */
 
303
    *cmdline_r = cmdline;
 
304
    *cmdline_len_r = cmdline_len;
 
305
    return pid;
 
306
  }
 
307
  
 
308
 fail_find_usplash:
 
309
  
 
310
  free(cmdline);
 
311
  if(proc_dir != NULL){
 
312
    int e = errno;
 
313
    closedir(proc_dir);
 
314
    errno = e;
 
315
  }
 
316
  return 0;
 
317
}
 
318
 
125
319
int main(__attribute__((unused))int argc,
126
320
         __attribute__((unused))char **argv){
127
321
  int ret = 0;
128
322
  ssize_t sret;
129
 
  bool an_error_occured = false;
 
323
  int fifo_fd = -1;
 
324
  int outfifo_fd = -1;
 
325
  char *buf = NULL;
 
326
  size_t buf_len = 0;
 
327
  pid_t usplash_pid = -1;
 
328
  bool usplash_accessed = false;
 
329
  int status = EXIT_FAILURE;    /* Default failure exit status */
130
330
  
131
 
  /* Create prompt string */
132
 
  char *prompt = NULL;
133
 
  {
134
 
    const char *const cryptsource = getenv("cryptsource");
135
 
    const char *const crypttarget = getenv("crypttarget");
136
 
    const char prompt_start[] = "Enter passphrase to unlock the disk";
137
 
    
138
 
    if(cryptsource == NULL){
139
 
      if(crypttarget == NULL){
140
 
        ret = asprintf(&prompt, "%s: ", prompt_start);
141
 
      } else {
142
 
        ret = asprintf(&prompt, "%s (%s): ", prompt_start,
143
 
                       crypttarget);
144
 
      }
145
 
    } else {
146
 
      if(crypttarget == NULL){
147
 
        ret = asprintf(&prompt, "%s %s: ", prompt_start, cryptsource);
148
 
      } else {
149
 
        ret = asprintf(&prompt, "%s %s (%s): ", prompt_start,
150
 
                       cryptsource, crypttarget);
151
 
      }
152
 
    }
153
 
    if(ret == -1){
154
 
      return EXIT_FAILURE;
155
 
    }
 
331
  char *prompt = makeprompt();
 
332
  if(prompt == NULL){
 
333
    status = EX_OSERR;
 
334
    goto failure;
156
335
  }
157
336
  
158
337
  /* Find usplash process */
159
 
  pid_t usplash_pid = 0;
160
338
  char *cmdline = NULL;
161
339
  size_t cmdline_len = 0;
162
 
  const char usplash_name[] = "/sbin/usplash";
163
 
  {
164
 
    DIR *proc_dir = opendir("/proc");
165
 
    if(proc_dir == NULL){
166
 
      free(prompt);
167
 
      perror("opendir");
168
 
      return EXIT_FAILURE;
169
 
    }
170
 
    for(struct dirent *proc_ent = readdir(proc_dir);
171
 
        proc_ent != NULL;
172
 
        proc_ent = readdir(proc_dir)){
173
 
      pid_t pid = (pid_t) strtoul(proc_ent->d_name, NULL, 10);
174
 
      if(pid == 0){
175
 
        /* Not a process */
176
 
        continue;
177
 
      }
178
 
      /* Find the executable name by doing readlink() on the
179
 
         /proc/<pid>/exe link */
180
 
      char exe_target[sizeof(usplash_name)];
181
 
      {
182
 
        /* create file name string */
183
 
        char *exe_link;
184
 
        ret = asprintf(&exe_link, "/proc/%s/exe", proc_ent->d_name);
185
 
        if(ret == -1){
186
 
          perror("asprintf");
187
 
          free(prompt);
188
 
          closedir(proc_dir);
189
 
          return EXIT_FAILURE;
190
 
        }
191
 
        
192
 
        /* Check that it refers to a symlink owned by root:root */
193
 
        struct stat exe_stat;
194
 
        ret = lstat(exe_link, &exe_stat);
195
 
        if(ret == -1){
196
 
          if(errno == ENOENT){
197
 
            free(exe_link);
198
 
            continue;
199
 
          }
200
 
          perror("lstat");
201
 
          free(exe_link);
202
 
          free(prompt);
203
 
          closedir(proc_dir);
204
 
          return EXIT_FAILURE;
205
 
        }
206
 
        if(not S_ISLNK(exe_stat.st_mode)
207
 
           or exe_stat.st_uid != 0
208
 
           or exe_stat.st_gid != 0){
209
 
          free(exe_link);
210
 
          continue;
211
 
        }
212
 
        
213
 
        sret = readlink(exe_link, exe_target, sizeof(exe_target));
214
 
        free(exe_link);
215
 
      }
216
 
      if((sret == ((ssize_t)sizeof(exe_target)-1))
217
 
         and (memcmp(usplash_name, exe_target,
218
 
                     sizeof(exe_target)-1) == 0)){
219
 
        usplash_pid = pid;
220
 
        /* Read and save the command line of usplash in "cmdline" */
221
 
        {
222
 
          /* Open /proc/<pid>/cmdline  */
223
 
          int cl_fd;
224
 
          {
225
 
            char *cmdline_filename;
226
 
            ret = asprintf(&cmdline_filename, "/proc/%s/cmdline",
227
 
                           proc_ent->d_name);
228
 
            if(ret == -1){
229
 
              perror("asprintf");
230
 
              free(prompt);
231
 
              closedir(proc_dir);
232
 
              return EXIT_FAILURE;
233
 
            }
234
 
            cl_fd = open(cmdline_filename, O_RDONLY);
235
 
            if(cl_fd == -1){
236
 
              perror("open");
237
 
              free(cmdline_filename);
238
 
              free(prompt);
239
 
              closedir(proc_dir);
240
 
              return EXIT_FAILURE;
241
 
            }
242
 
            free(cmdline_filename);
243
 
          }
244
 
          size_t cmdline_allocated = 0;
245
 
          char *tmp;
246
 
          const size_t blocksize = 1024;
247
 
          do{
248
 
            if(cmdline_len + blocksize > cmdline_allocated){
249
 
              tmp = realloc(cmdline, cmdline_allocated + blocksize);
250
 
              if(tmp == NULL){
251
 
                perror("realloc");
252
 
                free(cmdline);
253
 
                free(prompt);
254
 
                closedir(proc_dir);
255
 
                return EXIT_FAILURE;
256
 
              }
257
 
              cmdline = tmp;
258
 
              cmdline_allocated += blocksize;
259
 
            }
260
 
            sret = read(cl_fd, cmdline + cmdline_len,
261
 
                        cmdline_allocated - cmdline_len);
262
 
            if(sret == -1){
263
 
              perror("read");
264
 
              free(cmdline);
265
 
              free(prompt);
266
 
              closedir(proc_dir);
267
 
              return EXIT_FAILURE;
268
 
            }
269
 
            cmdline_len += (size_t)sret;
270
 
          } while(sret != 0);
271
 
          close(cl_fd);
272
 
        }
273
 
        break;
274
 
      }
275
 
    }
276
 
    closedir(proc_dir);
277
 
  }
 
340
  usplash_pid = find_usplash(&cmdline, &cmdline_len);
278
341
  if(usplash_pid == 0){
279
 
    free(prompt);
280
 
    return EXIT_FAILURE;
 
342
    status = EX_UNAVAILABLE;
 
343
    goto failure;
281
344
  }
282
345
  
283
346
  /* Set up the signal handler */
286
349
      new_action = { .sa_handler = termination_handler,
287
350
                     .sa_flags = 0 };
288
351
    sigemptyset(&new_action.sa_mask);
289
 
    sigaddset(&new_action.sa_mask, SIGINT);
290
 
    sigaddset(&new_action.sa_mask, SIGHUP);
291
 
    sigaddset(&new_action.sa_mask, SIGTERM);
 
352
    ret = sigaddset(&new_action.sa_mask, SIGINT);
 
353
    if(ret == -1){
 
354
      error_plus(0, errno, "sigaddset");
 
355
      status = EX_OSERR;
 
356
      goto failure;
 
357
    }
 
358
    ret = sigaddset(&new_action.sa_mask, SIGHUP);
 
359
    if(ret == -1){
 
360
      error_plus(0, errno, "sigaddset");
 
361
      status = EX_OSERR;
 
362
      goto failure;
 
363
    }
 
364
    ret = sigaddset(&new_action.sa_mask, SIGTERM);
 
365
    if(ret == -1){
 
366
      error_plus(0, errno, "sigaddset");
 
367
      status = EX_OSERR;
 
368
      goto failure;
 
369
    }
292
370
    ret = sigaction(SIGINT, NULL, &old_action);
293
371
    if(ret == -1){
294
 
      perror("sigaction");
295
 
      free(prompt);
296
 
      return EXIT_FAILURE;
 
372
      if(errno != EINTR){
 
373
        error_plus(0, errno, "sigaction");
 
374
        status = EX_OSERR;
 
375
      }
 
376
      goto failure;
297
377
    }
298
378
    if(old_action.sa_handler != SIG_IGN){
299
379
      ret = sigaction(SIGINT, &new_action, NULL);
300
380
      if(ret == -1){
301
 
        perror("sigaction");
302
 
        free(prompt);
303
 
        return EXIT_FAILURE;
 
381
        if(errno != EINTR){
 
382
          error_plus(0, errno, "sigaction");
 
383
          status = EX_OSERR;
 
384
        }
 
385
        goto failure;
304
386
      }
305
387
    }
306
388
    ret = sigaction(SIGHUP, NULL, &old_action);
307
389
    if(ret == -1){
308
 
      perror("sigaction");
309
 
      free(prompt);
310
 
      return EXIT_FAILURE;
 
390
      if(errno != EINTR){
 
391
        error_plus(0, errno, "sigaction");
 
392
        status = EX_OSERR;
 
393
      }
 
394
      goto failure;
311
395
    }
312
396
    if(old_action.sa_handler != SIG_IGN){
313
397
      ret = sigaction(SIGHUP, &new_action, NULL);
314
398
      if(ret == -1){
315
 
        perror("sigaction");
316
 
        free(prompt);
317
 
        return EXIT_FAILURE;
 
399
        if(errno != EINTR){
 
400
          error_plus(0, errno, "sigaction");
 
401
          status = EX_OSERR;
 
402
        }
 
403
        goto failure;
318
404
      }
319
405
    }
320
406
    ret = sigaction(SIGTERM, NULL, &old_action);
321
407
    if(ret == -1){
322
 
      perror("sigaction");
323
 
      free(prompt);
324
 
      return EXIT_FAILURE;
 
408
      if(errno != EINTR){
 
409
        error_plus(0, errno, "sigaction");
 
410
        status = EX_OSERR;
 
411
      }
 
412
      goto failure;
325
413
    }
326
414
    if(old_action.sa_handler != SIG_IGN){
327
415
      ret = sigaction(SIGTERM, &new_action, NULL);
328
416
      if(ret == -1){
329
 
        perror("sigaction");
330
 
        free(prompt);
331
 
        return EXIT_FAILURE;
 
417
        if(errno != EINTR){
 
418
          error_plus(0, errno, "sigaction");
 
419
          status = EX_OSERR;
 
420
        }
 
421
        goto failure;
332
422
      }
333
423
    }
334
424
  }
335
425
  
 
426
  usplash_accessed = true;
336
427
  /* Write command to FIFO */
337
 
  if(not interrupted_by_signal){
338
 
    if(not usplash_write("TIMEOUT", "0")
339
 
       and (errno != EINTR)){
340
 
      perror("usplash_write");
341
 
      an_error_occured = true;
342
 
    }
343
 
  }
344
 
  if(not interrupted_by_signal and not an_error_occured){
345
 
    if(not usplash_write("INPUTQUIET", prompt)
346
 
       and (errno != EINTR)){
347
 
      perror("usplash_write");
348
 
      an_error_occured = true;
349
 
    }
350
 
  }
 
428
  if(not usplash_write(&fifo_fd, "TIMEOUT", "0")){
 
429
    if(errno != EINTR){
 
430
      error_plus(0, errno, "usplash_write");
 
431
      status = EX_OSERR;
 
432
    }
 
433
    goto failure;
 
434
  }
 
435
  
 
436
  if(interrupted_by_signal){
 
437
    goto failure;
 
438
  }
 
439
  
 
440
  if(not usplash_write(&fifo_fd, "INPUTQUIET", prompt)){
 
441
    if(errno != EINTR){
 
442
      error_plus(0, errno, "usplash_write");
 
443
      status = EX_OSERR;
 
444
    }
 
445
    goto failure;
 
446
  }
 
447
  
 
448
  if(interrupted_by_signal){
 
449
    goto failure;
 
450
  }
 
451
  
351
452
  free(prompt);
352
 
  
353
 
  /* This is not really a loop; while() is used to be able to "break"
354
 
     out of it; those breaks are marked "Big" */
355
 
  while(not interrupted_by_signal and not an_error_occured){
356
 
    char *buf = NULL;
357
 
    size_t buf_len = 0;
358
 
    
359
 
    /* Open FIFO */
360
 
    int fifo_fd;
361
 
    do{
362
 
      fifo_fd = open("/dev/.initramfs/usplash_outfifo", O_RDONLY);
363
 
      if(fifo_fd == -1){
364
 
        if(errno != EINTR){
365
 
          perror("open");
366
 
          an_error_occured = true;
367
 
          break;
368
 
        }
369
 
        if(interrupted_by_signal){
370
 
          break;
371
 
        }
372
 
      }
373
 
    }while(fifo_fd == -1);
374
 
    if(interrupted_by_signal or an_error_occured){
375
 
      break;                    /* Big */
376
 
    }
377
 
    
378
 
    /* Read from FIFO */
379
 
    size_t buf_allocated = 0;
380
 
    const size_t blocksize = 1024;
381
 
    do{
382
 
      if(buf_len + blocksize > buf_allocated){
383
 
        char *tmp = realloc(buf, buf_allocated + blocksize);
384
 
        if(tmp == NULL){
385
 
          perror("realloc");
386
 
          an_error_occured = true;
387
 
          break;
388
 
        }
389
 
        buf = tmp;
390
 
        buf_allocated += blocksize;
391
 
      }
392
 
      do{
393
 
        sret = read(fifo_fd, buf + buf_len, buf_allocated - buf_len);
394
 
        if(sret == -1){
395
 
          if(errno != EINTR){
396
 
            perror("read");
397
 
            an_error_occured = true;
398
 
            break;
399
 
          }
400
 
          if(interrupted_by_signal){
401
 
            break;
402
 
          }
403
 
        }
404
 
      }while(sret == -1);
405
 
      if(interrupted_by_signal or an_error_occured){
406
 
        break;
407
 
      }
408
 
      
409
 
      buf_len += (size_t)sret;
410
 
    }while(sret != 0);
411
 
    close(fifo_fd);
412
 
    if(interrupted_by_signal or an_error_occured){
413
 
      break;                    /* Big */
414
 
    }
415
 
    
416
 
    if(not usplash_write("TIMEOUT", "15")
417
 
       and (errno != EINTR)){
418
 
        perror("usplash_write");
419
 
        an_error_occured = true;
420
 
    }
421
 
    if(interrupted_by_signal or an_error_occured){
422
 
      break;                    /* Big */
423
 
    }
424
 
    
425
 
    /* Print password to stdout */
426
 
    size_t written = 0;
427
 
    while(written < buf_len){
428
 
      do{
429
 
        sret = write(STDOUT_FILENO, buf + written, buf_len - written);
430
 
        if(sret == -1){
431
 
          if(errno != EINTR){
432
 
            perror("write");
433
 
            an_error_occured = true;
434
 
            break;
435
 
          }
436
 
          if(interrupted_by_signal){
437
 
            break;
438
 
          }
439
 
        }
440
 
      }while(sret == -1);
441
 
      if(interrupted_by_signal or an_error_occured){
442
 
        break;
443
 
      }
444
 
      written += (size_t)sret;
445
 
    }
446
 
    free(buf);
447
 
    if(not interrupted_by_signal and not an_error_occured){
448
 
      free(cmdline);
449
 
      return EXIT_SUCCESS;
450
 
    }
451
 
    break;                      /* Big */
452
 
  }                             /* end of non-loop while() */
453
 
  
454
 
  /* If we got here, an error or interrupt must have happened */
455
 
  
456
 
  /* Create argc and argv for new usplash*/
457
 
  int cmdline_argc = 0;
458
 
  char **cmdline_argv = malloc(sizeof(char *));
459
 
  {
460
 
    size_t position = 0;
461
 
    while(position < cmdline_len){
462
 
      char **tmp = realloc(cmdline_argv,
463
 
                           (sizeof(char *)
464
 
                            * (size_t)(cmdline_argc + 2)));
 
453
  prompt = NULL;
 
454
  
 
455
  /* Read reply from usplash */
 
456
  /* Open FIFO */
 
457
  outfifo_fd = open("/dev/.initramfs/usplash_outfifo", O_RDONLY);
 
458
  if(outfifo_fd == -1){
 
459
    if(errno != EINTR){
 
460
      error_plus(0, errno, "open");
 
461
      status = EX_OSERR;
 
462
    }
 
463
    goto failure;
 
464
  }
 
465
  
 
466
  if(interrupted_by_signal){
 
467
    goto failure;
 
468
  }
 
469
  
 
470
  /* Read from FIFO */
 
471
  size_t buf_allocated = 0;
 
472
  const size_t blocksize = 1024;
 
473
  do {
 
474
    /* Allocate more space */
 
475
    if(buf_len + blocksize > buf_allocated){
 
476
      char *tmp = realloc(buf, buf_allocated + blocksize);
465
477
      if(tmp == NULL){
466
 
        perror("realloc");
467
 
        free(cmdline_argv);
468
 
        return EXIT_FAILURE;
469
 
      }
470
 
      cmdline_argv = tmp;
471
 
      cmdline_argv[cmdline_argc] = cmdline + position;
472
 
      cmdline_argc++;
473
 
      position += strlen(cmdline + position) + 1;
474
 
    }
475
 
    cmdline_argv[cmdline_argc] = NULL;
476
 
  }
 
478
        if(errno != EINTR){
 
479
          error_plus(0, errno, "realloc");
 
480
          status = EX_OSERR;
 
481
        }
 
482
        goto failure;
 
483
      }
 
484
      buf = tmp;
 
485
      buf_allocated += blocksize;
 
486
    }
 
487
    sret = read(outfifo_fd, buf + buf_len,
 
488
                buf_allocated - buf_len);
 
489
    if(sret == -1){
 
490
      if(errno != EINTR){
 
491
        error_plus(0, errno, "read");
 
492
        status = EX_OSERR;
 
493
      }
 
494
      close(outfifo_fd);
 
495
      goto failure;
 
496
    }
 
497
    if(interrupted_by_signal){
 
498
      break;
 
499
    }
 
500
    
 
501
    buf_len += (size_t)sret;
 
502
  } while(sret != 0);
 
503
  ret = close(outfifo_fd);
 
504
  if(ret == -1){
 
505
    if(errno != EINTR){
 
506
      error_plus(0, errno, "close");
 
507
      status = EX_OSERR;
 
508
    }
 
509
    goto failure;
 
510
  }
 
511
  outfifo_fd = -1;
 
512
  
 
513
  if(interrupted_by_signal){
 
514
    goto failure;
 
515
  }
 
516
  
 
517
  if(not usplash_write(&fifo_fd, "TIMEOUT", "15")){
 
518
    if(errno != EINTR){
 
519
      error_plus(0, errno, "usplash_write");
 
520
      status = EX_OSERR;
 
521
    }
 
522
    goto failure;
 
523
  }
 
524
  
 
525
  if(interrupted_by_signal){
 
526
    goto failure;
 
527
  }
 
528
  
 
529
  ret = close(fifo_fd);
 
530
  if(ret == -1){
 
531
    if(errno != EINTR){
 
532
      error_plus(0, errno, "close");
 
533
      status = EX_OSERR;
 
534
    }
 
535
    goto failure;
 
536
  }
 
537
  fifo_fd = -1;
 
538
  
 
539
  /* Print password to stdout */
 
540
  size_t written = 0;
 
541
  while(written < buf_len){
 
542
    do {
 
543
      sret = write(STDOUT_FILENO, buf + written, buf_len - written);
 
544
      if(sret == -1){
 
545
        if(errno != EINTR){
 
546
          error_plus(0, errno, "write");
 
547
          status = EX_OSERR;
 
548
        }
 
549
        goto failure;
 
550
      }
 
551
    } while(sret == -1);
 
552
    
 
553
    if(interrupted_by_signal){
 
554
      goto failure;
 
555
    }
 
556
    written += (size_t)sret;
 
557
  }
 
558
  free(buf);
 
559
  buf = NULL;
 
560
  
 
561
  if(interrupted_by_signal){
 
562
    goto failure;
 
563
  }
 
564
  
 
565
  free(cmdline);
 
566
  return EXIT_SUCCESS;
 
567
  
 
568
 failure:
 
569
  
 
570
  free(buf);
 
571
  
 
572
  free(prompt);
 
573
  
 
574
  /* If usplash was never accessed, we can stop now */
 
575
  if(not usplash_accessed){
 
576
    return status;
 
577
  }
 
578
  
 
579
  /* Close FIFO */
 
580
  if(fifo_fd != -1){
 
581
    ret = close(fifo_fd);
 
582
    if(ret == -1 and errno != EINTR){
 
583
      error_plus(0, errno, "close");
 
584
    }
 
585
    fifo_fd = -1;
 
586
  }
 
587
  
 
588
  /* Close output FIFO */
 
589
  if(outfifo_fd != -1){
 
590
    ret = close(outfifo_fd);
 
591
    if(ret == -1){
 
592
      error_plus(0, errno, "close");
 
593
    }
 
594
  }
 
595
  
 
596
  /* Create argv for new usplash*/
 
597
  char **cmdline_argv = malloc((argz_count(cmdline, cmdline_len) + 1)
 
598
                               * sizeof(char *)); /* Count args */
 
599
  if(cmdline_argv == NULL){
 
600
    error_plus(0, errno, "malloc");
 
601
    return status;
 
602
  }
 
603
  argz_extract(cmdline, cmdline_len, cmdline_argv); /* Create argv */
 
604
  
477
605
  /* Kill old usplash */
478
606
  kill(usplash_pid, SIGTERM);
479
607
  sleep(2);
481
609
    kill(usplash_pid, SIGKILL);
482
610
    sleep(1);
483
611
  }
 
612
  
484
613
  pid_t new_usplash_pid = fork();
485
614
  if(new_usplash_pid == 0){
486
615
    /* Child; will become new usplash process */
487
616
    
488
617
    /* Make the effective user ID (root) the only user ID instead of
489
 
       the real user ID (mandos) */
 
618
       the real user ID (_mandos) */
490
619
    ret = setuid(geteuid());
491
620
    if(ret == -1){
492
 
      perror("setuid");
 
621
      error_plus(0, errno, "setuid");
493
622
    }
494
623
    
495
624
    setsid();
496
625
    ret = chdir("/");
 
626
    if(ret == -1){
 
627
      error_plus(0, errno, "chdir");
 
628
      _exit(EX_OSERR);
 
629
    }
497
630
/*     if(fork() != 0){ */
498
631
/*       _exit(EXIT_SUCCESS); */
499
632
/*     } */
500
633
    ret = dup2(STDERR_FILENO, STDOUT_FILENO); /* replace our stdout */
501
634
    if(ret == -1){
502
 
      perror("dup2");
503
 
      _exit(EXIT_FAILURE);
 
635
      error_plus(0, errno, "dup2");
 
636
      _exit(EX_OSERR);
504
637
    }
505
638
    
506
639
    execv(usplash_name, cmdline_argv);
507
640
    if(not interrupted_by_signal){
508
 
      perror("execv");
 
641
      error_plus(0, errno, "execv");
509
642
    }
510
643
    free(cmdline);
511
644
    free(cmdline_argv);
512
 
    _exit(EXIT_FAILURE);
 
645
    _exit(EX_OSERR);
513
646
  }
514
647
  free(cmdline);
515
648
  free(cmdline_argv);
516
649
  sleep(2);
517
 
  if(not usplash_write("PULSATE", NULL)
518
 
     and (errno != EINTR)){
519
 
    perror("usplash_write");
520
 
  }
521
 
  
522
 
  return EXIT_FAILURE;
 
650
  if(not usplash_write(&fifo_fd, "PULSATE", NULL)){
 
651
    if(errno != EINTR){
 
652
      error_plus(0, errno, "usplash_write");
 
653
    }
 
654
  }
 
655
  
 
656
  /* Close FIFO (again) */
 
657
  if(fifo_fd != -1){
 
658
    ret = close(fifo_fd);
 
659
    if(ret == -1 and errno != EINTR){
 
660
      error_plus(0, errno, "close");
 
661
    }
 
662
    fifo_fd = -1;
 
663
  }
 
664
  
 
665
  if(interrupted_by_signal){
 
666
    struct sigaction signal_action = { .sa_handler = SIG_DFL };
 
667
    sigemptyset(&signal_action.sa_mask);
 
668
    ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
 
669
                                            &signal_action, NULL));
 
670
    if(ret == -1){
 
671
      error_plus(0, errno, "sigaction");
 
672
    }
 
673
    do {
 
674
      ret = raise(signal_received);
 
675
    } while(ret != 0 and errno == EINTR);
 
676
    if(ret != 0){
 
677
      error_plus(0, errno, "raise");
 
678
      abort();
 
679
    }
 
680
    TEMP_FAILURE_RETRY(pause());
 
681
  }
 
682
  
 
683
  return status;
523
684
}