/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: 2015-03-10 18:03:38 UTC
  • mto: (237.7.304 trunk)
  • mto: This revision was merged to the branch mainline in revision 325.
  • Revision ID: teddy@recompile.se-20150310180338-pcxw6r2qmw9k6br9
Add ":!RSA" to GnuTLS priority string, to disallow non-DHE kx.

If Mandos was somehow made to use a non-ephemeral Diffie-Hellman key
exchange algorithm in the TLS handshake, any saved network traffic
could then be decrypted later if the Mandos client key was obtained.
By default, Mandos uses ephemeral DH key exchanges which does not have
this problem, but a non-ephemeral key exchange algorithm was still
enabled by default.  The simplest solution is to simply turn that off,
which ensures that Mandos will always use ephemeral DH key exchanges.

There is a "PFS" priority string specifier, but we can't use it because:

1. Security-wise, it is a mix between "NORMAL" and "SECURE128" - it
   enables a lot more algorithms than "SECURE256".

2. It is only available since GnuTLS 3.2.4.

Thanks to Andreas Fischer <af@bantuX.org> for reporting this issue.

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-2019 Teddy Hogeborn
6
 
 * Copyright © 2010-2019 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-2014 Teddy Hogeborn
 
6
 * Copyright © 2010-2014 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
 */
53
52
#include <errno.h>              /* TEMP_FAILURE_RETRY */
54
53
#include <argz.h>               /* argz_count(), argz_extract() */
55
54
#include <stdarg.h>             /* va_list, va_start(), ... */
56
 
#include <argp.h>
57
55
 
58
56
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>";
61
57
 
62
58
/* Used by Ubuntu 11.04 (Natty Narwahl) */
63
 
const char plymouth_old_old_pid[] = "/dev/.initramfs/plymouth.pid";
 
59
const char plymouth_old_pid[] = "/dev/.initramfs/plymouth.pid";
64
60
/* Used by Ubuntu 11.10 (Oneiric Ocelot) */
65
 
const char plymouth_old_pid[] = "/run/initramfs/plymouth.pid";
66
 
/* Used by Debian 9 (stretch) */
67
 
const char plymouth_pid[] = "/run/plymouth/pid";
 
61
const char plymouth_pid[] = "/run/initramfs/plymouth.pid";
68
62
 
69
63
const char plymouth_path[] = "/bin/plymouth";
70
64
const char plymouthd_path[] = "/sbin/plymouthd";
72
66
                                        "--mode=boot",
73
67
                                        "--attach-to-session",
74
68
                                        NULL };
75
 
bool debug = false;
76
69
 
