64
59
#include <string.h> /* memset */
65
60
#include <arpa/inet.h> /* inet_pton() */
66
61
#include <iso646.h> /* not */
67
#include <net/if.h> /* IF_NAMESIZE */
68
#include <argp.h> /* struct argp_option,
69
struct argp_state, struct argp,
72
64
#include <errno.h> /* perror() */
71
#define CERT_ROOT "/conf/conf.d/cryptkeyreq/"
73
#define CERTFILE CERT_ROOT "openpgp-client.txt"
74
#define KEYFILE CERT_ROOT "openpgp-client-key.txt"
75
75
#define BUFFER_SIZE 256
77
78
bool debug = false;
78
const char *keydir = "/conf/conf.d/mandos";
79
const char *argp_program_version = "mandosclient 0.9";
80
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
81
const char mandos_protocol_version[] = "1";
83
/* Used for passing in values through all the callback functions */
85
AvahiSimplePoll *simple_poll;
81
gnutls_session_t session;
87
82
gnutls_certificate_credentials_t cred;
89
83
gnutls_dh_params_t dh_params;
93
size_t adjustbuffer(char **buffer, size_t buffer_length,
94
size_t buffer_capacity){
95
if (buffer_length + BUFFER_SIZE > buffer_capacity){
96
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
100
buffer_capacity += BUFFER_SIZE;
102
return buffer_capacity;
106
* Decrypt OpenPGP data using keyrings in HOMEDIR.
107
* Returns -1 on error
109
static ssize_t pgp_packet_decrypt (const char *cryptotext,
112
const char *homedir){
87
ssize_t pgp_packet_decrypt (char *packet, size_t packet_size,
88
char **new_packet, const char *homedir){
113
89
gpgme_data_t dh_crypto, dh_plain;
117
size_t plaintext_capacity = 0;
118
ssize_t plaintext_length = 0;
93
ssize_t new_packet_capacity = 0;
94
ssize_t new_packet_length = 0;
119
95
gpgme_engine_info_t engine_info;
122
fprintf(stderr, "Trying to decrypt OpenPGP data\n");
98
fprintf(stderr, "Trying to decrypt OpenPGP packet\n");
126
102
gpgme_check_version(NULL);
127
rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
128
if (rc != GPG_ERR_NO_ERROR){
129
fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
130
gpgme_strsource(rc), gpgme_strerror(rc));
103
gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
134
/* Set GPGME home directory for the OpenPGP engine only */
105
/* Set GPGME home directory */
135
106
rc = gpgme_get_engine_info (&engine_info);
136
107
if (rc != GPG_ERR_NO_ERROR){
137
108
fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
191
/* Delete the GPGME FILE pointer cryptotext data buffer */
192
gpgme_data_release(dh_crypto);
224
194
/* Seek back to the beginning of the GPGME plaintext data buffer */
225
if (gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET) == -1){
226
perror("pgpme_data_seek");
227
plaintext_length = -1;
195
gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET);
233
plaintext_capacity = adjustbuffer(plaintext, (size_t)plaintext_length,
235
if (plaintext_capacity == 0){
236
perror("adjustbuffer");
237
plaintext_length = -1;
199
if (new_packet_length + BUFFER_SIZE > new_packet_capacity){
200
*new_packet = realloc(*new_packet,
201
(unsigned int)new_packet_capacity
203
if (*new_packet == NULL){
207
new_packet_capacity += BUFFER_SIZE;
241
ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
210
ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length,
243
212
/* Print the data, if any */
249
217
perror("gpgme_data_read");
250
plaintext_length = -1;
253
plaintext_length += ret;
220
new_packet_length += ret;
257
fprintf(stderr, "Decrypted password is: ");
258
for(ssize_t i = 0; i < plaintext_length; i++){
259
fprintf(stderr, "%02hhX ", (*plaintext)[i]);
261
fprintf(stderr, "\n");
266
/* Delete the GPGME cryptotext data buffer */
267
gpgme_data_release(dh_crypto);
223
/* FIXME: check characters before printing to screen so to not print
224
terminal control characters */
226
/* fprintf(stderr, "decrypted password is: "); */
227
/* fwrite(*new_packet, 1, new_packet_length, stderr); */
228
/* fprintf(stderr, "\n"); */
269
231
/* Delete the GPGME plaintext data buffer */
270
232
gpgme_data_release(dh_plain);
271
return plaintext_length;
233
return new_packet_length;
274
236
static const char * safer_gnutls_strerror (int value) {
281
/* GnuTLS log function callback */
282
static void debuggnutls(__attribute__((unused)) int level,
284
fprintf(stderr, "GnuTLS: %s", string);
243
void debuggnutls(__attribute__((unused)) int level,
245
fprintf(stderr, "%s", string);
287
static int init_gnutls_global(mandos_context *mc,
288
const char *pubkeyfile,
289
const char *seckeyfile){
248
int initgnutls(encrypted_session *es){
293
253
fprintf(stderr, "Initializing GnuTLS\n");
296
256
if ((ret = gnutls_global_init ())
297
257
!= GNUTLS_E_SUCCESS) {
298
fprintf (stderr, "GnuTLS global_init: %s\n",
299
safer_gnutls_strerror(ret));
258
fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
304
/* "Use a log level over 10 to enable all debugging options."
307
263
gnutls_global_set_log_level(11);
308
264
gnutls_global_set_log_function(debuggnutls);
311
/* OpenPGP credentials */
312
if ((ret = gnutls_certificate_allocate_credentials (&mc->cred))
267
/* openpgp credentials */
268
if ((ret = gnutls_certificate_allocate_credentials (&es->cred))
313
269
!= GNUTLS_E_SUCCESS) {
314
fprintf (stderr, "GnuTLS memory error: %s\n",
270
fprintf (stderr, "memory error: %s\n",
315
271
safer_gnutls_strerror(ret));
320
276
fprintf(stderr, "Attempting to use OpenPGP certificate %s"
321
" and keyfile %s as GnuTLS credentials\n", pubkeyfile,
277
" and keyfile %s as GnuTLS credentials\n", CERTFILE,
325
281
ret = gnutls_certificate_set_openpgp_key_file
326
(mc->cred, pubkeyfile, seckeyfile, GNUTLS_OPENPGP_FMT_BASE64);
282
(es->cred, CERTFILE, KEYFILE, GNUTLS_OPENPGP_FMT_BASE64);
327
283
if (ret != GNUTLS_E_SUCCESS) {
329
"Error[%d] while reading the OpenPGP key pair ('%s',"
330
" '%s')\n", ret, pubkeyfile, seckeyfile);
331
fprintf(stdout, "The GnuTLS error is: %s\n",
285
(stderr, "Error[%d] while reading the OpenPGP key pair ('%s',"
287
ret, CERTFILE, KEYFILE);
288
fprintf(stdout, "The Error is: %s\n",
332
289
safer_gnutls_strerror(ret));
336
/* GnuTLS server initialization */
337
ret = gnutls_dh_params_init(&mc->dh_params);
338
if (ret != GNUTLS_E_SUCCESS) {
339
fprintf (stderr, "Error in GnuTLS DH parameter initialization:"
340
" %s\n", safer_gnutls_strerror(ret));
343
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
344
if (ret != GNUTLS_E_SUCCESS) {
345
fprintf (stderr, "Error in GnuTLS prime generation: %s\n",
346
safer_gnutls_strerror(ret));
350
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
355
static int init_gnutls_session(mandos_context *mc, gnutls_session_t *session){
357
/* GnuTLS session creation */
358
ret = gnutls_init(session, GNUTLS_SERVER);
359
if (ret != GNUTLS_E_SUCCESS){
293
//GnuTLS server initialization
294
if ((ret = gnutls_dh_params_init (&es->dh_params))
295
!= GNUTLS_E_SUCCESS) {
296
fprintf (stderr, "Error in dh parameter initialization: %s\n",
297
safer_gnutls_strerror(ret));
301
if ((ret = gnutls_dh_params_generate2 (es->dh_params, DH_BITS))
302
!= GNUTLS_E_SUCCESS) {
303
fprintf (stderr, "Error in prime generation: %s\n",
304
safer_gnutls_strerror(ret));
308
gnutls_certificate_set_dh_params (es->cred, es->dh_params);
310
// GnuTLS session creation
311
if ((ret = gnutls_init (&es->session, GNUTLS_SERVER))
312
!= GNUTLS_E_SUCCESS){
360
313
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
361
314
safer_gnutls_strerror(ret));
366
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
367
if (ret != GNUTLS_E_SUCCESS) {
368
fprintf(stderr, "Syntax error at: %s\n", err);
369
fprintf(stderr, "GnuTLS error: %s\n",
370
safer_gnutls_strerror(ret));
317
if ((ret = gnutls_priority_set_direct (es->session, "NORMAL", &err))
318
!= GNUTLS_E_SUCCESS) {
319
fprintf(stderr, "Syntax error at: %s\n", err);
320
fprintf(stderr, "GnuTLS error: %s\n",
321
safer_gnutls_strerror(ret));
375
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
377
if (ret != GNUTLS_E_SUCCESS) {
378
fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
325
if ((ret = gnutls_credentials_set
326
(es->session, GNUTLS_CRD_CERTIFICATE, es->cred))
327
!= GNUTLS_E_SUCCESS) {
328
fprintf(stderr, "Error setting a credentials set: %s\n",
379
329
safer_gnutls_strerror(ret));
383
333
/* ignore client certificate if any. */
384
gnutls_certificate_server_set_request (*session,
334
gnutls_certificate_server_set_request (es->session,
385
335
GNUTLS_CERT_IGNORE);
387
gnutls_dh_set_prime_bits (*session, mc->dh_bits);
337
gnutls_dh_set_prime_bits (es->session, DH_BITS);
392
/* Avahi log function callback */
393
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
394
__attribute__((unused)) const char *txt){}
342
void empty_log(__attribute__((unused)) AvahiLogLevel level,
343
__attribute__((unused)) const char *txt){}
396
/* Called when a Mandos server is found */
397
static int start_mandos_communication(const char *ip, uint16_t port,
398
AvahiIfIndex if_index,
345
int start_mandos_communication(const char *ip, uint16_t port,
346
unsigned int if_index){
401
348
struct sockaddr_in6 to;
349
encrypted_session es;
402
350
char *buffer = NULL;
403
351
char *decrypted_buffer;
404
352
size_t buffer_length = 0;
405
353
size_t buffer_capacity = 0;
406
354
ssize_t decrypted_buffer_size;
409
357
char interface[IF_NAMESIZE];
410
gnutls_session_t session;
411
gnutls_dh_params_t dh_params;
413
ret = init_gnutls_session (mc, &session);
419
360
fprintf(stderr, "Setting up a tcp connection to %s, port %d\n",
593
/* Shutdown procedure */
515
fprintf(stderr, "Closing TLS session\n");
519
gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
598
gnutls_deinit (session);
599
gnutls_certificate_free_credentials (mc->cred);
522
gnutls_deinit (es.session);
523
gnutls_certificate_free_credentials (es.cred);
600
524
gnutls_global_deinit ();
604
static void resolve_callback(AvahiSServiceResolver *r,
605
AvahiIfIndex interface,
606
AVAHI_GCC_UNUSED AvahiProtocol protocol,
607
AvahiResolverEvent event,
611
const char *host_name,
612
const AvahiAddress *address,
614
AVAHI_GCC_UNUSED AvahiStringList *txt,
615
AVAHI_GCC_UNUSED AvahiLookupResultFlags
618
mandos_context *mc = userdata;
528
static AvahiSimplePoll *simple_poll = NULL;
529
static AvahiServer *server = NULL;
531
static void resolve_callback(
532
AvahiSServiceResolver *r,
533
AvahiIfIndex interface,
534
AVAHI_GCC_UNUSED AvahiProtocol protocol,
535
AvahiResolverEvent event,
539
const char *host_name,
540
const AvahiAddress *address,
542
AVAHI_GCC_UNUSED AvahiStringList *txt,
543
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
544
AVAHI_GCC_UNUSED void* userdata) {
619
546
assert(r); /* Spurious warning */
621
548
/* Called whenever a service has been resolved successfully or
646
574
avahi_s_service_resolver_free(r);
649
static void browse_callback( AvahiSServiceBrowser *b,
650
AvahiIfIndex interface,
651
AvahiProtocol protocol,
652
AvahiBrowserEvent event,
656
AVAHI_GCC_UNUSED AvahiLookupResultFlags
659
mandos_context *mc = userdata;
660
assert(b); /* Spurious warning */
662
/* Called whenever a new services becomes available on the LAN or
663
is removed from the LAN */
667
case AVAHI_BROWSER_FAILURE:
669
fprintf(stderr, "(Avahi browser) %s\n",
670
avahi_strerror(avahi_server_errno(mc->server)));
671
avahi_simple_poll_quit(mc->simple_poll);
674
case AVAHI_BROWSER_NEW:
675
/* We ignore the returned Avahi resolver object. In the callback
676
function we free it. If the Avahi server is terminated before
677
the callback function is called the Avahi server will free the
680
if (!(avahi_s_service_resolver_new(mc->server, interface,
681
protocol, name, type, domain,
682
AVAHI_PROTO_INET6, 0,
683
resolve_callback, mc)))
684
fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
685
name, avahi_strerror(avahi_server_errno(mc->server)));
688
case AVAHI_BROWSER_REMOVE:
691
case AVAHI_BROWSER_ALL_FOR_NOW:
692
case AVAHI_BROWSER_CACHE_EXHAUSTED:
694
fprintf(stderr, "No Mandos server found, still searching...\n");
577
static void browse_callback(
578
AvahiSServiceBrowser *b,
579
AvahiIfIndex interface,
580
AvahiProtocol protocol,
581
AvahiBrowserEvent event,
585
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
588
AvahiServer *s = userdata;
589
assert(b); /* Spurious warning */
591
/* Called whenever a new services becomes available on the LAN or
592
is removed from the LAN */
596
case AVAHI_BROWSER_FAILURE:
598
fprintf(stderr, "(Browser) %s\n",
599
avahi_strerror(avahi_server_errno(server)));
600
avahi_simple_poll_quit(simple_poll);
603
case AVAHI_BROWSER_NEW:
604
/* We ignore the returned resolver object. In the callback
605
function we free it. If the server is terminated before
606
the callback function is called the server will free
607
the resolver for us. */
609
if (!(avahi_s_service_resolver_new(s, interface, protocol, name,
611
AVAHI_PROTO_INET6, 0,
612
resolve_callback, s)))
613
fprintf(stderr, "Failed to resolve service '%s': %s\n", name,
614
avahi_strerror(avahi_server_errno(s)));
617
case AVAHI_BROWSER_REMOVE:
620
case AVAHI_BROWSER_ALL_FOR_NOW:
621
case AVAHI_BROWSER_CACHE_EXHAUSTED:
700
/* Combines file name and path and returns the malloced new
701
string. some sane checks could/should be added */
702
static const char *combinepath(const char *first, const char *second){
703
size_t f_len = strlen(first);
704
size_t s_len = strlen(second);
705
char *tmp = malloc(f_len + s_len + 2);
710
memcpy(tmp, first, f_len); /* Spurious warning */
714
memcpy(tmp + f_len + 1, second, s_len); /* Spurious warning */
716
tmp[f_len + 1 + s_len] = '\0';
721
int main(int argc, char *argv[]){
626
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
627
AvahiServerConfig config;
722
628
AvahiSServiceBrowser *sb = NULL;
725
int exitcode = EXIT_SUCCESS;
631
int returncode = EXIT_SUCCESS;
726
632
const char *interface = "eth0";
727
struct ifreq network;
633
unsigned int if_index;
731
634
char *connect_to = NULL;
732
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
733
const char *pubkeyfile = "pubkey.txt";
734
const char *seckeyfile = "seckey.txt";
735
mandos_context mc = { .simple_poll = NULL, .server = NULL,
736
.dh_bits = 1024, .priority = "SECURE256"};
739
struct argp_option options[] = {
740
{ .name = "debug", .key = 128,
741
.doc = "Debug mode", .group = 3 },
742
{ .name = "connect", .key = 'c',
744
.doc = "Connect directly to a sepcified mandos server", .group = 1 },
745
{ .name = "interface", .key = 'i',
747
.doc = "Interface that Avahi will conntect through", .group = 1 },
748
{ .name = "keydir", .key = 'd',
750
.doc = "Directory where the openpgp keyring is", .group = 1 },
751
{ .name = "seckey", .key = 's',
753
.doc = "Secret openpgp key for gnutls authentication", .group = 1 },
754
{ .name = "pubkey", .key = 'p',
756
.doc = "Public openpgp key for gnutls authentication", .group = 2 },
757
{ .name = "dh-bits", .key = 129,
759
.doc = "dh-bits to use in gnutls communication", .group = 2 },
760
{ .name = "priority", .key = 130,
762
.doc = "GNUTLS priority", .group = 1 },
767
error_t parse_opt (int key, char *arg, struct argp_state *state) {
768
/* Get the INPUT argument from `argp_parse', which we know is a
769
pointer to our plugin list pointer. */
791
mc.dh_bits = (unsigned int) strtol(arg, NULL, 10);
806
return ARGP_ERR_UNKNOWN;
811
struct argp argp = { .options = options, .parser = parse_opt,
813
.doc = "Mandos client -- Get and decrypt passwords from mandos server" };
814
argp_parse (&argp, argc, argv, 0, 0, NULL);
817
pubkeyfile = combinepath(keydir, pubkeyfile);
818
if (pubkeyfile == NULL){
819
perror("combinepath");
820
exitcode = EXIT_FAILURE;
824
seckeyfile = combinepath(keydir, seckeyfile);
825
if (seckeyfile == NULL){
826
perror("combinepath");
830
ret = init_gnutls_global(&mc, pubkeyfile, seckeyfile);
832
fprintf(stderr, "init_gnutls_global\n");
849
if_index = (AvahiIfIndex) if_nametoindex(interface);
637
static struct option long_options[] = {
638
{"debug", no_argument, (int *)&debug, 1},
639
{"connect", required_argument, 0, 'c'},
640
{"interface", required_argument, 0, 'i'},
643
int option_index = 0;
644
ret = getopt_long (argc, argv, "i:", long_options,
665
if_index = if_nametoindex(interface);
850
666
if(if_index == 0){
851
667
fprintf(stderr, "No such interface: \"%s\"\n", interface);
852
668
exit(EXIT_FAILURE);
858
674
char *address = strrchr(connect_to, ':');
859
675
if(address == NULL){
860
676
fprintf(stderr, "No colon in address\n");
861
exitcode = EXIT_FAILURE;
865
680
uint16_t port = (uint16_t) strtol(address+1, NULL, 10);
867
682
perror("Bad port number");
868
exitcode = EXIT_FAILURE;
872
686
address = connect_to;
873
ret = start_mandos_communication(address, port, if_index, &mc);
687
ret = start_mandos_communication(address, port, if_index);
875
exitcode = EXIT_FAILURE;
877
exitcode = EXIT_SUCCESS;
882
/* If the interface is down, bring it up */
884
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
887
exitcode = EXIT_FAILURE;
890
strcpy(network.ifr_name, interface); /* Spurious warning */
891
ret = ioctl(sd, SIOCGIFFLAGS, &network);
893
perror("ioctl SIOCGIFFLAGS");
894
exitcode = EXIT_FAILURE;
897
if((network.ifr_flags & IFF_UP) == 0){
898
network.ifr_flags |= IFF_UP;
899
ret = ioctl(sd, SIOCSIFFLAGS, &network);
901
perror("ioctl SIOCSIFFLAGS");
902
exitcode = EXIT_FAILURE;
910
696
avahi_set_log_function(empty_log);
913
/* Initialize the pseudo-RNG for Avahi */
699
/* Initialize the psuedo-RNG */
914
700
srand((unsigned int) time(NULL));
916
/* Allocate main Avahi loop object */
917
mc.simple_poll = avahi_simple_poll_new();
918
if (mc.simple_poll == NULL) {
919
fprintf(stderr, "Avahi: Failed to create simple poll"
921
exitcode = EXIT_FAILURE;
926
AvahiServerConfig config;
927
/* Do not publish any local Zeroconf records */
928
avahi_server_config_init(&config);
929
config.publish_hinfo = 0;
930
config.publish_addresses = 0;
931
config.publish_workstation = 0;
932
config.publish_domain = 0;
934
/* Allocate a new server */
935
mc.server = avahi_server_new(avahi_simple_poll_get
936
(mc.simple_poll), &config, NULL,
939
/* Free the Avahi configuration data */
940
avahi_server_config_free(&config);
943
/* Check if creating the Avahi server object succeeded */
944
if (mc.server == NULL) {
945
fprintf(stderr, "Failed to create Avahi server: %s\n",
702
/* Allocate main loop object */
703
if (!(simple_poll = avahi_simple_poll_new())) {
704
fprintf(stderr, "Failed to create simple poll object.\n");
709
/* Do not publish any local records */
710
avahi_server_config_init(&config);
711
config.publish_hinfo = 0;
712
config.publish_addresses = 0;
713
config.publish_workstation = 0;
714
config.publish_domain = 0;
716
/* Allocate a new server */
717
server = avahi_server_new(avahi_simple_poll_get(simple_poll),
718
&config, NULL, NULL, &error);
720
/* Free the configuration data */
721
avahi_server_config_free(&config);
723
/* Check if creating the server object succeeded */
725
fprintf(stderr, "Failed to create server: %s\n",
946
726
avahi_strerror(error));
947
exitcode = EXIT_FAILURE;
727
returncode = EXIT_FAILURE;
951
/* Create the Avahi service browser */
952
sb = avahi_s_service_browser_new(mc.server, if_index,
731
/* Create the service browser */
732
sb = avahi_s_service_browser_new(server, (AvahiIfIndex)if_index,
953
733
AVAHI_PROTO_INET6,
954
734
"_mandos._tcp", NULL, 0,
955
browse_callback, &mc);
735
browse_callback, server);
957
737
fprintf(stderr, "Failed to create service browser: %s\n",
958
avahi_strerror(avahi_server_errno(mc.server)));
959
exitcode = EXIT_FAILURE;
738
avahi_strerror(avahi_server_errno(server)));
739
returncode = EXIT_FAILURE;
963
743
/* Run the main loop */
966
fprintf(stderr, "Starting Avahi loop search\n");
746
fprintf(stderr, "Starting avahi loop search\n");
969
avahi_simple_poll_loop(mc.simple_poll);
749
avahi_simple_poll_loop(simple_poll);
974
754
fprintf(stderr, "%s exiting\n", argv[0]);
977
757
/* Cleanup things */
979
759
avahi_s_service_browser_free(sb);
981
if (mc.server != NULL)
982
avahi_server_free(mc.server);
984
if (mc.simple_poll != NULL)
985
avahi_simple_poll_free(mc.simple_poll);
762
avahi_server_free(server);
765
avahi_simple_poll_free(simple_poll);