/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: 2019-07-29 16:35:53 UTC
  • mto: This revision was merged to the branch mainline in revision 384.
  • Revision ID: teddy@recompile.se-20190729163553-1i442i2cbx64c537
Make tests and man page examples match

Make the tests test_manual_page_example[1-5] match exactly what is
written in the manual page, and add comments to manual page as
reminders to keep tests and manual page examples in sync.

* mandos-ctl (Test_commands_from_options.test_manual_page_example_1):
  Remove "--verbose" option, since the manual does not have it as the
  first example, and change assertion to match.
* mandos-ctl.xml (EXAMPLE): Add comments to all examples documenting
  which test function they correspond to.  Also remove unnecessary
  quotes from option arguments in fourth example, and clarify language
  slightly in fifth example.

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-2019 Teddy Hogeborn
 
13
 * Copyright © 2008-2019 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;
234
248
                          .af = af };
235
249
  if(new_server->ip == NULL){
236
250
    perror_plus("strdup");
 
251
    free(new_server);
237
252
    return false;
238
253
  }
239
254
  ret = clock_gettime(CLOCK_MONOTONIC, &(new_server->last_seen));
240
255
  if(ret == -1){
241
256
    perror_plus("clock_gettime");
 
257
#ifdef __GNUC__
 
258
#pragma GCC diagnostic push
 
259
#pragma GCC diagnostic ignored "-Wcast-qual"
 
260
#endif
 
261
    free((char *)(new_server->ip));
 
262
#ifdef __GNUC__
 
263
#pragma GCC diagnostic pop
 
264
#endif
 
265
    free(new_server);
242
266
    return false;
243
267
  }
244
268
  /* Special case of first server */
256
280
  return true;
257
281
}
258
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
 
259
335
/* 
260
336
 * Initialize GPGME.
261
337
 */
281
357
      return false;
282
358
    }
283
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
      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
 
284
410
    rc = gpgme_data_new_from_fd(&pgp_data, fd);
285
411
    if(rc != GPG_ERR_NO_ERROR){
286
412
      fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
294
420
                   gpgme_strsource(rc), gpgme_strerror(rc));
295
421
      return false;
296
422
    }
 
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
    }
297
498
    
298
 
    ret = (int)TEMP_FAILURE_RETRY(close(fd));
 
499
    ret = close(fd);
299
500
    if(ret == -1){
300
501
      perror_plus("close");
301
502
    }
340
541
  /* Create new GPGME "context" */
341
542
  rc = gpgme_new(&(mc->ctx));
342
543
  if(rc != GPG_ERR_NO_ERROR){
343
 
    fprintf_plus(stderr, "Mandos plugin mandos-client: "
344
 
                 "bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
345
 
                 gpgme_strerror(rc));
 
544
    fprintf_plus(stderr, "bad gpgme_new: %s: %s\n",
 
545
                 gpgme_strsource(rc), gpgme_strerror(rc));
346
546
    return false;
347
547
  }
348
548
  
384
584
  /* Create new empty GPGME data buffer for the plaintext */
385
585
  rc = gpgme_data_new(&dh_plain);
386
586
  if(rc != GPG_ERR_NO_ERROR){
387
 
    fprintf_plus(stderr, "Mandos plugin mandos-client: "
388
 
                 "bad gpgme_data_new: %s: %s\n",
 
587
    fprintf_plus(stderr, "bad gpgme_data_new: %s: %s\n",
389
588
                 gpgme_strsource(rc), gpgme_strerror(rc));
390
589
    gpgme_data_release(dh_crypto);
391
590
    return -1;
404
603
      if(result == NULL){
405
604
        fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
406
605
      } else {
407
 
        fprintf_plus(stderr, "Unsupported algorithm: %s\n",
408
 
                     result->unsupported_algorithm);
409
 
        fprintf_plus(stderr, "Wrong key usage: %u\n",
410
 
                     result->wrong_key_usage);
 
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");
411
612
        if(result->file_name != NULL){
412
613
          fprintf_plus(stderr, "File name: %s\n", result->file_name);
413
614
        }
414
 
        gpgme_recipient_t recipient;
415
 
        recipient = result->recipients;
416
 
        while(recipient != NULL){
 
615
 
 
616
        for(gpgme_recipient_t r = result->recipients; r != NULL;
 
617
            r = r->next){
417
618
          fprintf_plus(stderr, "Public key algorithm: %s\n",
418
 
                       gpgme_pubkey_algo_name
419
 
                       (recipient->pubkey_algo));
420
 
          fprintf_plus(stderr, "Key ID: %s\n", recipient->keyid);
 
619
                       gpgme_pubkey_algo_name(r->pubkey_algo));
 
620
          fprintf_plus(stderr, "Key ID: %s\n", r->keyid);
421
621
          fprintf_plus(stderr, "Secret key available: %s\n",
422
 
                       recipient->status == GPG_ERR_NO_SECKEY
423
 
                       ? "No" : "Yes");
424
 
          recipient = recipient->next;
 
622
                       r->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
425
623
        }
426
624
      }
427
625
    }
483
681
  return plaintext_length;
484
682
}
485
683
 
 
684
__attribute__((warn_unused_result, const))
 
685
static const char *safe_string(const char *str){
 
686
  if(str == NULL)
 
687
    return "(unknown)";
 
688
  return str;
 
689
}
 
690
 
486
691
__attribute__((warn_unused_result))
487
692
static const char *safer_gnutls_strerror(int value){
488
693
  const char *ret = gnutls_strerror(value);
489
 
  if(ret == NULL)
490
 
    ret = "(unknown)";
491
 
  return ret;
 
694
  return safe_string(ret);
492
695
}
493
696
 
