/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 Hogeborn
  • Date: 2015-07-20 03:03:33 UTC
  • Revision ID: teddy@recompile.se-20150720030333-203m2aeblypcsfte
Bug fix for GnuTLS 3: be compatible with old 2048-bit DSA keys.

The mandos-keygen program in Mandos version 1.6.0 and older generated
2048-bit DSA keys, and when GnuTLS uses these it has trouble
connecting using the Mandos default priority string.  This was
previously fixed in Mandos 1.6.2, but the bug reappeared when using
GnuTLS 3, so the default priority string has to change again; this
time also the Mandos client has to change its default, so now the
server and the client should use the same default priority string:

SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256

* mandos (main/server_defaults): Changed default priority string.
* mandos-options.xml (/section/para[id="priority_compat"]): Removed.
  (/section/para[id="priority"]): Changed default priority string.
* mandos.conf ([DEFAULT]/priority): - '' -
* mandos.conf.xml (OPTIONS/priority): Refer to the id "priority"
                                      instead of "priority_compat".
* mandos.xml (OPTIONS/--priority): - '' -
* plugins.d/mandos-client.c (main): Changed default priority string.

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-2013 Teddy Hogeborn
13
 
 * Copyright © 2008-2013 Björn Påhlsson
 
12
 * Copyright © 2008-2015 Teddy Hogeborn
 
13
 * Copyright © 2008-2015 Björn Påhlsson
14
14
 * 
15
15
 * This program is free software: you can redistribute it and/or
16
16
 * modify it under the terms of the GNU General Public License as
32
32
/* Needed by GPGME, specifically gpgme_data_seek() */
33
33
#ifndef _LARGEFILE_SOURCE
34
34
#define _LARGEFILE_SOURCE
35
 
#endif
 
35
#endif  /* not _LARGEFILE_SOURCE */
36
36
#ifndef _FILE_OFFSET_BITS
37
37
#define _FILE_OFFSET_BITS 64
38
 
#endif
 
38
#endif  /* not _FILE_OFFSET_BITS */
39
39
 
40
40
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), asprintf() */
41
41
 
42
42
#include <stdio.h>              /* fprintf(), stderr, fwrite(),
43
 
                                   stdout, ferror(), remove() */
 
43
                                   stdout, ferror() */
44
44
#include <stdint.h>             /* uint16_t, uint32_t, intptr_t */
45
45
#include <stddef.h>             /* NULL, size_t, ssize_t */
46
46
#include <stdlib.h>             /* free(), EXIT_SUCCESS, srand(),
47
47
                                   strtof(), abort() */
48
48
#include <stdbool.h>            /* bool, false, true */
49
 
#include <string.h>             /* memset(), strcmp(), strlen(),
50
 
                                   strerror(), asprintf(), strcpy() */
 
49
#include <string.h>             /* strcmp(), strlen(), strerror(),
 
50
                                   asprintf(), strcpy() */
51
51
#include <sys/ioctl.h>          /* ioctl */
52
52
#include <sys/types.h>          /* socket(), inet_pton(), sockaddr,
53
53
                                   sockaddr_in6, PF_INET6,
57
57
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
58
58
                                   inet_pton(), connect(),
59
59
                                   getnameinfo() */
60
 
#include <fcntl.h>              /* open() */
 
60
#include <fcntl.h>              /* open(), unlinkat() */
61
61
#include <dirent.h>             /* opendir(), struct dirent, readdir()
62
62
                                 */
63
63
#include <inttypes.h>           /* PRIu16, PRIdMAX, intmax_t,
73
73
                                */
74
74
#include <unistd.h>             /* close(), SEEK_SET, off_t, write(),
75
75
                                   getuid(), getgid(), seteuid(),
76
 
                                   setgid(), pause(), _exit() */
 
76
                                   setgid(), pause(), _exit(),
 
77
                                   unlinkat() */
77
78
#include <arpa/inet.h>          /* inet_pton(), htons() */
78
79
#include <iso646.h>             /* not, or, and */
79
80
#include <argp.h>               /* struct argp_option, error_t, struct
141
142
static const char sys_class_net[] = "/sys/class/net";
142
143
char *connect_to = NULL;
143
144
const char *hookdir = HOOKDIR;
 
145
int hookdir_fd = -1;
144
146
uid_t uid = 65534;
145
147
gid_t gid = 65534;
146
148
 
232
234
                          .af = af };
233
235
  if(new_server->ip == NULL){
234
236
    perror_plus("strdup");
 
237
    free(new_server);
235
238
    return false;
236
239
  }
237
240
  ret = clock_gettime(CLOCK_MONOTONIC, &(new_server->last_seen));
238
241
  if(ret == -1){
239
242
    perror_plus("clock_gettime");
 
243
#ifdef __GNUC__
 
244
#pragma GCC diagnostic push
 
245
#pragma GCC diagnostic ignored "-Wcast-qual"
 
246
#endif
 
247
    free((char *)(new_server->ip));
 
248
#ifdef __GNUC__
 
249
#pragma GCC diagnostic pop
 
250
#endif
 
251
    free(new_server);
240
252
    return false;
241
253
  }
242
254
  /* Special case of first server */
258
270
 * Initialize GPGME.
259
271
 */
260
272
__attribute__((nonnull, warn_unused_result))
261
 
