/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/askpass-fifo.c

  • Committer: Teddy Hogeborn
  • Date: 2019-07-14 22:39:15 UTC
  • mto: This revision was merged to the branch mainline in revision 384.
  • Revision ID: teddy@recompile.se-20190714223915-aqjkms3t3taa6tye
Only use sanitizing options when debugging

The C compiler's sanitizing options introduce code in the output
binary which is fragile and not very security conscious.  It has
become clear that sanitizing is only really meant for use while
debugging.

As a side effect, this makes compilation faster, as the Makefile, for
production builds, no longer runs the compiler repeatedly to find all
its currently supported sanitizing options.

* Makefile (DEBUG): Add "$(SANITIZE)".
  (SANITIZE): Comment out.
  (CFLAGS): Remove "$(SANITIZE)".
  (plugins.d/mandos-client): Revert back to use plain $(LINK.c), since
                             we no longer need to remove the leak
                             sanitizer by overriding CFLAGS.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/askpass-fifo.c
2
2
/*
3
3
 * Askpass-FIFO - Read a password from a FIFO and output 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
26
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY() */
26
 
#include <sys/types.h>          /* ssize_t */
 
27
#include <sys/types.h>          /* uid_t, gid_t, ssize_t */
27
28
#include <sys/stat.h>           /* mkfifo(), S_IRUSR, S_IWUSR */
28
29
#include <iso646.h>             /* and */
29
30
#include <errno.h>              /* errno, EACCES, ENOTDIR, ELOOP,
31
32
                                   ENOENT, EEXIST, EFAULT, EMFILE,
32
33
                                   ENFILE, ENOMEM, EBADF, EINVAL, EIO,
33
34
                                   EISDIR, EFBIG */
34
 
#include <stdio.h>              /* perror() */
 
35
#include <error.h>              /* error() */
 
36
#include <stdio.h>              /* fprintf(), vfprintf(),
 
37
                                   vasprintf() */
35
38
#include <stdlib.h>             /* EXIT_FAILURE, NULL, size_t, free(),
36
39
                                   realloc(), EXIT_SUCCESS */
37
40
#include <fcntl.h>              /* open(), O_RDONLY */
39
42
                                   STDOUT_FILENO */
40
43
#include <sysexits.h>           /* EX_OSERR, EX_OSFILE,
41
44
                                   EX_UNAVAILABLE, EX_IOERR */
42
 
 
 
45
#include <string.h>             /* strerror() */
 
46
#include <stdarg.h>             /* va_list, va_start(), ... */
 
47
 
 
48
uid_t uid = 65534;
 
49
gid_t gid = 65534;
 
50
 
 
51
/* Function to use when printing errors */
 
52
__attribute__((format (gnu_printf, 3, 4)))
 
53
void error_plus(int status, int errnum, const char *formatstring,
 
54
                ...){
 
55
  va_list ap;
 
56
  char *text;
 
57
  int ret;
 
58
  
 
59
  va_start(ap, formatstring);
 
60
  ret = vasprintf(&text, formatstring, ap);
 
61
  if(ret == -1){
 
62
    fprintf(stderr, "Mandos plugin %s: ",
 
63
            program_invocation_short_name);
 
64
    vfprintf(stderr, formatstring, ap);
 
65
    fprintf(stderr, ": ");
 
66
    fprintf(stderr, "%s\n", strerror(errnum));
 
67
    error(status, errno, "vasprintf while printing error");
 
68
    if(status){
 
69
      __builtin_unreachable();
 
70
    }
 
71
    return;
 
72
  }
 
73
  fprintf(stderr, "Mandos plugin ");
 
74
  error(status, errnum, "%s", text);
 
75
  if(status){
 
76
    __builtin_unreachable();
 
77
  }
 
78
  free(text);
 
79
}
43
80
 
44
81
int main(__attribute__((unused))int argc,
45
82
         __attribute__((unused))char **argv){
46
83
  int ret = 0;
47
84
  ssize_t sret;
48
85
  
 
86
  uid = getuid();
 
87
  gid = getgid();
 
88
  
49
89
  /* Create FIFO */
50
90
  const char passfifo[] = "/lib/cryptsetup/passfifo";
51
91
  ret = mkfifo(passfifo, S_IRUSR | S_IWUSR);
52
92
  if(ret == -1){
53
93
    int e = errno;
54
 
    perror("mkfifo");
55
94
    switch(e){
56
95
    case EACCES:
57
96
    case ENOTDIR:
58
97
    case ELOOP:
59
 
      return EX_OSFILE;
 
98
      error_plus(EX_OSFILE, errno, "mkfifo");
 
99
      __builtin_unreachable();
60
100
    case ENAMETOOLONG:
61
101
    case ENOSPC:
62
102
    case EROFS:
63
103
    default:
64
 
      return EX_OSERR;
 
104
      error_plus(EX_OSERR, errno, "mkfifo");
 
105
      __builtin_unreachable();
65
106
    case ENOENT:
66
 
      return EX_UNAVAILABLE;    /* no "/lib/cryptsetup"? */
 
107
      /* no "/lib/cryptsetup"? */
 
108
      error_plus(EX_UNAVAILABLE, errno, "mkfifo");
 
109
      __builtin_unreachable();
67
110
    case EEXIST:
68
111
      break;                    /* not an error */
69
112
    }
73
116
  int fifo_fd = open(passfifo, O_RDONLY);
74
117
  if(fifo_fd == -1){
75
118
    int e = errno;
76
 
    perror("open");
 
119
    error_plus(0, errno, "open");
77
120
    switch(e){
78
121
    case EACCES:
79
122
    case ENOENT:
91
134
    }
92
135
  }
93
136
  
 
137
  /* Lower group privileges  */
 
138
  if(setgid(gid) == -1){
 
139
    error_plus(0, errno, "setgid");
 
140
  }
 
141
  
 
142
  /* Lower user privileges */
 
143
  if(setuid(uid) == -1){
 
144
    error_plus(0, errno, "setuid");
 
145
  }
 
146
  
94
147
  /* Read from FIFO */
95
148
  char *buf = NULL;
96
149
  size_t buf_len = 0;
101
154
      if(buf_len + blocksize > buf_allocated){
102
155
        char *tmp = realloc(buf, buf_allocated + blocksize);
103
156
        if(tmp == NULL){
104
 
          perror("realloc");
 
157
          error_plus(0, errno, "realloc");
105
158
          free(buf);
106
159
          return EX_OSERR;
107
160
        }
113
166
        int e = errno;
114
167
        free(buf);
115
168
        errno = e;
116
 
        perror("read");
 
169
        error_plus(0, errno, "read");
117
170
        switch(e){
118
171
        case EBADF:
119
172
        case EFAULT:
141
194
      int e = errno;
142
195
      free(buf);
143
196
      errno = e;
144
 
      perror("write");
 
197
      error_plus(0, errno, "write");
145
198
      switch(e){
146
199
      case EBADF:
147
200
      case EFAULT:
161
214
  ret = close(STDOUT_FILENO);
162
215
  if(ret == -1){
163
216
    int e = errno;
164
 
    perror("close");
 
217
    error_plus(0, errno, "close");
165
218
    switch(e){
166
219
    case EBADF:
167
220
      return EX_OSFILE;