494
697
/* GnuTLS log function callback */
498
701
  fprintf_plus(stderr, "GnuTLS: %s", string);
499
702
}
500
703
 
501
 
__attribute__((nonnull, warn_unused_result))
 
704
__attribute__((nonnull(1, 2, 4), warn_unused_result))
502
705
static int init_gnutls_global(const char *pubkeyfilename,
503
706
                              const char *seckeyfilename,
 
707
                              const char *dhparamsfilename,
504
708
                              mandos_context *mc){
505
709
  int ret;
506
710
  
508
712
    fprintf_plus(stderr, "Initializing GnuTLS\n");
509
713
  }
510
714
  
511
 
  ret = gnutls_global_init();
512
 
  if(ret != GNUTLS_E_SUCCESS){
513
 
    fprintf_plus(stderr, "GnuTLS global_init: %s\n",
514
 
                 safer_gnutls_strerror(ret));
515
 
    return -1;
516
 
  }
517
 
  
518
715
  if(debug){
519
716
    /* "Use a log level over 10 to enable all debugging options."
520
717
     * - GnuTLS manual
528
725
  if(ret != GNUTLS_E_SUCCESS){
529
726
    fprintf_plus(stderr, "GnuTLS memory error: %s\n",
530
727
                 safer_gnutls_strerror(ret));
531
 
    gnutls_global_deinit();
532
728
    return -1;
533
729
  }
534
730
  
535
731
  if(debug){
536
 
    fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
537
 
                 " secret key %s as GnuTLS credentials\n",
 
732
    fprintf_plus(stderr, "Attempting to use public key %s and"
 
733
                 " private key %s as GnuTLS credentials\n",
538
734
                 pubkeyfilename,
539
735
                 seckeyfilename);
540
736
  }
541
737
  
 
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
542
751
  ret = gnutls_certificate_set_openpgp_key_file
543
752
    (mc->cred, pubkeyfilename, seckeyfilename,
544
753
     GNUTLS_OPENPGP_FMT_BASE64);
 
754
#else
 
755
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
 
756
#endif
545
757
  if(ret != GNUTLS_E_SUCCESS){
546
758
    fprintf_plus(stderr,
547
 
                 "Error[%d] while reading the OpenPGP key pair ('%s',"
 
759
                 "Error[%d] while reading the key pair ('%s',"
548
760
                 " '%s')\n", ret, pubkeyfilename, seckeyfilename);
549
761
    fprintf_plus(stderr, "The GnuTLS error is: %s\n",
550
762
                 safer_gnutls_strerror(ret));
559
771
                 safer_gnutls_strerror(ret));
560
772
    goto globalfail;
561
773
  }
562
 
  ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
563
 
  if(ret != GNUTLS_E_SUCCESS){
564
 
    fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
565
 
                 safer_gnutls_strerror(ret));
566
 
    goto globalfail;
567
 
  }
568
 
  
569
 
  gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
 
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;
 
785
      while(true){
 
786
        params_capacity = incbuffer((char **)&params.data,
 
787
                                    (size_t)params.size,
 
788
                                    (size_t)params_capacity);
 
789
        if(params_capacity == 0){
 
790
          perror_plus("incbuffer");
 
791
          free(params.data);
 
792
          params.data = NULL;
 
793
          dhparamsfilename = NULL;
 
794
          break;
 
795
        }
 
796
        ssize_t bytes_read = read(dhpfile,
 
797
                                  params.data + params.size,
 
798
                                  BUFFER_SIZE);
 
799
        /* EOF */
 
800
        if(bytes_read == 0){
 
801
          break;
 
802
        }
 
803
        /* check bytes_read for failure */
 
804
        if(bytes_read < 0){
 
805
          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);
 
881
          if(ret != GNUTLS_E_SUCCESS){
 
882
            fprintf_plus(stderr, "Error initializing OpenPGP key"
 
883
                         " structure: %s",
 
884
                         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
            }
 
909
          }
 
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)));
 
919
          }
 
920
        }
 
921
      }
 
922
      unsigned int uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
 
923
      if(uret != 0){
 
924
        mc->dh_bits = uret;
 
925
        if(debug){
 
926
          fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
 
927
                       " implies %u DH bits; using that.\n",
 
928
                       safe_string(gnutls_sec_param_get_name
 
929
                                   (sec_param)),
 
930
                       mc->dh_bits);
 
931
        }
 
932
      } else {
 
933
        fprintf_plus(stderr, "Failed to get implied number of DH"
 
934
                     " bits for security parameter \"%s\"): %s\n",
 
935
                     safe_string(gnutls_sec_param_get_name
 
936
                                 (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
                     mc->dh_bits);
 
945
      }
 
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);
 
954
    }
 
955
  }
570
956
  
571
957
  return 0;
572
958
  
573
959
 globalfail:
574
960
  
575
961
  gnutls_certificate_free_credentials(mc->cred);
576
 
  gnutls_global_deinit();
577
962
  gnutls_dh_params_deinit(mc->dh_params);
578
963
  return -1;
579
964
}
584
969
  int ret;
585
970
  /* GnuTLS session creation */
586
971
  do {
587
 
    ret = gnutls_init(session, GNUTLS_SERVER);
 
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
                                ));
588
980
    if(quit_now){
589
981
      return -1;
590
982
    }
631
1023
  /* ignore client certificate if any. */
632
1024
  gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
633
1025
  
