32
32
/* Needed by GPGME, specifically gpgme_data_seek() */
33
#ifndef _LARGEFILE_SOURCE
34
33
#define _LARGEFILE_SOURCE
36
#ifndef _FILE_OFFSET_BITS
37
34
#define _FILE_OFFSET_BITS 64
40
36
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
42
38
#include <stdio.h> /* fprintf(), stderr, fwrite(),
43
stdout, ferror(), remove() */
39
stdout, ferror(), sscanf(),
44
41
#include <stdint.h> /* uint16_t, uint32_t */
45
42
#include <stddef.h> /* NULL, size_t, ssize_t */
46
43
#include <stdlib.h> /* free(), EXIT_SUCCESS, EXIT_FAILURE,
47
srand(), strtof(), abort() */
48
45
#include <stdbool.h> /* bool, false, true */
49
46
#include <string.h> /* memset(), strcmp(), strlen(),
50
47
strerror(), asprintf(), strcpy() */
59
56
#include <fcntl.h> /* open() */
60
57
#include <dirent.h> /* opendir(), struct dirent, readdir()
62
#include <inttypes.h> /* PRIu16, PRIdMAX, intmax_t,
59
#include <inttypes.h> /* PRIu16, intmax_t, SCNdMAX */
64
60
#include <assert.h> /* assert() */
65
61
#include <errno.h> /* perror(), errno */
66
62
#include <time.h> /* nanosleep(), time() */
71
67
INET_ADDRSTRLEN, INET6_ADDRSTRLEN
73
69
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
74
getuid(), getgid(), seteuid(),
70
getuid(), getgid(), setuid(),
76
72
#include <arpa/inet.h> /* inet_pton(), htons */
77
73
#include <iso646.h> /* not, or, and */
78
74
#include <argp.h> /* struct argp_option, error_t, struct
80
76
argp_parse(), ARGP_KEY_ARG,
81
77
ARGP_KEY_END, ARGP_ERR_UNKNOWN */
82
78
#include <signal.h> /* sigemptyset(), sigaddset(),
83
sigaction(), SIGTERM, sig_atomic_t,
79
sigaction(), SIGTERM, sigaction */
87
82
#include <sys/klog.h> /* klogctl() */
88
#endif /* __linux__ */
91
86
/* All Avahi types, constants and functions
138
133
} mandos_context;
140
135
/* 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;
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.
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.
153
143
size_t incbuffer(char **buffer, size_t buffer_length,
154
144
size_t buffer_capacity){
313
303
gpgme_recipient_t recipient;
314
304
recipient = result->recipients;
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;
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;
477
469
static int init_gnutls_session(gnutls_session_t *session){
479
471
/* GnuTLS session creation */
481
ret = gnutls_init(session, GNUTLS_SERVER);
485
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
472
ret = gnutls_init(session, GNUTLS_SERVER);
486
473
if(ret != GNUTLS_E_SUCCESS){
487
474
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
488
475
safer_gnutls_strerror(ret));
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);
480
ret = gnutls_priority_set_direct(*session, mc.priority, &err);
500
481
if(ret != GNUTLS_E_SUCCESS){
501
482
fprintf(stderr, "Syntax error at: %s\n", err);
502
483
fprintf(stderr, "GnuTLS error: %s\n",
510
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
513
gnutls_deinit(*session);
516
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
490
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
517
492
if(ret != GNUTLS_E_SUCCESS){
518
493
fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
519
494
safer_gnutls_strerror(ret));
524
499
/* ignore client certificate if any. */
525
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
500
gnutls_certificate_server_set_request(*session,
527
503
gnutls_dh_set_prime_bits(*session, mc.dh_bits);
537
513
static int start_mandos_communication(const char *ip, uint16_t port,
538
514
AvahiIfIndex if_index,
540
int ret, tcp_sd = -1;
543
519
struct sockaddr_in in;
544
520
struct sockaddr_in6 in6;
546
522
char *buffer = NULL;
547
char *decrypted_buffer = NULL;
523
char *decrypted_buffer;
548
524
size_t buffer_length = 0;
549
525
size_t buffer_capacity = 0;
526
ssize_t decrypted_buffer_size;
552
529
gnutls_session_t session;
553
530
int pf; /* Protocol family */
581
554
tcp_sd = socket(pf, SOCK_STREAM, 0);
583
556
perror("socket");
591
560
memset(&to, 0, sizeof(to));
592
561
if(af == AF_INET6){
593
to.in6.sin6_family = (sa_family_t)af;
562
to.in6.sin6_family = (uint16_t)af;
594
563
ret = inet_pton(af, ip, &to.in6.sin6_addr);
595
564
} else { /* IPv4 */
596
565
to.in.sin_family = (sa_family_t)af;
615
584
if(if_index == AVAHI_IF_UNSPEC){
616
585
fprintf(stderr, "An IPv6 link-local address is incomplete"
617
586
" without a network interface\n");
620
589
/* Set the network interface number as scope */
621
590
to.in6.sin6_scope_id = (uint32_t)if_index;
711
665
fprintf(stderr, "Establishing TLS session with %s\n", ip);
718
668
gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
725
671
ret = gnutls_handshake(session);
729
672
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
731
674
if(ret != GNUTLS_E_SUCCESS){
771
707
case GNUTLS_E_AGAIN:
773
709
case GNUTLS_E_REHANDSHAKE:
775
711
ret = gnutls_handshake(session);
780
712
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
782
714
fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
783
715
gnutls_perror(ret);
788
721
fprintf(stderr, "Unknown error while reading data from"
789
722
" encrypted session with Mandos server\n");
790
724
gnutls_bye(session, GNUTLS_SHUT_RDWR);
799
733
fprintf(stderr, "Closing TLS session\n");
807
ret = gnutls_bye(session, GNUTLS_SHUT_RDWR);
811
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
736
gnutls_bye(session, GNUTLS_SHUT_RDWR);
813
738
if(buffer_length > 0){
814
ssize_t decrypted_buffer_size;
815
739
decrypted_buffer_size = pgp_packet_decrypt(buffer,
817
741
&decrypted_buffer);
818
742
if(decrypted_buffer_size >= 0){
821
744
while(written < (size_t) decrypted_buffer_size){
826
745
ret = (int)fwrite(decrypted_buffer + written, 1,
827
746
(size_t)decrypted_buffer_size - written,
941
851
the callback function is called the Avahi server will free the
942
852
resolver for us. */
944
if(avahi_s_service_resolver_new(mc.server, interface, protocol,
945
name, type, domain, protocol, 0,
946
resolve_callback, NULL) == NULL)
854
if(!(avahi_s_service_resolver_new(mc.server, interface,
855
protocol, name, type, domain,
856
AVAHI_PROTO_INET6, 0,
857
resolve_callback, NULL)))
947
858
fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
948
859
name, avahi_strerror(avahi_server_errno(mc.server)));
963
/* stop main loop after sigterm has been called */
964
static void handle_sigterm(int sig){
969
signal_received = sig;
874
static void handle_sigterm(__attribute__((unused)) int sig){
970
875
int old_errno = errno;
971
if(mc.simple_poll != NULL){
972
avahi_simple_poll_quit(mc.simple_poll);
876
avahi_simple_poll_quit(mc.simple_poll);
974
877
errno = old_errno;
994
896
const char *seckey = PATHDIR "/" SECKEY;
995
897
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" };
997
903
bool gnutls_initialized = false;
998
904
bool gpgme_initialized = false;
1001
struct sigaction old_sigterm_action = { .sa_handler = SIG_DFL };
907
struct sigaction old_sigterm_action;
1002
908
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) */
1026
911
struct argp_option options[] = {
1027
912
{ .name = "debug", .key = 128,
1080
965
case 129: /* --dh-bits */
1082
tmpmax = strtoimax(arg, &tmp, 10);
1083
if(errno != 0 or tmp == arg or *tmp != '\0'
1084
or tmpmax != (typeof(mc.dh_bits))tmpmax){
966
ret = sscanf(arg, "%" SCNdMAX "%n", &tmpmax, &numchars);
967
if(ret < 1 or tmpmax != (typeof(mc.dh_bits))tmpmax
968
or arg[numchars] != '\0'){
1085
969
fprintf(stderr, "Bad number of DH bits\n");
1086
970
exit(EXIT_FAILURE);
1091
975
mc.priority = arg;
1093
977
case 131: /* --delay */
1095
delay = strtof(arg, &tmp);
1096
if(errno != 0 or tmp == arg or *tmp != '\0'){
978
ret = sscanf(arg, "%lf%n", &delay, &numchars);
979
if(ret < 1 or arg[numchars] != '\0'){
1097
980
fprintf(stderr, "Bad delay\n");
1098
981
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;
1201
1006
/* If the interface is down, bring it up */
1202
1007
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 */
1221
1008
#ifdef __linux__
1222
1009
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1223
1010
messages to mess up the prompt */
1260
1041
perror("klogctl");
1263
#endif /* __linux__ */
1264
1045
exitcode = EXIT_FAILURE;
1265
/* Lower privileges */
1273
1048
if((network.ifr_flags & IFF_UP) == 0){
1274
1049
network.ifr_flags |= IFF_UP;
1275
take_down_interface = true;
1276
1050
ret = ioctl(sd, SIOCSIFFLAGS, &network);
1278
take_down_interface = false;
1279
1052
perror("ioctl SIOCSIFFLAGS");
1280
1053
exitcode = EXIT_FAILURE;
1281
1054
#ifdef __linux__
1355
1114
gnutls_initialized = true;
1362
tempdir_created = true;
1363
1117
if(mkdtemp(tempdir) == NULL){
1364
tempdir_created = false;
1365
1118
perror("mkdtemp");
1121
tempdir_created = true;
1373
1123
if(not init_gpgme(pubkey, seckey, tempdir)){
1374
1124
fprintf(stderr, "init_gpgme failed\n");
1378
1128
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;
1385
1140
if(connect_to != NULL){
1391
1146
exitcode = EXIT_FAILURE;
1401
tmpmax = strtoimax(address+1, &tmp, 10);
1402
if(errno != 0 or tmp == address+1 or *tmp != '\0'
1403
or tmpmax != (uint16_t)tmpmax){
1150
ret = sscanf(address+1, "%" SCNdMAX "%n", &tmpmax, &numchars);
1151
if(ret < 1 or tmpmax != (uint16_t)tmpmax
1152
or address[numchars+1] != '\0'){
1404
1153
fprintf(stderr, "Bad port number\n");
1405
1154
exitcode = EXIT_FAILURE;
1413
1157
port = (uint16_t)tmpmax;
1414
1158
*address = '\0';
1415
1159
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;
1471
1217
/* Create the Avahi service browser */
1472
1218
sb = avahi_s_service_browser_new(mc.server, if_index,
1473
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
1219
AVAHI_PROTO_INET6, "_mandos._tcp",
1474
1220
NULL, 0, browse_callback, NULL);
1475
1221
if(sb == NULL){
1476
1222
fprintf(stderr, "Failed to create service browser: %s\n",
1517
1273
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 */
1552
1276
/* Removes the temp directory used by GPGME */
1553
1277
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());
1615
1320
return exitcode;