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 741
- compare with another revision
- download diff
- download tarball
- view history from revision 741
- Committer: Teddy Hogeborn
- Date: 2015-01-25 00:02:51 UTC
- Revision ID: teddy@recompile.se-20150125000251-j2bw50gfq9smqyxe
mandos.xml (SEE ALSO): Update links.
Update link to GnuPG home page, change reference from TLS 1.1 to TLS
1.2, and change to latest RFC for using OpenPGP keys with TLS (and use
its correct title).
Update link to GnuPG home page, change reference from TLS 1.1 to TLS
1.2, and change to latest RFC for using OpenPGP keys with TLS (and use
its correct title).
- files removed:
- plugin-helpers
- files modified:
- DBUS-API
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");
2062
1689
free(direntry);
2063
1690
}
2064
1691
free(direntries);
2065
if(close(hookdir_fd) == -1){
1692
if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
2066
1693
perror_plus("close");
2067
1694
} else {
2068
1695
hookdir_fd = -1;
2071
1698
}
2072
1699
2073
1700
__attribute__((nonnull, warn_unused_result))
2074
int bring_up_interface(const char *const interface,
2075
const float delay){
2076
int old_errno = errno;
1701
error_t bring_up_interface(const char *const interface,
1702
const float delay){
1703
error_t old_errno = errno;
2077
1704
int ret;
2078
1705
struct ifreq network;
2079
1706
unsigned int if_index = if_nametoindex(interface);
2089
1716
}
2090
1717
2091
1718
if(not interface_is_up(interface)){
2092
int ret_errno = 0;
2093
int ioctl_errno = 0;
1719
error_t ret_errno = 0, ioctl_errno = 0;
2094
1720
if(not get_flags(interface, &network)){
2095
1721
ret_errno = errno;
2096
1722
fprintf_plus(stderr, "Failed to get flags for interface "
2109
1735
}
2110
1736
2111
1737
if(quit_now){
2112
ret = close(sd);
1738
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2113
1739
if(ret == -1){
2114
1740
perror_plus("close");
2115
1741
}
2165
1791
}
2166
1792
2167
1793
/* Close the socket */
2168
ret = close(sd);
1794
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2169
1795
if(ret == -1){
2170
1796
perror_plus("close");
2171
1797
}
2199
1825
}
2200
1826
2201
1827
__attribute__((nonnull, warn_unused_result))
2202
int take_down_interface(const char *const interface){
2203
int old_errno = errno;
1828
error_t take_down_interface(const char *const interface){
1829
error_t old_errno = errno;
2204
1830
struct ifreq network;
2205
1831
unsigned int if_index = if_nametoindex(interface);
2206
1832
if(if_index == 0){
2209
1835
return ENXIO;
2210
1836
}
2211
1837
if(interface_is_up(interface)){
2212
int ret_errno = 0;
2213
int ioctl_errno = 0;
1838
error_t ret_errno = 0, ioctl_errno = 0;
2214
1839
if(not get_flags(interface, &network) and debug){
2215
1840
ret_errno = errno;
2216
1841
fprintf_plus(stderr, "Failed to get flags for interface "
2254
1879
}
2255
1880
2256
1881
/* Close the socket */
2257
int ret = close(sd);
1882
int ret = (int)TEMP_FAILURE_RETRY(close(sd));
2258
1883
if(ret == -1){
2259
1884
perror_plus("close");
2260
1885
}
2275
1900
}
2276
1901
2277
1902
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 };
1903
mandos_context mc = { .server = NULL, .dh_bits = 1024,
1904
.priority = "SECURE256:!CTYPE-X.509:"
1905
"+CTYPE-OPENPGP", .current_server = NULL,
1906
.interfaces = NULL, .interfaces_size = 0 };
2283
1907
AvahiSServiceBrowser *sb = NULL;
2284
1908
error_t ret_errno;
2285
1909
int ret;
2294
1918
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
2295
1919
const char *seckey = PATHDIR "/" SECKEY;
2296
1920
const char *pubkey = PATHDIR "/" PUBKEY;
2297
const char *dh_params_file = NULL;
2298
1921
char *interfaces_hooks = NULL;
2299
1922
2300
1923
bool gnutls_initialized = false;
2353
1976
.doc = "Bit length of the prime number used in the"
2354
1977
" Diffie-Hellman key exchange",
2355
1978
.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
1979
{ .name = "priority", .key = 130,
2362
1980
.arg = "STRING",
2363
1981
.doc = "GnuTLS priority string for the TLS handshake",
2418
2036
}
2419
2037
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
2420
2038
break;
2421
case 134: /* --dh-params */
2422
dh_params_file = arg;
2423
break;
2424
2039
case 130: /* --priority */
2425
2040
mc.priority = arg;
2426
2041
break;
2466
2081
.args_doc = "",
2467
2082
.doc = "Mandos client -- Get and decrypt"
2468
2083
" 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){
2084
ret = argp_parse(&argp, argc, argv,
2085
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2086
switch(ret){
2472
2087
case 0:
2473
2088
break;
2474
2089
case ENOMEM:
2475
2090
default:
2476
errno = ret_errno;
2091
errno = ret;
2477
2092
perror_plus("argp_parse");
2478
2093
exitcode = EX_OSERR;
2479
2094
goto end;
2482
2097
goto end;
2483
2098
}
2484
2099
}
2485
2100
2486
2101
{
2487
2102
/* Work around Debian bug #633582:
2488
2103
<http://bugs.debian.org/633582> */
2489
2104
2490
2105
/* Re-raise privileges */
2491
ret = raise_privileges();
2492
if(ret != 0){
2493
errno = ret;
2106
ret_errno = raise_privileges();
2107
if(ret_errno != 0){
2108
errno = ret_errno;
2494
2109
perror_plus("Failed to raise privileges");
2495
2110
} else {
2496
2111
struct stat st;
2512
2127
}
2513
2128
}
2514
2129
}
2515
close(seckey_fd);
2130
TEMP_FAILURE_RETRY(close(seckey_fd));
2516
2131
}
2517
2132
}
2518
2133
2519
2134
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2520
2135
int pubkey_fd = open(pubkey, O_RDONLY);
2521
2136
if(pubkey_fd == -1){
2533
2148
}
2534
2149
}
2535
2150
}
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
2151
TEMP_FAILURE_RETRY(close(pubkey_fd));
2152
}
2153
}
2154
2562
2155
/* Lower privileges */
2563
ret = lower_privileges();
2564
if(ret != 0){
2565
errno = ret;
2156
ret_errno = lower_privileges();
2157
if(ret_errno != 0){
2158
errno = ret_errno;
2566
2159
perror_plus("Failed to lower privileges");
2567
2160
}
2568
2161
}
2738
2331
errno = bring_up_interface(interface, delay);
2739
2332
if(not interface_was_up){
2740
2333
if(errno != 0){
2741
fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
2742
" %s\n", interface, strerror(errno));
2334
perror_plus("Failed to bring up interface");
2743
2335
} else {
2744
2336
errno = argz_add(&interfaces_to_take_down,
2745
2337
&interfaces_to_take_down_size,
2768
2360
goto end;
2769
2361
}
2770
2362
2771
ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
2363
ret = init_gnutls_global(pubkey, seckey, &mc);
2772
2364
if(ret == -1){
2773
2365
fprintf_plus(stderr, "init_gnutls_global failed\n");
2774
2366
exitcode = EX_UNAVAILABLE;
2896
2488
2897
2489
/* Allocate a new server */
2898
2490
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
2899
&config, NULL, NULL, &ret);
2491
&config, NULL, NULL, &ret_errno);
2900
2492
2901
2493
/* Free the Avahi configuration data */
2902
2494
avahi_server_config_free(&config);
2905
2497
/* Check if creating the Avahi server object succeeded */
2906
2498
if(mc.server == NULL){
2907
2499
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2908
avahi_strerror(ret));
2500
avahi_strerror(ret_errno));
2909
2501
exitcode = EX_UNAVAILABLE;
2910
2502
goto end;
2911
2503
}
2963
2555
2964
2556
if(gnutls_initialized){
2965
2557
gnutls_certificate_free_credentials(mc.cred);
2558
gnutls_global_deinit();
2966
2559
gnutls_dh_params_deinit(mc.dh_params);
2967
2560
}
2968
2561
2991
2584
2992
2585
/* Re-raise privileges */
2993
2586
{
2994
ret = raise_privileges();
2995
if(ret != 0){
2996
errno = ret;
2587
ret_errno = raise_privileges();
2588
if(ret_errno != 0){
2589
errno = ret_errno;
2997
2590
perror_plus("Failed to raise privileges");
2998
2591
} else {
2999
2592
3007
2600
while((interface=argz_next(interfaces_to_take_down,
3008
2601
interfaces_to_take_down_size,
3009
2602
interface))){
3010
ret = take_down_interface(interface);
3011
if(ret != 0){
3012
errno = ret;
2603
ret_errno = take_down_interface(interface);
2604
if(ret_errno != 0){
2605
errno = ret_errno;
3013
2606
perror_plus("Failed to take down interface");
3014
2607
}
3015
2608
}
3020
2613
}
3021
2614
}
3022
2615
3023
ret = lower_privileges_permanently();
3024
if(ret != 0){
3025
errno = ret;
2616
ret_errno = lower_privileges_permanently();
2617
if(ret_errno != 0){
2618
errno = ret_errno;
3026
2619
perror_plus("Failed to lower privileges permanently");
3027
2620
}
3028
2621
}
3030
2623
free(interfaces_to_take_down);
3031
2624
free(interfaces_hooks);
3032
2625
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
2626
/* Removes the GPGME temp directory and all files inside */
3090
2627
if(tempdir != NULL){
3091
clean_dir_at(-1, tempdir, 0);
2628
struct dirent **direntries = NULL;
2629
int tempdir_fd = (int)TEMP_FAILURE_RETRY(open(tempdir, O_RDONLY |
2630
O_NOFOLLOW));
2631
if(tempdir_fd == -1){
2632
perror_plus("open");
2633
} else {
2634
#ifdef __GLIBC__
2635
#if __GLIBC_PREREQ(2, 15)
2636
int numentries = scandirat(tempdir_fd, ".", &direntries,
2637
notdotentries, alphasort);
2638
#else /* not __GLIBC_PREREQ(2, 15) */
2639
int numentries = scandir(tempdir, &direntries, notdotentries,
2640
alphasort);
2641
#endif /* not __GLIBC_PREREQ(2, 15) */
2642
#else /* not __GLIBC__ */
2643
int numentries = scandir(tempdir, &direntries, notdotentries,
2644
alphasort);
2645
#endif /* not __GLIBC__ */
2646
if(numentries >= 0){
2647
for(int i = 0; i < numentries; i++){
2648
ret = unlinkat(tempdir_fd, direntries[i]->d_name, 0);
2649
if(ret == -1){
2650
fprintf_plus(stderr, "unlinkat(open(\"%s\", O_RDONLY),"
2651
" \"%s\", 0): %s\n", tempdir,
2652
direntries[i]->d_name, strerror(errno));
2653
}
2654
free(direntries[i]);
2655
}
2656
2657
/* need to clean even if 0 because man page doesn't specify */
2658
free(direntries);
2659
if(numentries == -1){
2660
perror_plus("scandir");
2661
}
2662
ret = rmdir(tempdir);
2663
if(ret == -1 and errno != ENOENT){
2664
perror_plus("rmdir");
2665
}
2666
}
2667
TEMP_FAILURE_RETRY(close(tempdir_fd));
2668
}
3092
2669
}
3093
2670
3094
2671
if(quit_now){
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0