634
 
  gnutls_dh_set_prime_bits(*session, mc->dh_bits);
635
 
  
636
1026
  return 0;
637
1027
}
638
1028
 
640
1030
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
641
1031
                      __attribute__((unused)) const char *txt){}
642
1032
 
 
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
 
643
1199
/* Called when a Mandos server is found */
644
1200
__attribute__((nonnull, warn_unused_result))
645
1201
static int start_mandos_communication(const char *ip, in_port_t port,
656
1212
  int retval = -1;
657
1213
  gnutls_session_t session;
658
1214
  int pf;                       /* Protocol family */
 
1215
  bool route_added = false;
659
1216
  
660
1217
  errno = 0;
661
1218
  
683
1240
    bool match = false;
684
1241
    {
685
1242
      char *interface = NULL;
686
 
      while((interface=argz_next(mc->interfaces, mc->interfaces_size,
687
 
                                 interface))){
 
1243
      while((interface = argz_next(mc->interfaces,
 
1244
                                   mc->interfaces_size,
 
1245
                                   interface))){
688
1246
        if(if_nametoindex(interface) == (unsigned int)if_index){
689
1247
          match = true;
690
1248
          break;
719
1277
                 PRIuMAX "\n", ip, (uintmax_t)port);
720
1278
  }
721
1279
  
722
 
  tcp_sd = socket(pf, SOCK_STREAM, 0);
 
1280
  tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
723
1281
  if(tcp_sd < 0){
724
1282
    int e = errno;
725
1283
    perror_plus("socket");
732
1290
    goto mandos_end;
733
1291
  }
734
1292
  
735
 
  memset(&to, 0, sizeof(to));
736
1293
  if(af == AF_INET6){
737
 
    ((struct sockaddr_in6 *)&to)->sin6_family = (sa_family_t)af;
738
 
    ret = inet_pton(af, ip, &((struct sockaddr_in6 *)&to)->sin6_addr);
 
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);
739
1297
  } else {                      /* IPv4 */
740
 
    ((struct sockaddr_in *)&to)->sin_family = (sa_family_t)af;
741
 
    ret = inet_pton(af, ip, &((struct sockaddr_in *)&to)->sin_addr);
 
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);
742
1301
  }
743
1302
  if(ret < 0 ){
744
1303
    int e = errno;
814
1373
    goto mandos_end;
815
1374
  }
816
1375
  
817
 
  if(af == AF_INET6){
818
 
    ret = connect(tcp_sd, (struct sockaddr *)&to,
819
 
                  sizeof(struct sockaddr_in6));
820
 
  } else {
821
 
    ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
822
 
                  sizeof(struct sockaddr_in));
823
 
  }
824
 
  if(ret < 0){
825
 
    if((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
826
 
      int e = errno;
827
 
      perror_plus("connect");
828
 
      errno = e;
829
 
    }
830
 
    goto mandos_end;
831
 
  }
832
 
  
833
 
  if(quit_now){
834
 
    errno = EINTR;
835
 
    goto mandos_end;
 
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;
836
1431
  }
837
1432
  
838
1433
  const char *out = mandos_protocol_version;
992
1587
                                               &decrypted_buffer, mc);
993
1588
    if(decrypted_buffer_size >= 0){
994
1589
      
 
1590
      clearerr(stdout);
995
1591
      written = 0;
996
1592
      while(written < (size_t) decrypted_buffer_size){
997
1593
        if(quit_now){
1013
1609
        }
1014
1610
        written += (size_t)ret;
1015
1611
      }
 
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
      }
1016
1622
      retval = 0;
1017
1623
    }
1018
1624
  }
1021
1627
  
1022
1628
 mandos_end:
1023
1629
  {
 
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
    }
1024
1636
    int e = errno;
1025
1637
    free(decrypted_buffer);
1026
1638
    free(buffer);
1027
1639
    if(tcp_sd >= 0){
1028
 
      ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
 
1640
      ret = close(tcp_sd);
1029
1641
    }
1030
1642
    if(ret == -1){
1031
1643
      if(e == 0){
1043
1655
  return retval;
1044
1656
}
1045
1657
 
1046
 
__attribute__((nonnull))
1047
1658
static void resolve_callback(AvahiSServiceResolver *r,
1048
1659
                             AvahiIfIndex interface,
1049
1660
                             AvahiProtocol proto,
1066
1677
     timed out */
1067
1678
  
1068
1679
  if(quit_now){
 
1680
    avahi_s_service_resolver_free(r);
1069
1681
    return;
1070
1682
  }
1071
1683
  
1185
1797
__attribute__((nonnull, warn_unused_result))
1186
1798
bool get_flags(const char *ifname, struct ifreq *ifr){
1187
1799
  int ret;
1188
 
  error_t ret_errno;
 
1800
  int old_errno;
1189
1801
  
1190
1802
  int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1191
1803
  if(s < 0){
1192
 
    ret_errno = errno;
 
1804
    old_errno = errno;
1193
1805
    perror_plus("socket");
1194
 
    errno = ret_errno;
 
1806
    errno = old_errno;
1195
1807
    return false;
1196
1808
  }
1197
 
  strcpy(ifr->ifr_name, ifname);
 
1809
  strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
 
1810
  ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
1198
1811
  ret = ioctl(s, SIOCGIFFLAGS, ifr);
1199
1812
  if(ret == -1){
1200
1813
    if(debug){
1201
 
      ret_errno = errno;
 
1814
      old_errno = errno;
1202
1815
      perror_plus("ioctl SIOCGIFFLAGS");
1203
 
      errno = ret_errno;
 
1816
      errno = old_errno;
 
1817
    }
 
1818
    if((close(s) == -1) and debug){
 
1819
      old_errno = errno;
 
1820
      perror_plus("close");
 
1821
      errno = old_errno;
1204
1822
    }
1205
1823
    return false;
1206
1824
  }
 
1825
  if((close(s) == -1) and debug){
 
1826
    old_errno = errno;
 
1827
    perror_plus("close");
 
1828
    errno = old_errno;
 
1829
  }
1207
1830
  return true;
1208
1831
}
1209
1832
 
1451
2074
  }
1452
2075
}
1453
2076
 