static bool init_gpgme(const char *seckey, const char *pubkey,
262
 
                       const char *tempdir, mandos_context *mc){
 
273
static bool init_gpgme(const char * const seckey,
 
274
                       const char * const pubkey,
 
275
                       const char * const tempdir,
 
276
                       mandos_context *mc){
263
277
  gpgme_error_t rc;
264
278
  gpgme_engine_info_t engine_info;
265
279
  
266
280
  /*
267
281
   * Helper function to insert pub and seckey to the engine keyring.
268
282
   */
269
 
  bool import_key(const char *filename){
 
283
  bool import_key(const char * const filename){
270
284
    int ret;
271
285
    int fd;
272
286
    gpgme_data_t pgp_data;
291
305
      return false;
292
306
    }
293
307
    
294
 
    ret = (int)TEMP_FAILURE_RETRY(close(fd));
 
308
    ret = close(fd);
295
309
    if(ret == -1){
296
310
      perror_plus("close");
297
311
    }
479
493
  return plaintext_length;
480
494
}
481
495
 
 
496
__attribute__((warn_unused_result, const))
 
497
static const char *safe_string(const char *str){
 
498
  if(str == NULL)
 
499
    return "(unknown)";
 
500
  return str;
 
501
}
 
502
 
482
503
__attribute__((warn_unused_result))
483
504
static const char *safer_gnutls_strerror(int value){
484
505
  const char *ret = gnutls_strerror(value);
485
 
  if(ret == NULL)
486
 
    ret = "(unknown)";
487
 
  return ret;
 
506
  return safe_string(ret);
488
507
}
489
508
 
490
509
/* GnuTLS log function callback */
497
516
__attribute__((nonnull, warn_unused_result))
498
517
static int init_gnutls_global(const char *pubkeyfilename,
499
518
                              const char *seckeyfilename,
 
519
                              const char *dhparamsfilename,
500
520
                              mandos_context *mc){
501
521
  int ret;
 
522
  unsigned int uret;
502
523
  
503
524
  if(debug){
504
525
    fprintf_plus(stderr, "Initializing GnuTLS\n");
555
576
                 safer_gnutls_strerror(ret));
556
577
    goto globalfail;
557
578
  }
558
 
  ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
559
 
  if(ret != GNUTLS_E_SUCCESS){
560
 
    fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
561
 
                 safer_gnutls_strerror(ret));
562
 
    goto globalfail;
563
 
  }
564
 
  
 
579
  /* If a Diffie-Hellman parameters file was given, try to use it */
 
580
  if(dhparamsfilename != NULL){
 
581
    gnutls_datum_t params = { .data = NULL, .size = 0 };
 
582
    do {
 
583
      int dhpfile = open(dhparamsfilename, O_RDONLY);
 
584
      if(dhpfile == -1){
 
585
        perror_plus("open");
 
586
        dhparamsfilename = NULL;
 
587
        break;
 
588
      }
 
589
      size_t params_capacity = 0;
 
590
      while(true){
 
591
        params_capacity = incbuffer((char **)&params.data,
 
592
                                    (size_t)params.size,
 
593
                                    (size_t)params_capacity);
 
594
        if(params_capacity == 0){
 
595
          perror_plus("incbuffer");
 
596
          free(params.data);
 
597
          params.data = NULL;
 
598
          dhparamsfilename = NULL;
 
599
          break;
 
600
        }
 
601
        ssize_t bytes_read = read(dhpfile,
 
602
                                  params.data + params.size,
 
603
                                  BUFFER_SIZE);
 
604
        /* EOF */
 
605
        if(bytes_read == 0){
 
606
          break;
 
607
        }
 
608
        /* check bytes_read for failure */
 
609
        if(bytes_read < 0){
 
610
          perror_plus("read");
 
611
          free(params.data);
 
612
          params.data = NULL;
 
613
          dhparamsfilename = NULL;
 
614
          break;
 
615
        }
 
616
        params.size += (unsigned int)bytes_read;
 
617
      }
 
618
      if(params.data == NULL){
 
619
        dhparamsfilename = NULL;
 
620
      }
 
621
      if(dhparamsfilename == NULL){
 
622
        break;
 
623
      }
 
624
      ret = gnutls_dh_params_import_pkcs3(mc->dh_params, &params,
 
625
                                          GNUTLS_X509_FMT_PEM);
 
626
      if(ret != GNUTLS_E_SUCCESS){
 
627
        fprintf_plus(stderr, "Failed to parse DH parameters in file"
 
628
                     " \"%s\": %s\n", dhparamsfilename,
 
629
                     safer_gnutls_strerror(ret));
 
630
        dhparamsfilename = NULL;
 
631
      }
 
632
    } while(false);
 
633
  }
 
634
  if(dhparamsfilename == NULL){
 
635
    if(mc->dh_bits == 0){
 
636
      /* Find out the optimal number of DH bits */
 
637
      /* Try to read the private key file */
 
638
      gnutls_datum_t buffer = { .data = NULL, .size = 0 };
 
639
      do {
 
640
        int secfile = open(seckeyfilename, O_RDONLY);
 
641
        if(secfile == -1){
 
642
          perror_plus("open");
 
643
          break;
 
644
        }
 
645
        size_t buffer_capacity = 0;
 
646
        while(true){
 
647
          buffer_capacity = incbuffer((char **)&buffer.data,
 
648
                                      (size_t)buffer.size,
 
649
                                      (size_t)buffer_capacity);
 
650
          if(buffer_capacity == 0){
 
651
            perror_plus("incbuffer");
 
652
            free(buffer.data);
 
653
            buffer.data = NULL;
 
654
            break;
 
655
          }
 
656
          ssize_t bytes_read = read(secfile,
 
657
                                    buffer.data + buffer.size,
 
658
                                    BUFFER_SIZE);
 
659
          /* EOF */
 
660
          if(bytes_read == 0){
 
661
            break;
 
662
          }
 
663
          /* check bytes_read for failure */
 
664
          if(bytes_read < 0){
 
665
            perror_plus("read");
 
666
            free(buffer.data);
 
667
            buffer.data = NULL;
 
668
            break;
 
669
          }
 
670
          buffer.size += (unsigned int)bytes_read;
 
671
        }
 
672
        close(secfile);
 
673
      } while(false);
 
674
      /* If successful, use buffer to parse private key */
 
675
      gnutls_sec_param_t sec_param = GNUTLS_SEC_PARAM_ULTRA;
 
676
      if(buffer.data != NULL){
 
677
        {
 
678
          gnutls_openpgp_privkey_t privkey = NULL;
 
679
          ret = gnutls_openpgp_privkey_init(&privkey);
 
680
          if(ret != GNUTLS_E_SUCCESS){
 
681
            fprintf_plus(stderr, "Error initializing OpenPGP key"
 
682
                         " structure: %s",
 
683
                         safer_gnutls_strerror(ret));
 
684
            free(buffer.data);
 
685
            buffer.data = NULL;
 
686
          } else {
 
687
            ret = gnutls_openpgp_privkey_import
 
688
              (privkey, &buffer, GNUTLS_OPENPGP_FMT_BASE64, "", 0);
 
689
            if(ret != GNUTLS_E_SUCCESS){
 
690
              fprintf_plus(stderr, "Error importing OpenPGP key : %s",
 
691
                           safer_gnutls_strerror(ret));
 
692
              privkey = NULL;
 
693
            }
 
694
            free(buffer.data);
 
695
            buffer.data = NULL;
 
696
            if(privkey != NULL){
 
697
              /* Use private key to suggest an appropriate
 
698
                 sec_param */
 
699
              sec_param = gnutls_openpgp_privkey_sec_param(privkey);
 
700
              gnutls_openpgp_privkey_deinit(privkey);
 
701
              if(debug){
 
702
                fprintf_plus(stderr, "This OpenPGP key implies using"
 
703
                             " a GnuTLS security parameter \"%s\".\n",
 
704
                             safe_string(gnutls_sec_param_get_name
 
705
                                         (sec_param)));
 
706
              }
 
707
            }
 
708
          }
 
709
        }
 
710
        if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
 
711
          /* Err on the side of caution */
 
712
          sec_param = GNUTLS_SEC_PARAM_ULTRA;
 
713
          if(debug){
 
714
            fprintf_plus(stderr, "Falling back to security parameter"
 
715
                         " \"%s\"\n",
 
716
                         safe_string(gnutls_sec_param_get_name
 
717
                                     (sec_param)));
 
718
          }
 
719
        }
 
720
      }
 
721
      uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
 
722
      if(uret != 0){
 
723
        mc->dh_bits = uret;
 
724
        if(debug){
 
725
          fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
 
726
                       " implies %u DH bits; using that.\n",
 
727
                       safe_string(gnutls_sec_param_get_name
 
728
                                   (sec_param)),
 
729
                       mc->dh_bits);
 
730
        }
 
731
      } else {
 
732
        fprintf_plus(stderr, "Failed to get implied number of DH"
 
733
                     " bits for security parameter \"%s\"): %s\n",
 
734
                     safe_string(gnutls_sec_param_get_name
 
735
                                 (sec_param)),
 
736
                     safer_gnutls_strerror(ret));
 
737
        goto globalfail;
 
738
      }
 
739
    } else if(debug){
 
740
      fprintf_plus(stderr, "DH bits explicitly set to %u\n",
 
741
                   mc->dh_bits);
 
742
    }
 
743
    ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
 
744
    if(ret != GNUTLS_E_SUCCESS){
 
745
      fprintf_plus(stderr, "Error in GnuTLS prime generation (%u"
 
746
                   " bits): %s\n", mc->dh_bits,
 
747
                   safer_gnutls_strerror(ret));
 
748
      goto globalfail;
 
749
    }
 
750
  }
565
751
  gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
566
752
  
567
753
  return 0;
627
813
  /* ignore client certificate if any. */
628
814
  gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
629
815
  
630
 
  gnutls_dh_set_prime_bits(*session, mc->dh_bits);
631
 
  
632
816
  return 0;
633
817
}
634
818
 
