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