1454
 
/* Set effective uid to 0, return errno */
1455
 
__attribute__((warn_unused_result))
1456
 
error_t raise_privileges(void){
1457
 
  error_t old_errno = errno;
1458
 
  error_t ret_errno = 0;
1459
 
  if(seteuid(0) == -1){
1460
 
    ret_errno = errno;
1461
 
  }
1462
 
  errno = old_errno;
1463
 
  return ret_errno;
1464
 
}
1465
 
 
1466
 
/* Set effective and real user ID to 0.  Return errno. */
1467
 
__attribute__((warn_unused_result))
1468
 
error_t raise_privileges_permanently(void){
1469
 
  error_t old_errno = errno;
1470
 
  error_t ret_errno = raise_privileges();
1471
 
  if(ret_errno != 0){
1472
 
    errno = old_errno;
1473
 
    return ret_errno;
1474
 
  }
1475
 
  if(setuid(0) == -1){
1476
 
    ret_errno = errno;
1477
 
  }
1478
 
  errno = old_errno;
1479
 
  return ret_errno;
1480
 
}
1481
 
 
1482
 
/* Set effective user ID to unprivileged saved user ID */
1483
 
__attribute__((warn_unused_result))
1484
 
error_t lower_privileges(void){
1485
 
  error_t old_errno = errno;
1486
 
  error_t ret_errno = 0;
1487
 
  if(seteuid(uid) == -1){
1488
 
    ret_errno = errno;
1489
 
  }
1490
 
  errno = old_errno;
1491
 
  return ret_errno;
1492
 
}
1493
 
 
1494
 
/* Lower privileges permanently */
1495
 
__attribute__((warn_unused_result))
1496
 
error_t lower_privileges_permanently(void){
1497
 
  error_t old_errno = errno;
1498
 
  error_t ret_errno = 0;
1499
 
  if(setuid(uid) == -1){
1500
 
    ret_errno = errno;
1501
 
  }
1502
 
  errno = old_errno;
1503
 
  return ret_errno;
1504
 
}
1505
 
 
1506
2077
__attribute__((nonnull))
1507
2078
void run_network_hooks(const char *mode, const char *interface,
1508
2079
                       const float delay){
1509
2080
  struct dirent **direntries = NULL;
1510
2081
  if(hookdir_fd == -1){
1511
 
    hookdir_fd = open(hookdir, O_RDONLY);
 
2082
    hookdir_fd = open(hookdir, O_RDONLY | O_DIRECTORY | O_PATH
 
2083
                      | O_CLOEXEC);
1512
2084
    if(hookdir_fd == -1){
1513
2085
      if(errno == ENOENT){
1514
2086
        if(debug){
1521
2093
      return;
1522
2094
    }
1523
2095
  }
1524
 
#ifdef __GLIBC__
1525
 
#if __GLIBC_PREREQ(2, 15)
 
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
  }
1526
2101
  int numhooks = scandirat(hookdir_fd, ".", &direntries,
1527
2102
                           runnable_hook, alphasort);
1528
 
#else  /* not __GLIBC_PREREQ(2, 15) */
1529
 
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
1530
 
                         alphasort);
1531
 
#endif  /* not __GLIBC_PREREQ(2, 15) */
1532
 
#else   /* not __GLIBC__ */
1533
 
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
1534
 
                         alphasort);
1535
 
#endif  /* not __GLIBC__ */
1536
2103
  if(numhooks == -1){
1537
2104
    perror_plus("scandir");
 
2105
    close(devnull);
1538
2106
    return;
1539
2107
  }
1540
2108
  struct dirent *direntry;
1541
2109
  int ret;
1542
 
  int devnull = open("/dev/null", O_RDONLY);
1543
2110
  for(int i = 0; i < numhooks; i++){
1544
2111
    direntry = direntries[i];
1545
2112
    if(debug){
1569
2136
        perror_plus("setgroups");
1570
2137
        _exit(EX_NOPERM);
1571
2138
      }
1572
 
      ret = dup2(devnull, STDIN_FILENO);
1573
 
      if(ret == -1){
1574
 
        perror_plus("dup2(devnull, STDIN_FILENO)");
1575
 
        _exit(EX_OSERR);
1576
 
      }
1577
 
      ret = close(devnull);
1578
 
      if(ret == -1){
1579
 
        perror_plus("close");
1580
 
        _exit(EX_OSERR);
1581
 
      }
1582
 
      ret = dup2(STDERR_FILENO, STDOUT_FILENO);
1583
 
      if(ret == -1){
1584
 
        perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
1585
 
        _exit(EX_OSERR);
1586
 
      }
1587
2139
      ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1588
2140
      if(ret == -1){
1589
2141
        perror_plus("setenv");
1624
2176
          _exit(EX_OSERR);
1625
2177
        }
1626
2178
      }
1627
 
      int hook_fd = openat(hookdir_fd, direntry->d_name, O_RDONLY);
 
