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
- browse files at revision 723.1.1
- compare with another revision
- download diff
- download tarball
- view history from revision 723.1.1
- Committer: Teddy Hogeborn
- Date: 2014-07-25 22:44:20 UTC
- mto: This revision was merged to the branch mainline in revision 724.
- Revision ID: teddy@recompile.se-20140725224420-4a5ct2ptt0hsc92z
Require Python 2.7.
This is in preparation for the eventual move to Python 3, which will
happen as soon as all Python modules required by Mandos are available.
The mandos-ctl and mandos-monitor programs are already portable
between Python 2.6 and Python 3 without changes; this change will
bring the requirement up to Python 2.7.
* INSTALL (Prerequisites/Libraries/Mandos Server): Document
requirement of
Python 2.7; remove
Python-argparse
which is in the
Python 2.7 standard
library.
* debian/control (Source: mandos/Build-Depends-Indep): Depend on
exactly the
python2.7
package and all
the Python 2.7
versions of the
python modules.
(Package: mandos/Depends): - '' - but still depend on python (<=2.7)
and the generic versions of the Python
modules; this is for mandos-ctl and
mandos-monitor, both of which are
compatible with Python 3, and use
#!/usr/bin/python.
* mandos: Use #!/usr/bin/python2.7 instead of #!/usr/bin/python.
This is in preparation for the eventual move to Python 3, which will
happen as soon as all Python modules required by Mandos are available.
The mandos-ctl and mandos-monitor programs are already portable
between Python 2.6 and Python 3 without changes; this change will
bring the requirement up to Python 2.7.
* INSTALL (Prerequisites/Libraries/Mandos Server): Document
requirement of
Python 2.7; remove
Python-argparse
which is in the
Python 2.7 standard
library.
* debian/control (Source: mandos/Build-Depends-Indep): Depend on
exactly the
python2.7
package and all
the Python 2.7
versions of the
python modules.
(Package: mandos/Depends): - '' - but still depend on python (<=2.7)
and the generic versions of the Python
modules; this is for mandos-ctl and
mandos-monitor, both of which are
compatible with Python 3, and use
#!/usr/bin/python.
* mandos: Use #!/usr/bin/python2.7 instead of #!/usr/bin/python.
added
removed
plugins.d/mandos-client.c
9
9
* "browse_callback", and parts of "main".
10
10
*
11
11
* Everything else is
12
* Copyright © 2008-2016 Teddy Hogeborn
13
* Copyright © 2008-2016 Björn Påhlsson
12
* Copyright © 2008-2014 Teddy Hogeborn
13
* Copyright © 2008-2014 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
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> /* strcmp(), strlen(), strerror(),
50
asprintf(), strncpy() */
49
#include <string.h> /* memset(), strcmp(), strlen(),
50
strerror(), 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(), unlinkat(), AT_REMOVEDIR */
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,
64
64
strtoimax() */
65
#include <errno.h> /* perror(), errno, EINTR, EINVAL,
66
EAI_SYSTEM, ENETUNREACH,
67
EHOSTUNREACH, ECONNREFUSED, EPROTO,
68
EIO, ENOENT, ENXIO, ENOMEM, EISDIR,
69
ENOTEMPTY,
65
#include <errno.h> /* perror(), errno,
70
66
program_invocation_short_name */
71
67
#include <time.h> /* nanosleep(), time(), sleep() */
72
68
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
309
305
return false;
310
306
}
311
307
312
ret = close(fd);
308
ret = (int)TEMP_FAILURE_RETRY(close(fd));
313
309
if(ret == -1){
314
310
perror_plus("close");
315
311
}
497
493
return plaintext_length;
498
494
}
499
495
500
__attribute__((warn_unused_result, const))
501
static const char *safe_string(const char *str){
502
if(str == NULL)
503
return "(unknown)";
504
return str;
505
}
506
507
496
__attribute__((warn_unused_result))
508
497
static const char *safer_gnutls_strerror(int value){
509
498
const char *ret = gnutls_strerror(value);
510
return safe_string(ret);
499
if(ret == NULL)
500
ret = "(unknown)";
501
return ret;
511
502
}
512
503
513
504
/* GnuTLS log function callback */
517
508
fprintf_plus(stderr, "GnuTLS: %s", string);
518
509
}
519
510
520
__attribute__((nonnull(1, 2, 4), warn_unused_result))
511
__attribute__((nonnull, warn_unused_result))
521
512
static int init_gnutls_global(const char *pubkeyfilename,
522
513
const char *seckeyfilename,
523
const char *dhparamsfilename,
524
514
mandos_context *mc){
525
515
int ret;
526
unsigned int uret;
527
516
528
517
if(debug){
529
518
fprintf_plus(stderr, "Initializing GnuTLS\n");
530
519
}
531
520
521
ret = gnutls_global_init();
522
if(ret != GNUTLS_E_SUCCESS){
523
fprintf_plus(stderr, "GnuTLS global_init: %s\n",
524
safer_gnutls_strerror(ret));
525
return -1;
526
}
527
532
528
if(debug){
533
529
/* "Use a log level over 10 to enable all debugging options."
534
530
* - GnuTLS manual
542
538
if(ret != GNUTLS_E_SUCCESS){
543
539
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
544
540
safer_gnutls_strerror(ret));
541
gnutls_global_deinit();
545
542
return -1;
546
543
}
547
544
572
569
safer_gnutls_strerror(ret));
573
570
goto globalfail;
574
571
}
575
/* If a Diffie-Hellman parameters file was given, try to use it */
576
if(dhparamsfilename != NULL){
577
gnutls_datum_t params = { .data = NULL, .size = 0 };
578
do {
579
int dhpfile = open(dhparamsfilename, O_RDONLY);
580
if(dhpfile == -1){
581
perror_plus("open");
582
dhparamsfilename = NULL;
583
break;
584
}
585
size_t params_capacity = 0;
586
while(true){
587
params_capacity = incbuffer((char **)¶ms.data,
588
(size_t)params.size,
589
(size_t)params_capacity);
590
if(params_capacity == 0){
591
perror_plus("incbuffer");
592
free(params.data);
593
params.data = NULL;
594
dhparamsfilename = NULL;
595
break;
596
}
597
ssize_t bytes_read = read(dhpfile,
598
params.data + params.size,
599
BUFFER_SIZE);
600
/* EOF */
601
if(bytes_read == 0){
602
break;
603
}
604
/* check bytes_read for failure */
605
if(bytes_read < 0){
606
perror_plus("read");
607
free(params.data);
608
params.data = NULL;
609
dhparamsfilename = NULL;
610
break;
611
}
612
params.size += (unsigned int)bytes_read;
613
}
614
if(params.data == NULL){
615
dhparamsfilename = NULL;
616
}
617
if(dhparamsfilename == NULL){
618
break;
619
}
620
ret = gnutls_dh_params_import_pkcs3(mc->dh_params, ¶ms,
621
GNUTLS_X509_FMT_PEM);
622
if(ret != GNUTLS_E_SUCCESS){
623
fprintf_plus(stderr, "Failed to parse DH parameters in file"
624
" \"%s\": %s\n", dhparamsfilename,
625
safer_gnutls_strerror(ret));
626
dhparamsfilename = NULL;
627
}
628
} while(false);
629
}
630
if(dhparamsfilename == NULL){
631
if(mc->dh_bits == 0){
632
/* Find out the optimal number of DH bits */
633
/* Try to read the private key file */
634
gnutls_datum_t buffer = { .data = NULL, .size = 0 };
635
do {
636
int secfile = open(seckeyfilename, O_RDONLY);
637
if(secfile == -1){
638
perror_plus("open");
639
break;
640
}
641
size_t buffer_capacity = 0;
642
while(true){
643
buffer_capacity = incbuffer((char **)&buffer.data,
644
(size_t)buffer.size,
645
(size_t)buffer_capacity);
646
if(buffer_capacity == 0){
647
perror_plus("incbuffer");
648
free(buffer.data);
649
buffer.data = NULL;
650
break;
651
}
652
ssize_t bytes_read = read(secfile,
653
buffer.data + buffer.size,
654
BUFFER_SIZE);
655
/* EOF */
656
if(bytes_read == 0){
657
break;
658
}
659
/* check bytes_read for failure */
660
if(bytes_read < 0){
661
perror_plus("read");
662
free(buffer.data);
663
buffer.data = NULL;
664
break;
665
}
666
buffer.size += (unsigned int)bytes_read;
667
}
668
close(secfile);
669
} while(false);
670
/* If successful, use buffer to parse private key */
671
gnutls_sec_param_t sec_param = GNUTLS_SEC_PARAM_ULTRA;
672
if(buffer.data != NULL){
673
{
674
gnutls_openpgp_privkey_t privkey = NULL;
675
ret = gnutls_openpgp_privkey_init(&privkey);
676
if(ret != GNUTLS_E_SUCCESS){
677
fprintf_plus(stderr, "Error initializing OpenPGP key"
678
" structure: %s",
679
safer_gnutls_strerror(ret));
680
free(buffer.data);
681
buffer.data = NULL;
682
} else {
683
ret = gnutls_openpgp_privkey_import
684
(privkey, &buffer, GNUTLS_OPENPGP_FMT_BASE64, "", 0);
685
if(ret != GNUTLS_E_SUCCESS){
686
fprintf_plus(stderr, "Error importing OpenPGP key : %s",
687
safer_gnutls_strerror(ret));
688
privkey = NULL;
689
}
690
free(buffer.data);
691
buffer.data = NULL;
692
if(privkey != NULL){
693
/* Use private key to suggest an appropriate
694
sec_param */
695
sec_param = gnutls_openpgp_privkey_sec_param(privkey);
696
gnutls_openpgp_privkey_deinit(privkey);
697
if(debug){
698
fprintf_plus(stderr, "This OpenPGP key implies using"
699
" a GnuTLS security parameter \"%s\".\n",
700
safe_string(gnutls_sec_param_get_name
701
(sec_param)));
702
}
703
}
704
}
705
}
706
if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
707
/* Err on the side of caution */
708
sec_param = GNUTLS_SEC_PARAM_ULTRA;
709
if(debug){
710
fprintf_plus(stderr, "Falling back to security parameter"
711
" \"%s\"\n",
712
safe_string(gnutls_sec_param_get_name
713
(sec_param)));
714
}
715
}
716
}
717
uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
718
if(uret != 0){
719
mc->dh_bits = uret;
720
if(debug){
721
fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
722
" implies %u DH bits; using that.\n",
723
safe_string(gnutls_sec_param_get_name
724
(sec_param)),
725
mc->dh_bits);
726
}
727
} else {
728
fprintf_plus(stderr, "Failed to get implied number of DH"
729
" bits for security parameter \"%s\"): %s\n",
730
safe_string(gnutls_sec_param_get_name
731
(sec_param)),
732
safer_gnutls_strerror(ret));
733
goto globalfail;
734
}
735
} else if(debug){
736
fprintf_plus(stderr, "DH bits explicitly set to %u\n",
737
mc->dh_bits);
738
}
739
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
740
if(ret != GNUTLS_E_SUCCESS){
741
fprintf_plus(stderr, "Error in GnuTLS prime generation (%u"
742
" bits): %s\n", mc->dh_bits,
743
safer_gnutls_strerror(ret));
744
goto globalfail;
745
}
746
}
572
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
573
if(ret != GNUTLS_E_SUCCESS){
574
fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
575
safer_gnutls_strerror(ret));
576
goto globalfail;
577
}
578
747
579
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
748
580
749
581
return 0;
751
583
globalfail:
752
584
753
585
gnutls_certificate_free_credentials(mc->cred);
586
gnutls_global_deinit();
754
587
gnutls_dh_params_deinit(mc->dh_params);
755
588
return -1;
756
589
}
808
641
/* ignore client certificate if any. */
809
642
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
810
643
644
gnutls_dh_set_prime_bits(*session, mc->dh_bits);
645
811
646
return 0;
812
647
}
813
648
815
650
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
816
651
__attribute__((unused)) const char *txt){}
817
652
818
/* Set effective uid to 0, return errno */
819
__attribute__((warn_unused_result))
820
int raise_privileges(void){
821
int old_errno = errno;
822
int ret = 0;
823
if(seteuid(0) == -1){
824
ret = errno;
825
}
826
errno = old_errno;
827
return ret;
828
}
829
830
/* Set effective and real user ID to 0. Return errno. */
831
__attribute__((warn_unused_result))
832
int raise_privileges_permanently(void){
833
int old_errno = errno;
834
int ret = raise_privileges();
835
if(ret != 0){
836
errno = old_errno;
837
return ret;
838
}
839
if(setuid(0) == -1){
840
ret = errno;
841
}
842
errno = old_errno;
843
return ret;
844
}
845
846
/* Set effective user ID to unprivileged saved user ID */
847
__attribute__((warn_unused_result))
848
int lower_privileges(void){
849
int old_errno = errno;
850
int ret = 0;
851
if(seteuid(uid) == -1){
852
ret = errno;
853
}
854
errno = old_errno;
855
return ret;
856
}
857
858
/* Lower privileges permanently */
859
__attribute__((warn_unused_result))
860
int lower_privileges_permanently(void){
861
int old_errno = errno;
862
int ret = 0;
863
if(setuid(uid) == -1){
864
ret = errno;
865
}
866
errno = old_errno;
867
return ret;
868
}
869
870
/* Helper function to add_local_route() and delete_local_route() */
871
__attribute__((nonnull, warn_unused_result))
872
static bool add_delete_local_route(const bool add,
873
const char *address,
874
AvahiIfIndex if_index){
875
int ret;
876
char helper[] = "mandos-client-iprouteadddel";
877
char add_arg[] = "add";
878
char delete_arg[] = "delete";
879
char debug_flag[] = "--debug";
880
char *pluginhelperdir = getenv("MANDOSPLUGINHELPERDIR");
881
if(pluginhelperdir == NULL){
882
if(debug){
883
fprintf_plus(stderr, "MANDOSPLUGINHELPERDIR environment"
884
" variable not set; cannot run helper\n");
885
}
886
return false;
887
}
888
889
char interface[IF_NAMESIZE];
890
if(if_indextoname((unsigned int)if_index, interface) == NULL){
891
perror_plus("if_indextoname");
892
return false;
893
}
894
895
int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
896
if(devnull == -1){
897
perror_plus("open(\"/dev/null\", O_RDONLY)");
898
return false;
899
}
900
pid_t pid = fork();
901
if(pid == 0){
902
/* Child */
903
/* Raise privileges */
904
errno = raise_privileges_permanently();
905
if(errno != 0){
906
perror_plus("Failed to raise privileges");
907
/* _exit(EX_NOPERM); */
908
} else {
909
/* Set group */
910
errno = 0;
911
ret = setgid(0);
912
if(ret == -1){
913
perror_plus("setgid");
914
_exit(EX_NOPERM);
915
}
916
/* Reset supplementary groups */
917
errno = 0;
918
ret = setgroups(0, NULL);
919
if(ret == -1){
920
perror_plus("setgroups");
921
_exit(EX_NOPERM);
922
}
923
}
924
ret = dup2(devnull, STDIN_FILENO);
925
if(ret == -1){
926
perror_plus("dup2(devnull, STDIN_FILENO)");
927
_exit(EX_OSERR);
928
}
929
ret = close(devnull);
930
if(ret == -1){
931
perror_plus("close");
932
_exit(EX_OSERR);
933
}
934
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
935
if(ret == -1){
936
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
937
_exit(EX_OSERR);
938
}
939
int helperdir_fd = (int)TEMP_FAILURE_RETRY(open(pluginhelperdir,
940
O_RDONLY
941
| O_DIRECTORY
942
| O_PATH
943
| O_CLOEXEC));
944
if(helperdir_fd == -1){
945
perror_plus("open");
946
_exit(EX_UNAVAILABLE);
947
}
948
int helper_fd = (int)TEMP_FAILURE_RETRY(openat(helperdir_fd,
949
helper, O_RDONLY));
950
if(helper_fd == -1){
951
perror_plus("openat");
952
close(helperdir_fd);
953
_exit(EX_UNAVAILABLE);
954
}
955
close(helperdir_fd);
956
#ifdef __GNUC__
957
#pragma GCC diagnostic push
958
#pragma GCC diagnostic ignored "-Wcast-qual"
959
#endif
960
if(fexecve(helper_fd, (char *const [])
961
{ helper, add ? add_arg : delete_arg, (char *)address,
962
interface, debug ? debug_flag : NULL, NULL },
963
environ) == -1){
964
#ifdef __GNUC__
965
#pragma GCC diagnostic pop
966
#endif
967
perror_plus("fexecve");
968
_exit(EXIT_FAILURE);
969
}
970
}
971
if(pid == -1){
972
perror_plus("fork");
973
return false;
974
}
975
int status;
976
pid_t pret = -1;
977
errno = 0;
978
do {
979
pret = waitpid(pid, &status, 0);
980
if(pret == -1 and errno == EINTR and quit_now){
981
int errno_raising = 0;
982
if((errno = raise_privileges()) != 0){
983
errno_raising = errno;
984
perror_plus("Failed to raise privileges in order to"
985
" kill helper program");
986
}
987
if(kill(pid, SIGTERM) == -1){
988
perror_plus("kill");
989
}
990
if((errno_raising == 0) and (errno = lower_privileges()) != 0){
991
perror_plus("Failed to lower privileges after killing"
992
" helper program");
993
}
994
return false;
995
}
996
} while(pret == -1 and errno == EINTR);
997
if(pret == -1){
998
perror_plus("waitpid");
999
return false;
1000
}
1001
if(WIFEXITED(status)){
1002
if(WEXITSTATUS(status) != 0){
1003
fprintf_plus(stderr, "Error: iprouteadddel exited"
1004
" with status %d\n", WEXITSTATUS(status));
1005
return false;
1006
}
1007
return true;
1008
}
1009
if(WIFSIGNALED(status)){
1010
fprintf_plus(stderr, "Error: iprouteadddel died by"
1011
" signal %d\n", WTERMSIG(status));
1012
return false;
1013
}
1014
fprintf_plus(stderr, "Error: iprouteadddel crashed\n");
1015
return false;
1016
}
1017
1018
__attribute__((nonnull, warn_unused_result))
1019
static bool add_local_route(const char *address,
1020
AvahiIfIndex if_index){
1021
if(debug){
1022
fprintf_plus(stderr, "Adding route to %s\n", address);
1023
}
1024
return add_delete_local_route(true, address, if_index);
1025
}
1026
1027
__attribute__((nonnull, warn_unused_result))
1028
static bool delete_local_route(const char *address,
1029
AvahiIfIndex if_index){
1030
if(debug){
1031
fprintf_plus(stderr, "Removing route to %s\n", address);
1032
}
1033
return add_delete_local_route(false, address, if_index);
1034
}
1035
1036
653
/* Called when a Mandos server is found */
1037
654
__attribute__((nonnull, warn_unused_result))
1038
655
static int start_mandos_communication(const char *ip, in_port_t port,
1049
666
int retval = -1;
1050
667
gnutls_session_t session;
1051
668
int pf; /* Protocol family */
1052
bool route_added = false;
1053
669
1054
670
errno = 0;
1055
671
1113
729
PRIuMAX "\n", ip, (uintmax_t)port);
1114
730
}
1115
731
1116
tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
732
tcp_sd = socket(pf, SOCK_STREAM, 0);
1117
733
if(tcp_sd < 0){
1118
734
int e = errno;
1119
735
perror_plus("socket");
1126
742
goto mandos_end;
1127
743
}
1128
744
745
memset(&to, 0, sizeof(to));
1129
746
if(af == AF_INET6){
1130
struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)&to;
1131
*to6 = (struct sockaddr_in6){ .sin6_family = (sa_family_t)af };
1132
ret = inet_pton(af, ip, &to6->sin6_addr);
747
((struct sockaddr_in6 *)&to)->sin6_family = (sa_family_t)af;
748
ret = inet_pton(af, ip, &((struct sockaddr_in6 *)&to)->sin6_addr);
1133
749
} else { /* IPv4 */
1134
struct sockaddr_in *to4 = (struct sockaddr_in *)&to;
1135
*to4 = (struct sockaddr_in){ .sin_family = (sa_family_t)af };
1136
ret = inet_pton(af, ip, &to4->sin_addr);
750
((struct sockaddr_in *)&to)->sin_family = (sa_family_t)af;
751
ret = inet_pton(af, ip, &((struct sockaddr_in *)&to)->sin_addr);
1137
752
}
1138
753
if(ret < 0 ){
1139
754
int e = errno;
1209
824
goto mandos_end;
1210
825
}
1211
826
1212
while(true){
1213
if(af == AF_INET6){
1214
ret = connect(tcp_sd, (struct sockaddr *)&to,
1215
sizeof(struct sockaddr_in6));
1216
} else {
1217
ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
1218
sizeof(struct sockaddr_in));
1219
}
1220
if(ret < 0){
1221
if(((errno == ENETUNREACH) or (errno == EHOSTUNREACH))
1222
and if_index != AVAHI_IF_UNSPEC
1223
and connect_to == NULL
1224
and not route_added and
1225
((af == AF_INET6 and not
1226
IN6_IS_ADDR_LINKLOCAL(&(((struct sockaddr_in6 *)
1227
&to)->sin6_addr)))
1228
or (af == AF_INET and
1229
/* Not a a IPv4LL address */
1230
(ntohl(((struct sockaddr_in *)&to)->sin_addr.s_addr)
1231
& 0xFFFF0000L) != 0xA9FE0000L))){
1232
/* Work around Avahi bug - Avahi does not announce link-local
1233
addresses if it has a global address, so local hosts with
1234
*only* a link-local address (e.g. Mandos clients) cannot
1235
connect to a Mandos server announced by Avahi on a server
1236
host with a global address. Work around this by retrying
1237
with an explicit route added with the server's address.
1238
1239
Avahi bug reference:
1240
http://lists.freedesktop.org/archives/avahi/2010-February/001833.html
1241
https://bugs.debian.org/587961
1242
*/
1243
if(debug){
1244
fprintf_plus(stderr, "Mandos server unreachable, trying"
1245
" direct route\n");
1246
}
1247
int e = errno;
1248
route_added = add_local_route(ip, if_index);
1249
if(route_added){
1250
continue;
1251
}
1252
errno = e;
1253
}
1254
if(errno != ECONNREFUSED or debug){
1255
int e = errno;
1256
perror_plus("connect");
1257
errno = e;
1258
}
1259
goto mandos_end;
1260
}
1261
1262
if(quit_now){
1263
errno = EINTR;
1264
goto mandos_end;
1265
}
1266
break;
827
if(af == AF_INET6){
828
ret = connect(tcp_sd, (struct sockaddr *)&to,
829
sizeof(struct sockaddr_in6));
830
} else {
831
ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
832
sizeof(struct sockaddr_in));
833
}
834
if(ret < 0){
835
if((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
836
int e = errno;
837
perror_plus("connect");
838
errno = e;
839
}
840
goto mandos_end;
841
}
842
843
if(quit_now){
844
errno = EINTR;
845
goto mandos_end;
1267
846
}
1268
847
1269
848
const char *out = mandos_protocol_version;
1452
1031
1453
1032
mandos_end:
1454
1033
{
1455
if(route_added){
1456
if(not delete_local_route(ip, if_index)){
1457
fprintf_plus(stderr, "Failed to delete local route to %s on"
1458
" interface %d", ip, if_index);
1459
}
1460
}
1461
1034
int e = errno;
1462
1035
free(decrypted_buffer);
1463
1036
free(buffer);
1464
1037
if(tcp_sd >= 0){
1465
ret = close(tcp_sd);
1038
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
1466
1039
}
1467
1040
if(ret == -1){
1468
1041
if(e == 0){
1623
1196
__attribute__((nonnull, warn_unused_result))
1624
1197
bool get_flags(const char *ifname, struct ifreq *ifr){
1625
1198
int ret;
1626
int old_errno;
1199
error_t ret_errno;
1627
1200
1628
1201
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1629
1202
if(s < 0){
1630
old_errno = errno;
1203
ret_errno = errno;
1631
1204
perror_plus("socket");
1632
errno = old_errno;
1205
errno = ret_errno;
1633
1206
return false;
1634
1207
}
1635
strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
1636
ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
1208
strcpy(ifr->ifr_name, ifname);
1637
1209
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1638
1210
if(ret == -1){
1639
1211
if(debug){
1640
old_errno = errno;
1212
ret_errno = errno;
1641
1213
perror_plus("ioctl SIOCGIFFLAGS");
1642
errno = old_errno;
1214
errno = ret_errno;
1643
1215
}
1644
1216
return false;
1645
1217
}
1890
1462
}
1891
1463
}
1892
1464
1465
/* Set effective uid to 0, return errno */
1466
__attribute__((warn_unused_result))
1467
error_t raise_privileges(void){
1468
error_t old_errno = errno;
1469
error_t ret_errno = 0;
1470
if(seteuid(0) == -1){
1471
ret_errno = errno;
1472
}
1473
errno = old_errno;
1474
return ret_errno;
1475
}
1476
1477
/* Set effective and real user ID to 0. Return errno. */
1478
__attribute__((warn_unused_result))
1479
error_t raise_privileges_permanently(void){
1480
error_t old_errno = errno;
1481
error_t ret_errno = raise_privileges();
1482
if(ret_errno != 0){
1483
errno = old_errno;
1484
return ret_errno;
1485
}
1486
if(setuid(0) == -1){
1487
ret_errno = errno;
1488
}
1489
errno = old_errno;
1490
return ret_errno;
1491
}
1492
1493
/* Set effective user ID to unprivileged saved user ID */
1494
__attribute__((warn_unused_result))
1495
error_t lower_privileges(void){
1496
error_t old_errno = errno;
1497
error_t ret_errno = 0;
1498
if(seteuid(uid) == -1){
1499
ret_errno = errno;
1500
}
1501
errno = old_errno;
1502
return ret_errno;
1503
}
1504
1505
/* Lower privileges permanently */
1506
__attribute__((warn_unused_result))
1507
error_t lower_privileges_permanently(void){
1508
error_t old_errno = errno;
1509
error_t ret_errno = 0;
1510
if(setuid(uid) == -1){
1511
ret_errno = errno;
1512
}
1513
errno = old_errno;
1514
return ret_errno;
1515
}
1516
1893
1517
__attribute__((nonnull))
1894
1518
void run_network_hooks(const char *mode, const char *interface,
1895
1519
const float delay){
1896
1520
struct dirent **direntries = NULL;
1897
1521
if(hookdir_fd == -1){
1898
hookdir_fd = open(hookdir, O_RDONLY | O_DIRECTORY | O_PATH
1899
| O_CLOEXEC);
1522
hookdir_fd = open(hookdir, O_RDONLY);
1900
1523
if(hookdir_fd == -1){
1901
1524
if(errno == ENOENT){
1902
1525
if(debug){
1909
1532
return;
1910
1533
}
1911
1534
}
1535
#ifdef __GLIBC__
1536
#if __GLIBC_PREREQ(2, 15)
1912
1537
int numhooks = scandirat(hookdir_fd, ".", &direntries,
1913
1538
runnable_hook, alphasort);
1539
#else /* not __GLIBC_PREREQ(2, 15) */
1540
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1541
alphasort);
1542
#endif /* not __GLIBC_PREREQ(2, 15) */
1543
#else /* not __GLIBC__ */
1544
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1545
alphasort);
1546
#endif /* not __GLIBC__ */
1914
1547
if(numhooks == -1){
1915
1548
perror_plus("scandir");
1916
1549
return;
1917
1550
}
1918
1551
struct dirent *direntry;
1919
1552
int ret;
1920
int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
1921
if(devnull == -1){
1922
perror_plus("open(\"/dev/null\", O_RDONLY)");
1923
return;
1924
}
1553
int devnull = open("/dev/null", O_RDONLY);
1925
1554
for(int i = 0; i < numhooks; i++){
1926
1555
direntry = direntries[i];
1927
1556
if(debug){
1951
1580
perror_plus("setgroups");
1952
1581
_exit(EX_NOPERM);
1953
1582
}
1583
ret = dup2(devnull, STDIN_FILENO);
1584
if(ret == -1){
1585
perror_plus("dup2(devnull, STDIN_FILENO)");
1586
_exit(EX_OSERR);
1587
}
1588
ret = close(devnull);
1589
if(ret == -1){
1590
perror_plus("close");
1591
_exit(EX_OSERR);
1592
}
1593
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
1594
if(ret == -1){
1595
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
1596
_exit(EX_OSERR);
1597
}
1954
1598
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1955
1599
if(ret == -1){
1956
1600
perror_plus("setenv");
1991
1635
_exit(EX_OSERR);
1992
1636
}
1993
1637
}
1994
int hook_fd = (int)TEMP_FAILURE_RETRY(openat(hookdir_fd,
1995
direntry->d_name,
1996
O_RDONLY));
1638
int hook_fd = openat(hookdir_fd, direntry->d_name, O_RDONLY);
1997
1639
if(hook_fd == -1){
1998
1640
perror_plus("openat");
1999
1641
_exit(EXIT_FAILURE);
2000
1642
}
2001
if(close(hookdir_fd) == -1){
1643
if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
2002
1644
perror_plus("close");
2003
1645
_exit(EXIT_FAILURE);
2004
1646
}
2005
ret = dup2(devnull, STDIN_FILENO);
2006
if(ret == -1){
2007
perror_plus("dup2(devnull, STDIN_FILENO)");
2008
_exit(EX_OSERR);
2009
}
2010
ret = close(devnull);
2011
if(ret == -1){
2012
perror_plus("close");
2013
_exit(EX_OSERR);
2014
}
2015
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
2016
if(ret == -1){
2017
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
2018
_exit(EX_OSERR);
2019
}
2020
1647
if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
2021
1648
environ) == -1){
2022
1649
perror_plus("fexecve");
2023
1650
_exit(EXIT_FAILURE);
2024
1651
}
2025
1652
} else {
2026
if(hook_pid == -1){
2027
perror_plus("fork");
2028
free(direntry);
2029
continue;
2030
}
2031
1653
int status;
2032
1654
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
2033
1655
perror_plus("waitpid");
2062
1684
free(direntry);
2063
1685
}
2064
1686
free(direntries);
2065
if(close(hookdir_fd) == -1){
1687
if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
2066
1688
perror_plus("close");
2067
1689
} else {
2068
1690
hookdir_fd = -1;
2071
1693
}
2072
1694
2073
1695
__attribute__((nonnull, warn_unused_result))
2074
int bring_up_interface(const char *const interface,
2075
const float delay){
2076
int old_errno = errno;
1696
error_t bring_up_interface(const char *const interface,
1697
const float delay){
1698
error_t old_errno = errno;
2077
1699
int ret;
2078
1700
struct ifreq network;
2079
1701
unsigned int if_index = if_nametoindex(interface);
2089
1711
}
2090
1712
2091
1713
if(not interface_is_up(interface)){
2092
int ret_errno = 0;
2093
int ioctl_errno = 0;
1714
error_t ret_errno = 0, ioctl_errno = 0;
2094
1715
if(not get_flags(interface, &network)){
2095
1716
ret_errno = errno;
2096
1717
fprintf_plus(stderr, "Failed to get flags for interface "
2109
1730
}
2110
1731
2111
1732
if(quit_now){
2112
ret = close(sd);
1733
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2113
1734
if(ret == -1){
2114
1735
perror_plus("close");
2115
1736
}
2165
1786
}
2166
1787
2167
1788
/* Close the socket */
2168
ret = close(sd);
1789
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2169
1790
if(ret == -1){
2170
1791
perror_plus("close");
2171
1792
}
2199
1820
}
2200
1821
2201
1822
__attribute__((nonnull, warn_unused_result))
2202
int take_down_interface(const char *const interface){
2203
int old_errno = errno;
1823
error_t take_down_interface(const char *const interface){
1824
error_t old_errno = errno;
2204
1825
struct ifreq network;
2205
1826
unsigned int if_index = if_nametoindex(interface);
2206
1827
if(if_index == 0){
2209
1830
return ENXIO;
2210
1831
}
2211
1832
if(interface_is_up(interface)){
2212
int ret_errno = 0;
2213
int ioctl_errno = 0;
1833
error_t ret_errno = 0, ioctl_errno = 0;
2214
1834
if(not get_flags(interface, &network) and debug){
2215
1835
ret_errno = errno;
2216
1836
fprintf_plus(stderr, "Failed to get flags for interface "
2254
1874
}
2255
1875
2256
1876
/* Close the socket */
2257
int ret = close(sd);
1877
int ret = (int)TEMP_FAILURE_RETRY(close(sd));
2258
1878
if(ret == -1){
2259
1879
perror_plus("close");
2260
1880
}
2275
1895
}
2276
1896
2277
1897
int main(int argc, char *argv[]){
2278
mandos_context mc = { .server = NULL, .dh_bits = 0,
2279
.priority = "SECURE256:!CTYPE-X.509"
2280
":+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256",
2281
.current_server = NULL, .interfaces = NULL,
2282
.interfaces_size = 0 };
1898
mandos_context mc = { .server = NULL, .dh_bits = 1024,
1899
.priority = "SECURE256:!CTYPE-X.509:"
1900
"+CTYPE-OPENPGP", .current_server = NULL,
1901
.interfaces = NULL, .interfaces_size = 0 };
2283
1902
AvahiSServiceBrowser *sb = NULL;
2284
1903
error_t ret_errno;
2285
1904
int ret;
2294
1913
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
2295
1914
const char *seckey = PATHDIR "/" SECKEY;
2296
1915
const char *pubkey = PATHDIR "/" PUBKEY;
2297
const char *dh_params_file = NULL;
2298
1916
char *interfaces_hooks = NULL;
2299
1917
2300
1918
bool gnutls_initialized = false;
2353
1971
.doc = "Bit length of the prime number used in the"
2354
1972
" Diffie-Hellman key exchange",
2355
1973
.group = 2 },
2356
{ .name = "dh-params", .key = 134,
2357
.arg = "FILE",
2358
.doc = "PEM-encoded PKCS#3 file with pre-generated parameters"
2359
" for the Diffie-Hellman key exchange",
2360
.group = 2 },
2361
1974
{ .name = "priority", .key = 130,
2362
1975
.arg = "STRING",
2363
1976
.doc = "GnuTLS priority string for the TLS handshake",
2418
2031
}
2419
2032
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
2420
2033
break;
2421
case 134: /* --dh-params */
2422
dh_params_file = arg;
2423
break;
2424
2034
case 130: /* --priority */
2425
2035
mc.priority = arg;
2426
2036
break;
2466
2076
.args_doc = "",
2467
2077
.doc = "Mandos client -- Get and decrypt"
2468
2078
" passwords from a Mandos server" };
2469
ret_errno = argp_parse(&argp, argc, argv,
2470
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2471
switch(ret_errno){
2079
ret = argp_parse(&argp, argc, argv,
2080
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2081
switch(ret){
2472
2082
case 0:
2473
2083
break;
2474
2084
case ENOMEM:
2475
2085
default:
2476
errno = ret_errno;
2086
errno = ret;
2477
2087
perror_plus("argp_parse");
2478
2088
exitcode = EX_OSERR;
2479
2089
goto end;
2482
2092
goto end;
2483
2093
}
2484
2094
}
2485
2095
2486
2096
{
2487
2097
/* Work around Debian bug #633582:
2488
2098
<http://bugs.debian.org/633582> */
2489
2099
2490
2100
/* Re-raise privileges */
2491
ret = raise_privileges();
2492
if(ret != 0){
2493
errno = ret;
2101
ret_errno = raise_privileges();
2102
if(ret_errno != 0){
2103
errno = ret_errno;
2494
2104
perror_plus("Failed to raise privileges");
2495
2105
} else {
2496
2106
struct stat st;
2512
2122
}
2513
2123
}
2514
2124
}
2515
close(seckey_fd);
2125
TEMP_FAILURE_RETRY(close(seckey_fd));
2516
2126
}
2517
2127
}
2518
2128
2519
2129
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2520
2130
int pubkey_fd = open(pubkey, O_RDONLY);
2521
2131
if(pubkey_fd == -1){
2533
2143
}
2534
2144
}
2535
2145
}
2536
close(pubkey_fd);
2537
}
2538
}
2539
2540
if(dh_params_file != NULL
2541
and strcmp(dh_params_file, PATHDIR "/dhparams.pem" ) == 0){
2542
int dhparams_fd = open(dh_params_file, O_RDONLY);
2543
if(dhparams_fd == -1){
2544
perror_plus("open");
2545
} else {
2546
ret = (int)TEMP_FAILURE_RETRY(fstat(dhparams_fd, &st));
2547
if(ret == -1){
2548
perror_plus("fstat");
2549
} else {
2550
if(S_ISREG(st.st_mode)
2551
and st.st_uid == 0 and st.st_gid == 0){
2552
ret = fchown(dhparams_fd, uid, gid);
2553
if(ret == -1){
2554
perror_plus("fchown");
2555
}
2556
}
2557
}
2558
close(dhparams_fd);
2559
}
2560
}
2561
2146
TEMP_FAILURE_RETRY(close(pubkey_fd));
2147
}
2148
}
2149
2562
2150
/* Lower privileges */
2563
ret = lower_privileges();
2564
if(ret != 0){
2565
errno = ret;
2151
ret_errno = lower_privileges();
2152
if(ret_errno != 0){
2153
errno = ret_errno;
2566
2154
perror_plus("Failed to lower privileges");
2567
2155
}
2568
2156
}
2738
2326
errno = bring_up_interface(interface, delay);
2739
2327
if(not interface_was_up){
2740
2328
if(errno != 0){
2741
fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
2742
" %s\n", interface, strerror(errno));
2329
perror_plus("Failed to bring up interface");
2743
2330
} else {
2744
2331
errno = argz_add(&interfaces_to_take_down,
2745
2332
&interfaces_to_take_down_size,
2768
2355
goto end;
2769
2356
}
2770
2357
2771
ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
2358
ret = init_gnutls_global(pubkey, seckey, &mc);
2772
2359
if(ret == -1){
2773
2360
fprintf_plus(stderr, "init_gnutls_global failed\n");
2774
2361
exitcode = EX_UNAVAILABLE;
2896
2483
2897
2484
/* Allocate a new server */
2898
2485
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
2899
&config, NULL, NULL, &ret);
2486
&config, NULL, NULL, &ret_errno);
2900
2487
2901
2488
/* Free the Avahi configuration data */
2902
2489
avahi_server_config_free(&config);
2905
2492
/* Check if creating the Avahi server object succeeded */
2906
2493
if(mc.server == NULL){
2907
2494
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2908
avahi_strerror(ret));
2495
avahi_strerror(ret_errno));
2909
2496
exitcode = EX_UNAVAILABLE;
2910
2497
goto end;
2911
2498
}
2963
2550
2964
2551
if(gnutls_initialized){
2965
2552
gnutls_certificate_free_credentials(mc.cred);
2553
gnutls_global_deinit();
2966
2554
gnutls_dh_params_deinit(mc.dh_params);
2967
2555
}
2968
2556
2991
2579
2992
2580
/* Re-raise privileges */
2993
2581
{
2994
ret = raise_privileges();
2995
if(ret != 0){
2996
errno = ret;
2582
ret_errno = raise_privileges();
2583
if(ret_errno != 0){
2584
errno = ret_errno;
2997
2585
perror_plus("Failed to raise privileges");
2998
2586
} else {
2999
2587
3007
2595
while((interface=argz_next(interfaces_to_take_down,
3008
2596
interfaces_to_take_down_size,
3009
2597
interface))){
3010
ret = take_down_interface(interface);
3011
if(ret != 0){
3012
errno = ret;
2598
ret_errno = take_down_interface(interface);
2599
if(ret_errno != 0){
2600
errno = ret_errno;
3013
2601
perror_plus("Failed to take down interface");
3014
2602
}
3015
2603
}
3020
2608
}
3021
2609
}
3022
2610
3023
ret = lower_privileges_permanently();
3024
if(ret != 0){
3025
errno = ret;
2611
ret_errno = lower_privileges_permanently();
2612
if(ret_errno != 0){
2613
errno = ret_errno;
3026
2614
perror_plus("Failed to lower privileges permanently");
3027
2615
}
3028
2616
}
3030
2618
free(interfaces_to_take_down);
3031
2619
free(interfaces_hooks);
3032
2620
3033
void clean_dir_at(int base, const char * const dirname,
3034
uintmax_t level){
3035
struct dirent **direntries = NULL;
3036
int dret;
3037
int dir_fd = (int)TEMP_FAILURE_RETRY(openat(base, dirname,
3038
O_RDONLY
3039
| O_NOFOLLOW
3040
| O_DIRECTORY
3041
| O_PATH));
3042
if(dir_fd == -1){
3043
perror_plus("open");
3044
}
3045
int numentries = scandirat(dir_fd, ".", &direntries,
3046
notdotentries, alphasort);
3047
if(numentries >= 0){
3048
for(int i = 0; i < numentries; i++){
3049
if(debug){
3050
fprintf_plus(stderr, "Unlinking \"%s/%s\"\n",
3051
dirname, direntries[i]->d_name);
3052
}
3053
dret = unlinkat(dir_fd, direntries[i]->d_name, 0);
3054
if(dret == -1){
3055
if(errno == EISDIR){
3056
dret = unlinkat(dir_fd, direntries[i]->d_name,
3057
AT_REMOVEDIR);
3058
}
3059
if((dret == -1) and (errno == ENOTEMPTY)
3060
and (strcmp(direntries[i]->d_name, "private-keys-v1.d")
3061
== 0) and (level == 0)){
3062
/* Recurse only in this special case */
3063
clean_dir_at(dir_fd, direntries[i]->d_name, level+1);
3064
dret = 0;
3065
}
3066
if(dret == -1){
3067
fprintf_plus(stderr, "unlink(\"%s/%s\"): %s\n", dirname,
3068
direntries[i]->d_name, strerror(errno));
3069
}
3070
}
3071
free(direntries[i]);
3072
}
3073
3074
/* need to clean even if 0 because man page doesn't specify */
3075
free(direntries);
3076
if(numentries == -1){
3077
perror_plus("scandirat");
3078
}
3079
dret = unlinkat(base, dirname, AT_REMOVEDIR);
3080
if(dret == -1 and errno != ENOENT){
3081
perror_plus("rmdir");
3082
}
3083
} else {
3084
perror_plus("scandirat");
3085
}
3086
close(dir_fd);
3087
}
3088
3089
2621
/* Removes the GPGME temp directory and all files inside */
3090
2622
if(tempdir != NULL){
3091
clean_dir_at(-1, tempdir, 0);
2623
struct dirent **direntries = NULL;
2624
int tempdir_fd = (int)TEMP_FAILURE_RETRY(open(tempdir, O_RDONLY |
2625
O_NOFOLLOW));
2626
if(tempdir_fd == -1){
2627
perror_plus("open");
2628
} else {
2629
#ifdef __GLIBC__
2630
#if __GLIBC_PREREQ(2, 15)
2631
int numentries = scandirat(tempdir_fd, ".", &direntries,
2632
notdotentries, alphasort);
2633
#else /* not __GLIBC_PREREQ(2, 15) */
2634
int numentries = scandir(tempdir, &direntries, notdotentries,
2635
alphasort);
2636
#endif /* not __GLIBC_PREREQ(2, 15) */
2637
#else /* not __GLIBC__ */
2638
int numentries = scandir(tempdir, &direntries, notdotentries,
2639
alphasort);
2640
#endif /* not __GLIBC__ */
2641
if(numentries >= 0){
2642
for(int i = 0; i < numentries; i++){
2643
ret = unlinkat(tempdir_fd, direntries[i]->d_name, 0);
2644
if(ret == -1){
2645
fprintf_plus(stderr, "unlinkat(open(\"%s\", O_RDONLY),"
2646
" \"%s\", 0): %s\n", tempdir,
2647
direntries[i]->d_name, strerror(errno));
2648
}
2649
free(direntries[i]);
2650
}
2651
2652
/* need to clean even if 0 because man page doesn't specify */
2653
free(direntries);
2654
if(numentries == -1){
2655
perror_plus("scandir");
2656
}
2657
ret = rmdir(tempdir);
2658
if(ret == -1 and errno != ENOENT){
2659
perror_plus("rmdir");
2660
}
2661
}
2662
TEMP_FAILURE_RETRY(close(tempdir_fd));
2663
}
3092
2664
}
3093
2665
3094
2666
if(quit_now){
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0