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

  • Committer: teddy at recompile
  • Date: 2020-12-03 20:30:45 UTC
  • mto: This revision was merged to the branch mainline in revision 404.
  • Revision ID: teddy@recompile.se-20201203203045-iqd6nq9y5nwalh1x
Minor fix of a test function

In dracut-module/password-agent, the test function
test_send_password_to_socket_EMSGSIZE() (which tests that the
send_password_to_socket() task function aborts properly when getting
EMSGSIZE when writing to the password socket), part of the test code
is supposed to find a message size which definitely does trigger
EMSGSIZE when send()ing to a socket.  Without a "break" in the proper
place, however, the size given is always exactly 1024 bytes too large.

This is very probably not a problem, since a too large message will
still be too large if it is increased by 1024 bytes, and send(2) in
practice checks the size before reading the buffer.  The biggest issue
would be if some version of send(2) would try to look at the last 1024
bytes of the message buffer before checking the message size; this
would then lead to a buffer over-read when running this test function.
(But even then there would be no security implications since the tests
are not run in the normal operation of the program.)

* dracut-module/password-agent.c
  (test_send_password_to_socket_EMSGSIZE): Break out early when ssret
  < 0 and errno == EMSGSIZE; don't allow loop to increase message_size
  again.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/plymouth.c
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-2020 Teddy Hogeborn
 
6
 * Copyright © 2010-2020 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
23
 * Contact the authors at <mandos@recompile.se>.
23
24
 */
43
44
                                   STDERR_FILENO, execv(), access() */
44
45
#include <stdlib.h>             /* free(), EXIT_FAILURE, realloc(),
45
46
                                   EXIT_SUCCESS, malloc(), _exit(),
46
 
                                   getenv() */
 
47
                                   getenv(), reallocarray() */
47
48
#include <dirent.h>             /* scandir(), alphasort() */
48
49
#include <inttypes.h>           /* intmax_t, strtoumax(), SCNuMAX */
49
50
#include <sys/stat.h>           /* struct stat, lstat() */
52
53
#include <errno.h>              /* TEMP_FAILURE_RETRY */
53
54
#include <argz.h>               /* argz_count(), argz_extract() */
54
55
#include <stdarg.h>             /* va_list, va_start(), ... */
 
56
#include <argp.h>
55
57
 
56
58
sig_atomic_t interrupted_by_signal = 0;
 
59
const char *argp_program_version = "plymouth " VERSION;
 
60
const char *argp_program_bug_address = "<mandos@recompile.se>";
57
61
 
58
62
/* Used by Ubuntu 11.04 (Natty Narwahl) */
59
 
const char plymouth_old_pid[] = "/dev/.initramfs/plymouth.pid";
 
63
const char plymouth_old_old_pid[] = "/dev/.initramfs/plymouth.pid";
60
64
/* Used by Ubuntu 11.10 (Oneiric Ocelot) */
61
 
const char plymouth_pid[] = "/run/initramfs/plymouth.pid";
 
65
const char plymouth_old_pid[] = "/run/initramfs/plymouth.pid";
 
66
/* Used by Debian 9 (stretch) */
 
67
const char plymouth_pid[] = "/run/plymouth/pid";
62
68
 
63
69
const char plymouth_path[] = "/bin/plymouth";
64
70
const char plymouthd_path[] = "/sbin/plymouthd";
66
72
                                        "--mode=boot",
67
73
                                        "--attach-to-session",
68
74
                                        NULL };
 
75
bool debug = false;
69
76
 
