/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/mandos-client.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:
plugins.d/mandos-client.c
9
9
 * "browse_callback", and parts of "main".
10
10
 * 
11
11
 * Everything else is
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
 
12
 * Copyright © 2008-2020 Teddy Hogeborn
 
13
 * Copyright © 2008-2020 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
21
23
 * WITHOUT ANY WARRANTY; without even the implied warranty of
22
24
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
23
25
 * General Public License for more details.
24
26
 * 
25
27
 * You should have received a copy of the GNU General Public License
26
 
 * along with this program.  If not, see
27
 
 * <http://www.gnu.org/licenses/>.
 
28
 * along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
28
29
 * 
29
30
 * Contact the authors at <mandos@recompile.se>.
30
31
 */
46
47
#include <stdlib.h>             /* free(), EXIT_SUCCESS, srand(),
47
48
                                   strtof(), abort() */
48
49
#include <stdbool.h>            /* bool, false, true */
49
 
#include <string.h>             /* memset(), strcmp(), strlen(),
50
 
                                   strerror(), asprintf(), strcpy() */
 
50
#include <string.h>             /* strcmp(), strlen(), strerror(),
 
51
                                   asprintf(), strncpy(), strsignal()
 
52
                                */
51
53
#include <sys/ioctl.h>          /* ioctl */
52
54
#include <sys/types.h>          /* socket(), inet_pton(), sockaddr,
53
55
                                   sockaddr_in6, PF_INET6,
57
59
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
58
60
                                   inet_pton(), connect(),
59
61
                                   getnameinfo() */
60
 
#include <fcntl.h>              /* open(), unlinkat() */
 
62
#include <fcntl.h>              /* open(), unlinkat(), AT_REMOVEDIR */
61
63
#include <dirent.h>             /* opendir(), struct dirent, readdir()
62
64
                                 */
63
65
#include <inttypes.h>           /* PRIu16, PRIdMAX, intmax_t,
64
66
                                   strtoimax() */
65
 
#include <errno.h>              /* perror(), errno,
 
67
#include <errno.h>              /* perror(), errno, EINTR, EINVAL,
 
68
                                   EAI_SYSTEM, ENETUNREACH,
 
69
                                   EHOSTUNREACH, ECONNREFUSED, EPROTO,
 
70
                                   EIO, ENOENT, ENXIO, ENOMEM, EISDIR,
 
71
                                   ENOTEMPTY,
66
72
                                   program_invocation_short_name */
67
73
#include <time.h>               /* nanosleep(), time(), sleep() */
68
74
#include <net/if.h>             /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
117
123
                                   gnutls_*
118
124
                                   init_gnutls_session(),
119
125
                                   GNUTLS_* */
 
126
#if GNUTLS_VERSION_NUMBER < 0x030600
120
127
#include <gnutls/openpgp.h>
121
128
                         /* gnutls_certificate_set_openpgp_key_file(),
122
129
                            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
123
135
 
124
136
/* GPGME */
125
137
#include <gpgme.h>              /* All GPGME types, constants and
133
145
#define PATHDIR "/conf/conf.d/mandos"
134
146
#define SECKEY "seckey.txt"
135
147
#define PUBKEY "pubkey.txt"
 
148
#define TLS_PRIVKEY "tls-privkey.pem"
 
149
#define TLS_PUBKEY "tls-pubkey.pem"
136
150
#define HOOKDIR "/lib/mandos/network-hooks.d"
137
151
 
138
152
bool debug = false;
266
280
  return true;
267
281
}
268
282
 
 
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
 
269
335
/* 
270
336
 * Initialize GPGME.
271
337
 */
291
357
      return false;
292
358
    }
293
359
    
 
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
      if(clock_settime(CLOCK_REALTIME, &keystat.st_mtim) != 0){
 
400
        perror_plus("clock_settime");
 
401
      }
 
402
      ret = lower_privileges();
 
403
      if(ret != 0){
 
404
        errno = ret;
 
405
        perror_plus("Failed to lower privileges");
 
406
      }
 
407
    } while(false);
 
408
 
294
409
    rc = gpgme_data_new_from_fd(&pgp_data, fd);
295
410
    if(rc != GPG_ERR_NO_ERROR){
296
411
      fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
304
419
                   gpgme_strsource(rc), gpgme_strerror(rc));
305
420
      return false;
306
421
    }
 
422
    {
 
423
      gpgme_import_result_t import_result
 
424
        = gpgme_op_import_result(mc->ctx);
 
425
      if((import_result->imported < 1
 
426
          or import_result->not_imported > 0)
 
427
         and import_result->unchanged == 0){
 
428
        fprintf_plus(stderr, "bad gpgme_op_import_results:\n");
 
429
        fprintf_plus(stderr,
 
430
                     "The total number of considered keys: %d\n",
 
431
                     import_result->considered);
 
432
        fprintf_plus(stderr,
 
433
                     "The number of keys without user ID: %d\n",
 
434
                     import_result->no_user_id);
 
435
        fprintf_plus(stderr,
 
436
                     "The total number of imported keys: %d\n",
 
437
                     import_result->imported);
 
438
        fprintf_plus(stderr, "The number of imported RSA keys: %d\n",
 
439
                     import_result->imported_rsa);
 
440
        fprintf_plus(stderr, "The number of unchanged keys: %d\n",
 
441
                     import_result->unchanged);
 
442
        fprintf_plus(stderr, "The number of new user IDs: %d\n",
 
443
                     import_result->new_user_ids);
 
444
        fprintf_plus(stderr, "The number of new sub keys: %d\n",
 
445
                     import_result->new_sub_keys);
 
446
        fprintf_plus(stderr, "The number of new signatures: %d\n",
 
447
                     import_result->new_signatures);
 
448
        fprintf_plus(stderr, "The number of new revocations: %d\n",
 
449
                     import_result->new_revocations);
 
450
        fprintf_plus(stderr,
 
451
                     "The total number of secret keys read: %d\n",
 
452
                     import_result->secret_read);
 
453
        fprintf_plus(stderr,
 
454
                     "The number of imported secret keys: %d\n",
 
455
                     import_result->secret_imported);
 
456
        fprintf_plus(stderr,
 
457
                     "The number of unchanged secret keys: %d\n",
 
458
                     import_result->secret_unchanged);
 
459
        fprintf_plus(stderr, "The number of keys not imported: %d\n",
 
460
                     import_result->not_imported);
 
461
        for(gpgme_import_status_t import_status
 
462
              = import_result->imports;
 
463
            import_status != NULL;
 
464
            import_status = import_status->next){
 
465
          fprintf_plus(stderr, "Import status for key: %s\n",
 
466
                       import_status->fpr);
 
467
          if(import_status->result != GPG_ERR_NO_ERROR){
 
468
            fprintf_plus(stderr, "Import result: %s: %s\n",
 
469
                         gpgme_strsource(import_status->result),
 
470
                         gpgme_strerror(import_status->result));
 
471
          }
 
472
          fprintf_plus(stderr, "Key status:\n");
 
473
          fprintf_plus(stderr,
 
474
                       import_status->status & GPGME_IMPORT_NEW
 
475
                       ? "The key was new.\n"
 
476
                       : "The key was not new.\n");
 
477
          fprintf_plus(stderr,
 
478
                       import_status->status & GPGME_IMPORT_UID
 
479
                       ? "The key contained new user IDs.\n"
 
480
                       : "The key did not contain new user IDs.\n");
 
481
          fprintf_plus(stderr,
 
482
                       import_status->status & GPGME_IMPORT_SIG
 
483
                       ? "The key contained new signatures.\n"
 
484
                       : "The key did not contain new signatures.\n");
 
485
          fprintf_plus(stderr,
 
486
                       import_status->status & GPGME_IMPORT_SUBKEY
 
487
                       ? "The key contained new sub keys.\n"
 
488
                       : "The key did not contain new sub keys.\n");
 
489
          fprintf_plus(stderr,
 
490
                       import_status->status & GPGME_IMPORT_SECRET
 
491
                       ? "The key contained a secret key.\n"
 
492
                       : "The key did not contain a secret key.\n");
 
493
        }
 
494
        return false;
 
495
      }
 
496
    }
