/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: 2015-03-10 18:03:38 UTC
  • mto: (237.7.304 trunk)
  • mto: This revision was merged to the branch mainline in revision 325.
  • Revision ID: teddy@recompile.se-20150310180338-pcxw6r2qmw9k6br9
Add ":!RSA" to GnuTLS priority string, to disallow non-DHE kx.

If Mandos was somehow made to use a non-ephemeral Diffie-Hellman key
exchange algorithm in the TLS handshake, any saved network traffic
could then be decrypted later if the Mandos client key was obtained.
By default, Mandos uses ephemeral DH key exchanges which does not have
this problem, but a non-ephemeral key exchange algorithm was still
enabled by default.  The simplest solution is to simply turn that off,
which ensures that Mandos will always use ephemeral DH key exchanges.

There is a "PFS" priority string specifier, but we can't use it because:

1. Security-wise, it is a mix between "NORMAL" and "SECURE128" - it
   enables a lot more algorithms than "SECURE256".

2. It is only available since GnuTLS 3.2.4.

Thanks to Andreas Fischer <af@bantuX.org> for reporting this issue.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/*  -*- coding: utf-8 -*- */
 
2
/*
 
3
 * Askpass-FIFO - Read a password from a FIFO and output it
 
4
 * 
 
5
 * Copyright © 2008-2014 Teddy Hogeborn
 
6
 * Copyright © 2008-2014 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
 
14
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
16
 * General Public License for more details.
 
17
 * 
 
18
 * 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
 * 
 
22
 * Contact the authors at <mandos@recompile.se>.
 
23
 */
 
24
 
 
25
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY() */
 
26
#include <sys/types.h>          /* uid_t, gid_t, ssize_t */
 
27
#include <sys/stat.h>           /* mkfifo(), S_IRUSR, S_IWUSR */
 
28
#include <iso646.h>             /* and */
 
29
#include <errno.h>              /* errno, EACCES, ENOTDIR, ELOOP,
 
30
                                   ENAMETOOLONG, ENOSPC, EROFS,
 
31
                                   ENOENT, EEXIST, EFAULT, EMFILE,
 
32
                                   ENFILE, ENOMEM, EBADF, EINVAL, EIO,
 
33
                                   EISDIR, EFBIG */
 
34
#include <error.h>              /* error() */
 
35
#include <stdio.h>              /* fprintf(), vfprintf(),
 
36
                                   vasprintf() */
 
37
#include <stdlib.h>             /* EXIT_FAILURE, NULL, size_t, free(),
 
38
                                   realloc(), EXIT_SUCCESS */
 
39
#include <fcntl.h>              /* open(), O_RDONLY */
 
40
#include <unistd.h>             /* read(), close(), write(),
 
41
                                   STDOUT_FILENO */
 
42
#include <sysexits.h>           /* EX_OSERR, EX_OSFILE,
 
43
                                   EX_UNAVAILABLE, EX_IOERR */
 
44
#include <string.h>             /* strerror() */
 
45
#include <stdarg.h>             /* va_list, va_start(), ... */
 
46
 
 
47
uid_t uid = 65534;
 
48
gid_t gid = 65534;
 
49
 
 
50
/* Function to use when printing errors */
 
51
__attribute__((format (gnu_printf, 3, 4)))
 
52
void error_plus(int status, int errnum, const char *formatstring,
 
53
                ...){
 
54
  va_list ap;
 
55
  char *text;
 
56
  int ret;
 
57
  
 
58
  va_start(ap, formatstring);
 
59
  ret = vasprintf(&text, formatstring, ap);
 
60
  if(ret == -1){
 
61
    fprintf(stderr, "Mandos plugin %s: ",
 
62
            program_invocation_short_name);
 
63
    vfprintf(stderr, formatstring, ap);
 
64
    fprintf(stderr, ": ");
 
65
    fprintf(stderr, "%s\n", strerror(errnum));
 
66
    error(status, errno, "vasprintf while printing error");
 
67
    return;
 
68
  }
 
69
  fprintf(stderr, "Mandos plugin ");
 
70
  error(status, errnum, "%s", text);
 
71
  free(text);
 
72
}
 