2179
      int hook_fd = (int)TEMP_FAILURE_RETRY(openat(hookdir_fd,
 
2180
                                                   direntry->d_name,
 
2181
                                                   O_RDONLY));
1628
2182
      if(hook_fd == -1){
1629
2183
        perror_plus("openat");
1630
2184
        _exit(EXIT_FAILURE);
1631
2185
      }
1632
 
      if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
 
2186
      if(close(hookdir_fd) == -1){
1633
2187
        perror_plus("close");
1634
2188
        _exit(EXIT_FAILURE);
1635
2189
      }
 
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
      }
1636
2205
      if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
1637
2206
                 environ) == -1){
1638
2207
        perror_plus("fexecve");
1639
2208
        _exit(EXIT_FAILURE);
1640
2209
      }
1641
2210
    } else {
 
2211
      if(hook_pid == -1){
 
2212
        perror_plus("fork");
 
2213
        free(direntry);
 
2214
        continue;
 
2215
      }
1642
2216
      int status;
1643
2217
      if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1644
2218
        perror_plus("waitpid");
 
2219
        free(direntry);
1645
2220
        continue;
1646
2221
      }
1647
2222
      if(WIFEXITED(status)){
1649
2224
          fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1650
2225
                       " with status %d\n", direntry->d_name,
1651
2226
                       WEXITSTATUS(status));
 
2227
          free(direntry);
1652
2228
          continue;
1653
2229
        }
1654
2230
      } else if(WIFSIGNALED(status)){
1655
2231
        fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1656
2232
                     " signal %d\n", direntry->d_name,
1657
2233
                     WTERMSIG(status));
 
2234
        free(direntry);
1658
2235
        continue;
1659
2236
      } else {
1660
2237
        fprintf_plus(stderr, "Warning: network hook \"%s\""
1661
2238
                     " crashed\n", direntry->d_name);
 
2239
        free(direntry);
1662
2240
        continue;
1663
2241
      }
1664
2242
    }
1666
2244
      fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1667
2245
                   direntry->d_name);
1668
2246
    }
 
2247
    free(direntry);
1669
2248
  }
1670
2249
  free(direntries);
1671
 
  if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
 
2250
  if(close(hookdir_fd) == -1){
1672
2251
    perror_plus("close");
1673
2252
  } else {
1674
2253
    hookdir_fd = -1;
1677
2256
}
1678
2257
 
1679
2258
__attribute__((nonnull, warn_unused_result))
1680
 