307
497
    
308
 
    ret = (int)TEMP_FAILURE_RETRY(close(fd));
 
498
    ret = close(fd);
309
499
    if(ret == -1){
310
500
      perror_plus("close");
311
501
    }
350
540
  /* Create new GPGME "context" */
351
541
  rc = gpgme_new(&(mc->ctx));
352
542
  if(rc != GPG_ERR_NO_ERROR){
353
 
    fprintf_plus(stderr, "Mandos plugin mandos-client: "
354
 
                 "bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
355
 
                 gpgme_strerror(rc));
 
543
    fprintf_plus(stderr, "bad gpgme_new: %s: %s\n",
 
544
                 gpgme_strsource(rc), gpgme_strerror(rc));
356
545
    return false;
357
546
  }
358
547
  
394
583
  /* Create new empty GPGME data buffer for the plaintext */
395
584
  rc = gpgme_data_new(&dh_plain);
396
585
  if(rc != GPG_ERR_NO_ERROR){
397
 
    fprintf_plus(stderr, "Mandos plugin mandos-client: "
398
 
                 "bad gpgme_data_new: %s: %s\n",
 
586
    fprintf_plus(stderr, "bad gpgme_data_new: %s: %s\n",
399
587
                 gpgme_strsource(rc), gpgme_strerror(rc));
400
588
    gpgme_data_release(dh_crypto);
401
589
    return -1;
414
602
      if(result == NULL){
415
603
        fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
416
604
      } else {
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);
 
605
        if(result->unsupported_algorithm != NULL) {
 
606
          fprintf_plus(stderr, "Unsupported algorithm: %s\n",
 
607
                       result->unsupported_algorithm);
 
608
        }
 
609
        fprintf_plus(stderr, "Wrong key usage: %s\n",
 
610
                     result->wrong_key_usage ? "Yes" : "No");
421
611
        if(result->file_name != NULL){
422
612
          fprintf_plus(stderr, "File name: %s\n", result->file_name);
423
613
        }
424
 
        gpgme_recipient_t recipient;
425
 
        recipient = result->recipients;
426
 
        while(recipient != NULL){
 
614
 
 
615
        for(gpgme_recipient_t r = result->recipients; r != NULL;
 
616
            r = r->next){
427
617
          fprintf_plus(stderr, "Public key algorithm: %s\n",
428
 
                       gpgme_pubkey_algo_name
429
 
                       (recipient->pubkey_algo));
430
 
          fprintf_plus(stderr, "Key ID: %s\n", recipient->keyid);
 
618
                       gpgme_pubkey_algo_name(r->pubkey_algo));
 
619
          fprintf_plus(stderr, "Key ID: %s\n", r->keyid);
431
620
          fprintf_plus(stderr, "Secret key available: %s\n",
432
 
                       recipient->status == GPG_ERR_NO_SECKEY
433
 
                       ? "No" : "Yes");
434
 
          recipient = recipient->next;
 
621
                       r->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
435
622
        }
436
623
      }
437
624
    }
513
700
  fprintf_plus(stderr, "GnuTLS: %s", string);
514
701
}
515
702
 
516
 
__attribute__((nonnull, warn_unused_result))
 
703
__attribute__((nonnull(1, 2, 4), warn_unused_result))
517
704
static int init_gnutls_global(const char *pubkeyfilename,
518
705
                              const char *seckeyfilename,
 
706
                              const char *dhparamsfilename,
519
707
                              mandos_context *mc){
520
708
  int ret;
521
 
  unsigned int uret;
522
709
  
523
710
  if(debug){
524
711
    fprintf_plus(stderr, "Initializing GnuTLS\n");
525
712
  }
526
713
  
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
 
  
534
714
  if(debug){
535
715
    /* "Use a log level over 10 to enable all debugging options."
536
716
     * - GnuTLS manual
544
724
  if(ret != GNUTLS_E_SUCCESS){
545
725
    fprintf_plus(stderr, "GnuTLS memory error: %s\n",
546
726
                 safer_gnutls_strerror(ret));
547
 
    gnutls_global_deinit();
548
727
    return -1;
549
728
  }
550
729
  
551
730
  if(debug){
552
 
    fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
553
 
                 " secret key %s as GnuTLS credentials\n",
 
731
    fprintf_plus(stderr, "Attempting to use public key %s and"
 
732
                 " private key %s as GnuTLS credentials\n",
554
733
                 pubkeyfilename,
555
734
                 seckeyfilename);
556
735
  }
557
736
  
 
737
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
738
  ret = gnutls_certificate_set_rawpk_key_file
 
739
    (mc->cred, pubkeyfilename, seckeyfilename,
 
740
     GNUTLS_X509_FMT_PEM,       /* format */
 
741
     NULL,                      /* pass */
 
742
     /* key_usage */
 
743
     GNUTLS_KEY_DIGITAL_SIGNATURE | GNUTLS_KEY_KEY_ENCIPHERMENT,
 
744
     NULL,                      /* names */
 
745
     0,                         /* names_length */
 
746
     /* privkey_flags */
 
747
     GNUTLS_PKCS_PLAIN | GNUTLS_PKCS_NULL_PASSWORD,
 
748
     0);                        /* pkcs11_flags */
 
749
#elif GNUTLS_VERSION_NUMBER < 0x030600
558
750
  ret = gnutls_certificate_set_openpgp_key_file
559
751
    (mc->cred, pubkeyfilename, seckeyfilename,
560
752
     GNUTLS_OPENPGP_FMT_BASE64);
 
753
#else
 
754
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
 
755
#endif
561
756
  if(ret != GNUTLS_E_SUCCESS){
562
757
    fprintf_plus(stderr,
563
 
                 "Error[%d] while reading the OpenPGP key pair ('%s',"
 
758
                 "Error[%d] while reading the key pair ('%s',"
564
759
                 " '%s')\n", ret, pubkeyfilename, seckeyfilename);
565
760
    fprintf_plus(stderr, "The GnuTLS error is: %s\n",
566
761
                 safer_gnutls_strerror(ret));
575
770
                 safer_gnutls_strerror(ret));
576
771
    goto globalfail;
577
772
  }
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;
 
773
  /* If a Diffie-Hellman parameters file was given, try to use it */
 
