/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-09 23:23:26 UTC
  • Revision ID: teddy@recompile.se-20190209232326-z1z2kzpgfixz7iaj
Add support for using raw public keys in TLS (RFC 7250)

Since GnuTLS removed support for OpenPGP keys in TLS (RFC 6091), and
no other library supports it, we have to change the protocol to use
something else.  We choose to use "raw public keys" (RFC 7250).  Since
we still use OpenPGP keys to decrypt the secret password, this means
that each client will have two keys: One OpenPGP key and one TLS
public/private key, and the key ID of the latter key is used to
identify clients instead of the fingerprint of the OpenPGP key.

Note that this code is still compatible with GnuTLS before version
3.6.0 (when OpenPGP key support was removed).  This commit merely adds
support for using raw pulic keys instead with GnuTLS 3.6.6. or later.

* DBUS-API (Signals/ClientNotFound): Change name of first parameter
                                     from "Fingerprint" to "KeyID".
  (Mandos Client Interface/Properties/KeyID): New.
* INSTALL: Document conflict with GnuTLS 3.6.0 (which removed OpenPGP
           key support) up until 3.6.6, when support for raw public
           keys was added.  Also document new dependency of client on
           "gnutls-bin" package (for certtool).
* Makefile (run-client): Depend on TLS key files, and also pass them
                         as arguments to client.
  (keydir/tls-privkey.pem, keydir/tls-pubkey.pem): New.
  (confdir/clients.conf): Add dependency on TLS public key.
  (purge-client): Add removal of TLS key files.
* clients.conf ([foo]/key_id, [bar]/key_id): New.
* debian/control (Source: mandos/Build-Depends): Also allow
                                                 libgnutls30 (>= 3.6.6)
  (Package: mandos/Depends): - '' -
  (Package: mandos/Description): Alter description to match new
                                 design.
  (Package: mandos-client/Description): - '' -
  (Package: mandos-client/Depends): Move "gnutls-bin | openssl" to
                                    here from "Recommends".
* debian/mandos-client.README.Debian: Add --tls-privkey and
                                      --tls-pubkey options to test
                                      command.
* debian/mandos-client.postinst (create_key): Renamed to "create_keys"
                                             (all callers changed),
                                             and also create TLS key.
* debian/mandos-client.postrm (purge): Also remove TLS key files.
* intro.xml (DESCRIPTION): Describe new dual-key design.
* mandos (GnuTLS): Define different functions depending on whether
                   support for raw public keys is detected.
  (Client.key_id): New attribute.
  (ClientDBus.KeyID_dbus_property): New method.
  (ProxyClient.__init__): Take new "key_id" parameter.
  (ClientHandler.handle): Use key IDs when using raw public keys and
                          use fingerprints when using OpenPGP keys.
  (ClientHandler.peer_certificate): Also handle raw public keys.
  (ClientHandler.key_id): New.
  (MandosServer.handle_ipc): Pass key ID over the pipe IPC.  Also
                             check for key ID matches when looking up
                             clients.
  (main): Default GnuTLS priority string depends on whether we are
          using raw public keys or not.  When unpickling clients, set
          key_id if not set in the pickle.
  (main/MandosDBusService.ClientNotFound): Change name of first
                                           parameter from
                                           "Fingerprint" to "KeyID".
* mandos-clients.conf.xml (OPTIONS): Document new "key_id" option.
  (OPTIONS/secret): Mention new key ID matchning.
  (EXPANSION/RUNTIME EXPANSION): Add new "key_id" option.
  (EXAMPLE): - '' -
* mandos-ctl (tablewords, main/keywords): Add new "KeyID" property.
* mandos-keygen: Create TLS key files.  New "--tls-keytype" (-T)
                 option.  Alter help text to be more clear about key
                 types.  When in password mode, also output "key_id"
                 option.
* mandos-keygen.xml (SYNOPSIS): Add new "--tls-keytype" (-T) option.
  (DESCRIPTION): Alter to match new dual-key design.
  (OVERVIEW): - '' -
  (FILES): Add TLS key files.
* mandos-options.xml (priority): Document new default priority string
                                 when using raw public keys.
