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

  • Committer: Teddy Hogeborn
  • Date: 2019-02-10 03:50:20 UTC
  • mto: (237.7.594 trunk)
  • mto: This revision was merged to the branch mainline in revision 370.
  • 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
 
#define _GNU_SOURCE             /* getline() */
 
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,
31
 
                                   tcgetattr(), ECHO */
 
32
                                   tcgetattr(), ECHO, readlink() */
32
33
#include <signal.h>             /* sig_atomic_t, raise(), struct
33
34
                                   sigaction, sigemptyset(),
34
35
                                   sigaction(), sigaddset(), SIGINT,
35
36
                                   SIGQUIT, SIGHUP, SIGTERM,
36
37
                                   raise() */
37
38
#include <stddef.h>             /* NULL, size_t, ssize_t */
38
 
#include <sys/types.h>          /* ssize_t */
 
39
#include <sys/types.h>          /* ssize_t, struct dirent, pid_t,
 
40
                                   ssize_t, open() */
39
41
#include <stdlib.h>             /* EXIT_SUCCESS, EXIT_FAILURE,
40
 
                                   getenv() */
 
42
                                   getenv(), free() */
 
43
#include <dirent.h>             /* scandir(), alphasort() */
41
44
#include <stdio.h>              /* fprintf(), stderr, getline(),
42
 
                                   stdin, feof(), fputc()
43
 
                                */
 
45
                                   stdin, feof(), fputc(), vfprintf(),
 
46
                                   vasprintf() */
44
47
#include <errno.h>              /* errno, EBADF, ENOTTY, EINVAL,
45
48
                                   EFAULT, EFBIG, EIO, ENOSPC, EINTR
46
49
                                */
47
50
#include <error.h>              /* error() */
48
51
#include <iso646.h>             /* or, not */
49
52
#include <stdbool.h>            /* bool, false, true */
50
 
#include <string.h>             /* strlen, rindex */
 
53
#include <inttypes.h>           /* strtoumax() */
 
54
#include <sys/stat.h>           /* struct stat, lstat(), open() */
 
55
#include <string.h>             /* strlen, rindex, memcmp, strerror()
 
56
                                 */
51
57
#include <argp.h>               /* struct argp_option, struct
52
58
                                   argp_state, struct argp,
53
59
                                   argp_parse(), error_t,
55
61
                                   ARGP_ERR_UNKNOWN */
56
62
#include <sysexits.h>           /* EX_SOFTWARE, EX_OSERR,
57
63
                                   EX_UNAVAILABLE, EX_IOERR, EX_OK */
 
64
#include <fcntl.h>              /* open() */
 
65
#include <stdarg.h>             /* va_list, va_start(), ... */
58
66
 
59
67
volatile sig_atomic_t quit_now = 0;
60
68
int signal_received;
61
69
bool debug = false;
62
70
const char *argp_program_version = "password-prompt " VERSION;
63
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
 
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
}
64
98
 