774
  if(dhparamsfilename != NULL){
 
775
    gnutls_datum_t params = { .data = NULL, .size = 0 };
 
776
    do {
 
777
      int dhpfile = open(dhparamsfilename, O_RDONLY);
 
778
      if(dhpfile == -1){
 
779
        perror_plus("open");
 
780
        dhparamsfilename = NULL;
 
781
        break;
 
782
      }
 
783
      size_t params_capacity = 0;
585
784
      while(true){
586
 
        buffer_capacity = incbuffer((char **)&buffer.data,
587
 
                                    (size_t)buffer.size,
588
 
                                    (size_t)buffer_capacity);
589
 
        if(buffer_capacity == 0){
 
785
        params_capacity = incbuffer((char **)&params.data,
 
786
                                    (size_t)params.size,
 
787
                                    (size_t)params_capacity);
 
788
        if(params_capacity == 0){
590
789
          perror_plus("incbuffer");
591
 
          free(buffer.data);
592
 
          buffer.data = NULL;
 
790
          free(params.data);
 
791
          params.data = NULL;
 
792
          dhparamsfilename = NULL;
593
793
          break;
594
794
        }
595
 
        ssize_t bytes_read = read(secfile, buffer.data + buffer.size,
 
795
        ssize_t bytes_read = read(dhpfile,
 
796
                                  params.data + params.size,
596
797
                                  BUFFER_SIZE);
597
798
        /* EOF */
598
799
        if(bytes_read == 0){
601
802
        /* check bytes_read for failure */
602
803
        if(bytes_read < 0){
603
804
          perror_plus("read");
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);
 
805
          free(params.data);
 
806
          params.data = NULL;
 
807
          dhparamsfilename = NULL;
 
808
          break;
 
809
        }
 
810
        params.size += (unsigned int)bytes_read;
 
811
      }
 
812
      ret = close(dhpfile);
 
813
      if(ret == -1){
 
814
        perror_plus("close");
 
815
      }
 
816
      if(params.data == NULL){
 
817
        dhparamsfilename = NULL;
 
818
      }
 
819
      if(dhparamsfilename == NULL){
 
820
        break;
 
821
      }
 
822
      ret = gnutls_dh_params_import_pkcs3(mc->dh_params, &params,
 
823
                                          GNUTLS_X509_FMT_PEM);
 
824
      if(ret != GNUTLS_E_SUCCESS){
 
825
        fprintf_plus(stderr, "Failed to parse DH parameters in file"
 
826
                     " \"%s\": %s\n", dhparamsfilename,
 
827
                     safer_gnutls_strerror(ret));
 
828
        dhparamsfilename = NULL;
 
829
      }
 
830
      free(params.data);
 
831
    } while(false);
 
832
  }
 
833
  if(dhparamsfilename == NULL){
 
834
    if(mc->dh_bits == 0){
 
835
#if GNUTLS_VERSION_NUMBER < 0x030600
 
836
      /* Find out the optimal number of DH bits */
 
837
      /* Try to read the private key file */
 
838
      gnutls_datum_t buffer = { .data = NULL, .size = 0 };
 
839
      do {
 
840
        int secfile = open(seckeyfilename, O_RDONLY);
 
841
        if(secfile == -1){
 
842
          perror_plus("open");
 
843
          break;
 
844
        }
 
845
        size_t buffer_capacity = 0;
 
846
        while(true){
 
847
          buffer_capacity = incbuffer((char **)&buffer.data,
 
848
                                      (size_t)buffer.size,
 
849
                                      (size_t)buffer_capacity);
 
850
          if(buffer_capacity == 0){
 
851
            perror_plus("incbuffer");
 
852
            free(buffer.data);
 
853
            buffer.data = NULL;
 
854
            break;
 
855
          }
 
856
          ssize_t bytes_read = read(secfile,
 
857
                                    buffer.data + buffer.size,
 
858
                                    BUFFER_SIZE);
 
859
          /* EOF */
 
860
          if(bytes_read == 0){
 
861
            break;
 
862
          }
 
863
          /* check bytes_read for failure */
 
864
          if(bytes_read < 0){
 
865
            perror_plus("read");
 
866
            free(buffer.data);
 
867
            buffer.data = NULL;
 
868
            break;
 
869
          }
 
870
          buffer.size += (unsigned int)bytes_read;
 
871
        }
 
872
        close(secfile);
 
873
      } while(false);
 
874
      /* If successful, use buffer to parse private key */
 
875
      gnutls_sec_param_t sec_param = GNUTLS_SEC_PARAM_ULTRA;
 
876
      if(buffer.data != NULL){
 
877
        {
 
878
          gnutls_openpgp_privkey_t privkey = NULL;
 
879
          ret = gnutls_openpgp_privkey_init(&privkey);
627
880
          if(ret != GNUTLS_E_SUCCESS){
628
 
            fprintf_plus(stderr, "Error importing OpenPGP key : %s",
 
881
            fprintf_plus(stderr, "Error initializing OpenPGP key"
 
882
                         " structure: %s",
629
883
                         safer_gnutls_strerror(ret));
630
 
            privkey = NULL;
 
884
            free(buffer.data);
 
885
            buffer.data = NULL;
 
886
          } else {
 
887
            ret = gnutls_openpgp_privkey_import
 
888
              (privkey, &buffer, GNUTLS_OPENPGP_FMT_BASE64, "", 0);
 
889
            if(ret != GNUTLS_E_SUCCESS){
 
890
              fprintf_plus(stderr, "Error importing OpenPGP key : %s",
 
891
                           safer_gnutls_strerror(ret));
 
892
              privkey = NULL;
 
893
            }
 
894
            free(buffer.data);
 
895
            buffer.data = NULL;
 
896
            if(privkey != NULL){
 
897
              /* Use private key to suggest an appropriate
 
898
                 sec_param */
 
899
              sec_param = gnutls_openpgp_privkey_sec_param(privkey);
 
900
              gnutls_openpgp_privkey_deinit(privkey);
 
901
              if(debug){
 
902
                fprintf_plus(stderr, "This OpenPGP key implies using"
 
903
                             " a GnuTLS security parameter \"%s\".\n",
 
904
                             safe_string(gnutls_sec_param_get_name
 
905
                                         (sec_param)));
 
906
              }
 
907
            }
631
908
          }
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
 
            }
 
909
        }
 
910
        if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
 
911
          /* Err on the side of caution */
 
912
          sec_param = GNUTLS_SEC_PARAM_ULTRA;
 
913
          if(debug){
 
914
            fprintf_plus(stderr, "Falling back to security parameter"
 
915
                         " \"%s\"\n",
 
916
                         safe_string(gnutls_sec_param_get_name
 
917
                                     (sec_param)));
644
918
          }
645
919
        }
646
920
      }
647
 
      if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
648
 
        /* Err on the side of caution */
649
 
        sec_param = GNUTLS_SEC_PARAM_ULTRA;
 
921
      unsigned int uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
 
922
      if(uret != 0){
 
923
        mc->dh_bits = uret;
650
924
        if(debug){
651
 
          fprintf_plus(stderr, "Falling back to security parameter"
652
 
                       " \"%s\"\n",
 
925
          fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
 
926
                       " implies %u DH bits; using that.\n",
653
927
                       safe_string(gnutls_sec_param_get_name
654
 
                                   (sec_param)));
 
928
                                   (sec_param)),
 
929
                       mc->dh_bits);
655
930
        }
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",
 
931
      } else {
 
932
        fprintf_plus(stderr, "Failed to get implied number of DH"
 
933
                     " bits for security parameter \"%s\"): %s\n",
664
934
                     safe_string(gnutls_sec_param_get_name
665
935
                                 (sec_param)),
 
936
                     safer_gnutls_strerror(ret));
 
937
        goto globalfail;
 
938
      }
 
939
#endif
 
940
    } else {                    /* dh_bits != 0 */
 
941
      if(debug){
 
942
        fprintf_plus(stderr, "DH bits explicitly set to %u\n",
666
943
                     mc->dh_bits);
667
944
      }
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;
 
945
      ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
 
946
      if(ret != GNUTLS_E_SUCCESS){
 
947
        fprintf_plus(stderr, "Error in GnuTLS prime generation (%u"
 
948
                     " bits): %s\n", mc->dh_bits,
 
949
                     safer_gnutls_strerror(ret));
 
950
        goto globalfail;
 
951
      }
 
952
      gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
674
953
    }
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);
 
954
  }
687
955
  
688
956
  return 0;
689
957
  
690
958
 globalfail:
691
959
  
692
960
  gnutls_certificate_free_credentials(mc->cred);
693
 
  gnutls_global_deinit();
694
961
  gnutls_dh_params_deinit(mc->dh_params);
695
962
  return -1;
696
963
}
701
968
  int ret;
702
969
  /* GnuTLS session creation */