77
70
static void termination_handler(__attribute__((unused))int signum){
78
71
  if(interrupted_by_signal){
81
74
  interrupted_by_signal = 1;
82
75
}
83
76
 
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
 
 
92
77
/* Function to use when printing errors */
93
78
__attribute__((format (gnu_printf, 3, 4)))
94
79
void error_plus(int status, int errnum, const char *formatstring,
171
156
 
172
157
__attribute__((nonnull (2, 3)))
173
158
bool exec_and_wait(pid_t *pid_return, const char *path,
174
 
                   const char * const * const argv, bool interruptable,
 
159
                   const char * const *argv, bool interruptable,
175
160
                   bool daemonize){
176
161
  int status;
177
162
  int ret;
178
163
  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
 
 
186
164
  pid = fork();
187
165
  if(pid == -1){
188
166
    error_plus(0, errno, "fork");
196
174
      }
197
175
    }
198
176
    
199
 
    char **new_argv = malloc(sizeof(const char *));
200
 
    if(new_argv == NULL){
201
 
      error_plus(0, errno, "malloc");
202
 
      _exit(EX_OSERR);
203
 
    }
 
177
    char **new_argv = NULL;
204
178
    char **tmp;
205
179
    int i = 0;
206
 
    for (; argv[i] != NULL; i++){
207
 
      tmp = realloc(new_argv, sizeof(const char *) * ((size_t)i + 2));
 
180
    for (; argv[i]!=NULL; i++){
 
181
      tmp = realloc(new_argv, sizeof(const char *) * ((size_t)i + 1));
208
182
      if(tmp == NULL){
209
183
        error_plus(0, errno, "realloc");
210
184
        free(new_argv);
228
202
          and ((not interrupted_by_signal)
229
203
               or (not interruptable)));
230
204
  if(interrupted_by_signal and interruptable){
231
 
    if(debug){
232
 
      fprintf_plus(stderr, "Interrupted by signal\n");
233
 
    }
234
205
    return false;
235
206
  }
236
207
  if(ret == -1){
237
208
    error_plus(0, errno, "waitpid");
238
209
    return false;
239
210
  }
240
 
  if(debug){
241
 
    if(WIFEXITED(status)){
242
 
      fprintf_plus(stderr, "exec_and_wait exited: %d\n",
243
 
                   WEXITSTATUS(status));
244
 
    } else if(WIFSIGNALED(status)) {
245
 
      fprintf_plus(stderr, "exec_and_wait signaled: %d\n",
246
 
                   WTERMSIG(status));
247
 
    }
248
 
  }
249
211
  if(WIFEXITED(status) and (WEXITSTATUS(status) == 0)){
250
212
    return true;
251
213
  }
315
277
  }
316
278
  /* Try the old pid file location */
317
279
  if(proc_id == 0){
318
 
    pidfile = fopen(plymouth_old_pid, "r");
319
 
    if(pidfile != NULL){
320
 
      ret = fscanf(pidfile, "%" SCNuMAX, &proc_id);
321
 
      if(ret != 1){
322
 
        proc_id = 0;
323
 
      }
324
 
      fclose(pidfile);
325
 
    }
326
 
  }
327
 
  /* Try the old old pid file location */
328
 
  if(proc_id == 0){
329
 
    pidfile = fopen(plymouth_old_old_pid, "r");
 
280
    pidfile = fopen(plymouth_pid, "r");
330
281
    if(pidfile != NULL){
331
282
      ret = fscanf(pidfile, "%" SCNuMAX, &proc_id);
332
283
      if(ret != 1){
343
294
      error_plus(0, errno, "scandir");
344
295
    }
345
296
    if(ret > 0){
346
 
      for(int i = ret-1; i >= 0; i--){
347
 
        if(proc_id == 0){
348
 
          ret = sscanf(direntries[i]->d_name, "%" SCNuMAX, &proc_id);
349
 
          if(ret < 0){
350
 
            error_plus(0, errno, "sscanf");
351
 
          }
352
 
        }
353
 
        free(direntries[i]);
 
297
      ret = sscanf(direntries[0]->d_name, "%" SCNuMAX, &proc_id);
 
298
      if(ret < 0){
 
299
        error_plus(0, errno, "sscanf");
354
300
      }
355
301
    }
356
302
    /* scandir might preallocate for this variable (man page unclear).
366
312
  return 0;
367
313
}
368
314
 
369
 
char **getargv(pid_t pid){
 
315
const char * const * getargv(pid_t pid){
370
316
  int cl_fd;
371
317
  char *cmdline_filename;
372
318
  ssize_t sret;
433
379
    return NULL;
434
380
  }
435
381
  argz_extract(cmdline, cmdline_len, argv); /* Create argv */
436
 
  return argv;
 
382
  return (const char * const *)argv;
437
383
}
438
384
 
439
385
int main(__attribute__((unused))int argc,
440
386
         __attribute__((unused))char **argv){
441
 
  char *prompt = NULL;
 
387
  char *prompt;
442
388
  char *prompt_arg;
443
389
  pid_t plymouth_command_pid;
444
390
  int ret;
445
391
  bool bret;
446
392
 
447
 
  {
448
 
    struct argp_option options[] = {
449
 
      { .name = "prompt", .key = 128, .arg = "PROMPT",
450
 
        .doc = "The prompt to show" },
451
 
      { .name = "debug", .key = 129,
452
 
        .doc = "Debug mode" },
453
 
      { .name = NULL }
454
 
    };
455
 
    
456
 
    __attribute__((nonnull(3)))
457
 
    error_t parse_opt (int key, char *arg, __attribute__((unused))
458
 
                       struct argp_state *state){
459
 
      errno = 0;
460
 
      switch (key){
461
 
      case 128:                 /* --prompt */
462
 
        prompt = arg;
463
 
        if(debug){
464
 
          fprintf_plus(stderr, "Custom prompt \"%s\"\n", prompt);
465
 
        }
466
 
        break;
467
 
      case 129:                 /* --debug */
468
 
        debug = true;
469
 
        break;
470
 
      default:
471
 
        return ARGP_ERR_UNKNOWN;
472
 
      }
473
 
      return errno;
474
 
    }
475
 
    
476
 
    struct argp argp = { .options = options, .parser = parse_opt,
477
 
                         .args_doc = "",
478
 
                         .doc = "Mandos plymouth -- Read and"
479
 
                         " output a password" };
480
 
    ret = argp_parse(&argp, argc, argv, ARGP_IN_ORDER, NULL, NULL);
481
 
    switch(ret){
482
 
    case 0:
483
 
      break;
484
 
    case ENOMEM:
485
 
    default:
486
 
      errno = ret;
487
 
      error_plus(0, errno, "argp_parse");
488
 
      return EX_OSERR;
489
 
    case EINVAL:
490
 
      error_plus(0, errno, "argp_parse");
491
 
      return EX_USAGE;
492
 
    }
493
 
  }
494
 
  
495
393
  /* test -x /bin/plymouth */
496
394
  ret = access(plymouth_path, X_OK);
497
395
  if(ret == -1){
498
396
    /* Plymouth is probably not installed.  Don't print an error
499
397
       message, just exit. */
500
 
    if(debug){
501
 
      fprintf_plus(stderr, "Plymouth (%s) not found\n",
502
 
                   plymouth_path);
503
 
    }
504
398
    exit(EX_UNAVAILABLE);
505
399
  }
506
400
  
540
434
    }
541
435
    /* Plymouth is probably not running.  Don't print an error
542
436
       message, just exit. */
543
 
    if(debug){
544
 
      fprintf_plus(stderr, "Plymouth not running\n");
545
 
    }
546
437
    exit(EX_UNAVAILABLE);
547
438
  }
548
439
  
549
 
  if(prompt != NULL){
550
 
    ret = asprintf(&prompt_arg, "--prompt=%s", prompt);
551
 
  } else {
552
 
    char *made_prompt = makeprompt();
553
 
    ret = asprintf(&prompt_arg, "--prompt=%s", made_prompt);
554
 
    free(made_prompt);
555
 
  }
 
440
  prompt = makeprompt();
 
441
  ret = asprintf(&prompt_arg, "--prompt=%s", prompt);
 
442
  free(prompt);
556
443
  if(ret == -1){
557
444
    error_plus(EX_OSERR, errno, "asprintf");
558
445
  }
559
446
  
560
447
  /* plymouth ask-for-password --prompt="$prompt" */
561
 
  if(debug){
562
 
    fprintf_plus(stderr, "Prompting for password via Plymouth\n");
563
 
  }
564
448
  bret = exec_and_wait(&plymouth_command_pid,
565
449
                       plymouth_path, (const char *[])
566
450
                       { plymouth_path, "ask-for-password",
576
460
  }
577
461
  kill_and_wait(plymouth_command_pid);
578
462
  
579
 
  char **plymouthd_argv = NULL;
 
463
  const char * const *plymouthd_argv;
580
464
  pid_t pid = get_pid();
581
465
  if(pid == 0){
582
466
    error_plus(0, 0, "plymouthd pid not found");
 
467
    plymouthd_argv = plymouthd_default_argv;
583
468
  } else {
584
469
    plymouthd_argv = getargv(pid);
585
470
  }
588
473
                       { plymouth_path, "quit", NULL },
589
474
                       false, false);
590
475
  if(not bret){
591
 
    if(plymouthd_argv != NULL){
592
 
      free(*plymouthd_argv);
593
 
      free(plymouthd_argv);
594
 
    }
595
476
    exit(EXIT_FAILURE);
596
477
  }
597
 
  bret = exec_and_wait(NULL, plymouthd_path,
598
 
                       (plymouthd_argv != NULL)
599
 
                       ? (const char * const *)plymouthd_argv
600
 
                       : plymouthd_default_argv,
 
478
  bret = exec_and_wait(NULL, plymouthd_path, plymouthd_argv,
601
479
                       false, true);
602
 
  if(plymouthd_argv != NULL){
603
 
    free(*plymouthd_argv);
604
 
    free(plymouthd_argv);
605
 
  }
606
480
  if(not bret){
607
481
    exit(EXIT_FAILURE);
608
482
  }