/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-08-02 22:16:53 UTC
  • Revision ID: teddy@recompile.se-20190802221653-ic1iko9hbefzwsk7
Fix bug in server Debian package: Fails to start on first install

There has been a very long-standing bug where installation of the
server (the "mandos" Debian package) would fail to start the server
properly right after installation.  It would work on manual (re)start
after installation, or after reboot, and even after package purge and
reinstall, it would then work the first time.  The problem, it turns
out, is when the new "_mandos" user (and corresponding group) is
created, the D-Bus server is not reloaded, and is therefore not aware
of that user, and does not recognize the user and group name in the
/etc/dbus-1/system.d/mandos.conf file.  The Mandos server, when it
tries to start and access the D-Bus, is then not permitted to connect
to its D-Bus bus name, and disables D-Bus use as a fallback measure;
i.e. the server works, but it is not controllable via D-Bus commands
(via mandos-ctl or mandos-monitor).  The next time the D-Bus daemon is
reloaded for any reason, the new user & group would become visible to
the D-Bus daemon and after that, any restart of the Mandos server
would succeed and it would bind to its D-Bus name properly, and
thereby be visible and controllable by mandos-ctl & mandos-monitor.
This was mostly invisible when using sysvinit, but systemd makes the
problem visible since the systemd service file for the Mandos server
is configured to not consider the Mandos server "started" until the
D-Bus name has been bound; this makes the starting of the service wait
for 90 seconds and then fail with a timeout error.

Fixing this should also make the Debian CI autopkgtest tests work.

* debian/mandos.postinst (configure): After creating (or renaming)
                                      user & group, reload D-Bus
                                      daemon (if present).

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,2009 Teddy Hogeborn
6
 
 * Copyright © 2008,2009 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-2019 Teddy Hogeborn
 
6
 * Copyright © 2008-2019 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
 
#include <unistd.h>             /* struct termios, tcsetattr(),
30
 
                                   STDIN_FILENO, TCSAFLUSH,
31
 
                                   tcgetattr(), ECHO */
 
30
#include <unistd.h>             /* access(), struct termios,
 
31
                                   tcsetattr(), STDIN_FILENO,
 
32
                                   TCSAFLUSH, tcgetattr(), ECHO,
 
33
                                   readlink() */
32
34
#include <signal.h>             /* sig_atomic_t, raise(), struct
33
35
                                   sigaction, sigemptyset(),
34
36
                                   sigaction(), sigaddset(), SIGINT,
35
37
                                   SIGQUIT, SIGHUP, SIGTERM,
36
38
                                   raise() */
37
39
#include <stddef.h>             /* NULL, size_t, ssize_t */
38
 
#include <sys/types.h>          /* ssize_t */
 
40
#include <sys/types.h>          /* ssize_t, struct dirent, pid_t,
 
41
                                   ssize_t, open() */
39
42
#include <stdlib.h>             /* EXIT_SUCCESS, EXIT_FAILURE,
40
 
                                   getenv() */
 
43
                                   getenv(), free() */
 
44
#include <dirent.h>             /* scandir(), alphasort() */
41
45
#include <stdio.h>              /* fprintf(), stderr, getline(),
42
 
                                   stdin, feof(), perror(), fputc()
43
 
                                */
 
46
                                   stdin, feof(), fputc(), vfprintf(),
 
47
                                   vasprintf() */
44
48
#include <errno.h>              /* errno, EBADF, ENOTTY, EINVAL,
45
49
                                   EFAULT, EFBIG, EIO, ENOSPC, EINTR
46
50
                                */
 
51
#include <error.h>              /* error() */
47
52
#include <iso646.h>             /* or, not */
48
53
#include <stdbool.h>            /* bool, false, true */
49
 
#include <string.h>             /* strlen, rindex, strncmp, strcmp */
 
54
#include <inttypes.h>           /* strtoumax() */
 
55
#include <sys/stat.h>           /* struct stat, lstat(), open() */
 
56
#include <string.h>             /* strlen, rindex, memcmp, strerror()
 
57
                                 */
50
58
#include <argp.h>               /* struct argp_option, struct
51
59
                                   argp_state, struct argp,
52
60
                                   argp_parse(), error_t,
54
62
                                   ARGP_ERR_UNKNOWN */
