/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/splashy.c

  • Committer: teddy at recompile
  • Date: 2020-12-03 20:30:45 UTC
  • Revision ID: teddy@recompile.se-20201203203045-iqd6nq9y5nwalh1x
Minor fix of a test function

In dracut-module/password-agent, the test function
test_send_password_to_socket_EMSGSIZE() (which tests that the
send_password_to_socket() task function aborts properly when getting
EMSGSIZE when writing to the password socket), part of the test code
is supposed to find a message size which definitely does trigger
EMSGSIZE when send()ing to a socket.  Without a "break" in the proper
place, however, the size given is always exactly 1024 bytes too large.

This is very probably not a problem, since a too large message will
still be too large if it is increased by 1024 bytes, and send(2) in
practice checks the size before reading the buffer.  The biggest issue
would be if some version of send(2) would try to look at the last 1024
bytes of the message buffer before checking the message size; this
would then lead to a buffer over-read when running this test function.
(But even then there would be no security implications since the tests
are not run in the normal operation of the program.)

* dracut-module/password-agent.c
  (test_send_password_to_socket_EMSGSIZE): Break out early when ssret
  < 0 and errno == EMSGSIZE; don't allow loop to increase message_size
  again.

Show diffs side-by-side

added added

removed removed

Lines of Context:
2
2
/*
3
3
 * Splashy - Read a password from splashy 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-2018 Teddy Hogeborn
 
6
 * Copyright © 2008-2018 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 <https://www.fukt.bsnet.se/~belorn/> and
23
 
 * <https://www.fukt.bsnet.se/~teddy/>.
 
23
 * Contact the authors at <mandos@recompile.se>.
24
24
 */
25
25
 
26
 
#define _GNU_SOURCE             /* asprintf() */
 
26
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), asprintf() */
27
27
#include <signal.h>             /* sig_atomic_t, struct sigaction,
28
28
                                   sigemptyset(), sigaddset(), SIGINT,
29
29
                                   SIGHUP, SIGTERM, sigaction,
30
30
                                   SIG_IGN, kill(), SIGKILL */
31
31
#include <stddef.h>             /* NULL */
32
32
#include <stdlib.h>             /* getenv() */
33
 
#include <stdio.h>              /* asprintf(), perror() */
 
33
#include <stdio.h>              /* asprintf(), vasprintf(), vprintf(),
 
34
                                   fprintf() */
34
35
#include <stdlib.h>             /* EXIT_FAILURE, free(),
35
36
                                   EXIT_SUCCESS */
36
37
#include <sys/types.h>          /* pid_t, DIR, struct dirent,
41
42
#include <iso646.h>             /* not, or, and */
42
43
#include <unistd.h>             /* readlink(), fork(), execl(),
43
44
                                   sleep(), dup2() STDERR_FILENO,
44
 
                                   STDOUT_FILENO, _exit() */
45
 
#include <string.h>             /* memcmp() */
46
 
#include <errno.h>              /* errno */
 
45
                                   STDOUT_FILENO, _exit(),
 
46
                                   pause() */
 
47
#include <string.h>             /* memcmp(), strerror() */
 
48
#include <errno.h>              /* errno, EACCES, ENOTDIR, ELOOP,
 
49
                                   ENOENT, ENAMETOOLONG, EMFILE,
 
50
                                   ENFILE, ENOMEM, ENOEXEC, EINVAL,
 
51
                                   E2BIG, EFAULT, EIO, ETXTBSY,
 
52
                                   EISDIR, ELIBBAD, EPERM, EINTR,
 
53
                                   ECHILD */
 
54
#include <error.h>              /* error() */
47
55
#include <sys/wait.h>           /* waitpid(), WIFEXITED(),
48
56
                                   WEXITSTATUS() */
 
57
#include <sysexits.h>           /* EX_OSERR, EX_OSFILE,
 
58
                                   EX_UNAVAILABLE */
 
59
#include <stdarg.h>             /* va_list, va_start(), ... */
49
60
 
50
61
sig_atomic_t interrupted_by_signal = 0;
51
 
 
52
 