* mandos.xml (NETWORK PROTOCOL): Describe new protocol using key ID.
  (BUGS): Remove issue about checking expire times of OpenPGP keys,
          since TLS public keys do not have expiration times.
  (SECURITY/CLIENT): Alter description to match new design.
  (SEE ALSO/GnuTLS): - '' -
  (SEE ALSO): Add reference to RFC 7250, and alter description of when
              RFC 6091 is used.
* overview.xml: Alter text to match new design.
* plugin-runner.xml (EXAMPLE): Add --tls-pubkey and --tls-privkey
                               options to mandos-client options.
* plugins.d/mandos-client.c: Use raw public keys when compiling with
                             supporting GnuTLS versions. Add new
                             "--tls-pubkey" and "--tls-privkey"
                             options (which do nothing if GnuTLS
                             library does not support raw public
                             keys).  Alter text throughout to reflect
                             new design.  Only generate new DH
                             parameters (based on size of OpenPGP key)
                             when using OpenPGP in TLS.  Default
                             GnuTLS priority string depends on whether
                             we are using raw public keys or not.
* plugins.d/mandos-client.xml (SYNOPSIS): Add new "--tls-privkey" (-t)
                                          and "--tls-pubkey" (-T)
                                          options.
  (DESCRIPTION): Describe new dual-key design.
  (OPTIONS): Document new "--tls-privkey" (-t) and "--tls-pubkey" (-T)
             options.
  (OPTIONS/--dh-bits): No longer necessarily depends on OpenPGP key
                       size.
  (FILES): Add default locations for TLS public and private key files.
  (EXAMPLE): Use new --tls-pubkey and --tls-privkey options.
  (SECURITY): Alter wording slightly to reflect new dual-key design.
  (SEE ALSO/GnuTLS): Alter description to match new design.
  (SEE ALSO): Add reference to RFC 7250, and alter description of when
              RFC 6091 is used.

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() */
67
68
int signal_received;
68
69
bool debug = false;
69
70
const char *argp_program_version = "password-prompt " VERSION;
70
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
 
71
const char *argp_program_bug_address = "<mandos@recompile.se>";
71
72
 
72
73
/* Needed for conflict resolution */
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
      }
208
210
    return 1;
209
211
  }
210
212
  
211
 
  struct dirent **direntries;
 
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
 
  }
 
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);
217
226
  return ret > 0;
218
227
}
219
228
 
248
257
      { .name = NULL }
249
258
    };
250
259
    
 
260
    __attribute__((nonnull(3)))
