To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/release
« back to all changes in this revision
Viewing changes to plugins.d/mandosclient.c
- browse files at revision 18
- compare with another revision
- download diff
- download tarball
- view history from revision 18
- Committer: Teddy Hogeborn
- Date: 2008-07-21 02:33:00 UTC
- Revision ID: teddy@fukt.bsnet.se-20080721023300-c4t0cq7sxit973py
* plugins.d/Makefile: Removed
* plugins.d/mandosclient.c (start_mandos_communcation): Bug fix: write
server IP
address to
"to" struct.
* plugins.d/mandosclient.c (start_mandos_communcation): Bug fix: write
server IP
address to
"to" struct.
- files added:
- ca.pem
- files removed:
- .bzr-builddeb
- debian
- debian/po
- files renamed:
- clients.conf => mandos-clients.conf
- plugin-runner.c => plugbasedclient.c
- plugins.d/mandos-client.c => plugins.d/mandosclient.c
- plugins.d/password-prompt.c => plugins.d/passprompt.c
- mandos => server.py
- files modified:
- Makefile
added
removed
plugins.d/mandosclient.c
1
/* -*- coding: utf-8 -*- */
2
/*
3
* Mandos-client - get and decrypt data from a Mandos server
4
*
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".
10
*
11
* Everything else is
12
* Copyright © 2008,2009 Teddy Hogeborn
13
* Copyright © 2008,2009 Björn Påhlsson
14
*
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.
19
*
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.
24
*
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/>.
28
*
29
* Contact the authors at <mandos@fukt.bsnet.se>.
30
*/
1
/***
2
This file is part of avahi.
3
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.
8
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.
13
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
17
USA.
18
***/
31
19
32
/* Needed by GPGME, specifically gpgme_data_seek() */
33
20
#define _LARGEFILE_SOURCE
34
21
#define _FILE_OFFSET_BITS 64
35
22
36
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
37
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,
43
srand() */
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(),
52
DIR */
53
#include <sys/stat.h> /* open() */
54
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
55
struct in6_addr, inet_pton(),
56
connect() */
57
#include <fcntl.h> /* open() */
58
#include <dirent.h> /* opendir(), struct dirent, readdir()
59
*/
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(),
70
setgid() */
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 */
77
78
/* Avahi */
79
/* All Avahi types, constants and functions
80
Avahi*, avahi_*,
81
AVAHI_* */
23
#include <stdio.h>
24
#include <assert.h>
25
#include <stdlib.h>
26
#include <time.h>
27
#include <net/if.h> /* if_nametoindex */
28
82
29
#include <avahi-core/core.h>
83
30
#include <avahi-core/lookup.h>
84
31
#include <avahi-core/log.h>
86
33
#include <avahi-common/malloc.h>
87
34
#include <avahi-common/error.h>
88
35
89
/* GnuTLS */
90
#include <gnutls/gnutls.h> /* All GnuTLS types, constants and
91
functions:
92
gnutls_*
93
init_gnutls_session(),
94
GNUTLS_* */
95
#include <gnutls/openpgp.h>
96
/* gnutls_certificate_set_openpgp_key_file(),
97
GNUTLS_OPENPGP_FMT_BASE64 */
98
99
/* GPGME */
100
#include <gpgme.h> /* All GPGME types, constants and
101
functions:
102
gpgme_*
103
GPGME_PROTOCOL_OpenPGP,
104
GPG_ERR_NO_* */
105
36
//mandos client part
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 */
41
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 */
48
49
// gpgme
50
#include <errno.h> /* perror() */
51
#include <gpgme.h>
52
53
54
#ifndef CERT_ROOT
55
#define CERT_ROOT "/conf/conf.d/cryptkeyreq/"
56
#endif
57
#define CERTFILE CERT_ROOT "openpgp-client.txt"
58
#define KEYFILE CERT_ROOT "openpgp-client-key.txt"
106
59
#define BUFFER_SIZE 256
107
108
#define PATHDIR "/conf/conf.d/mandos"
109
#define SECKEY "seckey.txt"
110
#define PUBKEY "pubkey.txt"
60
#define DH_BITS 1024
111
61
112
62
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>";
116
63
117
/* Used for passing in values through the Avahi callback functions */
118
64
typedef struct {
119
AvahiSimplePoll *simple_poll;
120
AvahiServer *server;
65
gnutls_session_t session;
121
66
gnutls_certificate_credentials_t cred;
122
unsigned int dh_bits;
123
67
gnutls_dh_params_t dh_params;
124
const char *priority;
68
} encrypted_session;
69
70
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;
125
73
gpgme_ctx_t ctx;
126
} mandos_context;
127
128
/*
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.
132
*/
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);
137
if(buffer == NULL){
138
return 0;
139
}
140
buffer_capacity += BUFFER_SIZE;
141
}
142
return buffer_capacity;
143
}
144
145
/*
146
* Initialize GPGME.
147
*/
148
static bool init_gpgme(mandos_context *mc, const char *seckey,
149
const char *pubkey, const char *tempdir){
150
int ret;
151
74
gpgme_error_t rc;
75
ssize_t ret;
76
size_t new_packet_capacity = 0;
77
size_t new_packet_length = 0;
152
78
gpgme_engine_info_t engine_info;
153
154
155
/*
156
* Helper function to insert pub and seckey to the enigne keyring.
157
*/
158
bool import_key(const char *filename){
159
int fd;
160
gpgme_data_t pgp_data;
161
162
fd = (int)TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
163
if(fd == -1){
164
perror("open");
165
return false;
166
}
167
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));
172
return false;
173
}
174
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));
179
return false;
180
}
181
182
ret = (int)TEMP_FAILURE_RETRY(close(fd));
183
if(ret == -1){
184
perror("close");
185
}
186
gpgme_data_release(pgp_data);
187
return true;
188
}
189
190
if(debug){
191
fprintf(stderr, "Initialize gpgme\n");
79
80
if (debug){
81
fprintf(stderr, "Attempting to decrypt password from gpg packet\n");
192
82
}
193
83
194
84
/* Init GPGME */
195
85
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));
200
return false;
201
}
86
gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
202
87
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){
88
/* Set GPGME home directory */
89
rc = gpgme_get_engine_info (&engine_info);
90
if (rc != GPG_ERR_NO_ERROR){
206
91
fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
207
92
gpgme_strsource(rc), gpgme_strerror(rc));
208
return false;
93
return -1;
209
94
}
210
95
while(engine_info != NULL){
211
96
if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){
212
97
gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,
213
engine_info->file_name, tempdir);
98
engine_info->file_name, homedir);
214
99
break;
215
100
}
216
101
engine_info = engine_info->next;
217
102
}
218
103
if(engine_info == NULL){
219
fprintf(stderr, "Could not set GPGME home dir to %s\n", tempdir);
220
return false;
221
}
222
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));
228
return false;
229
}
230
231
if(not import_key(pubkey) or not import_key(seckey)){
232
return false;
233
}
234
235
return true;
236
}
237
238
/*
239
* Decrypt OpenPGP data.
240
* Returns -1 on error
241
*/
242
static ssize_t pgp_packet_decrypt(const mandos_context *mc,
243
const char *cryptotext,
244
size_t crypto_size,
245
char **plaintext){
246
gpgme_data_t dh_crypto, dh_plain;
247
gpgme_error_t rc;
248
ssize_t ret;
249
size_t plaintext_capacity = 0;
250
ssize_t plaintext_length = 0;
251
252
if(debug){
253
fprintf(stderr, "Trying to decrypt OpenPGP data\n");
254
}
255
256
/* Create new GPGME data buffer from memory cryptotext */
257
rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
258
0);
259
if(rc != GPG_ERR_NO_ERROR){
104
fprintf(stderr, "Could not set home dir to %s\n", homedir);
105
return -1;
106
}
107
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){
260
111
fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
261
112
gpgme_strsource(rc), gpgme_strerror(rc));
262
113
return -1;
264
115
265
116
/* Create new empty GPGME data buffer for the plaintext */
266
117
rc = gpgme_data_new(&dh_plain);
267
if(rc != GPG_ERR_NO_ERROR){
118
if (rc != GPG_ERR_NO_ERROR){
268
119
fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
269
120
gpgme_strsource(rc), gpgme_strerror(rc));
270
gpgme_data_release(dh_crypto);
271
return -1;
272
}
273
274
/* Decrypt data from the cryptotext data buffer to the plaintext
275
data buffer */
276
rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
277
if(rc != GPG_ERR_NO_ERROR){
121
return -1;
122
}
123
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));
129
return -1;
130
}
131
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){
278
135
fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
279
136
gpgme_strsource(rc), gpgme_strerror(rc));
280
plaintext_length = -1;
281
if(debug){
282
gpgme_decrypt_result_t result;
283
result = gpgme_op_decrypt_result(mc->ctx);
284
if(result == NULL){
285
fprintf(stderr, "gpgme_op_decrypt_result failed\n");
286
} else {
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);
293
}
294
gpgme_recipient_t recipient;
295
recipient = result->recipients;
296
if(recipient){
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
303
? "No" : "Yes");
304
recipient = recipient->next;
305
}
137
return -1;
138
}
139
140
if(debug){
141
fprintf(stderr, "decryption of gpg packet succeeded\n");
142
}
143
144
if (debug){
145
gpgme_decrypt_result_t result;
146
result = gpgme_op_decrypt_result(ctx);
147
if (result == NULL){
148
fprintf(stderr, "gpgme_op_decrypt_result failed\n");
149
} else {
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);
154
}
155
gpgme_recipient_t recipient;
156
recipient = result->recipients;
157
if(recipient){
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;
306
165
}
307
166
}
308
167
}
309
goto decrypt_end;
310
168
}
311
169
312
if(debug){
313
fprintf(stderr, "Decryption of OpenPGP data succeeded\n");
314
}
170
/* Delete the GPGME FILE pointer cryptotext data buffer */
171
gpgme_data_release(dh_crypto);
315
172
316
173
/* 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;
320
goto decrypt_end;
321
}
322
323
*plaintext = NULL;
174
gpgme_data_seek(dh_plain, 0, SEEK_SET);
175
176
*new_packet = 0;
324
177
while(true){
325
plaintext_capacity = adjustbuffer(plaintext,
326
(size_t)plaintext_length,
327
plaintext_capacity);
328
if(plaintext_capacity == 0){
329
perror("adjustbuffer");
330
plaintext_length = -1;
331
goto decrypt_end;
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){
181
perror("realloc");
182
return -1;
183
}
184
new_packet_capacity += BUFFER_SIZE;
332
185
}
333
186
334
ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
335
BUFFER_SIZE);
187
ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length, BUFFER_SIZE);
336
188
/* Print the data, if any */
337
if(ret == 0){
338
/* EOF */
189
if (ret == 0){
190
/* If password is empty, then a incorrect error will be printed */
339
191
break;
340
192
}
341
193
if(ret < 0){
342
194
perror("gpgme_data_read");
343
plaintext_length = -1;
344
goto decrypt_end;
195
return -1;
345
196
}
346
plaintext_length += ret;
197
new_packet_length += ret;
347
198
}
348
199
349
200
if(debug){
350
fprintf(stderr, "Decrypted password is: ");
351
for(ssize_t i = 0; i < plaintext_length; i++){
352
fprintf(stderr, "%02hhX ", (*plaintext)[i]);
353
}
354
fprintf(stderr, "\n");
201
fprintf(stderr, "decrypted password is: %s\n", *new_packet);
355
202
}
356
357
decrypt_end:
358
359
/* Delete the GPGME cryptotext data buffer */
360
gpgme_data_release(dh_crypto);
361
362
/* Delete the GPGME plaintext data buffer */
203
204
/* Delete the GPGME plaintext data buffer */
363
205
gpgme_data_release(dh_plain);
364
return plaintext_length;
206
return new_packet_length;
365
207
}
366
208
367
static const char * safer_gnutls_strerror(int value) {
368
const char *ret = gnutls_strerror(value); /* Spurious warning */
369
if(ret == NULL)
209
static const char * safer_gnutls_strerror (int value) {
210
const char *ret = gnutls_strerror (value);
211
if (ret == NULL)
370
212
ret = "(unknown)";
371
213
return ret;
372
214
}
373
215
374
/* GnuTLS log function callback */
375
static void debuggnutls(__attribute__((unused)) int level,
376
const char* string){
377
fprintf(stderr, "GnuTLS: %s", string);
216
void debuggnutls(int level, const char* string){
217
fprintf(stderr, "%s", string);
378
218
}
379
219
380
static int init_gnutls_global(mandos_context *mc,
381
const char *pubkeyfilename,
382
const char *seckeyfilename){
220
int initgnutls(encrypted_session *es){
221
const char *err;
383
222
int ret;
384
223
385
224
if(debug){
386
fprintf(stderr, "Initializing GnuTLS\n");
225
fprintf(stderr, "Initializing gnutls\n");
387
226
}
227
388
228
389
ret = gnutls_global_init();
390
if(ret != GNUTLS_E_SUCCESS) {
391
fprintf(stderr, "GnuTLS global_init: %s\n",
392
safer_gnutls_strerror(ret));
229
if ((ret = gnutls_global_init ())
230
!= GNUTLS_E_SUCCESS) {
231
fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
393
232
return -1;
394
233
}
395
396
if(debug){
397
/* "Use a log level over 10 to enable all debugging options."
398
* - GnuTLS manual
399
*/
234
235
if (debug){
400
236
gnutls_global_set_log_level(11);
401
237
gnutls_global_set_log_function(debuggnutls);
402
238
}
403
239
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
408
warning */
409
safer_gnutls_strerror(ret));
410
gnutls_global_deinit();
240
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));
411
245
return -1;
412
246
}
413
247
414
248
if(debug){
415
fprintf(stderr, "Attempting to use OpenPGP public key %s and"
416
" secret key %s as GnuTLS credentials\n", pubkeyfilename,
417
seckeyfilename);
249
fprintf(stderr, "Attempting to use openpgp certificate %s"
250
" and keyfile %s as gnutls credentials\n", CERTFILE, KEYFILE);
418
251
}
419
252
420
253
ret = gnutls_certificate_set_openpgp_key_file
421
(mc->cred, pubkeyfilename, seckeyfilename,
422
GNUTLS_OPENPGP_FMT_BASE64);
423
if(ret != GNUTLS_E_SUCCESS) {
424
fprintf(stderr,
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));
429
goto globalfail;
430
}
431
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));
437
goto globalfail;
438
}
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));
443
goto globalfail;
444
}
445
446
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
447
448
return 0;
449
450
globalfail:
451
452
gnutls_certificate_free_credentials(mc->cred);
453
gnutls_global_deinit();
454
gnutls_dh_params_deinit(mc->dh_params);
455
return -1;
456
}
457
458
static int init_gnutls_session(mandos_context *mc,
459
gnutls_session_t *session){
460
int ret;
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));
466
}
467
468
{
469
const char *err;
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);
476
return -1;
477
}
478
}
479
480
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
481
mc->cred);
482
if(ret != GNUTLS_E_SUCCESS) {
483
fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
484
safer_gnutls_strerror(ret));
485
gnutls_deinit(*session);
486
return -1;
487
}
488
254
(es->cred, CERTFILE, KEYFILE, GNUTLS_OPENPGP_FMT_BASE64);
255
if (ret != GNUTLS_E_SUCCESS) {
256
fprintf
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));
261
return -1;
262
}
263
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));
269
return -1;
270
}
271
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));
276
return -1;
277
}
278
279
gnutls_certificate_set_dh_params (es->cred, es->dh_params);
280
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));
286
}
287
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));
293
return -1;
294
}
295
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));
301
return -1;
302
}
303
489
304
/* ignore client certificate if any. */
490
gnutls_certificate_server_set_request(*session,
491
GNUTLS_CERT_IGNORE);
305
gnutls_certificate_server_set_request (es->session, GNUTLS_CERT_IGNORE);
492
306
493
gnutls_dh_set_prime_bits(*session, mc->dh_bits);
307
gnutls_dh_set_prime_bits (es->session, DH_BITS);
494
308
495
309
return 0;
496
310
}
497
311
498
/* Avahi log function callback */
499
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
500
__attribute__((unused)) const char *txt){}
312
void empty_log(AvahiLogLevel level, const char *txt){}
501
313
502
/* Called when a Mandos server is found */
503
static int start_mandos_communication(const char *ip, uint16_t port,
504
AvahiIfIndex if_index,
505
mandos_context *mc){
314
int start_mandos_communcation(char *ip, uint16_t port){
506
315
int ret, tcp_sd;
507
ssize_t sret;
508
union { struct sockaddr in; struct sockaddr_in6 in6; } to;
316
struct sockaddr_in6 to;
317
encrypted_session es;
509
318
char *buffer = NULL;
510
319
char *decrypted_buffer;
511
320
size_t buffer_length = 0;
512
321
size_t buffer_capacity = 0;
513
322
ssize_t decrypted_buffer_size;
514
size_t written;
515
323
int retval = 0;
516
char interface[IF_NAMESIZE];
517
gnutls_session_t session;
518
519
ret = init_gnutls_session(mc, &session);
520
if(ret != 0){
521
return -1;
522
}
523
324
const char interface[] = "eth0";
325
524
326
if(debug){
525
fprintf(stderr, "Setting up a tcp connection to %s, port %" PRIu16
526
"\n", ip, port);
327
fprintf(stderr, "Setting up a tcp connection to %s\n", ip);
527
328
}
528
329
529
330
tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
531
332
perror("socket");
532
333
return -1;
533
334
}
534
335
535
336
if(debug){
536
if(if_indextoname((unsigned int)if_index, interface) == NULL){
537
perror("if_indextoname");
538
return -1;
539
}
540
337
fprintf(stderr, "Binding to interface %s\n", interface);
541
338
}
339
340
ret = setsockopt(tcp_sd, SOL_SOCKET, SO_BINDTODEVICE, interface, 5);
341
if(tcp_sd < 0) {
342
perror("setsockopt bindtodevice");
343
return -1;
344
}
542
345
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);
548
if(ret < 0 ){
346
memset(&to,0,sizeof(to));
347
to.sin6_family = AF_INET6;
348
ret = inet_pton(AF_INET6, ip, &to.sin6_addr);
349
if (ret < 0 ){
549
350
perror("inet_pton");
550
351
return -1;
551
}
352
}
552
353
if(ret == 0){
553
354
fprintf(stderr, "Bad address: %s\n", ip);
554
355
return -1;
555
356
}
556
to.in6.sin6_port = htons(port); /* Spurious warning */
557
558
to.in6.sin6_scope_id = (uint32_t)if_index;
559
357
to.sin6_port = htons(port);
358
to.sin6_scope_id = if_nametoindex(interface);
359
560
360
if(debug){
561
fprintf(stderr, "Connection to: %s, port %" PRIu16 "\n", ip,
562
port);
563
char addrstr[INET6_ADDRSTRLEN] = "";
564
if(inet_ntop(to.in6.sin6_family, &(to.in6.sin6_addr), addrstr,
565
sizeof(addrstr)) == NULL){
566
perror("inet_ntop");
567
} else {
568
if(strcmp(addrstr, ip) != 0){
569
fprintf(stderr, "Canonical address form: %s\n", addrstr);
570
}
571
}
361
fprintf(stderr, "Connection to: %s\n", ip);
572
362
}
573
363
574
ret = connect(tcp_sd, &to.in, sizeof(to));
575
if(ret < 0){
364
ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
365
if (ret < 0){
576
366
perror("connect");
577
367
return -1;
578
368
}
579
369
580
const char *out = mandos_protocol_version;
581
written = 0;
370
ret = initgnutls (&es);
371
if (ret != 0){
372
retval = -1;
373
return -1;
374
}
375
376
377
gnutls_transport_set_ptr (es.session, (gnutls_transport_ptr_t) tcp_sd);
378
379
if(debug){
380
fprintf(stderr, "Establishing tls session with %s\n", ip);
381
}
382
383
384
ret = gnutls_handshake (es.session);
385
386
if (ret != GNUTLS_E_SUCCESS){
387
fprintf(stderr, "\n*** Handshake failed ***\n");
388
gnutls_perror (ret);
389
retval = -1;
390
goto exit;
391
}
392
393
//Retrieve gpg packet that contains the wanted password
394
395
if(debug){
396
fprintf(stderr, "Retrieving pgp encrypted password from %s\n", ip);
397
}
398
582
399
while(true){
583
size_t out_size = strlen(out);
584
ret = (int)TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
585
out_size - written));
586
if(ret == -1){
587
perror("write");
588
retval = -1;
589
goto mandos_end;
590
}
591
written += (size_t)ret;
592
if(written < out_size){
593
continue;
594
} else {
595
if(out == mandos_protocol_version){
596
written = 0;
597
out = "\r\n";
598
} else {
599
break;
400
if (buffer_length + BUFFER_SIZE > buffer_capacity){
401
buffer = realloc(buffer, buffer_capacity + BUFFER_SIZE);
402
if (buffer == NULL){
403
perror("realloc");
404
goto exit;
600
405
}
601
}
602
}
603
604
if(debug){
605
fprintf(stderr, "Establishing TLS session with %s\n", ip);
606
}
607
608
gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
609
610
do{
611
ret = gnutls_handshake(session);
612
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
613
614
if(ret != GNUTLS_E_SUCCESS){
615
if(debug){
616
fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
617
gnutls_perror(ret);
618
}
619
retval = -1;
620
goto mandos_end;
621
}
622
623
/* Read OpenPGP packet that contains the wanted password */
624
625
if(debug){
626
fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
627
ip);
628
}
629
630
while(true){
631
buffer_capacity = adjustbuffer(&buffer, buffer_length,
632
buffer_capacity);
633
if(buffer_capacity == 0){
634
perror("adjustbuffer");
635
retval = -1;
636
goto mandos_end;
406
buffer_capacity += BUFFER_SIZE;
637
407
}
638
408
639
sret = gnutls_record_recv(session, buffer+buffer_length,
640
BUFFER_SIZE);
641
if(sret == 0){
409
ret = gnutls_record_recv
410
(es.session, buffer+buffer_length, BUFFER_SIZE);
411
if (ret == 0){
642
412
break;
643
413
}
644
if(sret < 0){
645
switch(sret){
414
if (ret < 0){
415
switch(ret){
646
416
case GNUTLS_E_INTERRUPTED:
647
417
case GNUTLS_E_AGAIN:
648
418
break;
649
419
case GNUTLS_E_REHANDSHAKE:
650
do{
651
ret = gnutls_handshake(session);
652
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
653
if(ret < 0){
654
fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
655
gnutls_perror(ret);
420
ret = gnutls_handshake (es.session);
421
if (ret < 0){
422
fprintf(stderr, "\n*** Handshake failed ***\n");
423
gnutls_perror (ret);
656
424
retval = -1;
657
goto mandos_end;
425
goto exit;
658
426
}
659
427
break;
660
428
default:
661
fprintf(stderr, "Unknown error while reading data from"
662
" encrypted session with Mandos server\n");
429
fprintf(stderr, "Unknown error while reading data from encrypted session with mandos server\n");
663
430
retval = -1;
664
gnutls_bye(session, GNUTLS_SHUT_RDWR);
665
goto mandos_end;
431
gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
432
goto exit;
666
433
}
667
434
} else {
668
buffer_length += (size_t) sret;
435
buffer_length += ret;
669
436
}
670
437
}
671
438
672
if(debug){
673
fprintf(stderr, "Closing TLS session\n");
674
}
675
676
gnutls_bye(session, GNUTLS_SHUT_RDWR);
677
678
if(buffer_length > 0){
679
decrypted_buffer_size = pgp_packet_decrypt(mc, buffer,
680
buffer_length,
681
&decrypted_buffer);
682
if(decrypted_buffer_size >= 0){
683
written = 0;
684
while(written < (size_t) decrypted_buffer_size){
685
ret = (int)fwrite(decrypted_buffer + written, 1,
686
(size_t)decrypted_buffer_size - written,
687
stdout);
688
if(ret == 0 and ferror(stdout)){
689
if(debug){
690
fprintf(stderr, "Error writing encrypted data: %s\n",
691
strerror(errno));
692
}
693
retval = -1;
694
break;
695
}
696
written += (size_t)ret;
697
}
439
if (buffer_length > 0){
440
if ((decrypted_buffer_size = gpg_packet_decrypt(buffer, buffer_length, &decrypted_buffer, CERT_ROOT)) >= 0){
441
fwrite (decrypted_buffer, 1, decrypted_buffer_size, stdout);
698
442
free(decrypted_buffer);
699
443
} else {
700
444
retval = -1;
701
445
}
702
} else {
703
retval = -1;
704
}
705
706
/* Shutdown procedure */
707
708
mandos_end:
446
}
447
448
//shutdown procedure
449
450
if(debug){
451
fprintf(stderr, "Closing tls session\n");
452
}
453
709
454
free(buffer);
710
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
711
if(ret == -1){
712
perror("close");
713
}
714
gnutls_deinit(session);
455
gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
456
exit:
457
close(tcp_sd);
458
gnutls_deinit (es.session);
459
gnutls_certificate_free_credentials (es.cred);
460
gnutls_global_deinit ();
715
461
return retval;
716
462
}
717
463
718
static void resolve_callback(AvahiSServiceResolver *r,
719
AvahiIfIndex interface,
720
AVAHI_GCC_UNUSED AvahiProtocol protocol,
721
AvahiResolverEvent event,
722
const char *name,
723
const char *type,
724
const char *domain,
725
const char *host_name,
726
const AvahiAddress *address,
727
uint16_t port,
728
AVAHI_GCC_UNUSED AvahiStringList *txt,
729
AVAHI_GCC_UNUSED AvahiLookupResultFlags
730
flags,
731
void* userdata) {
732
mandos_context *mc = userdata;
733
assert(r);
734
735
/* Called whenever a service has been resolved successfully or
736
timed out */
737
738
switch(event) {
739
default:
740
case AVAHI_RESOLVER_FAILURE:
741
fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
742
" of type '%s' in domain '%s': %s\n", name, type, domain,
743
avahi_strerror(avahi_server_errno(mc->server)));
744
break;
745
746
case AVAHI_RESOLVER_FOUND:
747
{
748
char ip[AVAHI_ADDRESS_STR_MAX];
749
avahi_address_snprint(ip, sizeof(ip), address);
750
if(debug){
751
fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %"
752
PRIu16 ") on port %d\n", name, host_name, ip,
753
interface, port);
754
}
755
int ret = start_mandos_communication(ip, port, interface, mc);
756
if(ret == 0){
757
avahi_simple_poll_quit(mc->simple_poll);
758
}
759
}
760
}
761
avahi_s_service_resolver_free(r);
762
}
763
764
static void browse_callback( AvahiSServiceBrowser *b,
765
AvahiIfIndex interface,
766
AvahiProtocol protocol,
767
AvahiBrowserEvent event,
768
const char *name,
769
const char *type,
770
const char *domain,
771
AVAHI_GCC_UNUSED AvahiLookupResultFlags
772
flags,
773
void* userdata) {
774
mandos_context *mc = userdata;
775
assert(b);
776
777
/* Called whenever a new services becomes available on the LAN or
778
is removed from the LAN */
779
780
switch(event) {
781
default:
782
case AVAHI_BROWSER_FAILURE:
783
784
fprintf(stderr, "(Avahi browser) %s\n",
785
avahi_strerror(avahi_server_errno(mc->server)));
786
avahi_simple_poll_quit(mc->simple_poll);
787
return;
788
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
793
resolver for us. */
794
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)));
801
break;
802
803
case AVAHI_BROWSER_REMOVE:
804
break;
805
806
case AVAHI_BROWSER_ALL_FOR_NOW:
807
case AVAHI_BROWSER_CACHE_EXHAUSTED:
808
if(debug){
809
fprintf(stderr, "No Mandos server found, still searching...\n");
810
}
811
break;
812
}
813
}
814
815
int main(int argc, char *argv[]){
464
static AvahiSimplePoll *simple_poll = NULL;
465
static AvahiServer *server = NULL;
466
467
static void resolve_callback(
468
AvahiSServiceResolver *r,
469
AVAHI_GCC_UNUSED AvahiIfIndex interface,
470
AVAHI_GCC_UNUSED AvahiProtocol protocol,
471
AvahiResolverEvent event,
472
const char *name,
473
const char *type,
474
const char *domain,
475
const char *host_name,
476
const AvahiAddress *address,
477
uint16_t port,
478
AvahiStringList *txt,
479
AvahiLookupResultFlags flags,
480
AVAHI_GCC_UNUSED void* userdata) {
481
482
assert(r);
483
484
/* Called whenever a service has been resolved successfully or timed out */
485
486
switch (event) {
487
case AVAHI_RESOLVER_FAILURE:
488
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)));
489
break;
490
491
case AVAHI_RESOLVER_FOUND: {
492
char ip[AVAHI_ADDRESS_STR_MAX];
493
avahi_address_snprint(ip, sizeof(ip), address);
494
if(debug){
495
fprintf(stderr, "Mandos server found at %s on port %d\n", ip, port);
496
}
497
int ret = start_mandos_communcation(ip, port);
498
if (ret == 0){
499
exit(EXIT_SUCCESS);
500
} else {
501
exit(EXIT_FAILURE);
502
}
503
}
504
}
505
avahi_s_service_resolver_free(r);
506
}
507
508
static void browse_callback(
509
AvahiSServiceBrowser *b,
510
AvahiIfIndex interface,
511
AvahiProtocol protocol,
512
AvahiBrowserEvent event,
513
const char *name,
514
const char *type,
515
const char *domain,
516
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
517
void* userdata) {
518
519
AvahiServer *s = userdata;
520
assert(b);
521
522
/* Called whenever a new services becomes available on the LAN or is removed from the LAN */
523
524
switch (event) {
525
526
case AVAHI_BROWSER_FAILURE:
527
528
fprintf(stderr, "(Browser) %s\n", avahi_strerror(avahi_server_errno(server)));
529
avahi_simple_poll_quit(simple_poll);
530
return;
531
532
case AVAHI_BROWSER_NEW:
533
/* We ignore the returned resolver object. In the callback
534
function we free it. If the server is terminated before
535
the callback function is called the server will free
536
the resolver for us. */
537
538
if (!(avahi_s_service_resolver_new(s, interface, protocol, name, type, domain, AVAHI_PROTO_INET6, 0, resolve_callback, s)))
539
fprintf(stderr, "Failed to resolve service '%s': %s\n", name, avahi_strerror(avahi_server_errno(s)));
540
541
break;
542
543
case AVAHI_BROWSER_REMOVE:
544
break;
545
546
case AVAHI_BROWSER_ALL_FOR_NOW:
547
case AVAHI_BROWSER_CACHE_EXHAUSTED:
548
break;
549
}
550
}
551
552
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
553
AvahiServerConfig config;
816
554
AvahiSServiceBrowser *sb = NULL;
555
const char db[] = "--debug";
817
556
int error;
818
int ret;
819
int exitcode = EXIT_SUCCESS;
820
const char *interface = "eth0";
821
struct ifreq network;
822
int sd;
823
uid_t uid;
824
gid_t gid;
825
char *connect_to = NULL;
826
char tempdir[] = "/tmp/mandosXXXXXX";
827
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
828
const char *seckey = PATHDIR "/" SECKEY;
829
const char *pubkey = PATHDIR "/" PUBKEY;
830
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;
836
837
{
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",
844
.group = 1 },
845
{ .name = "interface", .key = 'i',
846
.arg = "NAME",
847
.doc = "Interface that will be used to search for Mandos"
848
" servers",
849
.group = 1 },
850
{ .name = "seckey", .key = 's',
851
.arg = "FILE",
852
.doc = "OpenPGP secret key file base name",
853
.group = 1 },
854
{ .name = "pubkey", .key = 'p',
855
.arg = "FILE",
856
.doc = "OpenPGP public key file base name",
857
.group = 2 },
858
{ .name = "dh-bits", .key = 129,
859
.arg = "BITS",
860
.doc = "Bit length of the prime number used in the"
861
" Diffie-Hellman key exchange",
862
.group = 2 },
863
{ .name = "priority", .key = 130,
864
.arg = "STRING",
865
.doc = "GnuTLS priority string for the TLS handshake",
866
.group = 1 },
867
{ .name = NULL }
868
};
869
870
error_t parse_opt(int key, char *arg,
871
struct argp_state *state) {
872
switch(key) {
873
case 128: /* --debug */
874
debug = true;
875
break;
876
case 'c': /* --connect */
877
connect_to = arg;
878
break;
879
case 'i': /* --interface */
880
interface = arg;
881
break;
882
case 's': /* --seckey */
883
seckey = arg;
884
break;
885
case 'p': /* --pubkey */
886
pubkey = arg;
887
break;
888
case 129: /* --dh-bits */
889
ret = sscanf(arg, "%u", &mc.dh_bits);
890
if(ret != 1){
891
fprintf(stderr, "Bad number of DH bits\n");
892
exit(EXIT_FAILURE);
557
int ret = 1;
558
int returncode = EXIT_SUCCESS;
559
char *basename = rindex(argv[0], '/');
560
if(basename == NULL){
561
basename = argv[0];
562
} else {
563
basename++;
564
}
565
566
char *program_name = malloc(strlen(basename) + sizeof(db));
567
568
if (program_name == NULL){
569
perror("argv[0]");
570
return EXIT_FAILURE;
571
}
572
573
program_name[0] = '\0';
574
575
for (int i = 1; i < argc; i++){
576
if (not strncmp(argv[i], db, 5)){
577
strcat(strcat(strcat(program_name, db ), "="), basename);
578
if(not strcmp(argv[i], db) or not strcmp(argv[i], program_name)){
579
debug = true;
893
580
}
894
break;
895
case 130: /* --priority */
896
mc.priority = arg;
897
break;
898
case ARGP_KEY_ARG:
899
argp_usage(state);
900
case ARGP_KEY_END:
901
break;
902
default:
903
return ARGP_ERR_UNKNOWN;
904
}
905
return 0;
906
}
907
908
struct argp argp = { .options = options, .parser = parse_opt,
909
.args_doc = "",
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;
916
goto end;
917
}
918
}
919
920
/* If the interface is down, bring it up */
921
{
922
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
923
if(sd < 0) {
924
perror("socket");
925
exitcode = EXIT_FAILURE;
926
goto end;
927
}
928
strcpy(network.ifr_name, interface);
929
ret = ioctl(sd, SIOCGIFFLAGS, &network);
930
if(ret == -1){
931
perror("ioctl SIOCGIFFLAGS");
932
exitcode = EXIT_FAILURE;
933
goto end;
934
}
935
if((network.ifr_flags & IFF_UP) == 0){
936
network.ifr_flags |= IFF_UP;
937
ret = ioctl(sd, SIOCSIFFLAGS, &network);
938
if(ret == -1){
939
perror("ioctl SIOCSIFFLAGS");
940
exitcode = EXIT_FAILURE;
941
goto end;
942
}
943
}
944
ret = (int)TEMP_FAILURE_RETRY(close(sd));
945
if(ret == -1){
946
perror("close");
947
}
948
}
949
950
uid = getuid();
951
gid = getgid();
952
953
ret = setuid(uid);
954
if(ret == -1){
955
perror("setuid");
956
}
957
958
setgid(gid);
959
if(ret == -1){
960
perror("setgid");
961
}
962
963
ret = init_gnutls_global(&mc, pubkey, seckey);
964
if(ret == -1){
965
fprintf(stderr, "init_gnutls_global failed\n");
966
exitcode = EXIT_FAILURE;
967
goto end;
968
} else {
969
gnutls_initalized = true;
970
}
971
972
if(mkdtemp(tempdir) == NULL){
973
perror("mkdtemp");
974
tempdir[0] = '\0';
975
goto end;
976
}
977
978
if(not init_gpgme(&mc, pubkey, seckey, tempdir)){
979
fprintf(stderr, "gpgme_initalized failed\n");
980
exitcode = EXIT_FAILURE;
981
goto end;
982
} else {
983
gpgme_initalized = true;
984
}
985
986
if_index = (AvahiIfIndex) if_nametoindex(interface);
987
if(if_index == 0){
988
fprintf(stderr, "No such interface: \"%s\"\n", interface);
989
exit(EXIT_FAILURE);
990
}
991
992
if(connect_to != NULL){
993
/* Connect directly, do not use Zeroconf */
994
/* (Mainly meant for debugging) */
995
char *address = strrchr(connect_to, ':');
996
if(address == NULL){
997
fprintf(stderr, "No colon in address\n");
998
exitcode = EXIT_FAILURE;
999
goto end;
1000
}
1001
uint16_t port;
1002
ret = sscanf(address+1, "%" SCNu16, &port);
1003
if(ret != 1){
1004
fprintf(stderr, "Bad port number\n");
1005
exitcode = EXIT_FAILURE;
1006
goto end;
1007
}
1008
*address = '\0';
1009
address = connect_to;
1010
ret = start_mandos_communication(address, port, if_index, &mc);
1011
if(ret < 0){
1012
exitcode = EXIT_FAILURE;
1013
} else {
1014
exitcode = EXIT_SUCCESS;
1015
}
1016
goto end;
1017
}
1018
1019
if(not debug){
581
}
582
}
583
free(program_name);
584
585
if (not debug){
1020
586
avahi_set_log_function(empty_log);
1021
587
}
1022
588
1023
/* Initialize the pseudo-RNG for Avahi */
1024
srand((unsigned int) time(NULL));
1025
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"
1030
" object.\n");
1031
exitcode = EXIT_FAILURE;
1032
goto end;
1033
}
1034
1035
{
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;
1043
1044
/* Allocate a new server */
1045
mc.server = avahi_server_new(avahi_simple_poll_get
1046
(mc.simple_poll), &config, NULL,
1047
NULL, &error);
1048
1049
/* Free the Avahi configuration data */
1050
avahi_server_config_free(&config);
1051
}
1052
1053
/* Check if creating the Avahi server object succeeded */
1054
if(mc.server == NULL) {
1055
fprintf(stderr, "Failed to create Avahi server: %s\n",
1056
avahi_strerror(error));
1057
exitcode = EXIT_FAILURE;
1058
goto end;
1059
}
1060
1061
/* Create the Avahi service browser */
1062
sb = avahi_s_service_browser_new(mc.server, if_index,
1063
AVAHI_PROTO_INET6,
1064
"_mandos._tcp", NULL, 0,
1065
browse_callback, &mc);
1066
if(sb == NULL) {
1067
fprintf(stderr, "Failed to create service browser: %s\n",
1068
avahi_strerror(avahi_server_errno(mc.server)));
1069
exitcode = EXIT_FAILURE;
1070
goto end;
589
/* Initialize the psuedo-RNG */
590
srand(time(NULL));
591
592
/* Allocate main loop object */
593
if (!(simple_poll = avahi_simple_poll_new())) {
594
fprintf(stderr, "Failed to create simple poll object.\n");
595
596
goto exit;
597
}
598
599
/* Do not publish any local records */
600
avahi_server_config_init(&config);
601
config.publish_hinfo = 0;
602
config.publish_addresses = 0;
603
config.publish_workstation = 0;
604
config.publish_domain = 0;
605
606
/* Allocate a new server */
607
server = avahi_server_new(avahi_simple_poll_get(simple_poll), &config, NULL, NULL, &error);
608
609
/* Free the configuration data */
610
avahi_server_config_free(&config);
611
612
/* Check if creating the server object succeeded */
613
if (!server) {
614
fprintf(stderr, "Failed to create server: %s\n", avahi_strerror(error));
615
returncode = EXIT_FAILURE;
616
goto exit;
617
}
618
619
/* Create the service browser */
620
if (!(sb = avahi_s_service_browser_new(server, if_nametoindex("eth0"), AVAHI_PROTO_INET6, "_mandos._tcp", NULL, 0, browse_callback, server))) {
621
fprintf(stderr, "Failed to create service browser: %s\n", avahi_strerror(avahi_server_errno(server)));
622
returncode = EXIT_FAILURE;
623
goto exit;
1071
624
}
1072
625
1073
626
/* Run the main loop */
1074
1075
if(debug){
1076
fprintf(stderr, "Starting Avahi loop search\n");
627
628
if (debug){
629
fprintf(stderr, "Starting avahi loop search\n");
1077
630
}
1078
631
1079
avahi_simple_poll_loop(mc.simple_poll);
1080
1081
end:
1082
1083
if(debug){
632
avahi_simple_poll_loop(simple_poll);
633
634
exit:
635
636
if (debug){
1084
637
fprintf(stderr, "%s exiting\n", argv[0]);
1085
638
}
1086
639
1087
640
/* Cleanup things */
1088
if(sb != NULL)
641
if (sb)
1089
642
avahi_s_service_browser_free(sb);
1090
643
1091
if(mc.server != NULL)
1092
avahi_server_free(mc.server);
1093
1094
if(mc.simple_poll != NULL)
1095
avahi_simple_poll_free(mc.simple_poll);
1096
1097
if(gnutls_initalized){
1098
gnutls_certificate_free_credentials(mc.cred);
1099
gnutls_global_deinit();
1100
gnutls_dh_params_deinit(mc.dh_params);
1101
}
1102
1103
if(gpgme_initalized){
1104
gpgme_release(mc.ctx);
1105
}
1106
1107
/* Removes the temp directory used by GPGME */
1108
if(tempdir[0] != '\0'){
1109
DIR *d;
1110
struct dirent *direntry;
1111
d = opendir(tempdir);
1112
if(d == NULL){
1113
if(errno != ENOENT){
1114
perror("opendir");
1115
}
1116
} else {
1117
while(true){
1118
direntry = readdir(d);
1119
if(direntry == NULL){
1120
break;
1121
}
1122
if(direntry->d_type == DT_REG){
1123
char *fullname = NULL;
1124
ret = asprintf(&fullname, "%s/%s", tempdir,
1125
direntry->d_name);
1126
if(ret < 0){
1127
perror("asprintf");
1128
continue;
1129
}
1130
ret = unlink(fullname);
1131
if(ret == -1){
1132
fprintf(stderr, "unlink(\"%s\"): %s",
1133
fullname, strerror(errno));
1134
}
1135
free(fullname);
1136
}
1137
}
1138
closedir(d);
1139
}
1140
ret = rmdir(tempdir);
1141
if(ret == -1 and errno != ENOENT){
1142
perror("rmdir");
1143
}
1144
}
1145
1146
return exitcode;
644
if (server)
645
avahi_server_free(server);
646
647
if (simple_poll)
648
avahi_simple_poll_free(simple_poll);
649
650
return ret;
1147
651
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0