static void termination_handler(__attribute__((unused))int signum){
 
62
int signal_received;
 
63
 
 
64
/* Function to use when printing errors */
 
65
__attribute__((format (gnu_printf, 3, 4)))
 
66
void error_plus(int status, int errnum, const char *formatstring,
 
67
                ...){
 
68
  va_list ap;
 
69
  char *text;
 
70
  int ret;
 
71
  
 
72
  va_start(ap, formatstring);
 
73
  ret = vasprintf(&text, formatstring, ap);
 
74
  if(ret == -1){
 
75
    fprintf(stderr, "Mandos plugin %s: ",
 
76
            program_invocation_short_name);
 
77
    vfprintf(stderr, formatstring, ap);
 
78
    fprintf(stderr, ": ");
 
79
    fprintf(stderr, "%s\n", strerror(errnum));
 
80
    error(status, errno, "vasprintf while printing error");
 
81
    return;
 
82
  }
 
83
  fprintf(stderr, "Mandos plugin ");
 
84
  error(status, errnum, "%s", text);
 
85
  free(text);
 
86
}
 
87
 
 
88
 
 
89
static void termination_handler(int signum){
 
90
  if(interrupted_by_signal){
 
91
    return;
 
92
  }
53
93
  interrupted_by_signal = 1;
 
94
  signal_received = signum;
54
95
}
55
96
 
56
97
int main(__attribute__((unused))int argc,
57
98
         __attribute__((unused))char **argv){
58
99
  int ret = 0;
 
100
  char *prompt = NULL;
 
101
  DIR *proc_dir = NULL;
 
102
  pid_t splashy_pid = 0;
 
103
  pid_t splashy_command_pid = 0;
 
104
  int exitstatus = EXIT_FAILURE;
59
105
  
60
106
  /* Create prompt string */
61
 
  char *prompt = NULL;
62
107
  {
63
108
    const char *const cryptsource = getenv("cryptsource");
64
109
    const char *const crypttarget = getenv("crypttarget");
81
126
      }
82
127
    }
83
128
    if(ret == -1){
84
 
      return EXIT_FAILURE;
 
129
      prompt = NULL;
 
130
      exitstatus = EX_OSERR;
 
131
      goto failure;
85
132
    }
86
133
  }
87
134
  
88
135
  /* Find splashy process */
89
 
  pid_t splashy_pid = 0;
90
136
  {
91
137
    const char splashy_name[] = "/sbin/splashy";
92
 
    DIR *proc_dir = opendir("/proc");
 
138
    proc_dir = opendir("/proc");
93
139
    if(proc_dir == NULL){
94
 
      free(prompt);
95
 
      perror("opendir");
96
 
      return EXIT_FAILURE;
 
140
      int e = errno;
 
141
      error_plus(0, errno, "opendir");
 
142
      switch(e){
 
143
      case EACCES:
 
144
      case ENOTDIR:
 
145
      case ELOOP:
 
146
      case ENOENT:
 
147
      default:
 
148
        exitstatus = EX_OSFILE;
 
149
        break;
 
150
      case ENAMETOOLONG:
 
151
      case EMFILE:
 
152
      case ENFILE:
 
153
      case ENOMEM:
 
154
        exitstatus = EX_OSERR;
 
155
        break;
 
156
      }
 
157
      goto failure;
97
158
    }
98
159
    for(struct dirent *proc_ent = readdir(proc_dir);
99
160
        proc_ent != NULL;
119
180
        char *exe_link;
120
181
        ret = asprintf(&exe_link, "/proc/%s/exe", proc_ent->d_name);
121
182
        if(ret == -1){
122
 
          perror("asprintf");
123
 
          free(prompt);
124
 
          closedir(proc_dir);
125
 
          return EXIT_FAILURE;
 
183
          error_plus(0, errno, "asprintf");
 
184
          exitstatus = EX_OSERR;
 
185
          goto failure;
126
186
        }
127
187
        
128
188
        /* Check that it refers to a symlink owned by root:root */
133
193
            free(exe_link);
134
194
            continue;
135
195
          }
136
 
          perror("lstat");
 
196
          int e = errno;
 
197
          error_plus(0, errno, "lstat");
137
198
          free(exe_link);
138
 
          free(prompt);
139
 
          closedir(proc_dir);
140
 
          return EXIT_FAILURE;
 
199
          switch(e){
 
200
          case EACCES:
 
201
          case ENOTDIR:
 
202
          case ELOOP:
 
203
          default:
 
204
            exitstatus = EX_OSFILE;
 
205
            break;
 
206
          case ENAMETOOLONG:
 
207
            exitstatus = EX_OSERR;
 
208
            break;
 
209
          }
 
210
          goto failure;
141
211
        }
142
212
        if(not S_ISLNK(exe_stat.st_mode)
143
213
           or exe_stat.st_uid != 0
157
227
      }
