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

  • Committer: Björn Påhlsson
  • Date: 2008-07-20 02:52:20 UTC
  • Revision ID: belorn@braxen-20080720025220-r5u0388uy9iu23h6
Added following support:
Pluginbased client handler
rewritten Mandos client
       Avahi instead of udp server discovery
       openpgp encrypted key support
Passprompt stand alone application for direct console input
Added logging for Mandos server

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