636
820
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
637
821
                      __attribute__((unused)) const char *txt){}
638
822
 
 
823
/* Set effective uid to 0, return errno */
 
824
__attribute__((warn_unused_result))
 
825
error_t raise_privileges(void){
 
826
  error_t old_errno = errno;
 
827
  error_t ret_errno = 0;
 
828
  if(seteuid(0) == -1){
 
829
    ret_errno = errno;
 
830
  }
 
831
  errno = old_errno;
 
832
  return ret_errno;
 
833
}
 
834
 
 
835
/* Set effective and real user ID to 0.  Return errno. */
 
836
__attribute__((warn_unused_result))
 
837
error_t raise_privileges_permanently(void){
 
838
  error_t old_errno = errno;
 
839
  error_t ret_errno = raise_privileges();
 
840
  if(ret_errno != 0){
 
841
    errno = old_errno;
 
842
    return ret_errno;
 
843
  }
 
844
  if(setuid(0) == -1){
 
845
    ret_errno = errno;
 
846
  }
 
847
  errno = old_errno;
 
848
  return ret_errno;
 
849
}
 
850
 
 
851
/* Set effective user ID to unprivileged saved user ID */
 
852
__attribute__((warn_unused_result))
 
853
error_t lower_privileges(void){
 
854
  error_t old_errno = errno;
 
855
  error_t ret_errno = 0;
 
856
  if(seteuid(uid) == -1){
 
857
    ret_errno = errno;
 
858
  }
 
859
  errno = old_errno;
 
860
  return ret_errno;
 
861
}
 
862
 
 
863
/* Lower privileges permanently */
 
864
__attribute__((warn_unused_result))
 
865
error_t lower_privileges_permanently(void){
 
866
  error_t old_errno = errno;
 
867
  error_t ret_errno = 0;
 
868
  if(setuid(uid) == -1){
 
869
    ret_errno = errno;
 
870
  }
 
871
  errno = old_errno;
 
872
  return ret_errno;
 
873
}
 
874
 
 
875
/* Helper function to add_local_route() and delete_local_route() */
 
876
__attribute__((nonnull, warn_unused_result))
 
877
static bool add_delete_local_route(const bool add,
 
878
                                   const char *address,
 
879
                                   AvahiIfIndex if_index){
 
880
  int ret;
 
881
  char helper[] = "mandos-client-iprouteadddel";
 
882
  char add_arg[] = "add";
 
883
  char delete_arg[] = "delete";
 
884
  char debug_flag[] = "--debug";
 
885
  char *pluginhelperdir = getenv("MANDOSPLUGINHELPERDIR");
 
886
  if(pluginhelperdir == NULL){
 
887
    if(debug){
 
888
      fprintf_plus(stderr, "MANDOSPLUGINHELPERDIR environment"
 
889
                   " variable not set; cannot run helper\n");
 
890
    }
 
891
    return false;
 
892
  }
 
893
  
 
894
  char interface[IF_NAMESIZE];
 
895
  if(if_indextoname((unsigned int)if_index, interface) == NULL){
 
896
    perror_plus("if_indextoname");
 
897
    return false;
 
898
  }
 
899
  
 
900
  int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
 
901
  if(devnull == -1){
 
902
    perror_plus("open(\"/dev/null\", O_RDONLY)");
 
903
    return false;
 
904
  }
 
905
  pid_t pid = fork();
 
906
  if(pid == 0){
 
907
    /* Child */
 
908
    /* Raise privileges */
 
909
    errno = raise_privileges_permanently();
 
910
    if(errno != 0){
 
911
      perror_plus("Failed to raise privileges");
 
912
      /* _exit(EX_NOPERM); */
 
913
    } else {
 
914
      /* Set group */
 
915
      errno = 0;
 
916
      ret = setgid(0);
 
917
      if(ret == -1){
 
918
        perror_plus("setgid");
 
919
        _exit(EX_NOPERM);
 
920
      }
 
921
      /* Reset supplementary groups */
 
922
      errno = 0;
 
923
      ret = setgroups(0, NULL);
 
924
      if(ret == -1){
 
925
        perror_plus("setgroups");
 
926
        _exit(EX_NOPERM);
 
927
      }
 
928
    }
 
929
    ret = dup2(devnull, STDIN_FILENO);
 
930
    if(ret == -1){
 
931
      perror_plus("dup2(devnull, STDIN_FILENO)");
 
932
      _exit(EX_OSERR);
 
933
    }
 
934
    ret = close(devnull);
 
935
    if(ret == -1){
 
936
      perror_plus("close");
 
937
      _exit(EX_OSERR);
 
938
    }
 
939
    ret = dup2(STDERR_FILENO, STDOUT_FILENO);
 
940
    if(ret == -1){
 
941
      perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
 
942
      _exit(EX_OSERR);
 
943
    }
 
944
    int helperdir_fd = (int)TEMP_FAILURE_RETRY(open(pluginhelperdir,
 
945
                                                    O_RDONLY
 
946
                                                    | O_DIRECTORY
 
947
                                                    | O_PATH
 
948
                                                    | O_CLOEXEC));
 
949
    if(helperdir_fd == -1){
 
950
      perror_plus("open");
 
951
      _exit(EX_UNAVAILABLE);
 
952
    }
 
953
    int helper_fd = (int)TEMP_FAILURE_RETRY(openat(helperdir_fd,
 
954
                                                   helper, O_RDONLY));
 
955
    if(helper_fd == -1){
 
956
      perror_plus("openat");
 
957
      close(helperdir_fd);
 
958
      _exit(EX_UNAVAILABLE);
 
959
    }
 
960
    close(helperdir_fd);
 
961
#ifdef __GNUC__
 
962
#pragma GCC diagnostic push
 
963
#pragma GCC diagnostic ignored "-Wcast-qual"
 
964
#endif
 
965
    if(fexecve(helper_fd, (char *const [])
 
966
               { helper, add ? add_arg : delete_arg, (char *)address,
 
967
                   interface, debug ? debug_flag : NULL, NULL },
 
968
               environ) == -1){
 
969
#ifdef __GNUC__
 
970
#pragma GCC diagnostic pop
 
971
#endif
 
972
      perror_plus("fexecve");
 
973
      _exit(EXIT_FAILURE);
 
974
    }
 
975
  }
 
976
  if(pid == -1){
 
977
    perror_plus("fork");
 
978
    return false;
 
979
  }
 
980
  int status;
 
981
  pid_t pret = -1;
 
982
  errno = 0;
 
983
  do {
 
984
    pret = waitpid(pid, &status, 0);
 
985
    if(pret == -1 and errno == EINTR and quit_now){
 
986
      int errno_raising = 0;
 
987
      if((errno = raise_privileges()) != 0){
 
988
        errno_raising = errno;
 
989
        perror_plus("Failed to raise privileges in order to"
 
990
                    " kill helper program");
 
991
      }
 
992
      if(kill(pid, SIGTERM) == -1){
 
993
        perror_plus("kill");
 
994
      }
 
995
      if((errno_raising == 0) and (errno = lower_privileges()) != 0){
 
996
        perror_plus("Failed to lower privileges after killing"
 
997
                    " helper program");
 
998
      }
 
999
      return false;
 
1000
    }
 
1001
  } while(pret == -1 and errno == EINTR);
 
1002
  if(pret == -1){
 
1003
    perror_plus("waitpid");
 
1004
    return false;
 
1005
  }
 
1006
  if(WIFEXITED(status)){
 
1007
    if(WEXITSTATUS(status) != 0){
 
1008
      fprintf_plus(stderr, "Error: iprouteadddel exited"
 
1009
                   " with status %d\n", WEXITSTATUS(status));
 
1010
      return false;
 
1011
    }
 
1012
    return true;
 
1013
  }
 
1014
  if(WIFSIGNALED(status)){
 
1015
    fprintf_plus(stderr, "Error: iprouteadddel died by"
 
1016
                 " signal %d\n", WTERMSIG(status));
 
1017
    return false;
 
1018
  }
 
1019
  fprintf_plus(stderr, "Error: iprouteadddel crashed\n");
 
1020
  return false;
 
1021
}
 
