/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: 2015-07-20 03:03:33 UTC
  • Revision ID: teddy@recompile.se-20150720030333-203m2aeblypcsfte
Bug fix for GnuTLS 3: be compatible with old 2048-bit DSA keys.

The mandos-keygen program in Mandos version 1.6.0 and older generated
2048-bit DSA keys, and when GnuTLS uses these it has trouble
connecting using the Mandos default priority string.  This was
previously fixed in Mandos 1.6.2, but the bug reappeared when using
GnuTLS 3, so the default priority string has to change again; this
time also the Mandos client has to change its default, so now the
server and the client should use the same default priority string:

SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256

* mandos (main/server_defaults): Changed default priority string.
* mandos-options.xml (/section/para[id="priority_compat"]): Removed.
  (/section/para[id="priority"]): Changed default priority string.
* mandos.conf ([DEFAULT]/priority): - '' -
* mandos.conf.xml (OPTIONS/priority): Refer to the id "priority"
                                      instead of "priority_compat".
* mandos.xml (OPTIONS/--priority): - '' -
* plugins.d/mandos-client.c (main): Changed default priority string.

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-2011 Teddy Hogeborn
6
 
 * Copyright © 2008-2011 Björn Påhlsson
 
5
 * Copyright © 2008-2014 Teddy Hogeborn
 
6
 * Copyright © 2008-2014 Björn Påhlsson
7
7
 * 
8
8
 * This program is free software: you can redistribute it and/or
9
9
 * modify it under the terms of the GNU General Public License as
82
82
  
83
83
  va_start(ap, formatstring);
84
84
  ret = vasprintf(&text, formatstring, ap);
