/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/password-prompt.c

  • Committer: Teddy Hogeborn
  • Date: 2019-02-10 03:50:20 UTC
  • Revision ID: teddy@recompile.se-20190210035020-nttr1tybgwwixueu
http://bugs.debian.org/879538
http://bugs.debian.org/916673
Show debconf note about new TLS key IDs

If mandos-client did not see TLS keys and had to create them, or if
mandos sees GnuTLS version 3.6.6 or later, show an important notice on
package installation about the importance of adding the new key_id
options to clients.conf on the Mandos server.

* debian/control (Package: mandos, Package: mandos-client): Depend on
                                                            debconf.
* debian/mandos-client.lintian-overrides: Override warnings.
* debian/mandos-client.postinst (create_keys): Show notice if new TLS
                                               key files were created.
* debian/mandos-client.templates: New.
* debian/mandos.lintian-overrides: Override warnings.
* debian/mandos.postinst (configure): If GnuTLS 3.6.6 or later is
                                      detected, show an important
                                      notice (once) about the new
                                      key_id option required in
                                      clients.conf.
* debian/mandos.templates: New.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/password-prompt.c
2
2
/*
3
3
 * Password-prompt - Read a password from the terminal and print it
4
4
 * 
5
 
 * Copyright © 2008-2010 Teddy Hogeborn
6
 
 * Copyright © 2008-2010 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 © 2008-2018 Teddy Hogeborn
 
6
 * Copyright © 2008-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             /* getline(), asprintf() */
26
27
 
27
 
#include <termios.h>            /* struct termios, tcsetattr(),
 
28
#include <termios.h>            /* struct termios, tcsetattr(),
28
29
                                   TCSAFLUSH, tcgetattr(), ECHO */
29
30
#include <unistd.h>             /* struct termios, tcsetattr(),
30
31
                                   STDIN_FILENO, TCSAFLUSH,
41
42
                                   getenv(), free() */
42
43
#include <dirent.h>             /* scandir(), alphasort() */
43
44
#include <stdio.h>              /* fprintf(), stderr, getline(),
44
 
                                   stdin, feof(), fputc()
45
 
                                */
 
45
                                   stdin, feof(), fputc(), vfprintf(),
 
46
                                   vasprintf() */
46
47
#include <errno.h>              /* errno, EBADF, ENOTTY, EINVAL,
47
48
                                   EFAULT, EFBIG, EIO, ENOSPC, EINTR
48
49
                                */
50
51
#include <iso646.h>             /* or, not */
51
52
#include <stdbool.h>            /* bool, false, true */
52
53
#include <inttypes.h>           /* strtoumax() */
53
 
#include <sys/stat.h>           /* struct stat, lstat(), open() */
54
 
#include <string.h>             /* strlen, rindex, memcmp */
 
54
#include <sys/stat.h>           /* struct stat, lstat(), open() */
 
55
#include <string.h>             /* strlen, rindex, memcmp, strerror()
 
56
                                 */
55
57
#include <argp.h>               /* struct argp_option, struct
56
58
                                   argp_state, struct argp,
57
59
                                   argp_parse(), error_t,
60
62
#include <sysexits.h>           /* EX_SOFTWARE, EX_OSERR,
61
63
                                   EX_UNAVAILABLE, EX_IOERR, EX_OK */
62
64
#include <fcntl.h>              /* open() */
 
65
#include <stdarg.h>             /* va_list, va_start(), ... */
63
66
 
64
67
volatile sig_atomic_t quit_now = 0;
65
68
int signal_received;
66
69
bool debug = false;
67
70
const char *argp_program_version = "password-prompt " VERSION;
68
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
69
 
 
70
 
/* Needed for conflic resolution */
71
 
const char plymouthd_name[] = "plymouthd";
72
 
 
 
71
const char *argp_program_bug_address = "<mandos@recompile.se>";
 
72
 
 
73
/* Needed for conflict resolution */
 
74
const char plymouth_name[] = "plymouthd";
 
75
 
 
76
/* Function to use when printing errors */
 
