/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/mandos-client.c

  • Committer: Teddy Hogeborn
  • Date: 2015-05-23 20:18:34 UTC
  • mto: (237.7.304 trunk)
  • mto: This revision was merged to the branch mainline in revision 325.
  • Revision ID: teddy@recompile.se-20150523201834-e89ex4ito93yni8x
mandos: Use multiprocessing module to run checkers.

For a long time, the Mandos server has occasionally logged the message
"ERROR: Child process vanished".  This was never a fatal error, but it
has been annoying and slightly worrying, since a definite cause was
not found.  One potential cause could be the "multiprocessing" and
"subprocess" modules conflicting w.r.t. SIGCHLD.  To avoid this,
change the running of checkers from using subprocess.Popen
asynchronously to instead first create a multiprocessing.Process()
(which is asynchronous) calling a function, and have that function
then call subprocess.call() (which is synchronous).  In this way, the
only thing using any asynchronous subprocesses is the multiprocessing
module.

This makes it necessary to change one small thing in the D-Bus API,
since the subprocesses.call() function does not expose the raw wait(2)
status value.

DBUS-API (CheckerCompleted): Change the second value provided by this
                             D-Bus signal from the raw wait(2) status
                             to the actual terminating signal number.
mandos (subprocess_call_pipe): New function to be called by
                               multiprocessing.Process (starting a
                               separate process).
(Client.last_checker signal): New attribute for signal which
                              terminated last checker.  Like
                              last_checker_status, only not accessible
                              via D-Bus.
(Client.checker_callback): Take new "connection" argument and use it
                           to get returncode; set last_checker_signal.
                           Return False so gobject does not call this
                           callback again.
(Client.start_checker): Start checker using a multiprocessing.Process
                        instead of a subprocess.Popen.
(ClientDBus.checker_callback): Take new "connection" argument.        Call
                               Client.checker_callback early to have
                               it set last_checker_status and
                               last_checker_signal; use those.  Change
                               second value provided to D-Bus signal
                               CheckerCompleted to use
                               last_checker_signal if checker was
                               terminated by signal.
mandos-monitor: Update to reflect DBus API change.
(MandosClientWidget.checker_completed): Take "signal" instead of
                                        "condition" argument.  Use it
                                        accordingly.  Remove dead code
                                        (os.WCOREDUMP case).

Show diffs side-by-side

added added

removed removed

Lines of Context:
9
9
 * "browse_callback", and parts of "main".
10
10
 * 
11
11
 * Everything else is
12
 
 * Copyright © 2008-2018 Teddy Hogeborn
13
 
 * Copyright © 2008-2018 Björn Påhlsson
14
 
 * 
15
 
 * This file is part of Mandos.
16
 
 * 
17
 
 * Mandos is free software: you can redistribute it and/or modify it
18
 
 * under the terms of the GNU General Public License as published by
19
 
 * the Free Software Foundation, either version 3 of the License, or
20
 
 * (at your option) any later version.
21
 
 * 
22
 
 * Mandos is distributed in the hope that it will be useful, but
 
12
 * Copyright © 2008-2014 Teddy Hogeborn
 
13
 * Copyright © 2008-2014 Björn Påhlsson
 
14
 * 
 
15
 * This program is free software: you can redistribute it and/or
 
16
 * modify it under the terms of the GNU General Public License as
 
17
 * published by the Free Software Foundation, either version 3 of the
 
18
 * License, or (at your option) any later version.
 
19
 * 
 
20
 * This program is distributed in the hope that it will be useful, but
23
21
 * WITHOUT ANY WARRANTY; without even the implied warranty of
24
22
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25
23
 * General Public License for more details.
26
24
 * 
27
25
 * You should have received a copy of the GNU General Public License
28
 
 * along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
 
26
 * along with this program.  If not, see
 
27
 * <http://www.gnu.org/licenses/>.
29
28
 * 
30
29
 * Contact the authors at <mandos@recompile.se>.
31
30
 */
47
46
#include <stdlib.h>             /* free(), EXIT_SUCCESS, srand(),
48
47
                                   strtof(), abort() */
49
48
#include <stdbool.h>            /* bool, false, true */
50
 
#include <string.h>             /* strcmp(), strlen(), strerror(),
51
 
                                   asprintf(), strncpy(), strsignal()
52
 
                                */
 
49
#include <string.h>             /* memset(), strcmp(), strlen(),
 
50
                                   strerror(), asprintf(), strcpy() */
53
51
#include <sys/ioctl.h>          /* ioctl */
54
52
#include <sys/types.h>          /* socket(), inet_pton(), sockaddr,
55
53
                                   sockaddr_in6, PF_INET6,
59
57
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
60
58
                                   inet_pton(), connect(),
61
59
                                   getnameinfo() */
62
 
#include <fcntl.h>              /* open(), unlinkat(), AT_REMOVEDIR */
 
60
#include <fcntl.h>              /* open(), unlinkat() */
63
61
#include <dirent.h>             /* opendir(), struct dirent, readdir()
64
62
                                 */
65
63
#include <inttypes.h>           /* PRIu16, PRIdMAX, intmax_t,
66
64
                                   strtoimax() */
67
 
#include <errno.h>              /* perror(), errno, EINTR, EINVAL,
68
 
                                   EAI_SYSTEM, ENETUNREACH,
69
 
                                   EHOSTUNREACH, ECONNREFUSED, EPROTO,
70
 
                                   EIO, ENOENT, ENXIO, ENOMEM, EISDIR,
71
 
                                   ENOTEMPTY,
 
65
#include <errno.h>              /* perror(), errno,
72
66
                                   program_invocation_short_name */
73
67
#include <time.h>               /* nanosleep(), time(), sleep() */
74
68
#include <net/if.h>             /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
123
117
                                   gnutls_*
124
118
                                   init_gnutls_session(),
125
119
                                   GNUTLS_* */
126
 
#if GNUTLS_VERSION_NUMBER < 0x030600
127
120
#include <gnutls/openpgp.h>
128
121
                         /* gnutls_certificate_set_openpgp_key_file(),
129
122
                            GNUTLS_OPENPGP_FMT_BASE64 */
130
 
#elif GNUTLS_VERSION_NUMBER >= 0x030606
131
 
#include <gnutls/x509.h>        /* gnutls_pkcs_encrypt_flags_t,
132
 
                                 GNUTLS_PKCS_PLAIN,
133
 
                                 GNUTLS_PKCS_NULL_PASSWORD */
134
 
#endif
135
123
 
136
124
/* GPGME */
137
125
#include <gpgme.h>              /* All GPGME types, constants and
145
133
#define PATHDIR "/conf/conf.d/mandos"
146
134
#define SECKEY "seckey.txt"
147
135
#define PUBKEY "pubkey.txt"
148
 
#define TLS_PRIVKEY "tls-privkey.pem"
149
 
#define TLS_PUBKEY "tls-pubkey.pem"
150
136
#define HOOKDIR "/lib/mandos/network-hooks.d"
151
137
 
152
138
bool debug = false;
280
266
  return true;
281
267
}
282
268
 
283
 
/* Set effective uid to 0, return errno */
284
 
__attribute__((warn_unused_result))
285
 
int raise_privileges(void){
286
 
  int old_errno = errno;
287
 
  int ret = 0;
288
 
  if(seteuid(0) == -1){
289
 
    ret = errno;
290
 
  }
291
 
  errno = old_errno;
292
 
  return ret;
293
 
}
294
 
 
295
 
/* Set effective and real user ID to 0.  Return errno. */
296
 
__attribute__((warn_unused_result))
297
 
int raise_privileges_permanently(void){
298
 
  int old_errno = errno;
299
 
  int ret = raise_privileges();
300
 
  if(ret != 0){
301
 
    errno = old_errno;
302
 
    return ret;
303
 
  }
304
 
  if(setuid(0) == -1){
305
 
    ret = errno;
306
 
  }
307
 
  errno = old_errno;
308
 
  return ret;
309
 
}
310
 
 
311
 
/* Set effective user ID to unprivileged saved user ID */
312
 
__attribute__((warn_unused_result))
313
 
int lower_privileges(void){
314
 
  int old_errno = errno;
315
 
  int ret = 0;
316
 
  if(seteuid(uid) == -1){
317
 
    ret = errno;
318
 
  }
319
 
  errno = old_errno;
320
 
  return ret;
321
 
}
322
 
 
323
 
/* Lower privileges permanently */
324
 
__attribute__((warn_unused_result))
325
 
int lower_privileges_permanently(void){
326
 
  int old_errno = errno;
327
 
  int ret = 0;
328
 
  if(setuid(uid) == -1){
329
 
    ret = errno;
330
 
  }
331
 
  errno = old_errno;
332
 
  return ret;
333
 
}
334
 
 
335
269
/* 
336
270
 * Initialize GPGME.
337
271
 */
357
291
      return false;
358
292
    }
359
293
    
360
 
    /* Workaround for systems without a real-time clock; see also
361
 
       Debian bug #894495: <https://bugs.debian.org/894495> */
