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/mandos-client.c
- browse files at revision 24.1.128
- compare with another revision
- download diff
- download tarball
- view history from revision 24.1.128
- Committer: Björn Påhlsson
- Date: 2009-01-19 06:55:59 UTC
- mto: (237.7.1 mandos) (24.1.154 mandos)
- mto: This revision was merged to the branch mainline in revision 250.
- Revision ID: belorn@braxen-20090119065559-vvflkj7ffxtn4ez4
fixed a bugg in mandos-ctl + added remove client option
- files added:
- NEWS
- files removed:
- debian/mandos-client.config
- files modified:
- .bzrignore
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 Teddy Hogeborn & Björn Påhlsson
12
* Copyright © 2008,2009 Teddy Hogeborn
13
* Copyright © 2008,2009 Björn Påhlsson
13
14
*
14
15
* This program is free software: you can redistribute it and/or
15
16
* modify it under the terms of the GNU General Public License as
35
36
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
36
37
37
38
#include <stdio.h> /* fprintf(), stderr, fwrite(),
38
stdout, ferror() */
39
stdout, ferror(), sscanf */
39
40
#include <stdint.h> /* uint16_t, uint32_t */
40
41
#include <stddef.h> /* NULL, size_t, ssize_t */
41
42
#include <stdlib.h> /* free(), EXIT_SUCCESS, EXIT_FAILURE,
47
48
#include <sys/types.h> /* socket(), inet_pton(), sockaddr,
48
49
sockaddr_in6, PF_INET6,
49
50
SOCK_STREAM, INET6_ADDRSTRLEN,
50
uid_t, gid_t, open(), opendir(), DIR */
51
uid_t, gid_t, open(), opendir(),
52
DIR */
51
53
#include <sys/stat.h> /* open() */
52
54
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
53
55
struct in6_addr, inet_pton(),
54
56
connect() */
55
57
#include <fcntl.h> /* open() */
56
#include <dirent.h> /* opendir(), struct dirent, readdir() */
57
#include <inttypes.h> /* PRIu16 */
58
#include <dirent.h> /* opendir(), struct dirent, readdir()
59
*/
60
#include <inttypes.h> /* PRIu16, intmax_t, SCNdMAX */
58
61
#include <assert.h> /* assert() */
59
62
#include <errno.h> /* perror(), errno */
60
#include <time.h> /* time() */
63
#include <time.h> /* time(), nanosleep() */
61
64
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
62
65
SIOCSIFFLAGS, if_indextoname(),
63
66
if_nametoindex(), IF_NAMESIZE */
66
69
getuid(), getgid(), setuid(),
67
70
setgid() */
68
71
#include <arpa/inet.h> /* inet_pton(), htons */
69
#include <iso646.h> /* not, and */
72
#include <iso646.h> /* not, and, or */
70
73
#include <argp.h> /* struct argp_option, error_t, struct
71
74
argp_state, struct argp,
72
75
argp_parse(), ARGP_KEY_ARG,
73
76
ARGP_KEY_END, ARGP_ERR_UNKNOWN */
77
#include <sys/klog.h> /* klogctl() */
74
78
75
79
/* Avahi */
76
80
/* All Avahi types, constants and functions
89
93
gnutls_*
90
94
init_gnutls_session(),
91
95
GNUTLS_* */
92
#include <gnutls/openpgp.h> /* gnutls_certificate_set_openpgp_key_file(),
96
#include <gnutls/openpgp.h>
97
/* gnutls_certificate_set_openpgp_key_file(),
93
98
GNUTLS_OPENPGP_FMT_BASE64 */
94
99
95
100
/* GPGME */
101
106
102
107
#define BUFFER_SIZE 256
103
108
104
/*
105
#define PATHDIR "/conf/conf.d/mandos"
106
*/
107
108
109
#define PATHDIR "/conf/conf.d/mandos"
109
110
#define SECKEY "seckey.txt"
110
111
#define PUBKEY "pubkey.txt"
111
112
112
113
bool debug = false;
113
114
static const char mandos_protocol_version[] = "1";
114
const char *argp_program_version = "mandos-client 1.0";
115
const char *argp_program_version = "mandos-client " VERSION;
115
116
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
116
117
117
118
/* Used for passing in values through the Avahi callback functions */
132
133
*/
133
134
size_t adjustbuffer(char **buffer, size_t buffer_length,
134
135
size_t buffer_capacity){
135
if (buffer_length + BUFFER_SIZE > buffer_capacity){
136
if(buffer_length + BUFFER_SIZE > buffer_capacity){
136
137
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
137
if (buffer == NULL){
138
if(buffer == NULL){
138
139
return 0;
139
140
}
140
141
buffer_capacity += BUFFER_SIZE;
159
160
int fd;
160
161
gpgme_data_t pgp_data;
161
162
162
fd = TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
163
fd = (int)TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
163
164
if(fd == -1){
164
165
perror("open");
165
166
return false;
166
167
}
167
168
168
169
rc = gpgme_data_new_from_fd(&pgp_data, fd);
169
if (rc != GPG_ERR_NO_ERROR){
170
if(rc != GPG_ERR_NO_ERROR){
170
171
fprintf(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
171
172
gpgme_strsource(rc), gpgme_strerror(rc));
172
173
return false;
173
174
}
174
175
175
176
rc = gpgme_op_import(mc->ctx, pgp_data);
176
if (rc != GPG_ERR_NO_ERROR){
177
if(rc != GPG_ERR_NO_ERROR){
177
178
fprintf(stderr, "bad gpgme_op_import: %s: %s\n",
178
179
gpgme_strsource(rc), gpgme_strerror(rc));
179
180
return false;
180
181
}
181
182
182
ret = TEMP_FAILURE_RETRY(close(fd));
183
ret = (int)TEMP_FAILURE_RETRY(close(fd));
183
184
if(ret == -1){
184
185
perror("close");
185
186
}
187
188
return true;
188
189
}
189
190
190
if (debug){
191
if(debug){
191
192
fprintf(stderr, "Initialize gpgme\n");
192
193
}
193
194
194
195
/* Init GPGME */
195
196
gpgme_check_version(NULL);
196
197
rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
197
if (rc != GPG_ERR_NO_ERROR){
198
if(rc != GPG_ERR_NO_ERROR){
198
199
fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
199
200
gpgme_strsource(rc), gpgme_strerror(rc));
200
201
return false;
201
202
}
202
203
203
204
/* Set GPGME home directory for the OpenPGP engine only */
204
rc = gpgme_get_engine_info (&engine_info);
205
if (rc != GPG_ERR_NO_ERROR){
205
rc = gpgme_get_engine_info(&engine_info);
206
if(rc != GPG_ERR_NO_ERROR){
206
207
fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
207
208
gpgme_strsource(rc), gpgme_strerror(rc));
208
209
return false;
222
223
223
224
/* Create new GPGME "context" */
224
225
rc = gpgme_new(&(mc->ctx));
225
if (rc != GPG_ERR_NO_ERROR){
226
if(rc != GPG_ERR_NO_ERROR){
226
227
fprintf(stderr, "bad gpgme_new: %s: %s\n",
227
228
gpgme_strsource(rc), gpgme_strerror(rc));
228
229
return false;
229
230
}
230
231
231
if (not import_key(pubkey) or not import_key(seckey)){
232
if(not import_key(pubkey) or not import_key(seckey)){
232
233
return false;
233
234
}
234
235
239
240
* Decrypt OpenPGP data.
240
241
* Returns -1 on error
241
242
*/
242
static ssize_t pgp_packet_decrypt (const mandos_context *mc,
243
const char *cryptotext,
244
size_t crypto_size,
245
char **plaintext){
243
static ssize_t pgp_packet_decrypt(const mandos_context *mc,
244
const char *cryptotext,
245
size_t crypto_size,
246
char **plaintext){
246
247
gpgme_data_t dh_crypto, dh_plain;
247
248
gpgme_error_t rc;
248
249
ssize_t ret;
249
250
size_t plaintext_capacity = 0;
250
251
ssize_t plaintext_length = 0;
251
252
252
if (debug){
253
if(debug){
253
254
fprintf(stderr, "Trying to decrypt OpenPGP data\n");
254
255
}
255
256
256
257
/* Create new GPGME data buffer from memory cryptotext */
257
258
rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
258
259
0);
259
if (rc != GPG_ERR_NO_ERROR){
260
if(rc != GPG_ERR_NO_ERROR){
260
261
fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
261
262
gpgme_strsource(rc), gpgme_strerror(rc));
262
263
return -1;
264
265
265
266
/* Create new empty GPGME data buffer for the plaintext */
266
267
rc = gpgme_data_new(&dh_plain);
267
if (rc != GPG_ERR_NO_ERROR){
268
if(rc != GPG_ERR_NO_ERROR){
268
269
fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
269
270
gpgme_strsource(rc), gpgme_strerror(rc));
270
271
gpgme_data_release(dh_crypto);
274
275
/* Decrypt data from the cryptotext data buffer to the plaintext
275
276
data buffer */
276
277
rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
277
if (rc != GPG_ERR_NO_ERROR){
278
if(rc != GPG_ERR_NO_ERROR){
278
279
fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
279
280
gpgme_strsource(rc), gpgme_strerror(rc));
280
281
plaintext_length = -1;
281
if (debug){
282
if(debug){
282
283
gpgme_decrypt_result_t result;
283
284
result = gpgme_op_decrypt_result(mc->ctx);
284
if (result == NULL){
285
if(result == NULL){
285
286
fprintf(stderr, "gpgme_op_decrypt_result failed\n");
286
287
} else {
287
288
fprintf(stderr, "Unsupported algorithm: %s\n",
314
315
}
315
316
316
317
/* Seek back to the beginning of the GPGME plaintext data buffer */
317
if (gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET) == -1){
318
if(gpgme_data_seek(dh_plain, (off_t)0, SEEK_SET) == -1){
318
319
perror("gpgme_data_seek");
319
320
plaintext_length = -1;
320
321
goto decrypt_end;
325
326
plaintext_capacity = adjustbuffer(plaintext,
326
327
(size_t)plaintext_length,
327
328
plaintext_capacity);
328
if (plaintext_capacity == 0){
329
if(plaintext_capacity == 0){
329
330
perror("adjustbuffer");
330
331
plaintext_length = -1;
331
332
goto decrypt_end;
334
335
ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
335
336
BUFFER_SIZE);
336
337
/* Print the data, if any */
337
if (ret == 0){
338
if(ret == 0){
338
339
/* EOF */
339
340
break;
340
341
}
364
365
return plaintext_length;
365
366
}
366
367
367
static const char * safer_gnutls_strerror (int value) {
368
const char *ret = gnutls_strerror (value); /* Spurious warning */
369
if (ret == NULL)
368
static const char * safer_gnutls_strerror(int value) {
369
const char *ret = gnutls_strerror(value); /* Spurious warning from
370
-Wunreachable-code */
371
if(ret == NULL)
370
372
ret = "(unknown)";
371
373
return ret;
372
374
}
387
389
}
388
390
389
391
ret = gnutls_global_init();
390
if (ret != GNUTLS_E_SUCCESS) {
391
fprintf (stderr, "GnuTLS global_init: %s\n",
392
safer_gnutls_strerror(ret));
392
if(ret != GNUTLS_E_SUCCESS) {
393
fprintf(stderr, "GnuTLS global_init: %s\n",
394
safer_gnutls_strerror(ret));
393
395
return -1;
394
396
}
395
397
396
if (debug){
398
if(debug){
397
399
/* "Use a log level over 10 to enable all debugging options."
398
400
* - GnuTLS manual
399
401
*/
403
405
404
406
/* OpenPGP credentials */
405
407
gnutls_certificate_allocate_credentials(&mc->cred);
406
if (ret != GNUTLS_E_SUCCESS){
407
fprintf (stderr, "GnuTLS memory error: %s\n", /* Spurious
408
warning */
409
safer_gnutls_strerror(ret));
410
gnutls_global_deinit ();
408
if(ret != GNUTLS_E_SUCCESS){
409
fprintf(stderr, "GnuTLS memory error: %s\n", /* Spurious warning
410
* from
411
* -Wunreachable-code
412
*/
413
safer_gnutls_strerror(ret));
414
gnutls_global_deinit();
411
415
return -1;
412
416
}
413
417
420
424
ret = gnutls_certificate_set_openpgp_key_file
421
425
(mc->cred, pubkeyfilename, seckeyfilename,
422
426
GNUTLS_OPENPGP_FMT_BASE64);
423
if (ret != GNUTLS_E_SUCCESS) {
427
if(ret != GNUTLS_E_SUCCESS) {
424
428
fprintf(stderr,
425
429
"Error[%d] while reading the OpenPGP key pair ('%s',"
426
430
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
431
435
432
436
/* GnuTLS server initialization */
433
437
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));
438
if(ret != GNUTLS_E_SUCCESS) {
439
fprintf(stderr, "Error in GnuTLS DH parameter initialization:"
440
" %s\n", safer_gnutls_strerror(ret));
437
441
goto globalfail;
438
442
}
439
443
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));
444
if(ret != GNUTLS_E_SUCCESS) {
445
fprintf(stderr, "Error in GnuTLS prime generation: %s\n",
446
safer_gnutls_strerror(ret));
443
447
goto globalfail;
444
448
}
445
449
460
464
int ret;
461
465
/* GnuTLS session creation */
462
466
ret = gnutls_init(session, GNUTLS_SERVER);
463
if (ret != GNUTLS_E_SUCCESS){
467
if(ret != GNUTLS_E_SUCCESS){
464
468
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
465
469
safer_gnutls_strerror(ret));
466
470
}
468
472
{
469
473
const char *err;
470
474
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
471
if (ret != GNUTLS_E_SUCCESS) {
475
if(ret != GNUTLS_E_SUCCESS) {
472
476
fprintf(stderr, "Syntax error at: %s\n", err);
473
477
fprintf(stderr, "GnuTLS error: %s\n",
474
478
safer_gnutls_strerror(ret));
475
gnutls_deinit (*session);
479
gnutls_deinit(*session);
476
480
return -1;
477
481
}
478
482
}
479
483
480
484
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
481
485
mc->cred);
482
if (ret != GNUTLS_E_SUCCESS) {
486
if(ret != GNUTLS_E_SUCCESS) {
483
487
fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
484
488
safer_gnutls_strerror(ret));
485
gnutls_deinit (*session);
489
gnutls_deinit(*session);
486
490
return -1;
487
491
}
488
492
489
493
/* ignore client certificate if any. */
490
gnutls_certificate_server_set_request (*session,
491
GNUTLS_CERT_IGNORE);
494
gnutls_certificate_server_set_request(*session,
495
GNUTLS_CERT_IGNORE);
492
496
493
gnutls_dh_set_prime_bits (*session, mc->dh_bits);
497
gnutls_dh_set_prime_bits(*session, mc->dh_bits);
494
498
495
499
return 0;
496
500
}
504
508
AvahiIfIndex if_index,
505
509
mandos_context *mc){
506
510
int ret, tcp_sd;
511
ssize_t sret;
507
512
union { struct sockaddr in; struct sockaddr_in6 in6; } to;
508
513
char *buffer = NULL;
509
514
char *decrypted_buffer;
515
520
char interface[IF_NAMESIZE];
516
521
gnutls_session_t session;
517
522
518
ret = init_gnutls_session (mc, &session);
519
if (ret != 0){
523
ret = init_gnutls_session(mc, &session);
524
if(ret != 0){
520
525
return -1;
521
526
}
522
527
544
549
/* It would be nice to have a way to detect if we were passed an
545
550
IPv4 address here. Now we assume an IPv6 address. */
546
551
ret = inet_pton(AF_INET6, ip, &to.in6.sin6_addr);
547
if (ret < 0 ){
552
if(ret < 0 ){
548
553
perror("inet_pton");
549
554
return -1;
550
555
}
552
557
fprintf(stderr, "Bad address: %s\n", ip);
553
558
return -1;
554
559
}
555
to.in6.sin6_port = htons(port); /* Spurious warning */
560
to.in6.sin6_port = htons(port); /* Spurious warnings from
561
-Wconversion and
562
-Wunreachable-code */
556
563
557
564
to.in6.sin6_scope_id = (uint32_t)if_index;
558
565
571
578
}
572
579
573
580
ret = connect(tcp_sd, &to.in, sizeof(to));
574
if (ret < 0){
581
if(ret < 0){
575
582
perror("connect");
576
583
return -1;
577
584
}
578
585
579
586
const char *out = mandos_protocol_version;
580
587
written = 0;
581
while (true){
588
while(true){
582
589
size_t out_size = strlen(out);
583
ret = TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
590
ret = (int)TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
584
591
out_size - written));
585
if (ret == -1){
592
if(ret == -1){
586
593
perror("write");
587
594
retval = -1;
588
595
goto mandos_end;
591
598
if(written < out_size){
592
599
continue;
593
600
} else {
594
if (out == mandos_protocol_version){
601
if(out == mandos_protocol_version){
595
602
written = 0;
596
603
out = "\r\n";
597
604
} else {
604
611
fprintf(stderr, "Establishing TLS session with %s\n", ip);
605
612
}
606
613
607
gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) tcp_sd);
614
gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
608
615
609
616
do{
610
ret = gnutls_handshake (session);
617
ret = gnutls_handshake(session);
611
618
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
612
619
613
if (ret != GNUTLS_E_SUCCESS){
620
if(ret != GNUTLS_E_SUCCESS){
614
621
if(debug){
615
622
fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
616
gnutls_perror (ret);
623
gnutls_perror(ret);
617
624
}
618
625
retval = -1;
619
626
goto mandos_end;
629
636
while(true){
630
637
buffer_capacity = adjustbuffer(&buffer, buffer_length,
631
638
buffer_capacity);
632
if (buffer_capacity == 0){
639
if(buffer_capacity == 0){
633
640
perror("adjustbuffer");
634
641
retval = -1;
635
642
goto mandos_end;
636
643
}
637
644
638
ret = gnutls_record_recv(session, buffer+buffer_length,
639
BUFFER_SIZE);
640
if (ret == 0){
645
sret = gnutls_record_recv(session, buffer+buffer_length,
646
BUFFER_SIZE);
647
if(sret == 0){
641
648
break;
642
649
}
643
if (ret < 0){
644
switch(ret){
650
if(sret < 0){
651
switch(sret){
645
652
case GNUTLS_E_INTERRUPTED:
646
653
case GNUTLS_E_AGAIN:
647
654
break;
648
655
case GNUTLS_E_REHANDSHAKE:
649
656
do{
650
ret = gnutls_handshake (session);
657
ret = gnutls_handshake(session);
651
658
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
652
if (ret < 0){
659
if(ret < 0){
653
660
fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
654
gnutls_perror (ret);
661
gnutls_perror(ret);
655
662
retval = -1;
656
663
goto mandos_end;
657
664
}
660
667
fprintf(stderr, "Unknown error while reading data from"
661
668
" encrypted session with Mandos server\n");
662
669
retval = -1;
663
gnutls_bye (session, GNUTLS_SHUT_RDWR);
670
gnutls_bye(session, GNUTLS_SHUT_RDWR);
664
671
goto mandos_end;
665
672
}
666
673
} else {
667
buffer_length += (size_t) ret;
674
buffer_length += (size_t) sret;
668
675
}
669
676
}
670
677
672
679
fprintf(stderr, "Closing TLS session\n");
673
680
}
674
681
675
gnutls_bye (session, GNUTLS_SHUT_RDWR);
682
gnutls_bye(session, GNUTLS_SHUT_RDWR);
676
683
677
if (buffer_length > 0){
684
if(buffer_length > 0){
678
685
decrypted_buffer_size = pgp_packet_decrypt(mc, buffer,
679
686
buffer_length,
680
687
&decrypted_buffer);
681
if (decrypted_buffer_size >= 0){
688
if(decrypted_buffer_size >= 0){
682
689
written = 0;
683
690
while(written < (size_t) decrypted_buffer_size){
684
ret = (int)fwrite (decrypted_buffer + written, 1,
685
(size_t)decrypted_buffer_size - written,
686
stdout);
691
ret = (int)fwrite(decrypted_buffer + written, 1,
692
(size_t)decrypted_buffer_size - written,
693
stdout);
687
694
if(ret == 0 and ferror(stdout)){
688
695
if(debug){
689
696
fprintf(stderr, "Error writing encrypted data: %s\n",
706
713
707
714
mandos_end:
708
715
free(buffer);
709
ret = TEMP_FAILURE_RETRY(close(tcp_sd));
716
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
710
717
if(ret == -1){
711
718
perror("close");
712
719
}
713
gnutls_deinit (session);
720
gnutls_deinit(session);
714
721
return retval;
715
722
}
716
723
734
741
/* Called whenever a service has been resolved successfully or
735
742
timed out */
736
743
737
switch (event) {
744
switch(event) {
738
745
default:
739
746
case AVAHI_RESOLVER_FAILURE:
740
747
fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
748
755
avahi_address_snprint(ip, sizeof(ip), address);
749
756
if(debug){
750
757
fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %"
751
PRIu16 ") on port %d\n", name, host_name, ip,
752
interface, port);
758
PRIdMAX ") on port %" PRIu16 "\n", name, host_name,
759
ip, (intmax_t)interface, port);
753
760
}
754
761
int ret = start_mandos_communication(ip, port, interface, mc);
755
if (ret == 0){
762
if(ret == 0){
756
763
avahi_simple_poll_quit(mc->simple_poll);
757
764
}
758
765
}
776
783
/* Called whenever a new services becomes available on the LAN or
777
784
is removed from the LAN */
778
785
779
switch (event) {
786
switch(event) {
780
787
default:
781
788
case AVAHI_BROWSER_FAILURE:
782
789
791
798
the callback function is called the Avahi server will free the
792
799
resolver for us. */
793
800
794
if (!(avahi_s_service_resolver_new(mc->server, interface,
801
if(!(avahi_s_service_resolver_new(mc->server, interface,
795
802
protocol, name, type, domain,
796
803
AVAHI_PROTO_INET6, 0,
797
804
resolve_callback, mc)))
815
822
AvahiSServiceBrowser *sb = NULL;
816
823
int error;
817
824
int ret;
825
intmax_t tmpmax;
826
int numchars;
818
827
int exitcode = EXIT_SUCCESS;
819
828
const char *interface = "eth0";
820
829
struct ifreq network;
832
841
":!CTYPE-X.509:+CTYPE-OPENPGP" };
833
842
bool gnutls_initalized = false;
834
843
bool gpgme_initalized = false;
844
double delay = 2.5;
835
845
836
846
{
837
847
struct argp_option options[] = {
863
873
.arg = "STRING",
864
874
.doc = "GnuTLS priority string for the TLS handshake",
865
875
.group = 1 },
876
{ .name = "delay", .key = 131,
877
.arg = "SECONDS",
878
.doc = "Maximum delay to wait for interface startup",
879
.group = 2 },
866
880
{ .name = NULL }
867
881
};
868
882
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) {
883
error_t parse_opt(int key, char *arg,
884
struct argp_state *state) {
885
switch(key) {
874
886
case 128: /* --debug */
875
887
debug = true;
876
888
break;
887
899
pubkey = arg;
888
900
break;
889
901
case 129: /* --dh-bits */
890
errno = 0;
891
mc.dh_bits = (unsigned int) strtol(arg, NULL, 10);
892
if (errno){
893
perror("strtol");
902
ret = sscanf(arg, "%" SCNdMAX "%n", &tmpmax, &numchars);
903
if(ret < 1 or tmpmax != (typeof(mc.dh_bits))tmpmax
904
or arg[numchars] != '\0'){
905
fprintf(stderr, "Bad number of DH bits\n");
894
906
exit(EXIT_FAILURE);
895
907
}
908
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
896
909
break;
897
910
case 130: /* --priority */
898
911
mc.priority = arg;
899
912
break;
913
case 131: /* --delay */
914
ret = sscanf(arg, "%lf%n", &delay, &numchars);
915
if(ret < 1 or arg[numchars] != '\0'){
916
fprintf(stderr, "Bad delay\n");
917
exit(EXIT_FAILURE);
918
}
919
break;
900
920
case ARGP_KEY_ARG:
901
argp_usage (state);
921
argp_usage(state);
902
922
case ARGP_KEY_END:
903
923
break;
904
924
default:
911
931
.args_doc = "",
912
932
.doc = "Mandos client -- Get and decrypt"
913
933
" passwords from a Mandos server" };
914
ret = argp_parse (&argp, argc, argv, 0, 0, NULL);
915
if (ret == ARGP_ERR_UNKNOWN){
934
ret = argp_parse(&argp, argc, argv, 0, 0, NULL);
935
if(ret == ARGP_ERR_UNKNOWN){
916
936
fprintf(stderr, "Unknown error while parsing arguments\n");
917
937
exitcode = EXIT_FAILURE;
918
938
goto end;
921
941
922
942
/* If the interface is down, bring it up */
923
943
{
944
// Lower kernel loglevel to KERN_NOTICE to avoid
945
// KERN_INFO messages to mess up the prompt
946
ret = klogctl(8, NULL, 5);
947
if(ret == -1){
948
perror("klogctl");
949
}
950
924
951
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
925
952
if(sd < 0) {
926
953
perror("socket");
927
954
exitcode = EXIT_FAILURE;
955
ret = klogctl(7, NULL, 0);
956
if(ret == -1){
957
perror("klogctl");
958
}
928
959
goto end;
929
960
}
930
961
strcpy(network.ifr_name, interface);
931
962
ret = ioctl(sd, SIOCGIFFLAGS, &network);
932
963
if(ret == -1){
933
964
perror("ioctl SIOCGIFFLAGS");
965
ret = klogctl(7, NULL, 0);
966
if(ret == -1){
967
perror("klogctl");
968
}
934
969
exitcode = EXIT_FAILURE;
935
970
goto end;
936
971
}
940
975
if(ret == -1){
941
976
perror("ioctl SIOCSIFFLAGS");
942
977
exitcode = EXIT_FAILURE;
978
ret = klogctl(7, NULL, 0);
979
if(ret == -1){
980
perror("klogctl");
981
}
943
982
goto end;
944
983
}
945
984
}
946
ret = TEMP_FAILURE_RETRY(close(sd));
985
// sleep checking until interface is running
986
for(int i=0; i < delay * 4; i++){
987
ret = ioctl(sd, SIOCGIFFLAGS, &network);
988
if(ret == -1){
989
perror("ioctl SIOCGIFFLAGS");
990
} else if(network.ifr_flags & IFF_RUNNING){
991
break;
992
}
993
struct timespec sleeptime = { .tv_nsec = 250000000 };
994
nanosleep(&sleeptime, NULL);
995
}
996
ret = (int)TEMP_FAILURE_RETRY(close(sd));
947
997
if(ret == -1){
948
998
perror("close");
949
999
}
1000
// Restores kernel loglevel to default
1001
ret = klogctl(7, NULL, 0);
1002
if(ret == -1){
1003
perror("klogctl");
1004
}
950
1005
}
951
1006
952
1007
uid = getuid();
953
1008
gid = getgid();
954
1009
955
1010
ret = setuid(uid);
956
if (ret == -1){
1011
if(ret == -1){
957
1012
perror("setuid");
958
1013
}
959
1014
960
1015
setgid(gid);
961
if (ret == -1){
1016
if(ret == -1){
962
1017
perror("setgid");
963
1018
}
964
1019
965
1020
ret = init_gnutls_global(&mc, pubkey, seckey);
966
if (ret == -1){
1021
if(ret == -1){
967
1022
fprintf(stderr, "init_gnutls_global failed\n");
968
1023
exitcode = EXIT_FAILURE;
969
1024
goto end;
1000
1055
exitcode = EXIT_FAILURE;
1001
1056
goto end;
1002
1057
}
1003
errno = 0;
1004
uint16_t port = (uint16_t) strtol(address+1, NULL, 10);
1005
if(errno){
1006
perror("Bad port number");
1058
uint16_t port;
1059
ret = sscanf(address+1, "%" SCNdMAX "%n", &tmpmax, &numchars);
1060
if(ret < 1 or tmpmax != (uint16_t)tmpmax
1061
or address[numchars+1] != '\0'){
1062
fprintf(stderr, "Bad port number\n");
1007
1063
exitcode = EXIT_FAILURE;
1008
1064
goto end;
1009
1065
}
1066
port = (uint16_t)tmpmax;
1010
1067
*address = '\0';
1011
1068
address = connect_to;
1012
1069
ret = start_mandos_communication(address, port, if_index, &mc);
1018
1075
goto end;
1019
1076
}
1020
1077
1021
if (not debug){
1078
if(not debug){
1022
1079
avahi_set_log_function(empty_log);
1023
1080
}
1024
1081
1027
1084
1028
1085
/* Allocate main Avahi loop object */
1029
1086
mc.simple_poll = avahi_simple_poll_new();
1030
if (mc.simple_poll == NULL) {
1087
if(mc.simple_poll == NULL) {
1031
1088
fprintf(stderr, "Avahi: Failed to create simple poll"
1032
1089
" object.\n");
1033
1090
exitcode = EXIT_FAILURE;
1053
1110
}
1054
1111
1055
1112
/* Check if creating the Avahi server object succeeded */
1056
if (mc.server == NULL) {
1113
if(mc.server == NULL) {
1057
1114
fprintf(stderr, "Failed to create Avahi server: %s\n",
1058
1115
avahi_strerror(error));
1059
1116
exitcode = EXIT_FAILURE;
1065
1122
AVAHI_PROTO_INET6,
1066
1123
"_mandos._tcp", NULL, 0,
1067
1124
browse_callback, &mc);
1068
if (sb == NULL) {
1125
if(sb == NULL) {
1069
1126
fprintf(stderr, "Failed to create service browser: %s\n",
1070
1127
avahi_strerror(avahi_server_errno(mc.server)));
1071
1128
exitcode = EXIT_FAILURE;
1074
1131
1075
1132
/* Run the main loop */
1076
1133
1077
if (debug){
1134
if(debug){
1078
1135
fprintf(stderr, "Starting Avahi loop search\n");
1079
1136
}
1080
1137
1081
1138
avahi_simple_poll_loop(mc.simple_poll);
1082
1139
1083
1140
end:
1084
1141
1085
if (debug){
1142
if(debug){
1086
1143
fprintf(stderr, "%s exiting\n", argv[0]);
1087
1144
}
1088
1145
1089
1146
/* Cleanup things */
1090
if (sb != NULL)
1147
if(sb != NULL)
1091
1148
avahi_s_service_browser_free(sb);
1092
1149
1093
if (mc.server != NULL)
1150
if(mc.server != NULL)
1094
1151
avahi_server_free(mc.server);
1095
1152
1096
if (mc.simple_poll != NULL)
1153
if(mc.simple_poll != NULL)
1097
1154
avahi_simple_poll_free(mc.simple_poll);
1098
1155
1099
if (gnutls_initalized){
1156
if(gnutls_initalized){
1100
1157
gnutls_certificate_free_credentials(mc.cred);
1101
gnutls_global_deinit ();
1158
gnutls_global_deinit();
1102
1159
gnutls_dh_params_deinit(mc.dh_params);
1103
1160
}
1104
1161
1112
1169
struct dirent *direntry;
1113
1170
d = opendir(tempdir);
1114
1171
if(d == NULL){
1115
perror("opendir");
1172
if(errno != ENOENT){
1173
perror("opendir");
1174
}
1116
1175
} else {
1117
1176
while(true){
1118
1177
direntry = readdir(d);
1119
1178
if(direntry == NULL){
1120
1179
break;
1121
1180
}
1122
if (direntry->d_type == DT_REG){
1181
if(direntry->d_type == DT_REG){
1123
1182
char *fullname = NULL;
1124
1183
ret = asprintf(&fullname, "%s/%s", tempdir,
1125
1184
direntry->d_name);
1138
1197
closedir(d);
1139
1198
}
1140
1199
ret = rmdir(tempdir);
1141
if(ret == -1){
1200
if(ret == -1 and errno != ENOENT){
1142
1201
perror("rmdir");
1143
1202
}
1144
1203
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0