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 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:
- COPYING
- files renamed:
- plugin-runner.c => plugbasedclient.c
- plugins.d/password-request.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
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 */
51
#include <inttypes.h> /* PRIu16 */
52
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
53
struct in6_addr, inet_pton(),
54
connect() */
55
#include <assert.h> /* assert() */
56
#include <errno.h> /* perror(), errno */
57
#include <time.h> /* time() */
58
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
59
SIOCSIFFLAGS, if_indextoname(),
60
if_nametoindex(), IF_NAMESIZE */
61
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
62
getuid(), getgid(), setuid(),
63
setgid() */
64
#include <netinet/in.h>
65
#include <arpa/inet.h> /* inet_pton(), htons */
66
#include <iso646.h> /* not, and */
67
#include <argp.h> /* struct argp_option, error_t, struct
68
argp_state, struct argp,
69
argp_parse(), ARGP_KEY_ARG,
70
ARGP_KEY_END, ARGP_ERR_UNKNOWN */
71
72
/* Avahi */
73
/* All Avahi types, constants and functions
74
Avahi*, avahi_*,
75
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
76
43
#include <avahi-core/core.h>
77
44
#include <avahi-core/lookup.h>
78
45
#include <avahi-core/log.h>
80
47
#include <avahi-common/malloc.h>
81
48
#include <avahi-common/error.h>
82
49
83
/* GnuTLS */
84
#include <gnutls/gnutls.h> /* All GnuTLS types, constants and
85
functions:
86
gnutls_*
87
init_gnutls_session(),
88
GNUTLS_* */
89
#include <gnutls/openpgp.h> /* gnutls_certificate_set_openpgp_key_file(),
90
GNUTLS_OPENPGP_FMT_BASE64 */
91
92
/* GPGME */
93
#include <gpgme.h> /* All GPGME types, constants and
94
functions:
95
gpgme_*
96
GPGME_PROTOCOL_OpenPGP,
97
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>
98
70
99
71
#define BUFFER_SIZE 256
100
72
73
static const char *keydir = "/conf/conf.d/mandos";
74
static const char *pubkeyfile = "pubkey.txt";
75
static const char *seckeyfile = "seckey.txt";
76
101
77
bool debug = false;
102
static const char *keydir = "/conf/conf.d/mandos";
103
static const char mandos_protocol_version[] = "1";
104
const char *argp_program_version = "password-request 1.0";
105
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
106
78
107
/* Used for passing in values through the Avahi callback functions */
79
/* Used for passing in values through all the callback functions */
108
80
typedef struct {
109
81
AvahiSimplePoll *simple_poll;
110
82
AvahiServer *server;
111
83
gnutls_certificate_credentials_t cred;
112
84
unsigned int dh_bits;
113
gnutls_dh_params_t dh_params;
114
85
const char *priority;
115
86
} mandos_context;
116
87
117
/*
118
* Make room in "buffer" for at least BUFFER_SIZE additional bytes.
119
* "buffer_capacity" is how much is currently allocated,
120
* "buffer_length" is how much is already used.
121
*/
122
size_t adjustbuffer(char **buffer, size_t buffer_length,
123
size_t buffer_capacity){
124
if (buffer_length + BUFFER_SIZE > buffer_capacity){
125
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
126
if (buffer == NULL){
127
return 0;
128
}
129
buffer_capacity += BUFFER_SIZE;
130
}
131
return buffer_capacity;
132
}
133
134
/*
135
* Decrypt OpenPGP data using keyrings in HOMEDIR.
136
* Returns -1 on error
137
*/
138
static ssize_t pgp_packet_decrypt (const char *cryptotext,
139
size_t crypto_size,
140
char **plaintext,
88
static ssize_t pgp_packet_decrypt (char *packet, size_t packet_size,
89
char **new_packet,
141
90
const char *homedir){
142
91
gpgme_data_t dh_crypto, dh_plain;
143
92
gpgme_ctx_t ctx;
144
93
gpgme_error_t rc;
145
94
ssize_t ret;
146
size_t plaintext_capacity = 0;
147
ssize_t plaintext_length = 0;
95
ssize_t new_packet_capacity = 0;
96
ssize_t new_packet_length = 0;
148
97
gpgme_engine_info_t engine_info;
149
98
150
99
if (debug){
151
fprintf(stderr, "Trying to decrypt OpenPGP data\n");
100
fprintf(stderr, "Trying to decrypt OpenPGP packet\n");
152
101
}
153
102
154
103
/* Init GPGME */
160
109
return -1;
161
110
}
162
111
163
/* Set GPGME home directory for the OpenPGP engine only */
112
/* Set GPGME home directory */
164
113
rc = gpgme_get_engine_info (&engine_info);
165
114
if (rc != GPG_ERR_NO_ERROR){
166
115
fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
176
125
engine_info = engine_info->next;
177
126
}
178
127
if(engine_info == NULL){
179
fprintf(stderr, "Could not set GPGME home dir to %s\n", homedir);
128
fprintf(stderr, "Could not set home dir to %s\n", homedir);
180
129
return -1;
181
130
}
182
131
183
/* Create new GPGME data buffer from memory cryptotext */
184
rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
185
0);
132
/* Create new GPGME data buffer from packet buffer */
133
rc = gpgme_data_new_from_mem(&dh_crypto, packet, packet_size, 0);
186
134
if (rc != GPG_ERR_NO_ERROR){
187
135
fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
188
136
gpgme_strsource(rc), gpgme_strerror(rc));
194
142
if (rc != GPG_ERR_NO_ERROR){
195
143
fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
196
144
gpgme_strsource(rc), gpgme_strerror(rc));
197
gpgme_data_release(dh_crypto);
198
145
return -1;
199
146
}
200
147
203
150
if (rc != GPG_ERR_NO_ERROR){
204
151
fprintf(stderr, "bad gpgme_new: %s: %s\n",
205
152
gpgme_strsource(rc), gpgme_strerror(rc));
206
plaintext_length = -1;
207
goto decrypt_end;
153
return -1;
208
154
}
209
155
210
/* Decrypt data from the cryptotext data buffer to the plaintext
211
data buffer */
156
/* Decrypt data from the FILE pointer to the plaintext data
157
buffer */
212
158
rc = gpgme_op_decrypt(ctx, dh_crypto, dh_plain);
213
159
if (rc != GPG_ERR_NO_ERROR){
214
160
fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
215
161
gpgme_strsource(rc), gpgme_strerror(rc));
216
plaintext_length = -1;
217
goto decrypt_end;
162
return -1;
218
163
}
219
164
220
165
if(debug){
221
fprintf(stderr, "Decryption of OpenPGP data succeeded\n");
166
fprintf(stderr, "Decryption of OpenPGP packet succeeded\n");
222
167
}
223
168
224
169
if (debug){
225
170
gpgme_decrypt_result_t result;
226
171
result = gpgme_op_decrypt_result(ctx);
229
174
} else {
230
175
fprintf(stderr, "Unsupported algorithm: %s\n",
231
176
result->unsupported_algorithm);
232
fprintf(stderr, "Wrong key usage: %u\n",
177
fprintf(stderr, "Wrong key usage: %d\n",
233
178
result->wrong_key_usage);
234
179
if(result->file_name != NULL){
235
180
fprintf(stderr, "File name: %s\n", result->file_name);
250
195
}
251
196
}
252
197
198
/* Delete the GPGME FILE pointer cryptotext data buffer */
199
gpgme_data_release(dh_crypto);
200
253
201
/* Seek back to the beginning of the GPGME plaintext data buffer */
254
202
if (gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET) == -1){
255
203
perror("pgpme_data_seek");
256
plaintext_length = -1;
257
goto decrypt_end;
258
204
}
259
205
260
*plaintext = NULL;
206
*new_packet = 0;
261
207
while(true){
262
plaintext_capacity = adjustbuffer(plaintext,
263
(size_t)plaintext_length,
264
plaintext_capacity);
265
if (plaintext_capacity == 0){
266
perror("adjustbuffer");
267
plaintext_length = -1;
268
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;
269
217
}
270
218
271
ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
219
ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length,
272
220
BUFFER_SIZE);
273
221
/* Print the data, if any */
274
222
if (ret == 0){
275
/* EOF */
276
223
break;
277
224
}
278
225
if(ret < 0){
279
226
perror("gpgme_data_read");
280
plaintext_length = -1;
281
goto decrypt_end;
227
return -1;
282
228
}
283
plaintext_length += ret;
229
new_packet_length += ret;
284
230
}
285
231
286
if(debug){
287
fprintf(stderr, "Decrypted password is: ");
288
for(ssize_t i = 0; i < plaintext_length; i++){
289
fprintf(stderr, "%02hhX ", (*plaintext)[i]);
290
}
291
fprintf(stderr, "\n");
292
}
293
294
decrypt_end:
295
296
/* Delete the GPGME cryptotext data buffer */
297
gpgme_data_release(dh_crypto);
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
/* } */
298
239
299
240
/* Delete the GPGME plaintext data buffer */
300
241
gpgme_data_release(dh_plain);
301
return plaintext_length;
242
return new_packet_length;
302
243
}
303
244
304
245
static const char * safer_gnutls_strerror (int value) {
308
249
return ret;
309
250
}
310
251
311
/* GnuTLS log function callback */
312
252
static void debuggnutls(__attribute__((unused)) int level,
313
253
const char* string){
314
fprintf(stderr, "GnuTLS: %s", string);
254
fprintf(stderr, "%s", string);
315
255
}
316
256
317
static int init_gnutls_global(mandos_context *mc,
318
const char *pubkeyfilename,
319
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;
320
260
int ret;
321
261
322
262
if(debug){
323
263
fprintf(stderr, "Initializing GnuTLS\n");
324
264
}
325
326
ret = gnutls_global_init();
327
if (ret != GNUTLS_E_SUCCESS) {
328
fprintf (stderr, "GnuTLS global_init: %s\n",
329
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));
330
269
return -1;
331
270
}
332
271
333
272
if (debug){
334
/* "Use a log level over 10 to enable all debugging options."
335
* - GnuTLS manual
336
*/
337
273
gnutls_global_set_log_level(11);
338
274
gnutls_global_set_log_function(debuggnutls);
339
275
}
340
276
341
/* OpenPGP credentials */
342
gnutls_certificate_allocate_credentials(&mc->cred);
343
if (ret != GNUTLS_E_SUCCESS){
344
fprintf (stderr, "GnuTLS memory error: %s\n",
277
/* openpgp credentials */
278
if ((ret = gnutls_certificate_allocate_credentials (&mc->cred))
279
!= GNUTLS_E_SUCCESS) {
280
fprintf (stderr, "memory error: %s\n",
345
281
safer_gnutls_strerror(ret));
346
gnutls_global_deinit ();
347
282
return -1;
348
283
}
349
284
350
285
if(debug){
351
286
fprintf(stderr, "Attempting to use OpenPGP certificate %s"
352
" and keyfile %s as GnuTLS credentials\n", pubkeyfilename,
353
seckeyfilename);
287
" and keyfile %s as GnuTLS credentials\n", pubkeyfile,
288
seckeyfile);
354
289
}
355
290
356
291
ret = gnutls_certificate_set_openpgp_key_file
357
(mc->cred, pubkeyfilename, seckeyfilename,
358
GNUTLS_OPENPGP_FMT_BASE64);
292
(mc->cred, pubkeyfile, seckeyfile, GNUTLS_OPENPGP_FMT_BASE64);
359
293
if (ret != GNUTLS_E_SUCCESS) {
360
fprintf(stderr,
361
"Error[%d] while reading the OpenPGP key pair ('%s',"
362
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
363
fprintf(stdout, "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",
364
299
safer_gnutls_strerror(ret));
365
goto globalfail;
366
}
367
368
/* GnuTLS server initialization */
369
ret = gnutls_dh_params_init(&mc->dh_params);
370
if (ret != GNUTLS_E_SUCCESS) {
371
fprintf (stderr, "Error in GnuTLS DH parameter initialization:"
372
" %s\n", safer_gnutls_strerror(ret));
373
goto globalfail;
374
}
375
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
376
if (ret != GNUTLS_E_SUCCESS) {
377
fprintf (stderr, "Error in GnuTLS prime generation: %s\n",
378
safer_gnutls_strerror(ret));
379
goto globalfail;
380
}
381
382
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
383
384
return 0;
385
386
globalfail:
387
388
gnutls_certificate_free_credentials(mc->cred);
389
gnutls_global_deinit();
390
return -1;
391
392
}
393
394
static int init_gnutls_session(mandos_context *mc,
395
gnutls_session_t *session){
396
int ret;
397
/* GnuTLS session creation */
398
ret = gnutls_init(session, GNUTLS_SERVER);
399
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){
400
323
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
401
324
safer_gnutls_strerror(ret));
402
325
}
403
326
404
{
405
const char *err;
406
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
407
if (ret != GNUTLS_E_SUCCESS) {
408
fprintf(stderr, "Syntax error at: %s\n", err);
409
fprintf(stderr, "GnuTLS error: %s\n",
410
safer_gnutls_strerror(ret));
411
gnutls_deinit (*session);
412
return -1;
413
}
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;
414
333
}
415
334
416
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
417
mc->cred);
418
if (ret != GNUTLS_E_SUCCESS) {
419
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",
420
339
safer_gnutls_strerror(ret));
421
gnutls_deinit (*session);
422
340
return -1;
423
341
}
424
342
431
349
return 0;
432
350
}
433
351
434
/* Avahi log function callback */
435
352
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
436
353
__attribute__((unused)) const char *txt){}
437
354
438
/* Called when a Mandos server is found */
439
355
static int start_mandos_communication(const char *ip, uint16_t port,
440
356
AvahiIfIndex if_index,
441
357
mandos_context *mc){
442
358
int ret, tcp_sd;
443
union { struct sockaddr in; struct sockaddr_in6 in6; } to;
359
struct sockaddr_in6 to;
444
360
char *buffer = NULL;
445
361
char *decrypted_buffer;
446
362
size_t buffer_length = 0;
447
363
size_t buffer_capacity = 0;
448
364
ssize_t decrypted_buffer_size;
449
size_t written;
365
size_t written = 0;
450
366
int retval = 0;
451
367
char interface[IF_NAMESIZE];
452
368
gnutls_session_t session;
453
454
ret = init_gnutls_session (mc, &session);
455
if (ret != 0){
456
return -1;
457
}
369
gnutls_dh_params_t dh_params;
458
370
459
371
if(debug){
460
fprintf(stderr, "Setting up a tcp connection to %s, port %" PRIu16
461
"\n", ip, port);
372
fprintf(stderr, "Setting up a tcp connection to %s, port %d\n",
373
ip, port);
462
374
}
463
375
464
376
tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
475
387
fprintf(stderr, "Binding to interface %s\n", interface);
476
388
}
477
389
478
memset(&to, 0, sizeof(to)); /* Spurious warning */
479
to.in6.sin6_family = AF_INET6;
480
/* It would be nice to have a way to detect if we were passed an
481
IPv4 address here. Now we assume an IPv6 address. */
482
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);
483
393
if (ret < 0 ){
484
394
perror("inet_pton");
485
395
return -1;
488
398
fprintf(stderr, "Bad address: %s\n", ip);
489
399
return -1;
490
400
}
491
to.in6.sin6_port = htons(port); /* Spurious warning */
401
to.sin6_port = htons(port); /* Spurious warning */
492
402
493
to.in6.sin6_scope_id = (uint32_t)if_index;
403
to.sin6_scope_id = (uint32_t)if_index;
494
404
495
405
if(debug){
496
fprintf(stderr, "Connection to: %s, port %" PRIu16 "\n", ip,
497
port);
406
fprintf(stderr, "Connection to: %s, port %d\n", ip, port);
498
407
char addrstr[INET6_ADDRSTRLEN] = "";
499
if(inet_ntop(to.in6.sin6_family, &(to.in6.sin6_addr), addrstr,
408
if(inet_ntop(to.sin6_family, &(to.sin6_addr), addrstr,
500
409
sizeof(addrstr)) == NULL){
501
410
perror("inet_ntop");
502
411
} else {
506
415
}
507
416
}
508
417
509
ret = connect(tcp_sd, &to.in, sizeof(to));
418
ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
510
419
if (ret < 0){
511
420
perror("connect");
512
421
return -1;
513
422
}
514
515
const char *out = mandos_protocol_version;
516
written = 0;
517
while (true){
518
size_t out_size = strlen(out);
519
ret = TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
520
out_size - written));
521
if (ret == -1){
522
perror("write");
523
retval = -1;
524
goto mandos_end;
525
}
526
written += (size_t)ret;
527
if(written < out_size){
528
continue;
529
} else {
530
if (out == mandos_protocol_version){
531
written = 0;
532
out = "\r\n";
533
} else {
534
break;
535
}
536
}
423
424
ret = initgnutls (mc, &session, &dh_params);
425
if (ret != 0){
426
retval = -1;
427
return -1;
537
428
}
538
429
430
gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) tcp_sd);
431
539
432
if(debug){
540
433
fprintf(stderr, "Establishing TLS session with %s\n", ip);
541
434
}
542
435
543
gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) tcp_sd);
544
545
do{
546
ret = gnutls_handshake (session);
547
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
436
ret = gnutls_handshake (session);
548
437
549
438
if (ret != GNUTLS_E_SUCCESS){
550
439
if(debug){
551
fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
440
fprintf(stderr, "\n*** Handshake failed ***\n");
552
441
gnutls_perror (ret);
553
442
}
554
443
retval = -1;
555
goto mandos_end;
444
goto exit;
556
445
}
557
446
558
/* Read OpenPGP packet that contains the wanted password */
447
//Retrieve OpenPGP packet that contains the wanted password
559
448
560
449
if(debug){
561
450
fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
563
452
}
564
453
565
454
while(true){
566
buffer_capacity = adjustbuffer(&buffer, buffer_length,
567
buffer_capacity);
568
if (buffer_capacity == 0){
569
perror("adjustbuffer");
570
retval = -1;
571
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;
572
462
}
573
463
574
464
ret = gnutls_record_recv(session, buffer+buffer_length,
582
472
case GNUTLS_E_AGAIN:
583
473
break;
584
474
case GNUTLS_E_REHANDSHAKE:
585
do{
586
ret = gnutls_handshake (session);
587
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
475
ret = gnutls_handshake (session);
588
476
if (ret < 0){
589
fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
477
fprintf(stderr, "\n*** Handshake failed ***\n");
590
478
gnutls_perror (ret);
591
479
retval = -1;
592
goto mandos_end;
480
goto exit;
593
481
}
594
482
break;
595
483
default:
596
484
fprintf(stderr, "Unknown error while reading data from"
597
" encrypted session with Mandos server\n");
485
" encrypted session with mandos server\n");
598
486
retval = -1;
599
487
gnutls_bye (session, GNUTLS_SHUT_RDWR);
600
goto mandos_end;
488
goto exit;
601
489
}
602
490
} else {
603
491
buffer_length += (size_t) ret;
604
492
}
605
493
}
606
494
607
if(debug){
608
fprintf(stderr, "Closing TLS session\n");
609
}
610
611
gnutls_bye (session, GNUTLS_SHUT_RDWR);
612
613
495
if (buffer_length > 0){
614
496
decrypted_buffer_size = pgp_packet_decrypt(buffer,
615
497
buffer_length,
616
498
&decrypted_buffer,
617
499
keydir);
618
500
if (decrypted_buffer_size >= 0){
619
written = 0;
620
501
while(written < (size_t) decrypted_buffer_size){
621
502
ret = (int)fwrite (decrypted_buffer + written, 1,
622
503
(size_t)decrypted_buffer_size - written,
636
517
retval = -1;
637
518
}
638
519
}
639
640
/* Shutdown procedure */
641
642
mandos_end:
520
521
//shutdown procedure
522
523
if(debug){
524
fprintf(stderr, "Closing TLS session\n");
525
}
526
643
527
free(buffer);
528
gnutls_bye (session, GNUTLS_SHUT_RDWR);
529
exit:
644
530
close(tcp_sd);
645
531
gnutls_deinit (session);
532
gnutls_certificate_free_credentials (mc->cred);
533
gnutls_global_deinit ();
646
534
return retval;
647
535
}
648
536
649
static void resolve_callback(AvahiSServiceResolver *r,
650
AvahiIfIndex interface,
651
AVAHI_GCC_UNUSED AvahiProtocol protocol,
652
AvahiResolverEvent event,
653
const char *name,
654
const char *type,
655
const char *domain,
656
const char *host_name,
657
const AvahiAddress *address,
658
uint16_t port,
659
AVAHI_GCC_UNUSED AvahiStringList *txt,
660
AVAHI_GCC_UNUSED AvahiLookupResultFlags
661
flags,
662
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) {
663
550
mandos_context *mc = userdata;
664
551
assert(r); /* Spurious warning */
665
552
669
556
switch (event) {
670
557
default:
671
558
case AVAHI_RESOLVER_FAILURE:
672
fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
673
" 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,
674
561
avahi_strerror(avahi_server_errno(mc->server)));
675
562
break;
676
563
679
566
char ip[AVAHI_ADDRESS_STR_MAX];
680
567
avahi_address_snprint(ip, sizeof(ip), address);
681
568
if(debug){
682
fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %"
683
PRIu16 ") on port %d\n", name, host_name, ip,
684
interface, port);
569
fprintf(stderr, "Mandos server \"%s\" found on %s (%s) on"
570
" port %d\n", name, host_name, ip, port);
685
571
}
686
572
int ret = start_mandos_communication(ip, port, interface, mc);
687
573
if (ret == 0){
688
avahi_simple_poll_quit(mc->simple_poll);
574
exit(EXIT_SUCCESS);
689
575
}
690
576
}
691
577
}
699
585
const char *name,
700
586
const char *type,
701
587
const char *domain,
702
AVAHI_GCC_UNUSED AvahiLookupResultFlags
703
flags,
588
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
704
589
void* userdata) {
705
590
mandos_context *mc = userdata;
706
591
assert(b); /* Spurious warning */
712
597
default:
713
598
case AVAHI_BROWSER_FAILURE:
714
599
715
fprintf(stderr, "(Avahi browser) %s\n",
600
fprintf(stderr, "(Browser) %s\n",
716
601
avahi_strerror(avahi_server_errno(mc->server)));
717
602
avahi_simple_poll_quit(mc->simple_poll);
718
603
return;
719
604
720
605
case AVAHI_BROWSER_NEW:
721
/* We ignore the returned Avahi resolver object. In the callback
722
function we free it. If the Avahi server is terminated before
723
the callback function is called the Avahi server will free the
724
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. */
725
610
726
if (!(avahi_s_service_resolver_new(mc->server, interface,
727
protocol, name, type, domain,
611
if (!(avahi_s_service_resolver_new(mc->server, interface, protocol, name,
612
type, domain,
728
613
AVAHI_PROTO_INET6, 0,
729
614
resolve_callback, mc)))
730
fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
731
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)));
732
617
break;
733
618
734
619
case AVAHI_BROWSER_REMOVE:
736
621
737
622
case AVAHI_BROWSER_ALL_FOR_NOW:
738
623
case AVAHI_BROWSER_CACHE_EXHAUSTED:
739
if(debug){
740
fprintf(stderr, "No Mandos server found, still searching...\n");
741
}
742
624
break;
743
625
}
744
626
}
745
627
746
628
/* Combines file name and path and returns the malloced new
747
629
string. some sane checks could/should be added */
748
static char *combinepath(const char *first, const char *second){
749
char *tmp;
750
int ret = asprintf(&tmp, "%s/%s", first, second);
751
if(ret < 0){
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){
752
635
return NULL;
753
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';
754
645
return tmp;
755
646
}
756
647
757
648
758
int main(int argc, char *argv[]){
649
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
650
AvahiServerConfig config;
759
651
AvahiSServiceBrowser *sb = NULL;
760
652
int error;
761
653
int ret;
762
int exitcode = EXIT_SUCCESS;
654
int debug_int;
655
int returncode = EXIT_SUCCESS;
763
656
const char *interface = "eth0";
764
657
struct ifreq network;
765
658
int sd;
766
uid_t uid;
767
gid_t gid;
768
659
char *connect_to = NULL;
769
660
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
770
char *pubkeyfilename = NULL;
771
char *seckeyfilename = NULL;
772
const char *pubkeyname = "pubkey.txt";
773
const char *seckeyname = "seckey.txt";
774
661
mandos_context mc = { .simple_poll = NULL, .server = NULL,
775
662
.dh_bits = 1024, .priority = "SECURE256"};
776
bool gnutls_initalized = false;
777
778
{
779
struct argp_option options[] = {
780
{ .name = "debug", .key = 128,
781
.doc = "Debug mode", .group = 3 },
782
{ .name = "connect", .key = 'c',
783
.arg = "IP",
784
.doc = "Connect directly to a sepcified mandos server",
785
.group = 1 },
786
{ .name = "interface", .key = 'i',
787
.arg = "INTERFACE",
788
.doc = "Interface that Avahi will conntect through",
789
.group = 1 },
790
{ .name = "keydir", .key = 'd',
791
.arg = "KEYDIR",
792
.doc = "Directory where the openpgp keyring is",
793
.group = 1 },
794
{ .name = "seckey", .key = 's',
795
.arg = "SECKEY",
796
.doc = "Secret openpgp key for gnutls authentication",
797
.group = 1 },
798
{ .name = "pubkey", .key = 'p',
799
.arg = "PUBKEY",
800
.doc = "Public openpgp key for gnutls authentication",
801
.group = 2 },
802
{ .name = "dh-bits", .key = 129,
803
.arg = "BITS",
804
.doc = "dh-bits to use in gnutls communication",
805
.group = 2 },
806
{ .name = "priority", .key = 130,
807
.arg = "PRIORITY",
808
.doc = "GNUTLS priority", .group = 1 },
809
{ .name = NULL }
810
};
811
812
813
error_t parse_opt (int key, char *arg,
814
struct argp_state *state) {
815
/* Get the INPUT argument from `argp_parse', which we know is
816
a pointer to our plugin list pointer. */
817
switch (key) {
818
case 128:
819
debug = true;
820
break;
821
case 'c':
822
connect_to = arg;
823
break;
824
case 'i':
825
interface = arg;
826
break;
827
case 'd':
828
keydir = arg;
829
break;
830
case 's':
831
seckeyname = arg;
832
break;
833
case 'p':
834
pubkeyname = arg;
835
break;
836
case 129:
837
errno = 0;
838
mc.dh_bits = (unsigned int) strtol(arg, NULL, 10);
839
if (errno){
840
perror("strtol");
841
exit(EXIT_FAILURE);
842
}
843
break;
844
case 130:
845
mc.priority = arg;
846
break;
847
case ARGP_KEY_ARG:
848
argp_usage (state);
849
case ARGP_KEY_END:
850
break;
851
default:
852
return ARGP_ERR_UNKNOWN;
853
}
854
return 0;
855
}
856
857
struct argp argp = { .options = options, .parser = parse_opt,
858
.args_doc = "",
859
.doc = "Mandos client -- Get and decrypt"
860
" passwords from mandos server" };
861
ret = argp_parse (&argp, argc, argv, 0, 0, NULL);
862
if (ret == ARGP_ERR_UNKNOWN){
863
fprintf(stderr, "Unknown error while parsing arguments\n");
864
exitcode = EXIT_FAILURE;
865
goto end;
866
}
867
}
868
869
pubkeyfilename = combinepath(keydir, pubkeyname);
870
if (pubkeyfilename == NULL){
871
perror("combinepath");
872
exitcode = EXIT_FAILURE;
873
goto end;
874
}
875
876
seckeyfilename = combinepath(keydir, seckeyname);
877
if (seckeyfilename == NULL){
878
perror("combinepath");
879
exitcode = EXIT_FAILURE;
880
goto end;
881
}
882
883
ret = init_gnutls_global(&mc, pubkeyfilename, seckeyfilename);
884
if (ret == -1){
885
fprintf(stderr, "init_gnutls_global failed\n");
886
exitcode = EXIT_FAILURE;
887
goto end;
888
} else {
889
gnutls_initalized = true;
890
}
891
892
/* If the interface is down, bring it up */
893
{
894
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
895
if(sd < 0) {
896
perror("socket");
897
exitcode = EXIT_FAILURE;
898
goto end;
899
}
900
strcpy(network.ifr_name, interface); /* Spurious warning */
901
ret = ioctl(sd, SIOCGIFFLAGS, &network);
902
if(ret == -1){
903
perror("ioctl SIOCGIFFLAGS");
904
exitcode = EXIT_FAILURE;
905
goto end;
906
}
907
if((network.ifr_flags & IFF_UP) == 0){
908
network.ifr_flags |= IFF_UP;
909
ret = ioctl(sd, SIOCSIFFLAGS, &network);
910
if(ret == -1){
911
perror("ioctl SIOCSIFFLAGS");
912
exitcode = EXIT_FAILURE;
913
goto end;
914
}
915
}
916
close(sd);
917
}
918
919
uid = getuid();
920
gid = getgid();
921
922
ret = setuid(uid);
923
if (ret == -1){
924
perror("setuid");
925
}
926
927
setgid(gid);
928
if (ret == -1){
929
perror("setgid");
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;
930
732
}
931
733
932
734
if_index = (AvahiIfIndex) if_nametoindex(interface);
941
743
char *address = strrchr(connect_to, ':');
942
744
if(address == NULL){
943
745
fprintf(stderr, "No colon in address\n");
944
exitcode = EXIT_FAILURE;
945
goto end;
746
exit(EXIT_FAILURE);
946
747
}
947
748
errno = 0;
948
749
uint16_t port = (uint16_t) strtol(address+1, NULL, 10);
949
750
if(errno){
950
751
perror("Bad port number");
951
exitcode = EXIT_FAILURE;
952
goto end;
752
exit(EXIT_FAILURE);
953
753
}
954
754
*address = '\0';
955
755
address = connect_to;
956
756
ret = start_mandos_communication(address, port, if_index, &mc);
957
757
if(ret < 0){
958
exitcode = EXIT_FAILURE;
758
exit(EXIT_FAILURE);
959
759
} else {
960
exitcode = EXIT_SUCCESS;
961
}
962
goto end;
963
}
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);
964
788
965
789
if (not debug){
966
790
avahi_set_log_function(empty_log);
967
791
}
968
792
969
/* Initialize the pseudo-RNG for Avahi */
793
/* Initialize the psuedo-RNG */
970
794
srand((unsigned int) time(NULL));
971
972
/* Allocate main Avahi loop object */
973
mc.simple_poll = avahi_simple_poll_new();
974
if (mc.simple_poll == NULL) {
975
fprintf(stderr, "Avahi: Failed to create simple poll"
976
" object.\n");
977
exitcode = EXIT_FAILURE;
978
goto end;
979
}
980
981
{
982
AvahiServerConfig config;
983
/* Do not publish any local Zeroconf records */
984
avahi_server_config_init(&config);
985
config.publish_hinfo = 0;
986
config.publish_addresses = 0;
987
config.publish_workstation = 0;
988
config.publish_domain = 0;
989
990
/* Allocate a new server */
991
mc.server = avahi_server_new(avahi_simple_poll_get
992
(mc.simple_poll), &config, NULL,
993
NULL, &error);
994
995
/* Free the Avahi configuration data */
996
avahi_server_config_free(&config);
997
}
998
999
/* Check if creating the Avahi server object succeeded */
1000
if (mc.server == NULL) {
1001
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",
1002
820
avahi_strerror(error));
1003
exitcode = EXIT_FAILURE;
1004
goto end;
821
returncode = EXIT_FAILURE;
822
goto exit;
1005
823
}
1006
824
1007
/* Create the Avahi service browser */
825
/* Create the service browser */
1008
826
sb = avahi_s_service_browser_new(mc.server, if_index,
1009
827
AVAHI_PROTO_INET6,
1010
828
"_mandos._tcp", NULL, 0,
1011
829
browse_callback, &mc);
1012
if (sb == NULL) {
830
if (!sb) {
1013
831
fprintf(stderr, "Failed to create service browser: %s\n",
1014
832
avahi_strerror(avahi_server_errno(mc.server)));
1015
exitcode = EXIT_FAILURE;
1016
goto end;
833
returncode = EXIT_FAILURE;
834
goto exit;
1017
835
}
1018
836
1019
837
/* Run the main loop */
1020
838
1021
839
if (debug){
1022
fprintf(stderr, "Starting Avahi loop search\n");
840
fprintf(stderr, "Starting avahi loop search\n");
1023
841
}
1024
842
1025
843
avahi_simple_poll_loop(mc.simple_poll);
1026
844
1027
end:
845
exit:
1028
846
1029
847
if (debug){
1030
848
fprintf(stderr, "%s exiting\n", argv[0]);
1031
849
}
1032
850
1033
851
/* Cleanup things */
1034
if (sb != NULL)
852
if (sb)
1035
853
avahi_s_service_browser_free(sb);
1036
854
1037
if (mc.server != NULL)
855
if (mc.server)
1038
856
avahi_server_free(mc.server);
1039
857
1040
if (mc.simple_poll != NULL)
858
if (mc.simple_poll)
1041
859
avahi_simple_poll_free(mc.simple_poll);
1042
free(pubkeyfilename);
1043
free(seckeyfilename);
1044
1045
if (gnutls_initalized){
1046
gnutls_certificate_free_credentials(mc.cred);
1047
gnutls_global_deinit ();
1048
}
860
free(pubkeyfile);
861
free(seckeyfile);
1049
862
1050
return exitcode;
863
return returncode;
1051
864
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0