362
 
    do {
363
 
      {
364
 
        time_t currtime = time(NULL);
365
 
        if(currtime != (time_t)-1){
366
 
          struct tm tm;
367
 
          if(gmtime_r(&currtime, &tm) == NULL) {
368
 
            perror_plus("gmtime_r");
369
 
            break;
370
 
          }
371
 
          if(tm.tm_year != 70 or tm.tm_mon != 0){
372
 
            break;
373
 
          }
374
 
          if(debug){
375
 
            fprintf_plus(stderr, "System clock is January 1970");
376
 
          }
377
 
        } else {
378
 
          if(debug){
379
 
            fprintf_plus(stderr, "System clock is invalid");
380
 
          }
381
 
        }
382
 
      }
383
 
      struct stat keystat;
384
 
      ret = fstat(fd, &keystat);
385
 
      if(ret != 0){
386
 
        perror_plus("fstat");
387
 
        break;
388
 
      }
389
 
      ret = raise_privileges();
390
 
      if(ret != 0){
391
 
        errno = ret;
392
 
        perror_plus("Failed to raise privileges");
393
 
        break;
394
 
      }
395
 
      if(debug){
396
 
        fprintf_plus(stderr,
397
 
                     "Setting system clock to key file mtime");
398
 
      }
399
 
      time_t keytime = keystat.st_mtim.tv_sec;
400
 
      if(stime(&keytime) != 0){
401
 
        perror_plus("stime");
402
 
      }
403
 
      ret = lower_privileges();
404
 
      if(ret != 0){
405
 
        errno = ret;
406
 
        perror_plus("Failed to lower privileges");
407
 
      }
408
 
    } while(false);
409
 
 
410
294
    rc = gpgme_data_new_from_fd(&pgp_data, fd);
411
295
    if(rc != GPG_ERR_NO_ERROR){
412
296
      fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
420
304
                   gpgme_strsource(rc), gpgme_strerror(rc));
421
305
      return false;
422
306
    }
423
 
    {
424
 
      gpgme_import_result_t import_result
425
 
        = gpgme_op_import_result(mc->ctx);
426
 
      if((import_result->imported < 1
427
 
          or import_result->not_imported > 0)
428
 
         and import_result->unchanged == 0){
429
 
        fprintf_plus(stderr, "bad gpgme_op_import_results:\n");
430
 
        fprintf_plus(stderr,
431
 
                     "The total number of considered keys: %d\n",
432
 
                     import_result->considered);
433
 
        fprintf_plus(stderr,
434
 
                     "The number of keys without user ID: %d\n",
435
 
                     import_result->no_user_id);
436
 
        fprintf_plus(stderr,
437
 
                     "The total number of imported keys: %d\n",
438
 
                     import_result->imported);
439
 
        fprintf_plus(stderr, "The number of imported RSA keys: %d\n",
440
 
                     import_result->imported_rsa);
441
 
        fprintf_plus(stderr, "The number of unchanged keys: %d\n",
442
 
                     import_result->unchanged);
443
 
        fprintf_plus(stderr, "The number of new user IDs: %d\n",
444
 
                     import_result->new_user_ids);
445
 
        fprintf_plus(stderr, "The number of new sub keys: %d\n",
446
 
                     import_result->new_sub_keys);
447
 
        fprintf_plus(stderr, "The number of new signatures: %d\n",
448
 
                     import_result->new_signatures);
449
 
        fprintf_plus(stderr, "The number of new revocations: %d\n",
450
 
                     import_result->new_revocations);
451
 
        fprintf_plus(stderr,
452
 
                     "The total number of secret keys read: %d\n",
453
 
                     import_result->secret_read);
454
 
        fprintf_plus(stderr,
455
 
                     "The number of imported secret keys: %d\n",
456
 
                     import_result->secret_imported);
457
 
        fprintf_plus(stderr,
458
 
                     "The number of unchanged secret keys: %d\n",
459
 
                     import_result->secret_unchanged);
460
 
        fprintf_plus(stderr, "The number of keys not imported: %d\n",
461
 
                     import_result->not_imported);
462
 
        for(gpgme_import_status_t import_status
463
 
              = import_result->imports;
464
 
            import_status != NULL;
465
 
            import_status = import_status->next){
466
 
          fprintf_plus(stderr, "Import status for key: %s\n",
467
 
                       import_status->fpr);
468
 
          if(import_status->result != GPG_ERR_NO_ERROR){
469
 
            fprintf_plus(stderr, "Import result: %s: %s\n",
470
 
                         gpgme_strsource(import_status->result),
471
 
                         gpgme_strerror(import_status->result));
472
 
          }
473
 
          fprintf_plus(stderr, "Key status:\n");
474
 
          fprintf_plus(stderr,
475
 
                       import_status->status & GPGME_IMPORT_NEW
476
 
                       ? "The key was new.\n"
477
 
                       : "The key was not new.\n");
478
 
          fprintf_plus(stderr,
479
 
                       import_status->status & GPGME_IMPORT_UID
480
 
                       ? "The key contained new user IDs.\n"
481
 
                       : "The key did not contain new user IDs.\n");
482
 
          fprintf_plus(stderr,
483
 
                       import_status->status & GPGME_IMPORT_SIG
484
 
                       ? "The key contained new signatures.\n"
485
 
                       : "The key did not contain new signatures.\n");
486
 
          fprintf_plus(stderr,
487
 
                       import_status->status & GPGME_IMPORT_SUBKEY
488
 
                       ? "The key contained new sub keys.\n"
489
 
                       : "The key did not contain new sub keys.\n");
490
 
          fprintf_plus(stderr,
491
 
                       import_status->status & GPGME_IMPORT_SECRET
492
 
                       ? "The key contained a secret key.\n"
493
 
                       : "The key did not contain a secret key.\n");
494
 
        }
495
 
        return false;
496
 
      }
497
 
    }
498
307
    
499
 
    ret = close(fd);
 
308
    ret = (int)TEMP_FAILURE_RETRY(close(fd));
500
309
    if(ret == -1){
501
310
      perror_plus("close");
502
311
    }
541
350
  /* Create new GPGME "context" */
542
351
  rc = gpgme_new(&(mc->ctx));
543
352
  if(rc != GPG_ERR_NO_ERROR){
544
 
    fprintf_plus(stderr, "bad gpgme_new: %s: %s\n",
545
 
                 gpgme_strsource(rc), gpgme_strerror(rc));
 
353
    fprintf_plus(stderr, "Mandos plugin mandos-client: "
 
354
                 "bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
 
355
                 gpgme_strerror(rc));
546
356
    return false;
547
357
  }
548
358
  
584
394
  /* Create new empty GPGME data buffer for the plaintext */
585
395
  rc = gpgme_data_new(&dh_plain);
586
396
  if(rc != GPG_ERR_NO_ERROR){
587
 
    fprintf_plus(stderr, "bad gpgme_data_new: %s: %s\n",
 
397
    fprintf_plus(stderr, "Mandos plugin mandos-client: "
 
398
                 "bad gpgme_data_new: %s: %s\n",
588
399
                 gpgme_strsource(rc), gpgme_strerror(rc));
589
400
    gpgme_data_release(dh_crypto);
590
401
    return -1;
603
414
      if(result == NULL){
604
415
        fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
605
416
      } else {
606
 
        if(result->unsupported_algorithm != NULL) {
607
 
          fprintf_plus(stderr, "Unsupported algorithm: %s\n",
608
 
                       result->unsupported_algorithm);
609
 
        }
610
 
        fprintf_plus(stderr, "Wrong key usage: %s\n",
611
 
                     result->wrong_key_usage ? "Yes" : "No");
 
417
        fprintf_plus(stderr, "Unsupported algorithm: %s\n",
 
418
                     result->unsupported_algorithm);
 
419
        fprintf_plus(stderr, "Wrong key usage: %u\n",
 
420
                     result->wrong_key_usage);
612
421
        if(result->file_name != NULL){
613
422
          fprintf_plus(stderr, "File name: %s\n", result->file_name);
614
423
        }
615
 
 
616
 
        for(gpgme_recipient_t r = result->recipients; r != NULL;
617
 
            r = r->next){
 
424
        gpgme_recipient_t recipient;
 
425
        recipient = result->recipients;
 
426
        while(recipient != NULL){
618
427
          fprintf_plus(stderr, "Public key algorithm: %s\n",
619
 
                       gpgme_pubkey_algo_name(r->pubkey_algo));
620
 
          fprintf_plus(stderr, "Key ID: %s\n", r->keyid);
 
428
                       gpgme_pubkey_algo_name
 
429
                       (recipient->pubkey_algo));
 
430
          fprintf_plus(stderr, "Key ID: %s\n", recipient->keyid);
621
431
          fprintf_plus(stderr, "Secret key available: %s\n",
622
 
                       r->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
 
432
                       recipient->status == GPG_ERR_NO_SECKEY
 
433
                       ? "No" : "Yes");
 
434
          recipient = recipient->next;
623
435
        }
624
436
      }
625
437
    }
701
513
  fprintf_plus(stderr, "GnuTLS: %s", string);
702
514
}
703
515
 
704
 
__attribute__((nonnull(1, 2, 4), warn_unused_result))
 