55
63
#include <sysexits.h>           /* EX_SOFTWARE, EX_OSERR,
56
64
                                   EX_UNAVAILABLE, EX_IOERR, EX_OK */
 
65
#include <fcntl.h>              /* open() */
 
66
#include <stdarg.h>             /* va_list, va_start(), ... */
57
67
 
58
68
volatile sig_atomic_t quit_now = 0;
59
69
int signal_received;
60
70
bool debug = false;
61
71
const char *argp_program_version = "password-prompt " VERSION;
62
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
 
72
const char *argp_program_bug_address = "<mandos@recompile.se>";
 
73
 
 
74
/* Needed for conflict resolution */
 
75
const char plymouth_name[] = "plymouthd";
 
76
 
 
77
/* Function to use when printing errors */
 
78
__attribute__((format (gnu_printf, 3, 4)))
 
79
void error_plus(int status, int errnum, const char *formatstring,
 
80
                ...){
 
81
  va_list ap;
 
82
  char *text;
 
83
  int ret;
 
84
  
 
85
  va_start(ap, formatstring);
 
86
  ret = vasprintf(&text, formatstring, ap);
 
87
  if(ret == -1){
 
88
    fprintf(stderr, "Mandos plugin %s: ",
 
89
            program_invocation_short_name);
 
90
    vfprintf(stderr, formatstring, ap);
 
91
    fprintf(stderr, ": %s\n", strerror(errnum));
 
92
    error(status, errno, "vasprintf while printing error");
 
93
    return;
 
94
  }
 
95
  fprintf(stderr, "Mandos plugin ");
 
96
  error(status, errnum, "%s", text);
 
97
  free(text);
 
98
}
63
99
 
