(root)/mandos/release
» Revision
237.7.289
(compared to revision 237.7.501)
: 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.7.289
- compare with another revision
- download diff
- download tarball
- view history from revision 237.7.289
- Committer: Teddy Hogeborn
- Date: 2015-01-25 00:02:51 UTC
- mto: (237.7.304 trunk)
- mto: This revision was merged to the branch mainline in revision 325.
- 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).
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,
272
266
return true;
273
267
}
274
268
275
/* Set effective uid to 0, return errno */
276
__attribute__((warn_unused_result))
277
int raise_privileges(void){
278
int old_errno = errno;
279
int ret = 0;
280
if(seteuid(0) == -1){
281
ret = errno;
282
}
283
errno = old_errno;
284
return ret;
285
}
286
287
/* Set effective and real user ID to 0. Return errno. */
288
__attribute__((warn_unused_result))
289
int raise_privileges_permanently(void){
290
int old_errno = errno;
291
int ret = raise_privileges();
292
if(ret != 0){
293
errno = old_errno;
294
return ret;
295
}
296
if(setuid(0) == -1){
297
ret = errno;
298
}
299
errno = old_errno;
300
return ret;
301
}
302
303
/* Set effective user ID to unprivileged saved user ID */
304
__attribute__((warn_unused_result))
305
int lower_privileges(void){
306
int old_errno = errno;
307
int ret = 0;
308
if(seteuid(uid) == -1){
309
ret = errno;
310
}
311
errno = old_errno;
312
return ret;
313
}
314
315
/* Lower privileges permanently */
316
__attribute__((warn_unused_result))
317
int lower_privileges_permanently(void){
318
int old_errno = errno;
319
int ret = 0;
320
if(setuid(uid) == -1){
321
ret = errno;
322
}
323
errno = old_errno;
324
return ret;
325
}
326
327
269
/*
328
270
* Initialize GPGME.
329
271
*/
349
291
return false;
350
292
}
351
293
352
/* Workaround for systems without a real-time clock; see also
353
Debian bug #894495: <https://bugs.debian.org/894495> */
354
do {
355
{
356
time_t currtime = time(NULL);
357
if(currtime != (time_t)-1){
358
struct tm tm;
359
if(gmtime_r(&currtime, &tm) == NULL) {
360
perror_plus("gmtime_r");
361
break;
362
}
363
if(tm.tm_year != 70 or tm.tm_mon != 0){
364
break;
365
}
366
if(debug){
367
fprintf_plus(stderr, "System clock is January 1970");
368
}
369
} else {
370
if(debug){
371
fprintf_plus(stderr, "System clock is invalid");
372
}
373
}
374
}
375
struct stat keystat;
376
ret = fstat(fd, &keystat);
377
if(ret != 0){
378
perror_plus("fstat");
379
break;
380
}
381
ret = raise_privileges();
382
if(ret != 0){
383
errno = ret;
384
perror_plus("Failed to raise privileges");
385
break;
386
}
387
if(debug){
388
fprintf_plus(stderr,
389
"Setting system clock to key file mtime");
390
}
391
time_t keytime = keystat.st_mtim.tv_sec;
392
if(stime(&keytime) != 0){
393
perror_plus("stime");
394
}
395
ret = lower_privileges();
396
if(ret != 0){
397
errno = ret;
398
perror_plus("Failed to lower privileges");
399
}
400
} while(false);
401
402
294
rc = gpgme_data_new_from_fd(&pgp_data, fd);
403
295
if(rc != GPG_ERR_NO_ERROR){
404
296
fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
412
304
gpgme_strsource(rc), gpgme_strerror(rc));
413
305
return false;
414
306
}
415
{
416
gpgme_import_result_t import_result
417
= gpgme_op_import_result(mc->ctx);
418
if((import_result->imported < 1
419
or import_result->not_imported > 0)
420
and import_result->unchanged == 0){
421
fprintf_plus(stderr, "bad gpgme_op_import_results:\n");
422
fprintf_plus(stderr,
423
"The total number of considered keys: %d\n",
424
import_result->considered);
425
fprintf_plus(stderr,
426
"The number of keys without user ID: %d\n",
427
import_result->no_user_id);
428
fprintf_plus(stderr,
429
"The total number of imported keys: %d\n",
430
import_result->imported);
431
fprintf_plus(stderr, "The number of imported RSA keys: %d\n",
432
import_result->imported_rsa);
433
fprintf_plus(stderr, "The number of unchanged keys: %d\n",
434
import_result->unchanged);
435
fprintf_plus(stderr, "The number of new user IDs: %d\n",
436
import_result->new_user_ids);
437
fprintf_plus(stderr, "The number of new sub keys: %d\n",
438
import_result->new_sub_keys);
439
fprintf_plus(stderr, "The number of new signatures: %d\n",
440
import_result->new_signatures);
441
fprintf_plus(stderr, "The number of new revocations: %d\n",
442
import_result->new_revocations);
443
fprintf_plus(stderr,
444
"The total number of secret keys read: %d\n",
445
import_result->secret_read);
446
fprintf_plus(stderr,
447
"The number of imported secret keys: %d\n",
448
import_result->secret_imported);
449
fprintf_plus(stderr,
450
"The number of unchanged secret keys: %d\n",
451
import_result->secret_unchanged);
452
fprintf_plus(stderr, "The number of keys not imported: %d\n",
453
import_result->not_imported);
454
for(gpgme_import_status_t import_status
455
= import_result->imports;
456
import_status != NULL;
457
import_status = import_status->next){
458
fprintf_plus(stderr, "Import status for key: %s\n",
459
import_status->fpr);
460
if(import_status->result != GPG_ERR_NO_ERROR){
461
fprintf_plus(stderr, "Import result: %s: %s\n",
462
gpgme_strsource(import_status->result),
463
gpgme_strerror(import_status->result));
464
}
465
fprintf_plus(stderr, "Key status:\n");
466
fprintf_plus(stderr,
467
import_status->status & GPGME_IMPORT_NEW
468
? "The key was new.\n"
469
: "The key was not new.\n");
470
fprintf_plus(stderr,
471
import_status->status & GPGME_IMPORT_UID
472
? "The key contained new user IDs.\n"
473
: "The key did not contain new user IDs.\n");
474
fprintf_plus(stderr,
475
import_status->status & GPGME_IMPORT_SIG
476
? "The key contained new signatures.\n"
477
: "The key did not contain new signatures.\n");
478
fprintf_plus(stderr,
479
import_status->status & GPGME_IMPORT_SUBKEY
480
? "The key contained new sub keys.\n"
481
: "The key did not contain new sub keys.\n");
482
fprintf_plus(stderr,
483
import_status->status & GPGME_IMPORT_SECRET
484
? "The key contained a secret key.\n"
485
: "The key did not contain a secret key.\n");
486
}
487
return false;
488
}
489
}
490
307
491
ret = close(fd);
308
ret = (int)TEMP_FAILURE_RETRY(close(fd));
492
309
if(ret == -1){
493
310
perror_plus("close");
494
311
}
533
350
/* Create new GPGME "context" */
534
351
rc = gpgme_new(&(mc->ctx));
535
352
if(rc != GPG_ERR_NO_ERROR){
536
fprintf_plus(stderr, "bad gpgme_new: %s: %s\n",
537
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));
538
356
return false;
539
357
}
540
358
576
394
/* Create new empty GPGME data buffer for the plaintext */
577
395
rc = gpgme_data_new(&dh_plain);
578
396
if(rc != GPG_ERR_NO_ERROR){
579
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",
580
399
gpgme_strsource(rc), gpgme_strerror(rc));
581
400
gpgme_data_release(dh_crypto);
582
401
return -1;
595
414
if(result == NULL){
596
415
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
597
416
} else {
598
if(result->unsupported_algorithm != NULL) {
599
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
600
result->unsupported_algorithm);
601
}
602
fprintf_plus(stderr, "Wrong key usage: %s\n",
603
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);
604
421
if(result->file_name != NULL){
605
422
fprintf_plus(stderr, "File name: %s\n", result->file_name);
606
423
}
607
608
for(gpgme_recipient_t r = result->recipients; r != NULL;
609
r = r->next){
424
gpgme_recipient_t recipient;
425
recipient = result->recipients;
426
while(recipient != NULL){
610
427
fprintf_plus(stderr, "Public key algorithm: %s\n",
611
gpgme_pubkey_algo_name(r->pubkey_algo));
612
fprintf_plus(stderr, "Key ID: %s\n", r->keyid);
428
gpgme_pubkey_algo_name
429
(recipient->pubkey_algo));
430
fprintf_plus(stderr, "Key ID: %s\n", recipient->keyid);
613
431
fprintf_plus(stderr, "Secret key available: %s\n",
614
r->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
432
recipient->status == GPG_ERR_NO_SECKEY
433
? "No" : "Yes");
434
recipient = recipient->next;
615
435
}
616
436
}
617
437
}
673
493
return plaintext_length;
674
494
}
675
495
676
__attribute__((warn_unused_result, const))
677
static const char *safe_string(const char *str){
678
if(str == NULL)
679
return "(unknown)";
680
return str;
681
}
682
683
496
__attribute__((warn_unused_result))
684
497
static const char *safer_gnutls_strerror(int value){
685
498
const char *ret = gnutls_strerror(value);
686
return safe_string(ret);
499
if(ret == NULL)
500
ret = "(unknown)";
501
return ret;
687
502
}
688
503
689
504
/* GnuTLS log function callback */
693
508
fprintf_plus(stderr, "GnuTLS: %s", string);
694
509
}
695
510
696
__attribute__((nonnull(1, 2, 4), warn_unused_result))
511
__attribute__((nonnull, warn_unused_result))
697
512
static int init_gnutls_global(const char *pubkeyfilename,
698
513
const char *seckeyfilename,
699
const char *dhparamsfilename,
700
514
mandos_context *mc){
701
515
int ret;
702
unsigned int uret;
703
516
704
517
if(debug){
705
518
fprintf_plus(stderr, "Initializing GnuTLS\n");
706
519
}
707
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
708
528
if(debug){
709
529
/* "Use a log level over 10 to enable all debugging options."
710
530
* - GnuTLS manual
718
538
if(ret != GNUTLS_E_SUCCESS){
719
539
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
720
540
safer_gnutls_strerror(ret));
541
gnutls_global_deinit();
721
542
return -1;
722
543
}
723
544
748
569
safer_gnutls_strerror(ret));
749
570
goto globalfail;
750
571
}
751
/* If a Diffie-Hellman parameters file was given, try to use it */
752
if(dhparamsfilename != NULL){
753
gnutls_datum_t params = { .data = NULL, .size = 0 };
754
do {
755
int dhpfile = open(dhparamsfilename, O_RDONLY);
756
if(dhpfile == -1){
757
perror_plus("open");
758
dhparamsfilename = NULL;
759
break;
760
}
761
size_t params_capacity = 0;
762
while(true){
763
params_capacity = incbuffer((char **)¶ms.data,
764
(size_t)params.size,
765
(size_t)params_capacity);
766
if(params_capacity == 0){
767
perror_plus("incbuffer");
768
free(params.data);
769
params.data = NULL;
770
dhparamsfilename = NULL;
771
break;
772
}
773
ssize_t bytes_read = read(dhpfile,
774
params.data + params.size,
775
BUFFER_SIZE);
776
/* EOF */
777
if(bytes_read == 0){
778
break;
779
}
780
/* check bytes_read for failure */
781
if(bytes_read < 0){
782
perror_plus("read");
783
free(params.data);
784
params.data = NULL;
785
dhparamsfilename = NULL;
786
break;
787
}
788
params.size += (unsigned int)bytes_read;
789
}
790
ret = close(dhpfile);
791
if(ret == -1){
792
perror_plus("close");
793
}
794
if(params.data == NULL){
795
dhparamsfilename = NULL;
796
}
797
if(dhparamsfilename == NULL){
798
break;
799
}
800
ret = gnutls_dh_params_import_pkcs3(mc->dh_params, ¶ms,
801
GNUTLS_X509_FMT_PEM);
802
if(ret != GNUTLS_E_SUCCESS){
803
fprintf_plus(stderr, "Failed to parse DH parameters in file"
804
" \"%s\": %s\n", dhparamsfilename,
805
safer_gnutls_strerror(ret));
806
dhparamsfilename = NULL;
807
}
808
free(params.data);
809
} while(false);
810
}
811
if(dhparamsfilename == NULL){
812
if(mc->dh_bits == 0){
813
/* Find out the optimal number of DH bits */
814
/* Try to read the private key file */
815
gnutls_datum_t buffer = { .data = NULL, .size = 0 };
816
do {
817
int secfile = open(seckeyfilename, O_RDONLY);
818
if(secfile == -1){
819
perror_plus("open");
820
break;
821
}
822
size_t buffer_capacity = 0;
823
while(true){
824
buffer_capacity = incbuffer((char **)&buffer.data,
825
(size_t)buffer.size,
826
(size_t)buffer_capacity);
827
if(buffer_capacity == 0){
828
perror_plus("incbuffer");
829
free(buffer.data);
830
buffer.data = NULL;
831
break;
832
}
833
ssize_t bytes_read = read(secfile,
834
buffer.data + buffer.size,
835
BUFFER_SIZE);
836
/* EOF */
837
if(bytes_read == 0){
838
break;
839
}
840
/* check bytes_read for failure */
841
if(bytes_read < 0){
842
perror_plus("read");
843
free(buffer.data);
844
buffer.data = NULL;
845
break;
846
}
847
buffer.size += (unsigned int)bytes_read;
848
}
849
close(secfile);
850
} while(false);
851
/* If successful, use buffer to parse private key */
852
gnutls_sec_param_t sec_param = GNUTLS_SEC_PARAM_ULTRA;
853
if(buffer.data != NULL){
854
{
855
gnutls_openpgp_privkey_t privkey = NULL;
856
ret = gnutls_openpgp_privkey_init(&privkey);
857
if(ret != GNUTLS_E_SUCCESS){
858
fprintf_plus(stderr, "Error initializing OpenPGP key"
859
" structure: %s",
860
safer_gnutls_strerror(ret));
861
free(buffer.data);
862
buffer.data = NULL;
863
} else {
864
ret = gnutls_openpgp_privkey_import
865
(privkey, &buffer, GNUTLS_OPENPGP_FMT_BASE64, "", 0);
866
if(ret != GNUTLS_E_SUCCESS){
867
fprintf_plus(stderr, "Error importing OpenPGP key : %s",
868
safer_gnutls_strerror(ret));
869
privkey = NULL;
870
}
871
free(buffer.data);
872
buffer.data = NULL;
873
if(privkey != NULL){
874
/* Use private key to suggest an appropriate
875
sec_param */
876
sec_param = gnutls_openpgp_privkey_sec_param(privkey);
877
gnutls_openpgp_privkey_deinit(privkey);
878
if(debug){
879
fprintf_plus(stderr, "This OpenPGP key implies using"
880
" a GnuTLS security parameter \"%s\".\n",
881
safe_string(gnutls_sec_param_get_name
882
(sec_param)));
883
}
884
}
885
}
886
}
887
if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
888
/* Err on the side of caution */
889
sec_param = GNUTLS_SEC_PARAM_ULTRA;
890
if(debug){
891
fprintf_plus(stderr, "Falling back to security parameter"
892
" \"%s\"\n",
893
safe_string(gnutls_sec_param_get_name
894
(sec_param)));
895
}
896
}
897
}
898
uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
899
if(uret != 0){
900
mc->dh_bits = uret;
901
if(debug){
902
fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
903
" implies %u DH bits; using that.\n",
904
safe_string(gnutls_sec_param_get_name
905
(sec_param)),
906
mc->dh_bits);
907
}
908
} else {
909
fprintf_plus(stderr, "Failed to get implied number of DH"
910
" bits for security parameter \"%s\"): %s\n",
911
safe_string(gnutls_sec_param_get_name
912
(sec_param)),
913
safer_gnutls_strerror(ret));
914
goto globalfail;
915
}
916
} else if(debug){
917
fprintf_plus(stderr, "DH bits explicitly set to %u\n",
918
mc->dh_bits);
919
}
920
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
921
if(ret != GNUTLS_E_SUCCESS){
922
fprintf_plus(stderr, "Error in GnuTLS prime generation (%u"
923
" bits): %s\n", mc->dh_bits,
924
safer_gnutls_strerror(ret));
925
goto globalfail;
926
}
927
}
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
928
579
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
929
580
930
581
return 0;
932
583
globalfail:
933
584
934
585
gnutls_certificate_free_credentials(mc->cred);
586
gnutls_global_deinit();
935
587
gnutls_dh_params_deinit(mc->dh_params);
936
588
return -1;
937
589
}
989
641
/* ignore client certificate if any. */
990
642
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
991
643
644
gnutls_dh_set_prime_bits(*session, mc->dh_bits);
645
992
646
return 0;
993
647
}
994
648
996
650
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
997
651
__attribute__((unused)) const char *txt){}
998
652
999
/* Helper function to add_local_route() and delete_local_route() */
1000
__attribute__((nonnull, warn_unused_result))
1001
static bool add_delete_local_route(const bool add,
1002
const char *address,
1003
AvahiIfIndex if_index){
1004
int ret;
1005
char helper[] = "mandos-client-iprouteadddel";
1006
char add_arg[] = "add";
1007
char delete_arg[] = "delete";
1008
char debug_flag[] = "--debug";
1009
char *pluginhelperdir = getenv("MANDOSPLUGINHELPERDIR");
1010
if(pluginhelperdir == NULL){
1011
if(debug){
1012
fprintf_plus(stderr, "MANDOSPLUGINHELPERDIR environment"
1013
" variable not set; cannot run helper\n");
1014
}
1015
return false;
1016
}
1017
1018
char interface[IF_NAMESIZE];
1019
if(if_indextoname((unsigned int)if_index, interface) == NULL){
1020
perror_plus("if_indextoname");
1021
return false;
1022
}
1023
1024
int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
1025
if(devnull == -1){
1026
perror_plus("open(\"/dev/null\", O_RDONLY)");
1027
return false;
1028
}
1029
pid_t pid = fork();
1030
if(pid == 0){
1031
/* Child */
1032
/* Raise privileges */
1033
errno = raise_privileges_permanently();
1034
if(errno != 0){
1035
perror_plus("Failed to raise privileges");
1036
/* _exit(EX_NOPERM); */
1037
} else {
1038
/* Set group */
1039
errno = 0;
1040
ret = setgid(0);
1041
if(ret == -1){
1042
perror_plus("setgid");
1043
_exit(EX_NOPERM);
1044
}
1045
/* Reset supplementary groups */
1046
errno = 0;
1047
ret = setgroups(0, NULL);
1048
if(ret == -1){
1049
perror_plus("setgroups");
1050
_exit(EX_NOPERM);
1051
}
1052
}
1053
ret = dup2(devnull, STDIN_FILENO);
1054
if(ret == -1){
1055
perror_plus("dup2(devnull, STDIN_FILENO)");
1056
_exit(EX_OSERR);
1057
}
1058
ret = close(devnull);
1059
if(ret == -1){
1060
perror_plus("close");
1061
_exit(EX_OSERR);
1062
}
1063
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
1064
if(ret == -1){
1065
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
1066
_exit(EX_OSERR);
1067
}
1068
int helperdir_fd = (int)TEMP_FAILURE_RETRY(open(pluginhelperdir,
1069
O_RDONLY
1070
| O_DIRECTORY
1071
| O_PATH
1072
| O_CLOEXEC));
1073
if(helperdir_fd == -1){
1074
perror_plus("open");
1075
_exit(EX_UNAVAILABLE);
1076
}
1077
int helper_fd = (int)TEMP_FAILURE_RETRY(openat(helperdir_fd,
1078
helper, O_RDONLY));
1079
if(helper_fd == -1){
1080
perror_plus("openat");
1081
close(helperdir_fd);
1082
_exit(EX_UNAVAILABLE);
1083
}
1084
close(helperdir_fd);
1085
#ifdef __GNUC__
1086
#pragma GCC diagnostic push
1087
#pragma GCC diagnostic ignored "-Wcast-qual"
1088
#endif
1089
if(fexecve(helper_fd, (char *const [])
1090
{ helper, add ? add_arg : delete_arg, (char *)address,
1091
interface, debug ? debug_flag : NULL, NULL },
1092
environ) == -1){
1093
#ifdef __GNUC__
1094
#pragma GCC diagnostic pop
1095
#endif
1096
perror_plus("fexecve");
1097
_exit(EXIT_FAILURE);
1098
}
1099
}
1100
if(pid == -1){
1101
perror_plus("fork");
1102
return false;
1103
}
1104
int status;
1105
pid_t pret = -1;
1106
errno = 0;
1107
do {
1108
pret = waitpid(pid, &status, 0);
1109
if(pret == -1 and errno == EINTR and quit_now){
1110
int errno_raising = 0;
1111
if((errno = raise_privileges()) != 0){
1112
errno_raising = errno;
1113
perror_plus("Failed to raise privileges in order to"
1114
" kill helper program");
1115
}
1116
if(kill(pid, SIGTERM) == -1){
1117
perror_plus("kill");
1118
}
1119
if((errno_raising == 0) and (errno = lower_privileges()) != 0){
1120
perror_plus("Failed to lower privileges after killing"
1121
" helper program");
1122
}
1123
return false;
1124
}
1125
} while(pret == -1 and errno == EINTR);
1126
if(pret == -1){
1127
perror_plus("waitpid");
1128
return false;
1129
}
1130
if(WIFEXITED(status)){
1131
if(WEXITSTATUS(status) != 0){
1132
fprintf_plus(stderr, "Error: iprouteadddel exited"
1133
" with status %d\n", WEXITSTATUS(status));
1134
return false;
1135
}
1136
return true;
1137
}
1138
if(WIFSIGNALED(status)){
1139
fprintf_plus(stderr, "Error: iprouteadddel died by"
1140
" signal %d\n", WTERMSIG(status));
1141
return false;
1142
}
1143
fprintf_plus(stderr, "Error: iprouteadddel crashed\n");
1144
return false;
1145
}
1146
1147
__attribute__((nonnull, warn_unused_result))
1148
static bool add_local_route(const char *address,
1149
AvahiIfIndex if_index){
1150
if(debug){
1151
fprintf_plus(stderr, "Adding route to %s\n", address);
1152
}
1153
return add_delete_local_route(true, address, if_index);
1154
}
1155
1156
__attribute__((nonnull, warn_unused_result))
1157
static bool delete_local_route(const char *address,
1158
AvahiIfIndex if_index){
1159
if(debug){
1160
fprintf_plus(stderr, "Removing route to %s\n", address);
1161
}
1162
return add_delete_local_route(false, address, if_index);
1163
}
1164
1165
653
/* Called when a Mandos server is found */
1166
654
__attribute__((nonnull, warn_unused_result))
1167
655
static int start_mandos_communication(const char *ip, in_port_t port,
1178
666
int retval = -1;
1179
667
gnutls_session_t session;
1180
668
int pf; /* Protocol family */
1181
bool route_added = false;
1182
669
1183
670
errno = 0;
1184
671
1206
693
bool match = false;
1207
694
{
1208
695
char *interface = NULL;
1209
while((interface = argz_next(mc->interfaces,
1210
mc->interfaces_size,
1211
interface))){
696
while((interface=argz_next(mc->interfaces, mc->interfaces_size,
697
interface))){
1212
698
if(if_nametoindex(interface) == (unsigned int)if_index){
1213
699
match = true;
1214
700
break;
1243
729
PRIuMAX "\n", ip, (uintmax_t)port);
1244
730
}
1245
731
1246
tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
732
tcp_sd = socket(pf, SOCK_STREAM, 0);
1247
733
if(tcp_sd < 0){
1248
734
int e = errno;
1249
735
perror_plus("socket");
1256
742
goto mandos_end;
1257
743
}
1258
744
745
memset(&to, 0, sizeof(to));
1259
746
if(af == AF_INET6){
1260
struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)&to;
1261
*to6 = (struct sockaddr_in6){ .sin6_family = (sa_family_t)af };
1262
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);
1263
749
} else { /* IPv4 */
1264
struct sockaddr_in *to4 = (struct sockaddr_in *)&to;
1265
*to4 = (struct sockaddr_in){ .sin_family = (sa_family_t)af };
1266
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);
1267
752
}
1268
753
if(ret < 0 ){
1269
754
int e = errno;
1339
824
goto mandos_end;
1340
825
}
1341
826
1342
while(true){
1343
if(af == AF_INET6){
1344
ret = connect(tcp_sd, (struct sockaddr *)&to,
1345
sizeof(struct sockaddr_in6));
1346
} else {
1347
ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
1348
sizeof(struct sockaddr_in));
1349
}
1350
if(ret < 0){
1351
if(((errno == ENETUNREACH) or (errno == EHOSTUNREACH))
1352
and if_index != AVAHI_IF_UNSPEC
1353
and connect_to == NULL
1354
and not route_added and
1355
((af == AF_INET6 and not
1356
IN6_IS_ADDR_LINKLOCAL(&(((struct sockaddr_in6 *)
1357
&to)->sin6_addr)))
1358
or (af == AF_INET and
1359
/* Not a a IPv4LL address */
1360
(ntohl(((struct sockaddr_in *)&to)->sin_addr.s_addr)
1361
& 0xFFFF0000L) != 0xA9FE0000L))){
1362
/* Work around Avahi bug - Avahi does not announce link-local
1363
addresses if it has a global address, so local hosts with
1364
*only* a link-local address (e.g. Mandos clients) cannot
1365
connect to a Mandos server announced by Avahi on a server
1366
host with a global address. Work around this by retrying
1367
with an explicit route added with the server's address.
1368
1369
Avahi bug reference:
1370
https://lists.freedesktop.org/archives/avahi/2010-February/001833.html
1371
https://bugs.debian.org/587961
1372
*/
1373
if(debug){
1374
fprintf_plus(stderr, "Mandos server unreachable, trying"
1375
" direct route\n");
1376
}
1377
int e = errno;
1378
route_added = add_local_route(ip, if_index);
1379
if(route_added){
1380
continue;
1381
}
1382
errno = e;
1383
}
1384
if(errno != ECONNREFUSED or debug){
1385
int e = errno;
1386
perror_plus("connect");
1387
errno = e;
1388
}
1389
goto mandos_end;
1390
}
1391
1392
if(quit_now){
1393
errno = EINTR;
1394
goto mandos_end;
1395
}
1396
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;
1397
846
}
1398
847
1399
848
const char *out = mandos_protocol_version;
1553
1002
&decrypted_buffer, mc);
1554
1003
if(decrypted_buffer_size >= 0){
1555
1004
1556
clearerr(stdout);
1557
1005
written = 0;
1558
1006
while(written < (size_t) decrypted_buffer_size){
1559
1007
if(quit_now){
1575
1023
}
1576
1024
written += (size_t)ret;
1577
1025
}
1578
ret = fflush(stdout);
1579
if(ret != 0){
1580
int e = errno;
1581
if(debug){
1582
fprintf_plus(stderr, "Error writing encrypted data: %s\n",
1583
strerror(errno));
1584
}
1585
errno = e;
1586
goto mandos_end;
1587
}
1588
1026
retval = 0;
1589
1027
}
1590
1028
}
1593
1031
1594
1032
mandos_end:
1595
1033
{
1596
if(route_added){
1597
if(not delete_local_route(ip, if_index)){
1598
fprintf_plus(stderr, "Failed to delete local route to %s on"
1599
" interface %d", ip, if_index);
1600
}
1601
}
1602
1034
int e = errno;
1603
1035
free(decrypted_buffer);
1604
1036
free(buffer);
1605
1037
if(tcp_sd >= 0){
1606
ret = close(tcp_sd);
1038
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
1607
1039
}
1608
1040
if(ret == -1){
1609
1041
if(e == 0){
1621
1053
return retval;
1622
1054
}
1623
1055
1056
__attribute__((nonnull))
1624
1057
static void resolve_callback(AvahiSServiceResolver *r,
1625
1058
AvahiIfIndex interface,
1626
1059
AvahiProtocol proto,
1763
1196
__attribute__((nonnull, warn_unused_result))
1764
1197
bool get_flags(const char *ifname, struct ifreq *ifr){
1765
1198
int ret;
1766
int old_errno;
1199
error_t ret_errno;
1767
1200
1768
1201
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1769
1202
if(s < 0){
1770
old_errno = errno;
1203
ret_errno = errno;
1771
1204
perror_plus("socket");
1772
errno = old_errno;
1205
errno = ret_errno;
1773
1206
return false;
1774
1207
}
1775
strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
1776
ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
1208
strcpy(ifr->ifr_name, ifname);
1777
1209
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1778
1210
if(ret == -1){
1779
1211
if(debug){
1780
old_errno = errno;
1212
ret_errno = errno;
1781
1213
perror_plus("ioctl SIOCGIFFLAGS");
1782
errno = old_errno;
1783
}
1784
if((close(s) == -1) and debug){
1785
old_errno = errno;
1786
perror_plus("close");
1787
errno = old_errno;
1214
errno = ret_errno;
1788
1215
}
1789
1216
return false;
1790
1217
}
1791
if((close(s) == -1) and debug){
1792
old_errno = errno;
1793
perror_plus("close");
1794
errno = old_errno;
1795
}
1796
1218
return true;
1797
1219
}
1798
1220
2040
1462
}
2041
1463
}
2042
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
2043
1517
__attribute__((nonnull))
2044
1518
void run_network_hooks(const char *mode, const char *interface,
2045
1519
const float delay){
2046
1520
struct dirent **direntries = NULL;
2047
1521
if(hookdir_fd == -1){
2048
hookdir_fd = open(hookdir, O_RDONLY | O_DIRECTORY | O_PATH
2049
| O_CLOEXEC);
1522
hookdir_fd = open(hookdir, O_RDONLY);
2050
1523
if(hookdir_fd == -1){
2051
1524
if(errno == ENOENT){
2052
1525
if(debug){
2059
1532
return;
2060
1533
}
2061
1534
}
2062
int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
2063
if(devnull == -1){
2064
perror_plus("open(\"/dev/null\", O_RDONLY)");
2065
return;
2066
}
1535
#ifdef __GLIBC__
1536
#if __GLIBC_PREREQ(2, 15)
2067
1537
int numhooks = scandirat(hookdir_fd, ".", &direntries,
2068
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__ */
2069
1547
if(numhooks == -1){
2070
1548
perror_plus("scandir");
2071
close(devnull);
2072
1549
return;
2073
1550
}
2074
1551
struct dirent *direntry;
2075
1552
int ret;
1553
int devnull = open("/dev/null", O_RDONLY);
2076
1554
for(int i = 0; i < numhooks; i++){
2077
1555
direntry = direntries[i];
2078
1556
if(debug){
2102
1580
perror_plus("setgroups");
2103
1581
_exit(EX_NOPERM);
2104
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
}
2105
1598
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
2106
1599
if(ret == -1){
2107
1600
perror_plus("setenv");
2142
1635
_exit(EX_OSERR);
2143
1636
}
2144
1637
}
2145
int hook_fd = (int)TEMP_FAILURE_RETRY(openat(hookdir_fd,
2146
direntry->d_name,
2147
O_RDONLY));
1638
int hook_fd = openat(hookdir_fd, direntry->d_name, O_RDONLY);
2148
1639
if(hook_fd == -1){
2149
1640
perror_plus("openat");
2150
1641
_exit(EXIT_FAILURE);
2151
1642
}
2152
if(close(hookdir_fd) == -1){
1643
if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
2153
1644
perror_plus("close");
2154
1645
_exit(EXIT_FAILURE);
2155
1646
}
2156
ret = dup2(devnull, STDIN_FILENO);
2157
if(ret == -1){
2158
perror_plus("dup2(devnull, STDIN_FILENO)");
2159
_exit(EX_OSERR);
2160
}
2161
ret = close(devnull);
2162
if(ret == -1){
2163
perror_plus("close");
2164
_exit(EX_OSERR);
2165
}
2166
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
2167
if(ret == -1){
2168
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
2169
_exit(EX_OSERR);
2170
}
2171
1647
if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
2172
1648
environ) == -1){
2173
1649
perror_plus("fexecve");
2213
1689
free(direntry);
2214
1690
}
2215
1691
free(direntries);
2216
if(close(hookdir_fd) == -1){
1692
if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
2217
1693
perror_plus("close");
2218
1694
} else {
2219
1695
hookdir_fd = -1;
2222
1698
}
2223
1699
2224
1700
__attribute__((nonnull, warn_unused_result))
2225
int bring_up_interface(const char *const interface,
2226
const float delay){
2227
int old_errno = errno;
1701
error_t bring_up_interface(const char *const interface,
1702
const float delay){
1703
error_t old_errno = errno;
2228
1704
int ret;
2229
1705
struct ifreq network;
2230
1706
unsigned int if_index = if_nametoindex(interface);
2240
1716
}
2241
1717
2242
1718
if(not interface_is_up(interface)){
2243
int ret_errno = 0;
2244
int ioctl_errno = 0;
1719
error_t ret_errno = 0, ioctl_errno = 0;
2245
1720
if(not get_flags(interface, &network)){
2246
1721
ret_errno = errno;
2247
1722
fprintf_plus(stderr, "Failed to get flags for interface "
2260
1735
}
2261
1736
2262
1737
if(quit_now){
2263
ret = close(sd);
1738
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2264
1739
if(ret == -1){
2265
1740
perror_plus("close");
2266
1741
}
2316
1791
}
2317
1792
2318
1793
/* Close the socket */
2319
ret = close(sd);
1794
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2320
1795
if(ret == -1){
2321
1796
perror_plus("close");
2322
1797
}
2334
1809
2335
1810
/* Sleep checking until interface is running.
2336
1811
Check every 0.25s, up to total time of delay */
2337
for(int i = 0; i < delay * 4; i++){
1812
for(int i=0; i < delay * 4; i++){
2338
1813
if(interface_is_running(interface)){
2339
1814
break;
2340
1815
}
2350
1825
}
2351
1826
2352
1827
__attribute__((nonnull, warn_unused_result))
2353
int take_down_interface(const char *const interface){
2354
int old_errno = errno;
1828
error_t take_down_interface(const char *const interface){
1829
error_t old_errno = errno;
2355
1830
struct ifreq network;
2356
1831
unsigned int if_index = if_nametoindex(interface);
2357
1832
if(if_index == 0){
2360
1835
return ENXIO;
2361
1836
}
2362
1837
if(interface_is_up(interface)){
2363
int ret_errno = 0;
2364
int ioctl_errno = 0;
1838
error_t ret_errno = 0, ioctl_errno = 0;
2365
1839
if(not get_flags(interface, &network) and debug){
2366
1840
ret_errno = errno;
2367
1841
fprintf_plus(stderr, "Failed to get flags for interface "
2405
1879
}
2406
1880
2407
1881
/* Close the socket */
2408
int ret = close(sd);
1882
int ret = (int)TEMP_FAILURE_RETRY(close(sd));
2409
1883
if(ret == -1){
2410
1884
perror_plus("close");
2411
1885
}
2426
1900
}
2427
1901
2428
1902
int main(int argc, char *argv[]){
2429
mandos_context mc = { .server = NULL, .dh_bits = 0,
2430
.priority = "SECURE256:!CTYPE-X.509"
2431
":+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256",
2432
.current_server = NULL, .interfaces = NULL,
2433
.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 };
2434
1907
AvahiSServiceBrowser *sb = NULL;
2435
1908
error_t ret_errno;
2436
1909
int ret;
2445
1918
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
2446
1919
const char *seckey = PATHDIR "/" SECKEY;
2447
1920
const char *pubkey = PATHDIR "/" PUBKEY;
2448
const char *dh_params_file = NULL;
2449
1921
char *interfaces_hooks = NULL;
2450
1922
2451
1923
bool gnutls_initialized = false;
2504
1976
.doc = "Bit length of the prime number used in the"
2505
1977
" Diffie-Hellman key exchange",
2506
1978
.group = 2 },
2507
{ .name = "dh-params", .key = 134,
2508
.arg = "FILE",
2509
.doc = "PEM-encoded PKCS#3 file with pre-generated parameters"
2510
" for the Diffie-Hellman key exchange",
2511
.group = 2 },
2512
1979
{ .name = "priority", .key = 130,
2513
1980
.arg = "STRING",
2514
1981
.doc = "GnuTLS priority string for the TLS handshake",
2569
2036
}
2570
2037
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
2571
2038
break;
2572
case 134: /* --dh-params */
2573
dh_params_file = arg;
2574
break;
2575
2039
case 130: /* --priority */
2576
2040
mc.priority = arg;
2577
2041
break;
2617
2081
.args_doc = "",
2618
2082
.doc = "Mandos client -- Get and decrypt"
2619
2083
" passwords from a Mandos server" };
2620
ret_errno = argp_parse(&argp, argc, argv,
2621
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2622
switch(ret_errno){
2084
ret = argp_parse(&argp, argc, argv,
2085
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2086
switch(ret){
2623
2087
case 0:
2624
2088
break;
2625
2089
case ENOMEM:
2626
2090
default:
2627
errno = ret_errno;
2091
errno = ret;
2628
2092
perror_plus("argp_parse");
2629
2093
exitcode = EX_OSERR;
2630
2094
goto end;
2633
2097
goto end;
2634
2098
}
2635
2099
}
2636
2100
2637
2101
{
2638
2102
/* Work around Debian bug #633582:
2639
<https://bugs.debian.org/633582> */
2103
<http://bugs.debian.org/633582> */
2640
2104
2641
2105
/* Re-raise privileges */
2642
ret = raise_privileges();
2643
if(ret != 0){
2644
errno = ret;
2106
ret_errno = raise_privileges();
2107
if(ret_errno != 0){
2108
errno = ret_errno;
2645
2109
perror_plus("Failed to raise privileges");
2646
2110
} else {
2647
2111
struct stat st;
2663
2127
}
2664
2128
}
2665
2129
}
2666
close(seckey_fd);
2130
TEMP_FAILURE_RETRY(close(seckey_fd));
2667
2131
}
2668
2132
}
2669
2133
2670
2134
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2671
2135
int pubkey_fd = open(pubkey, O_RDONLY);
2672
2136
if(pubkey_fd == -1){
2684
2148
}
2685
2149
}
2686
2150
}
2687
close(pubkey_fd);
2688
}
2689
}
2690
2691
if(dh_params_file != NULL
2692
and strcmp(dh_params_file, PATHDIR "/dhparams.pem" ) == 0){
2693
int dhparams_fd = open(dh_params_file, O_RDONLY);
2694
if(dhparams_fd == -1){
2695
perror_plus("open");
2696
} else {
2697
ret = (int)TEMP_FAILURE_RETRY(fstat(dhparams_fd, &st));
2698
if(ret == -1){
2699
perror_plus("fstat");
2700
} else {
2701
if(S_ISREG(st.st_mode)
2702
and st.st_uid == 0 and st.st_gid == 0){
2703
ret = fchown(dhparams_fd, uid, gid);
2704
if(ret == -1){
2705
perror_plus("fchown");
2706
}
2707
}
2708
}
2709
close(dhparams_fd);
2710
}
2711
}
2712
2151
TEMP_FAILURE_RETRY(close(pubkey_fd));
2152
}
2153
}
2154
2713
2155
/* Lower privileges */
2714
ret = lower_privileges();
2715
if(ret != 0){
2716
errno = ret;
2156
ret_errno = lower_privileges();
2157
if(ret_errno != 0){
2158
errno = ret_errno;
2717
2159
perror_plus("Failed to lower privileges");
2718
2160
}
2719
2161
}
2889
2331
errno = bring_up_interface(interface, delay);
2890
2332
if(not interface_was_up){
2891
2333
if(errno != 0){
2892
fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
2893
" %s\n", interface, strerror(errno));
2334
perror_plus("Failed to bring up interface");
2894
2335
} else {
2895
2336
errno = argz_add(&interfaces_to_take_down,
2896
2337
&interfaces_to_take_down_size,
2919
2360
goto end;
2920
2361
}
2921
2362
2922
ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
2363
ret = init_gnutls_global(pubkey, seckey, &mc);
2923
2364
if(ret == -1){
2924
2365
fprintf_plus(stderr, "init_gnutls_global failed\n");
2925
2366
exitcode = EX_UNAVAILABLE;
3047
2488
3048
2489
/* Allocate a new server */
3049
2490
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
3050
&config, NULL, NULL, &ret);
2491
&config, NULL, NULL, &ret_errno);
3051
2492
3052
2493
/* Free the Avahi configuration data */
3053
2494
avahi_server_config_free(&config);
3056
2497
/* Check if creating the Avahi server object succeeded */
3057
2498
if(mc.server == NULL){
3058
2499
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
3059
avahi_strerror(ret));
2500
avahi_strerror(ret_errno));
3060
2501
exitcode = EX_UNAVAILABLE;
3061
2502
goto end;
3062
2503
}
3097
2538
end:
3098
2539
3099
2540
if(debug){
3100
if(signal_received){
3101
fprintf_plus(stderr, "%s exiting due to signal %d: %s\n",
3102
argv[0], signal_received,
3103
strsignal(signal_received));
3104
} else {
3105
fprintf_plus(stderr, "%s exiting\n", argv[0]);
3106
}
2541
fprintf_plus(stderr, "%s exiting\n", argv[0]);
3107
2542
}
3108
2543
3109
2544
/* Cleanup things */
3120
2555
3121
2556
if(gnutls_initialized){
3122
2557
gnutls_certificate_free_credentials(mc.cred);
2558
gnutls_global_deinit();
3123
2559
gnutls_dh_params_deinit(mc.dh_params);
3124
2560
}
3125
2561
3148
2584
3149
2585
/* Re-raise privileges */
3150
2586
{
3151
ret = raise_privileges();
3152
if(ret != 0){
3153
errno = ret;
2587
ret_errno = raise_privileges();
2588
if(ret_errno != 0){
2589
errno = ret_errno;
3154
2590
perror_plus("Failed to raise privileges");
3155
2591
} else {
3156
2592
3161
2597
/* Take down the network interfaces which were brought up */
3162
2598
{
3163
2599
char *interface = NULL;
3164
while((interface = argz_next(interfaces_to_take_down,
3165
interfaces_to_take_down_size,
3166
interface))){
3167
ret = take_down_interface(interface);
3168
if(ret != 0){
3169
errno = ret;
2600
while((interface=argz_next(interfaces_to_take_down,
2601
interfaces_to_take_down_size,
2602
interface))){
2603
ret_errno = take_down_interface(interface);
2604
if(ret_errno != 0){
2605
errno = ret_errno;
3170
2606
perror_plus("Failed to take down interface");
3171
2607
}
3172
2608
}
3177
2613
}
3178
2614
}
3179
2615
3180
ret = lower_privileges_permanently();
3181
if(ret != 0){
3182
errno = ret;
2616
ret_errno = lower_privileges_permanently();
2617
if(ret_errno != 0){
2618
errno = ret_errno;
3183
2619
perror_plus("Failed to lower privileges permanently");
3184
2620
}
3185
2621
}
3187
2623
free(interfaces_to_take_down);
3188
2624
free(interfaces_hooks);
3189
2625
3190
void clean_dir_at(int base, const char * const dirname,
3191
uintmax_t level){
3192
struct dirent **direntries = NULL;
3193
int dret;
3194
int dir_fd = (int)TEMP_FAILURE_RETRY(openat(base, dirname,
3195
O_RDONLY
3196
| O_NOFOLLOW
3197
| O_DIRECTORY
3198
| O_PATH));
3199
if(dir_fd == -1){
3200
perror_plus("open");
3201
return;
3202
}
3203
int numentries = scandirat(dir_fd, ".", &direntries,
3204
notdotentries, alphasort);
3205
if(numentries >= 0){
3206
for(int i = 0; i < numentries; i++){
3207
if(debug){
3208
fprintf_plus(stderr, "Unlinking \"%s/%s\"\n",
3209
dirname, direntries[i]->d_name);
3210
}
3211
dret = unlinkat(dir_fd, direntries[i]->d_name, 0);
3212
if(dret == -1){
3213
if(errno == EISDIR){
3214
dret = unlinkat(dir_fd, direntries[i]->d_name,
3215
AT_REMOVEDIR);
3216
}
3217
if((dret == -1) and (errno == ENOTEMPTY)
3218
and (strcmp(direntries[i]->d_name, "private-keys-v1.d")
3219
== 0) and (level == 0)){
3220
/* Recurse only in this special case */
3221
clean_dir_at(dir_fd, direntries[i]->d_name, level+1);
3222
dret = 0;
3223
}
3224
if((dret == -1) and (errno != ENOENT)){
3225
fprintf_plus(stderr, "unlink(\"%s/%s\"): %s\n", dirname,
3226
direntries[i]->d_name, strerror(errno));
3227
}
3228
}
3229
free(direntries[i]);
3230
}
3231
3232
/* need to clean even if 0 because man page doesn't specify */
3233
free(direntries);
3234
dret = unlinkat(base, dirname, AT_REMOVEDIR);
3235
if(dret == -1 and errno != ENOENT){
3236
perror_plus("rmdir");
3237
}
3238
} else {
3239
perror_plus("scandirat");
3240
}
3241
close(dir_fd);
3242
}
3243
3244
2626
/* Removes the GPGME temp directory and all files inside */
3245
2627
if(tempdir != NULL){
3246
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
}
3247
2669
}
3248
2670
3249
2671
if(quit_now){
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0