1022
 
 
1023
__attribute__((nonnull, warn_unused_result))
 
1024
static bool add_local_route(const char *address,
 
1025
                            AvahiIfIndex if_index){
 
1026
  if(debug){
 
1027
    fprintf_plus(stderr, "Adding route to %s\n", address);
 
1028
  }
 
1029
  return add_delete_local_route(true, address, if_index);
 
1030
}
 
1031
 
 
1032
__attribute__((nonnull, warn_unused_result))
 
1033
static bool delete_local_route(const char *address,
 
1034
                               AvahiIfIndex if_index){
 
1035
  if(debug){
 
1036
    fprintf_plus(stderr, "Removing route to %s\n", address);
 
1037
  }
 
1038
  return add_delete_local_route(false, address, if_index);
 
1039
}
 
1040
 
639
1041
/* Called when a Mandos server is found */
640
1042
__attribute__((nonnull, warn_unused_result))
641
1043
static int start_mandos_communication(const char *ip, in_port_t port,
652
1054
  int retval = -1;
653
1055
  gnutls_session_t session;
654
1056
  int pf;                       /* Protocol family */
 
1057
  bool route_added = false;
655
1058
  
656
1059
  errno = 0;
657
1060
  
715
1118
                 PRIuMAX "\n", ip, (uintmax_t)port);
716
1119
  }
717
1120
  
718
 
  tcp_sd = socket(pf, SOCK_STREAM, 0);
 
1121
  tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
719
1122
  if(tcp_sd < 0){
720
1123
    int e = errno;
721
1124
    perror_plus("socket");
728
1131
    goto mandos_end;
729
1132
  }
730
1133
  
731
 
  memset(&to, 0, sizeof(to));
732
1134
  if(af == AF_INET6){
733
 
    ((struct sockaddr_in6 *)&to)->sin6_family = (sa_family_t)af;
734
 
    ret = inet_pton(af, ip, &((struct sockaddr_in6 *)&to)->sin6_addr);
 
1135
    struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)&to;
 
1136
    *to6 = (struct sockaddr_in6){ .sin6_family = (sa_family_t)af };
 
1137
    ret = inet_pton(af, ip, &to6->sin6_addr);
735
1138
  } else {                      /* IPv4 */
736
 
    ((struct sockaddr_in *)&to)->sin_family = (sa_family_t)af;
737
 
    ret = inet_pton(af, ip, &((struct sockaddr_in *)&to)->sin_addr);
 
1139
    struct sockaddr_in *to4 = (struct sockaddr_in *)&to;
 
1140
    *to4 = (struct sockaddr_in){ .sin_family = (sa_family_t)af };
 
1141
    ret = inet_pton(af, ip, &to4->sin_addr);
738
1142
  }
739
1143
  if(ret < 0 ){
740
1144
    int e = errno;
810
1214
    goto mandos_end;
811
1215
  }
812
1216
  
813
 
  if(af == AF_INET6){
814
 
    ret = connect(tcp_sd, (struct sockaddr *)&to,
815
 
                  sizeof(struct sockaddr_in6));
816
 
  } else {
817
 
    ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
818
 
                  sizeof(struct sockaddr_in));
819
 
  }
