32
32
/* Needed by GPGME, specifically gpgme_data_seek() */
33
#ifndef _LARGEFILE_SOURCE
33
34
#define _LARGEFILE_SOURCE
36
#ifndef _FILE_OFFSET_BITS
34
37
#define _FILE_OFFSET_BITS 64
36
40
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
38
42
#include <stdio.h> /* fprintf(), stderr, fwrite(),
39
stdout, ferror(), sscanf(),
43
stdout, ferror(), remove() */
41
44
#include <stdint.h> /* uint16_t, uint32_t */
42
45
#include <stddef.h> /* NULL, size_t, ssize_t */
43
46
#include <stdlib.h> /* free(), EXIT_SUCCESS, EXIT_FAILURE,
47
srand(), strtof(), abort() */
45
48
#include <stdbool.h> /* bool, false, true */
46
49
#include <string.h> /* memset(), strcmp(), strlen(),
47
50
strerror(), asprintf(), strcpy() */
56
59
#include <fcntl.h> /* open() */
57
60
#include <dirent.h> /* opendir(), struct dirent, readdir()
59
#include <inttypes.h> /* PRIu16, intmax_t, SCNdMAX */
62
#include <inttypes.h> /* PRIu16, PRIdMAX, intmax_t,
60
64
#include <assert.h> /* assert() */
61
65
#include <errno.h> /* perror(), errno */
62
66
#include <time.h> /* nanosleep(), time() */
67
71
INET_ADDRSTRLEN, INET6_ADDRSTRLEN
69
73
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
70
getuid(), getgid(), setuid(),
74
getuid(), getgid(), seteuid(),
72
76
#include <arpa/inet.h> /* inet_pton(), htons */
73
77
#include <iso646.h> /* not, or, and */
74
78
#include <argp.h> /* struct argp_option, error_t, struct
76
80
argp_parse(), ARGP_KEY_ARG,
77
81
ARGP_KEY_END, ARGP_ERR_UNKNOWN */
78
82
#include <signal.h> /* sigemptyset(), sigaddset(),
79
sigaction(), SIGTERM, sigaction */
83
sigaction(), SIGTERM, sig_atomic_t,
82
87
#include <sys/klog.h> /* klogctl() */
88
#endif /* __linux__ */
86
91
/* All Avahi types, constants and functions
133
138
} mandos_context;
135
140
/* global context so signal handler can reach it*/
141
mandos_context mc = { .simple_poll = NULL, .server = NULL,
142
.dh_bits = 1024, .priority = "SECURE256"
143
":!CTYPE-X.509:+CTYPE-OPENPGP" };
145
sig_atomic_t quit_now = 0;
146
int signal_received = 0;
139
* Make additional room in "buffer" for at least BUFFER_SIZE
140
* additional bytes. "buffer_capacity" is how much is currently
141
* allocated, "buffer_length" is how much is already used.
149
* Make additional room in "buffer" for at least BUFFER_SIZE more
150
* bytes. "buffer_capacity" is how much is currently allocated,
151
* "buffer_length" is how much is already used.
143
153
size_t incbuffer(char **buffer, size_t buffer_length,
144
154
size_t buffer_capacity){
303
313
gpgme_recipient_t recipient;
304
314
recipient = result->recipients;
306
while(recipient != NULL){
307
fprintf(stderr, "Public key algorithm: %s\n",
308
gpgme_pubkey_algo_name(recipient->pubkey_algo));
309
fprintf(stderr, "Key ID: %s\n", recipient->keyid);
310
fprintf(stderr, "Secret key available: %s\n",
311
recipient->status == GPG_ERR_NO_SECKEY
313
recipient = recipient->next;
315
while(recipient != NULL){
316
fprintf(stderr, "Public key algorithm: %s\n",
317
gpgme_pubkey_algo_name(recipient->pubkey_algo));
318
fprintf(stderr, "Key ID: %s\n", recipient->keyid);
319
fprintf(stderr, "Secret key available: %s\n",
320
recipient->status == GPG_ERR_NO_SECKEY
322
recipient = recipient->next;
469
477
static int init_gnutls_session(gnutls_session_t *session){
471
479
/* GnuTLS session creation */
472
ret = gnutls_init(session, GNUTLS_SERVER);
481
ret = gnutls_init(session, GNUTLS_SERVER);
485
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
473
486
if(ret != GNUTLS_E_SUCCESS){
474
487
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
475
488
safer_gnutls_strerror(ret));
480
ret = gnutls_priority_set_direct(*session, mc.priority, &err);
494
ret = gnutls_priority_set_direct(*session, mc.priority, &err);
496
gnutls_deinit(*session);
499
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
481
500
if(ret != GNUTLS_E_SUCCESS){
482
501
fprintf(stderr, "Syntax error at: %s\n", err);
483
502
fprintf(stderr, "GnuTLS error: %s\n",
490
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
510
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
513
gnutls_deinit(*session);
516
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
492
517
if(ret != GNUTLS_E_SUCCESS){
493
518
fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
494
519
safer_gnutls_strerror(ret));
499
524
/* ignore client certificate if any. */
500
gnutls_certificate_server_set_request(*session,
525
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
503
527
gnutls_dh_set_prime_bits(*session, mc.dh_bits);
513
537
static int start_mandos_communication(const char *ip, uint16_t port,
514
538
AvahiIfIndex if_index,
540
int ret, tcp_sd = -1;
519
543
struct sockaddr_in in;
520
544
struct sockaddr_in6 in6;
522
546
char *buffer = NULL;
523
char *decrypted_buffer;
547
char *decrypted_buffer = NULL;
524
548
size_t buffer_length = 0;
525
549
size_t buffer_capacity = 0;
526
ssize_t decrypted_buffer_size;
529
552
gnutls_session_t session;
530
553
int pf; /* Protocol family */
554
581
tcp_sd = socket(pf, SOCK_STREAM, 0);
556
583
perror("socket");
560
591
memset(&to, 0, sizeof(to));
561
592
if(af == AF_INET6){
562
to.in6.sin6_family = (uint16_t)af;
593
to.in6.sin6_family = (sa_family_t)af;
563
594
ret = inet_pton(af, ip, &to.in6.sin6_addr);
564
595
} else { /* IPv4 */
565
596
to.in.sin_family = (sa_family_t)af;
584
615
if(if_index == AVAHI_IF_UNSPEC){
585
616
fprintf(stderr, "An IPv6 link-local address is incomplete"
586
617
" without a network interface\n");
589
620
/* Set the network interface number as scope */
590
621
to.in6.sin6_scope_id = (uint32_t)if_index;
665
711
fprintf(stderr, "Establishing TLS session with %s\n", ip);
668
718
gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
671
725
ret = gnutls_handshake(session);
672
729
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
674
731
if(ret != GNUTLS_E_SUCCESS){
707
771
case GNUTLS_E_AGAIN:
709
773
case GNUTLS_E_REHANDSHAKE:
711
775
ret = gnutls_handshake(session);
712
780
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
714
782
fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
715
783
gnutls_perror(ret);
721
788
fprintf(stderr, "Unknown error while reading data from"
722
789
" encrypted session with Mandos server\n");
724
790
gnutls_bye(session, GNUTLS_SHUT_RDWR);
733
799
fprintf(stderr, "Closing TLS session\n");
736
gnutls_bye(session, GNUTLS_SHUT_RDWR);
807
ret = gnutls_bye(session, GNUTLS_SHUT_RDWR);
811
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
738
813
if(buffer_length > 0){
814
ssize_t decrypted_buffer_size;
739
815
decrypted_buffer_size = pgp_packet_decrypt(buffer,
741
817
&decrypted_buffer);
742
818
if(decrypted_buffer_size >= 0){
744
821
while(written < (size_t) decrypted_buffer_size){
745
826
ret = (int)fwrite(decrypted_buffer + written, 1,
746
827
(size_t)decrypted_buffer_size - written,
851
941
the callback function is called the Avahi server will free the
852
942
resolver for us. */
854
if(!(avahi_s_service_resolver_new(mc.server, interface,
855
protocol, name, type, domain,
856
AVAHI_PROTO_INET6, 0,
857
resolve_callback, NULL)))
944
if(avahi_s_service_resolver_new(mc.server, interface, protocol,
945
name, type, domain, protocol, 0,
946
resolve_callback, NULL) == NULL)
858
947
fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
859
948
name, avahi_strerror(avahi_server_errno(mc.server)));
874
static void handle_sigterm(__attribute__((unused)) int sig){
963
/* stop main loop after sigterm has been called */
964
static void handle_sigterm(int sig){
969
signal_received = sig;
875
970
int old_errno = errno;
876
avahi_simple_poll_quit(mc.simple_poll);
971
if(mc.simple_poll != NULL){
972
avahi_simple_poll_quit(mc.simple_poll);
877
974
errno = old_errno;
896
994
const char *seckey = PATHDIR "/" SECKEY;
897
995
const char *pubkey = PATHDIR "/" PUBKEY;
899
/* Initialize Mandos context */
900
mc = (mandos_context){ .simple_poll = NULL, .server = NULL,
901
.dh_bits = 1024, .priority = "SECURE256"
902
":!CTYPE-X.509:+CTYPE-OPENPGP" };
903
997
bool gnutls_initialized = false;
904
998
bool gpgme_initialized = false;
907
struct sigaction old_sigterm_action;
1001
struct sigaction old_sigterm_action = { .sa_handler = SIG_DFL };
908
1002
struct sigaction sigterm_action = { .sa_handler = handle_sigterm };
1007
/* Lower any group privileges we might have, just to be safe */
1014
/* Lower user privileges (temporarily) */
911
1026
struct argp_option options[] = {
912
1027
{ .name = "debug", .key = 128,
965
1080
case 129: /* --dh-bits */
966
ret = sscanf(arg, "%" SCNdMAX "%n", &tmpmax, &numchars);
967
if(ret < 1 or tmpmax != (typeof(mc.dh_bits))tmpmax
968
or arg[numchars] != '\0'){
1082
tmpmax = strtoimax(arg, &tmp, 10);
1083
if(errno != 0 or tmp == arg or *tmp != '\0'
1084
or tmpmax != (typeof(mc.dh_bits))tmpmax){
969
1085
fprintf(stderr, "Bad number of DH bits\n");
970
1086
exit(EXIT_FAILURE);
975
1091
mc.priority = arg;
977
1093
case 131: /* --delay */
978
ret = sscanf(arg, "%lf%n", &delay, &numchars);
979
if(ret < 1 or arg[numchars] != '\0'){
1095
delay = strtof(arg, &tmp);
1096
if(errno != 0 or tmp == arg or *tmp != '\0'){
980
1097
fprintf(stderr, "Bad delay\n");
981
1098
exit(EXIT_FAILURE);
1124
avahi_set_log_function(empty_log);
1127
/* Initialize Avahi early so avahi_simple_poll_quit() can be called
1128
from the signal handler */
1129
/* Initialize the pseudo-RNG for Avahi */
1130
srand((unsigned int) time(NULL));
1131
mc.simple_poll = avahi_simple_poll_new();
1132
if(mc.simple_poll == NULL){
1133
fprintf(stderr, "Avahi: Failed to create simple poll object.\n");
1134
exitcode = EXIT_FAILURE;
1138
sigemptyset(&sigterm_action.sa_mask);
1139
ret = sigaddset(&sigterm_action.sa_mask, SIGINT);
1141
perror("sigaddset");
1142
exitcode = EXIT_FAILURE;
1145
ret = sigaddset(&sigterm_action.sa_mask, SIGHUP);
1147
perror("sigaddset");
1148
exitcode = EXIT_FAILURE;
1151
ret = sigaddset(&sigterm_action.sa_mask, SIGTERM);
1153
perror("sigaddset");
1154
exitcode = EXIT_FAILURE;
1157
/* Need to check if the handler is SIG_IGN before handling:
1158
| [[info:libc:Initial Signal Actions]] |
1159
| [[info:libc:Basic Signal Handling]] |
1161
ret = sigaction(SIGINT, NULL, &old_sigterm_action);
1163
perror("sigaction");
1164
return EXIT_FAILURE;
1166
if(old_sigterm_action.sa_handler != SIG_IGN){
1167
ret = sigaction(SIGINT, &sigterm_action, NULL);
1169
perror("sigaction");
1170
exitcode = EXIT_FAILURE;
1174
ret = sigaction(SIGHUP, NULL, &old_sigterm_action);
1176
perror("sigaction");
1177
return EXIT_FAILURE;
1179
if(old_sigterm_action.sa_handler != SIG_IGN){
1180
ret = sigaction(SIGHUP, &sigterm_action, NULL);
1182
perror("sigaction");
1183
exitcode = EXIT_FAILURE;
1187
ret = sigaction(SIGTERM, NULL, &old_sigterm_action);
1189
perror("sigaction");
1190
return EXIT_FAILURE;
1192
if(old_sigterm_action.sa_handler != SIG_IGN){
1193
ret = sigaction(SIGTERM, &sigterm_action, NULL);
1195
perror("sigaction");
1196
exitcode = EXIT_FAILURE;
1006
1201
/* If the interface is down, bring it up */
1007
1202
if(interface[0] != '\0'){
1203
if_index = (AvahiIfIndex) if_nametoindex(interface);
1205
fprintf(stderr, "No such interface: \"%s\"\n", interface);
1206
exitcode = EXIT_FAILURE;
1214
/* Re-raise priviliges */
1008
1221
#ifdef __linux__
1009
1222
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1010
1223
messages to mess up the prompt */
1041
1260
perror("klogctl");
1263
#endif /* __linux__ */
1045
1264
exitcode = EXIT_FAILURE;
1265
/* Lower privileges */
1048
1273
if((network.ifr_flags & IFF_UP) == 0){
1049
1274
network.ifr_flags |= IFF_UP;
1275
take_down_interface = true;
1050
1276
ret = ioctl(sd, SIOCSIFFLAGS, &network);
1278
take_down_interface = false;
1052
1279
perror("ioctl SIOCSIFFLAGS");
1053
1280
exitcode = EXIT_FAILURE;
1054
1281
#ifdef __linux__
1114
1355
gnutls_initialized = true;
1362
tempdir_created = true;
1117
1363
if(mkdtemp(tempdir) == NULL){
1364
tempdir_created = false;
1118
1365
perror("mkdtemp");
1121
tempdir_created = true;
1123
1373
if(not init_gpgme(pubkey, seckey, tempdir)){
1124
1374
fprintf(stderr, "init_gpgme failed\n");
1128
1378
gpgme_initialized = true;
1131
if(interface[0] != '\0'){
1132
if_index = (AvahiIfIndex) if_nametoindex(interface);
1134
fprintf(stderr, "No such interface: \"%s\"\n", interface);
1135
exitcode = EXIT_FAILURE;
1140
1385
if(connect_to != NULL){
1146
1391
exitcode = EXIT_FAILURE;
1150
ret = sscanf(address+1, "%" SCNdMAX "%n", &tmpmax, &numchars);
1151
if(ret < 1 or tmpmax != (uint16_t)tmpmax
1152
or address[numchars+1] != '\0'){
1401
tmpmax = strtoimax(address+1, &tmp, 10);
1402
if(errno != 0 or tmp == address+1 or *tmp != '\0'
1403
or tmpmax != (uint16_t)tmpmax){
1153
1404
fprintf(stderr, "Bad port number\n");
1154
1405
exitcode = EXIT_FAILURE;
1157
1413
port = (uint16_t)tmpmax;
1158
1414
*address = '\0';
1159
1415
address = connect_to;
1177
avahi_set_log_function(empty_log);
1180
/* Initialize the pseudo-RNG for Avahi */
1181
srand((unsigned int) time(NULL));
1183
/* Allocate main Avahi loop object */
1184
mc.simple_poll = avahi_simple_poll_new();
1185
if(mc.simple_poll == NULL){
1186
fprintf(stderr, "Avahi: Failed to create simple poll object.\n");
1187
exitcode = EXIT_FAILURE;
1217
1471
/* Create the Avahi service browser */
1218
1472
sb = avahi_s_service_browser_new(mc.server, if_index,
1219
AVAHI_PROTO_INET6, "_mandos._tcp",
1473
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
1220
1474
NULL, 0, browse_callback, NULL);
1221
1475
if(sb == NULL){
1222
1476
fprintf(stderr, "Failed to create service browser: %s\n",
1273
1517
gpgme_release(mc.ctx);
1520
/* Take down the network interface */
1521
if(take_down_interface){
1522
/* Re-raise priviliges */
1529
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1531
perror("ioctl SIOCGIFFLAGS");
1532
} else if(network.ifr_flags & IFF_UP) {
1533
network.ifr_flags &= ~IFF_UP; /* clear flag */
1534
ret = ioctl(sd, SIOCSIFFLAGS, &network);
1536
perror("ioctl SIOCSIFFLAGS");
1539
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1543
/* Lower privileges permanently */
1276
1552
/* Removes the temp directory used by GPGME */
1277
1553
if(tempdir_created){
1597
sigemptyset(&old_sigterm_action.sa_mask);
1598
old_sigterm_action.sa_handler = SIG_DFL;
1599
ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
1600
&old_sigterm_action,
1603
perror("sigaction");
1606
ret = raise(signal_received);
1607
} while(ret != 0 and errno == EINTR);
1612
TEMP_FAILURE_RETRY(pause());
1320
1615
return exitcode;