/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 Hogeborn
  • Date: 2016-03-17 20:40:55 UTC
  • mto: (237.7.594 trunk)
  • mto: This revision was merged to the branch mainline in revision 341.
  • Revision ID: teddy@recompile.se-20160317204055-bhsh5xsidq7w5cxu
Client: Fix plymouth agent; broken since 1.7.2.

Fix an very old memory bug in the plymouth agent (which has been
present since its apperance in version 1.2), but which was only
recently detected at run time due to the new -fsanitize=address
compile- time flag, which has been used since version 1.7.2.  This
detection of a memory access violation causes the program to abort,
making the Plymouth graphical boot system unable to accept interactive
input of passwords when using the Mandos client.

* plugins.d/plymouth.c (exec_and_wait): Fix memory allocation bug when
  allocating new_argv.  Also tolerate a zero-length argv.

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-2022 Teddy Hogeborn
6
 
 * Copyright © 2010-2022 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
 
5
 * Copyright © 2010-2016 Teddy Hogeborn
 
6
 * Copyright © 2010-2016 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
16
14
 * WITHOUT ANY WARRANTY; without even the implied warranty of
17
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18
16
 * General Public License for more details.
19
17
 * 
20
18
 * You should have received a copy of the GNU General Public License
21
 
 * along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
 
19
 * along with this program.  If not, see
 
20
 * <http://www.gnu.org/licenses/>.
22
21
 * 
23
22
 * Contact the authors at <mandos@recompile.se>.
24
23
 */
25
24
 
26
 
#define _GNU_SOURCE             /* program_invocation_short_name,
27
 
                                   vasprintf(), asprintf(),
28
 
                                   TEMP_FAILURE_RETRY() */
29
 
#include <sys/types.h>          /* sig_atomic_t, pid_t, setuid(),
30
 
                                   geteuid(), setsid() */
31
 
#include <argp.h>               /* argp_program_version,
32
 
                                   argp_program_bug_address,
33
 
                                   struct argp_option,
34
 
                                   struct argp_state,
35
 
                                   ARGP_ERR_UNKNOWN, struct argp,
36
 
                                   argp_parse(), ARGP_IN_ORDER */
37
 
#include <stddef.h>             /* NULL, size_t */
 
25
#define _GNU_SOURCE             /* asprintf(), TEMP_FAILURE_RETRY() */
 
26
#include <signal.h>             /* sig_atomic_t, struct sigaction,
 
27
                                   sigemptyset(), sigaddset(), SIGINT,
 
28
                                   SIGHUP, SIGTERM, sigaction(),
 
29
                                   kill(), SIG_IGN */
38
30
#include <stdbool.h>            /* bool, false, true */
39
 
#include <stdio.h>              /* FILE, fprintf(), vfprintf(),
40
 
                                   vasprintf(), stderr, asprintf(),
41
 
                                   fopen(), fscanf(), fclose(),
42
 
                                   sscanf() */
43
 
#include <stdarg.h>             /* va_list, va_start(), vfprintf() */
44
 
#include <errno.h>              /* program_invocation_short_name,
45
 
                                   errno, ENOMEM, EINTR, ENOENT,
46
 
                                   error_t, EINVAL */
47
 
#include <string.h>             /* strerror(), strdup(), memcmp() */
 
31
#include <fcntl.h>              /* open(), O_RDONLY */
 
32
#include <iso646.h>             /* and, or, not*/
 
33
#include <sys/types.h>          /* size_t, ssize_t, pid_t, struct
 
34
                                   dirent, waitpid() */
 
35
#include <sys/wait.h>           /* waitpid() */
 
36
#include <stddef.h>             /* NULL */
 
37
#include <string.h>             /* strchr(), memcmp() */
 
38
#include <stdio.h>              /* asprintf(), perror(), fopen(),
 
39
                                   fscanf(), vasprintf(), fprintf(),
 
40
                                   vfprintf() */
 
41
#include <unistd.h>             /* close(), readlink(), read(),
 
42
                                   fork(), setsid(), chdir(), dup2(),
 
43
                                   STDERR_FILENO, execv(), access() */
 
44
#include <stdlib.h>             /* free(), EXIT_FAILURE, realloc(),
 
45
                                   EXIT_SUCCESS, malloc(), _exit(),
 
46
                                   getenv() */
 
47
#include <dirent.h>             /* scandir(), alphasort() */
 
48
#include <inttypes.h>           /* intmax_t, strtoumax(), SCNuMAX */
 
49
#include <sys/stat.h>           /* struct stat, lstat() */
 
50
#include <sysexits.h>           /* EX_OSERR, EX_UNAVAILABLE */
48
51
#include <error.h>              /* error() */
49
 
#include <stdlib.h>             /* free(), getenv(), malloc(),
50
 
                                   reallocarray(), realloc(),