516
__attribute__((nonnull, warn_unused_result))
705
517
static int init_gnutls_global(const char *pubkeyfilename,
706
518
                              const char *seckeyfilename,
707
 
                              const char *dhparamsfilename,
708
519
                              mandos_context *mc){
709
520
  int ret;
 
521
  unsigned int uret;
710
522
  
711
523
  if(debug){
712
524
    fprintf_plus(stderr, "Initializing GnuTLS\n");
713
525
  }
714
526
  
 
527
  ret = gnutls_global_init();
 
528
  if(ret != GNUTLS_E_SUCCESS){
 
529
    fprintf_plus(stderr, "GnuTLS global_init: %s\n",
 
530
                 safer_gnutls_strerror(ret));
 
531
    return -1;
 
532
  }
 
533
  
715
534
  if(debug){
716
535
    /* "Use a log level over 10 to enable all debugging options."
717
536
     * - GnuTLS manual
725
544
  if(ret != GNUTLS_E_SUCCESS){
726
545
    fprintf_plus(stderr, "GnuTLS memory error: %s\n",
727
546
                 safer_gnutls_strerror(ret));
 
547
    gnutls_global_deinit();
728
548
    return -1;
729
549
  }
730
550
  
731
551
  if(debug){
732
 
    fprintf_plus(stderr, "Attempting to use public key %s and"
733
 
                 " private key %s as GnuTLS credentials\n",
 
552
    fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
 
553
                 " secret key %s as GnuTLS credentials\n",
734
554
                 pubkeyfilename,
735
555
                 seckeyfilename);
736
556
  }
737
557
  
738
 
#if GNUTLS_VERSION_NUMBER >= 0x030606
739
 
  ret = gnutls_certificate_set_rawpk_key_file
740
 
    (mc->cred, pubkeyfilename, seckeyfilename,
741
 
     GNUTLS_X509_FMT_PEM,       /* format */
742
 
     NULL,                      /* pass */
743
 
     /* key_usage */
744
 
     GNUTLS_KEY_DIGITAL_SIGNATURE | GNUTLS_KEY_KEY_ENCIPHERMENT,
745
 
     NULL,                      /* names */
746
 
     0,                         /* names_length */
747
 
     /* privkey_flags */
748
 
     GNUTLS_PKCS_PLAIN | GNUTLS_PKCS_NULL_PASSWORD,
749
 
     0);                        /* pkcs11_flags */
750
 
#elif GNUTLS_VERSION_NUMBER < 0x030600
751
558
  ret = gnutls_certificate_set_openpgp_key_file
752
559
    (mc->cred, pubkeyfilename, seckeyfilename,
753
560
     GNUTLS_OPENPGP_FMT_BASE64);
754
 
#else
755
 
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
756
 
#endif
757
561
  if(ret != GNUTLS_E_SUCCESS){
758
562
    fprintf_plus(stderr,
759
 
                 "Error[%d] while reading the key pair ('%s',"
 
563
                 "Error[%d] while reading the OpenPGP key pair ('%s',"
760
564
                 " '%s')\n", ret, pubkeyfilename, seckeyfilename);
761
565
    fprintf_plus(stderr, "The GnuTLS error is: %s\n",
762
566
                 safer_gnutls_strerror(ret));
771
575
                 safer_gnutls_strerror(ret));
772
576
    goto globalfail;
773
577
  }
774
 
  /* If a Diffie-Hellman parameters file was given, try to use it */