85
 
  if (ret == -1){
 
85
  if(ret == -1){
86
86
    fprintf(stderr, "Mandos plugin %s: ",
87
87
            program_invocation_short_name);
88
88
    vfprintf(stderr, formatstring, ap);
89
 
    fprintf(stderr, ": ");
90
 
    fprintf(stderr, "%s\n", strerror(errnum));
 
89
    fprintf(stderr, ": %s\n", strerror(errnum));
91
90
    error(status, errno, "vasprintf while printing error");
92
91
    return;
93
92
  }
110
109
     from the terminal.  Password-prompt will exit if it detects
111
110
     plymouth since plymouth performs the same functionality.
112
111
   */
 
112
  __attribute__((nonnull))
113
113
  int is_plymouth(const struct dirent *proc_entry){
114
114
    int ret;
115
115
    int cl_fd;
116
116
    {
117
 
      uintmax_t maxvalue;
 
117
      uintmax_t proc_id;
118
118
      char *tmp;
119
119
      errno = 0;
120
 
      maxvalue = strtoumax(proc_entry->d_name, &tmp, 10);
 
120
      proc_id = strtoumax(proc_entry->d_name, &tmp, 10);
121
121
      
122
122
      if(errno != 0 or *tmp != '\0'
123
 
         or maxvalue != (uintmax_t)((pid_t)maxvalue)){
 
123
         or proc_id != (uintmax_t)((pid_t)proc_id)){
124
124
        return 0;
125
125
      }
126
126
    }
129
129
    ret = asprintf(&cmdline_filename, "/proc/%s/cmdline",
130
130
                   proc_entry->d_name);
131
131
    if(ret == -1){
132
 
      error(0, errno, "asprintf");
 
132
      error_plus(0, errno, "asprintf");
133
133
      return 0;
134
134
    }
135
135
    
138
138
    free(cmdline_filename);
139
139
    if(cl_fd == -1){
140
140
      if(errno != ENOENT){
141
 
        error(0, errno, "open");
 
141
        error_plus(0, errno, "open");
142
142
      }
143
143
      return 0;
144
144
    }
155
155
        if(cmdline_len + blocksize + 1 > cmdline_allocated){
156
156
          tmp = realloc(cmdline, cmdline_allocated + blocksize + 1);
157
157
          if(tmp == NULL){
158
 
            error(0, errno, "realloc");
 
158
            error_plus(0, errno, "realloc");
159
159
            free(cmdline);
160
160
            close(cl_fd);
161
161
            return 0;
168
168
        sret = read(cl_fd, cmdline + cmdline_len,
169
169
                    cmdline_allocated - cmdline_len);
170
170
        if(sret == -1){
171
 
          error(0, errno, "read");
 
171
          error_plus(0, errno, "read");
172
172
          free(cmdline);
173
173
          close(cl_fd);
174
174
          return 0;
177
177
      } while(sret != 0);
178
178
      ret = close(cl_fd);
179
179
      if(ret == -1){
180
 
        error(0, errno, "close");
 
180
        error_plus(0, errno, "close");
181
181
        free(cmdline);
182
182
        return 0;
183
183
      }
212
212
  struct dirent **direntries = NULL;
213
213
  int ret;
214
214
  ret = scandir("/proc", &direntries, is_plymouth, alphasort);
215
 
  if (ret == -1){
216
 
    error(1, errno, "scandir");
 
215
  if(ret == -1){
 
216
    error_plus(1, errno, "scandir");
217
217
  }
218
218
  free(direntries);
219
219
  return ret > 0;
250
250
      { .name = NULL }
251
251
    };
252
252
    
 
253
    __attribute__((nonnull(3)))
253
254
    error_t parse_opt (int key, char *arg, struct argp_state *state){
254
255
      errno = 0;
255
256
      switch (key){
291
292
    case ENOMEM:
292
293
    default:
293
294
      errno = ret;
294
 
      error(0, errno, "argp_parse");
 
295
      error_plus(0, errno, "argp_parse");
295
296
      return EX_OSERR;
296
297
    case EINVAL:
297
298
      return EX_USAGE;
302
303
    fprintf(stderr, "Starting %s\n", argv[0]);
303
304
  }
304
305
 
305
 
  if (conflict_detection()){
 
306
  if(conflict_detection()){
306
307
    if(debug){
307
308
      fprintf(stderr, "Stopping %s because of conflict\n", argv[0]);
308
309
    }
315
316
  
316
317
  if(tcgetattr(STDIN_FILENO, &t_old) != 0){
317
318
    int e = errno;
318
 
    error(0, errno, "tcgetattr");
 
319
    error_plus(0, errno, "tcgetattr");
319
320
    switch(e){
320
321
    case EBADF:
321
322
    case ENOTTY:
328
329
  sigemptyset(&new_action.sa_mask);
329
330
  ret = sigaddset(&new_action.sa_mask, SIGINT);
330
331
  if(ret == -1){
331
 
    error(0, errno, "sigaddset");
 
332
    error_plus(0, errno, "sigaddset");
332
333
    return EX_OSERR;
333
334
  }
334
335
  ret = sigaddset(&new_action.sa_mask, SIGHUP);
335
336
  if(ret == -1){
336
 
    error(0, errno, "sigaddset");
 
337
    error_plus(0, errno, "sigaddset");
337
338
    return EX_OSERR;
338
339
  }
339
340
  ret = sigaddset(&new_action.sa_mask, SIGTERM);
340
341
  if(ret == -1){
341
 
    error(0, errno, "sigaddset");
 
342
    error_plus(0, errno, "sigaddset");
342
343
    return EX_OSERR;
343
344
  }
344
345
  /* Need to check if the handler is SIG_IGN before handling:
347
348
  */
348
349
  ret = sigaction(SIGINT, NULL, &old_action);
349
350
  if(ret == -1){
350
 
    error(0, errno, "sigaction");
 
351
    error_plus(0, errno, "sigaction");
351
352
    return EX_OSERR;
352
353
  }
353
354
  if(old_action.sa_handler != SIG_IGN){
354
355
    ret = sigaction(SIGINT, &new_action, NULL);
355
356
    if(ret == -1){
356
 
      error(0, errno, "sigaction");
 
357
      error_plus(0, errno, "sigaction");
357
358
      return EX_OSERR;
358
359
    }
359
360
  }
360
361
  ret = sigaction(SIGHUP, NULL, &old_action);
361
362
  if(ret == -1){
362
 
    error(0, errno, "sigaction");
 
363
    error_plus(0, errno, "sigaction");
363
364
    return EX_OSERR;
364
365
  }
365
366
  if(old_action.sa_handler != SIG_IGN){
366
367
    ret = sigaction(SIGHUP, &new_action, NULL);
367
368
    if(ret == -1){
368
 
      error(0, errno, "sigaction");
 
369
      error_plus(0, errno, "sigaction");
369
370
      return EX_OSERR;
370
371
    }
371
372
  }
372
373
  ret = sigaction(SIGTERM, NULL, &old_action);
373
374
  if(ret == -1){
374
 
    error(0, errno, "sigaction");
 
375
    error_plus(0, errno, "sigaction");
375
376
    return EX_OSERR;
376
377
  }
377
378
  if(old_action.sa_handler != SIG_IGN){
378
379
    ret = sigaction(SIGTERM, &new_action, NULL);
379
380
    if(ret == -1){
380
 
      error(0, errno, "sigaction");
 
381
      error_plus(0, errno, "sigaction");
381
382
      return EX_OSERR;
382
383
    }
383
384
  }
391
392
  t_new.c_lflag &= ~(tcflag_t)ECHO;
392
393
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_new) != 0){
393
394
    int e = errno;
394
 
    error(0, errno, "tcsetattr-echo");
 
395
    error_plus(0, errno, "tcsetattr-echo");
395
396
    switch(e){
396
397
    case EBADF:
397
398
    case ENOTTY:
461
462
        sret = write(STDOUT_FILENO, buffer + written, n - written);
462
463
        if(sret < 0){
463
464
          int e = errno;
464
 
          error(0, errno, "write");
 
465
          error_plus(0, errno, "write");
465
466
          switch(e){
466
467
          case EBADF:
467
468
          case EFAULT:
483
484
      sret = close(STDOUT_FILENO);
484
485
      if(sret == -1){
485
486
        int e = errno;
486
 
        error(0, errno, "close");
 
487
        error_plus(0, errno, "close");
487
488
        switch(e){
488
489
        case EBADF:
489
490
          status = EX_OSFILE;
499
500
    if(sret < 0){
500
501
      int e = errno;
501
502
      if(errno != EINTR and not feof(stdin)){
502
 
        error(0, errno, "getline");
 
503
        error_plus(0, errno, "getline");
503
504
        switch(e){
504
505
        case EBADF:
505
506
          status = EX_UNAVAILABLE;
 
507
          break;
506
508
        case EIO:
507
509
        case EINVAL:
508
510
        default:
528
530
    fprintf(stderr, "Restoring terminal attributes\n");
529
531
  }
530
532
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_old) != 0){
531
 
    error(0, errno, "tcsetattr+echo");
 
533
    error_plus(0, errno, "tcsetattr+echo");
532
534
  }
533
535
  
534
536
  if(quit_now){
536
538
    old_action.sa_handler = SIG_DFL;
537
539
    ret = sigaction(signal_received, &old_action, NULL);
538
540
    if(ret == -1){
539
 
      error(0, errno, "sigaction");
 
541
      error_plus(0, errno, "sigaction");
540
542
    }
541
543
    raise(signal_received);
542
544
  }