65
99
static void termination_handler(int signum){
66
100
  if(quit_now){
70
104
  signal_received = signum;
71
105
}
72
106
 
 
107
bool conflict_detection(void){
 
108
 
 
109
  /* plymouth conflicts with password-prompt since both want to read
 
110
     from the terminal.  Password-prompt will exit if it detects
 
111
     plymouth since plymouth performs the same functionality.
 
112
   */
 
113
  __attribute__((nonnull))
 
114
  int is_plymouth(const struct dirent *proc_entry){
 
115
    int ret;
 
116
    int cl_fd;
 
117
    {
 
118
      uintmax_t proc_id;
 
119
      char *tmp;
 
120
      errno = 0;
 
121
      proc_id = strtoumax(proc_entry->d_name, &tmp, 10);
 
122
      
 
123
      if(errno != 0 or *tmp != '\0'
 
124
         or proc_id != (uintmax_t)((pid_t)proc_id)){
 
125
        return 0;
 
126
      }
 
127
    }
 
128
    
 
129
    char *cmdline_filename;
 
130
    ret = asprintf(&cmdline_filename, "/proc/%s/cmdline",
 
131
                   proc_entry->d_name);
 
132
    if(ret == -1){
 
133
      error_plus(0, errno, "asprintf");
 
134
      return 0;
 
135
    }
 
136
    
 
137
    /* Open /proc/<pid>/cmdline */
 
138
    cl_fd = open(cmdline_filename, O_RDONLY);
 
139
    free(cmdline_filename);
 
140
    if(cl_fd == -1){
 
141
      if(errno != ENOENT){
 
142
        error_plus(0, errno, "open");
 
143
      }
 
144
      return 0;
 
145
    }
 
146
    
 
147
    char *cmdline = NULL;
 
148
    {
 
149
      size_t cmdline_len = 0;
 
150
      size_t cmdline_allocated = 0;
 
151
      char *tmp;
 
152
      const size_t blocksize = 1024;
 
153
      ssize_t sret;
 
154
      do {
 
155
        /* Allocate more space? */
 
156
        if(cmdline_len + blocksize + 1 > cmdline_allocated){
 
157
          tmp = realloc(cmdline, cmdline_allocated + blocksize + 1);
 
158
          if(tmp == NULL){
 
159
            error_plus(0, errno, "realloc");
 
160
            free(cmdline);
 
161
            close(cl_fd);
 
162
            return 0;
 
163
          }
 
164
          cmdline = tmp;
 
165
          cmdline_allocated += blocksize;
 
166
        }
 
167
        
 
168
        /* Read data */
 
169
        sret = read(cl_fd, cmdline + cmdline_len,
 
170
                    cmdline_allocated - cmdline_len);
 
171
        if(sret == -1){
 
172
          error_plus(0, errno, "read");
 
173
          free(cmdline);
 
174
          close(cl_fd);
 
175
          return 0;
 
176
        }
 
177
        cmdline_len += (size_t)sret;
 
178
      } while(sret != 0);
 
179
      ret = close(cl_fd);
 
180
      if(ret == -1){
 
181
        error_plus(0, errno, "close");
 
182
        free(cmdline);
 
183
        return 0;
 
184
      }
 
185
      cmdline[cmdline_len] = '\0'; /* Make sure it is terminated */
 
186
    }
 
187
    /* we now have cmdline */
 
188
    
 
189
    /* get basename */
 
190
    char *cmdline_base = strrchr(cmdline, '/');
 
191
    if(cmdline_base != NULL){
 
192
      cmdline_base += 1;                /* skip the slash */
 
193
    } else {
 
194
      cmdline_base = cmdline;
 
195
    }
 
196
    
 
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
      }
 
202
      free(cmdline);
 
203
      return 0;
 
204
    }
 
205
    if(debug){
 
206
      fprintf(stderr, "\"%s\" equals \"%s\"\n", cmdline_base,
 
207
              plymouth_name);
 
208
    }
 
209
    free(cmdline);
 
210
    return 1;
 
211
  }
 
212
  
 
213
  struct dirent **direntries = NULL;
 
214
  int ret;
 
215
  ret = scandir("/proc", &direntries, is_plymouth, alphasort);
 
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);
 
226
  return ret > 0;
 
227
}
 
228
 
 
229
 
73
230
int main(int argc, char **argv){
74
231
  ssize_t sret;
75
232
  int ret;
100
257
      { .name = NULL }
101
258
    };
102
259
    
 
260
    __attribute__((nonnull(3)))
