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/mandosclient.c
- browse files at revision 38
- compare with another revision
- download diff
- download tarball
- view history from revision 38
- Committer: Teddy Hogeborn
- Date: 2008-08-03 01:09:36 UTC
- mfrom: (24.1.9 mandos)
- Revision ID: teddy@fukt.bsnet.se-20080803010936-ujme8tgxceszfbi1
* plugbasedclient.c (main): New "--userid" and "--groupid" options.
Take an additional non-option argument and
parse it as a plus-separated and -prefixed
list of additional options.
* plugins.d/mandosclient.c (DH_BITS): Replaced with
"mandos_context.dh_bits". All
users changed.
(certdir): Renamed to "keydir". All users changed.
(certfile): Renamed to "pubkeyfile". All users changed.
(certkey): Renamed to "seckeyfile". All users changed.
(encrypted_session): Replaced with "mandos_context". All users
changed.
(initgnutls): Take additional "session" and "dh_params" arguments.
All callers changed.
(start_mandos_communication): Take additional "mc" argument. All
callers changed. Print target IPv6
address if different than supplied
string.
(simple_poll) Replaced with "mandos_context.simple_poll". All users
changed.
(server): Replaced with "mandos_context.server". All users changed.
(main): Default interface to "eth0". Rename "--certdir" to
"--keydir", "--certkey" to "--seckey", and "--certfile" to
"--pubkey". New options "--dh-bits" and "--priority". If
the interface is not up, bring it up.
Take an additional non-option argument and
parse it as a plus-separated and -prefixed
list of additional options.
* plugins.d/mandosclient.c (DH_BITS): Replaced with
"mandos_context.dh_bits". All
users changed.
(certdir): Renamed to "keydir". All users changed.
(certfile): Renamed to "pubkeyfile". All users changed.
(certkey): Renamed to "seckeyfile". All users changed.
(encrypted_session): Replaced with "mandos_context". All users
changed.
(initgnutls): Take additional "session" and "dh_params" arguments.
All callers changed.
(start_mandos_communication): Take additional "mc" argument. All
callers changed. Print target IPv6
address if different than supplied
string.
(simple_poll) Replaced with "mandos_context.simple_poll". All users
changed.
(server): Replaced with "mandos_context.server". All users changed.
(main): Default interface to "eth0". Rename "--certdir" to
"--keydir", "--certkey" to "--seckey", and "--certfile" to
"--pubkey". New options "--dh-bits" and "--priority". If
the interface is not up, bring it up.
- 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
9
9
* "browse_callback", and parts of "main".
10
10
*
11
11
* Everything else is
12
* Copyright © 2008 Teddy Hogeborn & Björn Påhlsson
12
* Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
13
13
*
14
14
* This program is free software: you can redistribute it and/or
15
15
* modify it under the terms of the GNU General Public License as
32
32
#define _LARGEFILE_SOURCE
33
33
#define _FILE_OFFSET_BITS 64
34
34
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_* */
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, SIOCSIFFLAGS
41
#include <net/if.h> // ioctl, ifreq, SIOCGIFFLAGS, IFF_UP, SIOCSIFFLAGS
42
79
43
#include <avahi-core/core.h>
80
44
#include <avahi-core/lookup.h>
81
45
#include <avahi-core/log.h>
83
47
#include <avahi-common/malloc.h>
84
48
#include <avahi-common/error.h>
85
49
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_* */
50
//mandos client part
51
#include <sys/types.h> /* socket(), inet_pton() */
52
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
53
struct in6_addr, inet_pton() */
54
#include <gnutls/gnutls.h> /* All GnuTLS stuff */
55
#include <gnutls/openpgp.h> /* GnuTLS with openpgp stuff */
56
57
#include <unistd.h> /* close() */
58
#include <netinet/in.h>
59
#include <stdbool.h> /* true */
60
#include <string.h> /* memset */
61
#include <arpa/inet.h> /* inet_pton() */
62
#include <iso646.h> /* not */
63
64
// gpgme
65
#include <errno.h> /* perror() */
66
#include <gpgme.h>
67
68
// getopt_long
69
#include <getopt.h>
101
70
102
71
#define BUFFER_SIZE 256
103
72
104
/*
105
#define PATHDIR "/conf/conf.d/mandos"
106
*/
107
108
#define PATHDIR "/conf/conf.d/mandos"
109
#define SECKEY "seckey.txt"
110
#define PUBKEY "pubkey.txt"
73
static const char *keydir = "/conf/conf.d/mandos";
74
static const char *pubkeyfile = "pubkey.txt";
75
static const char *seckeyfile = "seckey.txt";
111
76
112
77
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>";
116
78
117
/* Used for passing in values through the Avahi callback functions */
79
/* Used for passing in values through all the callback functions */
118
80
typedef struct {
119
81
AvahiSimplePoll *simple_poll;
120
82
AvahiServer *server;
121
83
gnutls_certificate_credentials_t cred;
122
84
unsigned int dh_bits;
123
gnutls_dh_params_t dh_params;
124
85
const char *priority;
86
} mandos_context;
87
88
static ssize_t pgp_packet_decrypt (char *packet, size_t packet_size,
89
char **new_packet,
90
const char *homedir){
91
gpgme_data_t dh_crypto, dh_plain;
125
92
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
93
gpgme_error_t rc;
94
ssize_t ret;
95
ssize_t new_packet_capacity = 0;
96
ssize_t new_packet_length = 0;
152
97
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 = 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
99
if (debug){
191
fprintf(stderr, "Initialize gpgme\n");
100
fprintf(stderr, "Trying to decrypt OpenPGP packet\n");
192
101
}
193
102
194
103
/* Init GPGME */
197
106
if (rc != GPG_ERR_NO_ERROR){
198
107
fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
199
108
gpgme_strsource(rc), gpgme_strerror(rc));
200
return false;
109
return -1;
201
110
}
202
111
203
/* Set GPGME home directory for the OpenPGP engine only */
112
/* Set GPGME home directory */
204
113
rc = gpgme_get_engine_info (&engine_info);
205
114
if (rc != GPG_ERR_NO_ERROR){
206
115
fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
207
116
gpgme_strsource(rc), gpgme_strerror(rc));
208
return false;
117
return -1;
209
118
}
210
119
while(engine_info != NULL){
211
120
if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){
212
121
gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,
213
engine_info->file_name, tempdir);
122
engine_info->file_name, homedir);
214
123
break;
215
124
}
216
125
engine_info = engine_info->next;
217
126
}
218
127
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);
128
fprintf(stderr, "Could not set home dir to %s\n", homedir);
129
return -1;
130
}
131
132
/* Create new GPGME data buffer from packet buffer */
133
rc = gpgme_data_new_from_mem(&dh_crypto, packet, packet_size, 0);
259
134
if (rc != GPG_ERR_NO_ERROR){
260
135
fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
261
136
gpgme_strsource(rc), gpgme_strerror(rc));
267
142
if (rc != GPG_ERR_NO_ERROR){
268
143
fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
269
144
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);
145
return -1;
146
}
147
148
/* Create new GPGME "context" */
149
rc = gpgme_new(&ctx);
150
if (rc != GPG_ERR_NO_ERROR){
151
fprintf(stderr, "bad gpgme_new: %s: %s\n",
152
gpgme_strsource(rc), gpgme_strerror(rc));
153
return -1;
154
}
155
156
/* Decrypt data from the FILE pointer to the plaintext data
157
buffer */
158
rc = gpgme_op_decrypt(ctx, dh_crypto, dh_plain);
277
159
if (rc != GPG_ERR_NO_ERROR){
278
160
fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
279
161
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
}
162
return -1;
163
}
164
165
if(debug){
166
fprintf(stderr, "Decryption of OpenPGP packet succeeded\n");
167
}
168
169
if (debug){
170
gpgme_decrypt_result_t result;
171
result = gpgme_op_decrypt_result(ctx);
172
if (result == NULL){
173
fprintf(stderr, "gpgme_op_decrypt_result failed\n");
174
} else {
175
fprintf(stderr, "Unsupported algorithm: %s\n",
176
result->unsupported_algorithm);
177
fprintf(stderr, "Wrong key usage: %d\n",
178
result->wrong_key_usage);
179
if(result->file_name != NULL){
180
fprintf(stderr, "File name: %s\n", result->file_name);
181
}
182
gpgme_recipient_t recipient;
183
recipient = result->recipients;
184
if(recipient){
185
while(recipient != NULL){
186
fprintf(stderr, "Public key algorithm: %s\n",
187
gpgme_pubkey_algo_name(recipient->pubkey_algo));
188
fprintf(stderr, "Key ID: %s\n", recipient->keyid);
189
fprintf(stderr, "Secret key available: %s\n",
190
recipient->status == GPG_ERR_NO_SECKEY
191
? "No" : "Yes");
192
recipient = recipient->next;
306
193
}
307
194
}
308
195
}
309
goto decrypt_end;
310
196
}
311
197
312
if(debug){
313
fprintf(stderr, "Decryption of OpenPGP data succeeded\n");
314
}
198
/* Delete the GPGME FILE pointer cryptotext data buffer */
199
gpgme_data_release(dh_crypto);
315
200
316
201
/* Seek back to the beginning of the GPGME plaintext data buffer */
317
202
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;
203
perror("pgpme_data_seek");
321
204
}
322
205
323
*plaintext = NULL;
206
*new_packet = 0;
324
207
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;
208
if (new_packet_length + BUFFER_SIZE > new_packet_capacity){
209
*new_packet = realloc(*new_packet,
210
(unsigned int)new_packet_capacity
211
+ BUFFER_SIZE);
212
if (*new_packet == NULL){
213
perror("realloc");
214
return -1;
215
}
216
new_packet_capacity += BUFFER_SIZE;
332
217
}
333
218
334
ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
219
ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length,
335
220
BUFFER_SIZE);
336
221
/* Print the data, if any */
337
222
if (ret == 0){
338
/* EOF */
339
223
break;
340
224
}
341
225
if(ret < 0){
342
226
perror("gpgme_data_read");
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);
227
return -1;
228
}
229
new_packet_length += ret;
230
}
231
232
/* FIXME: check characters before printing to screen so to not print
233
terminal control characters */
234
/* if(debug){ */
235
/* fprintf(stderr, "decrypted password is: "); */
236
/* fwrite(*new_packet, 1, new_packet_length, stderr); */
237
/* fprintf(stderr, "\n"); */
238
/* } */
361
239
362
240
/* Delete the GPGME plaintext data buffer */
363
241
gpgme_data_release(dh_plain);
364
return plaintext_length;
242
return new_packet_length;
365
243
}
366
244
367
245
static const char * safer_gnutls_strerror (int value) {
368
const char *ret = gnutls_strerror (value); /* Spurious warning */
246
const char *ret = gnutls_strerror (value);
369
247
if (ret == NULL)
370
248
ret = "(unknown)";
371
249
return ret;
372
250
}
373
251
374
/* GnuTLS log function callback */
375
252
static void debuggnutls(__attribute__((unused)) int level,
376
253
const char* string){
377
fprintf(stderr, "GnuTLS: %s", string);
254
fprintf(stderr, "%s", string);
378
255
}
379
256
380
static int init_gnutls_global(mandos_context *mc,
381
const char *pubkeyfilename,
382
const char *seckeyfilename){
257
static int initgnutls(mandos_context *mc, gnutls_session_t *session,
258
gnutls_dh_params_t *dh_params){
259
const char *err;
383
260
int ret;
384
261
385
262
if(debug){
386
263
fprintf(stderr, "Initializing GnuTLS\n");
387
264
}
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));
265
266
if ((ret = gnutls_global_init ())
267
!= GNUTLS_E_SUCCESS) {
268
fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
393
269
return -1;
394
270
}
395
271
396
272
if (debug){
397
/* "Use a log level over 10 to enable all debugging options."
398
* - GnuTLS manual
399
*/
400
273
gnutls_global_set_log_level(11);
401
274
gnutls_global_set_log_function(debuggnutls);
402
275
}
403
276
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 */
277
/* openpgp credentials */
278
if ((ret = gnutls_certificate_allocate_credentials (&mc->cred))
279
!= GNUTLS_E_SUCCESS) {
280
fprintf (stderr, "memory error: %s\n",
409
281
safer_gnutls_strerror(ret));
410
gnutls_global_deinit ();
411
282
return -1;
412
283
}
413
284
414
285
if(debug){
415
fprintf(stderr, "Attempting to use OpenPGP public key %s and"
416
" secret key %s as GnuTLS credentials\n", pubkeyfilename,
417
seckeyfilename);
286
fprintf(stderr, "Attempting to use OpenPGP certificate %s"
287
" and keyfile %s as GnuTLS credentials\n", pubkeyfile,
288
seckeyfile);
418
289
}
419
290
420
291
ret = gnutls_certificate_set_openpgp_key_file
421
(mc->cred, pubkeyfilename, seckeyfilename,
422
GNUTLS_OPENPGP_FMT_BASE64);
292
(mc->cred, pubkeyfile, seckeyfile, GNUTLS_OPENPGP_FMT_BASE64);
423
293
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",
294
fprintf
295
(stderr, "Error[%d] while reading the OpenPGP key pair ('%s',"
296
" '%s')\n",
297
ret, pubkeyfile, seckeyfile);
298
fprintf(stdout, "The Error is: %s\n",
428
299
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){
300
return -1;
301
}
302
303
//GnuTLS server initialization
304
if ((ret = gnutls_dh_params_init(dh_params))
305
!= GNUTLS_E_SUCCESS) {
306
fprintf (stderr, "Error in dh parameter initialization: %s\n",
307
safer_gnutls_strerror(ret));
308
return -1;
309
}
310
311
if ((ret = gnutls_dh_params_generate2(*dh_params, mc->dh_bits))
312
!= GNUTLS_E_SUCCESS) {
313
fprintf (stderr, "Error in prime generation: %s\n",
314
safer_gnutls_strerror(ret));
315
return -1;
316
}
317
318
gnutls_certificate_set_dh_params(mc->cred, *dh_params);
319
320
// GnuTLS session creation
321
if ((ret = gnutls_init(session, GNUTLS_SERVER))
322
!= GNUTLS_E_SUCCESS){
464
323
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
465
324
safer_gnutls_strerror(ret));
466
325
}
467
326
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
}
327
if ((ret = gnutls_priority_set_direct(*session, mc->priority, &err))
328
!= GNUTLS_E_SUCCESS) {
329
fprintf(stderr, "Syntax error at: %s\n", err);
330
fprintf(stderr, "GnuTLS error: %s\n",
331
safer_gnutls_strerror(ret));
332
return -1;
478
333
}
479
334
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",
335
if ((ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
336
mc->cred))
337
!= GNUTLS_E_SUCCESS) {
338
fprintf(stderr, "Error setting a credentials set: %s\n",
484
339
safer_gnutls_strerror(ret));
485
gnutls_deinit (*session);
486
340
return -1;
487
341
}
488
342
495
349
return 0;
496
350
}
497
351
498
/* Avahi log function callback */
499
352
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
500
353
__attribute__((unused)) const char *txt){}
501
354
502
/* Called when a Mandos server is found */
503
355
static int start_mandos_communication(const char *ip, uint16_t port,
504
356
AvahiIfIndex if_index,
505
357
mandos_context *mc){
506
358
int ret, tcp_sd;
507
union { struct sockaddr in; struct sockaddr_in6 in6; } to;
359
struct sockaddr_in6 to;
508
360
char *buffer = NULL;
509
361
char *decrypted_buffer;
510
362
size_t buffer_length = 0;
511
363
size_t buffer_capacity = 0;
512
364
ssize_t decrypted_buffer_size;
513
size_t written;
365
size_t written = 0;
514
366
int retval = 0;
515
367
char interface[IF_NAMESIZE];
516
368
gnutls_session_t session;
517
518
ret = init_gnutls_session (mc, &session);
519
if (ret != 0){
520
return -1;
521
}
369
gnutls_dh_params_t dh_params;
522
370
523
371
if(debug){
524
fprintf(stderr, "Setting up a tcp connection to %s, port %" PRIu16
525
"\n", ip, port);
372
fprintf(stderr, "Setting up a tcp connection to %s, port %d\n",
373
ip, port);
526
374
}
527
375
528
376
tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
530
378
perror("socket");
531
379
return -1;
532
380
}
533
381
534
382
if(debug){
535
383
if(if_indextoname((unsigned int)if_index, interface) == NULL){
536
384
perror("if_indextoname");
539
387
fprintf(stderr, "Binding to interface %s\n", interface);
540
388
}
541
389
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);
390
memset(&to,0,sizeof(to)); /* Spurious warning */
391
to.sin6_family = AF_INET6;
392
ret = inet_pton(AF_INET6, ip, &to.sin6_addr);
547
393
if (ret < 0 ){
548
394
perror("inet_pton");
549
395
return -1;
552
398
fprintf(stderr, "Bad address: %s\n", ip);
553
399
return -1;
554
400
}
555
to.in6.sin6_port = htons(port); /* Spurious warning */
401
to.sin6_port = htons(port); /* Spurious warning */
556
402
557
to.in6.sin6_scope_id = (uint32_t)if_index;
403
to.sin6_scope_id = (uint32_t)if_index;
558
404
559
405
if(debug){
560
fprintf(stderr, "Connection to: %s, port %" PRIu16 "\n", ip,
561
port);
406
fprintf(stderr, "Connection to: %s, port %d\n", ip, port);
562
407
char addrstr[INET6_ADDRSTRLEN] = "";
563
if(inet_ntop(to.in6.sin6_family, &(to.in6.sin6_addr), addrstr,
408
if(inet_ntop(to.sin6_family, &(to.sin6_addr), addrstr,
564
409
sizeof(addrstr)) == NULL){
565
410
perror("inet_ntop");
566
411
} else {
570
415
}
571
416
}
572
417
573
ret = connect(tcp_sd, &to.in, sizeof(to));
418
ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
574
419
if (ret < 0){
575
420
perror("connect");
576
421
return -1;
577
422
}
578
423
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
}
424
ret = initgnutls (mc, &session, &dh_params);
425
if (ret != 0){
426
retval = -1;
427
return -1;
601
428
}
602
429
430
gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) tcp_sd);
431
603
432
if(debug){
604
433
fprintf(stderr, "Establishing TLS session with %s\n", ip);
605
434
}
606
435
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);
436
ret = gnutls_handshake (session);
612
437
613
438
if (ret != GNUTLS_E_SUCCESS){
614
439
if(debug){
615
fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
440
fprintf(stderr, "\n*** Handshake failed ***\n");
616
441
gnutls_perror (ret);
617
442
}
618
443
retval = -1;
619
goto mandos_end;
444
goto exit;
620
445
}
621
446
622
/* Read OpenPGP packet that contains the wanted password */
447
//Retrieve OpenPGP packet that contains the wanted password
623
448
624
449
if(debug){
625
450
fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
626
451
ip);
627
452
}
628
453
629
454
while(true){
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;
455
if (buffer_length + BUFFER_SIZE > buffer_capacity){
456
buffer = realloc(buffer, buffer_capacity + BUFFER_SIZE);
457
if (buffer == NULL){
458
perror("realloc");
459
goto exit;
460
}
461
buffer_capacity += BUFFER_SIZE;
636
462
}
637
463
638
464
ret = gnutls_record_recv(session, buffer+buffer_length,
646
472
case GNUTLS_E_AGAIN:
647
473
break;
648
474
case GNUTLS_E_REHANDSHAKE:
649
do{
650
ret = gnutls_handshake (session);
651
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
475
ret = gnutls_handshake (session);
652
476
if (ret < 0){
653
fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
477
fprintf(stderr, "\n*** Handshake failed ***\n");
654
478
gnutls_perror (ret);
655
479
retval = -1;
656
goto mandos_end;
480
goto exit;
657
481
}
658
482
break;
659
483
default:
660
484
fprintf(stderr, "Unknown error while reading data from"
661
" encrypted session with Mandos server\n");
485
" encrypted session with mandos server\n");
662
486
retval = -1;
663
487
gnutls_bye (session, GNUTLS_SHUT_RDWR);
664
goto mandos_end;
488
goto exit;
665
489
}
666
490
} else {
667
491
buffer_length += (size_t) ret;
668
492
}
669
493
}
670
494
671
if(debug){
672
fprintf(stderr, "Closing TLS session\n");
673
}
674
675
gnutls_bye (session, GNUTLS_SHUT_RDWR);
676
677
495
if (buffer_length > 0){
678
decrypted_buffer_size = pgp_packet_decrypt(mc, buffer,
496
decrypted_buffer_size = pgp_packet_decrypt(buffer,
679
497
buffer_length,
680
&decrypted_buffer);
498
&decrypted_buffer,
499
keydir);
681
500
if (decrypted_buffer_size >= 0){
682
written = 0;
683
501
while(written < (size_t) decrypted_buffer_size){
684
502
ret = (int)fwrite (decrypted_buffer + written, 1,
685
503
(size_t)decrypted_buffer_size - written,
698
516
} else {
699
517
retval = -1;
700
518
}
701
} else {
702
retval = -1;
703
}
704
705
/* Shutdown procedure */
706
707
mandos_end:
519
}
520
521
//shutdown procedure
522
523
if(debug){
524
fprintf(stderr, "Closing TLS session\n");
525
}
526
708
527
free(buffer);
709
ret = TEMP_FAILURE_RETRY(close(tcp_sd));
710
if(ret == -1){
711
perror("close");
712
}
528
gnutls_bye (session, GNUTLS_SHUT_RDWR);
529
exit:
530
close(tcp_sd);
713
531
gnutls_deinit (session);
532
gnutls_certificate_free_credentials (mc->cred);
533
gnutls_global_deinit ();
714
534
return retval;
715
535
}
716
536
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) {
537
static void resolve_callback( AvahiSServiceResolver *r,
538
AvahiIfIndex interface,
539
AVAHI_GCC_UNUSED AvahiProtocol protocol,
540
AvahiResolverEvent event,
541
const char *name,
542
const char *type,
543
const char *domain,
544
const char *host_name,
545
const AvahiAddress *address,
546
uint16_t port,
547
AVAHI_GCC_UNUSED AvahiStringList *txt,
548
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
549
void* userdata) {
731
550
mandos_context *mc = userdata;
732
assert(r);
551
assert(r); /* Spurious warning */
733
552
734
553
/* Called whenever a service has been resolved successfully or
735
554
timed out */
737
556
switch (event) {
738
557
default:
739
558
case AVAHI_RESOLVER_FAILURE:
740
fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
741
" of type '%s' in domain '%s': %s\n", name, type, domain,
559
fprintf(stderr, "(Resolver) Failed to resolve service '%s' of"
560
" type '%s' in domain '%s': %s\n", name, type, domain,
742
561
avahi_strerror(avahi_server_errno(mc->server)));
743
562
break;
744
563
747
566
char ip[AVAHI_ADDRESS_STR_MAX];
748
567
avahi_address_snprint(ip, sizeof(ip), address);
749
568
if(debug){
750
fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %"
751
PRIu16 ") on port %d\n", name, host_name, ip,
752
interface, port);
569
fprintf(stderr, "Mandos server \"%s\" found on %s (%s) on"
570
" port %d\n", name, host_name, ip, port);
753
571
}
754
572
int ret = start_mandos_communication(ip, port, interface, mc);
755
573
if (ret == 0){
756
avahi_simple_poll_quit(mc->simple_poll);
574
exit(EXIT_SUCCESS);
757
575
}
758
576
}
759
577
}
767
585
const char *name,
768
586
const char *type,
769
587
const char *domain,
770
AVAHI_GCC_UNUSED AvahiLookupResultFlags
771
flags,
588
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
772
589
void* userdata) {
773
590
mandos_context *mc = userdata;
774
assert(b);
591
assert(b); /* Spurious warning */
775
592
776
593
/* Called whenever a new services becomes available on the LAN or
777
594
is removed from the LAN */
780
597
default:
781
598
case AVAHI_BROWSER_FAILURE:
782
599
783
fprintf(stderr, "(Avahi browser) %s\n",
600
fprintf(stderr, "(Browser) %s\n",
784
601
avahi_strerror(avahi_server_errno(mc->server)));
785
602
avahi_simple_poll_quit(mc->simple_poll);
786
603
return;
787
604
788
605
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. */
606
/* We ignore the returned resolver object. In the callback
607
function we free it. If the server is terminated before
608
the callback function is called the server will free
609
the resolver for us. */
793
610
794
if (!(avahi_s_service_resolver_new(mc->server, interface,
795
protocol, name, type, domain,
611
if (!(avahi_s_service_resolver_new(mc->server, interface, protocol, name,
612
type, domain,
796
613
AVAHI_PROTO_INET6, 0,
797
614
resolve_callback, mc)))
798
fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
799
name, avahi_strerror(avahi_server_errno(mc->server)));
615
fprintf(stderr, "Failed to resolve service '%s': %s\n", name,
616
avahi_strerror(avahi_server_errno(mc->server)));
800
617
break;
801
618
802
619
case AVAHI_BROWSER_REMOVE:
804
621
805
622
case AVAHI_BROWSER_ALL_FOR_NOW:
806
623
case AVAHI_BROWSER_CACHE_EXHAUSTED:
807
if(debug){
808
fprintf(stderr, "No Mandos server found, still searching...\n");
809
}
810
624
break;
811
625
}
812
626
}
813
627
814
int main(int argc, char *argv[]){
628
/* Combines file name and path and returns the malloced new
629
string. some sane checks could/should be added */
630
static const char *combinepath(const char *first, const char *second){
631
size_t f_len = strlen(first);
632
size_t s_len = strlen(second);
633
char *tmp = malloc(f_len + s_len + 2);
634
if (tmp == NULL){
635
return NULL;
636
}
637
if(f_len > 0){
638
memcpy(tmp, first, f_len); /* Spurious warning */
639
}
640
tmp[f_len] = '/';
641
if(s_len > 0){
642
memcpy(tmp + f_len + 1, second, s_len); /* Spurious warning */
643
}
644
tmp[f_len + 1 + s_len] = '\0';
645
return tmp;
646
}
647
648
649
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
650
AvahiServerConfig config;
815
651
AvahiSServiceBrowser *sb = NULL;
816
652
int error;
817
653
int ret;
818
int exitcode = EXIT_SUCCESS;
654
int debug_int;
655
int returncode = EXIT_SUCCESS;
819
656
const char *interface = "eth0";
820
657
struct ifreq network;
821
658
int sd;
822
uid_t uid;
823
gid_t gid;
824
659
char *connect_to = NULL;
825
char tempdir[] = "/tmp/mandosXXXXXX";
826
660
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
827
const char *seckey = PATHDIR "/" SECKEY;
828
const char *pubkey = PATHDIR "/" PUBKEY;
829
830
661
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;
662
.dh_bits = 1024, .priority = "SECURE256"};
663
664
debug_int = debug ? 1 : 0;
665
while (true){
666
struct option long_options[] = {
667
{"debug", no_argument, &debug_int, 1},
668
{"connect", required_argument, NULL, 'c'},
669
{"interface", required_argument, NULL, 'i'},
670
{"keydir", required_argument, NULL, 'd'},
671
{"seckey", required_argument, NULL, 's'},
672
{"pubkey", required_argument, NULL, 'p'},
673
{"dh-bits", required_argument, NULL, 'D'},
674
{"priority", required_argument, NULL, 'P'},
675
{0, 0, 0, 0} };
676
677
int option_index = 0;
678
ret = getopt_long (argc, argv, "i:", long_options,
679
&option_index);
680
681
if (ret == -1){
682
break;
683
}
684
685
switch(ret){
686
case 0:
687
break;
688
case 'i':
689
interface = optarg;
690
break;
691
case 'c':
692
connect_to = optarg;
693
break;
694
case 'd':
695
keydir = optarg;
696
break;
697
case 'p':
698
pubkeyfile = optarg;
699
break;
700
case 's':
701
seckeyfile = optarg;
702
break;
703
case 'D':
704
errno = 0;
705
mc.dh_bits = (unsigned int) strtol(optarg, NULL, 10);
706
if (errno){
707
perror("strtol");
708
exit(EXIT_FAILURE);
709
}
710
break;
711
case 'P':
712
mc.priority = optarg;
713
break;
714
case '?':
715
default:
716
exit(EXIT_FAILURE);
717
}
718
}
719
debug = debug_int ? true : false;
720
721
pubkeyfile = combinepath(keydir, pubkeyfile);
722
if (pubkeyfile == NULL){
723
perror("combinepath");
724
returncode = EXIT_FAILURE;
725
goto exit;
726
}
727
728
seckeyfile = combinepath(keydir, seckeyfile);
729
if (seckeyfile == NULL){
730
perror("combinepath");
731
goto exit;
986
732
}
987
733
988
734
if_index = (AvahiIfIndex) if_nametoindex(interface);
997
743
char *address = strrchr(connect_to, ':');
998
744
if(address == NULL){
999
745
fprintf(stderr, "No colon in address\n");
1000
exitcode = EXIT_FAILURE;
1001
goto end;
746
exit(EXIT_FAILURE);
1002
747
}
1003
748
errno = 0;
1004
749
uint16_t port = (uint16_t) strtol(address+1, NULL, 10);
1005
750
if(errno){
1006
751
perror("Bad port number");
1007
exitcode = EXIT_FAILURE;
1008
goto end;
752
exit(EXIT_FAILURE);
1009
753
}
1010
754
*address = '\0';
1011
755
address = connect_to;
1012
756
ret = start_mandos_communication(address, port, if_index, &mc);
1013
757
if(ret < 0){
1014
exitcode = EXIT_FAILURE;
758
exit(EXIT_FAILURE);
1015
759
} else {
1016
exitcode = EXIT_SUCCESS;
1017
}
1018
goto end;
1019
}
760
exit(EXIT_SUCCESS);
761
}
762
}
763
764
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
765
if(sd < 0) {
766
perror("socket");
767
returncode = EXIT_FAILURE;
768
goto exit;
769
}
770
strcpy(network.ifr_name, interface); /* Spurious warning */
771
ret = ioctl(sd, SIOCGIFFLAGS, &network);
772
if(ret == -1){
773
774
perror("ioctl SIOCGIFFLAGS");
775
returncode = EXIT_FAILURE;
776
goto exit;
777
}
778
if((network.ifr_flags & IFF_UP) == 0){
779
network.ifr_flags |= IFF_UP;
780
ret = ioctl(sd, SIOCSIFFLAGS, &network);
781
if(ret == -1){
782
perror("ioctl SIOCSIFFLAGS");
783
returncode = EXIT_FAILURE;
784
goto exit;
785
}
786
}
787
close(sd);
1020
788
1021
789
if (not debug){
1022
790
avahi_set_log_function(empty_log);
1023
791
}
1024
792
1025
/* Initialize the pseudo-RNG for Avahi */
793
/* Initialize the psuedo-RNG */
1026
794
srand((unsigned int) time(NULL));
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",
795
796
/* Allocate main loop object */
797
if (!(mc.simple_poll = avahi_simple_poll_new())) {
798
fprintf(stderr, "Failed to create simple poll object.\n");
799
returncode = EXIT_FAILURE;
800
goto exit;
801
}
802
803
/* Do not publish any local records */
804
avahi_server_config_init(&config);
805
config.publish_hinfo = 0;
806
config.publish_addresses = 0;
807
config.publish_workstation = 0;
808
config.publish_domain = 0;
809
810
/* Allocate a new server */
811
mc.server=avahi_server_new(avahi_simple_poll_get(mc.simple_poll),
812
&config, NULL, NULL, &error);
813
814
/* Free the configuration data */
815
avahi_server_config_free(&config);
816
817
/* Check if creating the server object succeeded */
818
if (!mc.server) {
819
fprintf(stderr, "Failed to create server: %s\n",
1058
820
avahi_strerror(error));
1059
exitcode = EXIT_FAILURE;
1060
goto end;
821
returncode = EXIT_FAILURE;
822
goto exit;
1061
823
}
1062
824
1063
/* Create the Avahi service browser */
825
/* Create the service browser */
1064
826
sb = avahi_s_service_browser_new(mc.server, if_index,
1065
827
AVAHI_PROTO_INET6,
1066
828
"_mandos._tcp", NULL, 0,
1067
829
browse_callback, &mc);
1068
if (sb == NULL) {
830
if (!sb) {
1069
831
fprintf(stderr, "Failed to create service browser: %s\n",
1070
832
avahi_strerror(avahi_server_errno(mc.server)));
1071
exitcode = EXIT_FAILURE;
1072
goto end;
833
returncode = EXIT_FAILURE;
834
goto exit;
1073
835
}
1074
836
1075
837
/* Run the main loop */
1076
838
1077
839
if (debug){
1078
fprintf(stderr, "Starting Avahi loop search\n");
840
fprintf(stderr, "Starting avahi loop search\n");
1079
841
}
1080
842
1081
843
avahi_simple_poll_loop(mc.simple_poll);
1082
844
1083
end:
1084
845
exit:
846
1085
847
if (debug){
1086
848
fprintf(stderr, "%s exiting\n", argv[0]);
1087
849
}
1088
850
1089
851
/* Cleanup things */
1090
if (sb != NULL)
852
if (sb)
1091
853
avahi_s_service_browser_free(sb);
1092
854
1093
if (mc.server != NULL)
855
if (mc.server)
1094
856
avahi_server_free(mc.server);
1095
1096
if (mc.simple_poll != NULL)
857
858
if (mc.simple_poll)
1097
859
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;
860
free(pubkeyfile);
861
free(seckeyfile);
862
863
return returncode;
1147
864
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0