820
 
  if(ret < 0){
821
 
    if((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
822
 
      int e = errno;
823
 
      perror_plus("connect");
824
 
      errno = e;
825
 
    }
826
 
    goto mandos_end;
827
 
  }
828
 
  
829
 
  if(quit_now){
830
 
    errno = EINTR;
831
 
    goto mandos_end;
 
1217
  while(true){
 
1218
    if(af == AF_INET6){
 
1219
      ret = connect(tcp_sd, (struct sockaddr *)&to,
 
1220
                    sizeof(struct sockaddr_in6));
 
1221
    } else {
 
1222
      ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
 
1223
                    sizeof(struct sockaddr_in));
 
1224
    }
 
1225
    if(ret < 0){
 
1226
      if(errno == ENETUNREACH
 
1227
         and if_index != AVAHI_IF_UNSPEC
 
1228
         and connect_to == NULL
 
1229
         and not route_added and
 
1230
         ((af == AF_INET6 and not
 
1231
           IN6_IS_ADDR_LINKLOCAL(&(((struct sockaddr_in6 *)
 
1232
                                    &to)->sin6_addr)))
 
1233
          or (af == AF_INET and
 
1234
              /* Not a a IPv4LL address */
 
1235
              (ntohl(((struct sockaddr_in *)&to)->sin_addr.s_addr)
 
1236
               & 0xFFFF0000L) != 0xA9FE0000L))){
 
1237
        /* Work around Avahi bug - Avahi does not announce link-local
 
1238
           addresses if it has a global address, so local hosts with
 
1239
           *only* a link-local address (e.g. Mandos clients) cannot
 
1240
           connect to a Mandos server announced by Avahi on a server
 
1241
           host with a global address.  Work around this by retrying
 
1242
           with an explicit route added with the server's address.
 
1243
           
 
1244
           Avahi bug reference:
 
1245
           http://lists.freedesktop.org/archives/avahi/2010-February/001833.html
 
1246
           https://bugs.debian.org/587961
 
1247
        */
 
1248
        if(debug){
 
1249
          fprintf_plus(stderr, "Mandos server unreachable, trying"
 
1250
                       " direct route\n");
 
1251
        }
 
1252
        int e = errno;
 
1253
        route_added = add_local_route(ip, if_index);
 
1254
        if(route_added){
 
1255
          continue;
 
1256
        }
 
1257
        errno = e;
 
1258
      }
 
1259
      if(errno != ECONNREFUSED or debug){
 
1260
        int e = errno;
 
1261
        perror_plus("connect");
 
1262
        errno = e;
 
1263
      }
 
1264
      goto mandos_end;
 
1265
    }
 
1266
    
 
1267
    if(quit_now){
 
1268
      errno = EINTR;
 
1269
      goto mandos_end;
 
1270
    }
 
1271
    break;
832
1272
  }
833
1273
  
834
1274
  const char *out = mandos_protocol_version;
1017
1457
  
1018
1458
 mandos_end:
1019
1459
  {
 
1460
    if(route_added){
 
1461
      if(not delete_local_route(ip, if_index)){
 
1462
        fprintf_plus(stderr, "Failed to delete local route to %s on"
 
1463
                     " interface %d", ip, if_index);
 
1464
      }
 
1465
    }
1020
1466
    int e = errno;
1021
1467
    free(decrypted_buffer);
1022
1468
    free(buffer);
1023
1469
    if(tcp_sd >= 0){
1024
 
      ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
 
1470
      ret = close(tcp_sd);
1025
1471
    }
1026
1472
    if(ret == -1){
1027
1473
      if(e == 0){
1062
1508
     timed out */
1063
1509
  
1064
1510
  if(quit_now){
 
1511
    avahi_s_service_resolver_free(r);
1065
1512
    return;
1066
1513
  }
1067
1514
  
1333
1780
  sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1334
1781
                "abcdefghijklmnopqrstuvwxyz"
1335
1782
                "0123456789"
1336
 
                "_-");
 
1783
                "_.-");
1337
1784
  if((direntry->d_name)[sret] != '\0'){
1338
1785
    /* Contains non-allowed characters */
1339
1786
    if(debug){
1343
1790
    return 0;
1344
1791
  }
1345
1792
  
1346
 
  char *fullname = NULL;
1347
 
  ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1348
 
  if(ret < 0){
1349
 
    perror_plus("asprintf");
1350
 
    return 0;
1351
 
  }
1352
 
  
1353
 
  ret = stat(fullname, &st);
 
1793
  ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
1354
1794
  if(ret == -1){
1355
1795
    if(debug){
1356
1796
      perror_plus("Could not stat hook");
1454
1894
  }
1455
1895
}
1456
1896
 
1457
 
/* Set effective uid to 0, return errno */
1458
 
__attribute__((warn_unused_result))
1459
 
error_t raise_privileges(void){
1460
 
  error_t old_errno = errno;
1461
 
  error_t ret_errno = 0;
1462
 
  if(seteuid(0) == -1){
1463
 
    ret_errno = errno;
1464
 
    perror_plus("seteuid");
1465
 
  }
1466
 
  errno = old_errno;
1467
 
  return ret_errno;
1468
 
}
1469
 
 
1470
 
/* Set effective and real user ID to 0.  Return errno. */
1471
 
__attribute__((warn_unused_result))
1472
 
error_t raise_privileges_permanently(void){
1473
 
  error_t old_errno = errno;
1474
 
  error_t ret_errno = raise_privileges();
1475
 
  if(ret_errno != 0){
1476
 
    errno = old_errno;
1477
 
    return ret_errno;
1478
 
  }
1479
 
  if(setuid(0) == -1){
1480
 
    ret_errno = errno;
1481
 
    perror_plus("seteuid");
1482
 
  }
1483
 
  errno = old_errno;
1484
 
  return ret_errno;
1485
 
}
1486
 
 
1487
 
/* Set effective user ID to unprivileged saved user ID */
1488
 
__attribute__((warn_unused_result))
1489
 
error_t lower_privileges(void){
1490
 
  error_t old_errno = errno;
1491
 
  error_t ret_errno = 0;
1492
 
  if(seteuid(uid) == -1){
1493
 
    ret_errno = errno;
1494
 
    perror_plus("seteuid");
1495
 
  }
1496
 
  errno = old_errno;
1497
 
  return ret_errno;
1498
 
}
1499
 
 
1500
 
/* Lower privileges permanently */
1501
 
__attribute__((warn_unused_result))
1502
 
error_t lower_privileges_permanently(void){
1503
 
  error_t old_errno = errno;
1504
 
  error_t ret_errno = 0;
1505
 
  if(setuid(uid) == -1){
1506
 
    ret_errno = errno;
1507
 
    perror_plus("setuid");
1508
 
  }
1509
 
  errno = old_errno;
1510
 
  return ret_errno;
1511
 
}
1512
 
 
1513
1897
__attribute__((nonnull))
1514
1898
void run_network_hooks(const char *mode, const char *interface,
1515
1899
                       const float delay){
1516
 
  struct dirent **direntries;
1517
 
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
1518
 
                         alphasort);
 
1900
  struct dirent **direntries = NULL;
 
1901
  if(hookdir_fd == -1){
 
1902
    hookdir_fd = open(hookdir, O_RDONLY | O_DIRECTORY | O_PATH
 
1903
                      | O_CLOEXEC);
 
1904
    if(hookdir_fd == -1){
 
1905
      if(errno == ENOENT){
 
1906
        if(debug){
 
1907
          fprintf_plus(stderr, "Network hook directory \"%s\" not"
 
1908
                       " found\n", hookdir);
 
1909
        }
 
1910
      } else {
 
1911
        perror_plus("open");
 
1912
      }
 
1913
      return;
 
1914
    }
 
1915
  }
 
1916
#ifdef __GLIBC__
 
1917
#if __GLIBC_PREREQ(2, 15)
 
1918
  int numhooks = scandirat(hookdir_fd, ".", &direntries,
 
1919
                           runnable_hook, alphasort);
 
1920
#else  /* not __GLIBC_PREREQ(2, 15) */
 
1921
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
 
1922
                         alphasort);
 
1923
#endif  /* not __GLIBC_PREREQ(2, 15) */
 
1924
#else   /* not __GLIBC__ */
 
1925
  int numhooks = scandir(hookdir, &direntries, runnable_hook,
 
1926
                         alphasort);
 
1927
#endif  /* not __GLIBC__ */
1519
1928
  if(numhooks == -1){
1520
 
    if(errno == ENOENT){
1521
 
      if(debug){
1522
 
        fprintf_plus(stderr, "Network hook directory \"%s\" not"
1523
 
                     " found\n", hookdir);
1524
 
      }
1525
 
    } else {
1526
 
      perror_plus("scandir");
 
1929
    perror_plus("scandir");
 
1930
    return;
 
1931
  }
 
1932
  struct dirent *direntry;
 
1933
  int ret;
 
1934
  int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
 
1935
  if(devnull == -1){
 
1936
    perror_plus("open(\"/dev/null\", O_RDONLY)");
 
1937
    return;
 
1938
  }
 
1939
  for(int i = 0; i < numhooks; i++){
 
1940
    direntry = direntries[i];
 
1941
    if(debug){
 
1942
      fprintf_plus(stderr, "Running network hook \"%s\"\n",
 
1943
                   direntry->d_name);
1527
1944
    }
1528
 
  } else {
1529
 
    struct dirent *direntry;
1530
 
    int ret;
1531
 
    int devnull = open("/dev/null", O_RDONLY);
1532
 
    for(int i = 0; i < numhooks; i++){
1533
 
      direntry = direntries[i];
1534
 
      char *fullname = NULL;
1535
 
      ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1536
 
      if(ret < 0){
 
1945
    pid_t hook_pid = fork();
 
1946
    if(hook_pid == 0){
 
1947
      /* Child */
 
1948
      /* Raise privileges */
 
1949
      errno = raise_privileges_permanently();
 
1950
      if(errno != 0){
 
1951
        perror_plus("Failed to raise privileges");
 
1952
        _exit(EX_NOPERM);
 
1953
      }
 
1954
      /* Set group */
 
1955
      errno = 0;
 
1956
      ret = setgid(0);
 
1957
      if(ret == -1){
 
1958
        perror_plus("setgid");
 
1959
        _exit(EX_NOPERM);
 
1960
      }
 
1961
      /* Reset supplementary groups */
 
1962
      errno = 0;
 
1963
      ret = setgroups(0, NULL);
 
1964
      if(ret == -1){
 
1965
        perror_plus("setgroups");
 
1966
        _exit(EX_NOPERM);
 
1967
      }
 
1968
      ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
 
1969
      if(ret == -1){
 
1970
        perror_plus("setenv");
 
1971
        _exit(EX_OSERR);
 
1972
      }
 
1973
      ret = setenv("DEVICE", interface, 1);
 
1974
      if(ret == -1){
 
1975
        perror_plus("setenv");
 
1976
        _exit(EX_OSERR);
 
1977
      }
 
1978
      ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
 
1979
      if(ret == -1){
 
1980
        perror_plus("setenv");
 
1981
        _exit(EX_OSERR);
 
1982
      }
 
1983
      ret = setenv("MODE", mode, 1);
 
1984
      if(ret == -1){
 
1985
        perror_plus("setenv");
 
1986
        _exit(EX_OSERR);
 
1987
      }
 
1988
      char *delaystring;
 
1989
      ret = asprintf(&delaystring, "%f", (double)delay);
 
1990
      if(ret == -1){
1537
1991
        perror_plus("asprintf");
1538
 
        continue;
1539
 
      }
1540
 
      if(debug){
1541
 
        fprintf_plus(stderr, "Running network hook \"%s\"\n",
1542
 
                     direntry->d_name);
1543
 
      }
1544
 
      pid_t hook_pid = fork();
1545
 
      if(hook_pid == 0){
1546
 
        /* Child */
1547
 
        /* Raise privileges */
1548
 
        if(raise_privileges_permanently() != 0){
1549
 
          perror_plus("Failed to raise privileges");
1550
 
          _exit(EX_NOPERM);
1551
 
        }
1552
 
        /* Set group */
1553
 
        errno = 0;
1554
 
        ret = setgid(0);
1555
 
        if(ret == -1){
1556
 
          perror_plus("setgid");
1557
 
          _exit(EX_NOPERM);
1558
 
        }
1559
 
        /* Reset supplementary groups */
1560
 
        errno = 0;
1561
 
        ret = setgroups(0, NULL);
1562
 
        if(ret == -1){
1563
 
          perror_plus("setgroups");
1564
 
          _exit(EX_NOPERM);
1565
 
        }
1566
 
        ret = dup2(devnull, STDIN_FILENO);
1567
 
        if(ret == -1){
1568
 
          perror_plus("dup2(devnull, STDIN_FILENO)");
1569
 
          _exit(EX_OSERR);
1570
 
        }
1571
 
        ret = close(devnull);
1572
 
        if(ret == -1){
1573
 
          perror_plus("close");
1574
 
          _exit(EX_OSERR);
1575
 
        }
1576
 
        ret = dup2(STDERR_FILENO, STDOUT_FILENO);
1577
 
        if(ret == -1){
1578
 
          perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
1579
 
          _exit(EX_OSERR);
1580
 
        }
1581
 
        ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1582
 
        if(ret == -1){
1583
 
          perror_plus("setenv");
1584
 
          _exit(EX_OSERR);
1585
 
        }
1586
 
        ret = setenv("DEVICE", interface, 1);
1587
 
        if(ret == -1){
1588
 
          perror_plus("setenv");
1589
 
          _exit(EX_OSERR);
1590
 
        }
1591
 
        ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
1592
 
        if(ret == -1){
1593
 
          perror_plus("setenv");
1594
 
          _exit(EX_OSERR);
1595
 
        }
1596
 
        ret = setenv("MODE", mode, 1);
1597
 
        if(ret == -1){
1598
 
          perror_plus("setenv");
1599
 
          _exit(EX_OSERR);
1600
 
        }
1601
 
        char *delaystring;
1602
 
        ret = asprintf(&delaystring, "%f", (double)delay);
1603
 
        if(ret == -1){
1604
 
          perror_plus("asprintf");
1605
 
          _exit(EX_OSERR);
1606
 
        }
1607
 
        ret = setenv("DELAY", delaystring, 1);
1608
 
        if(ret == -1){
1609
 
          free(delaystring);
1610
 
          perror_plus("setenv");
1611
 
          _exit(EX_OSERR);
1612
 
        }
 
1992
        _exit(EX_OSERR);
 
1993
      }
 
1994
      ret = setenv("DELAY", delaystring, 1);
 
1995
      if(ret == -1){
1613
1996
        free(delaystring);
1614
 
        if(connect_to != NULL){
1615
 
          ret = setenv("CONNECT", connect_to, 1);
1616
 
          if(ret == -1){
1617
 
            perror_plus("setenv");
1618
 
            _exit(EX_OSERR);
1619
 
          }
1620
 
        }
1621
 
        if(execl(fullname, direntry->d_name, mode, NULL) == -1){
1622
 
          perror_plus("execl");
1623
 
          _exit(EXIT_FAILURE);
1624
 
        }
 
1997
        perror_plus("setenv");
 
1998
        _exit(EX_OSERR);
 
1999
      }
 
2000
      free(delaystring);
 
2001
      if(connect_to != NULL){
 
2002
        ret = setenv("CONNECT", connect_to, 1);
 
2003
        if(ret == -1){
 
2004
          perror_plus("setenv");
 
2005
          _exit(EX_OSERR);
 
2006
        }
 
2007
      }
 
2008
      int hook_fd = (int)TEMP_FAILURE_RETRY(openat(hookdir_fd,
 
2009
                                                   direntry->d_name,
 
2010
                                                   O_RDONLY));
 
2011
      if(hook_fd == -1){
 
2012
        perror_plus("openat");
 
2013
        _exit(EXIT_FAILURE);
 
2014
      }
 
2015
      if(close(hookdir_fd) == -1){
 
2016
        perror_plus("close");
 
2017
        _exit(EXIT_FAILURE);
 
2018
      }
 
2019
      ret = dup2(devnull, STDIN_FILENO);
 
2020
      if(ret == -1){
 
2021
        perror_plus("dup2(devnull, STDIN_FILENO)");
 
2022
        _exit(EX_OSERR);
 
2023
      }
 
2024
      ret = close(devnull);
 
2025
      if(ret == -1){
 
2026
        perror_plus("close");
 
2027
        _exit(EX_OSERR);
 
2028
      }
 
2029
      ret = dup2(STDERR_FILENO, STDOUT_FILENO);
 
2030
      if(ret == -1){
 
2031
        perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
 
2032
        _exit(EX_OSERR);
 
2033
      }
 
2034
      if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
 
2035
                 environ) == -1){
 
2036
        perror_plus("fexecve");
 
2037
        _exit(EXIT_FAILURE);
 
2038
      }
 
2039
    } else {
 
2040
      if(hook_pid == -1){
 
2041
        perror_plus("fork");
 
2042
        free(direntry);
 
2043
        continue;
 
2044
      }
 
2045
      int status;
 
2046
      if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
 
2047
        perror_plus("waitpid");
 
2048
        free(direntry);
 
2049
        continue;
 
2050
      }
 
2051
      if(WIFEXITED(status)){
 
2052
        if(WEXITSTATUS(status) != 0){
 
2053
          fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
 
2054
                       " with status %d\n", direntry->d_name,
 
2055
                       WEXITSTATUS(status));
 
2056
          free(direntry);
 
2057
          continue;
 
2058
        }
 
2059
      } else if(WIFSIGNALED(status)){
 
2060
        fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
 
2061
                     " signal %d\n", direntry->d_name,
 
2062
                     WTERMSIG(status));
 
2063
        free(direntry);
 
2064
        continue;
1625
2065
      } else {
1626
 
        int status;
1627
 
        if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1628
 
          perror_plus("waitpid");
1629
 
          free(fullname);
1630
 
          continue;
1631
 
        }
1632
 
        if(WIFEXITED(status)){
1633
 
          if(WEXITSTATUS(status) != 0){
1634
 
            fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1635
 
                         " with status %d\n", direntry->d_name,
1636
 
                         WEXITSTATUS(status));
1637
 
            free(fullname);
1638
 
            continue;
1639
 
          }
1640
 
        } else if(WIFSIGNALED(status)){
1641
 
          fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1642
 
                       " signal %d\n", direntry->d_name,
1643
 
                       WTERMSIG(status));
1644
 
          free(fullname);
1645
 
          continue;
1646
 
        } else {
1647
 
          fprintf_plus(stderr, "Warning: network hook \"%s\""
1648
 
                       " crashed\n", direntry->d_name);
1649
 
          free(fullname);
1650
 
          continue;
1651
 
        }