51
 
                                   EXIT_FAILURE, EXIT_SUCCESS */
52
 
#include <unistd.h>             /* TEMP_FAILURE_RETRY(), setuid(),
53
 
                                   geteuid(), setsid(), chdir(),
54
 
                                   dup2(), STDERR_FILENO,
55
 
                                   STDOUT_FILENO, fork(), _exit(),
56
 
                                   execv(), ssize_t, readlink(),
57
 
                                   close(), read(), access(), X_OK */
58
 
#include <signal.h>             /* kill(), SIGTERM, struct sigaction,
59
 
                                   sigemptyset(), SIGINT, SIGHUP,
60
 
                                   sigaddset(), SIG_IGN */
61
 
#include <sys/wait.h>           /* waitpid(), WIFEXITED(),
62
 
                                   WEXITSTATUS(), WIFSIGNALED(),
63
 
                                   WTERMSIG() */
64
 
#include <iso646.h>             /* not, and, or */
65
 
#include <sysexits.h>           /* EX_OSERR, EX_USAGE,
66
 
                                   EX_UNAVAILABLE */
67
 
#include <stdint.h>             /* SIZE_MAX */
68
 
#include <dirent.h>             /* struct dirent, scandir(),
69
 
                                   alphasort() */
70
 
#include <inttypes.h>           /* uintmax_t, strtoumax(), SCNuMAX,
71
 
                                   PRIuMAX */
72
 
#include <sys/stat.h>           /* struct stat, lstat(), S_ISLNK() */
73
 
#include <fcntl.h>              /* open(), O_RDONLY */
 
52
#include <errno.h>              /* TEMP_FAILURE_RETRY */
74
53
#include <argz.h>               /* argz_count(), argz_extract() */
 
54
#include <stdarg.h>             /* va_list, va_start(), ... */
75
55
 
76
56
sig_atomic_t interrupted_by_signal = 0;
77
 
const char *argp_program_version = "plymouth " VERSION;
78
 
const char *argp_program_bug_address = "<mandos@recompile.se>";
79
57
 
80
58
/* Used by Ubuntu 11.04 (Natty Narwahl) */
81
 
const char plymouth_old_old_pid[] = "/dev/.initramfs/plymouth.pid";
 
59
const char plymouth_old_pid[] = "/dev/.initramfs/plymouth.pid";
82
60
/* Used by Ubuntu 11.10 (Oneiric Ocelot) */
83
 
const char plymouth_old_pid[] = "/run/initramfs/plymouth.pid";
84
 
/* Used by Debian 9 (stretch) */
85
 
const char plymouth_pid[] = "/run/plymouth/pid";
 
61
const char plymouth_pid[] = "/run/initramfs/plymouth.pid";
86
62
 
87
63
const char plymouth_path[] = "/bin/plymouth";
88
64
const char plymouthd_path[] = "/sbin/plymouthd";
90
66
                                        "--mode=boot",
91
67
                                        "--attach-to-session",
92
68
                                        NULL };
93
 
bool debug = false;
94
69
 