775
 
  if(dhparamsfilename != NULL){
776
 
    gnutls_datum_t params = { .data = NULL, .size = 0 };
777
 
    do {
778
 
      int dhpfile = open(dhparamsfilename, O_RDONLY);
779
 
      if(dhpfile == -1){
780
 
        perror_plus("open");
781
 
        dhparamsfilename = NULL;
782
 
        break;
783
 
      }
784
 
      size_t params_capacity = 0;
 
578
  if(mc->dh_bits == 0){
 
579
    /* Find out the optimal number of DH bits */
 
580
    /* Try to read the private key file */
 
581
    gnutls_datum_t buffer = { .data = NULL, .size = 0 };
 
582
    {
 
583
      int secfile = open(seckeyfilename, O_RDONLY);
 
584
      size_t buffer_capacity = 0;
785
585
      while(true){
786
 
        params_capacity = incbuffer((char **)&params.data,
787
 
                                    (size_t)params.size,
788
 
                                    (size_t)params_capacity);
789
 
        if(params_capacity == 0){
 
586
        buffer_capacity = incbuffer((char **)&buffer.data,
 
587
                                    (size_t)buffer.size,
 
588
                                    (size_t)buffer_capacity);
 
589
        if(buffer_capacity == 0){
790
590
          perror_plus("incbuffer");
791
 
          free(params.data);
792
 
          params.data = NULL;
793
 
          dhparamsfilename = NULL;
 
591
          free(buffer.data);
 
592
          buffer.data = NULL;
794
593
          break;
795
594
        }
796
 
        ssize_t bytes_read = read(dhpfile,
797
 
                                  params.data + params.size,
 
595
        ssize_t bytes_read = read(secfile, buffer.data + buffer.size,
798
596
                                  BUFFER_SIZE);
799
597
        /* EOF */
800
598
        if(bytes_read == 0){
803
601
        /* check bytes_read for failure */
804
602
        if(bytes_read < 0){
805
603
          perror_plus("read");
806
 
          free(params.data);
807
 
          params.data = NULL;
808
 
          dhparamsfilename = NULL;
809
 
          break;
810
 
        }
811
 
        params.size += (unsigned int)bytes_read;
812
 
      }
813
 
      ret = close(dhpfile);
814
 
      if(ret == -1){
815
 
        perror_plus("close");
816
 
      }
817
 
      if(params.data == NULL){
818
 
        dhparamsfilename = NULL;
819
 
      }
820
 
      if(dhparamsfilename == NULL){
821
 
        break;
822
 
      }
823
 
      ret = gnutls_dh_params_import_pkcs3(mc->dh_params, &params,
824
 
                                          GNUTLS_X509_FMT_PEM);
825
 
      if(ret != GNUTLS_E_SUCCESS){
826
 
        fprintf_plus(stderr, "Failed to parse DH parameters in file"
827
 
                     " \"%s\": %s\n", dhparamsfilename,
828
 
                     safer_gnutls_strerror(ret));
829
 
        dhparamsfilename = NULL;
830
 
      }
831
 
      free(params.data);
832
 
    } while(false);
833
 
  }
834
 
  if(dhparamsfilename == NULL){
835
 
    if(mc->dh_bits == 0){
836
 
#if GNUTLS_VERSION_NUMBER < 0x030600
837
 
      /* Find out the optimal number of DH bits */
838
 
      /* Try to read the private key file */
839
 
      gnutls_datum_t buffer = { .data = NULL, .size = 0 };
840
 
      do {
841
 
        int secfile = open(seckeyfilename, O_RDONLY);
842
 
        if(secfile == -1){
843
 
          perror_plus("open");
844
 
          break;
845
 
        }
846
 
        size_t buffer_capacity = 0;
847
 
        while(true){
848
 
          buffer_capacity = incbuffer((char **)&buffer.data,
849
 
                                      (size_t)buffer.size,
850
 
                                      (size_t)buffer_capacity);
851
 
          if(buffer_capacity == 0){
852
 
            perror_plus("incbuffer");
853
 
            free(buffer.data);
854
 
            buffer.data = NULL;
855
 
            break;
856
 
          }
857
 
          ssize_t bytes_read = read(secfile,
858
 
                                    buffer.data + buffer.size,
859
 
                                    BUFFER_SIZE);
860
 
          /* EOF */
861
 
          if(bytes_read == 0){
862
 
            break;
863
 
          }
864
 
          /* check bytes_read for failure */
865
 
          if(bytes_read < 0){
866
 
            perror_plus("read");
867
 
            free(buffer.data);
868
 
            buffer.data = NULL;
869
 
            break;
870
 
          }
871
 
          buffer.size += (unsigned int)bytes_read;
872
 
        }
873
 
        close(secfile);
874
 
      } while(false);
875
 
      /* If successful, use buffer to parse private key */
876
 
      gnutls_sec_param_t sec_param = GNUTLS_SEC_PARAM_ULTRA;
877
 
      if(buffer.data != NULL){
878
 
        {
879
 
          gnutls_openpgp_privkey_t privkey = NULL;
880
 
          ret = gnutls_openpgp_privkey_init(&privkey);
 
604
          free(buffer.data);
 
605
          buffer.data = NULL;
 
606
          break;
 
607
        }
 
608
        buffer.size += (unsigned int)bytes_read;
 
609
      }
 
610
      close(secfile);
 
611
    }
 
612
    /* If successful, use buffer to parse private key */
 
613
    gnutls_sec_param_t sec_param = GNUTLS_SEC_PARAM_ULTRA;
 
614
    if(buffer.data != NULL){
 
615
      {
 
616
        gnutls_openpgp_privkey_t privkey = NULL;
 
617
        ret = gnutls_openpgp_privkey_init(&privkey);
 
618
        if(ret != GNUTLS_E_SUCCESS){
 
619
          fprintf_plus(stderr, "Error initializing OpenPGP key"
 
620
                       " structure: %s", safer_gnutls_strerror(ret));
 
621
          free(buffer.data);
 
622
          buffer.data = NULL;
 
623
        } else {
 
624
          ret = gnutls_openpgp_privkey_import(privkey, &buffer,
 
625
                                            GNUTLS_OPENPGP_FMT_BASE64,
 
626
                                              "", 0);
881
627
          if(ret != GNUTLS_E_SUCCESS){
882
 
            fprintf_plus(stderr, "Error initializing OpenPGP key"
883
 
                         " structure: %s",
 
628
            fprintf_plus(stderr, "Error importing OpenPGP key : %s",
884
629
                         safer_gnutls_strerror(ret));
885
 
            free(buffer.data);
886
 
            buffer.data = NULL;
887
 
          } else {
888
 
            ret = gnutls_openpgp_privkey_import
889
 
              (privkey, &buffer, GNUTLS_OPENPGP_FMT_BASE64, "", 0);
890
 
            if(ret != GNUTLS_E_SUCCESS){
891
 
              fprintf_plus(stderr, "Error importing OpenPGP key : %s",
892
 
                           safer_gnutls_strerror(ret));
893
 
              privkey = NULL;
894
 
            }
895
 
            free(buffer.data);
896
 
            buffer.data = NULL;
897
 
            if(privkey != NULL){
898
 
              /* Use private key to suggest an appropriate
899
 
                 sec_param */
900
 
              sec_param = gnutls_openpgp_privkey_sec_param(privkey);
901
 
              gnutls_openpgp_privkey_deinit(privkey);
902
 
              if(debug){
903
 
                fprintf_plus(stderr, "This OpenPGP key implies using"
904
 
                             " a GnuTLS security parameter \"%s\".\n",
905
 
                             safe_string(gnutls_sec_param_get_name
906
 
                                         (sec_param)));
907
 
              }
908
 
            }
 
630
            privkey = NULL;
909
631
          }
910
 
        }
911
 
        if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
912
 
          /* Err on the side of caution */
913
 
          sec_param = GNUTLS_SEC_PARAM_ULTRA;
914
 
          if(debug){
915
 
            fprintf_plus(stderr, "Falling back to security parameter"
916
 
                         " \"%s\"\n",
917
 
                         safe_string(gnutls_sec_param_get_name
918
 
                                     (sec_param)));
 
632
          free(buffer.data);
 
633
          buffer.data = NULL;
 
634
          if(privkey != NULL){
 
635
            /* Use private key to suggest an appropriate sec_param */
 
636
            sec_param = gnutls_openpgp_privkey_sec_param(privkey);
 
637
            gnutls_openpgp_privkey_deinit(privkey);
 
638
            if(debug){
 
639
              fprintf_plus(stderr, "This OpenPGP key implies using a"
 
640
                           " GnuTLS security parameter \"%s\".\n",
 
641
                           safe_string(gnutls_sec_param_get_name
 
642
                                       (sec_param)));
 
643
            }
919
644
          }
920
645
        }
921
646
      }
922
 
      unsigned int uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
923
 
      if(uret != 0){
924
 
        mc->dh_bits = uret;
 
647
      if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
 
648
        /* Err on the side of caution */
 
649
        sec_param = GNUTLS_SEC_PARAM_ULTRA;
925
650
        if(debug){
926
 
          fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
927
 
                       " implies %u DH bits; using that.\n",
 
651
          fprintf_plus(stderr, "Falling back to security parameter"
 
652
                       " \"%s\"\n",
928
653
                       safe_string(gnutls_sec_param_get_name
929
 
                                   (sec_param)),
930
 
                       mc->dh_bits);
 
654
                                   (sec_param)));
931
655
        }
932
 
      } else {
933
 
        fprintf_plus(stderr, "Failed to get implied number of DH"
934
 
                     " bits for security parameter \"%s\"): %s\n",
 
656
      }
 
657
    }
 
658
    uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
 
659
    if(uret != 0){
 
660
      mc->dh_bits = uret;
 
661
      if(debug){
 
662
        fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
 
663
                     " implies %u DH bits; using that.\n",
935
664
                     safe_string(gnutls_sec_param_get_name
936
665
                                 (sec_param)),
937
 
                     safer_gnutls_strerror(ret));
938
 
        goto globalfail;
939
 
      }
940
 
#endif
941
 
    } else {                    /* dh_bits != 0 */
942
 
      if(debug){
943
 
        fprintf_plus(stderr, "DH bits explicitly set to %u\n",
944
666
                     mc->dh_bits);
945
667
      }
946
 
      ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
947
 
      if(ret != GNUTLS_E_SUCCESS){
948
 
        fprintf_plus(stderr, "Error in GnuTLS prime generation (%u"
949
 
                     " bits): %s\n", mc->dh_bits,
950
 
                     safer_gnutls_strerror(ret));
951
 
        goto globalfail;
952
 
      }
953
 
      gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
 
668
    } else {
 
669
      fprintf_plus(stderr, "Failed to get implied number of DH"
 
670
                   " bits for security parameter \"%s\"): %s\n",
 
671
                   safe_string(gnutls_sec_param_get_name(sec_param)),
 
672
                   safer_gnutls_strerror(ret));
 
673
      goto globalfail;
954
674
    }
955
 
  }
 
675
  } else if(debug){
 
676
    fprintf_plus(stderr, "DH bits explicitly set to %u\n",
 
677
                 mc->dh_bits);
 
678
  }
 
679
  ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
 
680
  if(ret != GNUTLS_E_SUCCESS){
 
681
    fprintf_plus(stderr, "Error in GnuTLS prime generation (%u bits):"
 
682
                 " %s\n", mc->dh_bits, safer_gnutls_strerror(ret));
 
683
    goto globalfail;
 
684
  }
 
685
  
 
686
  gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
956
687
  
957
688
  return 0;
958
689
  
959
690
 globalfail:
960
691
  
961
692
  gnutls_certificate_free_credentials(mc->cred);
 
693
  gnutls_global_deinit();
962
694
  gnutls_dh_params_deinit(mc->dh_params);
963
695
  return -1;
964
696
}
969
701
  int ret;
970
702
  /* GnuTLS session creation */
971
703
  do {
972
 
    ret = gnutls_init(session, (GNUTLS_SERVER
973
 
#if GNUTLS_VERSION_NUMBER >= 0x030506
974
 
                                | GNUTLS_NO_TICKETS
975
 
#endif
976
 
#if GNUTLS_VERSION_NUMBER >= 0x030606
977
 
                                | GNUTLS_ENABLE_RAWPK
978
 
#endif
979
 
                                ));
 
704
    ret = gnutls_init(session, GNUTLS_SERVER);
980
705
    if(quit_now){
981
706
      return -1;
982
707
    }
1023
748
  /* ignore client certificate if any. */
1024
749
  gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
1025
750
  
 
751
  gnutls_dh_set_prime_bits(*session, mc->dh_bits);
 
752
  
1026
753
  return 0;
1027
754
}
1028
755
 
1030
757
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
1031
758
                      __attribute__((unused)) const char *txt){}
1032
759
 
1033
 
/* Helper function to add_local_route() and delete_local_route() */
1034
 
__attribute__((nonnull, warn_unused_result))
1035
 
static bool add_delete_local_route(const bool add,
1036
 
                                   const char *address,
1037
 
                                   AvahiIfIndex if_index){
1038
 
  int ret;
1039
 
  char helper[] = "mandos-client-iprouteadddel";
1040
 
  char add_arg[] = "add";
1041
 
  char delete_arg[] = "delete";
1042
 
  char debug_flag[] = "--debug";
1043
 
  char *pluginhelperdir = getenv("MANDOSPLUGINHELPERDIR");
1044
 
  if(pluginhelperdir == NULL){
1045
 
    if(debug){
1046
 
      fprintf_plus(stderr, "MANDOSPLUGINHELPERDIR environment"
1047
 
                   " variable not set; cannot run helper\n");
1048
 
    }
1049
 
    return false;
1050
 
  }
1051
 
  
1052
 
  char interface[IF_NAMESIZE];
1053
 
  if(if_indextoname((unsigned int)if_index, interface) == NULL){
1054
 
    perror_plus("if_indextoname");
1055
 
    return false;
1056
 
  }
1057
 
  
1058
 
  int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
1059
 
  if(devnull == -1){
1060
 
    perror_plus("open(\"/dev/null\", O_RDONLY)");
1061
 
    return false;
1062
 
  }
1063
 
  pid_t pid = fork();
1064
 
  if(pid == 0){
1065
 
    /* Child */
1066
 
    /* Raise privileges */
1067
 
    errno = raise_privileges_permanently();
1068
 
    if(errno != 0){
1069
 
      perror_plus("Failed to raise privileges");
1070
 
      /* _exit(EX_NOPERM); */
1071
 
    } else {
1072
 
      /* Set group */
1073
 
      errno = 0;
1074
 
      ret = setgid(0);
1075
 
      if(ret == -1){
1076
 
        perror_plus("setgid");
1077
 
        _exit(EX_NOPERM);
1078
 
      }
1079
 
      /* Reset supplementary groups */
1080
 
      errno = 0;
1081
 
      ret = setgroups(0, NULL);
1082
 
      if(ret == -1){
1083
 
        perror_plus("setgroups");
1084
 
        _exit(EX_NOPERM);
1085
 
      }
1086
 
    }
1087
 
    ret = dup2(devnull, STDIN_FILENO);
1088
 
    if(ret == -1){
1089
 
      perror_plus("dup2(devnull, STDIN_FILENO)");
1090
 
      _exit(EX_OSERR);
1091
 
    }
1092
 
    ret = close(devnull);
1093
 
    if(ret == -1){
1094
 
      perror_plus("close");
1095
 
      _exit(EX_OSERR);
1096
 
    }
1097
 
    ret = dup2(STDERR_FILENO, STDOUT_FILENO);
1098
 
    if(ret == -1){
1099
 
      perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
1100
 
      _exit(EX_OSERR);
1101
 
    }
1102
 
    int helperdir_fd = (int)TEMP_FAILURE_RETRY(open(pluginhelperdir,
1103
 
                                                    O_RDONLY
1104
 
                                                    | O_DIRECTORY
1105
 
                                                    | O_PATH
1106
 
                                                    | O_CLOEXEC));
1107
 
    if(helperdir_fd == -1){
1108
 
      perror_plus("open");
1109
 
      _exit(EX_UNAVAILABLE);
1110
 
    }
1111
 
    int helper_fd = (int)TEMP_FAILURE_RETRY(openat(helperdir_fd,
1112
 
                                                   helper, O_RDONLY));
1113
 
    if(helper_fd == -1){
1114
 
      perror_plus("openat");
1115
 
      close(helperdir_fd);
1116
 
      _exit(EX_UNAVAILABLE);
1117
 
    }
1118
 
    close(helperdir_fd);
1119
 
#ifdef __GNUC__
1120
 
#pragma GCC diagnostic push
1121
 
#pragma GCC diagnostic ignored "-Wcast-qual"
1122
 
#endif
1123
 
    if(fexecve(helper_fd, (char *const [])
1124
 
               { helper, add ? add_arg : delete_arg, (char *)address,
1125
 
                   interface, debug ? debug_flag : NULL, NULL },
1126
 
               environ) == -1){
1127
 
#ifdef __GNUC__
1128
 
#pragma GCC diagnostic pop
1129
 
#endif
1130
 
      perror_plus("fexecve");
1131
 
      _exit(EXIT_FAILURE);
1132
 
    }
1133
 
  }
1134
 
  if(pid == -1){
1135
 
    perror_plus("fork");
1136
 
    return false;
1137
 
  }
1138
 
  int status;
1139
 
  pid_t pret = -1;
1140
 
  errno = 0;
1141
 
  do {
1142
 
    pret = waitpid(pid, &status, 0);
1143
 
    if(pret == -1 and errno == EINTR and quit_now){
1144
 
      int errno_raising = 0;
1145
 
      if((errno = raise_privileges()) != 0){
1146
 
        errno_raising = errno;
1147
 
        perror_plus("Failed to raise privileges in order to"
1148
 
                    " kill helper program");
1149
 
      }
1150
 
      if(kill(pid, SIGTERM) == -1){
1151
 
        perror_plus("kill");
1152
 
      }
1153
 
      if((errno_raising == 0) and (errno = lower_privileges()) != 0){
1154
 
        perror_plus("Failed to lower privileges after killing"
1155
 
                    " helper program");
1156
 
      }
1157
 
      return false;
1158
 
    }
1159
 
  } while(pret == -1 and errno == EINTR);
1160
 
  if(pret == -1){
1161
 
    perror_plus("waitpid");
1162
 
    return false;
1163
 
  }
1164
 
  if(WIFEXITED(status)){
1165
 
    if(WEXITSTATUS(status) != 0){
1166
 
      fprintf_plus(stderr, "Error: iprouteadddel exited"
1167
 
                   " with status %d\n", WEXITSTATUS(status));
1168
 
      return false;
1169
 
    }
1170
 
    return true;
1171
 
  }
1172
 
  if(WIFSIGNALED(status)){
1173
 
    fprintf_plus(stderr, "Error: iprouteadddel died by"
1174
 
                 " signal %d\n", WTERMSIG(status));
1175
 
    return false;
1176
 
  }
1177
 
  fprintf_plus(stderr, "Error: iprouteadddel crashed\n");
1178
 
  return false;
1179
 
}
1180
 
 
1181
 
__attribute__((nonnull, warn_unused_result))
1182
 
static bool add_local_route(const char *address,
1183
 
                            AvahiIfIndex if_index){
1184
 
  if(debug){
1185
 
    fprintf_plus(stderr, "Adding route to %s\n", address);
1186
 
  }
1187
 
  return add_delete_local_route(true, address, if_index);
1188
 
}
1189
 
 
1190
 
__attribute__((nonnull, warn_unused_result))
1191
 
static bool delete_local_route(const char *address,
1192
 
                               AvahiIfIndex if_index){
1193
 
  if(debug){
1194
 
    fprintf_plus(stderr, "Removing route to %s\n", address);
1195
 
  }
1196
 
  return add_delete_local_route(false, address, if_index);
1197
 
}
1198
 
 
1199
760
/* Called when a Mandos server is found */
1200
761
__attribute__((nonnull, warn_unused_result))
1201
762
static int start_mandos_communication(const char *ip, in_port_t port,
1212
773
  int retval = -1;
1213
774
  gnutls_session_t session;
1214
775
  int pf;                       /* Protocol family */
1215
 
  bool route_added = false;
1216
776
  
1217
777
  errno = 0;
1218
778
  
1240
800
    bool match = false;
1241
801
    {
1242
802
      char *interface = NULL;
1243
 
      while((interface = argz_next(mc->interfaces,
1244
 
                                   mc->interfaces_size,
1245
 
                                   interface))){
 
803
      while((interface=argz_next(mc->interfaces, mc->interfaces_size,
 
804
                                 interface))){
1246
805
        if(if_nametoindex(interface) == (unsigned int)if_index){
1247
806
          match = true;
1248
807
          break;
1277
836
                 PRIuMAX "\n", ip, (uintmax_t)port);
1278
837
  }
1279
838
  
1280
 
  tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
 
839
  tcp_sd = socket(pf, SOCK_STREAM, 0);
1281
840
  if(tcp_sd < 0){
1282
841
    int e = errno;
1283
842
    perror_plus("socket");
1290
849
    goto mandos_end;
1291
850
  }
1292
851
  
 
852
  memset(&to, 0, sizeof(to));
1293
853
  if(af == AF_INET6){
1294
 
    struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)&to;
1295
 
    *to6 = (struct sockaddr_in6){ .sin6_family = (sa_family_t)af };
1296
 
    ret = inet_pton(af, ip, &to6->sin6_addr);
 
854
    ((struct sockaddr_in6 *)&to)->sin6_family = (sa_family_t)af;
 
855
    ret = inet_pton(af, ip, &((struct sockaddr_in6 *)&to)->sin6_addr);
1297
856
  } else {                      /* IPv4 */
1298
 
    struct sockaddr_in *to4 = (struct sockaddr_in *)&to;
1299
 
    *to4 = (struct sockaddr_in){ .sin_family = (sa_family_t)af };
1300
 
    ret = inet_pton(af, ip, &to4->sin_addr);
 
857
    ((struct sockaddr_in *)&to)->sin_family = (sa_family_t)af;
 
858
    ret = inet_pton(af, ip, &((struct sockaddr_in *)&to)->sin_addr);
1301
859
  }
1302
860
  if(ret < 0 ){
1303
861
    int e = errno;
1373
931
    goto mandos_end;
1374
932
  }
1375
933
  
1376
 
  while(true){
1377
 
    if(af == AF_INET6){
1378
 
      ret = connect(tcp_sd, (struct sockaddr *)&to,
1379
 
                    sizeof(struct sockaddr_in6));
1380
 
    } else {
1381
 
      ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
1382
 
                    sizeof(struct sockaddr_in));
1383
 
    }
1384
 
    if(ret < 0){
1385
 
      if(((errno == ENETUNREACH) or (errno == EHOSTUNREACH))
1386
 
         and if_index != AVAHI_IF_UNSPEC
1387
 
         and connect_to == NULL
1388
 
         and not route_added and
1389
 
         ((af == AF_INET6 and not
1390
 
           IN6_IS_ADDR_LINKLOCAL(&(((struct sockaddr_in6 *)
1391
 
                                    &to)->sin6_addr)))
1392
 
          or (af == AF_INET and
1393
 
              /* Not a a IPv4LL address */
1394
 
              (ntohl(((struct sockaddr_in *)&to)->sin_addr.s_addr)
1395
 
               & 0xFFFF0000L) != 0xA9FE0000L))){
1396
 
        /* Work around Avahi bug - Avahi does not announce link-local
1397
 
           addresses if it has a global address, so local hosts with
1398
 
           *only* a link-local address (e.g. Mandos clients) cannot
1399
 
           connect to a Mandos server announced by Avahi on a server
1400
 
           host with a global address.  Work around this by retrying
1401
 
           with an explicit route added with the server's address.
1402
 
           
1403
 
           Avahi bug reference:
1404
 
           https://lists.freedesktop.org/archives/avahi/2010-February/001833.html
1405
 
           https://bugs.debian.org/587961
1406
 
        */
1407
 
        if(debug){
1408
 
          fprintf_plus(stderr, "Mandos server unreachable, trying"
1409
 
                       " direct route\n");
1410
 
        }
1411
 
        int e = errno;
1412
 
        route_added = add_local_route(ip, if_index);
1413
 
        if(route_added){
1414
 
          continue;
1415
 
        }
1416
 
        errno = e;
1417
 
      }
1418
 
      if(errno != ECONNREFUSED or debug){
1419
 
        int e = errno;
1420
 
        perror_plus("connect");
1421
 
        errno = e;
1422
 
      }
1423
 
      goto mandos_end;
1424
 
    }
1425
 
    
1426
 
    if(quit_now){
1427
 
      errno = EINTR;
1428
 
      goto mandos_end;
1429
 
    }
1430
 
    break;
 
934
  if(af == AF_INET6){
 
935
    ret = connect(tcp_sd, (struct sockaddr *)&to,
 
936
                  sizeof(struct sockaddr_in6));
 
937
  } else {
 
938
    ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
 
939
                  sizeof(struct sockaddr_in));
 
940
  }
 
941
  if(ret < 0){
 
942
    if((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
 
943
      int e = errno;
 
944
      perror_plus("connect");
 
945
      errno = e;
 
946
    }
 
947
    goto mandos_end;
 
948
  }
 
949
  
 
950
  if(quit_now){
 
951
    errno = EINTR;
 
952
    goto mandos_end;
1431
953
  }
1432
954
  
1433
955
  const char *out = mandos_protocol_version;
1587
1109
                                               &decrypted_buffer, mc);
1588
1110
    if(decrypted_buffer_size >= 0){
1589
1111
      
1590
 
      clearerr(stdout);
1591
1112
      written = 0;
1592
1113
      while(written < (size_t) decrypted_buffer_size){
1593
1114
        if(quit_now){
1609
1130
        }
1610
1131
        written += (size_t)ret;
1611
1132
      }
1612
 
      ret = fflush(stdout);
1613
 
      if(ret != 0){
1614
 
        int e = errno;
1615
 
        if(debug){
1616
 
          fprintf_plus(stderr, "Error writing encrypted data: %s\n",
1617
 
                       strerror(errno));
1618
 
        }
1619
 
        errno = e;
1620
 
        goto mandos_end;
1621
 
      }
1622
1133
      retval = 0;
1623
1134
    }
1624
1135
  }
1627
1138
  
1628
1139
 mandos_end:
1629
1140
  {
1630
 
    if(route_added){
1631
 
      if(not delete_local_route(ip, if_index)){
1632
 
        fprintf_plus(stderr, "Failed to delete local route to %s on"
1633
 
                     " interface %d", ip, if_index);
1634
 
      }
1635
 
    }
1636
1141
    int e = errno;
1637
1142
    free(decrypted_buffer);
1638
1143
    free(buffer);
1639
1144
    if(tcp_sd >= 0){
1640
 
      ret = close(tcp_sd);
 
1145
      ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
1641
1146
    }
1642
1147
    if(ret == -1){
1643
1148
      if(e == 0){
1655
1160
  return retval;
1656
1161
}
1657
1162
 
 
1163
__attribute__((nonnull))
1658
1164
static void resolve_callback(AvahiSServiceResolver *r,
1659
1165
                             AvahiIfIndex interface,
1660
1166
                             AvahiProtocol proto,
1797
1303
__attribute__((nonnull, warn_unused_result))
1798
1304
bool get_flags(const char *ifname, struct ifreq *ifr){
1799
1305
  int ret;
1800
 
  int old_errno;
 
1306
  error_t ret_errno;
1801
1307
  
1802
1308
  int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1803
1309
  if(s < 0){
1804
 
    old_errno = errno;
 
1310
    ret_errno = errno;
1805
1311
    perror_plus("socket");
1806
 
    errno = old_errno;
 
1312
    errno = ret_errno;
1807
1313
    return false;
1808
1314
  }
1809
 
  strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
1810
 
  ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
 
1315
  strcpy(ifr->ifr_name, ifname);
1811
1316
  ret = ioctl(s, SIOCGIFFLAGS, ifr);
1812
1317
  if(ret == -1){
1813
1318
    if(debug){
1814
 
      old_errno = errno;
 
1319
      ret_errno = errno;
1815
1320
      perror_plus("ioctl SIOCGIFFLAGS");
1816
 
      errno = old_errno;
1817
 
    }
1818
 
    if((close(s) == -1) and debug){
1819
 
      old_errno = errno;
1820
 
      perror_plus("close");
1821
 
      errno = old_errno;
 
1321
      errno = ret_errno;
1822
1322
    }
1823
1323
    return false;
1824
1324
  }
1825
 
  if((close(s) == -1) and debug){
1826
 
    old_errno = errno;
1827
 
    perror_plus("close");
1828
 
    errno = old_errno;
1829
 
  }
1830
1325
  return true;
1831
1326
}
1832
1327
 
2074
1569
  }
2075
1570
}
2076
1571
 
 
1572
/* Set effective uid to 0, return errno */
 
1573
__attribute__((warn_unused_result))
 
1574
error_t raise_privileges(void){
 
1575
  error_t old_errno = errno;
 
1576
  error_t ret_errno = 0;
 
1577
  if(seteuid(0) == -1){
 
1578
    ret_errno = errno;
 
1579
  }
 
1580
  errno = old_errno;
 
1581
  return ret_errno;
 
1582
}
 
1583
 
 
1584
/* Set effective and real user ID to 0.  Return errno. */
 
1585
__attribute__((warn_unused_result))
 
1586
error_t raise_privileges_permanently(void){
 
1587
  error_t old_errno = errno;
 
1588
  error_t ret_errno = raise_privileges();
 
1589
  if(ret_errno != 0){
 
1590
    errno = old_errno;
 
1591
    return ret_errno;
 
1592
  }
 
1593
  if(setuid(0) == -1){
 
1594
    ret_errno = errno;
 
1595
  }
 
1596
  errno = old_errno;
 
1597
  return ret_errno;
 
1598
}
 
1599
 
 
1600
/* Set effective user ID to unprivileged saved user ID */
 
1601
__attribute__((warn_unused_result))
 
1602
error_t lower_privileges(void){
 
1603
  error_t old_errno = errno;
 
1604
  error_t ret_errno = 0;
 
1605
  if(seteuid(uid) == -1){
 
1606
    ret_errno = errno;
 
1607
  }
 
1608
  errno = old_errno;
 
1609
  return ret_errno;
 
1610
}
 
1611
 
 
1612
/* Lower privileges permanently */
 
1613
__attribute__((warn_unused_result))
 
1614
error_t lower_privileges_permanently(void){
 
1615
  error_t old_errno = errno;
 
1616
  error_t ret_errno = 0;
 
1617
  if(setuid(uid) == -1){
 
1618
    ret_errno = errno;
 
1619
  }
 
1620
  errno = old_errno;
 
1621
  return ret_errno;
 
1622
}
 
1623
 
2077
1624
__attribute__((nonnull))
2078
1625
void run_network_hooks(const char *mode, const char *interface,
2079
1626
                       const float delay){
2080
1627
  struct dirent **direntries = NULL;
2081
1628
  if(hookdir_fd == -1){
2082
 
    hookdir_fd = open(hookdir, O_RDONLY | O_DIRECTORY | O_PATH
2083
 
                      | O_CLOEXEC);
 
1629
    hookdir_fd = open(hookdir, O_RDONLY);
2084
1630
    if(hookdir_fd == -1){
2085
1631
      if(errno == ENOENT){
2086
1632
        if(debug){
2093
1639
      return;
2094
1640
    }
2095
1641
  }
2096
 
  int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
2097
 
  if(devnull == -1){
2098
 
    perror_plus("open(\"/dev/null\", O_RDONLY)");
2099
 
    return;
2100
 
  }
 
1642
#ifdef __GLIBC__
 
1643
#if __GLIBC_PREREQ(2, 15)
2101
1644
  int numhooks = scandirat(hookdir_fd, ".", &direntries,
2102
1645
                           runnable_hook, alphasort);
 
1646
#else  /* not __GLIBC_PREREQ(2, 15) */
 
1647
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
 
1648
                         alphasort);
 
1649
#endif  /* not __GLIBC_PREREQ(2, 15) */
 
1650
#else   /* not __GLIBC__ */
 
1651
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
 
1652
                         alphasort);
 
1653
#endif  /* not __GLIBC__ */
2103
1654
  if(numhooks == -1){
2104
1655
    perror_plus("scandir");
2105
 
    close(devnull);
2106
1656
    return;
2107
1657
  }
2108
1658
  struct dirent *direntry;
2109
1659
  int ret;
 
1660
  int devnull = open("/dev/null", O_RDONLY);
2110
1661
  for(int i = 0; i < numhooks; i++){
2111
1662
    direntry = direntries[i];
2112
1663
    if(debug){
2136
1687
        perror_plus("setgroups");
2137
1688
        _exit(EX_NOPERM);
2138
1689
      }
 
1690
      ret = dup2(devnull, STDIN_FILENO);
 
1691
      if(ret == -1){
 
1692
        perror_plus("dup2(devnull, STDIN_FILENO)");
 
1693
        _exit(EX_OSERR);
 
1694
      }
 
1695
      ret = close(devnull);
 
1696
      if(ret == -1){
 
1697
        perror_plus("close");
 
1698
        _exit(EX_OSERR);
 
1699
      }
 
1700
      ret = dup2(STDERR_FILENO, STDOUT_FILENO);
 
1701
      if(ret == -1){
 
1702
        perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
 
1703
        _exit(EX_OSERR);
 
1704
      }
2139
1705
      ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
2140
1706
      if(ret == -1){
2141
1707
        perror_plus("setenv");
2176
1742
          _exit(EX_OSERR);
2177
1743
        }
2178
1744
      }
2179
 
      int hook_fd = (int)TEMP_FAILURE_RETRY(openat(hookdir_fd,
2180
 
                                                   direntry->d_name,
2181
 
                                                   O_RDONLY));
 
1745
      int hook_fd = openat(hookdir_fd, direntry->d_name, O_RDONLY);
2182
1746
      if(hook_fd == -1){
2183
1747
        perror_plus("openat");
2184
1748
        _exit(EXIT_FAILURE);
2185
1749
      }
2186
 
      if(close(hookdir_fd) == -1){
 
1750
      if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
2187
1751
        perror_plus("close");
2188
1752
        _exit(EXIT_FAILURE);
2189
1753
      }
2190
 
      ret = dup2(devnull, STDIN_FILENO);
2191
 
      if(ret == -1){
2192
 
        perror_plus("dup2(devnull, STDIN_FILENO)");
2193
 
        _exit(EX_OSERR);
2194
 
      }
2195
 
      ret = close(devnull);
2196
 
      if(ret == -1){
2197
 
        perror_plus("close");
2198
 
        _exit(EX_OSERR);
2199
 
      }
2200
 
      ret = dup2(STDERR_FILENO, STDOUT_FILENO);
2201
 
      if(ret == -1){
2202
 
        perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
2203
 
        _exit(EX_OSERR);
2204
 
      }
2205
1754
      if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
2206
1755
                 environ) == -1){
2207
1756
        perror_plus("fexecve");
2247
1796
    free(direntry);
2248
1797
  }
2249
1798
  free(direntries);
2250
 
  if(close(hookdir_fd) == -1){
 
1799
  if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
2251
1800
    perror_plus("close");
2252
1801
  } else {
2253
1802
    hookdir_fd = -1;
2256
1805
}
2257
1806
 
2258
1807
__attribute__((nonnull, warn_unused_result))
2259
 
int bring_up_interface(const char *const interface,
2260
 
                       const float delay){
2261
 
  int old_errno = errno;
 
1808
error_t bring_up_interface(const char *const interface,
 
1809
                           const float delay){
 
1810
  error_t old_errno = errno;
2262
1811
  int ret;
2263
1812
  struct ifreq network;
2264
1813
  unsigned int if_index = if_nametoindex(interface);
2274
1823
  }
2275
1824
  
2276
1825
  if(not interface_is_up(interface)){
2277
 
    int ret_errno = 0;
2278
 
    int ioctl_errno = 0;
 
1826
    error_t ret_errno = 0, ioctl_errno = 0;
2279
1827
    if(not get_flags(interface, &network)){
2280
1828
      ret_errno = errno;
2281
1829
      fprintf_plus(stderr, "Failed to get flags for interface "
2294
1842
    }
2295
1843
    
2296
1844
    if(quit_now){
2297
 
      ret = close(sd);
 
1845
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
2298
1846
      if(ret == -1){
2299
1847
        perror_plus("close");
2300
1848
      }
2350
1898
    }
2351
1899
    
2352
1900
    /* Close the socket */
2353
 
    ret = close(sd);
 
1901
    ret = (int)TEMP_FAILURE_RETRY(close(sd));
2354
1902
    if(ret == -1){
2355
1903
      perror_plus("close");
2356
1904
    }
2368
1916
  
2369
1917
  /* Sleep checking until interface is running.
2370
1918
     Check every 0.25s, up to total time of delay */
2371
 
  for(int i = 0; i < delay * 4; i++){
 
1919
  for(int i=0; i < delay * 4; i++){
2372
1920
    if(interface_is_running(interface)){
2373
1921
      break;
2374
1922
    }
2384
1932
}
2385
1933
 
2386
1934
__attribute__((nonnull, warn_unused_result))
2387
 
int take_down_interface(const char *const interface){
2388
 
  int old_errno = errno;
 
1935
error_t take_down_interface(const char *const interface){
 
1936
  error_t old_errno = errno;
2389
1937
  struct ifreq network;
2390
1938
  unsigned int if_index = if_nametoindex(interface);
2391
1939
  if(if_index == 0){
2394
1942
    return ENXIO;
2395
1943
  }
2396
1944
  if(interface_is_up(interface)){
2397
 
    int ret_errno = 0;
2398
 
    int ioctl_errno = 0;
 
1945
    error_t ret_errno = 0, ioctl_errno = 0;
2399
1946
    if(not get_flags(interface, &network) and debug){
2400
1947
      ret_errno = errno;
2401
1948
      fprintf_plus(stderr, "Failed to get flags for interface "
2439
1986
    }
2440
1987
    
2441
1988
    /* Close the socket */
2442
 
    int ret = close(sd);
 
1989
    int ret = (int)TEMP_FAILURE_RETRY(close(sd));
2443
1990
    if(ret == -1){
2444
1991
      perror_plus("close");
2445
1992
    }
2461
2008
 
2462
2009
int main(int argc, char *argv[]){
2463
2010
  mandos_context mc = { .server = NULL, .dh_bits = 0,
2464
 
#if GNUTLS_VERSION_NUMBER >= 0x030606
2465
 
                        .priority = "SECURE128:!CTYPE-X.509"
2466
 
                        ":+CTYPE-RAWPK:!RSA:!VERS-ALL:+VERS-TLS1.3"
2467
 
                        ":%PROFILE_ULTRA",
2468
 
#elif GNUTLS_VERSION_NUMBER < 0x030600
2469
 
                        .priority = "SECURE256:!CTYPE-X.509"
2470
 
                        ":+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256",
2471
 
#else
2472
 
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
2473
 
#endif
2474
 
                        .current_server = NULL, .interfaces = NULL,
2475
 
                        .interfaces_size = 0 };
 
2011
                        .priority = "SECURE256:!CTYPE-X.509:"
 
2012
                        "+CTYPE-OPENPGP:!RSA", .current_server = NULL,
 
2013
                        .interfaces = NULL, .interfaces_size = 0 };
2476
2014
  AvahiSServiceBrowser *sb = NULL;
2477
2015
  error_t ret_errno;
2478
2016
  int ret;
2487
2025
  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
2488
2026
  const char *seckey = PATHDIR "/" SECKEY;
2489
2027
  const char *pubkey = PATHDIR "/" PUBKEY;
2490
 
#if GNUTLS_VERSION_NUMBER >= 0x030606
2491
 
  const char *tls_privkey = PATHDIR "/" TLS_PRIVKEY;
2492
 
  const char *tls_pubkey = PATHDIR "/" TLS_PUBKEY;
2493
 
#endif
2494
 
  const char *dh_params_file = NULL;
2495
2028
  char *interfaces_hooks = NULL;
2496
2029
  
2497
2030
  bool gnutls_initialized = false;
2544
2077
      { .name = "pubkey", .key = 'p',
2545
2078
        .arg = "FILE",
2546
2079
        .doc = "OpenPGP public key file base name",
2547
 
        .group = 1 },
2548
 
      { .name = "tls-privkey", .key = 't',
2549
 
        .arg = "FILE",
2550
 
#if GNUTLS_VERSION_NUMBER >= 0x030606
2551
 
        .doc = "TLS private key file base name",
2552
 
#else
2553
 
        .doc = "Dummy; ignored (requires GnuTLS 3.6.6)",
2554
 
#endif
2555
 
        .group = 1 },
2556
 
      { .name = "tls-pubkey", .key = 'T',
2557
 
        .arg = "FILE",
2558
 
#if GNUTLS_VERSION_NUMBER >= 0x030606
2559
 
        .doc = "TLS public key file base name",
2560
 
#else
2561
 
        .doc = "Dummy; ignored (requires GnuTLS 3.6.6)",
2562
 
#endif
2563
 
        .group = 1 },
 
2080
        .group = 2 },
2564
2081
      { .name = "dh-bits", .key = 129,
2565
2082
        .arg = "BITS",
2566
2083
        .doc = "Bit length of the prime number used in the"
2567
2084
        " Diffie-Hellman key exchange",
2568
2085
        .group = 2 },
2569
 
      { .name = "dh-params", .key = 134,
2570
 
        .arg = "FILE",
2571
 
        .doc = "PEM-encoded PKCS#3 file with pre-generated parameters"
2572
 
        " for the Diffie-Hellman key exchange",
2573
 
        .group = 2 },
2574
2086
      { .name = "priority", .key = 130,
2575
2087
        .arg = "STRING",
2576
2088
        .doc = "GnuTLS priority string for the TLS handshake",
2622
2134
      case 'p':                 /* --pubkey */
2623
2135
        pubkey = arg;
2624
2136
        break;
2625
 
      case 't':                 /* --tls-privkey */
2626
 
#if GNUTLS_VERSION_NUMBER >= 0x030606
2627
 
        tls_privkey = arg;
2628
 
#endif
2629
 
        break;
2630
 
      case 'T':                 /* --tls-pubkey */
2631
 
#if GNUTLS_VERSION_NUMBER >= 0x030606
2632
 
        tls_pubkey = arg;
2633
 
#endif
2634
 
        break;
2635
2137
      case 129:                 /* --dh-bits */
2636
2138
        errno = 0;
2637
2139
        tmpmax = strtoimax(arg, &tmp, 10);
2641
2143
        }
2642
2144
        mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
2643
2145
        break;
2644
 
      case 134:                 /* --dh-params */
2645
 
        dh_params_file = arg;
2646
 
        break;
2647
2146
      case 130:                 /* --priority */
2648
2147
        mc.priority = arg;
2649
2148
        break;
2689
2188
                         .args_doc = "",
2690
2189
                         .doc = "Mandos client -- Get and decrypt"
2691
2190
                         " passwords from a Mandos server" };
2692
 
    ret_errno = argp_parse(&argp, argc, argv,
2693
 
                           ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2694
 
    switch(ret_errno){
 
2191
    ret = argp_parse(&argp, argc, argv,
 
2192
                     ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
 
2193
    switch(ret){
2695
2194
    case 0:
2696
2195
      break;
2697
2196
    case ENOMEM:
2698
2197
    default:
2699
 
      errno = ret_errno;
 
2198
      errno = ret;
2700
2199
      perror_plus("argp_parse");
2701
2200
      exitcode = EX_OSERR;
2702
2201
      goto end;
2705
2204
      goto end;
2706
2205
    }
2707
2206
  }
2708
 
  
 
2207
    
2709
2208
  {
2710
2209
    /* Work around Debian bug #633582:
2711
 
       <https://bugs.debian.org/633582> */
 
2210
       <http://bugs.debian.org/633582> */
2712
2211
    
2713
2212
    /* Re-raise privileges */
2714
 
    ret = raise_privileges();
2715
 
    if(ret != 0){
2716
 
      errno = ret;
 
2213
    ret_errno = raise_privileges();
 
2214
    if(ret_errno != 0){
 
2215
      errno = ret_errno;
2717
2216
      perror_plus("Failed to raise privileges");
2718
2217
    } else {
2719
2218
      struct stat st;
2735
2234
              }
2736
2235
            }
2737
2236
          }
2738
 
          close(seckey_fd);
 
2237
          TEMP_FAILURE_RETRY(close(seckey_fd));
2739
2238
        }
2740
2239
      }
2741
 
      
 
2240
    
2742
2241
      if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2743
2242
        int pubkey_fd = open(pubkey, O_RDONLY);
2744
2243
        if(pubkey_fd == -1){
2756
2255
              }
2757
2256
            }
2758
2257
          }
2759
 
          close(pubkey_fd);
2760
 
        }
2761
 
      }
2762
 
      
2763
 
      if(dh_params_file != NULL
2764
 
         and strcmp(dh_params_file, PATHDIR "/dhparams.pem" ) == 0){
2765
 
        int dhparams_fd = open(dh_params_file, O_RDONLY);
2766
 
        if(dhparams_fd == -1){
2767
 
          perror_plus("open");
2768
 
        } else {
2769
 
          ret = (int)TEMP_FAILURE_RETRY(fstat(dhparams_fd, &st));
2770
 
          if(ret == -1){
2771
 
            perror_plus("fstat");
2772
 
          } else {
2773
 
            if(S_ISREG(st.st_mode)
2774
 
               and st.st_uid == 0 and st.st_gid == 0){
2775
 
              ret = fchown(dhparams_fd, uid, gid);
2776
 
              if(ret == -1){
2777
 
                perror_plus("fchown");
2778
 
              }
2779
 
            }
2780
 
          }
2781
 
          close(dhparams_fd);
2782
 
        }
2783
 
      }
2784
 
      
 
2258
          TEMP_FAILURE_RETRY(close(pubkey_fd));
 
2259
        }
 
2260
      }
 
2261
    
2785
2262
      /* Lower privileges */
2786
 
      ret = lower_privileges();
2787
 
      if(ret != 0){
2788
 
        errno = ret;
 
2263
      ret_errno = lower_privileges();
 
2264
      if(ret_errno != 0){
 
2265
        errno = ret_errno;
2789
2266
        perror_plus("Failed to lower privileges");
2790
2267
      }
2791
2268
    }
2961
2438
      errno = bring_up_interface(interface, delay);
2962
2439
      if(not interface_was_up){
2963
2440
        if(errno != 0){
2964
 
          fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
2965
 
                       " %s\n", interface, strerror(errno));
 
2441
          perror_plus("Failed to bring up interface");
2966
2442
        } else {
2967
2443
          errno = argz_add(&interfaces_to_take_down,
2968
2444
                           &interfaces_to_take_down_size,
2991
2467
    goto end;
2992
2468
  }
2993
2469
  
2994
 
#if GNUTLS_VERSION_NUMBER >= 0x030606
2995
 
  ret = init_gnutls_global(tls_pubkey, tls_privkey, dh_params_file, &mc);
2996
 
#elif GNUTLS_VERSION_NUMBER < 0x030600
2997
 
  ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
2998
 
#else
2999
 
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
3000
 
#endif
 
2470
  ret = init_gnutls_global(pubkey, seckey, &mc);
3001
2471
  if(ret == -1){
3002
2472
    fprintf_plus(stderr, "init_gnutls_global failed\n");
3003
2473
    exitcode = EX_UNAVAILABLE;
3125
2595
    
3126
2596
    /* Allocate a new server */
3127
2597
    mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
3128
 
                                 &config, NULL, NULL, &ret);
 
2598
                                 &config, NULL, NULL, &ret_errno);
3129
2599
    
3130
2600
    /* Free the Avahi configuration data */
3131
2601
    avahi_server_config_free(&config);
3134
2604
  /* Check if creating the Avahi server object succeeded */
3135
2605
  if(mc.server == NULL){
3136
2606
    fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
3137
 
                 avahi_strerror(ret));
 
2607
                 avahi_strerror(ret_errno));