1652
 
      }
1653
 
      free(fullname);
1654
 
      if(debug){
1655
 
        fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1656
 
                     direntry->d_name);
1657
 
      }
1658
 
    }
1659
 
    close(devnull);
1660
 
  }
 
2066
        fprintf_plus(stderr, "Warning: network hook \"%s\""
 
2067
                     " crashed\n", direntry->d_name);
 
2068
        free(direntry);
 
2069
        continue;
 
2070
      }
 
2071
    }
 
2072
    if(debug){
 
2073
      fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
 
2074
                   direntry->d_name);
 
2075
    }
 
2076
    free(direntry);
 
2077
  }
 
2078
  free(direntries);
 
2079
  if(close(hookdir_fd) == -1){
 
2080
    perror_plus("close");
 
2081
  } else {
 
2082
    hookdir_fd = -1;
 
2083
  }
 
2084
  close(devnull);
1661
2085
}
1662
2086
 
1663
2087
__attribute__((nonnull, warn_unused_result))
1698
2122
    }
1699
2123
    
1700
2124
    if(quit_now){
1701
 
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
2125
      ret = close(sd);
1702
2126
      if(ret == -1){
1703
2127
        perror_plus("close");
1704
2128
      }
1713
2137
    
1714
2138
    /* Raise privileges */
1715
2139
    ret_errno = raise_privileges();
 
2140
    if(ret_errno != 0){
 
2141
      errno = ret_errno;
 
2142
      perror_plus("Failed to raise privileges");
 
2143
    }
 
2144
    
 
2145
#ifdef __linux__
 
2146
    int ret_linux;
1716
2147
    bool restore_loglevel = false;
1717
 
    if(ret_errno != 0){
1718
 
      perror_plus("Failed to raise privileges");
1719
 
    }
1720
 
#ifdef __linux__
1721
 
    int ret_linux;
1722
2148
    if(ret_errno == 0){
1723
2149
      /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1724
2150
         messages about the network interface to mess up the prompt */
1752
2178
    }
1753
2179
    
1754
2180
    /* Close the socket */
1755
 
    ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
2181
    ret = close(sd);
1756
2182
    if(ret == -1){
1757
2183
      perror_plus("close");
1758
2184
    }
1822
2248
    /* Raise privileges */
1823
2249
    ret_errno = raise_privileges();
1824
2250
    if(ret_errno != 0){
 
2251
      errno = ret_errno;
1825
2252
      perror_plus("Failed to raise privileges");
1826
2253
    }
 
2254
    
1827
2255
    int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1828
2256
    ioctl_errno = errno;
1829
2257
    
1838
2266
    }
1839
2267
    
1840
2268
    /* Close the socket */
1841
 
    int ret = (int)TEMP_FAILURE_RETRY(close(sd));
 
2269
    int ret = close(sd);
1842
2270
    if(ret == -1){
1843
2271
      perror_plus("close");
1844
2272
    }
1859
2287
}
1860
2288
 
1861
2289
int main(int argc, char *argv[]){
1862
 
  mandos_context mc = { .server = NULL, .dh_bits = 1024,
1863
 
                        .priority = "SECURE256:!CTYPE-X.509:"
1864
 
                        "+CTYPE-OPENPGP", .current_server = NULL,
1865
 
                        .interfaces = NULL, .interfaces_size = 0 };
 
2290
  mandos_context mc = { .server = NULL, .dh_bits = 0,
 
2291
                        .priority = "SECURE256:!CTYPE-X.509"
 
2292
                        ":+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256",
 
2293
                        .current_server = NULL, .interfaces = NULL,
 
2294
                        .interfaces_size = 0 };
1866
2295
  AvahiSServiceBrowser *sb = NULL;
1867
2296
  error_t ret_errno;
1868
2297
  int ret;
1871
2300
  int exitcode = EXIT_SUCCESS;
1872
2301
  char *interfaces_to_take_down = NULL;
1873
2302
  size_t interfaces_to_take_down_size = 0;
1874
 
  char tempdir[] = "/tmp/mandosXXXXXX";
1875
 
  bool tempdir_created = false;
 
2303
  char run_tempdir[] = "/run/tmp/mandosXXXXXX";
 
2304
  char old_tempdir[] = "/tmp/mandosXXXXXX";
 
2305
  char *tempdir = NULL;
1876
2306
  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1877
2307
  const char *seckey = PATHDIR "/" SECKEY;
1878
2308
  const char *pubkey = PATHDIR "/" PUBKEY;
 
2309
  const char *dh_params_file = NULL;
1879
2310
  char *interfaces_hooks = NULL;
1880
2311
  
1881
2312
  bool gnutls_initialized = false;
1934
2365
        .doc = "Bit length of the prime number used in the"
1935
2366
        " Diffie-Hellman key exchange",
1936
2367
        .group = 2 },
 
2368
      { .name = "dh-params", .key = 134,
 
2369
        .arg = "FILE",
 
2370
        .doc = "PEM-encoded PKCS#3 file with pre-generated parameters"
 
2371
        " for the Diffie-Hellman key exchange",
 
2372
        .group = 2 },
1937
2373
      { .name = "priority", .key = 130,
1938
2374
        .arg = "STRING",
1939
2375
        .doc = "GnuTLS priority string for the TLS handshake",
1994
2430
        }
1995
2431
        mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
1996
2432
        break;
 
2433
      case 134:                 /* --dh-params */
 
2434
        dh_params_file = arg;
 
2435
        break;
1997
2436
      case 130:                 /* --priority */
1998
2437
        mc.priority = arg;
1999
2438
        break;
2055
2494
      goto end;
2056
2495
    }
2057
2496
  }
2058
 
    
 
2497
  
2059
2498
  {
2060
2499
    /* Work around Debian bug #633582:
2061
2500
       <http://bugs.debian.org/633582> */
2085
2524
              }
2086
2525
            }
2087
2526
          }
2088
 
          TEMP_FAILURE_RETRY(close(seckey_fd));
 
2527
          close(seckey_fd);
2089
2528
        }
2090
2529
      }
2091
 
    
 
2530
      
2092
2531
      if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2093
2532
        int pubkey_fd = open(pubkey, O_RDONLY);
2094
2533
        if(pubkey_fd == -1){
2106
2545
              }
2107
2546
            }
2108
2547
          }
2109
 
          TEMP_FAILURE_RETRY(close(pubkey_fd));
2110
 
        }
2111
 
      }
2112
 
    
 
2548
          close(pubkey_fd);
 
2549
        }
 
2550
      }
 
2551
      
 
2552
      if(dh_params_file != NULL
 
2553
         and strcmp(dh_params_file, PATHDIR "/dhparams.pem" ) == 0){
 
2554
        int dhparams_fd = open(dh_params_file, O_RDONLY);
 
2555
        if(dhparams_fd == -1){
 
2556
          perror_plus("open");
 
2557
        } else {
 
2558
          ret = (int)TEMP_FAILURE_RETRY(fstat(dhparams_fd, &st));
 
2559
          if(ret == -1){
 
2560
            perror_plus("fstat");
 
2561
          } else {
 
2562
            if(S_ISREG(st.st_mode)
 
2563
               and st.st_uid == 0 and st.st_gid == 0){
 
2564
              ret = fchown(dhparams_fd, uid, gid);
 
2565
              if(ret == -1){
 
2566
                perror_plus("fchown");
 
2567
              }
 
2568
            }
 
2569
          }
 
2570
          close(dhparams_fd);
 
2571
        }
 
2572
      }
 
2573
      
2113
2574
      /* Lower privileges */
2114
2575
      ret_errno = lower_privileges();