error_t bring_up_interface(const char *const interface,
1681
 
                           const float delay){
1682
 
  error_t old_errno = errno;
 
2259
int bring_up_interface(const char *const interface,
 
2260
                       const float delay){
 
2261
  int old_errno = errno;
1683
2262
  int ret;
1684
2263
  struct ifreq network;
1685
2264
  unsigned int if_index = if_nametoindex(interface);
1695
2274
  }
1696
2275
  
1697
2276
  if(not interface_is_up(interface)){
1698
 
    error_t ret_errno = 0, ioctl_errno = 0;
 
2277
    int ret_errno = 0;
 
2278
    int ioctl_errno = 0;
1699
2279
    if(not get_flags(interface, &network)){
1700
2280
      ret_errno = errno;
1701
2281
      fprintf_plus(stderr, "Failed to get flags for interface "
1714
2294
    }
1715
2295
    
1716
2296
    if(quit_now){
1717
 
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
2297
      ret = close(sd);
1718
2298
      if(ret == -1){
1719
2299
        perror_plus("close");
1720
2300
      }
1770
2350
    }
1771
2351
    
1772
2352
    /* Close the socket */
1773
 
    ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
2353
    ret = close(sd);
1774
2354
    if(ret == -1){
1775
2355
      perror_plus("close");
1776
2356
    }
1788
2368
  
1789
2369
  /* Sleep checking until interface is running.
1790
2370
     Check every 0.25s, up to total time of delay */
1791
 
  for(int i=0; i < delay * 4; i++){
 
2371
  for(int i = 0; i < delay * 4; i++){
1792
2372
    if(interface_is_running(interface)){
1793
2373
      break;
1794
2374
    }
1804
2384
}
1805
2385
 
1806
2386
__attribute__((nonnull, warn_unused_result))
1807
 
error_t take_down_interface(const char *const interface){
1808
 
  error_t old_errno = errno;
 
2387
int take_down_interface(const char *const interface){
 
2388
  int old_errno = errno;
1809
2389
  struct ifreq network;
1810
2390
  unsigned int if_index = if_nametoindex(interface);
1811
2391
  if(if_index == 0){
1814
2394
    return ENXIO;
1815
2395
  }
1816
2396
  if(interface_is_up(interface)){
1817
 
    error_t ret_errno = 0, ioctl_errno = 0;
 
2397
    int ret_errno = 0;
 
2398
    int ioctl_errno = 0;
1818
2399
    if(not get_flags(interface, &network) and debug){
1819
2400
      ret_errno = errno;
1820
2401
      fprintf_plus(stderr, "Failed to get flags for interface "
1858
2439
    }
1859
2440
    
1860
2441
    /* Close the socket */
1861
 
    int ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
2442
    int ret = close(sd);
1862
2443
    if(ret == -1){
1863
2444
      perror_plus("close");
1864
2445
    }
1879
2460
}
1880
2461
 
1881
2462
int main(int argc, char *argv[]){
1882
 
  mandos_context mc = { .server = NULL, .dh_bits = 1024,
1883
 
                        .priority = "SECURE256:!CTYPE-X.509:"
1884
 
                        "+CTYPE-OPENPGP", .current_server = NULL,
1885
 
                        .interfaces = NULL, .interfaces_size = 0 };
 
2463
  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 };
1886
2476
  AvahiSServiceBrowser *sb = NULL;
1887
2477
  error_t ret_errno;
1888
2478
  int ret;
1897
2487
  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1898
2488
  const char *seckey = PATHDIR "/" SECKEY;
1899
2489
  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;
1900
2495
  char *interfaces_hooks = NULL;
1901
2496
  
1902
2497
  bool gnutls_initialized = false;
1949
2544
      { .name = "pubkey", .key = 'p',
1950
2545
        .arg = "FILE",
1951
2546
        .doc = "OpenPGP public key file base name",
1952
 
        .group = 2 },
 
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 },
1953
2564
      { .name = "dh-bits", .key = 129,
1954
2565
        .arg = "BITS",
1955
2566
        .doc = "Bit length of the prime number used in the"
1956
2567
        " Diffie-Hellman key exchange",
1957
2568
        .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 },
1958
2574
      { .name = "priority", .key = 130,
1959
2575
        .arg = "STRING",
1960
2576
        .doc = "GnuTLS priority string for the TLS handshake",
2006
2622
      case 'p':                 /* --pubkey */
2007
2623
        pubkey = arg;
2008
2624
        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;
2009
2635
      case 129:                 /* --dh-bits */
2010
2636
        errno = 0;
2011
2637
        tmpmax = strtoimax(arg, &tmp, 10);
2015
2641
        }
2016
2642
        mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
2017
2643
        break;
 
2644
      case 134:                 /* --dh-params */
 
2645
        dh_params_file = arg;
 
2646
        break;
2018
2647
      case 130:                 /* --priority */
2019
2648
        mc.priority = arg;
2020
2649
        break;
2043
2672
        argp_state_help(state, state->out_stream,
2044
2673
                        (ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
2045
2674
                        & ~(unsigned int)ARGP_HELP_EXIT_OK);
 
2675
        __builtin_unreachable();
2046
2676
      case -3:                  /* --usage */
2047
2677
        argp_state_help(state, state->out_stream,
2048
2678
                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
 
2679
        __builtin_unreachable();
2049
2680
      case 'V':                 /* --version */
2050
2681
        fprintf_plus(state->out_stream, "%s\n", argp_program_version);
2051
2682
        exit(argp_err_exit_status);
2060
2691
                         .args_doc = "",
2061
2692
                         .doc = "Mandos client -- Get and decrypt"
2062
2693
                         " passwords from a Mandos server" };
2063
 
    ret = argp_parse(&argp, argc, argv,
2064
 
                     ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2065
 
    switch(ret){
 
2694
    ret_errno = argp_parse(&argp, argc, argv,
 
2695
                           ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
 
2696
    switch(ret_errno){
2066
2697
    case 0:
2067
2698
      break;
2068
2699
    case ENOMEM:
2069
2700
    default:
2070
 
      errno = ret;
 
2701
      errno = ret_errno;
2071
2702
      perror_plus("argp_parse");
2072
2703
      exitcode = EX_OSERR;
2073
2704
      goto end;
2076
2707
      goto end;
2077
2708
    }
2078
2709
  }
2079
 
    
 
2710
  
2080
2711
  {
2081
2712
    /* Work around Debian bug #633582:
2082
 
       <http://bugs.debian.org/633582> */
 
2713
       <https://bugs.debian.org/633582> */
2083
2714
    
2084
2715
    /* Re-raise privileges */
2085
 
    ret_errno = raise_privileges();
2086
 
    if(ret_errno != 0){
2087
 
      errno = ret_errno;
 
2716
    ret = raise_privileges();
 
2717
    if(ret != 0){
 
2718
      errno = ret;
2088
2719
      perror_plus("Failed to raise privileges");
2089
2720
    } else {
2090
2721
      struct stat st;
2106
2737
              }
2107
2738
            }
2108
2739
          }
2109
 
          TEMP_FAILURE_RETRY(close(seckey_fd));
 
2740
          close(seckey_fd);
2110
2741
        }
2111
2742
      }
2112
 
    
 
2743
      
2113
2744
      if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2114
2745
        int pubkey_fd = open(pubkey, O_RDONLY);
2115
2746
        if(pubkey_fd == -1){
2127
2758
              }
2128
2759
            }
2129
2760
          }
2130
 
          TEMP_FAILURE_RETRY(close(pubkey_fd));
2131
 
        }
2132
 
      }
2133
 
    
 
2761
          close(pubkey_fd);
 
2762
        }
 
2763
      }
 
2764
      
 
2765
      if(dh_params_file != NULL
 
2766
         and strcmp(dh_params_file, PATHDIR "/dhparams.pem" ) == 0){
 
2767
        int dhparams_fd = open(dh_params_file, O_RDONLY);
 
2768
        if(dhparams_fd == -1){
 
2769
          perror_plus("open");
 
2770
        } else {
 
2771
          ret = (int)TEMP_FAILURE_RETRY(fstat(dhparams_fd, &st));
 
2772
          if(ret == -1){
 
2773
            perror_plus("fstat");
 
2774
          } else {
 
2775
            if(S_ISREG(st.st_mode)
 
2776
               and st.st_uid == 0 and st.st_gid == 0){
 
2777
              ret = fchown(dhparams_fd, uid, gid);
 
2778
              if(ret == -1){
 
2779
                perror_plus("fchown");
 
2780
              }
 
2781
            }
 
2782
          }
 
2783
          close(dhparams_fd);
 
2784
        }
 
2785
      }
 
2786
      
2134
2787
      /* Lower privileges */
2135
 
      ret_errno = lower_privileges();
2136
 
      if(ret_errno != 0){
2137
 
        errno = ret_errno;
 
2788
      ret = lower_privileges();
 
2789
      if(ret != 0){
 
2790
        errno = ret;
2138
2791
        perror_plus("Failed to lower privileges");
2139
2792
      }
2140
2793
    }
2265
2918
        if(ret_errno != 0){
2266
2919
          errno = ret_errno;
2267
2920
          perror_plus("argz_add");
 
2921
          free(direntries[i]);
2268
2922
          continue;
2269
2923
        }
2270
2924
        if(debug){
2271
2925
          fprintf_plus(stderr, "Will use interface \"%s\"\n",
2272
2926
                       direntries[i]->d_name);
2273
2927
        }
 
2928
        free(direntries[i]);
2274
2929
      }