77
__attribute__((format (gnu_printf, 3, 4)))
 
78
void error_plus(int status, int errnum, const char *formatstring,
 
79
                ...){
 
80
  va_list ap;
 
81
  char *text;
 
82
  int ret;
 
83
  
 
84
  va_start(ap, formatstring);
 
85
  ret = vasprintf(&text, formatstring, ap);
 
86
  if(ret == -1){
 
87
    fprintf(stderr, "Mandos plugin %s: ",
 
88
            program_invocation_short_name);
 
89
    vfprintf(stderr, formatstring, ap);
 
90
    fprintf(stderr, ": %s\n", strerror(errnum));
 
91
    error(status, errno, "vasprintf while printing error");
 
92
    return;
 
93
  }
 
94
  fprintf(stderr, "Mandos plugin ");
 
95
  error(status, errnum, "%s", text);
 
96
  free(text);
 
97
}
73
98
 
74
99
static void termination_handler(int signum){
75
100
  if(quit_now){
85
110
     from the terminal.  Password-prompt will exit if it detects
86
111
     plymouth since plymouth performs the same functionality.
87
112
   */
 
113
  __attribute__((nonnull))
88
114
  int is_plymouth(const struct dirent *proc_entry){
89
115
    int ret;
90
116
    int cl_fd;
91
117
    {
92
 
      uintmax_t maxvalue;
 
118
      uintmax_t proc_id;
93
119
      char *tmp;
94
120
      errno = 0;
95
 
      maxvalue = strtoumax(proc_entry->d_name, &tmp, 10);
 
121
      proc_id = strtoumax(proc_entry->d_name, &tmp, 10);
96
122
      
97
123
      if(errno != 0 or *tmp != '\0'
98
 
         or maxvalue != (uintmax_t)((pid_t)maxvalue)){
 
124
         or proc_id != (uintmax_t)((pid_t)proc_id)){
99
125
        return 0;
100
126
      }
101
127
    }
102
128
    
103
129
    char *cmdline_filename;
104
 
    ret = asprintf(&cmdline_filename, "/proc/%s/cmdline", proc_entry->d_name);
 
130
    ret = asprintf(&cmdline_filename, "/proc/%s/cmdline",
 
131
                   proc_entry->d_name);
105
132
    if(ret == -1){
106
 
      error(0, errno, "asprintf");
 
133
      error_plus(0, errno, "asprintf");
107
134
      return 0;
108
135
    }
109
136
    
110
 
    /* Open /proc/<pid>/cmdline  */
 
137
    /* Open /proc/<pid>/cmdline */
111
138
    cl_fd = open(cmdline_filename, O_RDONLY);
112
139
    free(cmdline_filename);
113
140
    if(cl_fd == -1){
114
 
      error(0, errno, "open");
 
141
      if(errno != ENOENT){
 
142
        error_plus(0, errno, "open");
 
143
      }
115
144
      return 0;
116
145
    }
117
146
    
127
156
        if(cmdline_len + blocksize + 1 > cmdline_allocated){
128
157
          tmp = realloc(cmdline, cmdline_allocated + blocksize + 1);
129
158
          if(tmp == NULL){
130
 
            error(0, errno, "realloc");
 
159
            error_plus(0, errno, "realloc");
131
160
            free(cmdline);
132
161
            close(cl_fd);
133
162
            return 0;
140
169
        sret = read(cl_fd, cmdline + cmdline_len,
141
170
                    cmdline_allocated - cmdline_len);
142
171
        if(sret == -1){
143
 
          error(0, errno, "read");
 
172
          error_plus(0, errno, "read");
144
173
          free(cmdline);
145
174
          close(cl_fd);
146
175
          return 0;
149
178
      } while(sret != 0);
150
179
      ret = close(cl_fd);
151
180
      if(ret == -1){
152
 
        error(0, errno, "close");
 
181
        error_plus(0, errno, "close");
153
182
        free(cmdline);
154
183
        return 0;
155
184
      }
165
194
      cmdline_base = cmdline;
166
195
    }
167
196
    
168
 
    if(strcmp(cmdline_base, plymouthd_name) != 0){
 
197
    if(strcmp(cmdline_base, plymouth_name) != 0){
 
198
      if(debug){
 
199
        fprintf(stderr, "\"%s\" is not \"%s\"\n", cmdline_base,
 
200
                plymouth_name);
 
201
      }
169
202
      free(cmdline);
170
203
      return 0;
171
204
    }
 
205
    if(debug){
 
206
      fprintf(stderr, "\"%s\" equals \"%s\"\n", cmdline_base,
 
207
              plymouth_name);
 
208
    }
172
209
    free(cmdline);
173
210
    return 1;
174
211
  }
175
 
 
176
 
  struct dirent **direntries;
 
212
  
 
213
  struct dirent **direntries = NULL;
177
214
  int ret;
178
215
  ret = scandir("/proc", &direntries, is_plymouth, alphasort);
179
 
  if (ret == -1){
180
 
    error(1, errno, "scandir");
181
 
  }
 
216
  if(ret == -1){
 
217
    error_plus(1, errno, "scandir");
 
218
  }
 
219
  {
 
220
    int i = ret;
 
221
    while(i--){
 
222
      free(direntries[i]);
 
223
    }
 
224
  }
 
225
  free(direntries);
182
226
  return ret > 0;
183
227
}
184
228
 
213
257
      { .name = NULL }
214
258
    };
215
259
    
 
260
    __attribute__((nonnull(3)))
216
261
    error_t parse_opt (int key, char *arg, struct argp_state *state){
217
262
      errno = 0;
218
263
      switch (key){
254
299
    case ENOMEM:
255
300
    default:
256
301
      errno = ret;
257
 
      error(0, errno, "argp_parse");
 
302
      error_plus(0, errno, "argp_parse");
258
303
      return EX_OSERR;
259
304
    case EINVAL:
260
305
      return EX_USAGE;
265
310
    fprintf(stderr, "Starting %s\n", argv[0]);
266
311
  }
267
312
 
268
 
  if (conflict_detection()){
 
313
  if(conflict_detection()){
269
314
    if(debug){
270
 
      fprintf(stderr, "Stopping %s because of conflict", argv[0]);
 
315
      fprintf(stderr, "Stopping %s because of conflict\n", argv[0]);
271
316
    }
272
317
    return EXIT_FAILURE;
273
318
  }
278
323
  
279
324
  if(tcgetattr(STDIN_FILENO, &t_old) != 0){
280
325
    int e = errno;
281
 
    error(0, errno, "tcgetattr");
 
326
    error_plus(0, errno, "tcgetattr");
282
327
    switch(e){
283
328
    case EBADF:
284
329
    case ENOTTY:
291
336
  sigemptyset(&new_action.sa_mask);
292
337
  ret = sigaddset(&new_action.sa_mask, SIGINT);
293
338
  if(ret == -1){
294
 
    error(0, errno, "sigaddset");
 
339
    error_plus(0, errno, "sigaddset");
295
340
    return EX_OSERR;
296
341
  }
297
342
  ret = sigaddset(&new_action.sa_mask, SIGHUP);
298
343
  if(ret == -1){
299
 
    error(0, errno, "sigaddset");
 
344
    error_plus(0, errno, "sigaddset");
300
345
    return EX_OSERR;
301
346
  }
302
347
  ret = sigaddset(&new_action.sa_mask, SIGTERM);
303
348
  if(ret == -1){
304
 
    error(0, errno, "sigaddset");
 
349
    error_plus(0, errno, "sigaddset");
305
350
    return EX_OSERR;
306
351
  }
307
352
  /* Need to check if the handler is SIG_IGN before handling:
310
355
  */
311
356
  ret = sigaction(SIGINT, NULL, &old_action);
312
357
  if(ret == -1){
313
 
    error(0, errno, "sigaction");
 
358
    error_plus(0, errno, "sigaction");
314
359
    return EX_OSERR;
315
360
  }
316
361
  if(old_action.sa_handler != SIG_IGN){
317
362
    ret = sigaction(SIGINT, &new_action, NULL);
318
363
    if(ret == -1){
319
 
      error(0, errno, "sigaction");
 
364
      error_plus(0, errno, "sigaction");
320
365
      return EX_OSERR;
321
366
    }
322
367
  }
323
368
  ret = sigaction(SIGHUP, NULL, &old_action);
324
369
  if(ret == -1){
325
 
    error(0, errno, "sigaction");
 
370
    error_plus(0, errno, "sigaction");
326
371
    return EX_OSERR;
327
372
  }
328
373
  if(old_action.sa_handler != SIG_IGN){
329
374
    ret = sigaction(SIGHUP, &new_action, NULL);
330
375
    if(ret == -1){
331
 
      error(0, errno, "sigaction");
 
376
      error_plus(0, errno, "sigaction");
332
377
      return EX_OSERR;
333
378
    }
334
379
  }
335
380
  ret = sigaction(SIGTERM, NULL, &old_action);
336
381
  if(ret == -1){
337
 
    error(0, errno, "sigaction");
 
382
    error_plus(0, errno, "sigaction");
338
383
    return EX_OSERR;
339
384
  }
340
385
  if(old_action.sa_handler != SIG_IGN){
341
386
    ret = sigaction(SIGTERM, &new_action, NULL);
342
387
    if(ret == -1){
343
 
      error(0, errno, "sigaction");
 
388
      error_plus(0, errno, "sigaction");
344
389
      return EX_OSERR;
345
390
    }
346
391
  }
354
399
  t_new.c_lflag &= ~(tcflag_t)ECHO;
355
400
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_new) != 0){
356
401
    int e = errno;
357
 
    error(0, errno, "tcsetattr-echo");
 
402
    error_plus(0, errno, "tcsetattr-echo");
358
403
    switch(e){
359
404
    case EBADF:
360
405
    case ENOTTY:
424
469
        sret = write(STDOUT_FILENO, buffer + written, n - written);
425
470
        if(sret < 0){
426
471
          int e = errno;
427
 
          error(0, errno, "write");
 
472
          error_plus(0, errno, "write");
428
473
          switch(e){
429
474
          case EBADF:
430
475
          case EFAULT:
446
491
      sret = close(STDOUT_FILENO);
447
492
      if(sret == -1){
448
493
        int e = errno;
449
 
        error(0, errno, "close");
 
494
        error_plus(0, errno, "close");
450
495
        switch(e){
451
496
        case EBADF:
452
497
          status = EX_OSFILE;
462
507
    if(sret < 0){
463
508
      int e = errno;
464
509
      if(errno != EINTR and not feof(stdin)){
465
 
        error(0, errno, "getline");
 
510
        error_plus(0, errno, "getline");
466
511
        switch(e){
467
512
        case EBADF:
468
513
          status = EX_UNAVAILABLE;
 
514
          break;
469
515
        case EIO:
470
516
        case EINVAL:
471
517
        default:
475
521
        break;
476
522
      }
477
523
    }
478
 
    /* if(sret == 0), then the only sensible thing to do is to retry to
479
 
       read from stdin */
 
524
    /* if(sret == 0), then the only sensible thing to do is to retry
 
525
       to read from stdin */
480
526
    fputc('\n', stderr);
481
527
    if(debug and not quit_now){
482
528
      /* If quit_now is nonzero, we were interrupted by a signal, and
491
537
    fprintf(stderr, "Restoring terminal attributes\n");
492
538
  }
493
539
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_old) != 0){
494
 
    error(0, errno, "tcsetattr+echo");
 
540
    error_plus(0, errno, "tcsetattr+echo");
495
541
  }
496
542
  
497
543
  if(quit_now){
499
545
    old_action.sa_handler = SIG_DFL;
500
546
    ret = sigaction(signal_received, &old_action, NULL);
501
547
    if(ret == -1){
502
 
      error(0, errno, "sigaction");
 
548
      error_plus(0, errno, "sigaction");
503
549
    }
504
550
    raise(signal_received);
505
551
  }