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