95
70
static void termination_handler(__attribute__((unused))int signum){
96
71
  if(interrupted_by_signal){
99
74
  interrupted_by_signal = 1;
100
75
}
101
76
 
102
 
__attribute__((format (gnu_printf, 2, 3), nonnull))
103
 
int fprintf_plus(FILE *stream, const char *format, ...){
104
 
  va_list ap;
105
 
  va_start (ap, format);
106
 
  fprintf(stream, "Mandos plugin %s: ", program_invocation_short_name);
107
 
  return vfprintf(stream, format, ap);
108
 
}
109
 
 
110
77
/* Function to use when printing errors */
111
78
__attribute__((format (gnu_printf, 3, 4)))
112
79
void error_plus(int status, int errnum, const char *formatstring,
189
156
 
190
157
__attribute__((nonnull (2, 3)))
191
158
bool exec_and_wait(pid_t *pid_return, const char *path,
192
 
                   const char * const * const argv, bool interruptable,
 
159
                   const char * const *argv, bool interruptable,
193
160
                   bool daemonize){
194
161
  int status;
195
162
  int ret;
196
163
  pid_t pid;
197
 
  if(debug){
198
 
    for(const char * const *arg = argv; *arg != NULL; arg++){
199
 
      fprintf_plus(stderr, "exec_and_wait arg: %s\n", *arg);
200
 
    }
201
 
    fprintf_plus(stderr, "exec_and_wait end of args\n");
202
 
  }
203
 
 
204
164
  pid = fork();
205
165
  if(pid == -1){
206
166
    error_plus(0, errno, "fork");
221
181
    }
222
182
    char **tmp;
223
183
    int i = 0;
224
 
    for (; argv[i] != NULL; i++){
225
 
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 26)
226
 
      tmp = reallocarray(new_argv, ((size_t)i + 2),
227
 
                         sizeof(const char *));
228
 
#else
229
 
      if(((size_t)i + 2) > (SIZE_MAX / sizeof(const char *))){
230
 
        /* overflow */
231
 
        tmp = NULL;
232
 
        errno = ENOMEM;
233
 
      } else {
234
 
        tmp = realloc(new_argv, ((size_t)i + 2) * sizeof(const char *));
235
 
      }
236
 
#endif
 
184
    for (; argv[i]!=NULL; i++){
 
185
      tmp = realloc(new_argv, sizeof(const char *) * ((size_t)i + 2));
237
186
      if(tmp == NULL){
238
 
        error_plus(0, errno, "reallocarray");
 
187
        error_plus(0, errno, "realloc");
239
188
        free(new_argv);
240
189
        _exit(EX_OSERR);
241
190
      }
257
206
          and ((not interrupted_by_signal)
258
207
               or (not interruptable)));
259
208
  if(interrupted_by_signal and interruptable){
260
 
    if(debug){
261
 
      fprintf_plus(stderr, "Interrupted by signal\n");
262
 
    }
263
209
    return false;
264
210
  }
265
211
  if(ret == -1){
266
212
    error_plus(0, errno, "waitpid");
267
213
    return false;
268
214
  }
269
 
  if(debug){
270
 
    if(WIFEXITED(status)){
271
 
      fprintf_plus(stderr, "exec_and_wait exited: %d\n",
272
 
                   WEXITSTATUS(status));
273
 
    } else if(WIFSIGNALED(status)) {
274
 
      fprintf_plus(stderr, "exec_and_wait signaled: %d\n",
275
 
                   WTERMSIG(status));
276
 
    }
277
 
  }
278
215
  if(WIFEXITED(status) and (WEXITSTATUS(status) == 0)){
279
216
    return true;
280
217
  }
344
281
  }
345
282
  /* Try the old pid file location */
346
283
  if(proc_id == 0){
347
 
    pidfile = fopen(plymouth_old_pid, "r");
348
 
    if(pidfile != NULL){
349
 
      ret = fscanf(pidfile, "%" SCNuMAX, &proc_id);
350
 
      if(ret != 1){
351
 
        proc_id = 0;
352
 
      }
353
 
      fclose(pidfile);
354
 
    }
355
 
  }
356
 
  /* Try the old old pid file location */
357
 
  if(proc_id == 0){
358
 
    pidfile = fopen(plymouth_old_old_pid, "r");
 
284
    pidfile = fopen(plymouth_pid, "r");
359
285
    if(pidfile != NULL){
360
286
      ret = fscanf(pidfile, "%" SCNuMAX, &proc_id);
361
287
      if(ret != 1){
372
298
      error_plus(0, errno, "scandir");
373
299
    }
374
300
    if(ret > 0){
375
 
      for(int i = ret-1; i >= 0; i--){
376
 
        if(proc_id == 0){
377
 
          ret = sscanf(direntries[i]->d_name, "%" SCNuMAX, &proc_id);
378
 
          if(ret < 0){
379
 
            error_plus(0, errno, "sscanf");
380
 
          }
381
 
        }
382
 
        free(direntries[i]);
 
301
      ret = sscanf(direntries[0]->d_name, "%" SCNuMAX, &proc_id);
 
302
      if(ret < 0){
 
303
        error_plus(0, errno, "sscanf");
383
304
      }
384
305
    }
385
306
    /* scandir might preallocate for this variable (man page unclear).
395
316
  return 0;
396
317
}
397
318
 
398
 
char **getargv(pid_t pid){
 
319
const char * const * getargv(pid_t pid){
399
320
  int cl_fd;
400
321
  char *cmdline_filename;
401
322
  ssize_t sret;
462
383
    return NULL;
463
384
  }
464
385
  argz_extract(cmdline, cmdline_len, argv); /* Create argv */
465
 
  return argv;
 
386
  return (const char * const *)argv;
466
387
}
467
388
 
468
389
int main(__attribute__((unused))int argc,
469
390
         __attribute__((unused))char **argv){
470
 
  char *prompt = NULL;
 
391
  char *prompt;
471
392
  char *prompt_arg;
472
393
  pid_t plymouth_command_pid;
473
394
  int ret;
474
395
  bool bret;
475
396
 
476
 
  {
477
 
    struct argp_option options[] = {
478
 
      { .name = "prompt", .key = 128, .arg = "PROMPT",
479
 
        .doc = "The prompt to show" },
480
 
      { .name = "debug", .key = 129,
481
 
        .doc = "Debug mode" },
482
 
      { .name = NULL }
483
 
    };
484
 
    
485
 
    __attribute__((nonnull(3)))
486
 
    error_t parse_opt (int key, char *arg, __attribute__((unused))
487
 
                       struct argp_state *state){
488
 
      errno = 0;
489
 
      switch (key){
490
 
      case 128:                 /* --prompt */
491
 
        prompt = arg;
492
 
        if(debug){
493
 
          fprintf_plus(stderr, "Custom prompt \"%s\"\n", prompt);
494
 
        }
495
 
        break;
496
 
      case 129:                 /* --debug */
497
 
        debug = true;
498
 
        break;
499
 
      default:
500
 
        return ARGP_ERR_UNKNOWN;
501
 
      }
502
 
      return errno;
503
 
    }
504
 
    
505
 
    struct argp argp = { .options = options, .parser = parse_opt,
506
 
                         .args_doc = "",
507
 
                         .doc = "Mandos plymouth -- Read and"
508
 
                         " output a password" };
509
 
    ret = argp_parse(&argp, argc, argv, ARGP_IN_ORDER, NULL, NULL);
510
 
    switch(ret){
511
 
    case 0:
512
 
      break;
513
 
    case ENOMEM:
514
 
    default:
515
 
      errno = ret;
516
 
      error_plus(0, errno, "argp_parse");
517
 
      return EX_OSERR;
518
 
    case EINVAL:
519
 
      error_plus(0, errno, "argp_parse");
520
 
      return EX_USAGE;
521
 
    }
522
 
  }
523
 
  
524
397
  /* test -x /bin/plymouth */
525
398
  ret = access(plymouth_path, X_OK);
526
399
  if(ret == -1){
527
400
    /* Plymouth is probably not installed.  Don't print an error
528
401
       message, just exit. */
529
 
    if(debug){
530
 
      fprintf_plus(stderr, "Plymouth (%s) not found\n",
531
 
                   plymouth_path);
532
 
    }
533
402
    exit(EX_UNAVAILABLE);
534
403
  }
535
404
  
569
438
    }
570
439
    /* Plymouth is probably not running.  Don't print an error
571
440
       message, just exit. */
572
 
    if(debug){
573
 
      fprintf_plus(stderr, "Plymouth not running\n");
574
 
    }
575
441
    exit(EX_UNAVAILABLE);
576
442
  }
577
443
  
578
 
  if(prompt != NULL){
579
 
    ret = asprintf(&prompt_arg, "--prompt=%s", prompt);
580
 
  } else {
581
 
    char *made_prompt = makeprompt();
582
 
    ret = asprintf(&prompt_arg, "--prompt=%s", made_prompt);
583
 
    free(made_prompt);
584
 
  }
 
444
  prompt = makeprompt();
 
445
  ret = asprintf(&prompt_arg, "--prompt=%s", prompt);
 
446
  free(prompt);
585
447
  if(ret == -1){
586
448
    error_plus(EX_OSERR, errno, "asprintf");
587
449
  }
588
450
  
589
451
  /* plymouth ask-for-password --prompt="$prompt" */
590
 
  if(debug){
591
 
    fprintf_plus(stderr, "Prompting for password via Plymouth\n");
592
 
  }
593
452
  bret = exec_and_wait(&plymouth_command_pid,
594
453
                       plymouth_path, (const char *[])
595
454
                       { plymouth_path, "ask-for-password",
605
464
  }
606
465
  kill_and_wait(plymouth_command_pid);
607
466
  
608
 
  char **plymouthd_argv = NULL;
 
467
  const char * const *plymouthd_argv;
609
468
  pid_t pid = get_pid();
610
469
  if(pid == 0){
611
470
    error_plus(0, 0, "plymouthd pid not found");
 
471
    plymouthd_argv = plymouthd_default_argv;
612
472
  } else {
613
473
    plymouthd_argv = getargv(pid);
614
474
  }
617
477
                       { plymouth_path, "quit", NULL },
618
478
                       false, false);
619
479
  if(not bret){
620
 
    if(plymouthd_argv != NULL){
621
 
      free(*plymouthd_argv);
622
 
      free(plymouthd_argv);
623
 
    }
624
480
    exit(EXIT_FAILURE);
625
481
  }
626
 
  bret = exec_and_wait(NULL, plymouthd_path,
627
 
                       (plymouthd_argv != NULL)
628
 
                       ? (const char * const *)plymouthd_argv
629
 
                       : plymouthd_default_argv,
 
482
  bret = exec_and_wait(NULL, plymouthd_path, plymouthd_argv,
630
483
                       false, true);
631
 
  if(plymouthd_argv != NULL){
632
 
    free(*plymouthd_argv);
633
 
    free(plymouthd_argv);
634
 
  }
635
484
  if(not bret){
636
485
    exit(EXIT_FAILURE);
637
486
  }