3138
2608
    exitcode = EX_UNAVAILABLE;
3139
2609
    goto end;
3140
2610
  }
3175
2645
 end:
3176
2646
  
3177
2647
  if(debug){
3178
 
    if(signal_received){
3179
 
      fprintf_plus(stderr, "%s exiting due to signal %d: %s\n",
3180
 
                   argv[0], signal_received,
3181
 
                   strsignal(signal_received));
3182
 
    } else {
3183
 
      fprintf_plus(stderr, "%s exiting\n", argv[0]);
3184
 
    }
 
2648
    fprintf_plus(stderr, "%s exiting\n", argv[0]);
3185
2649
  }
3186
2650
  
3187
2651
  /* Cleanup things */
3198
2662
  
3199
2663
  if(gnutls_initialized){
3200
2664
    gnutls_certificate_free_credentials(mc.cred);
 
2665
    gnutls_global_deinit();
3201
2666
    gnutls_dh_params_deinit(mc.dh_params);
3202
2667
  }
3203
2668
  
3226
2691
  
3227
2692
  /* Re-raise privileges */
3228
2693
  {
3229
 
    ret = raise_privileges();
3230
 
    if(ret != 0){
3231
 
      errno = ret;
 
2694
    ret_errno = raise_privileges();
 
2695
    if(ret_errno != 0){
 
2696
      errno = ret_errno;
3232
2697
      perror_plus("Failed to raise privileges");
3233
2698
    } else {
3234
2699
      
3239
2704
      /* Take down the network interfaces which were brought up */
3240
2705
      {
3241
2706
        char *interface = NULL;
3242
 
        while((interface = argz_next(interfaces_to_take_down,
3243
 
                                     interfaces_to_take_down_size,
3244
 
                                     interface))){
3245
 
          ret = take_down_interface(interface);
3246
 
          if(ret != 0){
3247
 
            errno = ret;
 
2707
        while((interface=argz_next(interfaces_to_take_down,
 
2708
                                   interfaces_to_take_down_size,
 
2709
                                   interface))){
 
2710
          ret_errno = take_down_interface(interface);
 
2711
          if(ret_errno != 0){
 
2712
            errno = ret_errno;
3248
2713
            perror_plus("Failed to take down interface");
3249
2714
          }
3250
2715
        }
3255
2720
      }
3256
2721
    }
3257
2722
    
3258
 
    ret = lower_privileges_permanently();
3259
 
    if(ret != 0){
3260
 
      errno = ret;
 
2723
    ret_errno = lower_privileges_permanently();
 
2724
    if(ret_errno != 0){
 
2725
      errno = ret_errno;
3261
2726
      perror_plus("Failed to lower privileges permanently");
3262
2727
    }
3263
2728
  }
3265
2730
  free(interfaces_to_take_down);
3266
2731
  free(interfaces_hooks);
3267
2732
  
3268
 
  void clean_dir_at(int base, const char * const dirname,
3269
 
                    uintmax_t level){
3270
 
    struct dirent **direntries = NULL;
3271
 
    int dret;
3272
 
    int dir_fd = (int)TEMP_FAILURE_RETRY(openat(base, dirname,
3273
 
                                                O_RDONLY
3274
 
                                                | O_NOFOLLOW
3275
 
                                                | O_DIRECTORY
3276
 
                                                | O_PATH));
3277
 
    if(dir_fd == -1){
3278
 
      perror_plus("open");
3279
 
      return;
3280
 
    }
3281
 
    int numentries = scandirat(dir_fd, ".", &direntries,
3282
 
                               notdotentries, alphasort);
3283
 
    if(numentries >= 0){
3284
 
      for(int i = 0; i < numentries; i++){
3285
 
        if(debug){
3286
 
          fprintf_plus(stderr, "Unlinking \"%s/%s\"\n",
3287
 
                       dirname, direntries[i]->d_name);
3288
 
        }
3289
 
        dret = unlinkat(dir_fd, direntries[i]->d_name, 0);
3290
 
        if(dret == -1){
3291
 
          if(errno == EISDIR){
3292
 
              dret = unlinkat(dir_fd, direntries[i]->d_name,
3293
 
                              AT_REMOVEDIR);
3294
 
          }         
3295
 
          if((dret == -1) and (errno == ENOTEMPTY)
3296
 
             and (strcmp(direntries[i]->d_name, "private-keys-v1.d")
3297
 
                  == 0) and (level == 0)){
3298
 
            /* Recurse only in this special case */
3299
 
            clean_dir_at(dir_fd, direntries[i]->d_name, level+1);
3300
 
            dret = 0;
3301
 
          }
3302
 
          if((dret == -1) and (errno != ENOENT)){
3303
 
            fprintf_plus(stderr, "unlink(\"%s/%s\"): %s\n", dirname,
3304
 
                         direntries[i]->d_name, strerror(errno));
3305
 
          }
3306
 
        }
3307
 
        free(direntries[i]);
3308
 
      }
3309
 
      
3310
 
      /* need to clean even if 0 because man page doesn't specify */
3311
 
      free(direntries);
3312
 
      dret = unlinkat(base, dirname, AT_REMOVEDIR);
3313
 
      if(dret == -1 and errno != ENOENT){
3314
 
        perror_plus("rmdir");
3315
 
      }
3316
 
    } else {
3317
 
      perror_plus("scandirat");
3318
 
    }
3319
 
    close(dir_fd);
3320
 
  }
3321
 
  
3322
2733
  /* Removes the GPGME temp directory and all files inside */
3323
2734
  if(tempdir != NULL){
3324
 
    clean_dir_at(-1, tempdir, 0);
 
2735
    struct dirent **direntries = NULL;
 
2736
    int tempdir_fd = (int)TEMP_FAILURE_RETRY(open(tempdir, O_RDONLY |
 
2737
                                                  O_NOFOLLOW));
 
2738
    if(tempdir_fd == -1){
 
2739
      perror_plus("open");
 
2740
    } else {
 
2741
#ifdef __GLIBC__
 
2742
#if __GLIBC_PREREQ(2, 15)
 
2743
      int numentries = scandirat(tempdir_fd, ".", &direntries,
 
2744
                                 notdotentries, alphasort);
 
2745
#else  /* not __GLIBC_PREREQ(2, 15) */
 
2746
      int numentries = scandir(tempdir, &direntries, notdotentries,
 
2747
                               alphasort);
 
2748
#endif  /* not __GLIBC_PREREQ(2, 15) */
 
2749
#else   /* not __GLIBC__ */
 
2750
      int numentries = scandir(tempdir, &direntries, notdotentries,
 
2751
                               alphasort);
 
2752
#endif  /* not __GLIBC__ */
 
2753
      if(numentries >= 0){
 
2754
        for(int i = 0; i < numentries; i++){
 
2755
          ret = unlinkat(tempdir_fd, direntries[i]->d_name, 0);
 
2756
          if(ret == -1){
 
2757
            fprintf_plus(stderr, "unlinkat(open(\"%s\", O_RDONLY),"
 
2758
                         " \"%s\", 0): %s\n", tempdir,
 
2759
                         direntries[i]->d_name, strerror(errno));
 
2760
          }
 
2761
          free(direntries[i]);
 
2762
        }
 
2763
        
 
2764
        /* need to clean even if 0 because man page doesn't specify */
 
2765
        free(direntries);
 
2766
        if(numentries == -1){
 
2767
          perror_plus("scandir");
 
2768
        }
 
2769
        ret = rmdir(tempdir);
 
2770
        if(ret == -1 and errno != ENOENT){
 
2771
          perror_plus("rmdir");
 
2772
        }
 
2773
      }
 
2774
      TEMP_FAILURE_RETRY(close(tempdir_fd));
 
2775
    }
3325
2776
  }
3326
2777
  
3327
2778
  if(quit_now){