/mandos/trunk

/***

  This file is part of avahi.

 

  avahi is free software; you can redistribute it and/or modify it

  under the terms of the GNU Lesser General Public License as

  published by the Free Software Foundation; either version 2.1 of the

  License, or (at your option) any later version.

 

  avahi is distributed in the hope that it will be useful, but WITHOUT

  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY

  or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General

  Public License for more details.

 

  You should have received a copy of the GNU Lesser General Public

  License along with avahi; if not, write to the Free Software

  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307

  USA.

***/

#include <sys/types.h>          /* socket(), setsockopt(), inet_pton() */

#include <sys/socket.h>         /* socket(), setsockopt(), struct sockaddr_in6, struct in6_addr, inet_pton() */

#include <gnutls/gnutls.h>      /* ALL GNUTLS STUFF */

#include <gnutls/openpgp.h>     /* gnutls with openpgp stuff */

#ifndef CERT_ROOT

#define CERT_ROOT "/conf/conf.d/cryptkeyreq/"

#endif

#define CERTFILE CERT_ROOT "openpgp-client.txt"

#define KEYFILE CERT_ROOT "openpgp-client-key.txt"

char *interface = "eth0";

ssize_t gpg_packet_decrypt (char *packet, size_t packet_size, char **new_packet, char *homedir){

  size_t new_packet_capacity = 0;

  size_t new_packet_length = 0;

    fprintf(stderr, "Attempting to decrypt password from gpg packet\n");

  gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);

  /* Decrypt data from the FILE pointer to the plaintext data buffer */

    fprintf(stderr, "decryption of gpg packet succeeded\n");

      fprintf(stderr, "Unsupported algorithm: %s\n", result->unsupported_algorithm);

      fprintf(stderr, "Wrong key usage: %d\n", result->wrong_key_usage);

                  recipient->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");

  gpgme_data_seek(dh_plain, 0, SEEK_SET);

 

      *new_packet = realloc(*new_packet, new_packet_capacity + BUFFER_SIZE);

    ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length, BUFFER_SIZE);

      /* If password is empty, then a incorrect error will be printed */

void debuggnutls(int level, const char* string){

int initgnutls(encrypted_session *es){

 

    fprintf(stderr, "Initializing gnutls\n");

  

 

    fprintf (stderr, "memory error: %s\n", safer_gnutls_strerror(ret));

 

    fprintf(stderr, "Attempting to use openpgp certificate %s"

            " and keyfile %s as gnutls credentials\n", CERTFILE, KEYFILE);

 

    (es->cred, CERTFILE, KEYFILE, GNUTLS_OPENPGP_FMT_BASE64);

      (stderr, "Error[%d] while reading the OpenPGP key pair ('%s', '%s')\n",

       ret, CERTFILE, KEYFILE);

 

  //Gnutls server initialization

 

 

 

  // Gnutls session creation

    fprintf(stderr, "Error in gnutls session initialization: %s\n",

 

    fprintf(stderr, "Gnutls error: %s\n",

 

 

  gnutls_certificate_server_set_request (es->session, GNUTLS_CERT_IGNORE);

void empty_log(AvahiLogLevel level, const char *txt){}

int start_mandos_communication(char *ip, uint16_t port){

 

    fprintf(stderr, "Setting up a tcp connection to %s\n", ip);

 

  ret = setsockopt(tcp_sd, SOL_SOCKET, SO_BINDTODEVICE, interface, 5);

  if(tcp_sd < 0) {

    perror("setsockopt bindtodevice");

    return -1;

  }

  memset(&to,0,sizeof(to));

  to.sin6_port = htons(port);

  to.sin6_scope_id = if_nametoindex(interface);

 

    fprintf(stderr, "Connection to: %s\n", ip);

    

  

  gnutls_transport_set_ptr (es.session, (gnutls_transport_ptr_t) tcp_sd);

 

    fprintf(stderr, "Establishing tls session with %s\n", ip);

 

    fprintf(stderr, "\n*** Handshake failed ***\n");

    gnutls_perror (ret);

 

  //Retrieve gpg packet that contains the wanted password

 

    fprintf(stderr, "Retrieving pgp encrypted password from %s\n", ip);

        fprintf(stderr, "Unknown error while reading data from encrypted session with mandos server\n");

      buffer_length += ret;

    if ((decrypted_buffer_size = gpg_packet_decrypt(buffer, buffer_length, &decrypted_buffer, CERT_ROOT)) >= 0){

      fwrite (decrypted_buffer, 1, decrypted_buffer_size, stdout);

    fprintf(stderr, "Closing tls session\n");

    AVAHI_GCC_UNUSED AvahiIfIndex interface,

    AvahiStringList *txt,

    AvahiLookupResultFlags flags,

    assert(r);

 

    /* Called whenever a service has been resolved successfully or timed out */

 

    switch (event) {

        case AVAHI_RESOLVER_FAILURE:

            fprintf(stderr, "(Resolver) Failed to resolve service '%s' of type '%s' in domain '%s': %s\n", name, type, domain, avahi_strerror(avahi_server_errno(server)));

            break;

 

        case AVAHI_RESOLVER_FOUND: {

          char ip[AVAHI_ADDRESS_STR_MAX];

            avahi_address_snprint(ip, sizeof(ip), address);

            if(debug){

              fprintf(stderr, "Mandos server found at %s on port %d\n", ip, port);

            }

            int ret = start_mandos_communication(ip, port);

            if (ret == 0){

              exit(EXIT_SUCCESS);

            } else {

              exit(EXIT_FAILURE);

            }

        }

    avahi_s_service_resolver_free(r);

    assert(b);

 

    /* Called whenever a new services becomes available on the LAN or is removed from the LAN */

 

 

        case AVAHI_BROWSER_FAILURE:

            

            fprintf(stderr, "(Browser) %s\n", avahi_strerror(avahi_server_errno(server)));

            avahi_simple_poll_quit(simple_poll);

            return;

 

        case AVAHI_BROWSER_NEW:

            /* We ignore the returned resolver object. In the callback

               function we free it. If the server is terminated before

               the callback function is called the server will free

               the resolver for us. */

            

            if (!(avahi_s_service_resolver_new(s, interface, protocol, name, type, domain, AVAHI_PROTO_INET6, 0, resolve_callback, s)))

                fprintf(stderr, "Failed to resolve service '%s': %s\n", name, avahi_strerror(avahi_server_errno(s)));

            

            break;

 

        case AVAHI_BROWSER_REMOVE:

            break;

 

        case AVAHI_BROWSER_ALL_FOR_NOW:

        case AVAHI_BROWSER_CACHE_EXHAUSTED:

            break;

 

 

      ret = getopt_long (argc, argv, "i:", long_options, &option_index);

 

    srand(time(NULL));

        

    server = avahi_server_new(avahi_simple_poll_get(simple_poll), &config, NULL, NULL, &error);

        fprintf(stderr, "Failed to create server: %s\n", avahi_strerror(error));

    if (!(sb = avahi_s_service_browser_new(server, if_nametoindex("eth0"), AVAHI_PROTO_INET6, "_mandos._tcp", NULL, 0, browse_callback, server))) {

        fprintf(stderr, "Failed to create service browser: %s\n", avahi_strerror(avahi_server_errno(server)));

exit: