(root)/mandos/release
» Revision
237.24.1
(compared to revision 237.7.494)
: plugins.d/mandos-client.c
To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to plugins.d/mandos-client.c
- browse files at revision 237.24.1
- compare with another revision
- download diff
- download tarball
- view history from revision 237.24.1
- Committer: Teddy Hogeborn
- Date: 2015-05-23 20:18:34 UTC
- mto: (237.7.304 trunk)
- mto: This revision was merged to the branch mainline in revision 325.
- Revision ID: teddy@recompile.se-20150523201834-e89ex4ito93yni8x
mandos: Use multiprocessing module to run checkers.
For a long time, the Mandos server has occasionally logged the message
"ERROR: Child process vanished". This was never a fatal error, but it
has been annoying and slightly worrying, since a definite cause was
not found. One potential cause could be the "multiprocessing" and
"subprocess" modules conflicting w.r.t. SIGCHLD. To avoid this,
change the running of checkers from using subprocess.Popen
asynchronously to instead first create a multiprocessing.Process()
(which is asynchronous) calling a function, and have that function
then call subprocess.call() (which is synchronous). In this way, the
only thing using any asynchronous subprocesses is the multiprocessing
module.
This makes it necessary to change one small thing in the D-Bus API,
since the subprocesses.call() function does not expose the raw wait(2)
status value.
DBUS-API (CheckerCompleted): Change the second value provided by this
D-Bus signal from the raw wait(2) status
to the actual terminating signal number.
mandos (subprocess_call_pipe): New function to be called by
multiprocessing.Process (starting a
separate process).
(Client.last_checker signal): New attribute for signal which
terminated last checker. Like
last_checker_status, only not accessible
via D-Bus.
(Client.checker_callback): Take new "connection" argument and use it
to get returncode; set last_checker_signal.
Return False so gobject does not call this
callback again.
(Client.start_checker): Start checker using a multiprocessing.Process
instead of a subprocess.Popen.
(ClientDBus.checker_callback): Take new "connection" argument. Call
Client.checker_callback early to have
it set last_checker_status and
last_checker_signal; use those. Change
second value provided to D-Bus signal
CheckerCompleted to use
last_checker_signal if checker was
terminated by signal.
mandos-monitor: Update to reflect DBus API change.
(MandosClientWidget.checker_completed): Take "signal" instead of
"condition" argument. Use it
accordingly. Remove dead code
(os.WCOREDUMP case).
For a long time, the Mandos server has occasionally logged the message
"ERROR: Child process vanished". This was never a fatal error, but it
has been annoying and slightly worrying, since a definite cause was
not found. One potential cause could be the "multiprocessing" and
"subprocess" modules conflicting w.r.t. SIGCHLD. To avoid this,
change the running of checkers from using subprocess.Popen
asynchronously to instead first create a multiprocessing.Process()
(which is asynchronous) calling a function, and have that function
then call subprocess.call() (which is synchronous). In this way, the
only thing using any asynchronous subprocesses is the multiprocessing
module.
This makes it necessary to change one small thing in the D-Bus API,
since the subprocesses.call() function does not expose the raw wait(2)
status value.
DBUS-API (CheckerCompleted): Change the second value provided by this
D-Bus signal from the raw wait(2) status
to the actual terminating signal number.
mandos (subprocess_call_pipe): New function to be called by
multiprocessing.Process (starting a
separate process).
(Client.last_checker signal): New attribute for signal which
terminated last checker. Like
last_checker_status, only not accessible
via D-Bus.
(Client.checker_callback): Take new "connection" argument and use it
to get returncode; set last_checker_signal.
Return False so gobject does not call this
callback again.
(Client.start_checker): Start checker using a multiprocessing.Process
instead of a subprocess.Popen.
(ClientDBus.checker_callback): Take new "connection" argument. Call
Client.checker_callback early to have
it set last_checker_status and
last_checker_signal; use those. Change
second value provided to D-Bus signal
CheckerCompleted to use
last_checker_signal if checker was
terminated by signal.
mandos-monitor: Update to reflect DBus API change.
(MandosClientWidget.checker_completed): Take "signal" instead of
"condition" argument. Use it
accordingly. Remove dead code
(os.WCOREDUMP case).
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-2018 Teddy Hogeborn
13
* Copyright © 2008-2018 Björn Påhlsson
14
*
15
* This file is part of Mandos.
16
*
17
* Mandos is free software: you can redistribute it and/or modify it
18
* under the terms of the GNU General Public License as published by
19
* the Free Software Foundation, either version 3 of the License, or
20
* (at your option) any later version.
21
*
22
* Mandos is distributed in the hope that it will be useful, but
12
* Copyright © 2008-2014 Teddy Hogeborn
13
* Copyright © 2008-2014 Björn Påhlsson
14
*
15
* This program is free software: you can redistribute it and/or
16
* modify it under the terms of the GNU General Public License as
17
* published by the Free Software Foundation, either version 3 of the
18
* License, or (at your option) any later version.
19
*
20
* This program is distributed in the hope that it will be useful, but
23
21
* WITHOUT ANY WARRANTY; without even the implied warranty of
24
22
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
25
23
* General Public License for more details.
26
24
*
27
25
* You should have received a copy of the GNU General Public License
28
* along with Mandos. If not, see <http://www.gnu.org/licenses/>.
26
* along with this program. If not, see
27
* <http://www.gnu.org/licenses/>.
29
28
*
30
29
* Contact the authors at <mandos@recompile.se>.
31
30
*/
47
46
#include <stdlib.h> /* free(), EXIT_SUCCESS, srand(),
48
47
strtof(), abort() */
49
48
#include <stdbool.h> /* bool, false, true */
50
#include <string.h> /* strcmp(), strlen(), strerror(),
51
asprintf(), strncpy(), strsignal()
52
*/
49
#include <string.h> /* memset(), strcmp(), strlen(),
50
strerror(), asprintf(), strcpy() */
53
51
#include <sys/ioctl.h> /* ioctl */
54
52
#include <sys/types.h> /* socket(), inet_pton(), sockaddr,
55
53
sockaddr_in6, PF_INET6,
59
57
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
60
58
inet_pton(), connect(),
61
59
getnameinfo() */
62
#include <fcntl.h> /* open(), unlinkat(), AT_REMOVEDIR */
60
#include <fcntl.h> /* open(), unlinkat() */
63
61
#include <dirent.h> /* opendir(), struct dirent, readdir()
64
62
*/
65
63
#include <inttypes.h> /* PRIu16, PRIdMAX, intmax_t,
66
64
strtoimax() */
67
#include <errno.h> /* perror(), errno, EINTR, EINVAL,
68
EAI_SYSTEM, ENETUNREACH,
69
EHOSTUNREACH, ECONNREFUSED, EPROTO,
70
EIO, ENOENT, ENXIO, ENOMEM, EISDIR,
71
ENOTEMPTY,
65
#include <errno.h> /* perror(), errno,
72
66
program_invocation_short_name */
73
67
#include <time.h> /* nanosleep(), time(), sleep() */
74
68
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
311
305
return false;
312
306
}
313
307
314
ret = close(fd);
308
ret = (int)TEMP_FAILURE_RETRY(close(fd));
315
309
if(ret == -1){
316
310
perror_plus("close");
317
311
}
356
350
/* Create new GPGME "context" */
357
351
rc = gpgme_new(&(mc->ctx));
358
352
if(rc != GPG_ERR_NO_ERROR){
359
fprintf_plus(stderr, "bad gpgme_new: %s: %s\n",
360
gpgme_strsource(rc), gpgme_strerror(rc));
353
fprintf_plus(stderr, "Mandos plugin mandos-client: "
354
"bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
355
gpgme_strerror(rc));
361
356
return false;
362
357
}
363
358
399
394
/* Create new empty GPGME data buffer for the plaintext */
400
395
rc = gpgme_data_new(&dh_plain);
401
396
if(rc != GPG_ERR_NO_ERROR){
402
fprintf_plus(stderr, "bad gpgme_data_new: %s: %s\n",
397
fprintf_plus(stderr, "Mandos plugin mandos-client: "
398
"bad gpgme_data_new: %s: %s\n",
403
399
gpgme_strsource(rc), gpgme_strerror(rc));
404
400
gpgme_data_release(dh_crypto);
405
401
return -1;
418
414
if(result == NULL){
419
415
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
420
416
} else {
421
if(result->unsupported_algorithm != NULL) {
422
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
423
result->unsupported_algorithm);
424
}
425
fprintf_plus(stderr, "Wrong key usage: %s\n",
426
result->wrong_key_usage ? "Yes" : "No");
417
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
418
result->unsupported_algorithm);
419
fprintf_plus(stderr, "Wrong key usage: %u\n",
420
result->wrong_key_usage);
427
421
if(result->file_name != NULL){
428
422
fprintf_plus(stderr, "File name: %s\n", result->file_name);
429
423
}
519
513
fprintf_plus(stderr, "GnuTLS: %s", string);
520
514
}
521
515
522
__attribute__((nonnull(1, 2, 4), warn_unused_result))
516
__attribute__((nonnull, warn_unused_result))
523
517
static int init_gnutls_global(const char *pubkeyfilename,
524
518
const char *seckeyfilename,
525
const char *dhparamsfilename,
526
519
mandos_context *mc){
527
520
int ret;
528
521
unsigned int uret;
531
524
fprintf_plus(stderr, "Initializing GnuTLS\n");
532
525
}
533
526
527
ret = gnutls_global_init();
528
if(ret != GNUTLS_E_SUCCESS){
529
fprintf_plus(stderr, "GnuTLS global_init: %s\n",
530
safer_gnutls_strerror(ret));
531
return -1;
532
}
533
534
534
if(debug){
535
535
/* "Use a log level over 10 to enable all debugging options."
536
536
* - GnuTLS manual
544
544
if(ret != GNUTLS_E_SUCCESS){
545
545
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
546
546
safer_gnutls_strerror(ret));
547
gnutls_global_deinit();
547
548
return -1;
548
549
}
549
550
574
575
safer_gnutls_strerror(ret));
575
576
goto globalfail;
576
577
}
577
/* If a Diffie-Hellman parameters file was given, try to use it */
578
if(dhparamsfilename != NULL){
579
gnutls_datum_t params = { .data = NULL, .size = 0 };
580
do {
581
int dhpfile = open(dhparamsfilename, O_RDONLY);
582
if(dhpfile == -1){
583
perror_plus("open");
584
dhparamsfilename = NULL;
585
break;
586
}
587
size_t params_capacity = 0;
578
if(mc->dh_bits == 0){
579
/* Find out the optimal number of DH bits */
580
/* Try to read the private key file */
581
gnutls_datum_t buffer = { .data = NULL, .size = 0 };
582
{
583
int secfile = open(seckeyfilename, O_RDONLY);
584
size_t buffer_capacity = 0;
588
585
while(true){
589
params_capacity = incbuffer((char **)¶ms.data,
590
(size_t)params.size,
591
(size_t)params_capacity);
592
if(params_capacity == 0){
586
buffer_capacity = incbuffer((char **)&buffer.data,
587
(size_t)buffer.size,
588
(size_t)buffer_capacity);
589
if(buffer_capacity == 0){
593
590
perror_plus("incbuffer");
594
free(params.data);
595
params.data = NULL;
596
dhparamsfilename = NULL;
591
free(buffer.data);
592
buffer.data = NULL;
597
593
break;
598
594
}
599
ssize_t bytes_read = read(dhpfile,
600
params.data + params.size,
595
ssize_t bytes_read = read(secfile, buffer.data + buffer.size,
601
596
BUFFER_SIZE);
602
597
/* EOF */
603
598
if(bytes_read == 0){
606
601
/* check bytes_read for failure */
607
602
if(bytes_read < 0){
608
603
perror_plus("read");
609
free(params.data);
610
params.data = NULL;
611
dhparamsfilename = NULL;
612
break;
613
}
614
params.size += (unsigned int)bytes_read;
615
}
616
ret = close(dhpfile);
617
if(ret == -1){
618
perror_plus("close");
619
}
620
if(params.data == NULL){
621
dhparamsfilename = NULL;
622
}
623
if(dhparamsfilename == NULL){
624
break;
625
}
626
ret = gnutls_dh_params_import_pkcs3(mc->dh_params, ¶ms,
627
GNUTLS_X509_FMT_PEM);
628
if(ret != GNUTLS_E_SUCCESS){
629
fprintf_plus(stderr, "Failed to parse DH parameters in file"
630
" \"%s\": %s\n", dhparamsfilename,
631
safer_gnutls_strerror(ret));
632
dhparamsfilename = NULL;
633
}
634
free(params.data);
635
} while(false);
636
}
637
if(dhparamsfilename == NULL){
638
if(mc->dh_bits == 0){
639
/* Find out the optimal number of DH bits */
640
/* Try to read the private key file */
641
gnutls_datum_t buffer = { .data = NULL, .size = 0 };
642
do {
643
int secfile = open(seckeyfilename, O_RDONLY);
644
if(secfile == -1){
645
perror_plus("open");
646
break;
647
}
648
size_t buffer_capacity = 0;
649
while(true){
650
buffer_capacity = incbuffer((char **)&buffer.data,
651
(size_t)buffer.size,
652
(size_t)buffer_capacity);
653
if(buffer_capacity == 0){
654
perror_plus("incbuffer");
655
free(buffer.data);
656
buffer.data = NULL;
657
break;
658
}
659
ssize_t bytes_read = read(secfile,
660
buffer.data + buffer.size,
661
BUFFER_SIZE);
662
/* EOF */
663
if(bytes_read == 0){
664
break;
665
}
666
/* check bytes_read for failure */
667
if(bytes_read < 0){
668
perror_plus("read");
669
free(buffer.data);
670
buffer.data = NULL;
671
break;
672
}
673
buffer.size += (unsigned int)bytes_read;
674
}
675
close(secfile);
676
} while(false);
677
/* If successful, use buffer to parse private key */
678
gnutls_sec_param_t sec_param = GNUTLS_SEC_PARAM_ULTRA;
679
if(buffer.data != NULL){
680
{
681
gnutls_openpgp_privkey_t privkey = NULL;
682
ret = gnutls_openpgp_privkey_init(&privkey);
604
free(buffer.data);
605
buffer.data = NULL;
606
break;
607
}
608
buffer.size += (unsigned int)bytes_read;
609
}
610
close(secfile);
611
}
612
/* If successful, use buffer to parse private key */
613
gnutls_sec_param_t sec_param = GNUTLS_SEC_PARAM_ULTRA;
614
if(buffer.data != NULL){
615
{
616
gnutls_openpgp_privkey_t privkey = NULL;
617
ret = gnutls_openpgp_privkey_init(&privkey);
618
if(ret != GNUTLS_E_SUCCESS){
619
fprintf_plus(stderr, "Error initializing OpenPGP key"
620
" structure: %s", safer_gnutls_strerror(ret));
621
free(buffer.data);
622
buffer.data = NULL;
623
} else {
624
ret = gnutls_openpgp_privkey_import(privkey, &buffer,
625
GNUTLS_OPENPGP_FMT_BASE64,
626
"", 0);
683
627
if(ret != GNUTLS_E_SUCCESS){
684
fprintf_plus(stderr, "Error initializing OpenPGP key"
685
" structure: %s",
628
fprintf_plus(stderr, "Error importing OpenPGP key : %s",
686
629
safer_gnutls_strerror(ret));
687
free(buffer.data);
688
buffer.data = NULL;
689
} else {
690
ret = gnutls_openpgp_privkey_import
691
(privkey, &buffer, GNUTLS_OPENPGP_FMT_BASE64, "", 0);
692
if(ret != GNUTLS_E_SUCCESS){
693
fprintf_plus(stderr, "Error importing OpenPGP key : %s",
694
safer_gnutls_strerror(ret));
695
privkey = NULL;
696
}
697
free(buffer.data);
698
buffer.data = NULL;
699
if(privkey != NULL){
700
/* Use private key to suggest an appropriate
701
sec_param */
702
sec_param = gnutls_openpgp_privkey_sec_param(privkey);
703
gnutls_openpgp_privkey_deinit(privkey);
704
if(debug){
705
fprintf_plus(stderr, "This OpenPGP key implies using"
706
" a GnuTLS security parameter \"%s\".\n",
707
safe_string(gnutls_sec_param_get_name
708
(sec_param)));
709
}
710
}
630
privkey = NULL;
711
631
}
712
}
713
if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
714
/* Err on the side of caution */
715
sec_param = GNUTLS_SEC_PARAM_ULTRA;
716
if(debug){
717
fprintf_plus(stderr, "Falling back to security parameter"
718
" \"%s\"\n",
719
safe_string(gnutls_sec_param_get_name
720
(sec_param)));
632
free(buffer.data);
633
buffer.data = NULL;
634
if(privkey != NULL){
635
/* Use private key to suggest an appropriate sec_param */
636
sec_param = gnutls_openpgp_privkey_sec_param(privkey);
637
gnutls_openpgp_privkey_deinit(privkey);
638
if(debug){
639
fprintf_plus(stderr, "This OpenPGP key implies using a"
640
" GnuTLS security parameter \"%s\".\n",
641
safe_string(gnutls_sec_param_get_name
642
(sec_param)));
643
}
721
644
}
722
645
}
723
646
}
724
uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
725
if(uret != 0){
726
mc->dh_bits = uret;
647
if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
648
/* Err on the side of caution */
649
sec_param = GNUTLS_SEC_PARAM_ULTRA;
727
650
if(debug){
728
fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
729
" implies %u DH bits; using that.\n",
651
fprintf_plus(stderr, "Falling back to security parameter"
652
" \"%s\"\n",
730
653
safe_string(gnutls_sec_param_get_name
731
(sec_param)),
732
mc->dh_bits);
654
(sec_param)));
733
655
}
734
} else {
735
fprintf_plus(stderr, "Failed to get implied number of DH"
736
" bits for security parameter \"%s\"): %s\n",
656
}
657
}
658
uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
659
if(uret != 0){
660
mc->dh_bits = uret;
661
if(debug){
662
fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
663
" implies %u DH bits; using that.\n",
737
664
safe_string(gnutls_sec_param_get_name
738
665
(sec_param)),
739
safer_gnutls_strerror(ret));
740
goto globalfail;
666
mc->dh_bits);
741
667
}
742
} else if(debug){
743
fprintf_plus(stderr, "DH bits explicitly set to %u\n",
744
mc->dh_bits);
745
}
746
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
747
if(ret != GNUTLS_E_SUCCESS){
748
fprintf_plus(stderr, "Error in GnuTLS prime generation (%u"
749
" bits): %s\n", mc->dh_bits,
668
} else {
669
fprintf_plus(stderr, "Failed to get implied number of DH"
670
" bits for security parameter \"%s\"): %s\n",
671
safe_string(gnutls_sec_param_get_name(sec_param)),
750
672
safer_gnutls_strerror(ret));
751
673
goto globalfail;
752
674
}
753
}
675
} else if(debug){
676
fprintf_plus(stderr, "DH bits explicitly set to %u\n",
677
mc->dh_bits);
678
}
679
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
680
if(ret != GNUTLS_E_SUCCESS){
681
fprintf_plus(stderr, "Error in GnuTLS prime generation (%u bits):"
682
" %s\n", mc->dh_bits, safer_gnutls_strerror(ret));
683
goto globalfail;
684
}
685
754
686
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
755
687
756
688
return 0;
758
690
globalfail:
759
691
760
692
gnutls_certificate_free_credentials(mc->cred);
693
gnutls_global_deinit();
761
694
gnutls_dh_params_deinit(mc->dh_params);
762
695
return -1;
763
696
}
815
748
/* ignore client certificate if any. */
816
749
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
817
750
751
gnutls_dh_set_prime_bits(*session, mc->dh_bits);
752
818
753
return 0;
819
754
}
820
755
822
757
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
823
758
__attribute__((unused)) const char *txt){}
824
759
825
/* Set effective uid to 0, return errno */
826
__attribute__((warn_unused_result))
827
int raise_privileges(void){
828
int old_errno = errno;
829
int ret = 0;
830
if(seteuid(0) == -1){
831
ret = errno;
832
}
833
errno = old_errno;
834
return ret;
835
}
836
837
/* Set effective and real user ID to 0. Return errno. */
838
__attribute__((warn_unused_result))
839
int raise_privileges_permanently(void){
840
int old_errno = errno;
841
int ret = raise_privileges();
842
if(ret != 0){
843
errno = old_errno;
844
return ret;
845
}
846
if(setuid(0) == -1){
847
ret = errno;
848
}
849
errno = old_errno;
850
return ret;
851
}
852
853
/* Set effective user ID to unprivileged saved user ID */
854
__attribute__((warn_unused_result))
855
int lower_privileges(void){
856
int old_errno = errno;
857
int ret = 0;
858
if(seteuid(uid) == -1){
859
ret = errno;
860
}
861
errno = old_errno;
862
return ret;
863
}
864
865
/* Lower privileges permanently */
866
__attribute__((warn_unused_result))
867
int lower_privileges_permanently(void){
868
int old_errno = errno;
869
int ret = 0;
870
if(setuid(uid) == -1){
871
ret = errno;
872
}
873
errno = old_errno;
874
return ret;
875
}
876
877
/* Helper function to add_local_route() and delete_local_route() */
878
__attribute__((nonnull, warn_unused_result))
879
static bool add_delete_local_route(const bool add,
880
const char *address,
881
AvahiIfIndex if_index){
882
int ret;
883
char helper[] = "mandos-client-iprouteadddel";
884
char add_arg[] = "add";
885
char delete_arg[] = "delete";
886
char debug_flag[] = "--debug";
887
char *pluginhelperdir = getenv("MANDOSPLUGINHELPERDIR");
888
if(pluginhelperdir == NULL){
889
if(debug){
890
fprintf_plus(stderr, "MANDOSPLUGINHELPERDIR environment"
891
" variable not set; cannot run helper\n");
892
}
893
return false;
894
}
895
896
char interface[IF_NAMESIZE];
897
if(if_indextoname((unsigned int)if_index, interface) == NULL){
898
perror_plus("if_indextoname");
899
return false;
900
}
901
902
int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
903
if(devnull == -1){
904
perror_plus("open(\"/dev/null\", O_RDONLY)");
905
return false;
906
}
907
pid_t pid = fork();
908
if(pid == 0){
909
/* Child */
910
/* Raise privileges */
911
errno = raise_privileges_permanently();
912
if(errno != 0){
913
perror_plus("Failed to raise privileges");
914
/* _exit(EX_NOPERM); */
915
} else {
916
/* Set group */
917
errno = 0;
918
ret = setgid(0);
919
if(ret == -1){
920
perror_plus("setgid");
921
_exit(EX_NOPERM);
922
}
923
/* Reset supplementary groups */
924
errno = 0;
925
ret = setgroups(0, NULL);
926
if(ret == -1){
927
perror_plus("setgroups");
928
_exit(EX_NOPERM);
929
}
930
}
931
ret = dup2(devnull, STDIN_FILENO);
932
if(ret == -1){
933
perror_plus("dup2(devnull, STDIN_FILENO)");
934
_exit(EX_OSERR);
935
}
936
ret = close(devnull);
937
if(ret == -1){
938
perror_plus("close");
939
_exit(EX_OSERR);
940
}
941
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
942
if(ret == -1){
943
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
944
_exit(EX_OSERR);
945
}
946
int helperdir_fd = (int)TEMP_FAILURE_RETRY(open(pluginhelperdir,
947
O_RDONLY
948
| O_DIRECTORY
949
| O_PATH
950
| O_CLOEXEC));
951
if(helperdir_fd == -1){
952
perror_plus("open");
953
_exit(EX_UNAVAILABLE);
954
}
955
int helper_fd = (int)TEMP_FAILURE_RETRY(openat(helperdir_fd,
956
helper, O_RDONLY));
957
if(helper_fd == -1){
958
perror_plus("openat");
959
close(helperdir_fd);
960
_exit(EX_UNAVAILABLE);
961
}
962
close(helperdir_fd);
963
#ifdef __GNUC__
964
#pragma GCC diagnostic push
965
#pragma GCC diagnostic ignored "-Wcast-qual"
966
#endif
967
if(fexecve(helper_fd, (char *const [])
968
{ helper, add ? add_arg : delete_arg, (char *)address,
969
interface, debug ? debug_flag : NULL, NULL },
970
environ) == -1){
971
#ifdef __GNUC__
972
#pragma GCC diagnostic pop
973
#endif
974
perror_plus("fexecve");
975
_exit(EXIT_FAILURE);
976
}
977
}
978
if(pid == -1){
979
perror_plus("fork");
980
return false;
981
}
982
int status;
983
pid_t pret = -1;
984
errno = 0;
985
do {
986
pret = waitpid(pid, &status, 0);
987
if(pret == -1 and errno == EINTR and quit_now){
988
int errno_raising = 0;
989
if((errno = raise_privileges()) != 0){
990
errno_raising = errno;
991
perror_plus("Failed to raise privileges in order to"
992
" kill helper program");
993
}
994
if(kill(pid, SIGTERM) == -1){
995
perror_plus("kill");
996
}
997
if((errno_raising == 0) and (errno = lower_privileges()) != 0){
998
perror_plus("Failed to lower privileges after killing"
999
" helper program");
1000
}
1001
return false;
1002
}
1003
} while(pret == -1 and errno == EINTR);
1004
if(pret == -1){
1005
perror_plus("waitpid");
1006
return false;
1007
}
1008
if(WIFEXITED(status)){
1009
if(WEXITSTATUS(status) != 0){
1010
fprintf_plus(stderr, "Error: iprouteadddel exited"
1011
" with status %d\n", WEXITSTATUS(status));
1012
return false;
1013
}
1014
return true;
1015
}
1016
if(WIFSIGNALED(status)){
1017
fprintf_plus(stderr, "Error: iprouteadddel died by"
1018
" signal %d\n", WTERMSIG(status));
1019
return false;
1020
}
1021
fprintf_plus(stderr, "Error: iprouteadddel crashed\n");
1022
return false;
1023
}
1024
1025
__attribute__((nonnull, warn_unused_result))
1026
static bool add_local_route(const char *address,
1027
AvahiIfIndex if_index){
1028
if(debug){
1029
fprintf_plus(stderr, "Adding route to %s\n", address);
1030
}
1031
return add_delete_local_route(true, address, if_index);
1032
}
1033
1034
__attribute__((nonnull, warn_unused_result))
1035
static bool delete_local_route(const char *address,
1036
AvahiIfIndex if_index){
1037
if(debug){
1038
fprintf_plus(stderr, "Removing route to %s\n", address);
1039
}
1040
return add_delete_local_route(false, address, if_index);
1041
}
1042
1043
760
/* Called when a Mandos server is found */
1044
761
__attribute__((nonnull, warn_unused_result))
1045
762
static int start_mandos_communication(const char *ip, in_port_t port,
1056
773
int retval = -1;
1057
774
gnutls_session_t session;
1058
775
int pf; /* Protocol family */
1059
bool route_added = false;
1060
776
1061
777
errno = 0;
1062
778
1084
800
bool match = false;
1085
801
{
1086
802
char *interface = NULL;
1087
while((interface = argz_next(mc->interfaces,
1088
mc->interfaces_size,
1089
interface))){
803
while((interface=argz_next(mc->interfaces, mc->interfaces_size,
804
interface))){
1090
805
if(if_nametoindex(interface) == (unsigned int)if_index){
1091
806
match = true;
1092
807
break;
1121
836
PRIuMAX "\n", ip, (uintmax_t)port);
1122
837
}
1123
838
1124
tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
839
tcp_sd = socket(pf, SOCK_STREAM, 0);
1125
840
if(tcp_sd < 0){
1126
841
int e = errno;
1127
842
perror_plus("socket");
1134
849
goto mandos_end;
1135
850
}
1136
851
852
memset(&to, 0, sizeof(to));
1137
853
if(af == AF_INET6){
1138
struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)&to;
1139
*to6 = (struct sockaddr_in6){ .sin6_family = (sa_family_t)af };
1140
ret = inet_pton(af, ip, &to6->sin6_addr);
854
((struct sockaddr_in6 *)&to)->sin6_family = (sa_family_t)af;
855
ret = inet_pton(af, ip, &((struct sockaddr_in6 *)&to)->sin6_addr);
1141
856
} else { /* IPv4 */
1142
struct sockaddr_in *to4 = (struct sockaddr_in *)&to;
1143
*to4 = (struct sockaddr_in){ .sin_family = (sa_family_t)af };
1144
ret = inet_pton(af, ip, &to4->sin_addr);
857
((struct sockaddr_in *)&to)->sin_family = (sa_family_t)af;
858
ret = inet_pton(af, ip, &((struct sockaddr_in *)&to)->sin_addr);
1145
859
}
1146
860
if(ret < 0 ){
1147
861
int e = errno;
1217
931
goto mandos_end;
1218
932
}
1219
933
1220
while(true){
1221
if(af == AF_INET6){
1222
ret = connect(tcp_sd, (struct sockaddr *)&to,
1223
sizeof(struct sockaddr_in6));
1224
} else {
1225
ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
1226
sizeof(struct sockaddr_in));
1227
}
1228
if(ret < 0){
1229
if(((errno == ENETUNREACH) or (errno == EHOSTUNREACH))
1230
and if_index != AVAHI_IF_UNSPEC
1231
and connect_to == NULL
1232
and not route_added and
1233
((af == AF_INET6 and not
1234
IN6_IS_ADDR_LINKLOCAL(&(((struct sockaddr_in6 *)
1235
&to)->sin6_addr)))
1236
or (af == AF_INET and
1237
/* Not a a IPv4LL address */
1238
(ntohl(((struct sockaddr_in *)&to)->sin_addr.s_addr)
1239
& 0xFFFF0000L) != 0xA9FE0000L))){
1240
/* Work around Avahi bug - Avahi does not announce link-local
1241
addresses if it has a global address, so local hosts with
1242
*only* a link-local address (e.g. Mandos clients) cannot
1243
connect to a Mandos server announced by Avahi on a server
1244
host with a global address. Work around this by retrying
1245
with an explicit route added with the server's address.
1246
1247
Avahi bug reference:
1248
https://lists.freedesktop.org/archives/avahi/2010-February/001833.html
1249
https://bugs.debian.org/587961
1250
*/
1251
if(debug){
1252
fprintf_plus(stderr, "Mandos server unreachable, trying"
1253
" direct route\n");
1254
}
1255
int e = errno;
1256
route_added = add_local_route(ip, if_index);
1257
if(route_added){
1258
continue;
1259
}
1260
errno = e;
1261
}
1262
if(errno != ECONNREFUSED or debug){
1263
int e = errno;
1264
perror_plus("connect");
1265
errno = e;
1266
}
1267
goto mandos_end;
1268
}
1269
1270
if(quit_now){
1271
errno = EINTR;
1272
goto mandos_end;
1273
}
1274
break;
934
if(af == AF_INET6){
935
ret = connect(tcp_sd, (struct sockaddr *)&to,
936
sizeof(struct sockaddr_in6));
937
} else {
938
ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
939
sizeof(struct sockaddr_in));
940
}
941
if(ret < 0){
942
if((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
943
int e = errno;
944
perror_plus("connect");
945
errno = e;
946
}
947
goto mandos_end;
948
}
949
950
if(quit_now){
951
errno = EINTR;
952
goto mandos_end;
1275
953
}
1276
954
1277
955
const char *out = mandos_protocol_version;
1431
1109
&decrypted_buffer, mc);
1432
1110
if(decrypted_buffer_size >= 0){
1433
1111
1434
clearerr(stdout);
1435
1112
written = 0;
1436
1113
while(written < (size_t) decrypted_buffer_size){
1437
1114
if(quit_now){
1453
1130
}
1454
1131
written += (size_t)ret;
1455
1132
}
1456
ret = fflush(stdout);
1457
if(ret != 0){
1458
int e = errno;
1459
if(debug){
1460
fprintf_plus(stderr, "Error writing encrypted data: %s\n",
1461
strerror(errno));
1462
}
1463
errno = e;
1464
goto mandos_end;
1465
}
1466
1133
retval = 0;
1467
1134
}
1468
1135
}
1471
1138
1472
1139
mandos_end:
1473
1140
{
1474
if(route_added){
1475
if(not delete_local_route(ip, if_index)){
1476
fprintf_plus(stderr, "Failed to delete local route to %s on"
1477
" interface %d", ip, if_index);
1478
}
1479
}
1480
1141
int e = errno;
1481
1142
free(decrypted_buffer);
1482
1143
free(buffer);
1483
1144
if(tcp_sd >= 0){
1484
ret = close(tcp_sd);
1145
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
1485
1146
}
1486
1147
if(ret == -1){
1487
1148
if(e == 0){
1499
1160
return retval;
1500
1161
}
1501
1162
1163
__attribute__((nonnull))
1502
1164
static void resolve_callback(AvahiSServiceResolver *r,
1503
1165
AvahiIfIndex interface,
1504
1166
AvahiProtocol proto,
1641
1303
__attribute__((nonnull, warn_unused_result))
1642
1304
bool get_flags(const char *ifname, struct ifreq *ifr){
1643
1305
int ret;
1644
int old_errno;
1306
error_t ret_errno;
1645
1307
1646
1308
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1647
1309
if(s < 0){
1648
old_errno = errno;
1310
ret_errno = errno;
1649
1311
perror_plus("socket");
1650
errno = old_errno;
1312
errno = ret_errno;
1651
1313
return false;
1652
1314
}
1653
strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
1654
ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
1315
strcpy(ifr->ifr_name, ifname);
1655
1316
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1656
1317
if(ret == -1){
1657
1318
if(debug){
1658
old_errno = errno;
1319
ret_errno = errno;
1659
1320
perror_plus("ioctl SIOCGIFFLAGS");
1660
errno = old_errno;
1661
}
1662
if((close(s) == -1) and debug){
1663
old_errno = errno;
1664
perror_plus("close");
1665
errno = old_errno;
1321
errno = ret_errno;
1666
1322
}
1667
1323
return false;
1668
1324
}
1669
if((close(s) == -1) and debug){
1670
old_errno = errno;
1671
perror_plus("close");
1672
errno = old_errno;
1673
}
1674
1325
return true;
1675
1326
}
1676
1327
1918
1569
}
1919
1570
}
1920
1571
1572
/* Set effective uid to 0, return errno */
1573
__attribute__((warn_unused_result))
1574
error_t raise_privileges(void){
1575
error_t old_errno = errno;
1576
error_t ret_errno = 0;
1577
if(seteuid(0) == -1){
1578
ret_errno = errno;
1579
}
1580
errno = old_errno;
1581
return ret_errno;
1582
}
1583
1584
/* Set effective and real user ID to 0. Return errno. */
1585
__attribute__((warn_unused_result))
1586
error_t raise_privileges_permanently(void){
1587
error_t old_errno = errno;
1588
error_t ret_errno = raise_privileges();
1589
if(ret_errno != 0){
1590
errno = old_errno;
1591
return ret_errno;
1592
}
1593
if(setuid(0) == -1){
1594
ret_errno = errno;
1595
}
1596
errno = old_errno;
1597
return ret_errno;
1598
}
1599
1600
/* Set effective user ID to unprivileged saved user ID */
1601
__attribute__((warn_unused_result))
1602
error_t lower_privileges(void){
1603
error_t old_errno = errno;
1604
error_t ret_errno = 0;
1605
if(seteuid(uid) == -1){
1606
ret_errno = errno;
1607
}
1608
errno = old_errno;
1609
return ret_errno;
1610
}
1611
1612
/* Lower privileges permanently */
1613
__attribute__((warn_unused_result))
1614
error_t lower_privileges_permanently(void){
1615
error_t old_errno = errno;
1616
error_t ret_errno = 0;
1617
if(setuid(uid) == -1){
1618
ret_errno = errno;
1619
}
1620
errno = old_errno;
1621
return ret_errno;
1622
}
1623
1921
1624
__attribute__((nonnull))
1922
1625
void run_network_hooks(const char *mode, const char *interface,
1923
1626
const float delay){
1924
1627
struct dirent **direntries = NULL;
1925
1628
if(hookdir_fd == -1){
1926
hookdir_fd = open(hookdir, O_RDONLY | O_DIRECTORY | O_PATH
1927
| O_CLOEXEC);
1629
hookdir_fd = open(hookdir, O_RDONLY);
1928
1630
if(hookdir_fd == -1){
1929
1631
if(errno == ENOENT){
1930
1632
if(debug){
1937
1639
return;
1938
1640
}
1939
1641
}
1940
int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
1941
if(devnull == -1){
1942
perror_plus("open(\"/dev/null\", O_RDONLY)");
1943
return;
1944
}
1642
#ifdef __GLIBC__
1643
#if __GLIBC_PREREQ(2, 15)
1945
1644
int numhooks = scandirat(hookdir_fd, ".", &direntries,
1946
1645
runnable_hook, alphasort);
1646
#else /* not __GLIBC_PREREQ(2, 15) */
1647
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1648
alphasort);
1649
#endif /* not __GLIBC_PREREQ(2, 15) */
1650
#else /* not __GLIBC__ */
1651
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1652
alphasort);
1653
#endif /* not __GLIBC__ */
1947
1654
if(numhooks == -1){
1948
1655
perror_plus("scandir");
1949
close(devnull);
1950
1656
return;
1951
1657
}
1952
1658
struct dirent *direntry;
1953
1659
int ret;
1660
int devnull = open("/dev/null", O_RDONLY);
1954
1661
for(int i = 0; i < numhooks; i++){
1955
1662
direntry = direntries[i];
1956
1663
if(debug){
1980
1687
perror_plus("setgroups");
1981
1688
_exit(EX_NOPERM);
1982
1689
}
1690
ret = dup2(devnull, STDIN_FILENO);
1691
if(ret == -1){
1692
perror_plus("dup2(devnull, STDIN_FILENO)");
1693
_exit(EX_OSERR);
1694
}
1695
ret = close(devnull);
1696
if(ret == -1){
1697
perror_plus("close");
1698
_exit(EX_OSERR);
1699
}
1700
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
1701
if(ret == -1){
1702
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
1703
_exit(EX_OSERR);
1704
}
1983
1705
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1984
1706
if(ret == -1){
1985
1707
perror_plus("setenv");
2020
1742
_exit(EX_OSERR);
2021
1743
}
2022
1744
}
2023
int hook_fd = (int)TEMP_FAILURE_RETRY(openat(hookdir_fd,
2024
direntry->d_name,
2025
O_RDONLY));
1745
int hook_fd = openat(hookdir_fd, direntry->d_name, O_RDONLY);
2026
1746
if(hook_fd == -1){
2027
1747
perror_plus("openat");
2028
1748
_exit(EXIT_FAILURE);
2029
1749
}
2030
if(close(hookdir_fd) == -1){
1750
if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
2031
1751
perror_plus("close");
2032
1752
_exit(EXIT_FAILURE);
2033
1753
}
2034
ret = dup2(devnull, STDIN_FILENO);
2035
if(ret == -1){
2036
perror_plus("dup2(devnull, STDIN_FILENO)");
2037
_exit(EX_OSERR);
2038
}
2039
ret = close(devnull);
2040
if(ret == -1){
2041
perror_plus("close");
2042
_exit(EX_OSERR);
2043
}
2044
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
2045
if(ret == -1){
2046
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
2047
_exit(EX_OSERR);
2048
}
2049
1754
if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
2050
1755
environ) == -1){
2051
1756
perror_plus("fexecve");
2091
1796
free(direntry);
2092
1797
}
2093
1798
free(direntries);
2094
if(close(hookdir_fd) == -1){
1799
if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
2095
1800
perror_plus("close");
2096
1801
} else {
2097
1802
hookdir_fd = -1;
2100
1805
}
2101
1806
2102
1807
__attribute__((nonnull, warn_unused_result))
2103
int bring_up_interface(const char *const interface,
2104
const float delay){
2105
int old_errno = errno;
1808
error_t bring_up_interface(const char *const interface,
1809
const float delay){
1810
error_t old_errno = errno;
2106
1811
int ret;
2107
1812
struct ifreq network;
2108
1813
unsigned int if_index = if_nametoindex(interface);
2118
1823
}
2119
1824
2120
1825
if(not interface_is_up(interface)){
2121
int ret_errno = 0;
2122
int ioctl_errno = 0;
1826
error_t ret_errno = 0, ioctl_errno = 0;
2123
1827
if(not get_flags(interface, &network)){
2124
1828
ret_errno = errno;
2125
1829
fprintf_plus(stderr, "Failed to get flags for interface "
2138
1842
}
2139
1843
2140
1844
if(quit_now){
2141
ret = close(sd);
1845
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2142
1846
if(ret == -1){
2143
1847
perror_plus("close");
2144
1848
}
2194
1898
}
2195
1899
2196
1900
/* Close the socket */
2197
ret = close(sd);
1901
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2198
1902
if(ret == -1){
2199
1903
perror_plus("close");
2200
1904
}
2212
1916
2213
1917
/* Sleep checking until interface is running.
2214
1918
Check every 0.25s, up to total time of delay */
2215
for(int i = 0; i < delay * 4; i++){
1919
for(int i=0; i < delay * 4; i++){
2216
1920
if(interface_is_running(interface)){
2217
1921
break;
2218
1922
}
2228
1932
}
2229
1933
2230
1934
__attribute__((nonnull, warn_unused_result))
2231
int take_down_interface(const char *const interface){
2232
int old_errno = errno;
1935
error_t take_down_interface(const char *const interface){
1936
error_t old_errno = errno;
2233
1937
struct ifreq network;
2234
1938
unsigned int if_index = if_nametoindex(interface);
2235
1939
if(if_index == 0){
2238
1942
return ENXIO;
2239
1943
}
2240
1944
if(interface_is_up(interface)){
2241
int ret_errno = 0;
2242
int ioctl_errno = 0;
1945
error_t ret_errno = 0, ioctl_errno = 0;
2243
1946
if(not get_flags(interface, &network) and debug){
2244
1947
ret_errno = errno;
2245
1948
fprintf_plus(stderr, "Failed to get flags for interface "
2283
1986
}
2284
1987
2285
1988
/* Close the socket */
2286
int ret = close(sd);
1989
int ret = (int)TEMP_FAILURE_RETRY(close(sd));
2287
1990
if(ret == -1){
2288
1991
perror_plus("close");
2289
1992
}
2305
2008
2306
2009
int main(int argc, char *argv[]){
2307
2010
mandos_context mc = { .server = NULL, .dh_bits = 0,
2308
.priority = "SECURE256:!CTYPE-X.509"
2309
":+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256",
2310
.current_server = NULL, .interfaces = NULL,
2311
.interfaces_size = 0 };
2011
.priority = "SECURE256:!CTYPE-X.509:"
2012
"+CTYPE-OPENPGP:!RSA", .current_server = NULL,
2013
.interfaces = NULL, .interfaces_size = 0 };
2312
2014
AvahiSServiceBrowser *sb = NULL;
2313
2015
error_t ret_errno;
2314
2016
int ret;
2323
2025
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
2324
2026
const char *seckey = PATHDIR "/" SECKEY;
2325
2027
const char *pubkey = PATHDIR "/" PUBKEY;
2326
const char *dh_params_file = NULL;
2327
2028
char *interfaces_hooks = NULL;
2328
2029
2329
2030
bool gnutls_initialized = false;
2382
2083
.doc = "Bit length of the prime number used in the"
2383
2084
" Diffie-Hellman key exchange",
2384
2085
.group = 2 },
2385
{ .name = "dh-params", .key = 134,
2386
.arg = "FILE",
2387
.doc = "PEM-encoded PKCS#3 file with pre-generated parameters"
2388
" for the Diffie-Hellman key exchange",
2389
.group = 2 },
2390
2086
{ .name = "priority", .key = 130,
2391
2087
.arg = "STRING",
2392
2088
.doc = "GnuTLS priority string for the TLS handshake",
2447
2143
}
2448
2144
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
2449
2145
break;
2450
case 134: /* --dh-params */
2451
dh_params_file = arg;
2452
break;
2453
2146
case 130: /* --priority */
2454
2147
mc.priority = arg;
2455
2148
break;
2495
2188
.args_doc = "",
2496
2189
.doc = "Mandos client -- Get and decrypt"
2497
2190
" passwords from a Mandos server" };
2498
ret_errno = argp_parse(&argp, argc, argv,
2499
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2500
switch(ret_errno){
2191
ret = argp_parse(&argp, argc, argv,
2192
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2193
switch(ret){
2501
2194
case 0:
2502
2195
break;
2503
2196
case ENOMEM:
2504
2197
default:
2505
errno = ret_errno;
2198
errno = ret;
2506
2199
perror_plus("argp_parse");
2507
2200
exitcode = EX_OSERR;
2508
2201
goto end;
2511
2204
goto end;
2512
2205
}
2513
2206
}
2514
2207
2515
2208
{
2516
2209
/* Work around Debian bug #633582:
2517
<https://bugs.debian.org/633582> */
2210
<http://bugs.debian.org/633582> */
2518
2211
2519
2212
/* Re-raise privileges */
2520
ret = raise_privileges();
2521
if(ret != 0){
2522
errno = ret;
2213
ret_errno = raise_privileges();
2214
if(ret_errno != 0){
2215
errno = ret_errno;
2523
2216
perror_plus("Failed to raise privileges");
2524
2217
} else {
2525
2218
struct stat st;
2541
2234
}
2542
2235
}
2543
2236
}
2544
close(seckey_fd);
2237
TEMP_FAILURE_RETRY(close(seckey_fd));
2545
2238
}
2546
2239
}
2547
2240
2548
2241
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2549
2242
int pubkey_fd = open(pubkey, O_RDONLY);
2550
2243
if(pubkey_fd == -1){
2562
2255
}
2563
2256
}
2564
2257
}
2565
close(pubkey_fd);
2566
}
2567
}
2568
2569
if(dh_params_file != NULL
2570
and strcmp(dh_params_file, PATHDIR "/dhparams.pem" ) == 0){
2571
int dhparams_fd = open(dh_params_file, O_RDONLY);
2572
if(dhparams_fd == -1){
2573
perror_plus("open");
2574
} else {
2575
ret = (int)TEMP_FAILURE_RETRY(fstat(dhparams_fd, &st));
2576
if(ret == -1){
2577
perror_plus("fstat");
2578
} else {
2579
if(S_ISREG(st.st_mode)
2580
and st.st_uid == 0 and st.st_gid == 0){
2581
ret = fchown(dhparams_fd, uid, gid);
2582
if(ret == -1){
2583
perror_plus("fchown");
2584
}
2585
}
2586
}
2587
close(dhparams_fd);
2588
}
2589
}
2590
2258
TEMP_FAILURE_RETRY(close(pubkey_fd));
2259
}
2260
}
2261
2591
2262
/* Lower privileges */
2592
ret = lower_privileges();
2593
if(ret != 0){
2594
errno = ret;
2263
ret_errno = lower_privileges();
2264
if(ret_errno != 0){
2265
errno = ret_errno;
2595
2266
perror_plus("Failed to lower privileges");
2596
2267
}
2597
2268
}
2767
2438
errno = bring_up_interface(interface, delay);
2768
2439
if(not interface_was_up){
2769
2440
if(errno != 0){
2770
fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
2771
" %s\n", interface, strerror(errno));
2441
perror_plus("Failed to bring up interface");
2772
2442
} else {
2773
2443
errno = argz_add(&interfaces_to_take_down,
2774
2444
&interfaces_to_take_down_size,
2797
2467
goto end;
2798
2468
}
2799
2469
2800
ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
2470
ret = init_gnutls_global(pubkey, seckey, &mc);
2801
2471
if(ret == -1){
2802
2472
fprintf_plus(stderr, "init_gnutls_global failed\n");
2803
2473
exitcode = EX_UNAVAILABLE;
2925
2595
2926
2596
/* Allocate a new server */
2927
2597
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
2928
&config, NULL, NULL, &ret);
2598
&config, NULL, NULL, &ret_errno);
2929
2599
2930
2600
/* Free the Avahi configuration data */
2931
2601
avahi_server_config_free(&config);
2934
2604
/* Check if creating the Avahi server object succeeded */
2935
2605
if(mc.server == NULL){
2936
2606
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2937
avahi_strerror(ret));
2607
avahi_strerror(ret_errno));
2938
2608
exitcode = EX_UNAVAILABLE;
2939
2609
goto end;
2940
2610
}
2975
2645
end:
2976
2646
2977
2647
if(debug){
2978
if(signal_received){
2979
fprintf_plus(stderr, "%s exiting due to signal %d: %s\n",
2980
argv[0], signal_received,
2981
strsignal(signal_received));
2982
} else {
2983
fprintf_plus(stderr, "%s exiting\n", argv[0]);
2984
}
2648
fprintf_plus(stderr, "%s exiting\n", argv[0]);
2985
2649
}
2986
2650
2987
2651
/* Cleanup things */
2998
2662
2999
2663
if(gnutls_initialized){
3000
2664
gnutls_certificate_free_credentials(mc.cred);
2665
gnutls_global_deinit();
3001
2666
gnutls_dh_params_deinit(mc.dh_params);
3002
2667
}
3003
2668
3026
2691
3027
2692
/* Re-raise privileges */
3028
2693
{
3029
ret = raise_privileges();
3030
if(ret != 0){
3031
errno = ret;
2694
ret_errno = raise_privileges();
2695
if(ret_errno != 0){
2696
errno = ret_errno;
3032
2697
perror_plus("Failed to raise privileges");
3033
2698
} else {
3034
2699
3039
2704
/* Take down the network interfaces which were brought up */
3040
2705
{
3041
2706
char *interface = NULL;
3042
while((interface = argz_next(interfaces_to_take_down,
3043
interfaces_to_take_down_size,
3044
interface))){
3045
ret = take_down_interface(interface);
3046
if(ret != 0){
3047
errno = ret;
2707
while((interface=argz_next(interfaces_to_take_down,
2708
interfaces_to_take_down_size,
2709
interface))){
2710
ret_errno = take_down_interface(interface);
2711
if(ret_errno != 0){
2712
errno = ret_errno;
3048
2713
perror_plus("Failed to take down interface");
3049
2714
}
3050
2715
}
3055
2720
}
3056
2721
}
3057
2722
3058
ret = lower_privileges_permanently();
3059
if(ret != 0){
3060
errno = ret;
2723
ret_errno = lower_privileges_permanently();
2724
if(ret_errno != 0){
2725
errno = ret_errno;
3061
2726
perror_plus("Failed to lower privileges permanently");
3062
2727
}
3063
2728
}
3065
2730
free(interfaces_to_take_down);
3066
2731
free(interfaces_hooks);
3067
2732
3068
void clean_dir_at(int base, const char * const dirname,
3069
uintmax_t level){
3070
struct dirent **direntries = NULL;
3071
int dret;
3072
int dir_fd = (int)TEMP_FAILURE_RETRY(openat(base, dirname,
3073
O_RDONLY
3074
| O_NOFOLLOW
3075
| O_DIRECTORY
3076
| O_PATH));
3077
if(dir_fd == -1){
3078
perror_plus("open");
3079
return;
3080
}
3081
int numentries = scandirat(dir_fd, ".", &direntries,
3082
notdotentries, alphasort);
3083
if(numentries >= 0){
3084
for(int i = 0; i < numentries; i++){
3085
if(debug){
3086
fprintf_plus(stderr, "Unlinking \"%s/%s\"\n",
3087
dirname, direntries[i]->d_name);
3088
}
3089
dret = unlinkat(dir_fd, direntries[i]->d_name, 0);
3090
if(dret == -1){
3091
if(errno == EISDIR){
3092
dret = unlinkat(dir_fd, direntries[i]->d_name,
3093
AT_REMOVEDIR);
3094
}
3095
if((dret == -1) and (errno == ENOTEMPTY)
3096
and (strcmp(direntries[i]->d_name, "private-keys-v1.d")
3097
== 0) and (level == 0)){
3098
/* Recurse only in this special case */
3099
clean_dir_at(dir_fd, direntries[i]->d_name, level+1);
3100
dret = 0;
3101
}
3102
if((dret == -1) and (errno != ENOENT)){
3103
fprintf_plus(stderr, "unlink(\"%s/%s\"): %s\n", dirname,
3104
direntries[i]->d_name, strerror(errno));
3105
}
3106
}
3107
free(direntries[i]);
3108
}
3109
3110
/* need to clean even if 0 because man page doesn't specify */
3111
free(direntries);
3112
dret = unlinkat(base, dirname, AT_REMOVEDIR);
3113
if(dret == -1 and errno != ENOENT){
3114
perror_plus("rmdir");
3115
}
3116
} else {
3117
perror_plus("scandirat");
3118
}
3119
close(dir_fd);
3120
}
3121
3122
2733
/* Removes the GPGME temp directory and all files inside */
3123
2734
if(tempdir != NULL){
3124
clean_dir_at(-1, tempdir, 0);
2735
struct dirent **direntries = NULL;
2736
int tempdir_fd = (int)TEMP_FAILURE_RETRY(open(tempdir, O_RDONLY |
2737
O_NOFOLLOW));
2738
if(tempdir_fd == -1){
2739
perror_plus("open");
2740
} else {
2741
#ifdef __GLIBC__
2742
#if __GLIBC_PREREQ(2, 15)
2743
int numentries = scandirat(tempdir_fd, ".", &direntries,
2744
notdotentries, alphasort);
2745
#else /* not __GLIBC_PREREQ(2, 15) */
2746
int numentries = scandir(tempdir, &direntries, notdotentries,
2747
alphasort);
2748
#endif /* not __GLIBC_PREREQ(2, 15) */
2749
#else /* not __GLIBC__ */
2750
int numentries = scandir(tempdir, &direntries, notdotentries,
2751
alphasort);
2752
#endif /* not __GLIBC__ */
2753
if(numentries >= 0){
2754
for(int i = 0; i < numentries; i++){
2755
ret = unlinkat(tempdir_fd, direntries[i]->d_name, 0);
2756
if(ret == -1){
2757
fprintf_plus(stderr, "unlinkat(open(\"%s\", O_RDONLY),"
2758
" \"%s\", 0): %s\n", tempdir,
2759
direntries[i]->d_name, strerror(errno));
2760
}
2761
free(direntries[i]);
2762
}
2763
2764
/* need to clean even if 0 because man page doesn't specify */
2765
free(direntries);
2766
if(numentries == -1){
2767
perror_plus("scandir");
2768
}
2769
ret = rmdir(tempdir);
2770
if(ret == -1 and errno != ENOENT){
2771
perror_plus("rmdir");
2772
}
2773
}
2774
TEMP_FAILURE_RETRY(close(tempdir_fd));
2775
}
3125
2776
}
3126
2777
3127
2778
if(quit_now){
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0