To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to plugins.d/mandos-client.c
- browse files at revision 238
- compare with another revision
- download diff
- download tarball
- view history from revision 238
- Committer: Teddy Hogeborn
- Date: 2008-12-10 01:26:02 UTC
- mfrom: (237.1.2 mandos)
- Revision ID: teddy@fukt.bsnet.se-20081210012602-vhz3h75xkj24t340
First version of a somewhat complete D-Bus server interface. Also
change user/group name to "_mandos".
* debian/mandos.postinst: Rename old "mandos" user and group to
"_mandos"; create "_mandos" user and group
if none exist.
* debian/mandos-client.postinst: - '' -
* initramfs-tools-hook: Try "_mandos" before "mandos" as user and
group name.
* mandos (_datetime_to_dbus_struct): New; was previously local.
(Client.started): Renamed to "last_started". All users changed.
(Client.started): New; boolean.
(Client.dbus_object_path): New.
(Client.check_command): Renamed to "checker_command". All users
changed.
(Client.__init__): Set and use "self.dbus_object_path". Set
"self.started".
(Client.start): Update "self.started". Emit "self.PropertyChanged"
signals for both "started" and "last_started".
(Client.stop): Update "self.started". Emit "self.PropertyChanged"
signal for "started".
(Client.checker_callback): Take additional "command" argument. All
callers changed. Emit
"self.PropertyChanged" signal.
(Client.bump_timeout): Emit "self.PropertyChanged" signal for
"last_checked_ok".
(Client.start_checker): Emit "self.PropertyChanged" signal for
"checker_running".
(Client.stop_checker): Emit "self.PropertyChanged" signal for
"checker_running".
(Client.still_valid): Bug fix: use "getattr(self, started, False)"
instead of "self.started" in case this client
object is so new that the "started" attribute
has not been created yet.
(Client.IntervalChanged, Client.CheckerIsRunning, Client.GetChecker,
Client.GetCreated, Client.GetFingerprint, Client.GetHost,
Client.GetInterval, Client.GetName, Client.GetStarted,
Client.GetTimeout, Client.StateChanged, Client.TimeoutChanged):
Removed; all callers changed.
(Client.CheckerCompleted): Add "condition" and "command" arguments.
All callers changed.
(Client.GetAllProperties, Client.PropertyChanged): New.
(Client.StillValid): Renamed to "IsStillValid".
(Client.StartChecker): Changed to its own function to avoid the
return value from "Client.start_checker()".
(Client.Stop): Changed to its own function to avoid the return value
from "Client.stop()".
(main): Try "_mandos" before "mandos" as user and group name.
Removed inner function "remove_from_clients". New inner
class "MandosServer".
change user/group name to "_mandos".
* debian/mandos.postinst: Rename old "mandos" user and group to
"_mandos"; create "_mandos" user and group
if none exist.
* debian/mandos-client.postinst: - '' -
* initramfs-tools-hook: Try "_mandos" before "mandos" as user and
group name.
* mandos (_datetime_to_dbus_struct): New; was previously local.
(Client.started): Renamed to "last_started". All users changed.
(Client.started): New; boolean.
(Client.dbus_object_path): New.
(Client.check_command): Renamed to "checker_command". All users
changed.
(Client.__init__): Set and use "self.dbus_object_path". Set
"self.started".
(Client.start): Update "self.started". Emit "self.PropertyChanged"
signals for both "started" and "last_started".
(Client.stop): Update "self.started". Emit "self.PropertyChanged"
signal for "started".
(Client.checker_callback): Take additional "command" argument. All
callers changed. Emit
"self.PropertyChanged" signal.
(Client.bump_timeout): Emit "self.PropertyChanged" signal for
"last_checked_ok".
(Client.start_checker): Emit "self.PropertyChanged" signal for
"checker_running".
(Client.stop_checker): Emit "self.PropertyChanged" signal for
"checker_running".
(Client.still_valid): Bug fix: use "getattr(self, started, False)"
instead of "self.started" in case this client
object is so new that the "started" attribute
has not been created yet.
(Client.IntervalChanged, Client.CheckerIsRunning, Client.GetChecker,
Client.GetCreated, Client.GetFingerprint, Client.GetHost,
Client.GetInterval, Client.GetName, Client.GetStarted,
Client.GetTimeout, Client.StateChanged, Client.TimeoutChanged):
Removed; all callers changed.
(Client.CheckerCompleted): Add "condition" and "command" arguments.
All callers changed.
(Client.GetAllProperties, Client.PropertyChanged): New.
(Client.StillValid): Renamed to "IsStillValid".
(Client.StartChecker): Changed to its own function to avoid the
return value from "Client.start_checker()".
(Client.Stop): Changed to its own function to avoid the return value
from "Client.stop()".
(main): Try "_mandos" before "mandos" as user and group name.
Removed inner function "remove_from_clients". New inner
class "MandosServer".
- files added:
- debian/mandos-client.config
- files removed:
- debian/watch
- files modified:
- INSTALL
added
removed
plugins.d/mandos-client.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 © 2008 Teddy Hogeborn
13
* Copyright © 2008 Björn Påhlsson
14
14
*
15
15
* This program is free software: you can redistribute it and/or
16
16
* modify it under the terms of the GNU General Public License as
36
36
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
37
37
38
38
#include <stdio.h> /* fprintf(), stderr, fwrite(),
39
stdout, ferror(), sscanf(),
40
remove() */
39
stdout, ferror() */
41
40
#include <stdint.h> /* uint16_t, uint32_t */
42
41
#include <stddef.h> /* NULL, size_t, ssize_t */
43
42
#include <stdlib.h> /* free(), EXIT_SUCCESS, EXIT_FAILURE,
44
43
srand() */
45
#include <stdbool.h> /* bool, false, true */
44
#include <stdbool.h> /* bool, true */
46
45
#include <string.h> /* memset(), strcmp(), strlen(),
47
46
strerror(), asprintf(), strcpy() */
48
#include <sys/ioctl.h> /* ioctl */
47
#include <sys/ioctl.h> /* ioctl */
49
48
#include <sys/types.h> /* socket(), inet_pton(), sockaddr,
50
49
sockaddr_in6, PF_INET6,
51
SOCK_STREAM, uid_t, gid_t, open(),
52
opendir(), DIR */
50
SOCK_STREAM, INET6_ADDRSTRLEN,
51
uid_t, gid_t, open(), opendir(), DIR */
53
52
#include <sys/stat.h> /* open() */
54
53
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
55
inet_pton(), connect() */
54
struct in6_addr, inet_pton(),
55
connect() */
56
56
#include <fcntl.h> /* open() */
57
#include <dirent.h> /* opendir(), struct dirent, readdir()
58
*/
59
#include <inttypes.h> /* PRIu16, intmax_t, SCNdMAX */
57
#include <dirent.h> /* opendir(), struct dirent, readdir() */
58
#include <inttypes.h> /* PRIu16 */
60
59
#include <assert.h> /* assert() */
61
60
#include <errno.h> /* perror(), errno */
62
#include <time.h> /* nanosleep(), time() */
61
#include <time.h> /* time() */
63
62
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
64
63
SIOCSIFFLAGS, if_indextoname(),
65
64
if_nametoindex(), IF_NAMESIZE */
66
#include <netinet/in.h> /* IN6_IS_ADDR_LINKLOCAL,
67
INET_ADDRSTRLEN, INET6_ADDRSTRLEN
68
*/
65
#include <netinet/in.h>
69
66
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
70
67
getuid(), getgid(), setuid(),
71
68
setgid() */
72
69
#include <arpa/inet.h> /* inet_pton(), htons */
73
#include <iso646.h> /* not, or, and */
70
#include <iso646.h> /* not, and */
74
71
#include <argp.h> /* struct argp_option, error_t, struct
75
72
argp_state, struct argp,
76
73
argp_parse(), ARGP_KEY_ARG,
77
74
ARGP_KEY_END, ARGP_ERR_UNKNOWN */
78
#ifdef __linux__
79
#include <sys/klog.h> /* klogctl() */
80
#endif
81
75
82
76
/* Avahi */
83
77
/* All Avahi types, constants and functions
96
90
gnutls_*
97
91
init_gnutls_session(),
98
92
GNUTLS_* */
99
#include <gnutls/openpgp.h>
100
/* gnutls_certificate_set_openpgp_key_file(),
93
#include <gnutls/openpgp.h> /* gnutls_certificate_set_openpgp_key_file(),
101
94
GNUTLS_OPENPGP_FMT_BASE64 */
102
95
103
96
/* GPGME */
136
129
*/
137
130
size_t adjustbuffer(char **buffer, size_t buffer_length,
138
131
size_t buffer_capacity){
139
if(buffer_length + BUFFER_SIZE > buffer_capacity){
132
if (buffer_length + BUFFER_SIZE > buffer_capacity){
140
133
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
141
if(buffer == NULL){
134
if (buffer == NULL){
142
135
return 0;
143
136
}
144
137
buffer_capacity += BUFFER_SIZE;
157
150
158
151
159
152
/*
160
* Helper function to insert pub and seckey to the engine keyring.
153
* Helper function to insert pub and seckey to the enigne keyring.
161
154
*/
162
155
bool import_key(const char *filename){
163
156
int fd;
164
157
gpgme_data_t pgp_data;
165
158
166
fd = (int)TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
159
fd = TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
167
160
if(fd == -1){
168
161
perror("open");
169
162
return false;
170
163
}
171
164
172
165
rc = gpgme_data_new_from_fd(&pgp_data, fd);
173
if(rc != GPG_ERR_NO_ERROR){
166
if (rc != GPG_ERR_NO_ERROR){
174
167
fprintf(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
175
168
gpgme_strsource(rc), gpgme_strerror(rc));
176
169
return false;
177
170
}
178
171
179
172
rc = gpgme_op_import(mc->ctx, pgp_data);
180
if(rc != GPG_ERR_NO_ERROR){
173
if (rc != GPG_ERR_NO_ERROR){
181
174
fprintf(stderr, "bad gpgme_op_import: %s: %s\n",
182
175
gpgme_strsource(rc), gpgme_strerror(rc));
183
176
return false;
184
177
}
185
178
186
ret = (int)TEMP_FAILURE_RETRY(close(fd));
179
ret = TEMP_FAILURE_RETRY(close(fd));
187
180
if(ret == -1){
188
181
perror("close");
189
182
}
191
184
return true;
192
185
}
193
186
194
if(debug){
187
if (debug){
195
188
fprintf(stderr, "Initialize gpgme\n");
196
189
}
197
190
198
191
/* Init GPGME */
199
192
gpgme_check_version(NULL);
200
193
rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
201
if(rc != GPG_ERR_NO_ERROR){
194
if (rc != GPG_ERR_NO_ERROR){
202
195
fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
203
196
gpgme_strsource(rc), gpgme_strerror(rc));
204
197
return false;
205
198
}
206
199
207
200
/* Set GPGME home directory for the OpenPGP engine only */
208
rc = gpgme_get_engine_info(&engine_info);
209
if(rc != GPG_ERR_NO_ERROR){
201
rc = gpgme_get_engine_info (&engine_info);
202
if (rc != GPG_ERR_NO_ERROR){
210
203
fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
211
204
gpgme_strsource(rc), gpgme_strerror(rc));
212
205
return false;
226
219
227
220
/* Create new GPGME "context" */
228
221
rc = gpgme_new(&(mc->ctx));
229
if(rc != GPG_ERR_NO_ERROR){
222
if (rc != GPG_ERR_NO_ERROR){
230
223
fprintf(stderr, "bad gpgme_new: %s: %s\n",
231
224
gpgme_strsource(rc), gpgme_strerror(rc));
232
225
return false;
233
226
}
234
227
235
if(not import_key(pubkey) or not import_key(seckey)){
228
if (not import_key(pubkey) or not import_key(seckey)){
236
229
return false;
237
230
}
238
231
243
236
* Decrypt OpenPGP data.
244
237
* Returns -1 on error
245
238
*/
246
static ssize_t pgp_packet_decrypt(const mandos_context *mc,
247
const char *cryptotext,
248
size_t crypto_size,
249
char **plaintext){
239
static ssize_t pgp_packet_decrypt (const mandos_context *mc,
240
const char *cryptotext,
241
size_t crypto_size,
242
char **plaintext){
250
243
gpgme_data_t dh_crypto, dh_plain;
251
244
gpgme_error_t rc;
252
245
ssize_t ret;
253
246
size_t plaintext_capacity = 0;
254
247
ssize_t plaintext_length = 0;
255
248
256
if(debug){
249
if (debug){
257
250
fprintf(stderr, "Trying to decrypt OpenPGP data\n");
258
251
}
259
252
260
253
/* Create new GPGME data buffer from memory cryptotext */
261
254
rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
262
255
0);
263
if(rc != GPG_ERR_NO_ERROR){
256
if (rc != GPG_ERR_NO_ERROR){
264
257
fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
265
258
gpgme_strsource(rc), gpgme_strerror(rc));
266
259
return -1;
268
261
269
262
/* Create new empty GPGME data buffer for the plaintext */
270
263
rc = gpgme_data_new(&dh_plain);
271
if(rc != GPG_ERR_NO_ERROR){
264
if (rc != GPG_ERR_NO_ERROR){
272
265
fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
273
266
gpgme_strsource(rc), gpgme_strerror(rc));
274
267
gpgme_data_release(dh_crypto);
278
271
/* Decrypt data from the cryptotext data buffer to the plaintext
279
272
data buffer */
280
273
rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
281
if(rc != GPG_ERR_NO_ERROR){
274
if (rc != GPG_ERR_NO_ERROR){
282
275
fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
283
276
gpgme_strsource(rc), gpgme_strerror(rc));
284
277
plaintext_length = -1;
285
if(debug){
278
if (debug){
286
279
gpgme_decrypt_result_t result;
287
280
result = gpgme_op_decrypt_result(mc->ctx);
288
if(result == NULL){
281
if (result == NULL){
289
282
fprintf(stderr, "gpgme_op_decrypt_result failed\n");
290
283
} else {
291
284
fprintf(stderr, "Unsupported algorithm: %s\n",
318
311
}
319
312
320
313
/* Seek back to the beginning of the GPGME plaintext data buffer */
321
if(gpgme_data_seek(dh_plain, (off_t)0, SEEK_SET) == -1){
314
if (gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET) == -1){
322
315
perror("gpgme_data_seek");
323
316
plaintext_length = -1;
324
317
goto decrypt_end;
329
322
plaintext_capacity = adjustbuffer(plaintext,
330
323
(size_t)plaintext_length,
331
324
plaintext_capacity);
332
if(plaintext_capacity == 0){
325
if (plaintext_capacity == 0){
333
326
perror("adjustbuffer");
334
327
plaintext_length = -1;
335
328
goto decrypt_end;
338
331
ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
339
332
BUFFER_SIZE);
340
333
/* Print the data, if any */
341
if(ret == 0){
334
if (ret == 0){
342
335
/* EOF */
343
336
break;
344
337
}
368
361
return plaintext_length;
369
362
}
370
363
371
static const char * safer_gnutls_strerror(int value){
372
const char *ret = gnutls_strerror(value); /* Spurious warning from
373
-Wunreachable-code */
374
if(ret == NULL)
364
static const char * safer_gnutls_strerror (int value) {
365
const char *ret = gnutls_strerror (value); /* Spurious warning */
366
if (ret == NULL)
375
367
ret = "(unknown)";
376
368
return ret;
377
369
}
392
384
}
393
385
394
386
ret = gnutls_global_init();
395
if(ret != GNUTLS_E_SUCCESS){
396
fprintf(stderr, "GnuTLS global_init: %s\n",
397
safer_gnutls_strerror(ret));
387
if (ret != GNUTLS_E_SUCCESS) {
388
fprintf (stderr, "GnuTLS global_init: %s\n",
389
safer_gnutls_strerror(ret));
398
390
return -1;
399
391
}
400
392
401
if(debug){
393
if (debug){
402
394
/* "Use a log level over 10 to enable all debugging options."
403
395
* - GnuTLS manual
404
396
*/
408
400
409
401
/* OpenPGP credentials */
410
402
gnutls_certificate_allocate_credentials(&mc->cred);
411
if(ret != GNUTLS_E_SUCCESS){
412
fprintf(stderr, "GnuTLS memory error: %s\n", /* Spurious warning
413
from
414
-Wunreachable-code
415
*/
416
safer_gnutls_strerror(ret));
417
gnutls_global_deinit();
403
if (ret != GNUTLS_E_SUCCESS){
404
fprintf (stderr, "GnuTLS memory error: %s\n", /* Spurious
405
warning */
406
safer_gnutls_strerror(ret));
407
gnutls_global_deinit ();
418
408
return -1;
419
409
}
420
410
427
417
ret = gnutls_certificate_set_openpgp_key_file
428
418
(mc->cred, pubkeyfilename, seckeyfilename,
429
419
GNUTLS_OPENPGP_FMT_BASE64);
430
if(ret != GNUTLS_E_SUCCESS){
420
if (ret != GNUTLS_E_SUCCESS) {
431
421
fprintf(stderr,
432
422
"Error[%d] while reading the OpenPGP key pair ('%s',"
433
423
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
438
428
439
429
/* GnuTLS server initialization */
440
430
ret = gnutls_dh_params_init(&mc->dh_params);
441
if(ret != GNUTLS_E_SUCCESS){
442
fprintf(stderr, "Error in GnuTLS DH parameter initialization:"
443
" %s\n", safer_gnutls_strerror(ret));
431
if (ret != GNUTLS_E_SUCCESS) {
432
fprintf (stderr, "Error in GnuTLS DH parameter initialization:"
433
" %s\n", safer_gnutls_strerror(ret));
444
434
goto globalfail;
445
435
}
446
436
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
447
if(ret != GNUTLS_E_SUCCESS){
448
fprintf(stderr, "Error in GnuTLS prime generation: %s\n",
449
safer_gnutls_strerror(ret));
437
if (ret != GNUTLS_E_SUCCESS) {
438
fprintf (stderr, "Error in GnuTLS prime generation: %s\n",
439
safer_gnutls_strerror(ret));
450
440
goto globalfail;
451
441
}
452
442
467
457
int ret;
468
458
/* GnuTLS session creation */
469
459
ret = gnutls_init(session, GNUTLS_SERVER);
470
if(ret != GNUTLS_E_SUCCESS){
460
if (ret != GNUTLS_E_SUCCESS){
471
461
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
472
462
safer_gnutls_strerror(ret));
473
463
}
475
465
{
476
466
const char *err;
477
467
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
478
if(ret != GNUTLS_E_SUCCESS){
468
if (ret != GNUTLS_E_SUCCESS) {
479
469
fprintf(stderr, "Syntax error at: %s\n", err);
480
470
fprintf(stderr, "GnuTLS error: %s\n",
481
471
safer_gnutls_strerror(ret));
482
gnutls_deinit(*session);
472
gnutls_deinit (*session);
483
473
return -1;
484
474
}
485
475
}
486
476
487
477
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
488
478
mc->cred);
489
if(ret != GNUTLS_E_SUCCESS){
479
if (ret != GNUTLS_E_SUCCESS) {
490
480
fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
491
481
safer_gnutls_strerror(ret));
492
gnutls_deinit(*session);
482
gnutls_deinit (*session);
493
483
return -1;
494
484
}
495
485
496
486
/* ignore client certificate if any. */
497
gnutls_certificate_server_set_request(*session,
498
GNUTLS_CERT_IGNORE);
487
gnutls_certificate_server_set_request (*session,
488
GNUTLS_CERT_IGNORE);
499
489
500
gnutls_dh_set_prime_bits(*session, mc->dh_bits);
490
gnutls_dh_set_prime_bits (*session, mc->dh_bits);
501
491
502
492
return 0;
503
493
}
509
499
/* Called when a Mandos server is found */
510
500
static int start_mandos_communication(const char *ip, uint16_t port,
511
501
AvahiIfIndex if_index,
512
mandos_context *mc, int af){
502
mandos_context *mc){
513
503
int ret, tcp_sd;
514
ssize_t sret;
515
union {
516
struct sockaddr_in in;
517
struct sockaddr_in6 in6;
518
} to;
504
union { struct sockaddr in; struct sockaddr_in6 in6; } to;
519
505
char *buffer = NULL;
520
506
char *decrypted_buffer;
521
507
size_t buffer_length = 0;
523
509
ssize_t decrypted_buffer_size;
524
510
size_t written;
525
511
int retval = 0;
512
char interface[IF_NAMESIZE];
526
513
gnutls_session_t session;
527
int pf; /* Protocol family */
528
529
switch(af){
530
case AF_INET6:
531
pf = PF_INET6;
532
break;
533
case AF_INET:
534
pf = PF_INET;
535
break;
536
default:
537
fprintf(stderr, "Bad address family: %d\n", af);
538
return -1;
539
}
540
541
ret = init_gnutls_session(mc, &session);
542
if(ret != 0){
514
515
ret = init_gnutls_session (mc, &session);
516
if (ret != 0){
543
517
return -1;
544
518
}
545
519
546
520
if(debug){
547
fprintf(stderr, "Setting up a TCP connection to %s, port %" PRIu16
521
fprintf(stderr, "Setting up a tcp connection to %s, port %" PRIu16
548
522
"\n", ip, port);
549
523
}
550
524
551
tcp_sd = socket(pf, SOCK_STREAM, 0);
552
if(tcp_sd < 0){
525
tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
526
if(tcp_sd < 0) {
553
527
perror("socket");
554
528
return -1;
555
529
}
556
530
531
if(debug){
532
if(if_indextoname((unsigned int)if_index, interface) == NULL){
533
perror("if_indextoname");
534
return -1;
535
}
536
fprintf(stderr, "Binding to interface %s\n", interface);
537
}
538
557
539
memset(&to, 0, sizeof(to));
558
if(af == AF_INET6){
559
to.in6.sin6_family = (uint16_t)af;
560
ret = inet_pton(af, ip, &to.in6.sin6_addr);
561
} else { /* IPv4 */
562
to.in.sin_family = (sa_family_t)af;
563
ret = inet_pton(af, ip, &to.in.sin_addr);
564
}
565
if(ret < 0 ){
540
to.in6.sin6_family = AF_INET6;
541
/* It would be nice to have a way to detect if we were passed an
542
IPv4 address here. Now we assume an IPv6 address. */
543
ret = inet_pton(AF_INET6, ip, &to.in6.sin6_addr);
544
if (ret < 0 ){
566
545
perror("inet_pton");
567
546
return -1;
568
547
}
570
549
fprintf(stderr, "Bad address: %s\n", ip);
571
550
return -1;
572
551
}
573
if(af == AF_INET6){
574
to.in6.sin6_port = htons(port); /* Spurious warnings from
575
-Wconversion and
576
-Wunreachable-code */
577
578
if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
579
(&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
580
-Wunreachable-code*/
581
if(if_index == AVAHI_IF_UNSPEC){
582
fprintf(stderr, "An IPv6 link-local address is incomplete"
583
" without a network interface\n");
584
return -1;
585
}
586
/* Set the network interface number as scope */
587
to.in6.sin6_scope_id = (uint32_t)if_index;
588
}
589
} else {
590
to.in.sin_port = htons(port); /* Spurious warnings from
591
-Wconversion and
592
-Wunreachable-code */
593
}
552
to.in6.sin6_port = htons(port); /* Spurious warning */
553
554
to.in6.sin6_scope_id = (uint32_t)if_index;
594
555
595
556
if(debug){
596
if(af == AF_INET6 and if_index != AVAHI_IF_UNSPEC){
597
char interface[IF_NAMESIZE];
598
if(if_indextoname((unsigned int)if_index, interface) == NULL){
599
perror("if_indextoname");
600
} else {
601
fprintf(stderr, "Connection to: %s%%%s, port %" PRIu16 "\n",
602
ip, interface, port);
603
}
604
} else {
605
fprintf(stderr, "Connection to: %s, port %" PRIu16 "\n", ip,
606
port);
607
}
608
char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
609
INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
610
const char *pcret;
611
if(af == AF_INET6){
612
pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
613
sizeof(addrstr));
614
} else {
615
pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
616
sizeof(addrstr));
617
}
618
if(pcret == NULL){
557
fprintf(stderr, "Connection to: %s, port %" PRIu16 "\n", ip,
558
port);
559
char addrstr[INET6_ADDRSTRLEN] = "";
560
if(inet_ntop(to.in6.sin6_family, &(to.in6.sin6_addr), addrstr,
561
sizeof(addrstr)) == NULL){
619
562
perror("inet_ntop");
620
563
} else {
621
564
if(strcmp(addrstr, ip) != 0){
624
567
}
625
568
}
626
569
627
if(af == AF_INET6){
628
ret = connect(tcp_sd, &to.in6, sizeof(to));
629
} else {
630
ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
631
}
632
if(ret < 0){
570
ret = connect(tcp_sd, &to.in, sizeof(to));
571
if (ret < 0){
633
572
perror("connect");
634
573
return -1;
635
574
}
636
575
637
576
const char *out = mandos_protocol_version;
638
577
written = 0;
639
while(true){
578
while (true){
640
579
size_t out_size = strlen(out);
641
ret = (int)TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
580
ret = TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
642
581
out_size - written));
643
if(ret == -1){
582
if (ret == -1){
644
583
perror("write");
645
584
retval = -1;
646
585
goto mandos_end;
649
588
if(written < out_size){
650
589
continue;
651
590
} else {
652
if(out == mandos_protocol_version){
591
if (out == mandos_protocol_version){
653
592
written = 0;
654
593
out = "\r\n";
655
594
} else {
662
601
fprintf(stderr, "Establishing TLS session with %s\n", ip);
663
602
}
664
603
665
gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
604
gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) tcp_sd);
666
605
667
606
do{
668
ret = gnutls_handshake(session);
607
ret = gnutls_handshake (session);
669
608
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
670
609
671
if(ret != GNUTLS_E_SUCCESS){
610
if (ret != GNUTLS_E_SUCCESS){
672
611
if(debug){
673
612
fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
674
gnutls_perror(ret);
613
gnutls_perror (ret);
675
614
}
676
615
retval = -1;
677
616
goto mandos_end;
680
619
/* Read OpenPGP packet that contains the wanted password */
681
620
682
621
if(debug){
683
fprintf(stderr, "Retrieving OpenPGP encrypted password from %s\n",
622
fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
684
623
ip);
685
624
}
686
625
687
626
while(true){
688
627
buffer_capacity = adjustbuffer(&buffer, buffer_length,
689
628
buffer_capacity);
690
if(buffer_capacity == 0){
629
if (buffer_capacity == 0){
691
630
perror("adjustbuffer");
692
631
retval = -1;
693
632
goto mandos_end;
694
633
}
695
634
696
sret = gnutls_record_recv(session, buffer+buffer_length,
697
BUFFER_SIZE);
698
if(sret == 0){
635
ret = gnutls_record_recv(session, buffer+buffer_length,
636
BUFFER_SIZE);
637
if (ret == 0){
699
638
break;
700
639
}
701
if(sret < 0){
702
switch(sret){
640
if (ret < 0){
641
switch(ret){
703
642
case GNUTLS_E_INTERRUPTED:
704
643
case GNUTLS_E_AGAIN:
705
644
break;
706
645
case GNUTLS_E_REHANDSHAKE:
707
646
do{
708
ret = gnutls_handshake(session);
647
ret = gnutls_handshake (session);
709
648
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
710
if(ret < 0){
649
if (ret < 0){
711
650
fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
712
gnutls_perror(ret);
651
gnutls_perror (ret);
713
652
retval = -1;
714
653
goto mandos_end;
715
654
}
718
657
fprintf(stderr, "Unknown error while reading data from"
719
658
" encrypted session with Mandos server\n");
720
659
retval = -1;
721
gnutls_bye(session, GNUTLS_SHUT_RDWR);
660
gnutls_bye (session, GNUTLS_SHUT_RDWR);
722
661
goto mandos_end;
723
662
}
724
663
} else {
725
buffer_length += (size_t) sret;
664
buffer_length += (size_t) ret;
726
665
}
727
666
}
728
667
730
669
fprintf(stderr, "Closing TLS session\n");
731
670
}
732
671
733
gnutls_bye(session, GNUTLS_SHUT_RDWR);
672
gnutls_bye (session, GNUTLS_SHUT_RDWR);
734
673
735
if(buffer_length > 0){
674
if (buffer_length > 0){
736
675
decrypted_buffer_size = pgp_packet_decrypt(mc, buffer,
737
676
buffer_length,
738
677
&decrypted_buffer);
739
if(decrypted_buffer_size >= 0){
678
if (decrypted_buffer_size >= 0){
740
679
written = 0;
741
680
while(written < (size_t) decrypted_buffer_size){
742
ret = (int)fwrite(decrypted_buffer + written, 1,
743
(size_t)decrypted_buffer_size - written,
744
stdout);
681
ret = (int)fwrite (decrypted_buffer + written, 1,
682
(size_t)decrypted_buffer_size - written,
683
stdout);
745
684
if(ret == 0 and ferror(stdout)){
746
685
if(debug){
747
686
fprintf(stderr, "Error writing encrypted data: %s\n",
764
703
765
704
mandos_end:
766
705
free(buffer);
767
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
706
ret = TEMP_FAILURE_RETRY(close(tcp_sd));
768
707
if(ret == -1){
769
708
perror("close");
770
709
}
771
gnutls_deinit(session);
710
gnutls_deinit (session);
772
711
return retval;
773
712
}
774
713
775
714
static void resolve_callback(AvahiSServiceResolver *r,
776
715
AvahiIfIndex interface,
777
AvahiProtocol proto,
716
AVAHI_GCC_UNUSED AvahiProtocol protocol,
778
717
AvahiResolverEvent event,
779
718
const char *name,
780
719
const char *type,
785
724
AVAHI_GCC_UNUSED AvahiStringList *txt,
786
725
AVAHI_GCC_UNUSED AvahiLookupResultFlags
787
726
flags,
788
void* userdata){
727
void* userdata) {
789
728
mandos_context *mc = userdata;
790
729
assert(r);
791
730
792
731
/* Called whenever a service has been resolved successfully or
793
732
timed out */
794
733
795
switch(event){
734
switch (event) {
796
735
default:
797
736
case AVAHI_RESOLVER_FAILURE:
798
737
fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
806
745
avahi_address_snprint(ip, sizeof(ip), address);
807
746
if(debug){
808
747
fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %"
809
PRIdMAX ") on port %" PRIu16 "\n", name, host_name,
810
ip, (intmax_t)interface, port);
748
PRIu16 ") on port %d\n", name, host_name, ip,
749
interface, port);
811
750
}
812
int ret = start_mandos_communication(ip, port, interface, mc,
813
avahi_proto_to_af(proto));
814
if(ret == 0){
751
int ret = start_mandos_communication(ip, port, interface, mc);
752
if (ret == 0){
815
753
avahi_simple_poll_quit(mc->simple_poll);
816
754
}
817
755
}
819
757
avahi_s_service_resolver_free(r);
820
758
}
821
759
822
static void browse_callback(AvahiSServiceBrowser *b,
823
AvahiIfIndex interface,
824
AvahiProtocol protocol,
825
AvahiBrowserEvent event,
826
const char *name,
827
const char *type,
828
const char *domain,
829
AVAHI_GCC_UNUSED AvahiLookupResultFlags
830
flags,
831
void* userdata){
760
static void browse_callback( AvahiSServiceBrowser *b,
761
AvahiIfIndex interface,
762
AvahiProtocol protocol,
763
AvahiBrowserEvent event,
764
const char *name,
765
const char *type,
766
const char *domain,
767
AVAHI_GCC_UNUSED AvahiLookupResultFlags
768
flags,
769
void* userdata) {
832
770
mandos_context *mc = userdata;
833
771
assert(b);
834
772
835
773
/* Called whenever a new services becomes available on the LAN or
836
774
is removed from the LAN */
837
775
838
switch(event){
776
switch (event) {
839
777
default:
840
778
case AVAHI_BROWSER_FAILURE:
841
779
850
788
the callback function is called the Avahi server will free the
851
789
resolver for us. */
852
790
853
if(!(avahi_s_service_resolver_new(mc->server, interface,
791
if (!(avahi_s_service_resolver_new(mc->server, interface,
854
792
protocol, name, type, domain,
855
793
AVAHI_PROTO_INET6, 0,
856
794
resolve_callback, mc)))
871
809
}
872
810
873
811
int main(int argc, char *argv[]){
874
AvahiSServiceBrowser *sb = NULL;
875
int error;
876
int ret;
877
intmax_t tmpmax;
878
int numchars;
879
int exitcode = EXIT_SUCCESS;
880
const char *interface = "eth0";
881
struct ifreq network;
882
int sd;
883
uid_t uid;
884
gid_t gid;
885
char *connect_to = NULL;
886
char tempdir[] = "/tmp/mandosXXXXXX";
887
bool tempdir_created = false;
888
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
889
const char *seckey = PATHDIR "/" SECKEY;
890
const char *pubkey = PATHDIR "/" PUBKEY;
891
892
mandos_context mc = { .simple_poll = NULL, .server = NULL,
893
.dh_bits = 1024, .priority = "SECURE256"
894
":!CTYPE-X.509:+CTYPE-OPENPGP" };
895
bool gnutls_initialized = false;
896
bool gpgme_initialized = false;
897
double delay = 2.5;
898
899
{
900
struct argp_option options[] = {
901
{ .name = "debug", .key = 128,
902
.doc = "Debug mode", .group = 3 },
903
{ .name = "connect", .key = 'c',
904
.arg = "ADDRESS:PORT",
905
.doc = "Connect directly to a specific Mandos server",
906
.group = 1 },
907
{ .name = "interface", .key = 'i',
908
.arg = "NAME",
909
.doc = "Network interface that will be used to search for"
910
" Mandos servers",
911
.group = 1 },
912
{ .name = "seckey", .key = 's',
913
.arg = "FILE",
914
.doc = "OpenPGP secret key file base name",
915
.group = 1 },
916
{ .name = "pubkey", .key = 'p',
917
.arg = "FILE",
918
.doc = "OpenPGP public key file base name",
919
.group = 2 },
920
{ .name = "dh-bits", .key = 129,
921
.arg = "BITS",
922
.doc = "Bit length of the prime number used in the"
923
" Diffie-Hellman key exchange",
924
.group = 2 },
925
{ .name = "priority", .key = 130,
926
.arg = "STRING",
927
.doc = "GnuTLS priority string for the TLS handshake",
928
.group = 1 },
929
{ .name = "delay", .key = 131,
930
.arg = "SECONDS",
931
.doc = "Maximum delay to wait for interface startup",
932
.group = 2 },
933
{ .name = NULL }
934
};
935
936
error_t parse_opt(int key, char *arg,
937
struct argp_state *state){
938
switch(key){
939
case 128: /* --debug */
940
debug = true;
941
break;
942
case 'c': /* --connect */
943
connect_to = arg;
944
break;
945
case 'i': /* --interface */
946
interface = arg;
947
break;
948
case 's': /* --seckey */
949
seckey = arg;
950
break;
951
case 'p': /* --pubkey */
952
pubkey = arg;
953
break;
954
case 129: /* --dh-bits */
955
ret = sscanf(arg, "%" SCNdMAX "%n", &tmpmax, &numchars);
956
if(ret < 1 or tmpmax != (typeof(mc.dh_bits))tmpmax
957
or arg[numchars] != '\0'){
958
fprintf(stderr, "Bad number of DH bits\n");
959
exit(EXIT_FAILURE);
960
}
961
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
962
break;
963
case 130: /* --priority */
964
mc.priority = arg;
965
break;
966
case 131: /* --delay */
967
ret = sscanf(arg, "%lf%n", &delay, &numchars);
968
if(ret < 1 or arg[numchars] != '\0'){
969
fprintf(stderr, "Bad delay\n");
970
exit(EXIT_FAILURE);
971
}
972
break;
973
case ARGP_KEY_ARG:
974
argp_usage(state);
975
case ARGP_KEY_END:
976
break;
977
default:
978
return ARGP_ERR_UNKNOWN;
979
}
980
return 0;
981
}
982
983
struct argp argp = { .options = options, .parser = parse_opt,
984
.args_doc = "",
985
.doc = "Mandos client -- Get and decrypt"
986
" passwords from a Mandos server" };
987
ret = argp_parse(&argp, argc, argv, 0, 0, NULL);
988
if(ret == ARGP_ERR_UNKNOWN){
989
fprintf(stderr, "Unknown error while parsing arguments\n");
990
exitcode = EXIT_FAILURE;
991
goto end;
992
}
993
}
994
995
/* If the interface is down, bring it up */
996
if(interface[0] != '\0'){
997
#ifdef __linux__
998
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
999
messages to mess up the prompt */
1000
ret = klogctl(8, NULL, 5);
1001
bool restore_loglevel = true;
1002
if(ret == -1){
1003
restore_loglevel = false;
1004
perror("klogctl");
1005
}
1006
#endif
1007
1008
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1009
if(sd < 0){
1010
perror("socket");
1011
exitcode = EXIT_FAILURE;
1012
#ifdef __linux__
1013
if(restore_loglevel){
1014
ret = klogctl(7, NULL, 0);
1015
if(ret == -1){
1016
perror("klogctl");
1017
}
1018
}
1019
#endif
1020
goto end;
1021
}
1022
strcpy(network.ifr_name, interface);
1023
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1024
if(ret == -1){
1025
perror("ioctl SIOCGIFFLAGS");
1026
#ifdef __linux__
1027
if(restore_loglevel){
1028
ret = klogctl(7, NULL, 0);
1029
if(ret == -1){
1030
perror("klogctl");
1031
}
1032
}
1033
#endif
1034
exitcode = EXIT_FAILURE;
1035
goto end;
1036
}
1037
if((network.ifr_flags & IFF_UP) == 0){
1038
network.ifr_flags |= IFF_UP;
1039
ret = ioctl(sd, SIOCSIFFLAGS, &network);
1040
if(ret == -1){
1041
perror("ioctl SIOCSIFFLAGS");
1042
exitcode = EXIT_FAILURE;
1043
#ifdef __linux__
1044
if(restore_loglevel){
1045
ret = klogctl(7, NULL, 0);
1046
if(ret == -1){
1047
perror("klogctl");
812
AvahiSServiceBrowser *sb = NULL;
813
int error;
814
int ret;
815
int exitcode = EXIT_SUCCESS;
816
const char *interface = "eth0";
817
struct ifreq network;
818
int sd;
819
uid_t uid;
820
gid_t gid;
821
char *connect_to = NULL;
822
char tempdir[] = "/tmp/mandosXXXXXX";
823
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
824
const char *seckey = PATHDIR "/" SECKEY;
825
const char *pubkey = PATHDIR "/" PUBKEY;
826
827
mandos_context mc = { .simple_poll = NULL, .server = NULL,
828
.dh_bits = 1024, .priority = "SECURE256"
829
":!CTYPE-X.509:+CTYPE-OPENPGP" };
830
bool gnutls_initalized = false;
831
bool gpgme_initalized = false;
832
833
{
834
struct argp_option options[] = {
835
{ .name = "debug", .key = 128,
836
.doc = "Debug mode", .group = 3 },
837
{ .name = "connect", .key = 'c',
838
.arg = "ADDRESS:PORT",
839
.doc = "Connect directly to a specific Mandos server",
840
.group = 1 },
841
{ .name = "interface", .key = 'i',
842
.arg = "NAME",
843
.doc = "Interface that will be used to search for Mandos"
844
" servers",
845
.group = 1 },
846
{ .name = "seckey", .key = 's',
847
.arg = "FILE",
848
.doc = "OpenPGP secret key file base name",
849
.group = 1 },
850
{ .name = "pubkey", .key = 'p',
851
.arg = "FILE",
852
.doc = "OpenPGP public key file base name",
853
.group = 2 },
854
{ .name = "dh-bits", .key = 129,
855
.arg = "BITS",
856
.doc = "Bit length of the prime number used in the"
857
" Diffie-Hellman key exchange",
858
.group = 2 },
859
{ .name = "priority", .key = 130,
860
.arg = "STRING",
861
.doc = "GnuTLS priority string for the TLS handshake",
862
.group = 1 },
863
{ .name = NULL }
864
};
865
866
error_t parse_opt (int key, char *arg,
867
struct argp_state *state) {
868
/* Get the INPUT argument from `argp_parse', which we know is
869
a pointer to our plugin list pointer. */
870
switch (key) {
871
case 128: /* --debug */
872
debug = true;
873
break;
874
case 'c': /* --connect */
875
connect_to = arg;
876
break;
877
case 'i': /* --interface */
878
interface = arg;
879
break;
880
case 's': /* --seckey */
881
seckey = arg;
882
break;
883
case 'p': /* --pubkey */
884
pubkey = arg;
885
break;
886
case 129: /* --dh-bits */
887
errno = 0;
888
mc.dh_bits = (unsigned int) strtol(arg, NULL, 10);
889
if (errno){
890
perror("strtol");
891
exit(EXIT_FAILURE);
1048
892
}
893
break;
894
case 130: /* --priority */
895
mc.priority = arg;
896
break;
897
case ARGP_KEY_ARG:
898
argp_usage (state);
899
case ARGP_KEY_END:
900
break;
901
default:
902
return ARGP_ERR_UNKNOWN;
1049
903
}
1050
#endif
904
return 0;
905
}
906
907
struct argp argp = { .options = options, .parser = parse_opt,
908
.args_doc = "",
909
.doc = "Mandos client -- Get and decrypt"
910
" passwords from a Mandos server" };
911
ret = argp_parse (&argp, argc, argv, 0, 0, NULL);
912
if (ret == ARGP_ERR_UNKNOWN){
913
fprintf(stderr, "Unknown error while parsing arguments\n");
914
exitcode = EXIT_FAILURE;
1051
915
goto end;
1052
916
}
1053
917
}
1054
/* sleep checking until interface is running */
1055
for(int i=0; i < delay * 4; i++){
918
919
/* If the interface is down, bring it up */
920
{
921
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
922
if(sd < 0) {
923
perror("socket");
924
exitcode = EXIT_FAILURE;
925
goto end;
926
}
927
strcpy(network.ifr_name, interface);
1056
928
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1057
929
if(ret == -1){
1058
930
perror("ioctl SIOCGIFFLAGS");
1059
} else if(network.ifr_flags & IFF_RUNNING){
1060
break;
1061
}
1062
struct timespec sleeptime = { .tv_nsec = 250000000 };
1063
ret = nanosleep(&sleeptime, NULL);
1064
if(ret == -1 and errno != EINTR){
1065
perror("nanosleep");
1066
}
1067
}
1068
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1069
if(ret == -1){
1070
perror("close");
1071
}
1072
#ifdef __linux__
1073
if(restore_loglevel){
1074
/* Restores kernel loglevel to default */
1075
ret = klogctl(7, NULL, 0);
931
exitcode = EXIT_FAILURE;
932
goto end;
933
}
934
if((network.ifr_flags & IFF_UP) == 0){
935
network.ifr_flags |= IFF_UP;
936
ret = ioctl(sd, SIOCSIFFLAGS, &network);
937
if(ret == -1){
938
perror("ioctl SIOCSIFFLAGS");
939
exitcode = EXIT_FAILURE;
940
goto end;
941
}
942
}
943
ret = TEMP_FAILURE_RETRY(close(sd));
1076
944
if(ret == -1){
1077
perror("klogctl");
945
perror("close");
1078
946
}
1079
947
}
1080
#endif
1081
}
1082
1083
uid = getuid();
1084
gid = getgid();
1085
1086
errno = 0;
1087
setgid(gid);
1088
if(ret == -1){
1089
perror("setgid");
1090
}
1091
1092
ret = setuid(uid);
1093
if(ret == -1){
1094
perror("setuid");
1095
}
1096
1097
ret = init_gnutls_global(&mc, pubkey, seckey);
1098
if(ret == -1){
1099
fprintf(stderr, "init_gnutls_global failed\n");
1100
exitcode = EXIT_FAILURE;
1101
goto end;
1102
} else {
1103
gnutls_initialized = true;
1104
}
1105
1106
if(mkdtemp(tempdir) == NULL){
1107
perror("mkdtemp");
1108
goto end;
1109
}
1110
tempdir_created = true;
1111
1112
if(not init_gpgme(&mc, pubkey, seckey, tempdir)){
1113
fprintf(stderr, "init_gpgme failed\n");
1114
exitcode = EXIT_FAILURE;
1115
goto end;
1116
} else {
1117
gpgme_initialized = true;
1118
}
1119
1120
if(interface[0] != '\0'){
948
949
uid = getuid();
950
gid = getgid();
951
952
ret = setuid(uid);
953
if (ret == -1){
954
perror("setuid");
955
}
956
957
setgid(gid);
958
if (ret == -1){
959
perror("setgid");
960
}
961
962
ret = init_gnutls_global(&mc, pubkey, seckey);
963
if (ret == -1){
964
fprintf(stderr, "init_gnutls_global failed\n");
965
exitcode = EXIT_FAILURE;
966
goto end;
967
} else {
968
gnutls_initalized = true;
969
}
970
971
if(mkdtemp(tempdir) == NULL){
972
perror("mkdtemp");
973
tempdir[0] = '\0';
974
goto end;
975
}
976
977
if(not init_gpgme(&mc, pubkey, seckey, tempdir)){
978
fprintf(stderr, "gpgme_initalized failed\n");
979
exitcode = EXIT_FAILURE;
980
goto end;
981
} else {
982
gpgme_initalized = true;
983
}
984
1121
985
if_index = (AvahiIfIndex) if_nametoindex(interface);
1122
986
if(if_index == 0){
1123
987
fprintf(stderr, "No such interface: \"%s\"\n", interface);
1124
exitcode = EXIT_FAILURE;
1125
goto end;
1126
}
1127
}
1128
1129
if(connect_to != NULL){
1130
/* Connect directly, do not use Zeroconf */
1131
/* (Mainly meant for debugging) */
1132
char *address = strrchr(connect_to, ':');
1133
if(address == NULL){
1134
fprintf(stderr, "No colon in address\n");
1135
exitcode = EXIT_FAILURE;
1136
goto end;
1137
}
1138
uint16_t port;
1139
ret = sscanf(address+1, "%" SCNdMAX "%n", &tmpmax, &numchars);
1140
if(ret < 1 or tmpmax != (uint16_t)tmpmax
1141
or address[numchars+1] != '\0'){
1142
fprintf(stderr, "Bad port number\n");
1143
exitcode = EXIT_FAILURE;
1144
goto end;
1145
}
1146
port = (uint16_t)tmpmax;
1147
*address = '\0';
1148
address = connect_to;
1149
/* Colon in address indicates IPv6 */
1150
int af;
1151
if(strchr(address, ':') != NULL){
1152
af = AF_INET6;
1153
} else {
1154
af = AF_INET;
1155
}
1156
ret = start_mandos_communication(address, port, if_index, &mc,
1157
af);
1158
if(ret < 0){
1159
exitcode = EXIT_FAILURE;
1160
} else {
1161
exitcode = EXIT_SUCCESS;
1162
}
1163
goto end;
1164
}
1165
1166
if(not debug){
1167
avahi_set_log_function(empty_log);
1168
}
1169
1170
/* Initialize the pseudo-RNG for Avahi */
1171
srand((unsigned int) time(NULL));
1172
1173
/* Allocate main Avahi loop object */
1174
mc.simple_poll = avahi_simple_poll_new();
1175
if(mc.simple_poll == NULL){
1176
fprintf(stderr, "Avahi: Failed to create simple poll object.\n");
1177
exitcode = EXIT_FAILURE;
1178
goto end;
1179
}
1180
1181
{
1182
AvahiServerConfig config;
1183
/* Do not publish any local Zeroconf records */
1184
avahi_server_config_init(&config);
1185
config.publish_hinfo = 0;
1186
config.publish_addresses = 0;
1187
config.publish_workstation = 0;
1188
config.publish_domain = 0;
1189
1190
/* Allocate a new server */
1191
mc.server = avahi_server_new(avahi_simple_poll_get
1192
(mc.simple_poll), &config, NULL,
1193
NULL, &error);
1194
1195
/* Free the Avahi configuration data */
1196
avahi_server_config_free(&config);
1197
}
1198
1199
/* Check if creating the Avahi server object succeeded */
1200
if(mc.server == NULL){
1201
fprintf(stderr, "Failed to create Avahi server: %s\n",
1202
avahi_strerror(error));
1203
exitcode = EXIT_FAILURE;
1204
goto end;
1205
}
1206
1207
/* Create the Avahi service browser */
1208
sb = avahi_s_service_browser_new(mc.server, if_index,
1209
AVAHI_PROTO_INET6, "_mandos._tcp",
1210
NULL, 0, browse_callback, &mc);
1211
if(sb == NULL){
1212
fprintf(stderr, "Failed to create service browser: %s\n",
1213
avahi_strerror(avahi_server_errno(mc.server)));
1214
exitcode = EXIT_FAILURE;
1215
goto end;
1216
}
1217
1218
/* Run the main loop */
1219
1220
if(debug){
1221
fprintf(stderr, "Starting Avahi loop search\n");
1222
}
1223
1224
avahi_simple_poll_loop(mc.simple_poll);
1225
988
exit(EXIT_FAILURE);
989
}
990
991
if(connect_to != NULL){
992
/* Connect directly, do not use Zeroconf */
993
/* (Mainly meant for debugging) */
994
char *address = strrchr(connect_to, ':');
995
if(address == NULL){
996
fprintf(stderr, "No colon in address\n");
997
exitcode = EXIT_FAILURE;
998
goto end;
999
}
1000
errno = 0;
1001
uint16_t port = (uint16_t) strtol(address+1, NULL, 10);
1002
if(errno){
1003
perror("Bad port number");
1004
exitcode = EXIT_FAILURE;
1005
goto end;
1006
}
1007
*address = '\0';
1008
address = connect_to;
1009
ret = start_mandos_communication(address, port, if_index, &mc);
1010
if(ret < 0){
1011
exitcode = EXIT_FAILURE;
1012
} else {
1013
exitcode = EXIT_SUCCESS;
1014
}
1015
goto end;
1016
}
1017
1018
if (not debug){
1019
avahi_set_log_function(empty_log);
1020
}
1021
1022
/* Initialize the pseudo-RNG for Avahi */
1023
srand((unsigned int) time(NULL));
1024
1025
/* Allocate main Avahi loop object */
1026
mc.simple_poll = avahi_simple_poll_new();
1027
if (mc.simple_poll == NULL) {
1028
fprintf(stderr, "Avahi: Failed to create simple poll"
1029
" object.\n");
1030
exitcode = EXIT_FAILURE;
1031
goto end;
1032
}
1033
1034
{
1035
AvahiServerConfig config;
1036
/* Do not publish any local Zeroconf records */
1037
avahi_server_config_init(&config);
1038
config.publish_hinfo = 0;
1039
config.publish_addresses = 0;
1040
config.publish_workstation = 0;
1041
config.publish_domain = 0;
1042
1043
/* Allocate a new server */
1044
mc.server = avahi_server_new(avahi_simple_poll_get
1045
(mc.simple_poll), &config, NULL,
1046
NULL, &error);
1047
1048
/* Free the Avahi configuration data */
1049
avahi_server_config_free(&config);
1050
}
1051
1052
/* Check if creating the Avahi server object succeeded */
1053
if (mc.server == NULL) {
1054
fprintf(stderr, "Failed to create Avahi server: %s\n",
1055
avahi_strerror(error));
1056
exitcode = EXIT_FAILURE;
1057
goto end;
1058
}
1059
1060
/* Create the Avahi service browser */
1061
sb = avahi_s_service_browser_new(mc.server, if_index,
1062
AVAHI_PROTO_INET6,
1063
"_mandos._tcp", NULL, 0,
1064
browse_callback, &mc);
1065
if (sb == NULL) {
1066
fprintf(stderr, "Failed to create service browser: %s\n",
1067
avahi_strerror(avahi_server_errno(mc.server)));
1068
exitcode = EXIT_FAILURE;
1069
goto end;
1070
}
1071
1072
/* Run the main loop */
1073
1074
if (debug){
1075
fprintf(stderr, "Starting Avahi loop search\n");
1076
}
1077
1078
avahi_simple_poll_loop(mc.simple_poll);
1079
1226
1080
end:
1227
1228
if(debug){
1229
fprintf(stderr, "%s exiting\n", argv[0]);
1230
}
1231
1232
/* Cleanup things */
1233
if(sb != NULL)
1234
avahi_s_service_browser_free(sb);
1235
1236
if(mc.server != NULL)
1237
avahi_server_free(mc.server);
1238
1239
if(mc.simple_poll != NULL)
1240
avahi_simple_poll_free(mc.simple_poll);
1241
1242
if(gnutls_initialized){
1243
gnutls_certificate_free_credentials(mc.cred);
1244
gnutls_global_deinit();
1245
gnutls_dh_params_deinit(mc.dh_params);
1246
}
1247
1248
if(gpgme_initialized){
1249
gpgme_release(mc.ctx);
1250
}
1251
1252
/* Removes the temp directory used by GPGME */
1253
if(tempdir_created){
1254
DIR *d;
1255
struct dirent *direntry;
1256
d = opendir(tempdir);
1257
if(d == NULL){
1258
if(errno != ENOENT){
1081
1082
if (debug){
1083
fprintf(stderr, "%s exiting\n", argv[0]);
1084
}
1085
1086
/* Cleanup things */
1087
if (sb != NULL)
1088
avahi_s_service_browser_free(sb);
1089
1090
if (mc.server != NULL)
1091
avahi_server_free(mc.server);
1092
1093
if (mc.simple_poll != NULL)
1094
avahi_simple_poll_free(mc.simple_poll);
1095
1096
if (gnutls_initalized){
1097
gnutls_certificate_free_credentials(mc.cred);
1098
gnutls_global_deinit ();
1099
gnutls_dh_params_deinit(mc.dh_params);
1100
}
1101
1102
if(gpgme_initalized){
1103
gpgme_release(mc.ctx);
1104
}
1105
1106
/* Removes the temp directory used by GPGME */
1107
if(tempdir[0] != '\0'){
1108
DIR *d;
1109
struct dirent *direntry;
1110
d = opendir(tempdir);
1111
if(d == NULL){
1259
1112
perror("opendir");
1260
}
1261
} else {
1262
while(true){
1263
direntry = readdir(d);
1264
if(direntry == NULL){
1265
break;
1266
}
1267
/* Skip "." and ".." */
1268
if(direntry->d_name[0] == '.'
1269
and (direntry->d_name[1] == '\0'
1270
or (direntry->d_name[1] == '.'
1271
and direntry->d_name[2] == '\0'))){
1272
continue;
1273
}
1274
char *fullname = NULL;
1275
ret = asprintf(&fullname, "%s/%s", tempdir,
1276
direntry->d_name);
1277
if(ret < 0){
1278
perror("asprintf");
1279
continue;
1280
}
1281
ret = remove(fullname);
1282
if(ret == -1){
1283
fprintf(stderr, "remove(\"%s\"): %s\n", fullname,
1284
strerror(errno));
1285
}
1286
free(fullname);
1287
}
1288
closedir(d);
1289
}
1290
ret = rmdir(tempdir);
1291
if(ret == -1 and errno != ENOENT){
1292
perror("rmdir");
1293
}
1294
}
1295
1296
return exitcode;
1113
} else {
1114
while(true){
1115
direntry = readdir(d);
1116
if(direntry == NULL){
1117
break;
1118
}
1119
if (direntry->d_type == DT_REG){
1120
char *fullname = NULL;
1121
ret = asprintf(&fullname, "%s/%s", tempdir,
1122
direntry->d_name);
1123
if(ret < 0){
1124
perror("asprintf");
1125
continue;
1126
}
1127
ret = unlink(fullname);
1128
if(ret == -1){
1129
fprintf(stderr, "unlink(\"%s\"): %s",
1130
fullname, strerror(errno));
1131
}
1132
free(fullname);
1133
}
1134
}
1135
closedir(d);
1136
}
1137
ret = rmdir(tempdir);
1138
if(ret == -1){
1139
perror("rmdir");
1140
}
1141
}
1142
1143
return exitcode;
1297
1144
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0