103
261
    error_t parse_opt (int key, char *arg, struct argp_state *state){
104
262
      errno = 0;
105
263
      switch (key){
141
299
    case ENOMEM:
142
300
    default:
143
301
      errno = ret;
144
 
      error(0, errno, "argp_parse");
 
302
      error_plus(0, errno, "argp_parse");
145
303
      return EX_OSERR;
146
304
    case EINVAL:
147
305
      return EX_USAGE;
151
309
  if(debug){
152
310
    fprintf(stderr, "Starting %s\n", argv[0]);
153
311
  }
 
312
 
 
313
  if(conflict_detection()){
 
314
    if(debug){
 
315
      fprintf(stderr, "Stopping %s because of conflict\n", argv[0]);
 
316
    }
 
317
    return EXIT_FAILURE;
 
318
  }
 
319
  
154
320
  if(debug){
155
321
    fprintf(stderr, "Storing current terminal attributes\n");
156
322
  }
157
323
  
158
324
  if(tcgetattr(STDIN_FILENO, &t_old) != 0){
159
325
    int e = errno;
160
 
    error(0, errno, "tcgetattr");
 
326
    error_plus(0, errno, "tcgetattr");
161
327
    switch(e){
162
328
    case EBADF:
163
329
    case ENOTTY:
170
336
  sigemptyset(&new_action.sa_mask);
171
337
  ret = sigaddset(&new_action.sa_mask, SIGINT);
172
338
  if(ret == -1){
173
 
    error(0, errno, "sigaddset");
 
339
    error_plus(0, errno, "sigaddset");
174
340
    return EX_OSERR;
175
341
  }
176
342
  ret = sigaddset(&new_action.sa_mask, SIGHUP);
177
343
  if(ret == -1){
178
 
    error(0, errno, "sigaddset");
 
344
    error_plus(0, errno, "sigaddset");
179
345
    return EX_OSERR;
180
346
  }
181
347
  ret = sigaddset(&new_action.sa_mask, SIGTERM);
182
348
  if(ret == -1){
183
 
    error(0, errno, "sigaddset");
 
349
    error_plus(0, errno, "sigaddset");
184
350
    return EX_OSERR;
185
351
  }
186
352
  /* Need to check if the handler is SIG_IGN before handling:
189
355
  */
190
356
  ret = sigaction(SIGINT, NULL, &old_action);
191
357
  if(ret == -1){
192
 
    error(0, errno, "sigaction");
 
358
    error_plus(0, errno, "sigaction");
193
359
    return EX_OSERR;
194
360
  }
195
361
  if(old_action.sa_handler != SIG_IGN){
196
362
    ret = sigaction(SIGINT, &new_action, NULL);
197
363
    if(ret == -1){
198
 
      error(0, errno, "sigaction");
 
364
      error_plus(0, errno, "sigaction");
199
365
      return EX_OSERR;
200
366
    }
201
367
  }
202
368
  ret = sigaction(SIGHUP, NULL, &old_action);
203
369
  if(ret == -1){
204
 
    error(0, errno, "sigaction");
 
370
    error_plus(0, errno, "sigaction");
205
371
    return EX_OSERR;
206
372
  }
207
373
  if(old_action.sa_handler != SIG_IGN){
208
374
    ret = sigaction(SIGHUP, &new_action, NULL);
209
375
    if(ret == -1){
210
 
      error(0, errno, "sigaction");
 
376
      error_plus(0, errno, "sigaction");
211
377
      return EX_OSERR;
212
378
    }
213
379
  }
214
380
  ret = sigaction(SIGTERM, NULL, &old_action);
215
381
  if(ret == -1){
216
 
    error(0, errno, "sigaction");
 
382
    error_plus(0, errno, "sigaction");
217
383
    return EX_OSERR;
218
384
  }
219
385
  if(old_action.sa_handler != SIG_IGN){
220
386
    ret = sigaction(SIGTERM, &new_action, NULL);
221
387
    if(ret == -1){
222
 
      error(0, errno, "sigaction");
 
388
      error_plus(0, errno, "sigaction");
223
389
      return EX_OSERR;
224
390
    }
225
391
  }
233
399
  t_new.c_lflag &= ~(tcflag_t)ECHO;
234
400
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_new) != 0){
235
401
    int e = errno;
236
 
    error(0, errno, "tcsetattr-echo");
 
402
    error_plus(0, errno, "tcsetattr-echo");
237
403
    switch(e){
238
404
    case EBADF:
239
405
    case ENOTTY:
303
469
        sret = write(STDOUT_FILENO, buffer + written, n - written);
304
470
        if(sret < 0){
305
471
          int e = errno;
306
 
          error(0, errno, "write");
 
472
          error_plus(0, errno, "write");
307
473
          switch(e){
308
474
          case EBADF:
309
475
          case EFAULT:
325
491
      sret = close(STDOUT_FILENO);
326
492
      if(sret == -1){
327
493
        int e = errno;
328
 
        error(0, errno, "close");
 
494
        error_plus(0, errno, "close");
329
495
        switch(e){
330
496
        case EBADF:
331
497
          status = EX_OSFILE;
341
507
    if(sret < 0){
342
508
      int e = errno;
343
509
      if(errno != EINTR and not feof(stdin)){
344
 
        error(0, errno, "getline");
 
510
        error_plus(0, errno, "getline");
345
511
        switch(e){
346
512
        case EBADF:
347
513
          status = EX_UNAVAILABLE;
 
514
          break;
348
515
        case EIO:
349
516
        case EINVAL:
350
517
        default:
354
521
        break;
355
522
      }
356
523
    }
357
 
    /* if(sret == 0), then the only sensible thing to do is to retry to
358
 
       read from stdin */
 
524
    /* if(sret == 0), then the only sensible thing to do is to retry
 
525
       to read from stdin */
359
526
    fputc('\n', stderr);
360
527
    if(debug and not quit_now){
361
528
      /* If quit_now is nonzero, we were interrupted by a signal, and
370
537
    fprintf(stderr, "Restoring terminal attributes\n");
371
538
  }
372
539
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_old) != 0){
373
 
    error(0, errno, "tcsetattr+echo");
 
540
    error_plus(0, errno, "tcsetattr+echo");
374
541
  }
375
542
  
376
543
  if(quit_now){
378
545
    old_action.sa_handler = SIG_DFL;
379
546
    ret = sigaction(signal_received, &old_action, NULL);
380
547
    if(ret == -1){
381
 
      error(0, errno, "sigaction");
 
548
      error_plus(0, errno, "sigaction");
382
549
    }
383
550
    raise(signal_received);
384
551
  }