To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to plugins.d/mandos-client.c
- browse files at revision 951
- compare with another revision
- download diff
- download tarball
- view history from revision 951
- Committer: Teddy Hogeborn
- Date: 2018-08-15 09:26:02 UTC
- Revision ID: teddy@recompile.se-20180815092602-xoyb5s6gf8376i7u
mandos-client: Set system clock if necessary
* plugins.d/mandos-client.c (init_gpgme/import_key): If the system
clock is not set, or set to january 1970, set the system clock to
the more plausible value that is the mtime of the key file. This is
required by GnuPG to be able to import the keys. (We can't pass the
--ignore-time-conflict or the --ignore-valid-from options though
GPGME.)
* plugins.d/mandos-client.c (init_gpgme/import_key): If the system
clock is not set, or set to january 1970, set the system clock to
the more plausible value that is the mtime of the key file. This is
required by GnuPG to be able to import the keys. (We can't pass the
--ignore-time-conflict or the --ignore-valid-from options though
GPGME.)
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-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
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
21
23
* WITHOUT ANY WARRANTY; without even the implied warranty of
22
24
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23
25
* General Public License for more details.
24
26
*
25
27
* You should have received a copy of the GNU General Public License
26
* along with this program. If not, see
27
* <http://www.gnu.org/licenses/>.
28
* along with Mandos. If not, see <http://www.gnu.org/licenses/>.
28
29
*
29
30
* Contact the authors at <mandos@recompile.se>.
30
31
*/
46
47
#include <stdlib.h> /* free(), EXIT_SUCCESS, srand(),
47
48
strtof(), abort() */
48
49
#include <stdbool.h> /* bool, false, true */
49
#include <string.h> /* memset(), strcmp(), strlen(),
50
strerror(), asprintf(), strcpy() */
50
#include <string.h> /* strcmp(), strlen(), strerror(),
51
asprintf(), strncpy(), strsignal()
52
*/
51
53
#include <sys/ioctl.h> /* ioctl */
52
54
#include <sys/types.h> /* socket(), inet_pton(), sockaddr,
53
55
sockaddr_in6, PF_INET6,
57
59
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
58
60
inet_pton(), connect(),
59
61
getnameinfo() */
60
#include <fcntl.h> /* open(), unlinkat() */
62
#include <fcntl.h> /* open(), unlinkat(), AT_REMOVEDIR */
61
63
#include <dirent.h> /* opendir(), struct dirent, readdir()
62
64
*/
63
65
#include <inttypes.h> /* PRIu16, PRIdMAX, intmax_t,
64
66
strtoimax() */
65
#include <errno.h> /* perror(), errno,
67
#include <errno.h> /* perror(), errno, EINTR, EINVAL,
68
EAI_SYSTEM, ENETUNREACH,
69
EHOSTUNREACH, ECONNREFUSED, EPROTO,
70
EIO, ENOENT, ENXIO, ENOMEM, EISDIR,
71
ENOTEMPTY,
66
72
program_invocation_short_name */
67
73
#include <time.h> /* nanosleep(), time(), sleep() */
68
74
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
266
272
return true;
267
273
}
268
274
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
269
327
/*
270
328
* Initialize GPGME.
271
329
*/
291
349
return false;
292
350
}
293
351
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
294
402
rc = gpgme_data_new_from_fd(&pgp_data, fd);
295
403
if(rc != GPG_ERR_NO_ERROR){
296
404
fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
304
412
gpgme_strsource(rc), gpgme_strerror(rc));
305
413
return false;
306
414
}
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
}
307
490
308
ret = (int)TEMP_FAILURE_RETRY(close(fd));
491
ret = close(fd);
309
492
if(ret == -1){
310
493
perror_plus("close");
311
494
}
350
533
/* Create new GPGME "context" */
351
534
rc = gpgme_new(&(mc->ctx));
352
535
if(rc != GPG_ERR_NO_ERROR){
353
fprintf_plus(stderr, "Mandos plugin mandos-client: "
354
"bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
355
gpgme_strerror(rc));
536
fprintf_plus(stderr, "bad gpgme_new: %s: %s\n",
537
gpgme_strsource(rc), gpgme_strerror(rc));
356
538
return false;
357
539
}
358
540
394
576
/* Create new empty GPGME data buffer for the plaintext */
395
577
rc = gpgme_data_new(&dh_plain);
396
578
if(rc != GPG_ERR_NO_ERROR){
397
fprintf_plus(stderr, "Mandos plugin mandos-client: "
398
"bad gpgme_data_new: %s: %s\n",
579
fprintf_plus(stderr, "bad gpgme_data_new: %s: %s\n",
399
580
gpgme_strsource(rc), gpgme_strerror(rc));
400
581
gpgme_data_release(dh_crypto);
401
582
return -1;
414
595
if(result == NULL){
415
596
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
416
597
} else {
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);
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");
421
604
if(result->file_name != NULL){
422
605
fprintf_plus(stderr, "File name: %s\n", result->file_name);
423
606
}
424
gpgme_recipient_t recipient;
425
recipient = result->recipients;
426
while(recipient != NULL){
607
608
for(gpgme_recipient_t r = result->recipients; r != NULL;
609
r = r->next){
427
610
fprintf_plus(stderr, "Public key algorithm: %s\n",
428
gpgme_pubkey_algo_name
429
(recipient->pubkey_algo));
430
fprintf_plus(stderr, "Key ID: %s\n", recipient->keyid);
611
gpgme_pubkey_algo_name(r->pubkey_algo));
612
fprintf_plus(stderr, "Key ID: %s\n", r->keyid);
431
613
fprintf_plus(stderr, "Secret key available: %s\n",
432
recipient->status == GPG_ERR_NO_SECKEY
433
? "No" : "Yes");
434
recipient = recipient->next;
614
r->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
435
615
}
436
616
}
437
617
}
493
673
return plaintext_length;
494
674
}
495
675
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
496
683
__attribute__((warn_unused_result))
497
684
static const char *safer_gnutls_strerror(int value){
498
685
const char *ret = gnutls_strerror(value);
499
if(ret == NULL)
500
ret = "(unknown)";
501
return ret;
686
return safe_string(ret);
502
687
}
503
688
504
689
/* GnuTLS log function callback */
508
693
fprintf_plus(stderr, "GnuTLS: %s", string);
509
694
}
510
695
511
__attribute__((nonnull, warn_unused_result))
696
__attribute__((nonnull(1, 2, 4), warn_unused_result))
512
697
static int init_gnutls_global(const char *pubkeyfilename,
513
698
const char *seckeyfilename,
699
const char *dhparamsfilename,
514
700
mandos_context *mc){
515
701
int ret;
702
unsigned int uret;
516
703
517
704
if(debug){
518
705
fprintf_plus(stderr, "Initializing GnuTLS\n");
519
706
}
520
707
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
528
708
if(debug){
529
709
/* "Use a log level over 10 to enable all debugging options."
530
710
* - GnuTLS manual
538
718
if(ret != GNUTLS_E_SUCCESS){
539
719
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
540
720
safer_gnutls_strerror(ret));
541
gnutls_global_deinit();
542
721
return -1;
543
722
}
544
723
569
748
safer_gnutls_strerror(ret));
570
749
goto globalfail;
571
750
}
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
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
}
579
928
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
580
929
581
930
return 0;
583
932
globalfail:
584
933
585
934
gnutls_certificate_free_credentials(mc->cred);
586
gnutls_global_deinit();
587
935
gnutls_dh_params_deinit(mc->dh_params);
588
936
return -1;
589
937
}
641
989
/* ignore client certificate if any. */
642
990
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
643
991
644
gnutls_dh_set_prime_bits(*session, mc->dh_bits);
645
646
992
return 0;
647
993
}
648
994
650
996
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
651
997
__attribute__((unused)) const char *txt){}
652
998
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
653
1165
/* Called when a Mandos server is found */
654
1166
__attribute__((nonnull, warn_unused_result))
655
1167
static int start_mandos_communication(const char *ip, in_port_t port,
666
1178
int retval = -1;
667
1179
gnutls_session_t session;
668
1180
int pf; /* Protocol family */
1181
bool route_added = false;
669
1182
670
1183
errno = 0;
671
1184
693
1206
bool match = false;
694
1207
{
695
1208
char *interface = NULL;
696
while((interface=argz_next(mc->interfaces, mc->interfaces_size,
697
interface))){
1209
while((interface = argz_next(mc->interfaces,
1210
mc->interfaces_size,
1211
interface))){
698
1212
if(if_nametoindex(interface) == (unsigned int)if_index){
699
1213
match = true;
700
1214
break;
729
1243
PRIuMAX "\n", ip, (uintmax_t)port);
730
1244
}
731
1245
732
tcp_sd = socket(pf, SOCK_STREAM, 0);
1246
tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
733
1247
if(tcp_sd < 0){
734
1248
int e = errno;
735
1249
perror_plus("socket");
742
1256
goto mandos_end;
743
1257
}
744
1258
745
memset(&to, 0, sizeof(to));
746
1259
if(af == AF_INET6){
747
((struct sockaddr_in6 *)&to)->sin6_family = (sa_family_t)af;
748
ret = inet_pton(af, ip, &((struct sockaddr_in6 *)&to)->sin6_addr);
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);
749
1263
} else { /* IPv4 */
750
((struct sockaddr_in *)&to)->sin_family = (sa_family_t)af;
751
ret = inet_pton(af, ip, &((struct sockaddr_in *)&to)->sin_addr);
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);
752
1267
}
753
1268
if(ret < 0 ){
754
1269
int e = errno;
824
1339
goto mandos_end;
825
1340
}
826
1341
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;
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;
846
1397
}
847
1398
848
1399
const char *out = mandos_protocol_version;
1002
1553
&decrypted_buffer, mc);
1003
1554
if(decrypted_buffer_size >= 0){
1004
1555
1556
clearerr(stdout);
1005
1557
written = 0;
1006
1558
while(written < (size_t) decrypted_buffer_size){
1007
1559
if(quit_now){
1023
1575
}
1024
1576
written += (size_t)ret;
1025
1577
}
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
}
1026
1588
retval = 0;
1027
1589
}
1028
1590
}
1031
1593
1032
1594
mandos_end:
1033
1595
{
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
}
1034
1602
int e = errno;
1035
1603
free(decrypted_buffer);
1036
1604
free(buffer);
1037
1605
if(tcp_sd >= 0){
1038
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
1606
ret = close(tcp_sd);
1039
1607
}
1040
1608
if(ret == -1){
1041
1609
if(e == 0){
1053
1621
return retval;
1054
1622
}
1055
1623
1056
__attribute__((nonnull))
1057
1624
static void resolve_callback(AvahiSServiceResolver *r,
1058
1625
AvahiIfIndex interface,
1059
1626
AvahiProtocol proto,
1076
1643
timed out */
1077
1644
1078
1645
if(quit_now){
1646
avahi_s_service_resolver_free(r);
1079
1647
return;
1080
1648
}
1081
1649
1195
1763
__attribute__((nonnull, warn_unused_result))
1196
1764
bool get_flags(const char *ifname, struct ifreq *ifr){
1197
1765
int ret;
1198
error_t ret_errno;
1766
int old_errno;
1199
1767
1200
1768
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1201
1769
if(s < 0){
1202
ret_errno = errno;
1770
old_errno = errno;
1203
1771
perror_plus("socket");
1204
errno = ret_errno;
1772
errno = old_errno;
1205
1773
return false;
1206
1774
}
1207
strcpy(ifr->ifr_name, ifname);
1775
strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
1776
ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
1208
1777
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1209
1778
if(ret == -1){
1210
1779
if(debug){
1211
ret_errno = errno;
1780
old_errno = errno;
1212
1781
perror_plus("ioctl SIOCGIFFLAGS");
1213
errno = ret_errno;
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
1788
}
1215
1789
return false;
1216
1790
}
1791
if((close(s) == -1) and debug){
1792
old_errno = errno;
1793
perror_plus("close");
1794
errno = old_errno;
1795
}
1217
1796
return true;
1218
1797
}
1219
1798
1461
2040
}
1462
2041
}
1463
2042
1464
/* Set effective uid to 0, return errno */
1465
__attribute__((warn_unused_result))
1466
error_t raise_privileges(void){
1467
error_t old_errno = errno;
1468
error_t ret_errno = 0;
1469
if(seteuid(0) == -1){
1470
ret_errno = errno;
1471
}
1472
errno = old_errno;
1473
return ret_errno;
1474
}
1475
1476
/* Set effective and real user ID to 0. Return errno. */
1477
__attribute__((warn_unused_result))
1478
error_t raise_privileges_permanently(void){
1479
error_t old_errno = errno;
1480
error_t ret_errno = raise_privileges();
1481
if(ret_errno != 0){
1482
errno = old_errno;
1483
return ret_errno;
1484
}
1485
if(setuid(0) == -1){
1486
ret_errno = errno;
1487
}
1488
errno = old_errno;
1489
return ret_errno;
1490
}
1491
1492
/* Set effective user ID to unprivileged saved user ID */
1493
__attribute__((warn_unused_result))
1494
error_t lower_privileges(void){
1495
error_t old_errno = errno;
1496
error_t ret_errno = 0;
1497
if(seteuid(uid) == -1){
1498
ret_errno = errno;
1499
}
1500
errno = old_errno;
1501
return ret_errno;
1502
}
1503
1504
/* Lower privileges permanently */
1505
__attribute__((warn_unused_result))
1506
error_t lower_privileges_permanently(void){
1507
error_t old_errno = errno;
1508
error_t ret_errno = 0;
1509
if(setuid(uid) == -1){
1510
ret_errno = errno;
1511
}
1512
errno = old_errno;
1513
return ret_errno;
1514
}
1515
1516
2043
__attribute__((nonnull))
1517
2044
void run_network_hooks(const char *mode, const char *interface,
1518
2045
const float delay){
1519
2046
struct dirent **direntries = NULL;
1520
2047
if(hookdir_fd == -1){
1521
hookdir_fd = open(hookdir, O_RDONLY);
2048
hookdir_fd = open(hookdir, O_RDONLY | O_DIRECTORY | O_PATH
2049
| O_CLOEXEC);
1522
2050
if(hookdir_fd == -1){
1523
2051
if(errno == ENOENT){
1524
2052
if(debug){
1531
2059
return;
1532
2060
}
1533
2061
}
1534
#ifdef __GLIBC__
1535
#if __GLIBC_PREREQ(2, 15)
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
}
1536
2067
int numhooks = scandirat(hookdir_fd, ".", &direntries,
1537
2068
runnable_hook, alphasort);
1538
#else /* not __GLIBC_PREREQ(2, 15) */
1539
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1540
alphasort);
1541
#endif /* not __GLIBC_PREREQ(2, 15) */
1542
#else /* not __GLIBC__ */
1543
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1544
alphasort);
1545
#endif /* not __GLIBC__ */
1546
2069
if(numhooks == -1){
1547
2070
perror_plus("scandir");
2071
close(devnull);
1548
2072
return;
1549
2073
}
1550
2074
struct dirent *direntry;
1551
2075
int ret;
1552
int devnull = open("/dev/null", O_RDONLY);
1553
2076
for(int i = 0; i < numhooks; i++){
1554
2077
direntry = direntries[i];
1555
2078
if(debug){
1579
2102
perror_plus("setgroups");
1580
2103
_exit(EX_NOPERM);
1581
2104
}
1582
ret = dup2(devnull, STDIN_FILENO);
1583
if(ret == -1){
1584
perror_plus("dup2(devnull, STDIN_FILENO)");
1585
_exit(EX_OSERR);
1586
}
1587
ret = close(devnull);
1588
if(ret == -1){
1589
perror_plus("close");
1590
_exit(EX_OSERR);
1591
}
1592
ret = dup2(STDERR_FILENO, STDOUT_FILENO);
1593
if(ret == -1){
1594
perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
1595
_exit(EX_OSERR);
1596
}
1597
2105
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1598
2106
if(ret == -1){
1599
2107
perror_plus("setenv");
1634
2142
_exit(EX_OSERR);
1635
2143
}
1636
2144
}
1637
int hook_fd = openat(hookdir_fd, direntry->d_name, O_RDONLY);
2145
int hook_fd = (int)TEMP_FAILURE_RETRY(openat(hookdir_fd,
2146
direntry->d_name,
2147
O_RDONLY));
1638
2148
if(hook_fd == -1){
1639
2149
perror_plus("openat");
1640
2150
_exit(EXIT_FAILURE);
1641
2151
}
1642
if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
2152
if(close(hookdir_fd) == -1){
1643
2153
perror_plus("close");
1644
2154
_exit(EXIT_FAILURE);
1645
2155
}
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
}
1646
2171
if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
1647
2172
environ) == -1){
1648
2173
perror_plus("fexecve");
1649
2174
_exit(EXIT_FAILURE);
1650
2175
}
1651
2176
} else {
2177
if(hook_pid == -1){
2178
perror_plus("fork");
2179
free(direntry);
2180
continue;
2181
}
1652
2182
int status;
1653
2183
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1654
2184
perror_plus("waitpid");
2185
free(direntry);
1655
2186
continue;
1656
2187
}
1657
2188
if(WIFEXITED(status)){
1659
2190
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1660
2191
" with status %d\n", direntry->d_name,
1661
2192
WEXITSTATUS(status));
2193
free(direntry);
1662
2194
continue;
1663
2195
}
1664
2196
} else if(WIFSIGNALED(status)){
1665
2197
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1666
2198
" signal %d\n", direntry->d_name,
1667
2199
WTERMSIG(status));
2200
free(direntry);
1668
2201
continue;
1669
2202
} else {
1670
2203
fprintf_plus(stderr, "Warning: network hook \"%s\""
1671
2204
" crashed\n", direntry->d_name);
2205
free(direntry);
1672
2206
continue;
1673
2207
}
1674
2208
}
1676
2210
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1677
2211
direntry->d_name);
1678
2212
}
2213
free(direntry);
1679
2214
}
1680
2215
free(direntries);
1681
if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){
2216
if(close(hookdir_fd) == -1){
1682
2217
perror_plus("close");
1683
2218
} else {
1684
2219
hookdir_fd = -1;
1687
2222
}
1688
2223
1689
2224
__attribute__((nonnull, warn_unused_result))
1690
error_t bring_up_interface(const char *const interface,
1691
const float delay){
1692
error_t old_errno = errno;
2225
int bring_up_interface(const char *const interface,
2226
const float delay){
2227
int old_errno = errno;
1693
2228
int ret;
1694
2229
struct ifreq network;
1695
2230
unsigned int if_index = if_nametoindex(interface);
1705
2240
}
1706
2241
1707
2242
if(not interface_is_up(interface)){
1708
error_t ret_errno = 0, ioctl_errno = 0;
2243
int ret_errno = 0;
2244
int ioctl_errno = 0;
1709
2245
if(not get_flags(interface, &network)){
1710
2246
ret_errno = errno;
1711
2247
fprintf_plus(stderr, "Failed to get flags for interface "
1724
2260
}
1725
2261
1726
2262
if(quit_now){
1727
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2263
ret = close(sd);
1728
2264
if(ret == -1){
1729
2265
perror_plus("close");
1730
2266
}
1780
2316
}
1781
2317
1782
2318
/* Close the socket */
1783
ret = (int)TEMP_FAILURE_RETRY(close(sd));
2319
ret = close(sd);
1784
2320
if(ret == -1){
1785
2321
perror_plus("close");
1786
2322
}
1798
2334
1799
2335
/* Sleep checking until interface is running.
1800
2336
Check every 0.25s, up to total time of delay */
1801
for(int i=0; i < delay * 4; i++){
2337
for(int i = 0; i < delay * 4; i++){
1802
2338
if(interface_is_running(interface)){
1803
2339
break;
1804
2340
}
1814
2350
}
1815
2351
1816
2352
__attribute__((nonnull, warn_unused_result))
1817
error_t take_down_interface(const char *const interface){
1818
error_t old_errno = errno;
2353
int take_down_interface(const char *const interface){
2354
int old_errno = errno;
1819
2355
struct ifreq network;
1820
2356
unsigned int if_index = if_nametoindex(interface);
1821
2357
if(if_index == 0){
1824
2360
return ENXIO;
1825
2361
}
1826
2362
if(interface_is_up(interface)){
1827
error_t ret_errno = 0, ioctl_errno = 0;
2363
int ret_errno = 0;
2364
int ioctl_errno = 0;
1828
2365
if(not get_flags(interface, &network) and debug){
1829
2366
ret_errno = errno;
1830
2367
fprintf_plus(stderr, "Failed to get flags for interface "
1868
2405
}
1869
2406
1870
2407
/* Close the socket */
1871
int ret = (int)TEMP_FAILURE_RETRY(close(sd));
2408
int ret = close(sd);
1872
2409
if(ret == -1){
1873
2410
perror_plus("close");
1874
2411
}
1889
2426
}
1890
2427
1891
2428
int main(int argc, char *argv[]){
1892
mandos_context mc = { .server = NULL, .dh_bits = 1024,
1893
.priority = "SECURE256:!CTYPE-X.509:"
1894
"+CTYPE-OPENPGP", .current_server = NULL,
1895
.interfaces = NULL, .interfaces_size = 0 };
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 };
1896
2434
AvahiSServiceBrowser *sb = NULL;
1897
2435
error_t ret_errno;
1898
2436
int ret;
1907
2445
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1908
2446
const char *seckey = PATHDIR "/" SECKEY;
1909
2447
const char *pubkey = PATHDIR "/" PUBKEY;
2448
const char *dh_params_file = NULL;
1910
2449
char *interfaces_hooks = NULL;
1911
2450
1912
2451
bool gnutls_initialized = false;
1965
2504
.doc = "Bit length of the prime number used in the"
1966
2505
" Diffie-Hellman key exchange",
1967
2506
.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 },
1968
2512
{ .name = "priority", .key = 130,
1969
2513
.arg = "STRING",
1970
2514
.doc = "GnuTLS priority string for the TLS handshake",
2025
2569
}
2026
2570
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
2027
2571
break;
2572
case 134: /* --dh-params */
2573
dh_params_file = arg;
2574
break;
2028
2575
case 130: /* --priority */
2029
2576
mc.priority = arg;
2030
2577
break;
2070
2617
.args_doc = "",
2071
2618
.doc = "Mandos client -- Get and decrypt"
2072
2619
" passwords from a Mandos server" };
2073
ret = argp_parse(&argp, argc, argv,
2074
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2075
switch(ret){
2620
ret_errno = argp_parse(&argp, argc, argv,
2621
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
2622
switch(ret_errno){
2076
2623
case 0:
2077
2624
break;
2078
2625
case ENOMEM:
2079
2626
default:
2080
errno = ret;
2627
errno = ret_errno;
2081
2628
perror_plus("argp_parse");
2082
2629
exitcode = EX_OSERR;
2083
2630
goto end;
2086
2633
goto end;
2087
2634
}
2088
2635
}
2089
2636
2090
2637
{
2091
2638
/* Work around Debian bug #633582:
2092
<http://bugs.debian.org/633582> */
2639
<https://bugs.debian.org/633582> */
2093
2640
2094
2641
/* Re-raise privileges */
2095
ret_errno = raise_privileges();
2096
if(ret_errno != 0){
2097
errno = ret_errno;
2642
ret = raise_privileges();
2643
if(ret != 0){
2644
errno = ret;
2098
2645
perror_plus("Failed to raise privileges");
2099
2646
} else {
2100
2647
struct stat st;
2116
2663
}
2117
2664
}
2118
2665
}
2119
TEMP_FAILURE_RETRY(close(seckey_fd));
2666
close(seckey_fd);
2120
2667
}
2121
2668
}
2122
2669
2123
2670
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
2124
2671
int pubkey_fd = open(pubkey, O_RDONLY);
2125
2672
if(pubkey_fd == -1){
2137
2684
}
2138
2685
}
2139
2686
}
2140
TEMP_FAILURE_RETRY(close(pubkey_fd));
2141
}
2142
}
2143
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
2144
2713
/* Lower privileges */
2145
ret_errno = lower_privileges();
2146
if(ret_errno != 0){
2147
errno = ret_errno;
2714
ret = lower_privileges();
2715
if(ret != 0){
2716
errno = ret;
2148
2717
perror_plus("Failed to lower privileges");
2149
2718
}
2150
2719
}
2275
2844
if(ret_errno != 0){
2276
2845
errno = ret_errno;
2277
2846
perror_plus("argz_add");
2847
free(direntries[i]);
2278
2848
continue;
2279
2849
}
2280
2850
if(debug){
2281
2851
fprintf_plus(stderr, "Will use interface \"%s\"\n",
2282
2852
direntries[i]->d_name);
2283
2853
}
2854
free(direntries[i]);
2284
2855
}
2285
2856
free(direntries);
2286
2857
} else {
2318
2889
errno = bring_up_interface(interface, delay);
2319
2890
if(not interface_was_up){
2320
2891
if(errno != 0){
2321
perror_plus("Failed to bring up interface");
2892
fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
2893
" %s\n", interface, strerror(errno));
2322
2894
} else {
2323
2895
errno = argz_add(&interfaces_to_take_down,
2324
2896
&interfaces_to_take_down_size,
2347
2919
goto end;
2348
2920
}
2349
2921
2350
ret = init_gnutls_global(pubkey, seckey, &mc);
2922
ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
2351
2923
if(ret == -1){
2352
2924
fprintf_plus(stderr, "init_gnutls_global failed\n");
2353
2925
exitcode = EX_UNAVAILABLE;
2475
3047
2476
3048
/* Allocate a new server */
2477
3049
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
2478
&config, NULL, NULL, &ret_errno);
3050
&config, NULL, NULL, &ret);
2479
3051
2480
3052
/* Free the Avahi configuration data */
2481
3053
avahi_server_config_free(&config);
2484
3056
/* Check if creating the Avahi server object succeeded */
2485
3057
if(mc.server == NULL){
2486
3058
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2487
avahi_strerror(ret_errno));
3059
avahi_strerror(ret));
2488
3060
exitcode = EX_UNAVAILABLE;
2489
3061
goto end;
2490
3062
}
2525
3097
end:
2526
3098
2527
3099
if(debug){
2528
fprintf_plus(stderr, "%s exiting\n", argv[0]);
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
}
2529
3107
}
2530
3108
2531
3109
/* Cleanup things */
2542
3120
2543
3121
if(gnutls_initialized){
2544
3122
gnutls_certificate_free_credentials(mc.cred);
2545
gnutls_global_deinit();
2546
3123
gnutls_dh_params_deinit(mc.dh_params);
2547
3124
}
2548
3125
2571
3148
2572
3149
/* Re-raise privileges */
2573
3150
{
2574
ret_errno = raise_privileges();
2575
if(ret_errno != 0){
2576
errno = ret_errno;
3151
ret = raise_privileges();
3152
if(ret != 0){
3153
errno = ret;
2577
3154
perror_plus("Failed to raise privileges");
2578
3155
} else {
2579
3156
2584
3161
/* Take down the network interfaces which were brought up */
2585
3162
{
2586
3163
char *interface = NULL;
2587
while((interface=argz_next(interfaces_to_take_down,
2588
interfaces_to_take_down_size,
2589
interface))){
2590
ret_errno = take_down_interface(interface);
2591
if(ret_errno != 0){
2592
errno = ret_errno;
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;
2593
3170
perror_plus("Failed to take down interface");
2594
3171
}
2595
3172
}
2600
3177
}
2601
3178
}
2602
3179
2603
ret_errno = lower_privileges_permanently();
2604
if(ret_errno != 0){
2605
errno = ret_errno;
3180
ret = lower_privileges_permanently();
3181
if(ret != 0){
3182
errno = ret;
2606
3183
perror_plus("Failed to lower privileges permanently");
2607
3184
}
2608
3185
}
2610
3187
free(interfaces_to_take_down);
2611
3188
free(interfaces_hooks);
2612
3189
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
2613
3244
/* Removes the GPGME temp directory and all files inside */
2614
3245
if(tempdir != NULL){
2615
struct dirent **direntries = NULL;
2616
int tempdir_fd = (int)TEMP_FAILURE_RETRY(open(tempdir, O_RDONLY |
2617
O_NOFOLLOW));
2618
if(tempdir_fd == -1){
2619
perror_plus("open");
2620
} else {
2621
#ifdef __GLIBC__
2622
#if __GLIBC_PREREQ(2, 15)
2623
int numentries = scandirat(tempdir_fd, ".", &direntries,
2624
notdotentries, alphasort);
2625
#else /* not __GLIBC_PREREQ(2, 15) */
2626
int numentries = scandir(tempdir, &direntries, notdotentries,
2627
alphasort);
2628
#endif /* not __GLIBC_PREREQ(2, 15) */
2629
#else /* not __GLIBC__ */
2630
int numentries = scandir(tempdir, &direntries, notdotentries,
2631
alphasort);
2632
#endif /* not __GLIBC__ */
2633
if(numentries >= 0){
2634
for(int i = 0; i < numentries; i++){
2635
ret = unlinkat(tempdir_fd, direntries[i]->d_name, 0);
2636
if(ret == -1){
2637
fprintf_plus(stderr, "unlinkat(open(\"%s\", O_RDONLY),"
2638
" \"%s\", 0): %s\n", tempdir,
2639
direntries[i]->d_name, strerror(errno));
2640
}
2641
}
2642
2643
/* need to clean even if 0 because man page doesn't specify */
2644
free(direntries);
2645
if(numentries == -1){
2646
perror_plus("scandir");
2647
}
2648
ret = rmdir(tempdir);
2649
if(ret == -1 and errno != ENOENT){
2650
perror_plus("rmdir");
2651
}
2652
}
2653
TEMP_FAILURE_RETRY(close(tempdir_fd));
2654
}
3246
clean_dir_at(-1, tempdir, 0);
2655
3247
}
2656
3248
2657
3249
if(quit_now){
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0