158
228
    }
159
229
    closedir(proc_dir);
 
230
    proc_dir = NULL;
160
231
  }
161
232
  if(splashy_pid == 0){
162
 
    free(prompt);
163
 
    return EXIT_FAILURE;
 
233
    exitstatus = EX_UNAVAILABLE;
 
234
    goto failure;
164
235
  }
165
236
  
166
237
  /* Set up the signal handler */
169
240
      new_action = { .sa_handler = termination_handler,
170
241
                     .sa_flags = 0 };
171
242
    sigemptyset(&new_action.sa_mask);
172
 
    sigaddset(&new_action.sa_mask, SIGINT);
173
 
    sigaddset(&new_action.sa_mask, SIGHUP);
174
 
    sigaddset(&new_action.sa_mask, SIGTERM);
 
243
    ret = sigaddset(&new_action.sa_mask, SIGINT);
 
244
    if(ret == -1){
 
245
      error_plus(0, errno, "sigaddset");
 
246
      exitstatus = EX_OSERR;
 
247
      goto failure;
 
248
    }
 
249
    ret = sigaddset(&new_action.sa_mask, SIGHUP);
 
250
    if(ret == -1){
 
251
      error_plus(0, errno, "sigaddset");
 
252
      exitstatus = EX_OSERR;
 
253
      goto failure;
 
254
    }
 
255
    ret = sigaddset(&new_action.sa_mask, SIGTERM);
 
256
    if(ret == -1){
 
257
      error_plus(0, errno, "sigaddset");
 
258
      exitstatus = EX_OSERR;
 
259
      goto failure;
 
260
    }
175
261
    ret = sigaction(SIGINT, NULL, &old_action);
176
262
    if(ret == -1){
177
 
      perror("sigaction");
178
 
      free(prompt);
179
 
      return EXIT_FAILURE;
 
263
      error_plus(0, errno, "sigaction");
 
264
      exitstatus = EX_OSERR;
 
265
      goto failure;
180
266
    }
181
267
    if(old_action.sa_handler != SIG_IGN){
182
268
      ret = sigaction(SIGINT, &new_action, NULL);
183
269
      if(ret == -1){
184
 
        perror("sigaction");
185
 
        free(prompt);
186
 
        return EXIT_FAILURE;
 
270
        error_plus(0, errno, "sigaction");
 
271
        exitstatus = EX_OSERR;
 
272
        goto failure;
187
273
      }
188
274
    }
189
275
    ret = sigaction(SIGHUP, NULL, &old_action);
190
276
    if(ret == -1){
191
 
      perror("sigaction");
192
 
      free(prompt);
193
 
      return EXIT_FAILURE;
 
277
      error_plus(0, errno, "sigaction");
 
278
      exitstatus = EX_OSERR;
 
279
      goto failure;
194
280
    }
195
281
    if(old_action.sa_handler != SIG_IGN){
196
282
      ret = sigaction(SIGHUP, &new_action, NULL);
197
283
      if(ret == -1){
198
 
        perror("sigaction");
199
 
        free(prompt);
200
 
        return EXIT_FAILURE;
 
284
        error_plus(0, errno, "sigaction");
 
285
        exitstatus = EX_OSERR;
 
286
        goto failure;
201
287
      }
202
288
    }
203
289
    ret = sigaction(SIGTERM, NULL, &old_action);
204
290
    if(ret == -1){
205
 
      perror("sigaction");
206
 
      free(prompt);
207
 
      return EXIT_FAILURE;
 
291
      error_plus(0, errno, "sigaction");
 
292
      exitstatus = EX_OSERR;
 
293
      goto failure;
208
294
    }
209
295
    if(old_action.sa_handler != SIG_IGN){
210
296
      ret = sigaction(SIGTERM, &new_action, NULL);
211
297
      if(ret == -1){
212
 
        perror("sigaction");
213
 
        free(prompt);
214
 
        return EXIT_FAILURE;
 
298
        error_plus(0, errno, "sigaction");
 
299
        exitstatus = EX_OSERR;
 
300
        goto failure;
215
301
      }
216
302
    }
217
303
  }
218
304
  
 
305
  if(interrupted_by_signal){
 
306
    goto failure;
 
307
  }
 
308
  
219
309
  /* Fork off the splashy command to prompt for password */
220
 
  pid_t splashy_command_pid = 0;