251
261
    error_t parse_opt (int key, char *arg, struct argp_state *state){
252
262
      errno = 0;
253
263
      switch (key){
289
299
    case ENOMEM:
290
300
    default:
291
301
      errno = ret;
292
 
      error(0, errno, "argp_parse");
 
302
      error_plus(0, errno, "argp_parse");
293
303
      return EX_OSERR;
294
304
    case EINVAL:
295
305
      return EX_USAGE;
300
310
    fprintf(stderr, "Starting %s\n", argv[0]);
301
311
  }
302
312
 
303
 
  if (conflict_detection()){
 
313
  if(conflict_detection()){
304
314
    if(debug){
305
315
      fprintf(stderr, "Stopping %s because of conflict\n", argv[0]);
306
316
    }
313
323
  
314
324
  if(tcgetattr(STDIN_FILENO, &t_old) != 0){
315
325
    int e = errno;
316
 
    error(0, errno, "tcgetattr");
 
326
    error_plus(0, errno, "tcgetattr");
317
327
    switch(e){
318
328
    case EBADF:
319
329
    case ENOTTY:
326
336
  sigemptyset(&new_action.sa_mask);
327
337
  ret = sigaddset(&new_action.sa_mask, SIGINT);
328
338
  if(ret == -1){
329
 
    error(0, errno, "sigaddset");
 
339
    error_plus(0, errno, "sigaddset");
330
340
    return EX_OSERR;
331
341
  }
332
342
  ret = sigaddset(&new_action.sa_mask, SIGHUP);
333
343
  if(ret == -1){
334
 
    error(0, errno, "sigaddset");
 
344
    error_plus(0, errno, "sigaddset");
335
345
    return EX_OSERR;
336
346
  }
337
347
  ret = sigaddset(&new_action.sa_mask, SIGTERM);
338
348
  if(ret == -1){
339
 
    error(0, errno, "sigaddset");
 
349
    error_plus(0, errno, "sigaddset");
340
350
    return EX_OSERR;
341
351
  }
342
352
  /* Need to check if the handler is SIG_IGN before handling:
345
355
  */
346
356
  ret = sigaction(SIGINT, NULL, &old_action);
347
357
  if(ret == -1){
348
 
    error(0, errno, "sigaction");
 
358
    error_plus(0, errno, "sigaction");
349
359
    return EX_OSERR;
350
360
  }
351
361
  if(old_action.sa_handler != SIG_IGN){
352
362
    ret = sigaction(SIGINT, &new_action, NULL);
353
363
    if(ret == -1){
354
 
      error(0, errno, "sigaction");
 
364
      error_plus(0, errno, "sigaction");
355
365
      return EX_OSERR;
356
366
    }
357
367
  }
358
368
  ret = sigaction(SIGHUP, NULL, &old_action);
359
369
  if(ret == -1){
360
 
    error(0, errno, "sigaction");
 
370
    error_plus(0, errno, "sigaction");
361
371
    return EX_OSERR;
362
372
  }
363
373
  if(old_action.sa_handler != SIG_IGN){
364
374
    ret = sigaction(SIGHUP, &new_action, NULL);
365
375
    if(ret == -1){
366
 
      error(0, errno, "sigaction");
 
376
      error_plus(0, errno, "sigaction");
367
377
      return EX_OSERR;
368
378
    }
369
379
  }
370
380
  ret = sigaction(SIGTERM, NULL, &old_action);
371
381
  if(ret == -1){
372
 
    error(0, errno, "sigaction");
 
382
    error_plus(0, errno, "sigaction");
373
383
    return EX_OSERR;
374
384
  }
375
385
  if(old_action.sa_handler != SIG_IGN){
376
386
    ret = sigaction(SIGTERM, &new_action, NULL);
377
387
    if(ret == -1){
378
 
      error(0, errno, "sigaction");
 
388
      error_plus(0, errno, "sigaction");
379
389
      return EX_OSERR;
380
390
    }
381
391
  }
389
399
  t_new.c_lflag &= ~(tcflag_t)ECHO;
390
400
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_new) != 0){
391
401
    int e = errno;
392
 
    error(0, errno, "tcsetattr-echo");
 
402
    error_plus(0, errno, "tcsetattr-echo");
393
403
    switch(e){
394
404
    case EBADF:
395
405
    case ENOTTY:
459
469
        sret = write(STDOUT_FILENO, buffer + written, n - written);
460
470
        if(sret < 0){
461
471
          int e = errno;
462
 
          error(0, errno, "write");
 
472
          error_plus(0, errno, "write");
463
473
          switch(e){
464
474
          case EBADF:
465
475
          case EFAULT:
481
491
      sret = close(STDOUT_FILENO);
482
492
      if(sret == -1){
483
493
        int e = errno;
484
 
        error(0, errno, "close");
 
494
        error_plus(0, errno, "close");
485
495
        switch(e){
486
496
        case EBADF:
487
497
          status = EX_OSFILE;
497
507
    if(sret < 0){
498
508
      int e = errno;
499
509
      if(errno != EINTR and not feof(stdin)){
500
 
        error(0, errno, "getline");
 
510
        error_plus(0, errno, "getline");
501
511
        switch(e){
502
512
        case EBADF:
503
513
          status = EX_UNAVAILABLE;
 
514
          break;
504
515
        case EIO:
505
516
        case EINVAL:
506
517
        default:
526
537
    fprintf(stderr, "Restoring terminal attributes\n");
527
538
  }
528
539
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_old) != 0){
529
 
    error(0, errno, "tcsetattr+echo");
 
540
    error_plus(0, errno, "tcsetattr+echo");
530
541
  }
531
542
  
532
543
  if(quit_now){
534
545
    old_action.sa_handler = SIG_DFL;
535
546
    ret = sigaction(signal_received, &old_action, NULL);
536
547
    if(ret == -1){
537
 
      error(0, errno, "sigaction");
 
548
      error_plus(0, errno, "sigaction");
538
549
    }
539
550
    raise(signal_received);
540
551
  }