70
77
static void termination_handler(__attribute__((unused))int signum){
71
78
  if(interrupted_by_signal){
74
81
  interrupted_by_signal = 1;
75
82
}
76
83
 
 
84
__attribute__((format (gnu_printf, 2, 3), nonnull))
 
85
int fprintf_plus(FILE *stream, const char *format, ...){
 
86
  va_list ap;
 
87
  va_start (ap, format);
 
88
  fprintf(stream, "Mandos plugin %s: ", program_invocation_short_name);
 
89
  return vfprintf(stream, format, ap);
 
90
}
 
91
 
77
92
/* Function to use when printing errors */
 
93
__attribute__((format (gnu_printf, 3, 4)))
78
94
void error_plus(int status, int errnum, const char *formatstring,
79
95
                ...){
80
96
  va_list ap;
83
99
  
84
100
  va_start(ap, formatstring);
85
101
  ret = vasprintf(&text, formatstring, ap);
86
 
  if (ret == -1){
 
102
  if(ret == -1){
87
103
    fprintf(stderr, "Mandos plugin %s: ",
88
104
            program_invocation_short_name);
89
105
    vfprintf(stderr, formatstring, ap);
153
169
  return true;
154
170
}
155
171
 
 
172
__attribute__((nonnull (2, 3)))
156
173
bool exec_and_wait(pid_t *pid_return, const char *path,
157
 
                   const char **argv, bool interruptable,
 
174
                   const char * const * const argv, bool interruptable,
158
175
                   bool daemonize){
159
176
  int status;
160
177
  int ret;
161
178
  pid_t pid;
 
179
  if(debug){
 
180
    for(const char * const *arg = argv; *arg != NULL; arg++){
 
181
      fprintf_plus(stderr, "exec_and_wait arg: %s\n", *arg);
 
182
    }
 
183
    fprintf_plus(stderr, "exec_and_wait end of args\n");
 
184
  }
 
185
 
162
186
  pid = fork();
163
187
  if(pid == -1){
164
188
    error_plus(0, errno, "fork");
172
196
      }
173
197
    }
174
198
    
175
 
    char **new_argv = NULL;
 
199
    char **new_argv = malloc(sizeof(const char *));
 
200
    if(new_argv == NULL){
 
201
      error_plus(0, errno, "malloc");
 
202
      _exit(EX_OSERR);
 
203
    }
176
204
    char **tmp;
177
205
    int i = 0;
178
 
    for (; argv[i]!=NULL; i++){
179
 
      tmp = realloc(new_argv, sizeof(const char *) * ((size_t)i + 1));
180
 
      if (tmp == NULL){
181
 
        error_plus(0, errno, "realloc");
 
206
    for (; argv[i] != NULL; i++){
 
207
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 26)
 
208
      tmp = reallocarray(new_argv, ((size_t)i + 2),
 
209
                         sizeof(const char *));
 
210
#else
 
211
      if(((size_t)i + 2) > (SIZE_MAX / sizeof(const char *))){
 
212
        /* overflow */
 
213
        tmp = NULL;
 
214
        errno = ENOMEM;
 
215
      } else {
 
216
        tmp = realloc(new_argv, ((size_t)i + 2) * sizeof(const char *));
 
217
      }
 
218
#endif
 
219
      if(tmp == NULL){
 
220
        error_plus(0, errno, "reallocarray");
182
221
        free(new_argv);
183
222
        _exit(EX_OSERR);
184
223
      }
200
239
          and ((not interrupted_by_signal)
201
240
               or (not interruptable)));
202
241
  if(interrupted_by_signal and interruptable){
 
242
    if(debug){
 
243
      fprintf_plus(stderr, "Interrupted by signal\n");
 
244
    }
203
245
    return false;
204
246
  }
205
247
  if(ret == -1){
206
248
    error_plus(0, errno, "waitpid");
207
249
    return false;
208
250
  }
 
251
  if(debug){
 
252
    if(WIFEXITED(status)){
 
253
      fprintf_plus(stderr, "exec_and_wait exited: %d\n",
 
254
                   WEXITSTATUS(status));
 
255
    } else if(WIFSIGNALED(status)) {
 
256
      fprintf_plus(stderr, "exec_and_wait signaled: %d\n",
 
257
                   WTERMSIG(status));
 
258
    }
 
259
  }
209
260
  if(WIFEXITED(status) and (WEXITSTATUS(status) == 0)){
210
261
    return true;
211
262
  }
212
263
  return false;
213
264
}
214
265
 
 
266
__attribute__((nonnull))
215
267
int is_plymouth(const struct dirent *proc_entry){
216
268
  int ret;
217
269
  {
218
 
    uintmax_t maxvalue;
 
270
    uintmax_t proc_id;
219
271
    char *tmp;
220
272
    errno = 0;
221
 
    maxvalue = strtoumax(proc_entry->d_name, &tmp, 10);
 
273
    proc_id = strtoumax(proc_entry->d_name, &tmp, 10);
222
274
 
223
275
    if(errno != 0 or *tmp != '\0'
224
 
       or maxvalue != (uintmax_t)((pid_t)maxvalue)){
 
276
       or proc_id != (uintmax_t)((pid_t)proc_id)){
225
277
      return 0;
226
278
    }
227
279
  }
262
314
 
263
315
pid_t get_pid(void){
264
316
  int ret;
265
 
  uintmax_t maxvalue = 0;
 
317
  uintmax_t proc_id = 0;
266
318
  FILE *pidfile = fopen(plymouth_pid, "r");
267
319
  /* Try the new pid file location */
268
320
  if(pidfile != NULL){
269
 
    ret = fscanf(pidfile, "%" SCNuMAX, &maxvalue);
 
321
    ret = fscanf(pidfile, "%" SCNuMAX, &proc_id);
270
322
    if(ret != 1){
271
 
      maxvalue = 0;
 
323
      proc_id = 0;
272
324
    }
273
325
    fclose(pidfile);
274
326
  }
275
327
  /* Try the old pid file location */
276
 
  if(maxvalue == 0){
277
 
    pidfile = fopen(plymouth_pid, "r");
278
 
    if(pidfile != NULL){
279
 
      ret = fscanf(pidfile, "%" SCNuMAX, &maxvalue);
280
 
      if(ret != 1){
281
 
        maxvalue = 0;
 
328
  if(proc_id == 0){
 
329
    pidfile = fopen(plymouth_old_pid, "r");
 
330
    if(pidfile != NULL){
 
331
      ret = fscanf(pidfile, "%" SCNuMAX, &proc_id);
 
332
      if(ret != 1){
 
333
        proc_id = 0;
 
334
      }
 
335
      fclose(pidfile);
 
336
    }
 
337
  }
 
338
  /* Try the old old pid file location */
 
339
  if(proc_id == 0){
 
340
    pidfile = fopen(plymouth_old_old_pid, "r");
 
341
    if(pidfile != NULL){
 
342
      ret = fscanf(pidfile, "%" SCNuMAX, &proc_id);
 
343
      if(ret != 1){
 
344
        proc_id = 0;
282
345
      }
283
346
      fclose(pidfile);
284
347
    }
285
348
  }
286
349
  /* Look for a plymouth process */
287
 
  if(maxvalue == 0){
 
350
  if(proc_id == 0){
288
351
    struct dirent **direntries = NULL;
289
352
    ret = scandir("/proc", &direntries, is_plymouth, alphasort);
290
 
    if (ret == -1){
 
353
    if(ret == -1){
291
354
      error_plus(0, errno, "scandir");
292
355
    }
293
 
    if (ret > 0){
294
 
      ret = sscanf(direntries[0]->d_name, "%" SCNuMAX, &maxvalue);
295
 
      if (ret < 0){
296
 
        error_plus(0, errno, "sscanf");
 
356
    if(ret > 0){
 
357
      for(int i = ret-1; i >= 0; i--){
 
358
        if(proc_id == 0){
 
359
          ret = sscanf(direntries[i]->d_name, "%" SCNuMAX, &proc_id);
 
360
          if(ret < 0){
 
361
            error_plus(0, errno, "sscanf");
 
362
          }
 
363
        }
 
364
        free(direntries[i]);
297
365
      }
298
366
    }
299
367
    /* scandir might preallocate for this variable (man page unclear).
301
369
    free(direntries);
302
370
  }
303
371
  pid_t pid;
304
 
  pid = (pid_t)maxvalue;
305
 
  if((uintmax_t)pid == maxvalue){
 
372
  pid = (pid_t)proc_id;
 
373
  if((uintmax_t)pid == proc_id){
306
374
    return pid;
307
375
  }
308
376
  
309
377
  return 0;
310
378
}
311
379
 
312
 
const char **getargv(pid_t pid){
 
380
char **getargv(pid_t pid){
313
381
  int cl_fd;
314
382
  char *cmdline_filename;
315
383
  ssize_t sret;
376
444
    return NULL;
377
445
  }
378
446
  argz_extract(cmdline, cmdline_len, argv); /* Create argv */
379
 
  return (const char **)argv;
 
447
  return argv;
380
448
}
381
449
 
382
450
int main(__attribute__((unused))int argc,
383
451
         __attribute__((unused))char **argv){
384
 
  char *prompt;
 
452
  char *prompt = NULL;
385
453
  char *prompt_arg;
386
454
  pid_t plymouth_command_pid;
387
455
  int ret;
388
456
  bool bret;
389
457
 
 
458
  {
 
459
    struct argp_option options[] = {
 
460
      { .name = "prompt", .key = 128, .arg = "PROMPT",
 
461
        .doc = "The prompt to show" },
 
462
      { .name = "debug", .key = 129,
 
463
        .doc = "Debug mode" },
 
464
      { .name = NULL }
 
465
    };
 
466
    
 
467
    __attribute__((nonnull(3)))
 
468
    error_t parse_opt (int key, char *arg, __attribute__((unused))
 
469
                       struct argp_state *state){
 
470
      errno = 0;
 
471
      switch (key){
 
472
      case 128:                 /* --prompt */
 
473
        prompt = arg;
 
474
        if(debug){
 
475
          fprintf_plus(stderr, "Custom prompt \"%s\"\n", prompt);
 
476
        }
 
477
        break;
 
478
      case 129:                 /* --debug */
 
479
        debug = true;
 
480
        break;
 
481
      default:
 
482
        return ARGP_ERR_UNKNOWN;
 
483
      }
 
484
      return errno;
 
485
    }
 
486
    
 
487
    struct argp argp = { .options = options, .parser = parse_opt,
 
488
                         .args_doc = "",
 
489
                         .doc = "Mandos plymouth -- Read and"
 
490
                         " output a password" };
 
491
    ret = argp_parse(&argp, argc, argv, ARGP_IN_ORDER, NULL, NULL);
 
492
    switch(ret){
 
493
    case 0:
 
494
      break;
 
495
    case ENOMEM:
 
496
    default:
 
497
      errno = ret;
 
498
      error_plus(0, errno, "argp_parse");
 
499
      return EX_OSERR;
 
500
    case EINVAL:
 
501
      error_plus(0, errno, "argp_parse");
 
502
      return EX_USAGE;
 
503
    }
 
504
  }
 
505
  
390
506
  /* test -x /bin/plymouth */
391
507
  ret = access(plymouth_path, X_OK);
392
508
  if(ret == -1){
393
509
    /* Plymouth is probably not installed.  Don't print an error
394
510
       message, just exit. */
 
511
    if(debug){
 
512
      fprintf_plus(stderr, "Plymouth (%s) not found\n",
 
513
                   plymouth_path);
 
514
    }
395
515
    exit(EX_UNAVAILABLE);
396
516
  }
397
517
  
431
551
    }
432
552
    /* Plymouth is probably not running.  Don't print an error
433
553
       message, just exit. */
 
554
    if(debug){
 
555
      fprintf_plus(stderr, "Plymouth not running\n");
 
556
    }
434
557
    exit(EX_UNAVAILABLE);
435
558
  }
436
559
  
437
 
  prompt = makeprompt();
438
 
  ret = asprintf(&prompt_arg, "--prompt=%s", prompt);
439
 
  free(prompt);
 
560
  if(prompt != NULL){
 
561
    ret = asprintf(&prompt_arg, "--prompt=%s", prompt);
 
562
  } else {
 
563
    char *made_prompt = makeprompt();
 
564
    ret = asprintf(&prompt_arg, "--prompt=%s", made_prompt);
 
565
    free(made_prompt);
 
566
  }
440
567
  if(ret == -1){
441
568
    error_plus(EX_OSERR, errno, "asprintf");
442
569
  }
443
570
  
444
571
  /* plymouth ask-for-password --prompt="$prompt" */
 
572
  if(debug){
 
573
    fprintf_plus(stderr, "Prompting for password via Plymouth\n");
 
574
  }
445
575
  bret = exec_and_wait(&plymouth_command_pid,
446
576
                       plymouth_path, (const char *[])
447
577
                       { plymouth_path, "ask-for-password",
457
587
  }
458
588
  kill_and_wait(plymouth_command_pid);
459
589
  
460
 
  const char **plymouthd_argv;
 
590
  char **plymouthd_argv = NULL;
461
591
  pid_t pid = get_pid();
462
592
  if(pid == 0){
463
593
    error_plus(0, 0, "plymouthd pid not found");
464
 
    plymouthd_argv = plymouthd_default_argv;
465
594
  } else {
466
595
    plymouthd_argv = getargv(pid);
467
596
  }
470
599
                       { plymouth_path, "quit", NULL },
471
600
                       false, false);
472
601
  if(not bret){
 
602
    if(plymouthd_argv != NULL){
 
603
      free(*plymouthd_argv);
 
604
      free(plymouthd_argv);
 
605
    }
473
606
    exit(EXIT_FAILURE);
474
607
  }
475
 
  bret = exec_and_wait(NULL, plymouthd_path, plymouthd_argv,
 
608
  bret = exec_and_wait(NULL, plymouthd_path,
 
609
                       (plymouthd_argv != NULL)
 
610
                       ? (const char * const *)plymouthd_argv
 
611
                       : plymouthd_default_argv,
476
612
                       false, true);
 
613
  if(plymouthd_argv != NULL){
 
614
    free(*plymouthd_argv);
 
615
    free(plymouthd_argv);
 
616
  }
477
617
  if(not bret){
478
618
    exit(EXIT_FAILURE);
479
619
  }