2275
2930
      free(direntries);
2276
2931
    } else {
2308
2963
      errno = bring_up_interface(interface, delay);
2309
2964
      if(not interface_was_up){
2310
2965
        if(errno != 0){
2311
 
          perror_plus("Failed to bring up interface");
 
2966
          fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
 
2967
                       " %s\n", interface, strerror(errno));
2312
2968
        } else {
2313
2969
          errno = argz_add(&interfaces_to_take_down,
2314
2970
                           &interfaces_to_take_down_size,
2337
2993
    goto end;
2338
2994
  }
2339
2995
  
2340
 
  ret = init_gnutls_global(pubkey, seckey, &mc);
 
2996
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
2997
  ret = init_gnutls_global(tls_pubkey, tls_privkey, dh_params_file, &mc);
 
2998
#elif GNUTLS_VERSION_NUMBER < 0x030600
 
2999
  ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
 
3000
#else
 
3001
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
 
3002
#endif
2341
3003
  if(ret == -1){
2342
3004
    fprintf_plus(stderr, "init_gnutls_global failed\n");
2343
3005
    exitcode = EX_UNAVAILABLE;
2465
3127
    
2466
3128
    /* Allocate a new server */
2467
3129
    mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
2468
 
                                 &config, NULL, NULL, &ret_errno);
 
3130
                                 &config, NULL, NULL, &ret);
2469
3131
    
2470
3132
    /* Free the Avahi configuration data */
2471
3133
    avahi_server_config_free(&config);
2474
3136
  /* Check if creating the Avahi server object succeeded */
2475
3137
  if(mc.server == NULL){
2476
3138
    fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2477
 
                 avahi_strerror(ret_errno));
 
3139
                 avahi_strerror(ret));
2478
3140
    exitcode = EX_UNAVAILABLE;
2479
3141
    goto end;
2480
3142
  }
2515
3177
 end:
2516
3178
  
2517
3179
  if(debug){
2518
 
    fprintf_plus(stderr, "%s exiting\n", argv[0]);
 
3180
    if(signal_received){
 
3181
      fprintf_plus(stderr, "%s exiting due to signal %d: %s\n",
 
3182
                   argv[0], signal_received,
 
3183
                   strsignal(signal_received));
 
3184
    } else {
 
3185
      fprintf_plus(stderr, "%s exiting\n", argv[0]);
 
3186
    }
2519
3187
  }
2520
3188
  
2521
3189
  /* Cleanup things */
2532
3200
  
2533
3201
  if(gnutls_initialized){
2534
3202
    gnutls_certificate_free_credentials(mc.cred);
2535
 
    gnutls_global_deinit();
2536
3203
    gnutls_dh_params_deinit(mc.dh_params);
2537
3204
  }
2538
3205
  
2546
3213
    mc.current_server->prev->next = NULL;
2547
3214
    while(mc.current_server != NULL){
2548
3215
      server *next = mc.current_server->next;
 
3216
#ifdef __GNUC__
 
3217
#pragma GCC diagnostic push
 
3218
#pragma GCC diagnostic ignored "-Wcast-qual"
 
3219
#endif
 
3220
      free((char *)(mc.current_server->ip));
 
3221
#ifdef __GNUC__
 
3222
#pragma GCC diagnostic pop
 
3223
#endif
2549
3224
      free(mc.current_server);
2550
3225
      mc.current_server = next;
2551
3226
    }
2553
3228
  
2554
3229
  /* Re-raise privileges */