2115
2576
      if(ret_errno != 0){
2232
2693
  
2233
2694
  /* If no interfaces were specified, make a list */
2234
2695
  if(mc.interfaces == NULL){
2235
 
    struct dirent **direntries;
 
2696
    struct dirent **direntries = NULL;
2236
2697
    /* Look for any good interfaces */
2237
2698
    ret = scandir(sys_class_net, &direntries, good_interface,
2238
2699
                  alphasort);
2244
2705
        if(ret_errno != 0){
2245
2706
          errno = ret_errno;
2246
2707
          perror_plus("argz_add");
 
2708
          free(direntries[i]);
2247
2709
          continue;
2248
2710
        }
2249
2711
        if(debug){
2250
2712
          fprintf_plus(stderr, "Will use interface \"%s\"\n",
2251
2713
                       direntries[i]->d_name);
2252
2714
        }
 
2715
        free(direntries[i]);
2253
2716
      }
2254
2717
      free(direntries);
2255
2718
    } else {
2256
 
      free(direntries);
 
2719
      if(ret == 0){
 
2720
        free(direntries);
 
2721
      }
2257
2722
      fprintf_plus(stderr, "Could not find a network interface\n");
2258
2723
      exitcode = EXIT_FAILURE;
2259
2724
      goto end;
2285
2750
      errno = bring_up_interface(interface, delay);
2286
2751
      if(not interface_was_up){
2287
2752
        if(errno != 0){
2288
 
          perror_plus("Failed to bring up interface");
 
2753
          fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
 
2754
                       " %s\n", interface, strerror(errno));
2289
2755
        } else {
2290
2756
          errno = argz_add(&interfaces_to_take_down,
2291
2757
                           &interfaces_to_take_down_size,
2314
2780
    goto end;
2315
2781
  }
2316
2782
  
2317
 
  ret = init_gnutls_global(pubkey, seckey, &mc);
 
2783
  ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
2318
2784
  if(ret == -1){
2319
2785
    fprintf_plus(stderr, "init_gnutls_global failed\n");
2320
2786
    exitcode = EX_UNAVAILABLE;
2327
2793
    goto end;
2328
2794
  }
2329
2795
  
2330
 
  if(mkdtemp(tempdir) == NULL){
 
2796
  /* Try /run/tmp before /tmp */
 
2797
  tempdir = mkdtemp(run_tempdir);
 
2798
  if(tempdir == NULL and errno == ENOENT){
 
2799
      if(debug){
 
2800
        fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
 
2801
                     run_tempdir, old_tempdir);
 
2802
      }
 
2803
      tempdir = mkdtemp(old_tempdir);
 
2804
  }
 
2805
  if(tempdir == NULL){
2331
2806
    perror_plus("mkdtemp");
2332
2807
    goto end;
2333
2808
  }
2334
 
  tempdir_created = true;
2335
2809
  
2336
2810
  if(quit_now){
2337
2811
    goto end;
2473
2947
  if(debug){
2474
2948
    fprintf_plus(stderr, "Starting Avahi loop search\n");
2475
2949
  }
2476
 
 
 
2950
  
2477
2951
  ret = avahi_loop_with_timeout(simple_poll,
2478
2952
                                (int)(retry_interval * 1000), &mc);
2479
2953
  if(debug){
2515
2989
    mc.current_server->prev->next = NULL;
2516
2990
    while(mc.current_server != NULL){
2517
2991
      server *next = mc.current_server->next;
 
2992
#ifdef __GNUC__
 
2993
#pragma GCC diagnostic push
 
2994
#pragma GCC diagnostic ignored "-Wcast-qual"
 
2995
#endif
 
2996
      free((char *)(mc.current_server->ip));
 
2997
#ifdef __GNUC__
 
2998
#pragma GCC diagnostic pop
 
2999
#endif
2518
3000
      free(mc.current_server);
2519
3001
      mc.current_server = next;
2520
3002
    }
2524
3006
  {
2525
3007
    ret_errno = raise_privileges();
2526
3008
    if(ret_errno != 0){
 
3009
      errno = ret_errno;
2527
3010
      perror_plus("Failed to raise privileges");
2528
3011
    } else {
2529
3012
      
2549
3032
        }
2550
3033
      }
2551
3034
    }
 
3035
    
2552
3036
    ret_errno = lower_privileges_permanently();
2553
3037
    if(ret_errno != 0){
 
3038
      errno = ret_errno;
2554
3039
      perror_plus("Failed to lower privileges permanently");
2555
3040
    }
2556
3041
  }
2559
3044
  free(interfaces_hooks);
2560
3045
  
2561
3046
  /* Removes the GPGME temp directory and all files inside */
2562
 
  if(tempdir_created){
 
3047
  if(tempdir != NULL){
2563
3048
    struct dirent **direntries = NULL;
2564
 
    struct dirent *direntry = NULL;
2565
 
    int numentries = scandir(tempdir, &direntries, notdotentries,
2566
 
                             alphasort);
2567
 
    if(numentries > 0){
2568
 
      for(int i = 0; i < numentries; i++){
2569
 
        direntry = direntries[i];
2570
 
        char *fullname = NULL;
2571
 
        ret = asprintf(&fullname, "%s/%s", tempdir,
2572
 
                       direntry->d_name);
2573
 
        if(ret < 0){
2574
 
          perror_plus("asprintf");
2575
 
          continue;
2576
 
        }
2577
 
        ret = remove(fullname);
2578
 
        if(ret == -1){
2579
 
          fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2580
 
                       strerror(errno));
2581
 
        }
2582
 
        free(fullname);
 
3049
    int tempdir_fd = (int)TEMP_FAILURE_RETRY(open(tempdir, O_RDONLY
 
3050
                                                  | O_NOFOLLOW
 
3051
                                                  | O_DIRECTORY
 
3052
                                                  | O_PATH));
 
3053
    if(tempdir_fd == -1){
 
3054
      perror_plus("open");
 
3055
    } else {
 
3056
#ifdef __GLIBC__
 
3057
#if __GLIBC_PREREQ(2, 15)
 
3058
      int numentries = scandirat(tempdir_fd, ".", &direntries,
 
3059
                                 notdotentries, alphasort);
 
3060
#else  /* not __GLIBC_PREREQ(2, 15) */
 
3061
      int numentries = scandir(tempdir, &direntries, notdotentries,
 
3062
                               alphasort);
 
3063
#endif  /* not __GLIBC_PREREQ(2, 15) */
 
3064
#else   /* not __GLIBC__ */
 
3065
      int numentries = scandir(tempdir, &direntries, notdotentries,
 
3066
                               alphasort);
 
3067
#endif  /* not __GLIBC__ */
 
3068
      if(numentries >= 0){
 
3069
        for(int i = 0; i < numentries; i++){
 
3070
          ret = unlinkat(tempdir_fd, direntries[i]->d_name, 0);
 
3071
          if(ret == -1){
 
3072
            fprintf_plus(stderr, "unlinkat(open(\"%s\", O_RDONLY),"
 
3073
                         " \"%s\", 0): %s\n", tempdir,
 
3074
                         direntries[i]->d_name, strerror(errno));
 
3075
          }
 
3076
          free(direntries[i]);
 
3077
        }
 
3078
        
 
3079
        /* need to clean even if 0 because man page doesn't specify */
 
3080
        free(direntries);
 
3081
        if(numentries == -1){
 
3082
          perror_plus("scandir");
 
3083
        }
 
3084
        ret = rmdir(tempdir);
 
3085
        if(ret == -1 and errno != ENOENT){
 
3086
          perror_plus("rmdir");
 
3087
        }
2583
3088
      }
2584
 
    }
2585
 
 
2586
 
    /* need to clean even if 0 because man page doesn't specify */
2587
 
    free(direntries);
2588
 
    if(numentries == -1){
2589
 
      perror_plus("scandir");
2590
 
    }
2591
 
    ret = rmdir(tempdir);
2592
 
    if(ret == -1 and errno != ENOENT){
2593
 
      perror_plus("rmdir");
 
3089
      close(tempdir_fd);
2594
3090
    }
2595
3091
  }
2596
3092