703
970
  do {
704
 
    ret = gnutls_init(session, GNUTLS_SERVER);
 
971
    ret = gnutls_init(session, (GNUTLS_SERVER
 
972
#if GNUTLS_VERSION_NUMBER >= 0x030506
 
973
                                | GNUTLS_NO_TICKETS
 
974
#endif
 
975
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
976
                                | GNUTLS_ENABLE_RAWPK
 
977
#endif
 
978
                                ));
705
979
    if(quit_now){
706
980
      return -1;
707
981
    }
748
1022
  /* ignore client certificate if any. */
749
1023
  gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
750
1024
  
751
 
  gnutls_dh_set_prime_bits(*session, mc->dh_bits);
752
 
  
753
1025
  return 0;
754
1026
}
755
1027
 
757
1029
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
758
1030
                      __attribute__((unused)) const char *txt){}
759
1031
 
 
1032
/* Helper function to add_local_route() and delete_local_route() */
 
1033
__attribute__((nonnull, warn_unused_result))
 
1034
static bool add_delete_local_route(const bool add,
 
1035
                                   const char *address,
 
1036
                                   AvahiIfIndex if_index){
 
1037
  int ret;
 
1038
  char helper[] = "mandos-client-iprouteadddel";
 
1039
  char add_arg[] = "add";
 
1040
  char delete_arg[] = "delete";
 
1041
  char debug_flag[] = "--debug";
 
1042
  char *pluginhelperdir = getenv("MANDOSPLUGINHELPERDIR");
 
1043
  if(pluginhelperdir == NULL){
 
1044
    if(debug){
 
1045
      fprintf_plus(stderr, "MANDOSPLUGINHELPERDIR environment"
 
1046
                   " variable not set; cannot run helper\n");
 
1047
    }
 
1048
    return false;
 
1049
  }
 
1050
  
 
1051
  char interface[IF_NAMESIZE];
 
1052
  if(if_indextoname((unsigned int)if_index, interface) == NULL){
 
1053
    perror_plus("if_indextoname");
 
1054
    return false;
 
1055
  }
 
1056
  
 
1057
  int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
 
1058
  if(devnull == -1){
 
1059
    perror_plus("open(\"/dev/null\", O_RDONLY)");
 
1060
    return false;
 
1061
  }
 
1062
  pid_t pid = fork();
 
1063
  if(pid == 0){
 
1064
    /* Child */
 
1065
    /* Raise privileges */
 
1066
    errno = raise_privileges_permanently();
 
1067
    if(errno != 0){
 
1068
      perror_plus("Failed to raise privileges");
 
1069
      /* _exit(EX_NOPERM); */
 
1070
    } else {
 
1071
      /* Set group */
 
1072
      errno = 0;
 
1073
      ret = setgid(0);
 
1074
      if(ret == -1){
 
1075
        perror_plus("setgid");
 
1076
        close(devnull);
 
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
        close(devnull);
 
1085
        _exit(EX_NOPERM);
 
1086
      }
 
1087
    }
 
1088
    ret = dup2(devnull, STDIN_FILENO);
 
1089
    if(ret == -1){
 
1090
      perror_plus("dup2(devnull, STDIN_FILENO)");
 
1091
      close(devnull);
 
1092
      _exit(EX_OSERR);
 
1093
    }
 
1094
    ret = close(devnull);
 
1095
    if(ret == -1){
 
1096
      perror_plus("close");
 
1097
    }
 
1098
    ret = dup2(STDERR_FILENO, STDOUT_FILENO);
 
1099
    if(ret == -1){
 
1100
      perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
 
1101
      _exit(EX_OSERR);
 
1102
    }
 
1103
    int helperdir_fd = (int)TEMP_FAILURE_RETRY(open(pluginhelperdir,
 
1104
                                                    O_RDONLY
 
1105
                                                    | O_DIRECTORY
 
1106
                                                    | O_PATH
 
1107
                                                    | O_CLOEXEC));
 
1108
    if(helperdir_fd == -1){
 
1109
      perror_plus("open");
 
1110
      _exit(EX_UNAVAILABLE);
 
1111
    }
 
1112
    int helper_fd = (int)TEMP_FAILURE_RETRY(openat(helperdir_fd,
 
1113
                                                   helper, O_RDONLY));
 
1114
    if(helper_fd == -1){
 
1115
      perror_plus("openat");
 
1116
      close(helperdir_fd);
 
1117
      _exit(EX_UNAVAILABLE);
 
1118
    }
 
1119
    close(helperdir_fd);
 
1120
#ifdef __GNUC__
 
1121
#pragma GCC diagnostic push
 
1122
#pragma GCC diagnostic ignored "-Wcast-qual"
 
1123
#endif
 
1124
    if(fexecve(helper_fd, (char *const [])
 
1125
               { helper, add ? add_arg : delete_arg, (char *)address,
 
1126
                   interface, debug ? debug_flag : NULL, NULL },
 
1127
               environ) == -1){
 
1128
#ifdef __GNUC__
 
1129
#pragma GCC diagnostic pop
 
1130
#endif
 
1131
      perror_plus("fexecve");
 
1132
      _exit(EXIT_FAILURE);
 
1133
    }
 
1134
  }
 
1135
  if(pid == -1){
 
1136
    perror_plus("fork");
 
1137
    close(devnull);
 
1138
    return false;
 
1139
  }
 
1140
  ret = close(devnull);
 
1141
  if(ret == -1){
 
1142
    perror_plus("close");
 
1143
  }
 
1144
  int status;
 
1145
  pid_t pret = -1;
 
1146
  errno = 0;
 
1147
  do {
 
1148
    pret = waitpid(pid, &status, 0);
 
1149
    if(pret == -1 and errno == EINTR and quit_now){
 
1150
      int errno_raising = 0;
 
1151
      if((errno = raise_privileges()) != 0){
 
1152
        errno_raising = errno;
 
1153
        perror_plus("Failed to raise privileges in order to"
 
1154
                    " kill helper program");
 
1155
      }
 
1156
      if(kill(pid, SIGTERM) == -1){
 
1157
        perror_plus("kill");
 
1158
      }
 
1159
      if((errno_raising == 0) and (errno = lower_privileges()) != 0){
 
1160
        perror_plus("Failed to lower privileges after killing"
 
1161
                    " helper program");
 
1162
      }
 
1163
      return false;
 
1164
    }
 
1165
  } while(pret == -1 and errno == EINTR);
 
1166
  if(pret == -1){
 
1167
    perror_plus("waitpid");
 
1168
    return false;
 
1169
  }
 
1170
  if(WIFEXITED(status)){
 
1171
    if(WEXITSTATUS(status) != 0){
 
1172
      fprintf_plus(stderr, "Error: iprouteadddel exited"
 
1173
                   " with status %d\n", WEXITSTATUS(status));
 
1174
      return false;
 
1175
    }
 
1176
    return true;
 
1177
  }
 
1178
  if(WIFSIGNALED(status)){
 
1179
    fprintf_plus(stderr, "Error: iprouteadddel died by"
 
1180
                 " signal %d\n", WTERMSIG(status));
 
1181
    return false;
 
1182
  }
 
1183
  fprintf_plus(stderr, "Error: iprouteadddel crashed\n");
 
1184
  return false;
 
1185
}
 
1186
 
 
1187
__attribute__((nonnull, warn_unused_result))
 
1188
static bool add_local_route(const char *address,
 
1189
                            AvahiIfIndex if_index){
 
1190
  if(debug){
 
1191
    fprintf_plus(stderr, "Adding route to %s\n", address);
 
1192
  }
 
1193
  return add_delete_local_route(true, address, if_index);
 
1194
}
 
1195
 
 
1196
__attribute__((nonnull, warn_unused_result))
 