221
 
  if(not interrupted_by_signal){
222
 
    splashy_command_pid = fork();
223
 
    if(splashy_command_pid == -1){
224
 
      if(not interrupted_by_signal){
225
 
        perror("fork");
226
 
      }
227
 
      return EXIT_FAILURE;
228
 
    }
229
 
    /* Child */
230
 
    if(splashy_command_pid == 0){
 
310
  splashy_command_pid = fork();
 
311
  if(splashy_command_pid != 0 and interrupted_by_signal){
 
312
    goto failure;
 
313
  }
 
314
  if(splashy_command_pid == -1){
 
315
    error_plus(0, errno, "fork");
 
316
    exitstatus = EX_OSERR;
 
317
    goto failure;
 
318
  }
 
319
  /* Child */
 
320
  if(splashy_command_pid == 0){
 
321
    if(not interrupted_by_signal){
231
322
      const char splashy_command[] = "/sbin/splashy_update";
232
 
      ret = execl(splashy_command, splashy_command, prompt,
233
 
                  (char *)NULL);
234
 
      if(not interrupted_by_signal){
235
 
        perror("execl");
 
323
      execl(splashy_command, splashy_command, prompt, (char *)NULL);
 
324
      int e = errno;
 
325
      error_plus(0, errno, "execl");
 
326
      switch(e){
 
327
      case EACCES:
 
328
      case ENOENT:
 
329
      case ENOEXEC:
 
330
      case EINVAL:
 
331
        _exit(EX_UNAVAILABLE);
 
332
      case ENAMETOOLONG:
 
333
      case E2BIG:
 
334
      case ENOMEM:
 
335
      case EFAULT:
 
336
      case EIO:
 
337
      case EMFILE:
 
338
      case ENFILE:
 
339
      case ETXTBSY:
 
340
      default:
 
341
        _exit(EX_OSERR);
 
342
      case ENOTDIR:
 
343
      case ELOOP:
 
344
      case EISDIR:
 
345
#ifdef ELIBBAD
 
346
      case ELIBBAD:             /* Linux only */
 
347
#endif
 
348
      case EPERM:
 
349
        _exit(EX_OSFILE);
236
350
      }
237
 
      free(prompt);
238
 
      _exit(EXIT_FAILURE);
239
351
    }
 
352
    free(prompt);
 
353
    _exit(EXIT_FAILURE);
240
354
  }
241
355
  
242
356
  /* Parent */
243
357
  free(prompt);
 
358
  prompt = NULL;
 
359
  
 
360
  if(interrupted_by_signal){
 
361
    goto failure;
 
362
  }
244
363
  
245
364
  /* Wait for command to complete */
246
 
  if(not interrupted_by_signal and splashy_command_pid != 0){
 
365
  {
247
366
    int status;
248
 
    ret = waitpid(splashy_command_pid, &status, 0);
 
367
    do {
 
368
      ret = waitpid(splashy_command_pid, &status, 0);
 
369
    } while(ret == -1 and errno == EINTR
 
370
            and not interrupted_by_signal);
 
371
    if(interrupted_by_signal){
 
372
      goto failure;
 
373
    }
249
374
    if(ret == -1){
250
 
      if(errno != EINTR){
251
 
        perror("waitpid");
252
 
      }
 
375
      error_plus(0, errno, "waitpid");
253
376
      if(errno == ECHILD){
254
377
        splashy_command_pid = 0;
255
378
      }
256
379
    } else {
257
380
      /* The child process has exited */
258
381
      splashy_command_pid = 0;
259
 
      if(not interrupted_by_signal and WIFEXITED(status)
260
 
         and WEXITSTATUS(status)==0){
 
382
      if(WIFEXITED(status) and WEXITSTATUS(status) == 0){
261
383
        return EXIT_SUCCESS;
262
384
      }
263
385
    }
264
386
  }
265
 
  kill(splashy_pid, SIGTERM);
266
 
  if(interrupted_by_signal and splashy_command_pid != 0){
267
 
    kill(splashy_command_pid, SIGTERM);
268
 
  }
269
 
  sleep(2);
270
 
  while(kill(splashy_pid, 0) == 0){
271
 
    kill(splashy_pid, SIGKILL);
272
 
    sleep(1);
273
 
  }
274
 
  pid_t new_splashy_pid = fork();
275
 
  if(new_splashy_pid == 0){
276
 
    /* Child; will become new splashy process */
277
 
    
278
 
    /* Make the effective user ID (root) the only user ID instead of
279
 
       the real user ID (_mandos) */
280
 
    ret = setuid(geteuid());
281
 
    if(ret == -1){
282
 
      perror("setuid");
283
 
    }
284
 
    
285
 
    setsid();
286
 
    ret = chdir("/");
287
 
/*     if(fork() != 0){ */
288
 
/*       _exit(EXIT_SUCCESS); */
289
 
/*     } */
290
 
    ret = dup2(STDERR_FILENO, STDOUT_FILENO); /* replace our stdout */
291
 
    if(ret == -1){
292
 
      perror("dup2");
293
 
      _exit(EXIT_FAILURE);
294
 
    }
295
 
    
296
 
    execl("/sbin/splashy", "/sbin/splashy", "boot", (char *)NULL);
297
 
    if(not interrupted_by_signal){
298
 
      perror("execl");
299
 
    }
300
 
    _exit(EXIT_FAILURE);
301
 
  }
302
 
  
303
 
  return EXIT_FAILURE;
 
387
  
 
388
 failure:
 
389
  
 
390
  free(prompt);
 
391
  
 
392
  if(proc_dir != NULL){
 
393
    TEMP_FAILURE_RETRY(closedir(proc_dir));
 
394
  }
 
395
  
 
396
  if(splashy_command_pid != 0){
 
397
    TEMP_FAILURE_RETRY(kill(splashy_command_pid, SIGTERM));
 
398
    
 
399
    TEMP_FAILURE_RETRY(kill(splashy_pid, SIGTERM));
 
400
    sleep(2);
 
401
    while(TEMP_FAILURE_RETRY(kill(splashy_pid, 0)) == 0){
 
402
      TEMP_FAILURE_RETRY(kill(splashy_pid, SIGKILL));
 
403
      sleep(1);
 
404
    }
 
405
    pid_t new_splashy_pid = (pid_t)TEMP_FAILURE_RETRY(fork());
 
406
    if(new_splashy_pid == 0){
 
407
      /* Child; will become new splashy process */
 
408
      
 
409
      /* Make the effective user ID (root) the only user ID instead of
 
410
         the real user ID (_mandos) */
 
411
      ret = setuid(geteuid());
 
412
      if(ret == -1){
 
413
        error_plus(0, errno, "setuid");
 
414
      }
 
415
      
 
416
      setsid();
 
417
      ret = chdir("/");
 
418
      if(ret == -1){
 
419
        error_plus(0, errno, "chdir");
 
420
      }
 
421
/*       if(fork() != 0){ */
 
422
/*      _exit(EXIT_SUCCESS); */
 
423
/*       } */
 
424
      ret = dup2(STDERR_FILENO, STDOUT_FILENO); /* replace stdout */
 
425
      if(ret == -1){
 
426
        error_plus(0, errno, "dup2");
 
427
        _exit(EX_OSERR);
 
428
      }
 
429
      
 
430
      execl("/sbin/splashy", "/sbin/splashy", "boot", (char *)NULL);
 
431
      {
 
432
        int e = errno;
 
433
        error_plus(0, errno, "execl");
 
434
        switch(e){
 
435
        case EACCES:
 
436
        case ENOENT:
 
437
        case ENOEXEC:
 
438
        default:
 
439
          _exit(EX_UNAVAILABLE);
 
440
        case ENAMETOOLONG:
 
441
        case E2BIG:
 
442
        case ENOMEM:
 
443
          _exit(EX_OSERR);
 
444
        case ENOTDIR:
 
445
        case ELOOP:
 
446
          _exit(EX_OSFILE);
 
447
        }
 
448
      }
 
449
    }
 
450
  }
 
451
  
 
452
  if(interrupted_by_signal){
 
453
    struct sigaction signal_action;
 
454
    sigemptyset(&signal_action.sa_mask);
 
455
    signal_action.sa_handler = SIG_DFL;
 
456
    ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
 
457
                                            &signal_action, NULL));
 
458
    if(ret == -1){
 
459
      error_plus(0, errno, "sigaction");
 
460
    }
 
461
    do {
 
462
      ret = raise(signal_received);
 
463
    } while(ret != 0 and errno == EINTR);
 
464
    if(ret != 0){
 
465
      error_plus(0, errno, "raise");
 
466
      abort();
 
467
    }
 
468
    TEMP_FAILURE_RETRY(pause());
 
469
  }
 
470
  
 
471
  return exitstatus;
304
472
}