64
100
static void termination_handler(int signum){
65
101
  if(quit_now){
69
105
  signal_received = signum;
70
106
}
71
107
 
 
108
bool conflict_detection(void){
 
109
 
 
110
  /* plymouth conflicts with password-prompt since both want to read
 
111
     from the terminal.  Password-prompt will exit if it detects
 
112
     plymouth since plymouth performs the same functionality.
 
113
   */
 
114
  if(access("/run/plymouth/pid", R_OK) == 0){
 
115
    return true;
 
116
  }
 
117
  
 
118
  __attribute__((nonnull))
 
119
  int is_plymouth(const struct dirent *proc_entry){
 
120
    int ret;
 
121
    int cl_fd;
 
122
    {
 
123
      uintmax_t proc_id;
 
124
      char *tmp;
 
125
      errno = 0;
 
126
      proc_id = strtoumax(proc_entry->d_name, &tmp, 10);
 
127
      
 
128
      if(errno != 0 or *tmp != '\0'
 
129
         or proc_id != (uintmax_t)((pid_t)proc_id)){
 
130
        return 0;
 
131
      }
 
132
    }
 
133
    
 
134
    char *cmdline_filename;
 
135
    ret = asprintf(&cmdline_filename, "/proc/%s/cmdline",
 
136
                   proc_entry->d_name);
 
137
    if(ret == -1){
 
138
      error_plus(0, errno, "asprintf");
 
139
      return 0;
 
140
    }
 
141
    
 
142
    /* Open /proc/<pid>/cmdline */
 
143
    cl_fd = open(cmdline_filename, O_RDONLY);
 
144
    free(cmdline_filename);
 
145
    if(cl_fd == -1){
 
146
      if(errno != ENOENT){
 
147
        error_plus(0, errno, "open");
 
148
      }
 
149
      return 0;
 
150
    }
 
151
    
 
152
    char *cmdline = NULL;
 
153
    {
 
154
      size_t cmdline_len = 0;
 
155
      size_t cmdline_allocated = 0;
 
156
      char *tmp;
 
157
      const size_t blocksize = 1024;
 
158
      ssize_t sret;
 
159
      do {
 
160
        /* Allocate more space? */
 
161
        if(cmdline_len + blocksize + 1 > cmdline_allocated){
 
162
          tmp = realloc(cmdline, cmdline_allocated + blocksize + 1);
 
163
          if(tmp == NULL){
 
164
            error_plus(0, errno, "realloc");
 
165
            free(cmdline);
 
166
            close(cl_fd);
 
167
            return 0;
 
168
          }
 
169
          cmdline = tmp;
 
170
          cmdline_allocated += blocksize;
 
171
        }
 
172
        
 
173
        /* Read data */
 
174
        sret = read(cl_fd, cmdline + cmdline_len,
 
175
                    cmdline_allocated - cmdline_len);
 
176
        if(sret == -1){
 
177
          error_plus(0, errno, "read");
 
178
          free(cmdline);
 
179
          close(cl_fd);
 
180
          return 0;
 
181
        }
 
182
        cmdline_len += (size_t)sret;
 
183
      } while(sret != 0);
 
184
      ret = close(cl_fd);
 
185
      if(ret == -1){
 
186
        error_plus(0, errno, "close");
 
187
        free(cmdline);
 
188
        return 0;
 
189
      }
 
190
      cmdline[cmdline_len] = '\0'; /* Make sure it is terminated */
 
191
    }
 
192
    /* we now have cmdline */
 
193
    
 
194
    /* get basename */
 
195
    char *cmdline_base = strrchr(cmdline, '/');
 
196
    if(cmdline_base != NULL){
 
197
      cmdline_base += 1;                /* skip the slash */
 
198
    } else {
 
199
      cmdline_base = cmdline;
 
200
    }
 
201
    
 
202
    if(strcmp(cmdline_base, plymouth_name) != 0){
 
203
      if(debug){
 
204
        fprintf(stderr, "\"%s\" is not \"%s\"\n", cmdline_base,
 
205
                plymouth_name);
 
206
      }
 
207
      free(cmdline);
 
208
      return 0;
 
209
    }
 
210
    if(debug){
 
211
      fprintf(stderr, "\"%s\" equals \"%s\"\n", cmdline_base,
 
212
              plymouth_name);
 
213
    }
 
214
    free(cmdline);
 
215
    return 1;
 
216
  }
 
217
  
 
218
  struct dirent **direntries = NULL;
 
219
  int ret;
 
220
  ret = scandir("/proc", &direntries, is_plymouth, alphasort);
 
221
  if(ret == -1){
 
222
    error_plus(1, errno, "scandir");
 
223
  }
 
224
  {
 
225
    int i = ret;
 
226
    while(i--){
 
227
      free(direntries[i]);
 
228
    }
 
229
  }
 
230
  free(direntries);
 
231
  return ret > 0;
 
232
}
 
233
 
 
234
 
72
235
int main(int argc, char **argv){
73
 
  ssize_t ret;
 
236
  ssize_t sret;
 
237
  int ret;
74
238
  size_t n;
75
239
  struct termios t_new, t_old;
76
240
  char *buffer = NULL;
77
241
  char *prefix = NULL;
 
242
  char *prompt = NULL;
78
243
  int status = EXIT_SUCCESS;
79
244
  struct sigaction old_action,
80
245
    new_action = { .sa_handler = termination_handler,
84
249
      { .name = "prefix", .key = 'p',
85
250
        .arg = "PREFIX", .flags = 0,
86
251
        .doc = "Prefix shown before the prompt", .group = 2 },
 
252
      { .name = "prompt", .key = 129,
 
253
        .arg = "PROMPT", .flags = 0,
 
254
        .doc = "The prompt to show", .group = 2 },
87
255
      { .name = "debug", .key = 128,
88
256
        .doc = "Debug mode", .group = 3 },
89
257
      /*
98
266
      { .name = NULL }
99
267
    };
100
268
    
 
269
    __attribute__((nonnull(3)))
101
270
    error_t parse_opt (int key, char *arg, struct argp_state *state){
102
271
      errno = 0;
103
272
      switch (key){
104
 
      case 'p':
 
273
      case 'p':                 /* --prefix */
105
274
        prefix = arg;
106
275
        break;
107
 
      case 128:
 
276
      case 128:                 /* --debug */
108
277
        debug = true;
109
278
        break;
 
279
      case 129:                 /* --prompt */
 
280
        prompt = arg;
 
281
        break;
110
282
        /*
111
283
         * These reproduce what we would get without ARGP_NO_HELP
112
284
         */
114
286
        argp_state_help(state, state->out_stream,
115
287
                        (ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
116
288
                        & ~(unsigned int)ARGP_HELP_EXIT_OK);
 
289
        __builtin_unreachable();
117
290
      case -3:                  /* --usage */
118
291
        argp_state_help(state, state->out_stream,
119
292
                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
 
293
        __builtin_unreachable();
120
294
      case 'V':                 /* --version */
121
295
        fprintf(state->out_stream, "%s\n", argp_program_version);
122
296
        exit(argp_err_exit_status);
139
313
    case ENOMEM:
140
314
    default:
141
315
      errno = ret;
142
 
      perror("argp_parse");
 
316
      error_plus(0, errno, "argp_parse");
143
317
      return EX_OSERR;
144
318
    case EINVAL:
145
319
      return EX_USAGE;
149
323
  if(debug){
150
324
    fprintf(stderr, "Starting %s\n", argv[0]);
151
325
  }
 
326
 
 
327
  if(conflict_detection()){
 
328
    if(debug){
 
329
      fprintf(stderr, "Stopping %s because of conflict\n", argv[0]);
 
330
    }
 
331
    return EXIT_FAILURE;
 
332
  }
 
333
  
152
334
  if(debug){
153
335
    fprintf(stderr, "Storing current terminal attributes\n");
154
336
  }
155
337
  
156
338
  if(tcgetattr(STDIN_FILENO, &t_old) != 0){
157
339
    int e = errno;
158
 
    perror("tcgetattr");
 
340
    error_plus(0, errno, "tcgetattr");
159
341
    switch(e){
160
342
    case EBADF:
161
343
    case ENOTTY:
168
350
  sigemptyset(&new_action.sa_mask);
169
351
  ret = sigaddset(&new_action.sa_mask, SIGINT);
170
352
  if(ret == -1){
171
 
    perror("sigaddset");
 
353
    error_plus(0, errno, "sigaddset");
172
354
    return EX_OSERR;
173
355
  }
174
356
  ret = sigaddset(&new_action.sa_mask, SIGHUP);
175
357
  if(ret == -1){
176
 
    perror("sigaddset");
 
358
    error_plus(0, errno, "sigaddset");
177
359
    return EX_OSERR;
178
360
  }
179
361
  ret = sigaddset(&new_action.sa_mask, SIGTERM);
180
362
  if(ret == -1){
181
 
    perror("sigaddset");
 
363
    error_plus(0, errno, "sigaddset");
182
364
    return EX_OSERR;
183
365
  }
184
366
  /* Need to check if the handler is SIG_IGN before handling:
187
369
  */
188
370
  ret = sigaction(SIGINT, NULL, &old_action);
189
371
  if(ret == -1){
190
 
    perror("sigaction");
 
372
    error_plus(0, errno, "sigaction");
191
373
    return EX_OSERR;
192
374
  }
193
375
  if(old_action.sa_handler != SIG_IGN){
194
376
    ret = sigaction(SIGINT, &new_action, NULL);
195
377
    if(ret == -1){
196
 
      perror("sigaction");
 
378
      error_plus(0, errno, "sigaction");
197
379
      return EX_OSERR;
198
380
    }
199
381
  }
200
382
  ret = sigaction(SIGHUP, NULL, &old_action);
201
383
  if(ret == -1){
202
 
    perror("sigaction");
 
384
    error_plus(0, errno, "sigaction");
203
385
    return EX_OSERR;
204
386
  }
205
387
  if(old_action.sa_handler != SIG_IGN){
206
388
    ret = sigaction(SIGHUP, &new_action, NULL);
207
389
    if(ret == -1){
208
 
      perror("sigaction");
 
390
      error_plus(0, errno, "sigaction");
209
391
      return EX_OSERR;
210
392
    }
211
393
  }
212
394
  ret = sigaction(SIGTERM, NULL, &old_action);
213
395
  if(ret == -1){
214
 
    perror("sigaction");
 
396
    error_plus(0, errno, "sigaction");
215
397
    return EX_OSERR;
216
398
  }
217
399
  if(old_action.sa_handler != SIG_IGN){
218
400
    ret = sigaction(SIGTERM, &new_action, NULL);
219
401
    if(ret == -1){
220
 
      perror("sigaction");
 
402
      error_plus(0, errno, "sigaction");
221
403
      return EX_OSERR;
222
404
    }
223
405
  }
231
413
  t_new.c_lflag &= ~(tcflag_t)ECHO;
232
414
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_new) != 0){
233
415
    int e = errno;
234
 
    perror("tcsetattr-echo");
 
416
    error_plus(0, errno, "tcsetattr-echo");
235
417
    switch(e){
236
418
    case EBADF:
237
419
    case ENOTTY:
257
439
    if(prefix){
258
440
      fprintf(stderr, "%s ", prefix);
259
441
    }
260
 
    {
 
442
    if(prompt != NULL){
 
443
      fprintf(stderr, "%s: ", prompt);
 
444
    } else {
261
445
      const char *cryptsource = getenv("CRYPTTAB_SOURCE");
262
446
      const char *crypttarget = getenv("CRYPTTAB_NAME");
263
447
      /* Before cryptsetup 1.1.0~rc2 */
286
470
        }
287
471
      }
288
472
    }
289
 
    ret = getline(&buffer, &n, stdin);
290
 
    if(ret > 0){
 
473
    sret = getline(&buffer, &n, stdin);
 
474
    if(sret > 0){
291
475
      status = EXIT_SUCCESS;
292
476
      /* Make n = data size instead of allocated buffer size */
293
 
      n = (size_t)ret;
 
477
      n = (size_t)sret;
294
478
      /* Strip final newline */
295
479
      if(n > 0 and buffer[n-1] == '\n'){
296
480
        buffer[n-1] = '\0';     /* not strictly necessary */
298
482
      }
299
483
      size_t written = 0;
300
484
      while(written < n){
301
 
        ret = write(STDOUT_FILENO, buffer + written, n - written);
302
 
        if(ret < 0){
 
485
        sret = write(STDOUT_FILENO, buffer + written, n - written);
 
486
        if(sret < 0){
303
487
          int e = errno;
304
 
          perror("write");
 
488
          error_plus(0, errno, "write");
305
489
          switch(e){
306
490
          case EBADF:
307
491
          case EFAULT:
318
502
          }
319
503
          break;
320
504
        }
321
 
        written += (size_t)ret;
 
505
        written += (size_t)sret;
322
506
      }
323
 
      ret = close(STDOUT_FILENO);
324
 
      if(ret == -1){
 
507
      sret = close(STDOUT_FILENO);
 
508
      if(sret == -1){
325
509
        int e = errno;
326
 
        perror("close");
 
510
        error_plus(0, errno, "close");
327
511
        switch(e){
328
512
        case EBADF:
329
513
          status = EX_OSFILE;
336
520
      }
337
521
      break;
338
522
    }
339
 
    if(ret < 0){
 
523
    if(sret < 0){
340
524
      int e = errno;
341
 
      if(errno != EINTR and not feof(stdin)){
342
 
        perror("getline");
343
 
        switch(e){
344
 
        case EBADF:
345
 
          status = EX_UNAVAILABLE;
346
 
        case EIO:
347
 
        case EINVAL:
348
 
        default:
349
 
          status = EX_IOERR;
 
525
      if(errno != EINTR){
 
526
        if(not feof(stdin)){
 
527
          error_plus(0, errno, "getline");
 
528
          switch(e){
 
529
          case EBADF:
 
530
            status = EX_UNAVAILABLE;
 
531
            break;
 
532
          case EIO:
 
533
          case EINVAL:
 
534
          default:
 
535
            status = EX_IOERR;
 
536
            break;
 
537
          }
350
538
          break;
 
539
        } else {
 
540
          clearerr(stdin);
351
541
        }
352
 
        break;
353
542
      }
354
543
    }
355
 
    /* if(ret == 0), then the only sensible thing to do is to retry to
356
 
       read from stdin */
 
544
    /* if(sret == 0), then the only sensible thing to do is to retry
 
545
       to read from stdin */
357
546
    fputc('\n', stderr);
358
547
    if(debug and not quit_now){
359
548
      /* If quit_now is nonzero, we were interrupted by a signal, and
368
557
    fprintf(stderr, "Restoring terminal attributes\n");
369
558
  }
370
559
  if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_old) != 0){
371
 
    perror("tcsetattr+echo");
 
560
    error_plus(0, errno, "tcsetattr+echo");
372
561
  }
373
562
  
374
563
  if(quit_now){
376
565
    old_action.sa_handler = SIG_DFL;
377
566
    ret = sigaction(signal_received, &old_action, NULL);
378
567
    if(ret == -1){
379
 
      perror("sigaction");
 
568
      error_plus(0, errno, "sigaction");
380
569
    }
381
570
    raise(signal_received);
382
571
  }