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

  • Committer: Teddy Hogeborn
  • Date: 2019-07-14 22:39:15 UTC
  • Revision ID: teddy@recompile.se-20190714223915-aqjkms3t3taa6tye
Only use sanitizing options when debugging

The C compiler's sanitizing options introduce code in the output
binary which is fragile and not very security conscious.  It has
become clear that sanitizing is only really meant for use while
debugging.

As a side effect, this makes compilation faster, as the Makefile, for
production builds, no longer runs the compiler repeatedly to find all
its currently supported sanitizing options.

* Makefile (DEBUG): Add "$(SANITIZE)".
  (SANITIZE): Comment out.
  (CFLAGS): Remove "$(SANITIZE)".
  (plugins.d/mandos-client): Revert back to use plain $(LINK.c), since
                             we no longer need to remove the leak
                             sanitizer by overriding CFLAGS.

Show diffs side-by-side

added added

removed removed

Lines of Context:
2
2
/*
3
3
 * Plymouth - Read a password from Plymouth and output it
4
4
 * 
5
 
 * Copyright © 2010-2011 Teddy Hogeborn
6
 
 * Copyright © 2010-2011 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
 
5
 * Copyright © 2010-2018 Teddy Hogeborn
 
6
 * Copyright © 2010-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 <mandos@fukt.bsnet.se>.
 
23
 * Contact the authors at <mandos@recompile.se>.
23
24
 */
24
25
 
25
26
#define _GNU_SOURCE             /* asprintf(), TEMP_FAILURE_RETRY() */
54
55
#include <stdarg.h>             /* va_list, va_start(), ... */
55
56
 
56
57
sig_atomic_t interrupted_by_signal = 0;
57
 
const char plymouth_pid[] = "/dev/.initramfs/plymouth.pid";
 
58
 
 
59
/* Used by Ubuntu 11.04 (Natty Narwahl) */
 
60
const char plymouth_old_old_pid[] = "/dev/.initramfs/plymouth.pid";
 
61
/* Used by Ubuntu 11.10 (Oneiric Ocelot) */
 
62
const char plymouth_old_pid[] = "/run/initramfs/plymouth.pid";
 
63
/* Used by Debian 9 (stretch) */
 
64
const char plymouth_pid[] = "/run/plymouth/pid";
 
65
 
58
66
const char plymouth_path[] = "/bin/plymouth";
59
67
const char plymouthd_path[] = "/sbin/plymouthd";
60
68
const char *plymouthd_default_argv[] = {"/sbin/plymouthd",
61
69
                                        "--mode=boot",
62
70
                                        "--attach-to-session",
63
 
                                        "--pid-file="
64
 
                                        "/dev/.initramfs/"
65
 
                                        "plymouth.pid",
66
71
                                        NULL };
67
72
 
68
73
static void termination_handler(__attribute__((unused))int signum){
73
78
}
74
79
 
75
80
/* Function to use when printing errors */
 
