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,
85
#include <sysexits.h> /* EX_OSERR, EX_USAGE */
82
88
#include <sys/klog.h> /* klogctl() */
89
#endif /* __linux__ */
86
92
/* All Avahi types, constants and functions
133
139
} mandos_context;
135
141
/* global context so signal handler can reach it*/
142
mandos_context mc = { .simple_poll = NULL, .server = NULL,
143
.dh_bits = 1024, .priority = "SECURE256"
144
":!CTYPE-X.509:+CTYPE-OPENPGP" };
146
sig_atomic_t quit_now = 0;
147
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.
150
* Make additional room in "buffer" for at least BUFFER_SIZE more
151
* bytes. "buffer_capacity" is how much is currently allocated,
152
* "buffer_length" is how much is already used.
143
154
size_t incbuffer(char **buffer, size_t buffer_length,
144
155
size_t buffer_capacity){
303
314
gpgme_recipient_t recipient;
304
315
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;
316
while(recipient != NULL){
317
fprintf(stderr, "Public key algorithm: %s\n",
318
gpgme_pubkey_algo_name(recipient->pubkey_algo));
319
fprintf(stderr, "Key ID: %s\n", recipient->keyid);
320
fprintf(stderr, "Secret key available: %s\n",
321
recipient->status == GPG_ERR_NO_SECKEY
323
recipient = recipient->next;
469
478
static int init_gnutls_session(gnutls_session_t *session){
471
480
/* GnuTLS session creation */
472
ret = gnutls_init(session, GNUTLS_SERVER);
482
ret = gnutls_init(session, GNUTLS_SERVER);
486
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
473
487
if(ret != GNUTLS_E_SUCCESS){
474
488
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
475
489
safer_gnutls_strerror(ret));
733
800
fprintf(stderr, "Closing TLS session\n");
736
gnutls_bye(session, GNUTLS_SHUT_RDWR);
808
ret = gnutls_bye(session, GNUTLS_SHUT_RDWR);
812
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
738
814
if(buffer_length > 0){
815
ssize_t decrypted_buffer_size;
739
816
decrypted_buffer_size = pgp_packet_decrypt(buffer,
741
818
&decrypted_buffer);
742
819
if(decrypted_buffer_size >= 0){
744
822
while(written < (size_t) decrypted_buffer_size){
745
827
ret = (int)fwrite(decrypted_buffer + written, 1,
746
828
(size_t)decrypted_buffer_size - written,
851
942
the callback function is called the Avahi server will free the
852
943
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)))
945
if(avahi_s_service_resolver_new(mc.server, interface, protocol,
946
name, type, domain, protocol, 0,
947
resolve_callback, NULL) == NULL)
858
948
fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
859
949
name, avahi_strerror(avahi_server_errno(mc.server)));
896
995
const char *seckey = PATHDIR "/" SECKEY;
897
996
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
998
bool gnutls_initialized = false;
904
999
bool gpgme_initialized = false;
907
struct sigaction old_sigterm_action;
1002
struct sigaction old_sigterm_action = { .sa_handler = SIG_DFL };
908
1003
struct sigaction sigterm_action = { .sa_handler = handle_sigterm };
1008
/* Lower any group privileges we might have, just to be safe */
1015
/* Lower user privileges (temporarily) */
911
1027
struct argp_option options[] = {
912
1028
{ .name = "debug", .key = 128,
941
1057
.arg = "SECONDS",
942
1058
.doc = "Maximum delay to wait for interface startup",
1061
* These reproduce what we would get without ARGP_NO_HELP
1063
{ .name = "help", .key = '?',
1064
.doc = "Give this help list", .group = -1 },
1065
{ .name = "usage", .key = -3,
1066
.doc = "Give a short usage message", .group = -1 },
1067
{ .name = "version", .key = 'V',
1068
.doc = "Print program version", .group = -1 },
944
1069
{ .name = NULL }
947
1072
error_t parse_opt(int key, char *arg,
948
1073
struct argp_state *state){
950
1076
case 128: /* --debug */
965
1091
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'){
969
fprintf(stderr, "Bad number of DH bits\n");
1093
tmpmax = strtoimax(arg, &tmp, 10);
1094
if(errno != 0 or tmp == arg or *tmp != '\0'
1095
or tmpmax != (typeof(mc.dh_bits))tmpmax){
1096
argp_error(state, "Bad number of DH bits");
972
1098
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
975
1101
mc.priority = arg;
977
1103
case 131: /* --delay */
978
ret = sscanf(arg, "%lf%n", &delay, &numchars);
979
if(ret < 1 or arg[numchars] != '\0'){
980
fprintf(stderr, "Bad delay\n");
1105
delay = strtof(arg, &tmp);
1106
if(errno != 0 or tmp == arg or *tmp != '\0'){
1107
argp_error(state, "Bad delay");
1111
* These reproduce what we would get without ARGP_NO_HELP
1113
case '?': /* --help */
1114
argp_state_help(state, state->out_stream,
1115
(ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
1116
& ~(unsigned int)ARGP_HELP_EXIT_OK);
1117
case -3: /* --usage */
1118
argp_state_help(state, state->out_stream,
1119
ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
1120
case 'V': /* --version */
1121
fprintf(state->out_stream, "%s\n", argp_program_version);
1122
exit(argp_err_exit_status);
989
1125
return ARGP_ERR_UNKNOWN;
994
1130
struct argp argp = { .options = options, .parser = parse_opt,
996
1132
.doc = "Mandos client -- Get and decrypt"
997
1133
" passwords from a Mandos server" };
998
ret = argp_parse(&argp, argc, argv, 0, 0, NULL);
999
if(ret == ARGP_ERR_UNKNOWN){
1000
fprintf(stderr, "Unknown error while parsing arguments\n");
1134
ret = argp_parse(&argp, argc, argv,
1135
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
1142
perror("argp_parse");
1143
exitcode = EX_OSERR;
1146
exitcode = EX_USAGE;
1152
avahi_set_log_function(empty_log);
1155
/* Initialize Avahi early so avahi_simple_poll_quit() can be called
1156
from the signal handler */
1157
/* Initialize the pseudo-RNG for Avahi */
1158
srand((unsigned int) time(NULL));
1159
mc.simple_poll = avahi_simple_poll_new();
1160
if(mc.simple_poll == NULL){
1161
fprintf(stderr, "Avahi: Failed to create simple poll object.\n");
1162
exitcode = EXIT_FAILURE;
1166
sigemptyset(&sigterm_action.sa_mask);
1167
ret = sigaddset(&sigterm_action.sa_mask, SIGINT);
1169
perror("sigaddset");
1170
exitcode = EXIT_FAILURE;
1173
ret = sigaddset(&sigterm_action.sa_mask, SIGHUP);
1175
perror("sigaddset");
1176
exitcode = EXIT_FAILURE;
1179
ret = sigaddset(&sigterm_action.sa_mask, SIGTERM);
1181
perror("sigaddset");
1182
exitcode = EXIT_FAILURE;
1185
/* Need to check if the handler is SIG_IGN before handling:
1186
| [[info:libc:Initial Signal Actions]] |
1187
| [[info:libc:Basic Signal Handling]] |
1189
ret = sigaction(SIGINT, NULL, &old_sigterm_action);
1191
perror("sigaction");
1192
return EXIT_FAILURE;
1194
if(old_sigterm_action.sa_handler != SIG_IGN){
1195
ret = sigaction(SIGINT, &sigterm_action, NULL);
1197
perror("sigaction");
1198
exitcode = EXIT_FAILURE;
1202
ret = sigaction(SIGHUP, NULL, &old_sigterm_action);
1204
perror("sigaction");
1205
return EXIT_FAILURE;
1207
if(old_sigterm_action.sa_handler != SIG_IGN){
1208
ret = sigaction(SIGHUP, &sigterm_action, NULL);
1210
perror("sigaction");
1211
exitcode = EXIT_FAILURE;
1215
ret = sigaction(SIGTERM, NULL, &old_sigterm_action);
1217
perror("sigaction");
1218
return EXIT_FAILURE;
1220
if(old_sigterm_action.sa_handler != SIG_IGN){
1221
ret = sigaction(SIGTERM, &sigterm_action, NULL);
1223
perror("sigaction");
1001
1224
exitcode = EXIT_FAILURE;
1006
1229
/* If the interface is down, bring it up */
1007
1230
if(interface[0] != '\0'){
1231
if_index = (AvahiIfIndex) if_nametoindex(interface);
1233
fprintf(stderr, "No such interface: \"%s\"\n", interface);
1234
exitcode = EXIT_FAILURE;
1242
/* Re-raise priviliges */
1008
1249
#ifdef __linux__
1009
1250
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1010
messages to mess up the prompt */
1251
messages about the network interface to mess up the prompt */
1011
1252
ret = klogctl(8, NULL, 5);
1012
1253
bool restore_loglevel = true;
1014
1255
restore_loglevel = false;
1015
1256
perror("klogctl");
1258
#endif /* __linux__ */
1019
1260
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1217
1499
/* Create the Avahi service browser */
1218
1500
sb = avahi_s_service_browser_new(mc.server, if_index,
1219
AVAHI_PROTO_INET6, "_mandos._tcp",
1501
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
1220
1502
NULL, 0, browse_callback, NULL);
1221
1503
if(sb == NULL){
1222
1504
fprintf(stderr, "Failed to create service browser: %s\n",
1273
1545
gpgme_release(mc.ctx);
1548
/* Take down the network interface */
1549
if(take_down_interface){
1550
/* Re-raise priviliges */
1557
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1559
perror("ioctl SIOCGIFFLAGS");
1560
} else if(network.ifr_flags & IFF_UP) {
1561
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
1562
ret = ioctl(sd, SIOCSIFFLAGS, &network);
1564
perror("ioctl SIOCSIFFLAGS");
1567
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1571
/* Lower privileges permanently */
1276
1580
/* Removes the temp directory used by GPGME */
1277
1581
if(tempdir_created){