2555
3230
  {
2556
 
    ret_errno = raise_privileges();
2557
 
    if(ret_errno != 0){
2558
 
      errno = ret_errno;
 
3231
    ret = raise_privileges();
 
3232
    if(ret != 0){
 
3233
      errno = ret;
2559
3234
      perror_plus("Failed to raise privileges");
2560
3235
    } else {
2561
3236
      
2566
3241
      /* Take down the network interfaces which were brought up */
2567
3242
      {
2568
3243
        char *interface = NULL;
2569
 
        while((interface=argz_next(interfaces_to_take_down,
2570
 
                                   interfaces_to_take_down_size,
2571
 
                                   interface))){
2572
 
          ret_errno = take_down_interface(interface);
2573
 
          if(ret_errno != 0){
2574
 
            errno = ret_errno;
 
3244
        while((interface = argz_next(interfaces_to_take_down,
 
3245
                                     interfaces_to_take_down_size,
 
3246
                                     interface))){
 
3247
          ret = take_down_interface(interface);
 
3248
          if(ret != 0){
 
3249
            errno = ret;
2575
3250
            perror_plus("Failed to take down interface");
2576
3251
          }
2577
3252
        }
2582
3257
      }
2583
3258
    }
2584
3259
    
2585
 
    ret_errno = lower_privileges_permanently();
2586
 
    if(ret_errno != 0){
2587
 
      errno = ret_errno;
 
3260
    ret = lower_privileges_permanently();
 
3261
    if(ret != 0){
 
3262
      errno = ret;
2588
3263
      perror_plus("Failed to lower privileges permanently");
2589
3264
    }
2590
3265
  }
2592
3267
  free(interfaces_to_take_down);
2593
3268
  free(interfaces_hooks);
2594
3269
  
 
3270
  void clean_dir_at(int base, const char * const dirname,
 
3271
                    uintmax_t level){
 
3272
    struct dirent **direntries = NULL;
 
3273
    int dret;
 
3274
    int dir_fd = (int)TEMP_FAILURE_RETRY(openat(base, dirname,
 
3275
                                                O_RDONLY
 
3276
                                                | O_NOFOLLOW
 
3277
                                                | O_DIRECTORY
 
3278
                                                | O_PATH));
 
3279
    if(dir_fd == -1){
 
3280
      perror_plus("open");
 
3281
      return;
 
3282
    }
 
3283
    int numentries = scandirat(dir_fd, ".", &direntries,
 
3284
                               notdotentries, alphasort);
 
3285
    if(numentries >= 0){
 
3286
      for(int i = 0; i < numentries; i++){
 
3287
        if(debug){
 
3288
          fprintf_plus(stderr, "Unlinking \"%s/%s\"\n",
 
3289
                       dirname, direntries[i]->d_name);
 
3290
        }
 
3291
        dret = unlinkat(dir_fd, direntries[i]->d_name, 0);
 
3292
        if(dret == -1){
 
3293
          if(errno == EISDIR){
 
3294
              dret = unlinkat(dir_fd, direntries[i]->d_name,
 
3295
                              AT_REMOVEDIR);
 
3296
          }         
 
3297
          if((dret == -1) and (errno == ENOTEMPTY)
 
3298
             and (strcmp(direntries[i]->d_name, "private-keys-v1.d")
 
3299
                  == 0) and (level == 0)){
 
3300
            /* Recurse only in this special case */
 
3301
            clean_dir_at(dir_fd, direntries[i]->d_name, level+1);
 
3302
            dret = 0;
 
3303
          }
 
3304
          if((dret == -1) and (errno != ENOENT)){
 
3305
            fprintf_plus(stderr, "unlink(\"%s/%s\"): %s\n", dirname,
 
3306
                         direntries[i]->d_name, strerror(errno));
 
3307
          }
 
3308
        }
 
3309
        free(direntries[i]);
 
3310
      }
 
3311
      
 
3312
      /* need to clean even if 0 because man page doesn't specify */
 
3313
      free(direntries);
 
3314
      dret = unlinkat(base, dirname, AT_REMOVEDIR);
 
3315
      if(dret == -1 and errno != ENOENT){
 
3316
        perror_plus("rmdir");
 
3317
      }
 
3318
    } else {
 
3319
      perror_plus("scandirat");
 
3320
    }
 
3321
    close(dir_fd);
 
3322
  }
 
3323
  
2595
3324
  /* Removes the GPGME temp directory and all files inside */
2596
3325
  if(tempdir != NULL){
2597
 
    struct dirent **direntries = NULL;
2598
 
    int tempdir_fd = (int)TEMP_FAILURE_RETRY(open(tempdir, O_RDONLY |
2599
 
                                                  O_NOFOLLOW));
2600
 
    if(tempdir_fd == -1){
2601
 
      perror_plus("open");
2602
 
    } else {
2603
 
#ifdef __GLIBC__
2604
 
#if __GLIBC_PREREQ(2, 15)
2605
 
      int numentries = scandirat(tempdir_fd, ".", &direntries,
2606
 
                                 notdotentries, alphasort);
2607
 
#else  /* not __GLIBC_PREREQ(2, 15) */
2608
 
      int numentries = scandir(tempdir, &direntries, notdotentries,
2609
 
                               alphasort);
2610
 
#endif  /* not __GLIBC_PREREQ(2, 15) */
2611
 
#else   /* not __GLIBC__ */
2612
 
      int numentries = scandir(tempdir, &direntries, notdotentries,
2613
 
                               alphasort);
2614
 
#endif  /* not __GLIBC__ */
2615
 
      if(numentries >= 0){
2616
 
        for(int i = 0; i < numentries; i++){
2617
 
          ret = unlinkat(tempdir_fd, direntries[i]->d_name, 0);
2618
 
          if(ret == -1){
2619
 
            fprintf_plus(stderr, "unlinkat(open(\"%s\", O_RDONLY),"
2620
 
                         " \"%s\", 0): %s\n", tempdir,
2621
 
                         direntries[i]->d_name, strerror(errno));
2622
 
          }
2623
 
        }
2624
 
        
2625
 
        /* need to clean even if 0 because man page doesn't specify */
2626
 
        free(direntries);
2627
 
        if(numentries == -1){
2628
 
          perror_plus("scandir");
2629
 
        }
2630
 
        ret = rmdir(tempdir);
2631
 
        if(ret == -1 and errno != ENOENT){
2632
 
          perror_plus("rmdir");
2633
 
        }
2634
 
      }
2635
 
      TEMP_FAILURE_RETRY(close(tempdir_fd));
2636
 
    }
 
3326
    clean_dir_at(-1, tempdir, 0);
2637
3327
  }
2638
3328
  
2639
3329
  if(quit_now){