1197
static bool delete_local_route(const char *address,
 
1198
                               AvahiIfIndex if_index){
 
1199
  if(debug){
 
1200
    fprintf_plus(stderr, "Removing route to %s\n", address);
 
1201
  }
 
1202
  return add_delete_local_route(false, address, if_index);
 
1203
}
 
1204
 
760
1205
/* Called when a Mandos server is found */
761
1206
__attribute__((nonnull, warn_unused_result))
762
1207
static int start_mandos_communication(const char *ip, in_port_t port,
773
1218
  int retval = -1;
774
1219
  gnutls_session_t session;
775
1220
  int pf;                       /* Protocol family */
 
1221
  bool route_added = false;
776
1222
  
777
1223
  errno = 0;
778
1224
  
800
1246
    bool match = false;
801
1247
    {
802
1248
      char *interface = NULL;
803
 
      while((interface=argz_next(mc->interfaces, mc->interfaces_size,
804
 
                                 interface))){
 
1249
      while((interface = argz_next(mc->interfaces,
 
1250
                                   mc->interfaces_size,
 
1251
                                   interface))){
805
1252
        if(if_nametoindex(interface) == (unsigned int)if_index){
806
1253
          match = true;
807
1254
          break;
836
1283
                 PRIuMAX "\n", ip, (uintmax_t)port);
837
1284
  }
838
1285
  
839
 
  tcp_sd = socket(pf, SOCK_STREAM, 0);
 
1286
  tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
840
1287
  if(tcp_sd < 0){
841
1288
    int e = errno;
842
1289
    perror_plus("socket");
849
1296
    goto mandos_end;
850
1297
  }
851
1298
  
852
 
  memset(&to, 0, sizeof(to));
853
1299
  if(af == AF_INET6){
854
 
    ((struct sockaddr_in6 *)&to)->sin6_family = (sa_family_t)af;
855
 
    ret = inet_pton(af, ip, &((struct sockaddr_in6 *)&to)->sin6_addr);
 
1300
    struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)&to;
 
1301
    *to6 = (struct sockaddr_in6){ .sin6_family = (sa_family_t)af };
 
1302
    ret = inet_pton(af, ip, &to6->sin6_addr);
856
1303
  } else {                      /* IPv4 */
857
 
    ((struct sockaddr_in *)&to)->sin_family = (sa_family_t)af;
858
 
    ret = inet_pton(af, ip, &((struct sockaddr_in *)&to)->sin_addr);
 
1304
    struct sockaddr_in *to4 = (struct sockaddr_in *)&to;
 
1305
    *to4 = (struct sockaddr_in){ .sin_family = (sa_family_t)af };
 
1306
    ret = inet_pton(af, ip, &to4->sin_addr);
859
1307
  }
860
1308
  if(ret < 0 ){
861
1309
    int e = errno;
931
1379
    goto mandos_end;
932
1380
  }
933
1381
  
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;
 
1382
  while(true){
 
1383
    if(af == AF_INET6){
 
1384
      ret = connect(tcp_sd, (struct sockaddr *)&to,
 
1385
                    sizeof(struct sockaddr_in6));
 
1386
    } else {
 
1387
      ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
 
1388
                    sizeof(struct sockaddr_in));
 
1389
    }
 
1390
    if(ret < 0){
 
1391
      if(((errno == ENETUNREACH) or (errno == EHOSTUNREACH))
 
1392
         and if_index != AVAHI_IF_UNSPEC
 
1393
         and connect_to == NULL
 
1394
         and not route_added and
 
1395
         ((af == AF_INET6 and not
 
1396
           IN6_IS_ADDR_LINKLOCAL(&(((struct sockaddr_in6 *)
 
1397
                                    &to)->sin6_addr)))
 
1398
          or (af == AF_INET and
 
1399
              /* Not a a IPv4LL address */
 
1400
              (ntohl(((struct sockaddr_in *)&to)->sin_addr.s_addr)
 
1401
               & 0xFFFF0000L) != 0xA9FE0000L))){
 
1402
        /* Work around Avahi bug - Avahi does not announce link-local
 
1403
           addresses if it has a global address, so local hosts with
 
1404
           *only* a link-local address (e.g. Mandos clients) cannot
 
1405
           connect to a Mandos server announced by Avahi on a server
 
1406
           host with a global address.  Work around this by retrying
 
1407
           with an explicit route added with the server's address.
 
1408
           
 
1409
           Avahi bug reference:
 
1410
           https://lists.freedesktop.org/archives/avahi/2010-February/001833.html
 
1411
           https://bugs.debian.org/587961
 
1412
        */
 
1413
        if(debug){
 
1414
          fprintf_plus(stderr, "Mandos server unreachable, trying"
 
1415
                       " direct route\n");
 
1416
        }
 
1417
        int e = errno;
 
1418
        route_added = add_local_route(ip, if_index);
 
1419
        if(route_added){
 
1420
          continue;
 
1421
        }
 
1422
        errno = e;
 
1423
      }
 
1424
      if(errno != ECONNREFUSED or debug){
 
1425
        int e = errno;
 
1426
        perror_plus("connect");
 
1427
        errno = e;
 
1428
      }
 
1429
      goto mandos_end;
 
1430
    }
 
1431
    
 
1432
    if(quit_now){
 
1433
      errno = EINTR;
 
1434
      goto mandos_end;
 
1435
    }
 
1436
    break;
953
1437
  }
954
1438
  
955
1439
  const char *out = mandos_protocol_version;
1109
1593
                                               &decrypted_buffer, mc);
1110
1594
    if(decrypted_buffer_size >= 0){
1111
1595
      
 
1596
      clearerr(stdout);
1112
1597
      written = 0;
1113
1598
      while(written < (size_t) decrypted_buffer_size){
1114
1599
        if(quit_now){
1130
1615
        }
1131
1616
        written += (size_t)ret;
1132
1617
      }
 
1618
      ret = fflush(stdout);
 
1619
      if(ret != 0){
 
1620
        int e = errno;
 
1621
        if(debug){
 
1622
          fprintf_plus(stderr, "Error writing encrypted data: %s\n",
 
1623
                       strerror(errno));
 
1624
        }
 
1625
        errno = e;
 
1626
        goto mandos_end;
 
1627
      }
1133
1628
      retval = 0;
1134
1629
    }
1135
1630
  }
1138
1633
  
1139
1634
 mandos_end:
