/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: Teddy Hogeborn
  • Date: 2024-09-09 01:36:41 UTC
  • Revision ID: teddy@recompile.se-20240909013641-6zu6kx2f7meu134k
Make all required directories when installing

When installing into a normal system, one can assume that target
directories, such as /usr/bin, already exists.  But when installing
into a subdirectory for the purpose of creating a package, one cannot
assume that all directories already exist.  Therefore, when
installing, we must not check if any directories exist, and must
instead always create any directories we want to install into.

* Makefile (confdir/mandos.conf, confdir/clients.conf, install-html):
  Use the "-D" option to "install" instead of creating the directory
  separately.
  (install-server): Move creation of $(CONFDIR) down to before it is
  needed.  Don't check if the $(TMPFILES) or $(SYSUSERS) directories
  exist; instead create them by using the "-D" option to "install".
  Create the $(PREFIX)/sbin directory.  Always use
  "--target-directory" if possible; i.e. if the file name is the same.
  Create the $(DBUSPOLICYDIR) and $(DESTDIR)/etc/init.d directories by
  using the "-D" option to "install".  Don't check if the $(SYSTEMD)
  directory exists; instead create it by using the "-D" option to
  "install".  Create the $(DESTDIR)/etc/default and $(MANDIR)/man8
  directories by using the "-D" option to "install".  Create the
  $(MANDIR)/man5 directories explicitly.
  (install-client-nokey): Remove unnecessary creation of the
  $(CONFDIR) directory.  Don't check if the $(SYSUSERS) directory
  exists; instead create it by using the "-D" option to "install".
  Move the "--directory" argument to be the first argument, for
  clarity.  Create the $(PREFIX)/sbin directory.  Use the "-D"
  argument to "install" when installing
  $(INITRAMFSTOOLS)/hooks/mandos,
  $(INITRAMFSTOOLS)/conf.d/mandos-conf,
  $(INITRAMFSTOOLS)/conf-hooks.d/zz-mandos,
  $(INITRAMFSTOOLS)/scripts/init-premount/mandos,
  $(INITRAMFSTOOLS)/scripts/local-premount/mandos,
  $(DRACUTMODULE)/ask-password-mandos.path, and
  $(DRACUTMODULE)/dracut-module/ask-password-mandos.service.  Create
  the $(MANDIR)/man8 directory.

Reported-By: Erich Eckner <erich@eckner.net>
Thanks: Erich Eckner <erich@eckner.net> for analysis

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/askpass-fifo.c
 
1
/*  -*- coding: utf-8 -*- */
 
2
/*
 
3
 * Askpass-FIFO - Read a password from a FIFO and output it
 
4
 * 
 
5
 * Copyright © 2008-2019, 2021 Teddy Hogeborn
 
6
 * Copyright © 2008-2019, 2021 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
}