25
26
* along with this program. If not, see
26
27
* <http://www.gnu.org/licenses/>.
28
* Contact the authors at <https://www.fukt.bsnet.se/~belorn/> and
29
* <https://www.fukt.bsnet.se/~teddy/>.
29
* Contact the authors at <mandos@fukt.bsnet.se>.
32
32
/* Needed by GPGME, specifically gpgme_data_seek() */
33
33
#define _LARGEFILE_SOURCE
34
34
#define _FILE_OFFSET_BITS 64
40
#include <net/if.h> /* if_nametoindex */
36
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
38
#include <stdio.h> /* fprintf(), stderr, fwrite(),
39
stdout, ferror(), sscanf */
40
#include <stdint.h> /* uint16_t, uint32_t */
41
#include <stddef.h> /* NULL, size_t, ssize_t */
42
#include <stdlib.h> /* free(), EXIT_SUCCESS, EXIT_FAILURE,
44
#include <stdbool.h> /* bool, true */
45
#include <string.h> /* memset(), strcmp(), strlen(),
46
strerror(), asprintf(), strcpy() */
47
#include <sys/ioctl.h> /* ioctl */
48
#include <sys/types.h> /* socket(), inet_pton(), sockaddr,
49
sockaddr_in6, PF_INET6,
50
SOCK_STREAM, INET6_ADDRSTRLEN,
51
uid_t, gid_t, open(), opendir(),
53
#include <sys/stat.h> /* open() */
54
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
55
struct in6_addr, inet_pton(),
57
#include <fcntl.h> /* open() */
58
#include <dirent.h> /* opendir(), struct dirent, readdir()
60
#include <inttypes.h> /* PRIu16, SCNu16 */
61
#include <assert.h> /* assert() */
62
#include <errno.h> /* perror(), errno */
63
#include <time.h> /* time() */
64
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
65
SIOCSIFFLAGS, if_indextoname(),
66
if_nametoindex(), IF_NAMESIZE */
67
#include <netinet/in.h>
68
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
69
getuid(), getgid(), setuid(),
71
#include <arpa/inet.h> /* inet_pton(), htons */
72
#include <iso646.h> /* not, and, or */
73
#include <argp.h> /* struct argp_option, error_t, struct
74
argp_state, struct argp,
75
argp_parse(), ARGP_KEY_ARG,
76
ARGP_KEY_END, ARGP_ERR_UNKNOWN */
79
/* All Avahi types, constants and functions
42
82
#include <avahi-core/core.h>
43
83
#include <avahi-core/lookup.h>
44
84
#include <avahi-core/log.h>
46
86
#include <avahi-common/malloc.h>
47
87
#include <avahi-common/error.h>
50
#include <sys/types.h> /* socket(), inet_pton() */
51
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
52
struct in6_addr, inet_pton() */
53
#include <gnutls/gnutls.h> /* All GnuTLS stuff */
54
#include <gnutls/openpgp.h> /* GnuTLS with openpgp stuff */
56
#include <unistd.h> /* close() */
57
#include <netinet/in.h>
58
#include <stdbool.h> /* true */
59
#include <string.h> /* memset */
60
#include <arpa/inet.h> /* inet_pton() */
61
#include <iso646.h> /* not */
64
#include <errno.h> /* perror() */
71
#define CERT_ROOT "/conf/conf.d/cryptkeyreq/"
73
#define CERTFILE CERT_ROOT "openpgp-client.txt"
74
#define KEYFILE CERT_ROOT "openpgp-client-key.txt"
90
#include <gnutls/gnutls.h> /* All GnuTLS types, constants and
93
init_gnutls_session(),
95
#include <gnutls/openpgp.h>
96
/* gnutls_certificate_set_openpgp_key_file(),
97
GNUTLS_OPENPGP_FMT_BASE64 */
100
#include <gpgme.h> /* All GPGME types, constants and
103
GPGME_PROTOCOL_OpenPGP,
75
106
#define BUFFER_SIZE 256
108
#define PATHDIR "/conf/conf.d/mandos"
109
#define SECKEY "seckey.txt"
110
#define PUBKEY "pubkey.txt"
78
112
bool debug = false;
113
static const char mandos_protocol_version[] = "1";
114
const char *argp_program_version = "mandos-client " VERSION;
115
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
117
/* Used for passing in values through the Avahi callback functions */
81
gnutls_session_t session;
119
AvahiSimplePoll *simple_poll;
82
121
gnutls_certificate_credentials_t cred;
122
unsigned int dh_bits;
83
123
gnutls_dh_params_t dh_params;
87
ssize_t pgp_packet_decrypt (char *packet, size_t packet_size,
88
char **new_packet, const char *homedir){
89
gpgme_data_t dh_crypto, dh_plain;
124
const char *priority;
129
* Make room in "buffer" for at least BUFFER_SIZE additional bytes.
130
* "buffer_capacity" is how much is currently allocated,
131
* "buffer_length" is how much is already used.
133
size_t adjustbuffer(char **buffer, size_t buffer_length,
134
size_t buffer_capacity){
135
if(buffer_length + BUFFER_SIZE > buffer_capacity){
136
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
140
buffer_capacity += BUFFER_SIZE;
142
return buffer_capacity;
148
static bool init_gpgme(mandos_context *mc, const char *seckey,
149
const char *pubkey, const char *tempdir){
93
ssize_t new_packet_capacity = 0;
94
ssize_t new_packet_length = 0;
95
152
gpgme_engine_info_t engine_info;
98
fprintf(stderr, "Trying to decrypt OpenPGP packet\n");
156
* Helper function to insert pub and seckey to the enigne keyring.
158
bool import_key(const char *filename){
160
gpgme_data_t pgp_data;
162
fd = (int)TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
168
rc = gpgme_data_new_from_fd(&pgp_data, fd);
169
if(rc != GPG_ERR_NO_ERROR){
170
fprintf(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
171
gpgme_strsource(rc), gpgme_strerror(rc));
175
rc = gpgme_op_import(mc->ctx, pgp_data);
176
if(rc != GPG_ERR_NO_ERROR){
177
fprintf(stderr, "bad gpgme_op_import: %s: %s\n",
178
gpgme_strsource(rc), gpgme_strerror(rc));
182
ret = (int)TEMP_FAILURE_RETRY(close(fd));
186
gpgme_data_release(pgp_data);
191
fprintf(stderr, "Initialize gpgme\n");
102
195
gpgme_check_version(NULL);
103
gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
196
rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
197
if(rc != GPG_ERR_NO_ERROR){
198
fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
199
gpgme_strsource(rc), gpgme_strerror(rc));
105
/* Set GPGME home directory */
106
rc = gpgme_get_engine_info (&engine_info);
107
if (rc != GPG_ERR_NO_ERROR){
203
/* Set GPGME home directory for the OpenPGP engine only */
204
rc = gpgme_get_engine_info(&engine_info);
205
if(rc != GPG_ERR_NO_ERROR){
108
206
fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
109
207
gpgme_strsource(rc), gpgme_strerror(rc));
112
210
while(engine_info != NULL){
113
211
if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){
114
212
gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,
115
engine_info->file_name, homedir);
213
engine_info->file_name, tempdir);
118
216
engine_info = engine_info->next;
120
218
if(engine_info == NULL){
121
fprintf(stderr, "Could not set home dir to %s\n", homedir);
125
/* Create new GPGME data buffer from packet buffer */
126
rc = gpgme_data_new_from_mem(&dh_crypto, packet, packet_size, 0);
127
if (rc != GPG_ERR_NO_ERROR){
219
fprintf(stderr, "Could not set GPGME home dir to %s\n", tempdir);
223
/* Create new GPGME "context" */
224
rc = gpgme_new(&(mc->ctx));
225
if(rc != GPG_ERR_NO_ERROR){
226
fprintf(stderr, "bad gpgme_new: %s: %s\n",
227
gpgme_strsource(rc), gpgme_strerror(rc));
231
if(not import_key(pubkey) or not import_key(seckey)){
239
* Decrypt OpenPGP data.
240
* Returns -1 on error
242
static ssize_t pgp_packet_decrypt(const mandos_context *mc,
243
const char *cryptotext,
246
gpgme_data_t dh_crypto, dh_plain;
249
size_t plaintext_capacity = 0;
250
ssize_t plaintext_length = 0;
253
fprintf(stderr, "Trying to decrypt OpenPGP data\n");
256
/* Create new GPGME data buffer from memory cryptotext */
257
rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
259
if(rc != GPG_ERR_NO_ERROR){
128
260
fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
129
261
gpgme_strsource(rc), gpgme_strerror(rc));
133
265
/* Create new empty GPGME data buffer for the plaintext */
134
266
rc = gpgme_data_new(&dh_plain);
135
if (rc != GPG_ERR_NO_ERROR){
267
if(rc != GPG_ERR_NO_ERROR){
136
268
fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
137
269
gpgme_strsource(rc), gpgme_strerror(rc));
141
/* Create new GPGME "context" */
142
rc = gpgme_new(&ctx);
143
if (rc != GPG_ERR_NO_ERROR){
144
fprintf(stderr, "bad gpgme_new: %s: %s\n",
145
gpgme_strsource(rc), gpgme_strerror(rc));
149
/* Decrypt data from the FILE pointer to the plaintext data
151
rc = gpgme_op_decrypt(ctx, dh_crypto, dh_plain);
152
if (rc != GPG_ERR_NO_ERROR){
270
gpgme_data_release(dh_crypto);
274
/* Decrypt data from the cryptotext data buffer to the plaintext
276
rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
277
if(rc != GPG_ERR_NO_ERROR){
153
278
fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
154
279
gpgme_strsource(rc), gpgme_strerror(rc));
280
plaintext_length = -1;
282
gpgme_decrypt_result_t result;
283
result = gpgme_op_decrypt_result(mc->ctx);
285
fprintf(stderr, "gpgme_op_decrypt_result failed\n");
287
fprintf(stderr, "Unsupported algorithm: %s\n",
288
result->unsupported_algorithm);
289
fprintf(stderr, "Wrong key usage: %u\n",
290
result->wrong_key_usage);
291
if(result->file_name != NULL){
292
fprintf(stderr, "File name: %s\n", result->file_name);
294
gpgme_recipient_t recipient;
295
recipient = result->recipients;
297
while(recipient != NULL){
298
fprintf(stderr, "Public key algorithm: %s\n",
299
gpgme_pubkey_algo_name(recipient->pubkey_algo));
300
fprintf(stderr, "Key ID: %s\n", recipient->keyid);
301
fprintf(stderr, "Secret key available: %s\n",
302
recipient->status == GPG_ERR_NO_SECKEY
304
recipient = recipient->next;
159
fprintf(stderr, "Decryption of OpenPGP packet succeeded\n");
163
gpgme_decrypt_result_t result;
164
result = gpgme_op_decrypt_result(ctx);
166
fprintf(stderr, "gpgme_op_decrypt_result failed\n");
168
fprintf(stderr, "Unsupported algorithm: %s\n",
169
result->unsupported_algorithm);
170
fprintf(stderr, "Wrong key usage: %d\n",
171
result->wrong_key_usage);
172
if(result->file_name != NULL){
173
fprintf(stderr, "File name: %s\n", result->file_name);
175
gpgme_recipient_t recipient;
176
recipient = result->recipients;
178
while(recipient != NULL){
179
fprintf(stderr, "Public key algorithm: %s\n",
180
gpgme_pubkey_algo_name(recipient->pubkey_algo));
181
fprintf(stderr, "Key ID: %s\n", recipient->keyid);
182
fprintf(stderr, "Secret key available: %s\n",
183
recipient->status == GPG_ERR_NO_SECKEY
185
recipient = recipient->next;
191
/* Delete the GPGME FILE pointer cryptotext data buffer */
192
gpgme_data_release(dh_crypto);
313
fprintf(stderr, "Decryption of OpenPGP data succeeded\n");
194
316
/* Seek back to the beginning of the GPGME plaintext data buffer */
195
gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET);
317
if(gpgme_data_seek(dh_plain, (off_t)0, SEEK_SET) == -1){
318
perror("gpgme_data_seek");
319
plaintext_length = -1;
199
if (new_packet_length + BUFFER_SIZE > new_packet_capacity){
200
*new_packet = realloc(*new_packet,
201
(unsigned int)new_packet_capacity
203
if (*new_packet == NULL){
207
new_packet_capacity += BUFFER_SIZE;
325
plaintext_capacity = adjustbuffer(plaintext,
326
(size_t)plaintext_length,
328
if(plaintext_capacity == 0){
329
perror("adjustbuffer");
330
plaintext_length = -1;
210
ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length,
334
ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
212
336
/* Print the data, if any */
217
342
perror("gpgme_data_read");
220
new_packet_length += ret;
223
/* FIXME: check characters before printing to screen so to not print
224
terminal control characters */
226
/* fprintf(stderr, "decrypted password is: "); */
227
/* fwrite(*new_packet, 1, new_packet_length, stderr); */
228
/* fprintf(stderr, "\n"); */
343
plaintext_length = -1;
346
plaintext_length += ret;
350
fprintf(stderr, "Decrypted password is: ");
351
for(ssize_t i = 0; i < plaintext_length; i++){
352
fprintf(stderr, "%02hhX ", (*plaintext)[i]);
354
fprintf(stderr, "\n");
359
/* Delete the GPGME cryptotext data buffer */
360
gpgme_data_release(dh_crypto);
231
362
/* Delete the GPGME plaintext data buffer */
232
363
gpgme_data_release(dh_plain);
233
return new_packet_length;
364
return plaintext_length;
236
static const char * safer_gnutls_strerror (int value) {
237
const char *ret = gnutls_strerror (value);
367
static const char * safer_gnutls_strerror(int value) {
368
const char *ret = gnutls_strerror(value); /* Spurious warning */
239
370
ret = "(unknown)";
243
void debuggnutls(__attribute__((unused)) int level,
245
fprintf(stderr, "%s", string);
374
/* GnuTLS log function callback */
375
static void debuggnutls(__attribute__((unused)) int level,
377
fprintf(stderr, "GnuTLS: %s", string);
248
int initgnutls(encrypted_session *es){
380
static int init_gnutls_global(mandos_context *mc,
381
const char *pubkeyfilename,
382
const char *seckeyfilename){
253
386
fprintf(stderr, "Initializing GnuTLS\n");
256
if ((ret = gnutls_global_init ())
257
!= GNUTLS_E_SUCCESS) {
258
fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
389
ret = gnutls_global_init();
390
if(ret != GNUTLS_E_SUCCESS) {
391
fprintf(stderr, "GnuTLS global_init: %s\n",
392
safer_gnutls_strerror(ret));
397
/* "Use a log level over 10 to enable all debugging options."
263
400
gnutls_global_set_log_level(11);
264
401
gnutls_global_set_log_function(debuggnutls);
267
/* openpgp credentials */
268
if ((ret = gnutls_certificate_allocate_credentials (&es->cred))
269
!= GNUTLS_E_SUCCESS) {
270
fprintf (stderr, "memory error: %s\n",
271
safer_gnutls_strerror(ret));
404
/* OpenPGP credentials */
405
gnutls_certificate_allocate_credentials(&mc->cred);
406
if(ret != GNUTLS_E_SUCCESS){
407
fprintf(stderr, "GnuTLS memory error: %s\n", /* Spurious
409
safer_gnutls_strerror(ret));
410
gnutls_global_deinit();
276
fprintf(stderr, "Attempting to use OpenPGP certificate %s"
277
" and keyfile %s as GnuTLS credentials\n", CERTFILE,
415
fprintf(stderr, "Attempting to use OpenPGP public key %s and"
416
" secret key %s as GnuTLS credentials\n", pubkeyfilename,
281
420
ret = gnutls_certificate_set_openpgp_key_file
282
(es->cred, CERTFILE, KEYFILE, GNUTLS_OPENPGP_FMT_BASE64);
283
if (ret != GNUTLS_E_SUCCESS) {
285
(stderr, "Error[%d] while reading the OpenPGP key pair ('%s',"
287
ret, CERTFILE, KEYFILE);
288
fprintf(stdout, "The Error is: %s\n",
289
safer_gnutls_strerror(ret));
293
//GnuTLS server initialization
294
if ((ret = gnutls_dh_params_init (&es->dh_params))
295
!= GNUTLS_E_SUCCESS) {
296
fprintf (stderr, "Error in dh parameter initialization: %s\n",
297
safer_gnutls_strerror(ret));
301
if ((ret = gnutls_dh_params_generate2 (es->dh_params, DH_BITS))
302
!= GNUTLS_E_SUCCESS) {
303
fprintf (stderr, "Error in prime generation: %s\n",
304
safer_gnutls_strerror(ret));
308
gnutls_certificate_set_dh_params (es->cred, es->dh_params);
310
// GnuTLS session creation
311
if ((ret = gnutls_init (&es->session, GNUTLS_SERVER))
312
!= GNUTLS_E_SUCCESS){
421
(mc->cred, pubkeyfilename, seckeyfilename,
422
GNUTLS_OPENPGP_FMT_BASE64);
423
if(ret != GNUTLS_E_SUCCESS) {
425
"Error[%d] while reading the OpenPGP key pair ('%s',"
426
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
427
fprintf(stderr, "The GnuTLS error is: %s\n",
428
safer_gnutls_strerror(ret));
432
/* GnuTLS server initialization */
433
ret = gnutls_dh_params_init(&mc->dh_params);
434
if(ret != GNUTLS_E_SUCCESS) {
435
fprintf(stderr, "Error in GnuTLS DH parameter initialization:"
436
" %s\n", safer_gnutls_strerror(ret));
439
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
440
if(ret != GNUTLS_E_SUCCESS) {
441
fprintf(stderr, "Error in GnuTLS prime generation: %s\n",
442
safer_gnutls_strerror(ret));
446
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
452
gnutls_certificate_free_credentials(mc->cred);
453
gnutls_global_deinit();
454
gnutls_dh_params_deinit(mc->dh_params);
458
static int init_gnutls_session(mandos_context *mc,
459
gnutls_session_t *session){
461
/* GnuTLS session creation */
462
ret = gnutls_init(session, GNUTLS_SERVER);
463
if(ret != GNUTLS_E_SUCCESS){
313
464
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
314
465
safer_gnutls_strerror(ret));
317
if ((ret = gnutls_priority_set_direct (es->session, "NORMAL", &err))
318
!= GNUTLS_E_SUCCESS) {
319
fprintf(stderr, "Syntax error at: %s\n", err);
320
fprintf(stderr, "GnuTLS error: %s\n",
321
safer_gnutls_strerror(ret));
470
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
471
if(ret != GNUTLS_E_SUCCESS) {
472
fprintf(stderr, "Syntax error at: %s\n", err);
473
fprintf(stderr, "GnuTLS error: %s\n",
474
safer_gnutls_strerror(ret));
475
gnutls_deinit(*session);
325
if ((ret = gnutls_credentials_set
326
(es->session, GNUTLS_CRD_CERTIFICATE, es->cred))
327
!= GNUTLS_E_SUCCESS) {
328
fprintf(stderr, "Error setting a credentials set: %s\n",
480
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
482
if(ret != GNUTLS_E_SUCCESS) {
483
fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
329
484
safer_gnutls_strerror(ret));
485
gnutls_deinit(*session);
333
489
/* ignore client certificate if any. */
334
gnutls_certificate_server_set_request (es->session,
490
gnutls_certificate_server_set_request(*session,
337
gnutls_dh_set_prime_bits (es->session, DH_BITS);
493
gnutls_dh_set_prime_bits(*session, mc->dh_bits);
342
void empty_log(__attribute__((unused)) AvahiLogLevel level,
343
__attribute__((unused)) const char *txt){}
498
/* Avahi log function callback */
499
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
500
__attribute__((unused)) const char *txt){}
345
int start_mandos_communication(const char *ip, uint16_t port,
346
AvahiIfIndex if_index){
502
/* Called when a Mandos server is found */
503
static int start_mandos_communication(const char *ip, uint16_t port,
504
AvahiIfIndex if_index,
348
struct sockaddr_in6 to;
349
encrypted_session es;
508
union { struct sockaddr in; struct sockaddr_in6 in6; } to;
350
509
char *buffer = NULL;
351
510
char *decrypted_buffer;
352
511
size_t buffer_length = 0;
353
512
size_t buffer_capacity = 0;
354
513
ssize_t decrypted_buffer_size;
357
516
char interface[IF_NAMESIZE];
517
gnutls_session_t session;
519
ret = init_gnutls_session(mc, &session);
360
fprintf(stderr, "Setting up a tcp connection to %s, port %d\n",
525
fprintf(stderr, "Setting up a tcp connection to %s, port %" PRIu16
364
529
tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
370
if(if_indextoname((unsigned int)if_index, interface) == NULL){
536
if(if_indextoname((unsigned int)if_index, interface) == NULL){
372
537
perror("if_indextoname");
378
540
fprintf(stderr, "Binding to interface %s\n", interface);
381
memset(&to,0,sizeof(to)); /* Spurious warning */
382
to.sin6_family = AF_INET6;
383
ret = inet_pton(AF_INET6, ip, &to.sin6_addr);
543
memset(&to, 0, sizeof(to));
544
to.in6.sin6_family = AF_INET6;
545
/* It would be nice to have a way to detect if we were passed an
546
IPv4 address here. Now we assume an IPv6 address. */
547
ret = inet_pton(AF_INET6, ip, &to.in6.sin6_addr);
385
549
perror("inet_pton");
389
553
fprintf(stderr, "Bad address: %s\n", ip);
392
to.sin6_port = htons(port); /* Spurious warning */
556
to.in6.sin6_port = htons(port); /* Spurious warning */
394
to.sin6_scope_id = (uint32_t)if_index;
558
to.in6.sin6_scope_id = (uint32_t)if_index;
397
fprintf(stderr, "Connection to: %s, port %d\n", ip, port);
398
/* char addrstr[INET6_ADDRSTRLEN]; */
399
/* if(inet_ntop(to.sin6_family, &(to.sin6_addr), addrstr, */
400
/* sizeof(addrstr)) == NULL){ */
401
/* perror("inet_ntop"); */
403
/* fprintf(stderr, "Really connecting to: %s, port %d\n", */
404
/* addrstr, ntohs(to.sin6_port)); */
561
fprintf(stderr, "Connection to: %s, port %" PRIu16 "\n", ip,
563
char addrstr[INET6_ADDRSTRLEN] = "";
564
if(inet_ntop(to.in6.sin6_family, &(to.in6.sin6_addr), addrstr,
565
sizeof(addrstr)) == NULL){
568
if(strcmp(addrstr, ip) != 0){
569
fprintf(stderr, "Canonical address form: %s\n", addrstr);
408
ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
574
ret = connect(tcp_sd, &to.in, sizeof(to));
410
576
perror("connect");
414
ret = initgnutls (&es);
580
const char *out = mandos_protocol_version;
583
size_t out_size = strlen(out);
584
ret = (int)TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
585
out_size - written));
591
written += (size_t)ret;
592
if(written < out_size){
595
if(out == mandos_protocol_version){
420
gnutls_transport_set_ptr (es.session,
421
(gnutls_transport_ptr_t) tcp_sd);
424
605
fprintf(stderr, "Establishing TLS session with %s\n", ip);
427
ret = gnutls_handshake (es.session);
429
if (ret != GNUTLS_E_SUCCESS){
608
gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
611
ret = gnutls_handshake(session);
612
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
614
if(ret != GNUTLS_E_SUCCESS){
431
fprintf(stderr, "\n*** Handshake failed ***\n");
616
fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
438
//Retrieve OpenPGP packet that contains the wanted password
623
/* Read OpenPGP packet that contains the wanted password */
441
626
fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
446
if (buffer_length + BUFFER_SIZE > buffer_capacity){
447
buffer = realloc(buffer, buffer_capacity + BUFFER_SIZE);
452
buffer_capacity += BUFFER_SIZE;
631
buffer_capacity = adjustbuffer(&buffer, buffer_length,
633
if(buffer_capacity == 0){
634
perror("adjustbuffer");
455
ret = gnutls_record_recv
456
(es.session, buffer+buffer_length, BUFFER_SIZE);
639
sret = gnutls_record_recv(session, buffer+buffer_length,
462
646
case GNUTLS_E_INTERRUPTED:
463
647
case GNUTLS_E_AGAIN:
465
649
case GNUTLS_E_REHANDSHAKE:
466
ret = gnutls_handshake (es.session);
468
fprintf(stderr, "\n*** Handshake failed ***\n");
651
ret = gnutls_handshake(session);
652
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
654
fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
475
661
fprintf(stderr, "Unknown error while reading data from"
476
" encrypted session with mandos server\n");
662
" encrypted session with Mandos server\n");
478
gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
664
gnutls_bye(session, GNUTLS_SHUT_RDWR);
482
buffer_length += (size_t) ret;
668
buffer_length += (size_t) sret;
486
if (buffer_length > 0){
487
decrypted_buffer_size = pgp_packet_decrypt(buffer,
673
fprintf(stderr, "Closing TLS session\n");
676
gnutls_bye(session, GNUTLS_SHUT_RDWR);
678
if(buffer_length > 0){
679
decrypted_buffer_size = pgp_packet_decrypt(mc, buffer,
491
if (decrypted_buffer_size >= 0){
682
if(decrypted_buffer_size >= 0){
492
684
while(written < (size_t) decrypted_buffer_size){
493
ret = (int)fwrite (decrypted_buffer + written, 1,
494
(size_t)decrypted_buffer_size - written,
685
ret = (int)fwrite(decrypted_buffer + written, 1,
686
(size_t)decrypted_buffer_size - written,
496
688
if(ret == 0 and ferror(stdout)){
498
690
fprintf(stderr, "Error writing encrypted data: %s\n",
561
748
char ip[AVAHI_ADDRESS_STR_MAX];
562
749
avahi_address_snprint(ip, sizeof(ip), address);
564
fprintf(stderr, "Mandos server \"%s\" found on %s (%s) on"
565
" port %d\n", name, host_name, ip, port);
751
fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %"
752
PRIu16 ") on port %d\n", name, host_name, ip,
567
int ret = start_mandos_communication(ip, port, interface);
755
int ret = start_mandos_communication(ip, port, interface, mc);
757
avahi_simple_poll_quit(mc->simple_poll);
573
761
avahi_s_service_resolver_free(r);
576
static void browse_callback(
577
AvahiSServiceBrowser *b,
578
AvahiIfIndex interface,
579
AvahiProtocol protocol,
580
AvahiBrowserEvent event,
584
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
587
AvahiServer *s = userdata;
588
assert(b); /* Spurious warning */
590
/* Called whenever a new services becomes available on the LAN or
591
is removed from the LAN */
595
case AVAHI_BROWSER_FAILURE:
597
fprintf(stderr, "(Browser) %s\n",
598
avahi_strerror(avahi_server_errno(server)));
599
avahi_simple_poll_quit(simple_poll);
602
case AVAHI_BROWSER_NEW:
603
/* We ignore the returned resolver object. In the callback
604
function we free it. If the server is terminated before
605
the callback function is called the server will free
606
the resolver for us. */
608
if (!(avahi_s_service_resolver_new(s, interface, protocol, name,
610
AVAHI_PROTO_INET6, 0,
611
resolve_callback, s)))
612
fprintf(stderr, "Failed to resolve service '%s': %s\n", name,
613
avahi_strerror(avahi_server_errno(s)));
616
case AVAHI_BROWSER_REMOVE:
619
case AVAHI_BROWSER_ALL_FOR_NOW:
620
case AVAHI_BROWSER_CACHE_EXHAUSTED:
764
static void browse_callback( AvahiSServiceBrowser *b,
765
AvahiIfIndex interface,
766
AvahiProtocol protocol,
767
AvahiBrowserEvent event,
771
AVAHI_GCC_UNUSED AvahiLookupResultFlags
774
mandos_context *mc = userdata;
777
/* Called whenever a new services becomes available on the LAN or
778
is removed from the LAN */
782
case AVAHI_BROWSER_FAILURE:
784
fprintf(stderr, "(Avahi browser) %s\n",
785
avahi_strerror(avahi_server_errno(mc->server)));
786
avahi_simple_poll_quit(mc->simple_poll);
789
case AVAHI_BROWSER_NEW:
790
/* We ignore the returned Avahi resolver object. In the callback
791
function we free it. If the Avahi server is terminated before
792
the callback function is called the Avahi server will free the
795
if(!(avahi_s_service_resolver_new(mc->server, interface,
796
protocol, name, type, domain,
797
AVAHI_PROTO_INET6, 0,
798
resolve_callback, mc)))
799
fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
800
name, avahi_strerror(avahi_server_errno(mc->server)));
803
case AVAHI_BROWSER_REMOVE:
806
case AVAHI_BROWSER_ALL_FOR_NOW:
807
case AVAHI_BROWSER_CACHE_EXHAUSTED:
809
fprintf(stderr, "No Mandos server found, still searching...\n");
625
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
626
AvahiServerConfig config;
815
int main(int argc, char *argv[]){
627
816
AvahiSServiceBrowser *sb = NULL;
630
int returncode = EXIT_SUCCESS;
631
const char *interface = NULL;
819
int exitcode = EXIT_SUCCESS;
820
const char *interface = "eth0";
821
struct ifreq network;
825
char *connect_to = NULL;
826
char tempdir[] = "/tmp/mandosXXXXXX";
632
827
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
633
char *connect_to = NULL;
636
static struct option long_options[] = {
637
{"debug", no_argument, (int *)&debug, 1},
638
{"connect", required_argument, 0, 'c'},
639
{"interface", required_argument, 0, 'i'},
642
int option_index = 0;
643
ret = getopt_long (argc, argv, "i:", long_options,
664
if(interface != NULL){
665
if_index = (AvahiIfIndex) if_nametoindex(interface);
667
fprintf(stderr, "No such interface: \"%s\"\n", interface);
828
const char *seckey = PATHDIR "/" SECKEY;
829
const char *pubkey = PATHDIR "/" PUBKEY;
831
mandos_context mc = { .simple_poll = NULL, .server = NULL,
832
.dh_bits = 1024, .priority = "SECURE256"
833
":!CTYPE-X.509:+CTYPE-OPENPGP" };
834
bool gnutls_initalized = false;
835
bool gpgme_initalized = false;
838
struct argp_option options[] = {
839
{ .name = "debug", .key = 128,
840
.doc = "Debug mode", .group = 3 },
841
{ .name = "connect", .key = 'c',
842
.arg = "ADDRESS:PORT",
843
.doc = "Connect directly to a specific Mandos server",
845
{ .name = "interface", .key = 'i',
847
.doc = "Interface that will be used to search for Mandos"
850
{ .name = "seckey", .key = 's',
852
.doc = "OpenPGP secret key file base name",
854
{ .name = "pubkey", .key = 'p',
856
.doc = "OpenPGP public key file base name",
858
{ .name = "dh-bits", .key = 129,
860
.doc = "Bit length of the prime number used in the"
861
" Diffie-Hellman key exchange",
863
{ .name = "priority", .key = 130,
865
.doc = "GnuTLS priority string for the TLS handshake",
870
error_t parse_opt(int key, char *arg,
871
struct argp_state *state) {
873
case 128: /* --debug */
876
case 'c': /* --connect */
879
case 'i': /* --interface */
882
case 's': /* --seckey */
885
case 'p': /* --pubkey */
888
case 129: /* --dh-bits */
889
ret = sscanf(arg, "%u", &mc.dh_bits);
891
fprintf(stderr, "Bad number of DH bits\n");
895
case 130: /* --priority */
903
return ARGP_ERR_UNKNOWN;
908
struct argp argp = { .options = options, .parser = parse_opt,
910
.doc = "Mandos client -- Get and decrypt"
911
" passwords from a Mandos server" };
912
ret = argp_parse(&argp, argc, argv, 0, 0, NULL);
913
if(ret == ARGP_ERR_UNKNOWN){
914
fprintf(stderr, "Unknown error while parsing arguments\n");
915
exitcode = EXIT_FAILURE;
920
/* If the interface is down, bring it up */
922
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
925
exitcode = EXIT_FAILURE;
928
strcpy(network.ifr_name, interface);
929
ret = ioctl(sd, SIOCGIFFLAGS, &network);
931
perror("ioctl SIOCGIFFLAGS");
932
exitcode = EXIT_FAILURE;
935
if((network.ifr_flags & IFF_UP) == 0){
936
network.ifr_flags |= IFF_UP;
937
ret = ioctl(sd, SIOCSIFFLAGS, &network);
939
perror("ioctl SIOCSIFFLAGS");
940
exitcode = EXIT_FAILURE;
944
ret = (int)TEMP_FAILURE_RETRY(close(sd));
963
ret = init_gnutls_global(&mc, pubkey, seckey);
965
fprintf(stderr, "init_gnutls_global failed\n");
966
exitcode = EXIT_FAILURE;
969
gnutls_initalized = true;
972
if(mkdtemp(tempdir) == NULL){
978
if(not init_gpgme(&mc, pubkey, seckey, tempdir)){
979
fprintf(stderr, "gpgme_initalized failed\n");
980
exitcode = EXIT_FAILURE;
983
gpgme_initalized = true;
986
if_index = (AvahiIfIndex) if_nametoindex(interface);
988
fprintf(stderr, "No such interface: \"%s\"\n", interface);
672
992
if(connect_to != NULL){
675
995
char *address = strrchr(connect_to, ':');
676
996
if(address == NULL){
677
997
fprintf(stderr, "No colon in address\n");
998
exitcode = EXIT_FAILURE;
681
uint16_t port = (uint16_t) strtol(address+1, NULL, 10);
683
perror("Bad port number");
1002
ret = sscanf(address+1, "%" SCNu16, &port);
1004
fprintf(stderr, "Bad port number\n");
1005
exitcode = EXIT_FAILURE;
686
1008
*address = '\0';
687
1009
address = connect_to;
688
ret = start_mandos_communication(address, port, if_index);
1010
ret = start_mandos_communication(address, port, if_index, &mc);
1012
exitcode = EXIT_FAILURE;
1014
exitcode = EXIT_SUCCESS;
697
1020
avahi_set_log_function(empty_log);
700
/* Initialize the psuedo-RNG */
1023
/* Initialize the pseudo-RNG for Avahi */
701
1024
srand((unsigned int) time(NULL));
703
/* Allocate main loop object */
704
if (!(simple_poll = avahi_simple_poll_new())) {
705
fprintf(stderr, "Failed to create simple poll object.\n");
710
/* Do not publish any local records */
711
avahi_server_config_init(&config);
712
config.publish_hinfo = 0;
713
config.publish_addresses = 0;
714
config.publish_workstation = 0;
715
config.publish_domain = 0;
717
/* Allocate a new server */
718
server = avahi_server_new(avahi_simple_poll_get(simple_poll),
719
&config, NULL, NULL, &error);
721
/* Free the configuration data */
722
avahi_server_config_free(&config);
724
/* Check if creating the server object succeeded */
726
fprintf(stderr, "Failed to create server: %s\n",
1026
/* Allocate main Avahi loop object */
1027
mc.simple_poll = avahi_simple_poll_new();
1028
if(mc.simple_poll == NULL) {
1029
fprintf(stderr, "Avahi: Failed to create simple poll"
1031
exitcode = EXIT_FAILURE;
1036
AvahiServerConfig config;
1037
/* Do not publish any local Zeroconf records */
1038
avahi_server_config_init(&config);
1039
config.publish_hinfo = 0;
1040
config.publish_addresses = 0;
1041
config.publish_workstation = 0;
1042
config.publish_domain = 0;
1044
/* Allocate a new server */
1045
mc.server = avahi_server_new(avahi_simple_poll_get
1046
(mc.simple_poll), &config, NULL,
1049
/* Free the Avahi configuration data */
1050
avahi_server_config_free(&config);
1053
/* Check if creating the Avahi server object succeeded */
1054
if(mc.server == NULL) {
1055
fprintf(stderr, "Failed to create Avahi server: %s\n",
727
1056
avahi_strerror(error));
728
returncode = EXIT_FAILURE;
1057
exitcode = EXIT_FAILURE;
732
/* Create the service browser */
733
sb = avahi_s_service_browser_new(server, if_index,
1061
/* Create the Avahi service browser */
1062
sb = avahi_s_service_browser_new(mc.server, if_index,
734
1063
AVAHI_PROTO_INET6,
735
1064
"_mandos._tcp", NULL, 0,
736
browse_callback, server);
1065
browse_callback, &mc);
738
1067
fprintf(stderr, "Failed to create service browser: %s\n",
739
avahi_strerror(avahi_server_errno(server)));
740
returncode = EXIT_FAILURE;
1068
avahi_strerror(avahi_server_errno(mc.server)));
1069
exitcode = EXIT_FAILURE;
744
1073
/* Run the main loop */
747
fprintf(stderr, "Starting avahi loop search\n");
1076
fprintf(stderr, "Starting Avahi loop search\n");
750
avahi_simple_poll_loop(simple_poll);
1079
avahi_simple_poll_loop(mc.simple_poll);
755
1084
fprintf(stderr, "%s exiting\n", argv[0]);
758
1087
/* Cleanup things */
760
1089
avahi_s_service_browser_free(sb);
763
avahi_server_free(server);
766
avahi_simple_poll_free(simple_poll);
1091
if(mc.server != NULL)
1092
avahi_server_free(mc.server);
1094
if(mc.simple_poll != NULL)
1095
avahi_simple_poll_free(mc.simple_poll);
1097
if(gnutls_initalized){
1098
gnutls_certificate_free_credentials(mc.cred);
1099
gnutls_global_deinit();
1100
gnutls_dh_params_deinit(mc.dh_params);
1103
if(gpgme_initalized){
1104
gpgme_release(mc.ctx);
1107
/* Removes the temp directory used by GPGME */
1108
if(tempdir[0] != '\0'){
1110
struct dirent *direntry;
1111
d = opendir(tempdir);
1113
if(errno != ENOENT){
1118
direntry = readdir(d);
1119
if(direntry == NULL){
1122
if(direntry->d_type == DT_REG){
1123
char *fullname = NULL;
1124
ret = asprintf(&fullname, "%s/%s", tempdir,
1130
ret = unlink(fullname);
1132
fprintf(stderr, "unlink(\"%s\"): %s",
1133
fullname, strerror(errno));
1140
ret = rmdir(tempdir);
1141
if(ret == -1 and errno != ENOENT){