1140
1635
  {
 
1636
    if(route_added){
 
1637
      if(not delete_local_route(ip, if_index)){
 
1638
        fprintf_plus(stderr, "Failed to delete local route to %s on"
 
1639
                     " interface %d", ip, if_index);
 
1640
      }
 
1641
    }
1141
1642
    int e = errno;
1142
1643
    free(decrypted_buffer);
1143
1644
    free(buffer);
1144
1645
    if(tcp_sd >= 0){
1145
 
      ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
 
1646
      ret = close(tcp_sd);
1146
1647
    }
1147
1648
    if(ret == -1){
1148
1649
      if(e == 0){
1160
1661
  return retval;
1161
1662
}
1162
1663
 
1163
 
__attribute__((nonnull))
1164
1664
static void resolve_callback(AvahiSServiceResolver *r,
1165
1665
                             AvahiIfIndex interface,
1166
1666
                             AvahiProtocol proto,
1303
1803
__attribute__((nonnull, warn_unused_result))
1304
1804
bool get_flags(const char *ifname, struct ifreq *ifr){
1305
1805
  int ret;
1306
 
  error_t ret_errno;
 
1806
  int old_errno;
1307
1807
  
1308
1808
  int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1309
1809
  if(s < 0){
1310
 
    ret_errno = errno;
 
1810
    old_errno = errno;
1311
1811
    perror_plus("socket");
1312
 
    errno = ret_errno;
 
1812
    errno = old_errno;
1313
1813
    return false;
1314
1814
  }
1315
 
  strcpy(ifr->ifr_name, ifname);
 
1815
  strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
 
1816
  ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
1316
1817
  ret = ioctl(s, SIOCGIFFLAGS, ifr);
1317
1818
  if(ret == -1){
1318
1819
    if(debug){
1319
 
      ret_errno = errno;
 
1820
      old_errno = errno;
1320
1821
      perror_plus("ioctl SIOCGIFFLAGS");
1321
 
      errno = ret_errno;
 
1822
      errno = old_errno;
 
1823
    }
 
1824
    if((close(s) == -1) and debug){
 
1825
      old_errno = errno;
 
1826
      perror_plus("close");
 
1827
      errno = old_errno;
1322
1828
    }
1323
1829
    return false;
1324
1830
  }
 
1831
  if((close(s) == -1) and debug){
 
1832
    old_errno = errno;
 
1833
    perror_plus("close");
 
1834
    errno = old_errno;
 
1835
  }
1325
1836
  return true;
1326
1837
}
1327
1838
 
1569
2080
  }
1570
2081
}
1571
2082
 
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
 
 
1624
2083
__attribute__((nonnull))
1625
2084
void run_network_hooks(const char *mode, const char *interface,
1626
2085
                       const float delay){
1627
2086
  struct dirent **direntries = NULL;
1628
2087
  if(hookdir_fd == -1){
1629
 
    hookdir_fd = open(hookdir, O_RDONLY);
 
2088
    hookdir_fd = open(hookdir, O_RDONLY | O_DIRECTORY | O_PATH
 
2089
                      | O_CLOEXEC);
1630
2090
    if(hookdir_fd == -1){
1631
2091
      if(errno == ENOENT){
1632
2092
        if(debug){
1639
2099
      return;
1640
2100
    }
1641
2101
  }
1642
 
#ifdef __GLIBC__
1643
 
#if __GLIBC_PREREQ(2, 15)
 
2102
  int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
 
2103
  if(devnull == -1){
 
2104
    perror_plus("open(\"/dev/null\", O_RDONLY)");
 
2105
    return;
 
2106
  }
1644
2107
  int numhooks = scandirat(hookdir_fd, ".", &direntries,
1645
2108
                           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__ */
1654
2109
  if(numhooks == -1){
1655
2110
    perror_plus("scandir");
 
2111
    close(devnull);
1656
2112
    return;
1657
2113
  }
1658
2114
  struct dirent *direntry;
1659
2115
  int ret;
1660
 
  int devnull = open("/dev/null", O_RDONLY);
1661
2116
  for(int i = 0; i < numhooks; i++){
1662
2117
    direntry = direntries[i];
1663
2118
    if(debug){
1687
2142
        perror_plus("setgroups");
1688
2143
        _exit(EX_NOPERM);
1689
2144
      }
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
 
      }
1705
2145
      ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1706
2146
      if(ret == -1){
1707
2147
        perror_plus("setenv");
1742
2182
          _exit(EX_OSERR);
1743
2183
        }
1744
2184
      }
1745
 
      int hook_fd = openat(hookdir_fd, direntry->d_name, O_RDONLY);
 
2185
      int hook_fd = (int)TEMP_FAILURE_RETRY(openat(hookdir_fd,
 
2186
                                                   direntry->d_name,
 
2187
                                                   O_RDONLY));
1746
2188
      if(hook_fd == -1){
1747
2189
        perror_plus("openat");
1748
2190
        _exit(EXIT_FAILURE);
1749
2191
      }
1750
 
      if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
 
2192
      if(close(hookdir_fd) == -1){
1751
2193
        perror_plus("close");
1752
2194
        _exit(EXIT_FAILURE);
1753
2195
      }
 
2196
      ret = dup2(devnull, STDIN_FILENO);
 
2197
      if(ret == -1){
 
2198
        perror_plus("dup2(devnull, STDIN_FILENO)");
 
2199
        _exit(EX_OSERR);
 
2200
      }
 
2201
      ret = close(devnull);
 
2202
      if(ret == -1){
 
2203
        perror_plus("close");
 
2204
        _exit(EX_OSERR);
 
2205
      }
 
2206
      ret = dup2(STDERR_FILENO, STDOUT_FILENO);
 
2207
      if(ret == -1){
 
2208
        perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
 
2209
        _exit(EX_OSERR);
 
2210
      }
1754
2211
      if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
1755
2212
                 environ) == -1){
1756
2213
        perror_plus("fexecve");
1796
2253
    free(direntry);
1797
2254
  }
1798
2255
  free(direntries);
1799
 
  if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
 
2256
  if(close(hookdir_fd) == -1){
1800
2257
    perror_plus("close");
1801
2258
  } else {
1802
2259
    hookdir_fd = -1;
1805
2262
}
1806
2263
 
1807
2264
__attribute__((nonnull, warn_unused_result))
1808
 
error_t bring_up_interface(const char *const interface,
1809
 
                           const float delay){
1810
 
  error_t old_errno = errno;
 
2265
int bring_up_interface(const char *const interface,
 
2266
                       const float delay){
 
2267
  int old_errno = errno;
1811
2268
  int ret;
1812
2269
  struct ifreq network;
1813
2270
  unsigned int if_index = if_nametoindex(interface);
1823
2280
  }
1824
2281
  
1825
2282
  if(not interface_is_up(interface)){
1826
 
    error_t ret_errno = 0, ioctl_errno = 0;
 
2283
    int ret_errno = 0;
 
2284
    int ioctl_errno = 0;
1827
2285
    if(not get_flags(interface, &network)){
1828
2286
      ret_errno = errno;
1829
2287
      fprintf_plus(stderr, "Failed to get flags for interface "
1842
2300
    }
1843
2301
    
1844
2302
    if(quit_now){
1845
 
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
2303
      ret = close(sd);
1846
2304
      if(ret == -1){
1847
2305
        perror_plus("close");
1848
2306
      }
1898
2356
    }
1899
2357
    
1900
2358
    /* Close the socket */
1901
 
    ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
2359
    ret = close(sd);
1902
2360
    if(ret == -1){
1903
2361
      perror_plus("close");
1904
2362
    }
1916
2374
  
1917
2375
  /* Sleep checking until interface is running.
1918
2376
     Check every 0.25s, up to total time of delay */
1919
 
  for(int i=0; i < delay * 4; i++){
 
2377
  for(int i = 0; i < delay * 4; i++){
1920
2378
    if(interface_is_running(interface)){
1921
2379
      break;
1922
2380
    }
1932
2390
}
1933
2391
 
1934
2392
__attribute__((nonnull, warn_unused_result))
1935
 
error_t take_down_interface(const char *const interface){
1936
 
  error_t old_errno = errno;
 
2393
int take_down_interface(const char *const interface){
 
2394
  int old_errno = errno;
1937
2395
  struct ifreq network;
1938
2396
  unsigned int if_index = if_nametoindex(interface);
1939
2397
  if(if_index == 0){
1942
2400
    return ENXIO;
1943
2401
  }
1944
2402
  if(interface_is_up(interface)){
1945
 
    error_t ret_errno = 0, ioctl_errno = 0;
 
2403
    int ret_errno = 0;
 
2404
    int ioctl_errno = 0;
1946
2405
    if(not get_flags(interface, &network) and debug){
1947
2406
      ret_errno = errno;
1948
2407
      fprintf_plus(stderr, "Failed to get flags for interface "
1986
2445
    }
1987
2446
    
1988
2447
    /* Close the socket */
1989
 
    int ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
2448
    int ret = close(sd);
1990
2449
    if(ret == -1){
1991
2450
      perror_plus("close");
1992
2451
    }
2008
2467
 
2009
2468
int main(int argc, char *argv[]){
2010
2469
  mandos_context mc = { .server = NULL, .dh_bits = 0,
2011
 
                        .priority = "SECURE256:!CTYPE-X.509:"
2012
 
                        "+CTYPE-OPENPGP:!RSA", .current_server = NULL,
2013
 
                        .interfaces = NULL, .interfaces_size = 0 };
 
2470
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
2471
                        .priority = "SECURE128:!CTYPE-X.509"
 
2472
                        ":+CTYPE-RAWPK:!RSA:!VERS-ALL:+VERS-TLS1.3"
 
2473
                        ":%PROFILE_ULTRA",
 
2474
#elif GNUTLS_VERSION_NUMBER < 0x030600
 
2475
                        .priority = "SECURE256:!CTYPE-X.509"
 
2476
                        ":+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256",
 
2477
#else
 
2478
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
 
2479
#endif
 
2480
                        .current_server = NULL, .interfaces = NULL,
 
2481
                        .interfaces_size = 0 };
2014
2482
  AvahiSServiceBrowser *sb = NULL;
2015
2483
  error_t ret_errno;
2016
2484
  int ret;
2025
2493
  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
2026
2494
  const char *seckey = PATHDIR "/" SECKEY;
2027
2495
  const char *pubkey = PATHDIR "/" PUBKEY;
 
2496
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
2497
  const char *tls_privkey = PATHDIR "/" TLS_PRIVKEY;
 
2498
  const char *tls_pubkey = PATHDIR "/" TLS_PUBKEY;
 
2499
#endif
 
2500
  const char *dh_params_file = NULL;
2028
2501
  char *interfaces_hooks = NULL;
2029
2502
  
2030
2503
  bool gnutls_initialized = false;
2077
2550
      { .name = "pubkey", .key = 'p',
2078
2551
        .arg = "FILE",
2079
2552
        .doc = "OpenPGP public key file base name",
2080
 
        .group = 2 },
 
2553
        .group = 1 },
 
2554
      { .name = "tls-privkey", .key = 't',
 
2555
        .arg = "FILE",
 
2556
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
2557
        .doc = "TLS private key file base name",
 
2558
#else
 
2559
        .doc = "Dummy; ignored (requires GnuTLS 3.6.6)",
 
2560
#endif
 
2561
        .group = 1 },
 
2562
      { .name = "tls-pubkey", .key = 'T',
 
2563
        .arg = "FILE",
 
2564
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
2565
        .doc = "TLS public key file base name",
 
2566
#else
 
2567
        .doc = "Dummy; ignored (requires GnuTLS 3.6.6)",
 
2568
#endif
 
2569
        .group = 1 },
2081
2570
      { .name = "dh-bits", .key = 129,
2082
2571
        .arg = "BITS",
2083
2572
        .doc = "Bit length of the prime number used in the"
2084
2573
        " Diffie-Hellman key exchange",
2085
2574
        .group = 2 },
 
2575
      { .name = "dh-params", .key = 134,
 
2576
        .arg = "FILE",
 
2577
        .doc = "PEM-encoded PKCS#3 file with pre-generated parameters"
 
2578
        " for the Diffie-Hellman key exchange",
 
2579
        .group = 2 },
2086
2580
      { .name = "priority", .key = 130,
2087
2581
        .arg = "STRING",
2088
2582
        .doc = "GnuTLS priority string for the TLS handshake",
2134
2628
      case 'p':                 /* --pubkey */
2135
2629
        pubkey = arg;
2136
2630
        break;
 
2631
      case 't':                 /* --tls-privkey */
 
2632
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
2633
        tls_privkey = arg;
 
2634
#endif
 
2635
        break;
 
2636
      case 'T':                 /* --tls-pubkey */
 
2637
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
2638
        tls_pubkey = arg;
 
2639
#endif
 
2640
        break;
2137
2641
      case 129:                 /* --dh-bits */
2138
2642
        errno = 0;
2139
2643
        tmpmax = strtoimax(arg, &tmp, 10);
2143
2647
        }
2144
2648
        mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
2145
2649
        break;
 
2650
      case 134:                 /* --dh-params */
 
2651
        dh_params_file = arg;
 
2652
        break;
2146
2653
      case 130:                 /* --priority */
2147
2654
        mc.priority = arg;
2148
2655
        break;
2171
2678
        argp_state_help(state, state->out_stream,
2172
2679
                        (ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
2173
2680
                        & ~(unsigned int)ARGP_HELP_EXIT_OK);
 
2681
        __builtin_unreachable();
2174
2682
      case -3:                  /* --usage */
2175
2683
        argp_state_help(state, state->out_stream,
2176
2684
                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
 
2685
        __builtin_unreachable();
2177
2686
      case 'V':                 /* --version */
2178
2687
        fprintf_plus(state->out_stream, "%s\n", argp_program_version);
2179
2688
        exit(argp_err_exit_status);
2188
2697
                         .args_doc = "",
2189
2698
                         .doc = "Mandos client -- Get and decrypt"
2190
2699
                         " passwords from a Mandos server" };
2191
 
    ret = argp_parse(&argp, argc, argv,
2192
 
                     ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2193
 
    switch(ret){
 
2700
    ret_errno = argp_parse(&argp, argc, argv,
 
2701
                           ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
 
2702
    switch(ret_errno){
2194
2703
    case 0:
2195
2704
      break;
2196
2705
    case ENOMEM:
2197
2706
    default:
2198
 
      errno = ret;
 
2707
      errno = ret_errno;
2199
2708
      perror_plus("argp_parse");
2200
2709
      exitcode = EX_OSERR;
2201
2710
      goto end;
2204
2713
      goto end;
2205
2714
    }
2206
2715
  }
2207
 
    
 
2716
  
2208
2717
  {
2209
2718
    /* Work around Debian bug #633582:
2210
 
       <http://bugs.debian.org/633582> */
 
2719
       <https://bugs.debian.org/633582> */
2211
2720
    
2212
2721
    /* Re-raise privileges */
2213
 
    ret_errno = raise_privileges();
2214
 
    if(ret_errno != 0){
2215
 
      errno = ret_errno;
 
2722
    ret = raise_privileges();
 
2723
    if(ret != 0){
 
2724
      errno = ret;
2216
2725
      perror_plus("Failed to raise privileges");
2217
2726
    } else {
2218
2727
      struct stat st;
2234
2743
              }
2235
2744
            }
2236
2745
          }
2237
 
          TEMP_FAILURE_RETRY(close(seckey_fd));
 
2746
          close(seckey_fd);
2238
2747
        }
2239
2748
      }
2240
 
    
 
2749
      
2241
2750
      if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2242
2751
        int pubkey_fd = open(pubkey, O_RDONLY);
2243
2752
        if(pubkey_fd == -1){
2255
2764
              }
2256
2765
            }
2257
2766
          }
2258
 
          TEMP_FAILURE_RETRY(close(pubkey_fd));
2259
 
        }
2260
 
      }
2261
 
    
 
2767
          close(pubkey_fd);
 
2768
        }
 
2769
      }
 
2770
      
 
2771
      if(dh_params_file != NULL
 
2772
         and strcmp(dh_params_file, PATHDIR "/dhparams.pem" ) == 0){
 
2773
        int dhparams_fd = open(dh_params_file, O_RDONLY);
 
2774
        if(dhparams_fd == -1){
 
2775
          perror_plus("open");
 
2776
        } else {
 
2777
          ret = (int)TEMP_FAILURE_RETRY(fstat(dhparams_fd, &st));
 
2778
          if(ret == -1){
 
2779
            perror_plus("fstat");
 
2780
          } else {
 
2781
            if(S_ISREG(st.st_mode)
 
2782
               and st.st_uid == 0 and st.st_gid == 0){
 
2783
              ret = fchown(dhparams_fd, uid, gid);
 
2784
              if(ret == -1){
 
2785
                perror_plus("fchown");
 
2786
              }
 
2787
            }
 
2788
          }
 
2789
          close(dhparams_fd);
 
2790
        }
 
2791
      }
 
2792
      
2262
2793
      /* Lower privileges */
2263
 
      ret_errno = lower_privileges();
2264
 
      if(ret_errno != 0){
2265
 
        errno = ret_errno;
 
2794
      ret = lower_privileges();
 
2795
      if(ret != 0){
 
2796
        errno = ret;
2266
2797
        perror_plus("Failed to lower privileges");
2267
2798
      }
2268
2799
    }
2438
2969
      errno = bring_up_interface(interface, delay);
2439
2970
      if(not interface_was_up){
2440
2971
        if(errno != 0){
2441
 
          perror_plus("Failed to bring up interface");
 
2972
          fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
 
2973
                       " %s\n", interface, strerror(errno));
2442
2974
        } else {
2443
2975
          errno = argz_add(&interfaces_to_take_down,
2444
2976
                           &interfaces_to_take_down_size,
2467
2999
    goto end;
2468
3000
  }
2469
3001
  
2470
 
  ret = init_gnutls_global(pubkey, seckey, &mc);
 
3002
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
3003
  ret = init_gnutls_global(tls_pubkey, tls_privkey, dh_params_file, &mc);
 
3004
#elif GNUTLS_VERSION_NUMBER < 0x030600
 
3005
  ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
 
3006
#else
 
3007
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
 
3008
#endif
2471
3009
  if(ret == -1){
2472
3010
    fprintf_plus(stderr, "init_gnutls_global failed\n");
2473
3011
    exitcode = EX_UNAVAILABLE;
2595
3133
    
2596
3134
    /* Allocate a new server */
2597
3135
    mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
2598
 
                                 &config, NULL, NULL, &ret_errno);
 
3136
                                 &config, NULL, NULL, &ret);
2599
3137
    
2600
3138
    /* Free the Avahi configuration data */
2601
3139
    avahi_server_config_free(&config);
2604
3142
  /* Check if creating the Avahi server object succeeded */
2605
3143
  if(mc.server == NULL){
2606
3144
    fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2607
 
                 avahi_strerror(ret_errno));
 
3145
                 avahi_strerror(ret));
2608
3146
    exitcode = EX_UNAVAILABLE;
2609
3147
    goto end;
2610
3148
  }
2645
3183
 end:
2646
3184
  
2647
3185
  if(debug){
2648
 
    fprintf_plus(stderr, "%s exiting\n", argv[0]);
 
3186
    if(signal_received){
 
3187
      fprintf_plus(stderr, "%s exiting due to signal %d: %s\n",
 
3188
                   argv[0], signal_received,
 
3189
                   strsignal(signal_received));
 
3190
    } else {
 
3191
      fprintf_plus(stderr, "%s exiting\n", argv[0]);
 
3192
    }
2649
3193
  }
2650
3194
  
2651
3195
  /* Cleanup things */
2662
3206
  
2663
3207
  if(gnutls_initialized){
2664
3208
    gnutls_certificate_free_credentials(mc.cred);
2665
 
    gnutls_global_deinit();
2666
3209
    gnutls_dh_params_deinit(mc.dh_params);
2667
3210
  }
2668
3211
  
2691
3234
  
2692
3235
  /* Re-raise privileges */
2693
3236
  {
2694
 
    ret_errno = raise_privileges();
2695
 
    if(ret_errno != 0){
2696
 
      errno = ret_errno;
 
3237
    ret = raise_privileges();
 
3238
    if(ret != 0){
 
3239
      errno = ret;
2697
3240
      perror_plus("Failed to raise privileges");
2698
3241
    } else {
2699
3242
      
2704
3247
      /* Take down the network interfaces which were brought up */
2705
3248
      {
2706
3249
        char *interface = NULL;
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;
 
3250
        while((interface = argz_next(interfaces_to_take_down,
 
3251
                                     interfaces_to_take_down_size,
 
3252
                                     interface))){
 
3253
          ret = take_down_interface(interface);
 
3254
          if(ret != 0){
 
3255
            errno = ret;
2713
3256
            perror_plus("Failed to take down interface");
2714
3257
          }
2715
3258
        }
2720
3263
      }
2721
3264
    }
2722
3265
    
2723
 
    ret_errno = lower_privileges_permanently();
2724
 
    if(ret_errno != 0){
2725
 
      errno = ret_errno;
 
3266
    ret = lower_privileges_permanently();
 
3267
    if(ret != 0){
 
3268
      errno = ret;
2726
3269
      perror_plus("Failed to lower privileges permanently");
2727
3270
    }
2728
3271
  }
2730
3273
  free(interfaces_to_take_down);
2731
3274
  free(interfaces_hooks);
2732
3275
  
 
3276
  void clean_dir_at(int base, const char * const dirname,
 
3277
                    uintmax_t level){
 
3278
    struct dirent **direntries = NULL;
 
3279
    int dret;
 
3280
    int dir_fd = (int)TEMP_FAILURE_RETRY(openat(base, dirname,
 
3281
                                                O_RDONLY
 
3282
                                                | O_NOFOLLOW
 
3283
                                                | O_DIRECTORY
 
3284
                                                | O_PATH));
 
3285
    if(dir_fd == -1){
 
3286
      perror_plus("open");
 
3287
      return;
 
3288
    }
 
3289
    int numentries = scandirat(dir_fd, ".", &direntries,
 
3290
                               notdotentries, alphasort);
 
3291
    if(numentries >= 0){
 
3292
      for(int i = 0; i < numentries; i++){
 
3293
        if(debug){
 
3294
          fprintf_plus(stderr, "Unlinking \"%s/%s\"\n",
 
3295
                       dirname, direntries[i]->d_name);
 
3296
        }
 
3297
        dret = unlinkat(dir_fd, direntries[i]->d_name, 0);
 
3298
        if(dret == -1){
 
3299
          if(errno == EISDIR){
 
3300
              dret = unlinkat(dir_fd, direntries[i]->d_name,
 
3301
                              AT_REMOVEDIR);
 
3302
          }         
 
3303
          if((dret == -1) and (errno == ENOTEMPTY)
 
3304
             and (strcmp(direntries[i]->d_name, "private-keys-v1.d")
 
3305
                  == 0) and (level == 0)){
 
3306
            /* Recurse only in this special case */
 
3307
            clean_dir_at(dir_fd, direntries[i]->d_name, level+1);
 
3308
            dret = 0;
 
3309
          }
 
3310
          if((dret == -1) and (errno != ENOENT)){
 
3311
            fprintf_plus(stderr, "unlink(\"%s/%s\"): %s\n", dirname,
 
3312
                         direntries[i]->d_name, strerror(errno));
 
3313
          }
 
3314
        }
 
3315
        free(direntries[i]);
 
3316
      }
 
3317
      
 
3318
      /* need to clean even if 0 because man page doesn't specify */
 
3319
      free(direntries);
 
3320
      dret = unlinkat(base, dirname, AT_REMOVEDIR);
 
3321
      if(dret == -1 and errno != ENOENT){
 
3322
        perror_plus("rmdir");
 
3323
      }
 
3324
    } else {
 
3325
      perror_plus("scandirat");
 
3326
    }
 
3327
    close(dir_fd);
 
3328
  }
 
3329
  
2733
3330
  /* Removes the GPGME temp directory and all files inside */
2734
3331
  if(tempdir != NULL){
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
 
    }
 
3332
    clean_dir_at(-1, tempdir, 0);
2776
3333
  }
2777
3334
  
2778
3335
  if(quit_now){