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
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 © 2008,2009 Teddy Hogeborn
13
* Copyright © 2008,2009 Björn Påhlsson
15
* This program is free software: you can redistribute it and/or
16
* modify it under the terms of the GNU General Public License as
17
* published by the Free Software Foundation, either version 3 of the
18
* License, or (at your option) any later version.
20
* This program is distributed in the hope that it will be useful, but
21
* WITHOUT ANY WARRANTY; without even the implied warranty of
22
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23
* General Public License for more details.
25
* You should have received a copy of the GNU General Public License
26
* along with this program. If not, see
27
* <http://www.gnu.org/licenses/>.
29
* Contact the authors at <mandos@fukt.bsnet.se>.
32
/* Needed by GPGME, specifically gpgme_data_seek() */
20
33
#define _LARGEFILE_SOURCE
21
34
#define _FILE_OFFSET_BITS 64
27
#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, intmax_t, SCNdMAX */
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
29
82
#include <avahi-core/core.h>
30
83
#include <avahi-core/lookup.h>
31
84
#include <avahi-core/log.h>
33
86
#include <avahi-common/malloc.h>
34
87
#include <avahi-common/error.h>
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() */
55
#define CERT_ROOT "/conf/conf.d/cryptkeyreq/"
57
#define CERTFILE CERT_ROOT "openpgp-client.txt"
58
#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,
59
106
#define BUFFER_SIZE 256
108
#define PATHDIR "/conf/conf.d/mandos"
109
#define SECKEY "seckey.txt"
110
#define PUBKEY "pubkey.txt"
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 */
65
gnutls_session_t session;
119
AvahiSimplePoll *simple_poll;
66
121
gnutls_certificate_credentials_t cred;
122
unsigned int dh_bits;
67
123
gnutls_dh_params_t dh_params;
71
ssize_t gpg_packet_decrypt (char *packet, size_t packet_size, char **new_packet, char *homedir){
72
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){
76
size_t new_packet_capacity = 0;
77
size_t new_packet_length = 0;
78
152
gpgme_engine_info_t engine_info;
81
fprintf(stderr, "Attempting to decrypt password from gpg 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");
85
195
gpgme_check_version(NULL);
86
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));
88
/* Set GPGME home directory */
89
rc = gpgme_get_engine_info (&engine_info);
90
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){
91
206
fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
92
207
gpgme_strsource(rc), gpgme_strerror(rc));
95
210
while(engine_info != NULL){
96
211
if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){
97
212
gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,
98
engine_info->file_name, homedir);
213
engine_info->file_name, tempdir);
101
216
engine_info = engine_info->next;
103
218
if(engine_info == NULL){
104
fprintf(stderr, "Could not set home dir to %s\n", homedir);
108
/* Create new GPGME data buffer from packet buffer */
109
rc = gpgme_data_new_from_mem(&dh_crypto, packet, packet_size, 0);
110
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){
111
260
fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
112
261
gpgme_strsource(rc), gpgme_strerror(rc));
116
265
/* Create new empty GPGME data buffer for the plaintext */
117
266
rc = gpgme_data_new(&dh_plain);
118
if (rc != GPG_ERR_NO_ERROR){
267
if(rc != GPG_ERR_NO_ERROR){
119
268
fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
120
269
gpgme_strsource(rc), gpgme_strerror(rc));
124
/* Create new GPGME "context" */
125
rc = gpgme_new(&ctx);
126
if (rc != GPG_ERR_NO_ERROR){
127
fprintf(stderr, "bad gpgme_new: %s: %s\n",
128
gpgme_strsource(rc), gpgme_strerror(rc));
132
/* Decrypt data from the FILE pointer to the plaintext data buffer */
133
rc = gpgme_op_decrypt(ctx, dh_crypto, dh_plain);
134
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){
135
278
fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
136
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;
141
fprintf(stderr, "decryption of gpg packet succeeded\n");
145
gpgme_decrypt_result_t result;
146
result = gpgme_op_decrypt_result(ctx);
148
fprintf(stderr, "gpgme_op_decrypt_result failed\n");
150
fprintf(stderr, "Unsupported algorithm: %s\n", result->unsupported_algorithm);
151
fprintf(stderr, "Wrong key usage: %d\n", result->wrong_key_usage);
152
if(result->file_name != NULL){
153
fprintf(stderr, "File name: %s\n", result->file_name);
155
gpgme_recipient_t recipient;
156
recipient = result->recipients;
158
while(recipient != NULL){
159
fprintf(stderr, "Public key algorithm: %s\n",
160
gpgme_pubkey_algo_name(recipient->pubkey_algo));
161
fprintf(stderr, "Key ID: %s\n", recipient->keyid);
162
fprintf(stderr, "Secret key available: %s\n",
163
recipient->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
164
recipient = recipient->next;
170
/* Delete the GPGME FILE pointer cryptotext data buffer */
171
gpgme_data_release(dh_crypto);
313
fprintf(stderr, "Decryption of OpenPGP data succeeded\n");
173
316
/* Seek back to the beginning of the GPGME plaintext data buffer */
174
gpgme_data_seek(dh_plain, 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;
178
if (new_packet_length + BUFFER_SIZE > new_packet_capacity){
179
*new_packet = realloc(*new_packet, new_packet_capacity + BUFFER_SIZE);
180
if (*new_packet == NULL){
184
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;
187
ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length, BUFFER_SIZE);
334
ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
188
336
/* Print the data, if any */
190
/* If password is empty, then a incorrect error will be printed */
194
342
perror("gpgme_data_read");
343
plaintext_length = -1;
197
new_packet_length += ret;
346
plaintext_length += ret;
201
fprintf(stderr, "decrypted password is: %s\n", *new_packet);
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");
204
/* Delete the GPGME plaintext data buffer */
359
/* Delete the GPGME cryptotext data buffer */
360
gpgme_data_release(dh_crypto);
362
/* Delete the GPGME plaintext data buffer */
205
363
gpgme_data_release(dh_plain);
206
return new_packet_length;
364
return plaintext_length;
209
static const char * safer_gnutls_strerror (int value) {
210
const char *ret = gnutls_strerror (value);
367
static const char * safer_gnutls_strerror(int value) {
368
const char *ret = gnutls_strerror(value); /* Spurious warning from
369
-Wunreachable-code */
212
371
ret = "(unknown)";
216
void debuggnutls(int level, const char* string){
217
fprintf(stderr, "%s", string);
375
/* GnuTLS log function callback */
376
static void debuggnutls(__attribute__((unused)) int level,
378
fprintf(stderr, "GnuTLS: %s", string);
220
int initgnutls(encrypted_session *es){
381
static int init_gnutls_global(mandos_context *mc,
382
const char *pubkeyfilename,
383
const char *seckeyfilename){
225
fprintf(stderr, "Initializing gnutls\n");
387
fprintf(stderr, "Initializing GnuTLS\n");
229
if ((ret = gnutls_global_init ())
230
!= GNUTLS_E_SUCCESS) {
231
fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
390
ret = gnutls_global_init();
391
if(ret != GNUTLS_E_SUCCESS) {
392
fprintf(stderr, "GnuTLS global_init: %s\n",
393
safer_gnutls_strerror(ret));
398
/* "Use a log level over 10 to enable all debugging options."
236
401
gnutls_global_set_log_level(11);
237
402
gnutls_global_set_log_function(debuggnutls);
241
/* openpgp credentials */
242
if ((ret = gnutls_certificate_allocate_credentials (&es->cred))
243
!= GNUTLS_E_SUCCESS) {
244
fprintf (stderr, "memory error: %s\n", safer_gnutls_strerror(ret));
405
/* OpenPGP credentials */
406
gnutls_certificate_allocate_credentials(&mc->cred);
407
if(ret != GNUTLS_E_SUCCESS){
408
fprintf(stderr, "GnuTLS memory error: %s\n", /* Spurious warning
412
safer_gnutls_strerror(ret));
413
gnutls_global_deinit();
249
fprintf(stderr, "Attempting to use openpgp certificate %s"
250
" and keyfile %s as gnutls credentials\n", CERTFILE, KEYFILE);
418
fprintf(stderr, "Attempting to use OpenPGP public key %s and"
419
" secret key %s as GnuTLS credentials\n", pubkeyfilename,
253
423
ret = gnutls_certificate_set_openpgp_key_file
254
(es->cred, CERTFILE, KEYFILE, GNUTLS_OPENPGP_FMT_BASE64);
255
if (ret != GNUTLS_E_SUCCESS) {
257
(stderr, "Error[%d] while reading the OpenPGP key pair ('%s', '%s')\n",
258
ret, CERTFILE, KEYFILE);
259
fprintf(stdout, "The Error is: %s\n",
260
safer_gnutls_strerror(ret));
264
//Gnutls server initialization
265
if ((ret = gnutls_dh_params_init (&es->dh_params))
266
!= GNUTLS_E_SUCCESS) {
267
fprintf (stderr, "Error in dh parameter initialization: %s\n",
268
safer_gnutls_strerror(ret));
272
if ((ret = gnutls_dh_params_generate2 (es->dh_params, DH_BITS))
273
!= GNUTLS_E_SUCCESS) {
274
fprintf (stderr, "Error in prime generation: %s\n",
275
safer_gnutls_strerror(ret));
279
gnutls_certificate_set_dh_params (es->cred, es->dh_params);
281
// Gnutls session creation
282
if ((ret = gnutls_init (&es->session, GNUTLS_SERVER))
283
!= GNUTLS_E_SUCCESS){
284
fprintf(stderr, "Error in gnutls session initialization: %s\n",
285
safer_gnutls_strerror(ret));
288
if ((ret = gnutls_priority_set_direct (es->session, "NORMAL", &err))
289
!= GNUTLS_E_SUCCESS) {
290
fprintf(stderr, "Syntax error at: %s\n", err);
291
fprintf(stderr, "Gnutls error: %s\n",
292
safer_gnutls_strerror(ret));
296
if ((ret = gnutls_credentials_set
297
(es->session, GNUTLS_CRD_CERTIFICATE, es->cred))
298
!= GNUTLS_E_SUCCESS) {
299
fprintf(stderr, "Error setting a credentials set: %s\n",
300
safer_gnutls_strerror(ret));
424
(mc->cred, pubkeyfilename, seckeyfilename,
425
GNUTLS_OPENPGP_FMT_BASE64);
426
if(ret != GNUTLS_E_SUCCESS) {
428
"Error[%d] while reading the OpenPGP key pair ('%s',"
429
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
430
fprintf(stderr, "The GnuTLS error is: %s\n",
431
safer_gnutls_strerror(ret));
435
/* GnuTLS server initialization */
436
ret = gnutls_dh_params_init(&mc->dh_params);
437
if(ret != GNUTLS_E_SUCCESS) {
438
fprintf(stderr, "Error in GnuTLS DH parameter initialization:"
439
" %s\n", safer_gnutls_strerror(ret));
442
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
443
if(ret != GNUTLS_E_SUCCESS) {
444
fprintf(stderr, "Error in GnuTLS prime generation: %s\n",
445
safer_gnutls_strerror(ret));
449
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
455
gnutls_certificate_free_credentials(mc->cred);
456
gnutls_global_deinit();
457
gnutls_dh_params_deinit(mc->dh_params);
461
static int init_gnutls_session(mandos_context *mc,
462
gnutls_session_t *session){
464
/* GnuTLS session creation */
465
ret = gnutls_init(session, GNUTLS_SERVER);
466
if(ret != GNUTLS_E_SUCCESS){
467
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
468
safer_gnutls_strerror(ret));
473
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
474
if(ret != GNUTLS_E_SUCCESS) {
475
fprintf(stderr, "Syntax error at: %s\n", err);
476
fprintf(stderr, "GnuTLS error: %s\n",
477
safer_gnutls_strerror(ret));
478
gnutls_deinit(*session);
483
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
485
if(ret != GNUTLS_E_SUCCESS) {
486
fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
487
safer_gnutls_strerror(ret));
488
gnutls_deinit(*session);
304
492
/* ignore client certificate if any. */
305
gnutls_certificate_server_set_request (es->session, GNUTLS_CERT_IGNORE);
493
gnutls_certificate_server_set_request(*session,
307
gnutls_dh_set_prime_bits (es->session, DH_BITS);
496
gnutls_dh_set_prime_bits(*session, mc->dh_bits);
312
void empty_log(AvahiLogLevel level, const char *txt){}
501
/* Avahi log function callback */
502
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
503
__attribute__((unused)) const char *txt){}
314
int start_mandos_communcation(char *ip, uint16_t port){
505
/* Called when a Mandos server is found */
506
static int start_mandos_communication(const char *ip, uint16_t port,
507
AvahiIfIndex if_index,
316
struct sockaddr_in6 to;
317
struct in6_addr ip_addr;
318
encrypted_session es;
511
union { struct sockaddr in; struct sockaddr_in6 in6; } to;
319
512
char *buffer = NULL;
320
513
char *decrypted_buffer;
321
514
size_t buffer_length = 0;
322
515
size_t buffer_capacity = 0;
323
516
ssize_t decrypted_buffer_size;
325
const char interface[] = "eth0";
519
char interface[IF_NAMESIZE];
520
gnutls_session_t session;
522
ret = init_gnutls_session(mc, &session);
328
fprintf(stderr, "Setting up a tcp connection to %s\n", ip);
528
fprintf(stderr, "Setting up a tcp connection to %s, port %" PRIu16
331
532
tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
333
534
perror("socket");
539
if(if_indextoname((unsigned int)if_index, interface) == NULL){
540
perror("if_indextoname");
338
543
fprintf(stderr, "Binding to interface %s\n", interface);
341
ret = setsockopt(tcp_sd, SOL_SOCKET, SO_BINDTODEVICE, interface, 5);
343
perror("setsockopt bindtodevice");
347
memset(&to,0,sizeof(to));
348
to.sin6_family = AF_INET6;
349
ret = inet_pton(AF_INET6, ip, &ip_addr);
546
memset(&to, 0, sizeof(to));
547
to.in6.sin6_family = AF_INET6;
548
/* It would be nice to have a way to detect if we were passed an
549
IPv4 address here. Now we assume an IPv6 address. */
550
ret = inet_pton(AF_INET6, ip, &to.in6.sin6_addr);
351
552
perror("inet_pton");
355
556
fprintf(stderr, "Bad address: %s\n", ip);
358
to.sin6_port = htons(port);
359
to.sin6_scope_id = if_nametoindex(interface);
559
to.in6.sin6_port = htons(port); /* Spurious warnings from
561
-Wunreachable-code */
563
to.in6.sin6_scope_id = (uint32_t)if_index;
362
fprintf(stderr, "Connection to: %s\n", ip);
566
fprintf(stderr, "Connection to: %s, port %" PRIu16 "\n", ip,
568
char addrstr[INET6_ADDRSTRLEN] = "";
569
if(inet_ntop(to.in6.sin6_family, &(to.in6.sin6_addr), addrstr,
570
sizeof(addrstr)) == NULL){
573
if(strcmp(addrstr, ip) != 0){
574
fprintf(stderr, "Canonical address form: %s\n", addrstr);
365
ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
579
ret = connect(tcp_sd, &to.in, sizeof(to));
367
581
perror("connect");
371
ret = initgnutls (&es);
378
gnutls_transport_set_ptr (es.session, (gnutls_transport_ptr_t) tcp_sd);
381
fprintf(stderr, "Establishing tls session with %s\n", ip);
385
ret = gnutls_handshake (es.session);
387
if (ret != GNUTLS_E_SUCCESS){
388
fprintf(stderr, "\n*** Handshake failed ***\n");
394
//Retrieve gpg packet that contains the wanted password
397
fprintf(stderr, "Retrieving pgp encrypted password from %s\n", ip);
585
const char *out = mandos_protocol_version;
401
if (buffer_length + BUFFER_SIZE > buffer_capacity){
402
buffer = realloc(buffer, buffer_capacity + BUFFER_SIZE);
588
size_t out_size = strlen(out);
589
ret = (int)TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
590
out_size - written));
596
written += (size_t)ret;
597
if(written < out_size){
600
if(out == mandos_protocol_version){
407
buffer_capacity += BUFFER_SIZE;
610
fprintf(stderr, "Establishing TLS session with %s\n", ip);
613
gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
616
ret = gnutls_handshake(session);
617
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
619
if(ret != GNUTLS_E_SUCCESS){
621
fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
628
/* Read OpenPGP packet that contains the wanted password */
631
fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
636
buffer_capacity = adjustbuffer(&buffer, buffer_length,
638
if(buffer_capacity == 0){
639
perror("adjustbuffer");
410
ret = gnutls_record_recv
411
(es.session, buffer+buffer_length, BUFFER_SIZE);
644
sret = gnutls_record_recv(session, buffer+buffer_length,
417
651
case GNUTLS_E_INTERRUPTED:
418
652
case GNUTLS_E_AGAIN:
420
654
case GNUTLS_E_REHANDSHAKE:
421
ret = gnutls_handshake (es.session);
423
fprintf(stderr, "\n*** Handshake failed ***\n");
656
ret = gnutls_handshake(session);
657
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
659
fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
430
fprintf(stderr, "Unknown error while reading data from encrypted session with mandos server\n");
666
fprintf(stderr, "Unknown error while reading data from"
667
" encrypted session with Mandos server\n");
432
gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
669
gnutls_bye(session, GNUTLS_SHUT_RDWR);
436
buffer_length += ret;
673
buffer_length += (size_t) sret;
440
if (buffer_length > 0){
441
if ((decrypted_buffer_size = gpg_packet_decrypt(buffer, buffer_length, &decrypted_buffer, CERT_ROOT)) >= 0){
442
fwrite (decrypted_buffer, 1, decrypted_buffer_size, stdout);
678
fprintf(stderr, "Closing TLS session\n");
681
gnutls_bye(session, GNUTLS_SHUT_RDWR);
683
if(buffer_length > 0){
684
decrypted_buffer_size = pgp_packet_decrypt(mc, buffer,
687
if(decrypted_buffer_size >= 0){
689
while(written < (size_t) decrypted_buffer_size){
690
ret = (int)fwrite(decrypted_buffer + written, 1,
691
(size_t)decrypted_buffer_size - written,
693
if(ret == 0 and ferror(stdout)){
695
fprintf(stderr, "Error writing encrypted data: %s\n",
701
written += (size_t)ret;
443
703
free(decrypted_buffer);
452
fprintf(stderr, "Closing tls session\n");
711
/* Shutdown procedure */
456
gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
459
gnutls_deinit (es.session);
460
gnutls_certificate_free_credentials (es.cred);
461
gnutls_global_deinit ();
715
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
719
gnutls_deinit(session);
465
static AvahiSimplePoll *simple_poll = NULL;
466
static AvahiServer *server = NULL;
468
static void resolve_callback(
469
AvahiSServiceResolver *r,
470
AVAHI_GCC_UNUSED AvahiIfIndex interface,
471
AVAHI_GCC_UNUSED AvahiProtocol protocol,
472
AvahiResolverEvent event,
476
const char *host_name,
477
const AvahiAddress *address,
479
AvahiStringList *txt,
480
AvahiLookupResultFlags flags,
481
AVAHI_GCC_UNUSED void* userdata) {
485
/* Called whenever a service has been resolved successfully or timed out */
488
case AVAHI_RESOLVER_FAILURE:
489
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)));
492
case AVAHI_RESOLVER_FOUND: {
493
char ip[AVAHI_ADDRESS_STR_MAX];
494
avahi_address_snprint(ip, sizeof(ip), address);
496
fprintf(stderr, "Mandos server found at %s on port %d\n", ip, port);
498
int ret = start_mandos_communcation(ip, port);
506
avahi_s_service_resolver_free(r);
509
static void browse_callback(
510
AvahiSServiceBrowser *b,
511
AvahiIfIndex interface,
512
AvahiProtocol protocol,
513
AvahiBrowserEvent event,
517
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
520
AvahiServer *s = userdata;
523
/* Called whenever a new services becomes available on the LAN or is removed from the LAN */
527
case AVAHI_BROWSER_FAILURE:
529
fprintf(stderr, "(Browser) %s\n", avahi_strerror(avahi_server_errno(server)));
530
avahi_simple_poll_quit(simple_poll);
533
case AVAHI_BROWSER_NEW:
534
/* We ignore the returned resolver object. In the callback
535
function we free it. If the server is terminated before
536
the callback function is called the server will free
537
the resolver for us. */
539
if (!(avahi_s_service_resolver_new(s, interface, protocol, name, type, domain, AVAHI_PROTO_INET6, 0, resolve_callback, s)))
540
fprintf(stderr, "Failed to resolve service '%s': %s\n", name, avahi_strerror(avahi_server_errno(s)));
544
case AVAHI_BROWSER_REMOVE:
547
case AVAHI_BROWSER_ALL_FOR_NOW:
548
case AVAHI_BROWSER_CACHE_EXHAUSTED:
553
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
554
AvahiServerConfig config;
723
static void resolve_callback(AvahiSServiceResolver *r,
724
AvahiIfIndex interface,
725
AVAHI_GCC_UNUSED AvahiProtocol protocol,
726
AvahiResolverEvent event,
730
const char *host_name,
731
const AvahiAddress *address,
733
AVAHI_GCC_UNUSED AvahiStringList *txt,
734
AVAHI_GCC_UNUSED AvahiLookupResultFlags
737
mandos_context *mc = userdata;
740
/* Called whenever a service has been resolved successfully or
745
case AVAHI_RESOLVER_FAILURE:
746
fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
747
" of type '%s' in domain '%s': %s\n", name, type, domain,
748
avahi_strerror(avahi_server_errno(mc->server)));
751
case AVAHI_RESOLVER_FOUND:
753
char ip[AVAHI_ADDRESS_STR_MAX];
754
avahi_address_snprint(ip, sizeof(ip), address);
756
fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %"
757
PRIdMAX ") on port %" PRIu16 "\n", name, host_name,
758
ip, (intmax_t)interface, port);
760
int ret = start_mandos_communication(ip, port, interface, mc);
762
avahi_simple_poll_quit(mc->simple_poll);
766
avahi_s_service_resolver_free(r);
769
static void browse_callback( AvahiSServiceBrowser *b,
770
AvahiIfIndex interface,
771
AvahiProtocol protocol,
772
AvahiBrowserEvent event,
776
AVAHI_GCC_UNUSED AvahiLookupResultFlags
779
mandos_context *mc = userdata;
782
/* Called whenever a new services becomes available on the LAN or
783
is removed from the LAN */
787
case AVAHI_BROWSER_FAILURE:
789
fprintf(stderr, "(Avahi browser) %s\n",
790
avahi_strerror(avahi_server_errno(mc->server)));
791
avahi_simple_poll_quit(mc->simple_poll);
794
case AVAHI_BROWSER_NEW:
795
/* We ignore the returned Avahi resolver object. In the callback
796
function we free it. If the Avahi server is terminated before
797
the callback function is called the Avahi server will free the
800
if(!(avahi_s_service_resolver_new(mc->server, interface,
801
protocol, name, type, domain,
802
AVAHI_PROTO_INET6, 0,
803
resolve_callback, mc)))
804
fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
805
name, avahi_strerror(avahi_server_errno(mc->server)));
808
case AVAHI_BROWSER_REMOVE:
811
case AVAHI_BROWSER_ALL_FOR_NOW:
812
case AVAHI_BROWSER_CACHE_EXHAUSTED:
814
fprintf(stderr, "No Mandos server found, still searching...\n");
820
int main(int argc, char *argv[]){
555
821
AvahiSServiceBrowser *sb = NULL;
556
const char db[] = "--debug";
559
int returncode = EXIT_SUCCESS;
560
char *basename = rindex(argv[0], '/');
561
if(basename == NULL){
567
char *program_name = malloc(strlen(basename) + sizeof(db));
569
if (program_name == NULL){
574
program_name[0] = '\0';
576
for (int i = 1; i < argc; i++){
577
if (not strncmp(argv[i], db, 5)){
578
strcat(strcat(strcat(program_name, db ), "="), basename);
579
if(not strcmp(argv[i], db) or not strcmp(argv[i], program_name)){
826
int exitcode = EXIT_SUCCESS;
827
const char *interface = "eth0";
828
struct ifreq network;
832
char *connect_to = NULL;
833
char tempdir[] = "/tmp/mandosXXXXXX";
834
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
835
const char *seckey = PATHDIR "/" SECKEY;
836
const char *pubkey = PATHDIR "/" PUBKEY;
838
mandos_context mc = { .simple_poll = NULL, .server = NULL,
839
.dh_bits = 1024, .priority = "SECURE256"
840
":!CTYPE-X.509:+CTYPE-OPENPGP" };
841
bool gnutls_initalized = false;
842
bool gpgme_initalized = false;
845
struct argp_option options[] = {
846
{ .name = "debug", .key = 128,
847
.doc = "Debug mode", .group = 3 },
848
{ .name = "connect", .key = 'c',
849
.arg = "ADDRESS:PORT",
850
.doc = "Connect directly to a specific Mandos server",
852
{ .name = "interface", .key = 'i',
854
.doc = "Interface that will be used to search for Mandos"
857
{ .name = "seckey", .key = 's',
859
.doc = "OpenPGP secret key file base name",
861
{ .name = "pubkey", .key = 'p',
863
.doc = "OpenPGP public key file base name",
865
{ .name = "dh-bits", .key = 129,
867
.doc = "Bit length of the prime number used in the"
868
" Diffie-Hellman key exchange",
870
{ .name = "priority", .key = 130,
872
.doc = "GnuTLS priority string for the TLS handshake",
877
error_t parse_opt(int key, char *arg,
878
struct argp_state *state) {
880
case 128: /* --debug */
883
case 'c': /* --connect */
886
case 'i': /* --interface */
889
case 's': /* --seckey */
892
case 'p': /* --pubkey */
895
case 129: /* --dh-bits */
896
ret = sscanf(arg, "%" SCNdMAX "%n", &tmpmax, &numchars);
897
if(ret < 1 or tmpmax != (typeof(mc.dh_bits))tmpmax
898
or arg[numchars] != '\0'){
899
fprintf(stderr, "Bad number of DH bits\n");
902
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
904
case 130: /* --priority */
912
return ARGP_ERR_UNKNOWN;
917
struct argp argp = { .options = options, .parser = parse_opt,
919
.doc = "Mandos client -- Get and decrypt"
920
" passwords from a Mandos server" };
921
ret = argp_parse(&argp, argc, argv, 0, 0, NULL);
922
if(ret == ARGP_ERR_UNKNOWN){
923
fprintf(stderr, "Unknown error while parsing arguments\n");
924
exitcode = EXIT_FAILURE;
929
/* If the interface is down, bring it up */
931
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
934
exitcode = EXIT_FAILURE;
937
strcpy(network.ifr_name, interface);
938
ret = ioctl(sd, SIOCGIFFLAGS, &network);
940
perror("ioctl SIOCGIFFLAGS");
941
exitcode = EXIT_FAILURE;
944
if((network.ifr_flags & IFF_UP) == 0){
945
network.ifr_flags |= IFF_UP;
946
ret = ioctl(sd, SIOCSIFFLAGS, &network);
948
perror("ioctl SIOCSIFFLAGS");
949
exitcode = EXIT_FAILURE;
953
ret = (int)TEMP_FAILURE_RETRY(close(sd));
972
ret = init_gnutls_global(&mc, pubkey, seckey);
974
fprintf(stderr, "init_gnutls_global failed\n");
975
exitcode = EXIT_FAILURE;
978
gnutls_initalized = true;
981
if(mkdtemp(tempdir) == NULL){
987
if(not init_gpgme(&mc, pubkey, seckey, tempdir)){
988
fprintf(stderr, "gpgme_initalized failed\n");
989
exitcode = EXIT_FAILURE;
992
gpgme_initalized = true;
995
if_index = (AvahiIfIndex) if_nametoindex(interface);
997
fprintf(stderr, "No such interface: \"%s\"\n", interface);
1001
if(connect_to != NULL){
1002
/* Connect directly, do not use Zeroconf */
1003
/* (Mainly meant for debugging) */
1004
char *address = strrchr(connect_to, ':');
1005
if(address == NULL){
1006
fprintf(stderr, "No colon in address\n");
1007
exitcode = EXIT_FAILURE;
1011
ret = sscanf(address+1, "%" SCNdMAX "%n", &tmpmax, &numchars);
1012
if(ret < 1 or tmpmax != (uint16_t)tmpmax
1013
or address[numchars+1] != '\0'){
1014
fprintf(stderr, "Bad port number\n");
1015
exitcode = EXIT_FAILURE;
1018
port = (uint16_t)tmpmax;
1020
address = connect_to;
1021
ret = start_mandos_communication(address, port, if_index, &mc);
1023
exitcode = EXIT_FAILURE;
1025
exitcode = EXIT_SUCCESS;
587
1031
avahi_set_log_function(empty_log);
590
/* Initialize the psuedo-RNG */
593
/* Allocate main loop object */
594
if (!(simple_poll = avahi_simple_poll_new())) {
595
fprintf(stderr, "Failed to create simple poll object.\n");
600
/* Do not publish any local records */
601
avahi_server_config_init(&config);
602
config.publish_hinfo = 0;
603
config.publish_addresses = 0;
604
config.publish_workstation = 0;
605
config.publish_domain = 0;
607
/* Allocate a new server */
608
server = avahi_server_new(avahi_simple_poll_get(simple_poll), &config, NULL, NULL, &error);
610
/* Free the configuration data */
611
avahi_server_config_free(&config);
613
/* Check if creating the server object succeeded */
615
fprintf(stderr, "Failed to create server: %s\n", avahi_strerror(error));
616
returncode = EXIT_FAILURE;
620
/* Create the service browser */
621
if (!(sb = avahi_s_service_browser_new(server, if_nametoindex("eth0"), AVAHI_PROTO_INET6, "_mandos._tcp", NULL, 0, browse_callback, server))) {
622
fprintf(stderr, "Failed to create service browser: %s\n", avahi_strerror(avahi_server_errno(server)));
623
returncode = EXIT_FAILURE;
1034
/* Initialize the pseudo-RNG for Avahi */
1035
srand((unsigned int) time(NULL));
1037
/* Allocate main Avahi loop object */
1038
mc.simple_poll = avahi_simple_poll_new();
1039
if(mc.simple_poll == NULL) {
1040
fprintf(stderr, "Avahi: Failed to create simple poll"
1042
exitcode = EXIT_FAILURE;
1047
AvahiServerConfig config;
1048
/* Do not publish any local Zeroconf records */
1049
avahi_server_config_init(&config);
1050
config.publish_hinfo = 0;
1051
config.publish_addresses = 0;
1052
config.publish_workstation = 0;
1053
config.publish_domain = 0;
1055
/* Allocate a new server */
1056
mc.server = avahi_server_new(avahi_simple_poll_get
1057
(mc.simple_poll), &config, NULL,
1060
/* Free the Avahi configuration data */
1061
avahi_server_config_free(&config);
1064
/* Check if creating the Avahi server object succeeded */
1065
if(mc.server == NULL) {
1066
fprintf(stderr, "Failed to create Avahi server: %s\n",
1067
avahi_strerror(error));
1068
exitcode = EXIT_FAILURE;
1072
/* Create the Avahi service browser */
1073
sb = avahi_s_service_browser_new(mc.server, if_index,
1075
"_mandos._tcp", NULL, 0,
1076
browse_callback, &mc);
1078
fprintf(stderr, "Failed to create service browser: %s\n",
1079
avahi_strerror(avahi_server_errno(mc.server)));
1080
exitcode = EXIT_FAILURE;
627
1084
/* Run the main loop */
630
fprintf(stderr, "Starting avahi loop search\n");
1087
fprintf(stderr, "Starting Avahi loop search\n");
633
avahi_simple_poll_loop(simple_poll);
1090
avahi_simple_poll_loop(mc.simple_poll);
638
1095
fprintf(stderr, "%s exiting\n", argv[0]);
641
1098
/* Cleanup things */
643
1100
avahi_s_service_browser_free(sb);
646
avahi_server_free(server);
649
avahi_simple_poll_free(simple_poll);
1102
if(mc.server != NULL)
1103
avahi_server_free(mc.server);
1105
if(mc.simple_poll != NULL)
1106
avahi_simple_poll_free(mc.simple_poll);
1108
if(gnutls_initalized){
1109
gnutls_certificate_free_credentials(mc.cred);
1110
gnutls_global_deinit();
1111
gnutls_dh_params_deinit(mc.dh_params);
1114
if(gpgme_initalized){
1115
gpgme_release(mc.ctx);
1118
/* Removes the temp directory used by GPGME */
1119
if(tempdir[0] != '\0'){
1121
struct dirent *direntry;
1122
d = opendir(tempdir);
1124
if(errno != ENOENT){
1129
direntry = readdir(d);
1130
if(direntry == NULL){
1133
if(direntry->d_type == DT_REG){
1134
char *fullname = NULL;
1135
ret = asprintf(&fullname, "%s/%s", tempdir,
1141
ret = unlink(fullname);
1143
fprintf(stderr, "unlink(\"%s\"): %s",
1144
fullname, strerror(errno));
1151
ret = rmdir(tempdir);
1152
if(ret == -1 and errno != ENOENT){