73
 
 
74
int main(__attribute__((unused))int argc,
 
75
         __attribute__((unused))char **argv){
 
76
  int ret = 0;
 
77
  ssize_t sret;
 
78
  
 
79
  uid = getuid();
 
80
  gid = getgid();
 
81
  
 
82
  /* Create FIFO */
 
83
  const char passfifo[] = "/lib/cryptsetup/passfifo";
 
84
  ret = mkfifo(passfifo, S_IRUSR | S_IWUSR);
 
85
  if(ret == -1){
 
86
    int e = errno;
 
87
    switch(e){
 
88
    case EACCES:
 
89
    case ENOTDIR:
 
90
    case ELOOP:
 
91
      error_plus(EX_OSFILE, errno, "mkfifo");
 
92
    case ENAMETOOLONG:
 
93
    case ENOSPC:
 
94
    case EROFS:
 
95
    default:
 
96
      error_plus(EX_OSERR, errno, "mkfifo");
 
97
    case ENOENT:
 
98
      /* no "/lib/cryptsetup"? */
 
99
      error_plus(EX_UNAVAILABLE, errno, "mkfifo");
 
100
    case EEXIST:
 
101
      break;                    /* not an error */
 
102
    }
 
103
  }
 
104
  
 
105
  /* Open FIFO */
 
106
  int fifo_fd = open(passfifo, O_RDONLY);
 
107
  if(fifo_fd == -1){
 
108
    int e = errno;
 
109
    error_plus(0, errno, "open");
 
110
    switch(e){
 
111
    case EACCES:
 
112
    case ENOENT:
 
113
    case EFAULT:
 
114
      return EX_UNAVAILABLE;
 
115
    case ENAMETOOLONG:
 
116
    case EMFILE:
 
117
    case ENFILE:
 
118
    case ENOMEM:
 
119
    default:
 
120
      return EX_OSERR;
 
121
    case ENOTDIR:
 
122
    case ELOOP:
 
123
      return EX_OSFILE;
 
124
    }
 
125
  }
 
126
  
 
127
  /* Lower group privileges  */
 
128
  if(setgid(gid) == -1){
 
129
    error_plus(0, errno, "setgid");
 
130
  }
 
131
  
 
132
  /* Lower user privileges */
 
133
  if(setuid(uid) == -1){
 
134
    error_plus(0, errno, "setuid");
 
135
  }
 
136
  
 
137
  /* Read from FIFO */
 
138
  char *buf = NULL;
 
139
  size_t buf_len = 0;
 
140
  {
 
141
    size_t buf_allocated = 0;
 
142
    const size_t blocksize = 1024;
 
143
    do {
 
144
      if(buf_len + blocksize > buf_allocated){
 
145
        char *tmp = realloc(buf, buf_allocated + blocksize);
 
146
        if(tmp == NULL){
 
147
          error_plus(0, errno, "realloc");
 
148
          free(buf);
 
149
          return EX_OSERR;
 
150
        }
 
151
        buf = tmp;
 
152
        buf_allocated += blocksize;
 
153
      }
 
154
      sret = read(fifo_fd, buf + buf_len, buf_allocated - buf_len);
 
155
      if(sret == -1){
 
156
        int e = errno;
 
157
        free(buf);
 
158
        errno = e;
 
159
        error_plus(0, errno, "read");
 
160
        switch(e){
 
161
        case EBADF:
 
162
        case EFAULT:
 
163
        case EINVAL:
 
164
        default:
 
165
          return EX_OSERR;
 
166
        case EIO:
 
167
          return EX_IOERR;
 
168
        case EISDIR:
 
169
          return EX_UNAVAILABLE;
 
170
        }
 
171
      }
 
172
      buf_len += (size_t)sret;
 
173
    } while(sret != 0);
 
174
  }
 
175
  
 
176
  /* Close FIFO */
 
177
  close(fifo_fd);
 
178
  
 
179
  /* Print password to stdout */
 
180
  size_t written = 0;
 
181
  while(written < buf_len){
 
182
    sret = write(STDOUT_FILENO, buf + written, buf_len - written);
 
183
    if(sret == -1){
 
184
      int e = errno;
 
185
      free(buf);
 
186
      errno = e;
 
187
      error_plus(0, errno, "write");
 
188
      switch(e){
 
189
      case EBADF:
 
190
      case EFAULT:
 
191
      case EINVAL:
 
192
        return EX_OSFILE;
 
193
      case EFBIG:
 
194
      case EIO:
 
195
      case ENOSPC:
 
196
      default:
 
197
        return EX_IOERR;
 
198
      }
 
199
    }
 
200
    written += (size_t)sret;
 
201
  }
 
202
  free(buf);
 
203
  
 
204
  ret = close(STDOUT_FILENO);
 
205
  if(ret == -1){
 
206
    int e = errno;
 
207
    error_plus(0, errno, "close");
 
208
    switch(e){
 
209
    case EBADF:
 
210
      return EX_OSFILE;
 
211
    case EIO:
 
212
    default:
 
213
      return EX_IOERR;
 
214
    }
 
215
  }
 
216
  return EXIT_SUCCESS;
 
217
}