1
/* -*- coding: utf-8 -*- */
3
* Mandos client - get and decrypt data from a Mandos server
5
* This program is partly derived from an example program for an Avahi
6
* service browser, downloaded from
7
* <http://avahi.org/browser/examples/core-browse-services.c>. This
8
* includes the following functions: "resolve_callback",
9
* "browse_callback", and parts of "main".
12
* Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
14
* This program is free software: you can redistribute it and/or
15
* modify it under the terms of the GNU General Public License as
16
* published by the Free Software Foundation, either version 3 of the
17
* License, or (at your option) any later version.
19
* This program is distributed in the hope that it will be useful, but
20
* WITHOUT ANY WARRANTY; without even the implied warranty of
21
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22
* General Public License for more details.
24
* You should have received a copy of the GNU General Public License
25
* along with this program. If not, see
26
* <http://www.gnu.org/licenses/>.
28
* Contact the authors at <mandos@fukt.bsnet.se>.
2
This file is part of avahi.
4
avahi is free software; you can redistribute it and/or modify it
5
under the terms of the GNU Lesser General Public License as
6
published by the Free Software Foundation; either version 2.1 of the
7
License, or (at your option) any later version.
9
avahi is distributed in the hope that it will be useful, but WITHOUT
10
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
11
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
12
Public License for more details.
14
You should have received a copy of the GNU Lesser General Public
15
License along with avahi; if not, write to the Free Software
16
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
31
/* Needed by GPGME, specifically gpgme_data_seek() */
32
20
#define _LARGEFILE_SOURCE
33
21
#define _FILE_OFFSET_BITS 64
35
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
37
#include <stdio.h> /* fprintf(), stderr, fwrite(),
39
#include <stdint.h> /* uint16_t, uint32_t */
40
#include <stddef.h> /* NULL, size_t, ssize_t */
41
#include <stdlib.h> /* free(), EXIT_SUCCESS, EXIT_FAILURE,
43
#include <stdbool.h> /* bool, true */
44
#include <string.h> /* memset(), strcmp(), strlen(),
45
strerror(), asprintf(), strcpy() */
46
#include <sys/ioctl.h> /* ioctl */
47
#include <sys/types.h> /* socket(), inet_pton(), sockaddr,
48
sockaddr_in6, PF_INET6,
49
SOCK_STREAM, INET6_ADDRSTRLEN,
50
uid_t, gid_t, open(), opendir(), DIR */
51
#include <sys/stat.h> /* open() */
52
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
53
struct in6_addr, inet_pton(),
55
#include <fcntl.h> /* open() */
56
#include <dirent.h> /* opendir(), struct dirent, readdir() */
57
#include <inttypes.h> /* PRIu16 */
58
#include <assert.h> /* assert() */
59
#include <errno.h> /* perror(), errno */
60
#include <time.h> /* time() */
61
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
62
SIOCSIFFLAGS, if_indextoname(),
63
if_nametoindex(), IF_NAMESIZE */
64
#include <netinet/in.h>
65
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
66
getuid(), getgid(), setuid(),
68
#include <arpa/inet.h> /* inet_pton(), htons */
69
#include <iso646.h> /* not, and */
70
#include <argp.h> /* struct argp_option, error_t, struct
71
argp_state, struct argp,
72
argp_parse(), ARGP_KEY_ARG,
73
ARGP_KEY_END, ARGP_ERR_UNKNOWN */
76
/* All Avahi types, constants and functions
27
#include <net/if.h> /* if_nametoindex */
79
29
#include <avahi-core/core.h>
80
30
#include <avahi-core/lookup.h>
81
31
#include <avahi-core/log.h>
83
33
#include <avahi-common/malloc.h>
84
34
#include <avahi-common/error.h>
87
#include <gnutls/gnutls.h> /* All GnuTLS types, constants and
90
init_gnutls_session(),
92
#include <gnutls/openpgp.h> /* gnutls_certificate_set_openpgp_key_file(),
93
GNUTLS_OPENPGP_FMT_BASE64 */
96
#include <gpgme.h> /* All GPGME types, constants and
99
GPGME_PROTOCOL_OpenPGP,
37
#include <sys/types.h> /* socket(), setsockopt(), inet_pton() */
38
#include <sys/socket.h> /* socket(), setsockopt(), struct sockaddr_in6, struct in6_addr, inet_pton() */
39
#include <gnutls/gnutls.h> /* ALL GNUTLS STUFF */
40
#include <gnutls/openpgp.h> /* gnutls with openpgp stuff */
42
#include <unistd.h> /* close() */
43
#include <netinet/in.h>
44
#include <stdbool.h> /* true */
45
#include <string.h> /* memset */
46
#include <arpa/inet.h> /* inet_pton() */
47
#include <iso646.h> /* not */
50
#include <errno.h> /* perror() */
57
#define CERT_ROOT "/conf/conf.d/cryptkeyreq/"
59
#define CERTFILE CERT_ROOT "openpgp-client.txt"
60
#define KEYFILE CERT_ROOT "openpgp-client-key.txt"
102
61
#define BUFFER_SIZE 256
105
#define PATHDIR "/conf/conf.d/mandos"
108
#define PATHDIR "/conf/conf.d/mandos"
109
#define SECKEY "seckey.txt"
110
#define PUBKEY "pubkey.txt"
112
64
bool debug = false;
113
static const char mandos_protocol_version[] = "1";
114
const char *argp_program_version = "mandos-client 1.0";
115
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
65
char *interface = "eth0";
117
/* Used for passing in values through the Avahi callback functions */
119
AvahiSimplePoll *simple_poll;
68
gnutls_session_t session;
121
69
gnutls_certificate_credentials_t cred;
122
unsigned int dh_bits;
123
70
gnutls_dh_params_t dh_params;
124
const char *priority;
74
ssize_t gpg_packet_decrypt (char *packet, size_t packet_size, char **new_packet, char *homedir){
75
gpgme_data_t dh_crypto, dh_plain;
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){
79
size_t new_packet_capacity = 0;
80
size_t new_packet_length = 0;
152
81
gpgme_engine_info_t engine_info;
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 = 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 = TEMP_FAILURE_RETRY(close(fd));
186
gpgme_data_release(pgp_data);
191
fprintf(stderr, "Initialize gpgme\n");
84
fprintf(stderr, "Attempting to decrypt password from gpg packet\n");
195
88
gpgme_check_version(NULL);
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));
89
gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
203
/* Set GPGME home directory for the OpenPGP engine only */
91
/* Set GPGME home directory */
204
92
rc = gpgme_get_engine_info (&engine_info);
205
93
if (rc != GPG_ERR_NO_ERROR){
206
94
fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
207
95
gpgme_strsource(rc), gpgme_strerror(rc));
210
98
while(engine_info != NULL){
211
99
if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){
212
100
gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,
213
engine_info->file_name, tempdir);
101
engine_info->file_name, homedir);
216
104
engine_info = engine_info->next;
218
106
if(engine_info == NULL){
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,
107
fprintf(stderr, "Could not set home dir to %s\n", homedir);
111
/* Create new GPGME data buffer from packet buffer */
112
rc = gpgme_data_new_from_mem(&dh_crypto, packet, packet_size, 0);
259
113
if (rc != GPG_ERR_NO_ERROR){
260
114
fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
261
115
gpgme_strsource(rc), gpgme_strerror(rc));
267
121
if (rc != GPG_ERR_NO_ERROR){
268
122
fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
269
123
gpgme_strsource(rc), gpgme_strerror(rc));
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);
127
/* Create new GPGME "context" */
128
rc = gpgme_new(&ctx);
129
if (rc != GPG_ERR_NO_ERROR){
130
fprintf(stderr, "bad gpgme_new: %s: %s\n",
131
gpgme_strsource(rc), gpgme_strerror(rc));
135
/* Decrypt data from the FILE pointer to the plaintext data buffer */
136
rc = gpgme_op_decrypt(ctx, dh_crypto, dh_plain);
277
137
if (rc != GPG_ERR_NO_ERROR){
278
138
fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
279
139
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;
144
fprintf(stderr, "decryption of gpg packet succeeded\n");
148
gpgme_decrypt_result_t result;
149
result = gpgme_op_decrypt_result(ctx);
151
fprintf(stderr, "gpgme_op_decrypt_result failed\n");
153
fprintf(stderr, "Unsupported algorithm: %s\n", result->unsupported_algorithm);
154
fprintf(stderr, "Wrong key usage: %d\n", result->wrong_key_usage);
155
if(result->file_name != NULL){
156
fprintf(stderr, "File name: %s\n", result->file_name);
158
gpgme_recipient_t recipient;
159
recipient = result->recipients;
161
while(recipient != NULL){
162
fprintf(stderr, "Public key algorithm: %s\n",
163
gpgme_pubkey_algo_name(recipient->pubkey_algo));
164
fprintf(stderr, "Key ID: %s\n", recipient->keyid);
165
fprintf(stderr, "Secret key available: %s\n",
166
recipient->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
167
recipient = recipient->next;
313
fprintf(stderr, "Decryption of OpenPGP data succeeded\n");
173
/* Delete the GPGME FILE pointer cryptotext data buffer */
174
gpgme_data_release(dh_crypto);
316
176
/* Seek back to the beginning of the GPGME plaintext data buffer */
317
if (gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET) == -1){
318
perror("gpgme_data_seek");
319
plaintext_length = -1;
177
gpgme_data_seek(dh_plain, 0, SEEK_SET);
325
plaintext_capacity = adjustbuffer(plaintext,
326
(size_t)plaintext_length,
328
if (plaintext_capacity == 0){
329
perror("adjustbuffer");
330
plaintext_length = -1;
181
if (new_packet_length + BUFFER_SIZE > new_packet_capacity){
182
*new_packet = realloc(*new_packet, new_packet_capacity + BUFFER_SIZE);
183
if (*new_packet == NULL){
187
new_packet_capacity += BUFFER_SIZE;
334
ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
190
ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length, BUFFER_SIZE);
336
191
/* Print the data, if any */
193
/* If password is empty, then a incorrect error will be printed */
342
197
perror("gpgme_data_read");
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);
200
new_packet_length += ret;
203
/* FIXME: check characters before printing to screen so to not print
204
terminal control characters */
206
/* fprintf(stderr, "decrypted password is: "); */
207
/* fwrite(*new_packet, 1, new_packet_length, stderr); */
208
/* fprintf(stderr, "\n"); */
362
211
/* Delete the GPGME plaintext data buffer */
363
212
gpgme_data_release(dh_plain);
364
return plaintext_length;
213
return new_packet_length;
367
216
static const char * safer_gnutls_strerror (int value) {
368
const char *ret = gnutls_strerror (value); /* Spurious warning */
217
const char *ret = gnutls_strerror (value);
370
219
ret = "(unknown)";
374
/* GnuTLS log function callback */
375
static void debuggnutls(__attribute__((unused)) int level,
377
fprintf(stderr, "GnuTLS: %s", string);
223
void debuggnutls(int level, const char* string){
224
fprintf(stderr, "%s", string);
380
static int init_gnutls_global(mandos_context *mc,
381
const char *pubkeyfilename,
382
const char *seckeyfilename){
227
int initgnutls(encrypted_session *es){
386
fprintf(stderr, "Initializing GnuTLS\n");
232
fprintf(stderr, "Initializing gnutls\n");
389
ret = gnutls_global_init();
390
if (ret != GNUTLS_E_SUCCESS) {
391
fprintf (stderr, "GnuTLS global_init: %s\n",
392
safer_gnutls_strerror(ret));
236
if ((ret = gnutls_global_init ())
237
!= GNUTLS_E_SUCCESS) {
238
fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
397
/* "Use a log level over 10 to enable all debugging options."
400
243
gnutls_global_set_log_level(11);
401
244
gnutls_global_set_log_function(debuggnutls);
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 ();
248
/* openpgp credentials */
249
if ((ret = gnutls_certificate_allocate_credentials (&es->cred))
250
!= GNUTLS_E_SUCCESS) {
251
fprintf (stderr, "memory error: %s\n", safer_gnutls_strerror(ret));
415
fprintf(stderr, "Attempting to use OpenPGP public key %s and"
416
" secret key %s as GnuTLS credentials\n", pubkeyfilename,
256
fprintf(stderr, "Attempting to use openpgp certificate %s"
257
" and keyfile %s as gnutls credentials\n", CERTFILE, KEYFILE);
420
260
ret = gnutls_certificate_set_openpgp_key_file
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){
464
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
465
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);
480
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
482
if (ret != GNUTLS_E_SUCCESS) {
483
fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
484
safer_gnutls_strerror(ret));
485
gnutls_deinit (*session);
261
(es->cred, CERTFILE, KEYFILE, GNUTLS_OPENPGP_FMT_BASE64);
262
if (ret != GNUTLS_E_SUCCESS) {
264
(stderr, "Error[%d] while reading the OpenPGP key pair ('%s', '%s')\n",
265
ret, CERTFILE, KEYFILE);
266
fprintf(stdout, "The Error is: %s\n",
267
safer_gnutls_strerror(ret));
271
//Gnutls server initialization
272
if ((ret = gnutls_dh_params_init (&es->dh_params))
273
!= GNUTLS_E_SUCCESS) {
274
fprintf (stderr, "Error in dh parameter initialization: %s\n",
275
safer_gnutls_strerror(ret));
279
if ((ret = gnutls_dh_params_generate2 (es->dh_params, DH_BITS))
280
!= GNUTLS_E_SUCCESS) {
281
fprintf (stderr, "Error in prime generation: %s\n",
282
safer_gnutls_strerror(ret));
286
gnutls_certificate_set_dh_params (es->cred, es->dh_params);
288
// Gnutls session creation
289
if ((ret = gnutls_init (&es->session, GNUTLS_SERVER))
290
!= GNUTLS_E_SUCCESS){
291
fprintf(stderr, "Error in gnutls session initialization: %s\n",
292
safer_gnutls_strerror(ret));
295
if ((ret = gnutls_priority_set_direct (es->session, "NORMAL", &err))
296
!= GNUTLS_E_SUCCESS) {
297
fprintf(stderr, "Syntax error at: %s\n", err);
298
fprintf(stderr, "Gnutls error: %s\n",
299
safer_gnutls_strerror(ret));
303
if ((ret = gnutls_credentials_set
304
(es->session, GNUTLS_CRD_CERTIFICATE, es->cred))
305
!= GNUTLS_E_SUCCESS) {
306
fprintf(stderr, "Error setting a credentials set: %s\n",
307
safer_gnutls_strerror(ret));
489
311
/* ignore client certificate if any. */
490
gnutls_certificate_server_set_request (*session,
312
gnutls_certificate_server_set_request (es->session, GNUTLS_CERT_IGNORE);
493
gnutls_dh_set_prime_bits (*session, mc->dh_bits);
314
gnutls_dh_set_prime_bits (es->session, DH_BITS);
498
/* Avahi log function callback */
499
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
500
__attribute__((unused)) const char *txt){}
319
void empty_log(AvahiLogLevel level, const char *txt){}
502
/* Called when a Mandos server is found */
503
static int start_mandos_communication(const char *ip, uint16_t port,
504
AvahiIfIndex if_index,
321
int start_mandos_communcation(char *ip, uint16_t port){
507
union { struct sockaddr in; struct sockaddr_in6 in6; } to;
323
struct sockaddr_in6 to;
324
struct in6_addr ip_addr;
325
encrypted_session es;
508
326
char *buffer = NULL;
509
327
char *decrypted_buffer;
510
328
size_t buffer_length = 0;
511
329
size_t buffer_capacity = 0;
512
330
ssize_t decrypted_buffer_size;
515
char interface[IF_NAMESIZE];
516
gnutls_session_t session;
518
ret = init_gnutls_session (mc, &session);
524
fprintf(stderr, "Setting up a tcp connection to %s, port %" PRIu16
334
fprintf(stderr, "Setting up a tcp connection to %s\n", ip);
528
337
tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
530
339
perror("socket");
535
if(if_indextoname((unsigned int)if_index, interface) == NULL){
536
perror("if_indextoname");
539
344
fprintf(stderr, "Binding to interface %s\n", interface);
347
ret = setsockopt(tcp_sd, SOL_SOCKET, SO_BINDTODEVICE, interface, 5);
349
perror("setsockopt bindtodevice");
542
memset(&to, 0, sizeof(to));
543
to.in6.sin6_family = AF_INET6;
544
/* It would be nice to have a way to detect if we were passed an
545
IPv4 address here. Now we assume an IPv6 address. */
546
ret = inet_pton(AF_INET6, ip, &to.in6.sin6_addr);
353
memset(&to,0,sizeof(to));
354
to.sin6_family = AF_INET6;
355
ret = inet_pton(AF_INET6, ip, &ip_addr);
548
357
perror("inet_pton");
552
361
fprintf(stderr, "Bad address: %s\n", ip);
555
to.in6.sin6_port = htons(port); /* Spurious warning */
557
to.in6.sin6_scope_id = (uint32_t)if_index;
364
to.sin6_port = htons(port);
365
to.sin6_scope_id = if_nametoindex(interface);
560
fprintf(stderr, "Connection to: %s, port %" PRIu16 "\n", ip,
562
char addrstr[INET6_ADDRSTRLEN] = "";
563
if(inet_ntop(to.in6.sin6_family, &(to.in6.sin6_addr), addrstr,
564
sizeof(addrstr)) == NULL){
567
if(strcmp(addrstr, ip) != 0){
568
fprintf(stderr, "Canonical address form: %s\n", addrstr);
368
fprintf(stderr, "Connection to: %s\n", ip);
573
ret = connect(tcp_sd, &to.in, sizeof(to));
371
ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
575
373
perror("connect");
579
const char *out = mandos_protocol_version;
582
size_t out_size = strlen(out);
583
ret = TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
584
out_size - written));
590
written += (size_t)ret;
591
if(written < out_size){
594
if (out == mandos_protocol_version){
377
ret = initgnutls (&es);
384
gnutls_transport_set_ptr (es.session, (gnutls_transport_ptr_t) tcp_sd);
604
fprintf(stderr, "Establishing TLS session with %s\n", ip);
387
fprintf(stderr, "Establishing tls session with %s\n", ip);
607
gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) tcp_sd);
610
ret = gnutls_handshake (session);
611
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
391
ret = gnutls_handshake (es.session);
613
393
if (ret != GNUTLS_E_SUCCESS){
615
fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
394
fprintf(stderr, "\n*** Handshake failed ***\n");
622
/* Read OpenPGP packet that contains the wanted password */
400
//Retrieve gpg packet that contains the wanted password
625
fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
403
fprintf(stderr, "Retrieving pgp encrypted password from %s\n", ip);
630
buffer_capacity = adjustbuffer(&buffer, buffer_length,
632
if (buffer_capacity == 0){
633
perror("adjustbuffer");
407
if (buffer_length + BUFFER_SIZE > buffer_capacity){
408
buffer = realloc(buffer, buffer_capacity + BUFFER_SIZE);
413
buffer_capacity += BUFFER_SIZE;
638
ret = gnutls_record_recv(session, buffer+buffer_length,
416
ret = gnutls_record_recv
417
(es.session, buffer+buffer_length, BUFFER_SIZE);
646
424
case GNUTLS_E_AGAIN:
648
426
case GNUTLS_E_REHANDSHAKE:
650
ret = gnutls_handshake (session);
651
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
427
ret = gnutls_handshake (es.session);
653
fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
429
fprintf(stderr, "\n*** Handshake failed ***\n");
654
430
gnutls_perror (ret);
660
fprintf(stderr, "Unknown error while reading data from"
661
" encrypted session with Mandos server\n");
436
fprintf(stderr, "Unknown error while reading data from encrypted session with mandos server\n");
663
gnutls_bye (session, GNUTLS_SHUT_RDWR);
438
gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
667
buffer_length += (size_t) ret;
442
buffer_length += ret;
672
fprintf(stderr, "Closing TLS session\n");
675
gnutls_bye (session, GNUTLS_SHUT_RDWR);
677
446
if (buffer_length > 0){
678
decrypted_buffer_size = pgp_packet_decrypt(mc, buffer,
681
if (decrypted_buffer_size >= 0){
683
while(written < (size_t) decrypted_buffer_size){
684
ret = (int)fwrite (decrypted_buffer + written, 1,
685
(size_t)decrypted_buffer_size - written,
687
if(ret == 0 and ferror(stdout)){
689
fprintf(stderr, "Error writing encrypted data: %s\n",
695
written += (size_t)ret;
447
if ((decrypted_buffer_size = gpg_packet_decrypt(buffer, buffer_length, &decrypted_buffer, CERT_ROOT)) >= 0){
448
fwrite (decrypted_buffer, 1, decrypted_buffer_size, stdout);
697
449
free(decrypted_buffer);
705
/* Shutdown procedure */
458
fprintf(stderr, "Closing tls session\n");
709
ret = TEMP_FAILURE_RETRY(close(tcp_sd));
713
gnutls_deinit (session);
462
gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
465
gnutls_deinit (es.session);
466
gnutls_certificate_free_credentials (es.cred);
467
gnutls_global_deinit ();
717
static void resolve_callback(AvahiSServiceResolver *r,
718
AvahiIfIndex interface,
719
AVAHI_GCC_UNUSED AvahiProtocol protocol,
720
AvahiResolverEvent event,
724
const char *host_name,
725
const AvahiAddress *address,
727
AVAHI_GCC_UNUSED AvahiStringList *txt,
728
AVAHI_GCC_UNUSED AvahiLookupResultFlags
731
mandos_context *mc = userdata;
734
/* Called whenever a service has been resolved successfully or
739
case AVAHI_RESOLVER_FAILURE:
740
fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
741
" of type '%s' in domain '%s': %s\n", name, type, domain,
742
avahi_strerror(avahi_server_errno(mc->server)));
745
case AVAHI_RESOLVER_FOUND:
747
char ip[AVAHI_ADDRESS_STR_MAX];
748
avahi_address_snprint(ip, sizeof(ip), address);
750
fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %"
751
PRIu16 ") on port %d\n", name, host_name, ip,
754
int ret = start_mandos_communication(ip, port, interface, mc);
756
avahi_simple_poll_quit(mc->simple_poll);
760
avahi_s_service_resolver_free(r);
763
static void browse_callback( AvahiSServiceBrowser *b,
764
AvahiIfIndex interface,
765
AvahiProtocol protocol,
766
AvahiBrowserEvent event,
770
AVAHI_GCC_UNUSED AvahiLookupResultFlags
773
mandos_context *mc = userdata;
776
/* Called whenever a new services becomes available on the LAN or
777
is removed from the LAN */
781
case AVAHI_BROWSER_FAILURE:
783
fprintf(stderr, "(Avahi browser) %s\n",
784
avahi_strerror(avahi_server_errno(mc->server)));
785
avahi_simple_poll_quit(mc->simple_poll);
788
case AVAHI_BROWSER_NEW:
789
/* We ignore the returned Avahi resolver object. In the callback
790
function we free it. If the Avahi server is terminated before
791
the callback function is called the Avahi server will free the
794
if (!(avahi_s_service_resolver_new(mc->server, interface,
795
protocol, name, type, domain,
796
AVAHI_PROTO_INET6, 0,
797
resolve_callback, mc)))
798
fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
799
name, avahi_strerror(avahi_server_errno(mc->server)));
802
case AVAHI_BROWSER_REMOVE:
805
case AVAHI_BROWSER_ALL_FOR_NOW:
806
case AVAHI_BROWSER_CACHE_EXHAUSTED:
808
fprintf(stderr, "No Mandos server found, still searching...\n");
814
int main(int argc, char *argv[]){
471
static AvahiSimplePoll *simple_poll = NULL;
472
static AvahiServer *server = NULL;
474
static void resolve_callback(
475
AvahiSServiceResolver *r,
476
AVAHI_GCC_UNUSED AvahiIfIndex interface,
477
AVAHI_GCC_UNUSED AvahiProtocol protocol,
478
AvahiResolverEvent event,
482
const char *host_name,
483
const AvahiAddress *address,
485
AvahiStringList *txt,
486
AvahiLookupResultFlags flags,
487
AVAHI_GCC_UNUSED void* userdata) {
491
/* Called whenever a service has been resolved successfully or timed out */
494
case AVAHI_RESOLVER_FAILURE:
495
fprintf(stderr, "(Resolver) Failed to resolve service '%s' of type '%s' in domain '%s': %s\n", name, type, domain, avahi_strerror(avahi_server_errno(server)));
498
case AVAHI_RESOLVER_FOUND: {
499
char ip[AVAHI_ADDRESS_STR_MAX];
500
avahi_address_snprint(ip, sizeof(ip), address);
502
fprintf(stderr, "Mandos server found at %s on port %d\n", ip, port);
504
int ret = start_mandos_communcation(ip, port);
512
avahi_s_service_resolver_free(r);
515
static void browse_callback(
516
AvahiSServiceBrowser *b,
517
AvahiIfIndex interface,
518
AvahiProtocol protocol,
519
AvahiBrowserEvent event,
523
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
526
AvahiServer *s = userdata;
529
/* Called whenever a new services becomes available on the LAN or is removed from the LAN */
533
case AVAHI_BROWSER_FAILURE:
535
fprintf(stderr, "(Browser) %s\n", avahi_strerror(avahi_server_errno(server)));
536
avahi_simple_poll_quit(simple_poll);
539
case AVAHI_BROWSER_NEW:
540
/* We ignore the returned resolver object. In the callback
541
function we free it. If the server is terminated before
542
the callback function is called the server will free
543
the resolver for us. */
545
if (!(avahi_s_service_resolver_new(s, interface, protocol, name, type, domain, AVAHI_PROTO_INET6, 0, resolve_callback, s)))
546
fprintf(stderr, "Failed to resolve service '%s': %s\n", name, avahi_strerror(avahi_server_errno(s)));
550
case AVAHI_BROWSER_REMOVE:
553
case AVAHI_BROWSER_ALL_FOR_NOW:
554
case AVAHI_BROWSER_CACHE_EXHAUSTED:
559
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
560
AvahiServerConfig config;
815
561
AvahiSServiceBrowser *sb = NULL;
818
int exitcode = EXIT_SUCCESS;
819
const char *interface = "eth0";
820
struct ifreq network;
824
char *connect_to = NULL;
825
char tempdir[] = "/tmp/mandosXXXXXX";
826
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
827
const char *seckey = PATHDIR "/" SECKEY;
828
const char *pubkey = PATHDIR "/" PUBKEY;
830
mandos_context mc = { .simple_poll = NULL, .server = NULL,
831
.dh_bits = 1024, .priority = "SECURE256"
832
":!CTYPE-X.509:+CTYPE-OPENPGP" };
833
bool gnutls_initalized = false;
834
bool gpgme_initalized = false;
837
struct argp_option options[] = {
838
{ .name = "debug", .key = 128,
839
.doc = "Debug mode", .group = 3 },
840
{ .name = "connect", .key = 'c',
841
.arg = "ADDRESS:PORT",
842
.doc = "Connect directly to a specific Mandos server",
844
{ .name = "interface", .key = 'i',
846
.doc = "Interface that will be used to search for Mandos"
849
{ .name = "seckey", .key = 's',
851
.doc = "OpenPGP secret key file base name",
853
{ .name = "pubkey", .key = 'p',
855
.doc = "OpenPGP public key file base name",
857
{ .name = "dh-bits", .key = 129,
859
.doc = "Bit length of the prime number used in the"
860
" Diffie-Hellman key exchange",
862
{ .name = "priority", .key = 130,
864
.doc = "GnuTLS priority string for the TLS handshake",
869
error_t parse_opt (int key, char *arg,
870
struct argp_state *state) {
871
/* Get the INPUT argument from `argp_parse', which we know is
872
a pointer to our plugin list pointer. */
874
case 128: /* --debug */
877
case 'c': /* --connect */
880
case 'i': /* --interface */
883
case 's': /* --seckey */
886
case 'p': /* --pubkey */
889
case 129: /* --dh-bits */
891
mc.dh_bits = (unsigned int) strtol(arg, NULL, 10);
897
case 130: /* --priority */
905
return ARGP_ERR_UNKNOWN;
910
struct argp argp = { .options = options, .parser = parse_opt,
912
.doc = "Mandos client -- Get and decrypt"
913
" passwords from a Mandos server" };
914
ret = argp_parse (&argp, argc, argv, 0, 0, NULL);
915
if (ret == ARGP_ERR_UNKNOWN){
916
fprintf(stderr, "Unknown error while parsing arguments\n");
917
exitcode = EXIT_FAILURE;
922
/* If the interface is down, bring it up */
924
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
927
exitcode = EXIT_FAILURE;
930
strcpy(network.ifr_name, interface);
931
ret = ioctl(sd, SIOCGIFFLAGS, &network);
933
perror("ioctl SIOCGIFFLAGS");
934
exitcode = EXIT_FAILURE;
937
if((network.ifr_flags & IFF_UP) == 0){
938
network.ifr_flags |= IFF_UP;
939
ret = ioctl(sd, SIOCSIFFLAGS, &network);
941
perror("ioctl SIOCSIFFLAGS");
942
exitcode = EXIT_FAILURE;
946
ret = TEMP_FAILURE_RETRY(close(sd));
965
ret = init_gnutls_global(&mc, pubkey, seckey);
967
fprintf(stderr, "init_gnutls_global failed\n");
968
exitcode = EXIT_FAILURE;
971
gnutls_initalized = true;
974
if(mkdtemp(tempdir) == NULL){
980
if(not init_gpgme(&mc, pubkey, seckey, tempdir)){
981
fprintf(stderr, "gpgme_initalized failed\n");
982
exitcode = EXIT_FAILURE;
985
gpgme_initalized = true;
988
if_index = (AvahiIfIndex) if_nametoindex(interface);
990
fprintf(stderr, "No such interface: \"%s\"\n", interface);
994
if(connect_to != NULL){
995
/* Connect directly, do not use Zeroconf */
996
/* (Mainly meant for debugging) */
997
char *address = strrchr(connect_to, ':');
999
fprintf(stderr, "No colon in address\n");
1000
exitcode = EXIT_FAILURE;
1004
uint16_t port = (uint16_t) strtol(address+1, NULL, 10);
1006
perror("Bad port number");
1007
exitcode = EXIT_FAILURE;
1011
address = connect_to;
1012
ret = start_mandos_communication(address, port, if_index, &mc);
1014
exitcode = EXIT_FAILURE;
1016
exitcode = EXIT_SUCCESS;
564
int returncode = EXIT_SUCCESS;
567
static struct option long_options[] = {
568
{"debug", no_argument, (int *)&debug, 1},
569
{"interface", required_argument, 0, 'i'},
572
int option_index = 0;
573
ret = getopt_long (argc, argv, "i:", long_options, &option_index);
1022
591
avahi_set_log_function(empty_log);
1025
/* Initialize the pseudo-RNG for Avahi */
1026
srand((unsigned int) time(NULL));
1028
/* Allocate main Avahi loop object */
1029
mc.simple_poll = avahi_simple_poll_new();
1030
if (mc.simple_poll == NULL) {
1031
fprintf(stderr, "Avahi: Failed to create simple poll"
1033
exitcode = EXIT_FAILURE;
1038
AvahiServerConfig config;
1039
/* Do not publish any local Zeroconf records */
1040
avahi_server_config_init(&config);
1041
config.publish_hinfo = 0;
1042
config.publish_addresses = 0;
1043
config.publish_workstation = 0;
1044
config.publish_domain = 0;
1046
/* Allocate a new server */
1047
mc.server = avahi_server_new(avahi_simple_poll_get
1048
(mc.simple_poll), &config, NULL,
1051
/* Free the Avahi configuration data */
1052
avahi_server_config_free(&config);
1055
/* Check if creating the Avahi server object succeeded */
1056
if (mc.server == NULL) {
1057
fprintf(stderr, "Failed to create Avahi server: %s\n",
1058
avahi_strerror(error));
1059
exitcode = EXIT_FAILURE;
1063
/* Create the Avahi service browser */
1064
sb = avahi_s_service_browser_new(mc.server, if_index,
1066
"_mandos._tcp", NULL, 0,
1067
browse_callback, &mc);
1069
fprintf(stderr, "Failed to create service browser: %s\n",
1070
avahi_strerror(avahi_server_errno(mc.server)));
1071
exitcode = EXIT_FAILURE;
594
/* Initialize the psuedo-RNG */
597
/* Allocate main loop object */
598
if (!(simple_poll = avahi_simple_poll_new())) {
599
fprintf(stderr, "Failed to create simple poll object.\n");
604
/* Do not publish any local records */
605
avahi_server_config_init(&config);
606
config.publish_hinfo = 0;
607
config.publish_addresses = 0;
608
config.publish_workstation = 0;
609
config.publish_domain = 0;
611
/* Allocate a new server */
612
server = avahi_server_new(avahi_simple_poll_get(simple_poll), &config, NULL, NULL, &error);
614
/* Free the configuration data */
615
avahi_server_config_free(&config);
617
/* Check if creating the server object succeeded */
619
fprintf(stderr, "Failed to create server: %s\n", avahi_strerror(error));
620
returncode = EXIT_FAILURE;
624
/* Create the service browser */
625
if (!(sb = avahi_s_service_browser_new(server, if_nametoindex("eth0"), AVAHI_PROTO_INET6, "_mandos._tcp", NULL, 0, browse_callback, server))) {
626
fprintf(stderr, "Failed to create service browser: %s\n", avahi_strerror(avahi_server_errno(server)));
627
returncode = EXIT_FAILURE;
1075
631
/* Run the main loop */
1078
fprintf(stderr, "Starting Avahi loop search\n");
634
fprintf(stderr, "Starting avahi loop search\n");
1081
avahi_simple_poll_loop(mc.simple_poll);
637
avahi_simple_poll_loop(simple_poll);
1086
642
fprintf(stderr, "%s exiting\n", argv[0]);
1089
645
/* Cleanup things */
1091
647
avahi_s_service_browser_free(sb);
1093
if (mc.server != NULL)
1094
avahi_server_free(mc.server);
1096
if (mc.simple_poll != NULL)
1097
avahi_simple_poll_free(mc.simple_poll);
1099
if (gnutls_initalized){
1100
gnutls_certificate_free_credentials(mc.cred);
1101
gnutls_global_deinit ();
1102
gnutls_dh_params_deinit(mc.dh_params);
1105
if(gpgme_initalized){
1106
gpgme_release(mc.ctx);
1109
/* Removes the temp directory used by GPGME */
1110
if(tempdir[0] != '\0'){
1112
struct dirent *direntry;
1113
d = opendir(tempdir);
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);
650
avahi_server_free(server);
653
avahi_simple_poll_free(simple_poll);