/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
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:
2
2
/*
3
3
 * Password-prompt - Read a password from the terminal and print it
4
4
 * 
5
 
 * Copyright © 2008-2011 Teddy Hogeborn
6
 
 * Copyright © 2008-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 © 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
23
 * Contact the authors at <mandos@recompile.se>.
23
24
 */
73
74
const char plymouth_name[] = "plymouthd";
74
75
 
75
76
/* Function to use when printing errors */
 
77
__attribute__((format (gnu_printf, 3, 4)))
76
78
void error_plus(int status, int errnum, const char *formatstring,
77
79
                ...){
78
80
  va_list ap;
81
83
  
82
84
  va_start(ap, formatstring);
83
85
  ret = vasprintf(&text, formatstring, ap);
84
 
  if (ret == -1){
 
86
  if(ret == -1){
85
87
    fprintf(stderr, "Mandos plugin %s: ",
86
88
            program_invocation_short_name);
87
89
    vfprintf(stderr, formatstring, ap);
88
 
    fprintf(stderr, ": ");
89
 
    fprintf(stderr, "%s\n", strerror(errnum));
 
90
    fprintf(stderr, ": %s\n", strerror(errnum));
90
91
    error(status, errno, "vasprintf while printing error");
91
92
    return;
92
93
  }
109
110
     from the terminal.  Password-prompt will exit if it detects
110
111
     plymouth since plymouth performs the same functionality.
111
112
   */
 
113
  __attribute__((nonnull))
112
114
  int is_plymouth(const struct dirent *proc_entry){
113
115
    int ret;
114
116
    int cl_fd;
115
117
    {
116
 
      uintmax_t maxvalue;
 
118
      uintmax_t proc_id;
117
119
      char *tmp;
118
120
      errno = 0;
119
 
      maxvalue = strtoumax(proc_entry->d_name, &tmp, 10);
 
121
      proc_id = strtoumax(proc_entry->d_name, &tmp, 10);
120
122
      
121
123
      if(errno != 0 or *tmp != '\0'
122
 
         or maxvalue != (uintmax_t)((pid_t)maxvalue)){
 
124
         or proc_id != (uintmax_t)((pid_t)proc_id)){
123
125
        return 0;
124
126
      }
125
127
    }
128
130
    ret = asprintf(&cmdline_filename, "/proc/%s/cmdline",
129
131
                   proc_entry->d_name);
130
132
    if(ret == -1){
131
 
      error(0, errno, "asprintf");
 
133
      error_plus(0, errno, "asprintf");
132
134
      return 0;
133
135
    }
134
136
    
137
139
    free(cmdline_filename);
138
140
    if(cl_fd == -1){
139
141
      if(errno != ENOENT){
140
 
        error(0, errno, "open");
 
142
        error_plus(0, errno, "open");
141
143
      }
142
144
      return 0;
143
145
    }
154
156
        if(cmdline_len + blocksize + 1 > cmdline_allocated){
155
157
          tmp = realloc(cmdline, cmdline_allocated + blocksize + 1);
156
158
          if(tmp == NULL){
157
 
            error(0, errno, "realloc");
 
159
            error_plus(0, errno, "realloc");
158
160
            free(cmdline);
159
161
            close(cl_fd);
160
162
            return 0;
167
169
        sret = read(cl_fd, cmdline + cmdline_len,
168
170
                    cmdline_allocated - cmdline_len);
169
171
        if(sret == -1){
170
 
          error(0, errno, "read");
 
172
          error_plus(0, errno, "read");
171
173
          free(cmdline);
172
174
          close(cl_fd);
173
175
          return 0;
176
178
      } while(sret != 0);
177
179
      ret = close(cl_fd);
178
180
      if(ret == -1){
179
 
        error(0, errno, "close");
 
181
        error_plus(0, errno, "close");
180
182
        free(cmdline);
181
183
        return 0;
182
184
      }
211
213
  struct dirent **direntries = NULL;
212
214
  int ret;
213
215
  ret = scandir("/proc", &direntries, is_plymouth, alphasort);
214
 
  if (ret == -1){
215
 
    error(1, errno, "scandir");
 
216
  if(ret == -1){
 
217
    error_plus(1, errno, "scandir");
 
218
  }
 
219
  {
 
220
    int i = ret;
 
221
    while(i--){
 
222
      free(direntries[i]);
 
223
    }
216
224
  }
217
225
  free(direntries);
218
226
  return ret > 0;
249
257
      { .name = NULL }
250
258
    };
251
259
    
 
260
    __attribute__((nonnull(3)))
252
261
    error_t parse_opt (int key, char *arg, struct argp_state *state){
253
262
      errno = 0;
254
263
      switch (key){
290
299
    case ENOMEM:
291
300
    default:
292
301
      errno = ret;
293
 
      error(0, errno, "argp_parse");
 
302
      error_plus(0, errno, "argp_parse");
294
303
      return EX_OSERR;
295
304
    case EINVAL:
296
305
      return EX_USAGE;
301
310
    fprintf(stderr, "Starting %s\n", argv[0]);
302
311
  }
303
312
 
304
 
  if (conflict_detection()){
 
313
  if(conflict_detection()){
305
314
    if(debug){
306
315
      fprintf(stderr, "Stopping %s because of conflict\n", argv[0]);
307
316
    }
314
323
  
315
324
  if(tcgetattr(STDIN_FILENO, &t_old) != 0){
316
325
    int e = errno;
317
 
    error(0, errno, "tcgetattr");
 
326
    error_plus(0, errno, "tcgetattr");
318
327
    switch(e){
319
328
    case EBADF:
320
329
    case ENOTTY:
327
336
  sigemptyset(&new_action.sa_mask);
328
337
  ret = sigaddset(&new_action.sa_mask, SIGINT);
329
338
  if(ret == -1){
330
 
    error(0, errno, "sigaddset");
 
339
    error_plus(0, errno, "sigaddset");
331
340
    return EX_OSERR;
332
341
  }
333
342
  ret = sigaddset(&new_action.sa_mask, SIGHUP);
334
343
  if(ret == -1){
335
 
    error(0, errno, "sigaddset");
 
344
    error_plus(0, errno, "sigaddset");
336
345
    return EX_OSERR;
337
346
  }
338
347
  ret = sigaddset(&new_action.sa_mask, SIGTERM);
339
348
  if(ret == -1){
340
 
    error(0, errno, "sigaddset");
 
349
    error_plus(0, errno, "sigaddset");
341
350
    return EX_OSERR;
342
351
  }
343
352
  /* Need to check if the handler is SIG_IGN before handling:
346
355
  */
347
356
  ret = sigaction(SIGINT, NULL, &old_action);
348
357
  if(ret == -1){
349
 
    error(0, errno, "sigaction");
 
358
    error_plus(0, errno, "sigaction");
350
359
    return EX_OSERR;
351
360
  }
352
361
  if(old_action.sa_handler != SIG_IGN){
353
362
    ret = sigaction(SIGINT, &new_action, NULL);
354
363
    if(ret == -1){
355
 
      error(0, errno, "sigaction");
 
364
      error_plus(0, errno, "sigaction");
356
365
      return EX_OSERR;
357
366
    }
358
367
  }
359
368
  ret = sigaction(SIGHUP, NULL, &old_action);
360
369
  if(ret == -1){
361
 
    error(0, errno, "sigaction");
 
370
    error_plus(0, errno, "sigaction");
362
371
    return EX_OSERR;
363
372
  }
364
373
  if(old_action.sa_handler != SIG_IGN){
365
374
    ret = sigaction(SIGHUP, &new_action, NULL);
366
375
    if(ret == -1){
367
 
      error(0, errno, "sigaction");
 
376
      error_plus(0, errno, "sigaction");
368
377
      return EX_OSERR;
369
378
    }
370
379
  }
371
380
  ret = sigaction(SIGTERM, NULL, &old_action);
372
381
  if(ret == -1){
373
 
    error(0, errno, "sigaction");
 
382
    error_plus(0, errno, "sigaction");
374
383
    return EX_OSERR;
375
384
  }
376
385
  if(old_action.sa_handler != SIG_IGN){
377
386
    ret = sigaction(SIGTERM, &new_action, NULL);
378
387
    if(ret == -1){
379
 
      error(0, errno, "sigaction");
 
388
      error_plus(0, errno, "sigaction");
380
389
      return EX_OSERR;
381
390
    }
382
391
  }
390
399
  t_new.c_lflag &= ~(tcflag_t)ECHO;
391
400
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_new) != 0){
392
401
    int e = errno;
393
 
    error(0, errno, "tcsetattr-echo");
 
402
    error_plus(0, errno, "tcsetattr-echo");
394
403
    switch(e){
395
404
    case EBADF:
396
405
    case ENOTTY:
460
469
        sret = write(STDOUT_FILENO, buffer + written, n - written);
461
470
        if(sret < 0){
462
471
          int e = errno;
463
 
          error(0, errno, "write");
 
472
          error_plus(0, errno, "write");
464
473
          switch(e){
465
474
          case EBADF:
466
475
          case EFAULT:
482
491
      sret = close(STDOUT_FILENO);
483
492
      if(sret == -1){
484
493
        int e = errno;
485
 
        error(0, errno, "close");
 
494
        error_plus(0, errno, "close");
486
495
        switch(e){
487
496
        case EBADF:
488
497
          status = EX_OSFILE;
498
507
    if(sret < 0){
499
508
      int e = errno;
500
509
      if(errno != EINTR and not feof(stdin)){
501
 
        error(0, errno, "getline");
 
510
        error_plus(0, errno, "getline");
502
511
        switch(e){
503
512
        case EBADF:
504
513
          status = EX_UNAVAILABLE;
 
514
          break;
505
515
        case EIO:
506
516
        case EINVAL:
507
517
        default:
527
537
    fprintf(stderr, "Restoring terminal attributes\n");
528
538
  }
529
539
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_old) != 0){
530
 
    error(0, errno, "tcsetattr+echo");
 
540
    error_plus(0, errno, "tcsetattr+echo");
531
541
  }
532
542
  
533
543
  if(quit_now){
535
545
    old_action.sa_handler = SIG_DFL;
536
546
    ret = sigaction(signal_received, &old_action, NULL);
537
547
    if(ret == -1){
538
 
      error(0, errno, "sigaction");
 
548
      error_plus(0, errno, "sigaction");
539
549
    }
540
550
    raise(signal_received);
541
551
  }