81
__attribute__((format (gnu_printf, 3, 4)))
76
82
void error_plus(int status, int errnum, const char *formatstring,
77
83
                ...){
78
84
  va_list ap;
81
87
  
82
88
  va_start(ap, formatstring);
83
89
  ret = vasprintf(&text, formatstring, ap);
84
 
  if (ret == -1){
 
90
  if(ret == -1){
85
91
    fprintf(stderr, "Mandos plugin %s: ",
86
92
            program_invocation_short_name);
87
93
    vfprintf(stderr, formatstring, ap);
151
157
  return true;
152
158
}
153
159
 
 
160
__attribute__((nonnull (2, 3)))
154
161
bool exec_and_wait(pid_t *pid_return, const char *path,
155
 
                   const char **argv, bool interruptable,
 
162
                   const char * const *argv, bool interruptable,
156
163
                   bool daemonize){
157
164
  int status;
158
165
  int ret;
170
177
      }
171
178
    }
172
179
    
173
 
    char **new_argv = NULL;
 
180
    char **new_argv = malloc(sizeof(const char *));
 
181
    if(new_argv == NULL){
 
182
      error_plus(0, errno, "malloc");
 
183
      _exit(EX_OSERR);
 
184
    }
174
185
    char **tmp;
175
186
    int i = 0;
176
 
    for (; argv[i]!=NULL; i++){
177
 
      tmp = realloc(new_argv, sizeof(const char *) * ((size_t)i + 1));
178
 
      if (tmp == NULL){
 
187
    for (; argv[i] != NULL; i++){
 
188
      tmp = realloc(new_argv, sizeof(const char *) * ((size_t)i + 2));
 
189
      if(tmp == NULL){
179
190
        error_plus(0, errno, "realloc");
180
191
        free(new_argv);
181
192
        _exit(EX_OSERR);
210
221
  return false;
211
222
}
212
223
 
 
224
__attribute__((nonnull))
213
225
int is_plymouth(const struct dirent *proc_entry){
214
226
  int ret;
215
227
  {
216
 
    uintmax_t maxvalue;
 
228
    uintmax_t proc_id;
217
229
    char *tmp;
218
230
    errno = 0;
219
 
    maxvalue = strtoumax(proc_entry->d_name, &tmp, 10);
 
231
    proc_id = strtoumax(proc_entry->d_name, &tmp, 10);
220
232
 
221
233
    if(errno != 0 or *tmp != '\0'
222
 
       or maxvalue != (uintmax_t)((pid_t)maxvalue)){
 
234
       or proc_id != (uintmax_t)((pid_t)proc_id)){
223
235
      return 0;
224
236
    }
225
237
  }
260
272
 
261
273
pid_t get_pid(void){
262
274
  int ret;
 
275
  uintmax_t proc_id = 0;
263
276
  FILE *pidfile = fopen(plymouth_pid, "r");
264
 
  uintmax_t maxvalue = 0;
 
277
  /* Try the new pid file location */
265
278
  if(pidfile != NULL){
266
 
    ret = fscanf(pidfile, "%" SCNuMAX, &maxvalue);
 
279
    ret = fscanf(pidfile, "%" SCNuMAX, &proc_id);
267
280
    if(ret != 1){
268
 
      maxvalue = 0;
 
281
      proc_id = 0;
269
282
    }
270
283
    fclose(pidfile);
271
284
  }
272
 
  if(maxvalue == 0){
 
285
  /* Try the old pid file location */
 
286
  if(proc_id == 0){
 
287
    pidfile = fopen(plymouth_old_pid, "r");
 
288
    if(pidfile != NULL){
 
289
      ret = fscanf(pidfile, "%" SCNuMAX, &proc_id);
 
290
      if(ret != 1){
 
291
        proc_id = 0;
 
292
      }
 
293
      fclose(pidfile);
 
294
    }
 
295
  }
 
296
  /* Try the old old pid file location */
 
297
  if(proc_id == 0){
 
298
    pidfile = fopen(plymouth_old_old_pid, "r");
 
299
    if(pidfile != NULL){
 
300
      ret = fscanf(pidfile, "%" SCNuMAX, &proc_id);
 
301
      if(ret != 1){
 
302
        proc_id = 0;
 
303
      }
 
304
      fclose(pidfile);
 
305
    }
 
306
  }
 
307
  /* Look for a plymouth process */
 
308
  if(proc_id == 0){
273
309
    struct dirent **direntries = NULL;
274
310
    ret = scandir("/proc", &direntries, is_plymouth, alphasort);
275
 
    if (ret == -1){
 
311
    if(ret == -1){
276
312
      error_plus(0, errno, "scandir");
277
313
    }
278
 
    if (ret > 0){
279
 
      ret = sscanf(direntries[0]->d_name, "%" SCNuMAX, &maxvalue);
280
 
      if (ret < 0){
281
 
        error_plus(0, errno, "sscanf");
 
314
    if(ret > 0){
 
315
      for(int i = ret-1; i >= 0; i--){
 
316
        if(proc_id == 0){
 
317
          ret = sscanf(direntries[i]->d_name, "%" SCNuMAX, &proc_id);
 
318
          if(ret < 0){
 
319
            error_plus(0, errno, "sscanf");
 
320
          }
 
321
        }
 
322
        free(direntries[i]);
282
323
      }
283
324
    }
284
325
    /* scandir might preallocate for this variable (man page unclear).
286
327
    free(direntries);
287
328
  }
288
329
  pid_t pid;
289
 
  pid = (pid_t)maxvalue;
290
 
  if((uintmax_t)pid == maxvalue){
 
330
  pid = (pid_t)proc_id;
 
331
  if((uintmax_t)pid == proc_id){
291
332
    return pid;
292
333
  }
293
334
  
294
335
  return 0;
295
336
}
296
337
 
297
 
const char **getargv(pid_t pid){
 
338
char **getargv(pid_t pid){
298
339
  int cl_fd;
299
340
  char *cmdline_filename;
300
341
  ssize_t sret;
361
402
    return NULL;
362
403
  }
363
404
  argz_extract(cmdline, cmdline_len, argv); /* Create argv */
364
 
  return (const char **)argv;
 
405
  return argv;
365
406
}
366
407
 
367
408
int main(__attribute__((unused))int argc,
442
483
  }
443
484
  kill_and_wait(plymouth_command_pid);
444
485
  
445
 
  const char **plymouthd_argv;
 
486
  char **plymouthd_argv = NULL;
446
487
  pid_t pid = get_pid();
447
488
  if(pid == 0){
448
489
    error_plus(0, 0, "plymouthd pid not found");
449
 
    plymouthd_argv = plymouthd_default_argv;
450
490
  } else {
451
491
    plymouthd_argv = getargv(pid);
452
492
  }
455
495
                       { plymouth_path, "quit", NULL },
456
496
                       false, false);
457
497
  if(not bret){
 
498
    if(plymouthd_argv != NULL){
 
499
      free(*plymouthd_argv);
 
500
      free(plymouthd_argv);
 
501
    }
458
502
    exit(EXIT_FAILURE);
459
503
  }
460
 
  bret = exec_and_wait(NULL, plymouthd_path, plymouthd_argv,
 
504
  bret = exec_and_wait(NULL, plymouthd_path,
 
505
                       (plymouthd_argv != NULL)
 
506
                       ? (const char * const *)plymouthd_argv
 
507
                       : plymouthd_default_argv,
461
508
                       false, true);
 
509
  if(plymouthd_argv != NULL){
 
510
    free(*plymouthd_argv);
 
511
    free(plymouthd_argv);
 
512
  }
462
513
  if(not bret){
463
514
    exit(EXIT_FAILURE);
464
515
  }