/mandos/trunk

/*  -*- coding: utf-8 -*- */

/*

 * Mandos-client - get and decrypt data from a Mandos server

 *

 * This program is partly derived from an example program for an Avahi

 * service browser, downloaded from

 * <http://avahi.org/browser/examples/core-browse-services.c>.  This

 * includes the following functions: "resolve_callback",

 * "browse_callback", and parts of "main".

 * 

 * Everything else is

 * Copyright © 2008-2018 Teddy Hogeborn

 * Copyright © 2008-2018 Björn Påhlsson

 * 

 * This file is part of Mandos.

 * 

 * Mandos is free software: you can redistribute it and/or modify it

 * under the terms of the GNU General Public License as published by

 * the Free Software Foundation, either version 3 of the License, or

 * (at your option) any later version.

 * 

 * Mandos 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

 * General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with Mandos.  If not, see <http://www.gnu.org/licenses/>.

 * 

 * Contact the authors at <mandos@recompile.se>.

 */

/* Needed by GPGME, specifically gpgme_data_seek() */

#ifndef _LARGEFILE_SOURCE

#define _LARGEFILE_SOURCE

#endif	/* not _LARGEFILE_SOURCE */

#ifndef _FILE_OFFSET_BITS

#define _FILE_OFFSET_BITS 64

#endif	/* not _FILE_OFFSET_BITS */

#define _GNU_SOURCE		/* TEMP_FAILURE_RETRY(), asprintf() */

#include <stdio.h>		/* fprintf(), stderr, fwrite(),

				   stdout, ferror() */

#include <stdint.h> 		/* uint16_t, uint32_t, intptr_t */

#include <stddef.h>		/* NULL, size_t, ssize_t */

#include <stdlib.h> 		/* free(), EXIT_SUCCESS, srand(),

				   strtof(), abort() */

#include <stdbool.h>		/* bool, false, true */

#include <string.h>		/* strcmp(), strlen(), strerror(),

				   asprintf(), strncpy(), strsignal()

				*/

#include <sys/ioctl.h>		/* ioctl */

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

				   sockaddr_in6, PF_INET6,

				   SOCK_STREAM, uid_t, gid_t, open(),

				   opendir(), DIR */

#include <sys/stat.h>		/* open(), S_ISREG */

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

				   inet_pton(), connect(),

				   getnameinfo() */

#include <fcntl.h>		/* open(), unlinkat(), AT_REMOVEDIR */

#include <dirent.h>		/* opendir(), struct dirent, readdir()

				 */

#include <inttypes.h>		/* PRIu16, PRIdMAX, intmax_t,

				   strtoimax() */

#include <errno.h>		/* perror(), errno, EINTR, EINVAL,

				   EAI_SYSTEM, ENETUNREACH,

				   EHOSTUNREACH, ECONNREFUSED, EPROTO,

				   EIO, ENOENT, ENXIO, ENOMEM, EISDIR,

				   ENOTEMPTY,

				   program_invocation_short_name */

#include <time.h>		/* nanosleep(), time(), sleep() */

#include <net/if.h>		/* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,

				   SIOCSIFFLAGS, if_indextoname(),

				   if_nametoindex(), IF_NAMESIZE */

#include <netinet/in.h>		/* IN6_IS_ADDR_LINKLOCAL,

				   INET_ADDRSTRLEN, INET6_ADDRSTRLEN

				*/

#include <unistd.h>		/* close(), SEEK_SET, off_t, write(),

				   getuid(), getgid(), seteuid(),

				   setgid(), pause(), _exit(),

				   unlinkat() */

#include <arpa/inet.h>		/* inet_pton(), htons() */

#include <iso646.h>		/* not, or, and */

#include <argp.h>		/* struct argp_option, error_t, struct

				   argp_state, struct argp,

				   argp_parse(), ARGP_KEY_ARG,

				   ARGP_KEY_END, ARGP_ERR_UNKNOWN */

#include <signal.h>		/* sigemptyset(), sigaddset(),

				   sigaction(), SIGTERM, sig_atomic_t,

				   raise() */

#include <sysexits.h>		/* EX_OSERR, EX_USAGE, EX_UNAVAILABLE,

				   EX_NOHOST, EX_IOERR, EX_PROTOCOL */

#include <sys/wait.h>		/* waitpid(), WIFEXITED(),

				   WEXITSTATUS(), WTERMSIG() */

#include <grp.h>		/* setgroups() */

#include <argz.h>		/* argz_add_sep(), argz_next(),

				   argz_delete(), argz_append(),

				   argz_stringify(), argz_add(),

				   argz_count() */

#include <netdb.h>		/* getnameinfo(), NI_NUMERICHOST,

				   EAI_SYSTEM, gai_strerror() */

#ifdef __linux__

#include <sys/klog.h> 		/* klogctl() */

#endif	/* __linux__ */

/* Avahi */

/* All Avahi types, constants and functions

 Avahi*, avahi_*,

 AVAHI_* */

#include <avahi-core/core.h>

#include <avahi-core/lookup.h>

#include <avahi-core/log.h>

#include <avahi-common/simple-watch.h>

#include <avahi-common/malloc.h>

#include <avahi-common/error.h>

/* GnuTLS */

#include <gnutls/gnutls.h>	/* All GnuTLS types, constants and

				   functions:

				   gnutls_*

				   init_gnutls_session(),

				   GNUTLS_* */

#include <gnutls/openpgp.h>

			 /* gnutls_certificate_set_openpgp_key_file(),

			    GNUTLS_OPENPGP_FMT_BASE64 */

/* GPGME */

#include <gpgme.h> 		/* All GPGME types, constants and

				   functions:

				   gpgme_*

				   GPGME_PROTOCOL_OpenPGP,

				   GPG_ERR_NO_* */

#define BUFFER_SIZE 256

#define PATHDIR "/conf/conf.d/mandos"

#define SECKEY "seckey.txt"

#define PUBKEY "pubkey.txt"

#define HOOKDIR "/lib/mandos/network-hooks.d"

bool debug = false;

static const char mandos_protocol_version[] = "1";

const char *argp_program_version = "mandos-client " VERSION;

const char *argp_program_bug_address = "<mandos@recompile.se>";

static const char sys_class_net[] = "/sys/class/net";

char *connect_to = NULL;

const char *hookdir = HOOKDIR;

int hookdir_fd = -1;

uid_t uid = 65534;

gid_t gid = 65534;

/* Doubly linked list that need to be circularly linked when used */

typedef struct server{

  const char *ip;

  in_port_t port;

  AvahiIfIndex if_index;

  int af;

  struct timespec last_seen;

  struct server *next;

  struct server *prev;

} server;

/* Used for passing in values through the Avahi callback functions */

typedef struct {

  AvahiServer *server;

  gnutls_certificate_credentials_t cred;

  unsigned int dh_bits;

  gnutls_dh_params_t dh_params;

  const char *priority;

  gpgme_ctx_t ctx;

  server *current_server;

  char *interfaces;

  size_t interfaces_size;

} mandos_context;

/* global so signal handler can reach it*/

AvahiSimplePoll *simple_poll;

sig_atomic_t quit_now = 0;

int signal_received = 0;

/* Function to use when printing errors */

void perror_plus(const char *print_text){

  int e = errno;

  fprintf(stderr, "Mandos plugin %s: ",

	  program_invocation_short_name);

  errno = e;

  perror(print_text);

}

__attribute__((format (gnu_printf, 2, 3), nonnull))

int fprintf_plus(FILE *stream, const char *format, ...){

  va_list ap;

  va_start (ap, format);

  TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",

			     program_invocation_short_name));

  return (int)TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));

}

/*

 * Make additional room in "buffer" for at least BUFFER_SIZE more

 * bytes. "buffer_capacity" is how much is currently allocated,

 * "buffer_length" is how much is already used.

 */

__attribute__((nonnull, warn_unused_result))

size_t incbuffer(char **buffer, size_t buffer_length,

		 size_t buffer_capacity){

  if(buffer_length + BUFFER_SIZE > buffer_capacity){

    char *new_buf = realloc(*buffer, buffer_capacity + BUFFER_SIZE);

    if(new_buf == NULL){

      int old_errno = errno;

      free(*buffer);

      errno = old_errno;

      *buffer = NULL;

      return 0;

    }

    *buffer = new_buf;

    buffer_capacity += BUFFER_SIZE;

  }

  return buffer_capacity;

}

/* Add server to set of servers to retry periodically */

__attribute__((nonnull, warn_unused_result))

bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,

		int af, server **current_server){

  int ret;

  server *new_server = malloc(sizeof(server));

  if(new_server == NULL){

    perror_plus("malloc");

    return false;

  }

  *new_server = (server){ .ip = strdup(ip),

			  .port = port,

			  .if_index = if_index,

			  .af = af };

  if(new_server->ip == NULL){

    perror_plus("strdup");

    free(new_server);

    return false;

  }

  ret = clock_gettime(CLOCK_MONOTONIC, &(new_server->last_seen));

  if(ret == -1){

    perror_plus("clock_gettime");

#ifdef __GNUC__

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wcast-qual"

#endif

    free((char *)(new_server->ip));

#ifdef __GNUC__

#pragma GCC diagnostic pop

#endif

    free(new_server);

    return false;

  }

  /* Special case of first server */

  if(*current_server == NULL){

    new_server->next = new_server;

    new_server->prev = new_server;

    *current_server = new_server;

  } else {

    /* Place the new server last in the list */

    new_server->next = *current_server;

    new_server->prev = (*current_server)->prev;

    new_server->prev->next = new_server;

    (*current_server)->prev = new_server;

  }

  return true;

}

/* 

 * Initialize GPGME.

 */

__attribute__((nonnull, warn_unused_result))

static bool init_gpgme(const char * const seckey,

		       const char * const pubkey,

		       const char * const tempdir,

		       mandos_context *mc){

  gpgme_error_t rc;

  gpgme_engine_info_t engine_info;

  /*

   * Helper function to insert pub and seckey to the engine keyring.

   */

  bool import_key(const char * const filename){

    int ret;

    int fd;

    gpgme_data_t pgp_data;

    fd = (int)TEMP_FAILURE_RETRY(open(filename, O_RDONLY));

    if(fd == -1){

      perror_plus("open");

      return false;

    }

    rc = gpgme_data_new_from_fd(&pgp_data, fd);

    if(rc != GPG_ERR_NO_ERROR){

      fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",

		   gpgme_strsource(rc), gpgme_strerror(rc));

      return false;

    }

    rc = gpgme_op_import(mc->ctx, pgp_data);

    if(rc != GPG_ERR_NO_ERROR){

      fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",

		   gpgme_strsource(rc), gpgme_strerror(rc));

      return false;

    }

    ret = close(fd);

    if(ret == -1){

      perror_plus("close");

    }

    gpgme_data_release(pgp_data);

    return true;

  }

  if(debug){

    fprintf_plus(stderr, "Initializing GPGME\n");

  }

  /* Init GPGME */

  gpgme_check_version(NULL);

  rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);

  if(rc != GPG_ERR_NO_ERROR){

    fprintf_plus(stderr, "bad gpgme_engine_check_version: %s: %s\n",

		 gpgme_strsource(rc), gpgme_strerror(rc));

    return false;

  }

  /* Set GPGME home directory for the OpenPGP engine only */

  rc = gpgme_get_engine_info(&engine_info);

  if(rc != GPG_ERR_NO_ERROR){

    fprintf_plus(stderr, "bad gpgme_get_engine_info: %s: %s\n",

		 gpgme_strsource(rc), gpgme_strerror(rc));

    return false;

  }

  while(engine_info != NULL){

    if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){

      gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,

			    engine_info->file_name, tempdir);

      break;

    }

    engine_info = engine_info->next;

  }

  if(engine_info == NULL){

    fprintf_plus(stderr, "Could not set GPGME home dir to %s\n",

		 tempdir);

    return false;

  }

  /* Create new GPGME "context" */

  rc = gpgme_new(&(mc->ctx));

  if(rc != GPG_ERR_NO_ERROR){

    fprintf_plus(stderr, "Mandos plugin mandos-client: "

		 "bad gpgme_new: %s: %s\n", gpgme_strsource(rc),

		 gpgme_strerror(rc));

    return false;

  }

  if(not import_key(pubkey) or not import_key(seckey)){

    return false;

  }

  return true;

}

/* 

 * Decrypt OpenPGP data.

 * Returns -1 on error

 */

__attribute__((nonnull, warn_unused_result))

static ssize_t pgp_packet_decrypt(const char *cryptotext,

				  size_t crypto_size,

				  char **plaintext,

				  mandos_context *mc){

  gpgme_data_t dh_crypto, dh_plain;

  gpgme_error_t rc;

  ssize_t ret;

  size_t plaintext_capacity = 0;

  ssize_t plaintext_length = 0;

  if(debug){

    fprintf_plus(stderr, "Trying to decrypt OpenPGP data\n");

  }

  /* Create new GPGME data buffer from memory cryptotext */

  rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,

			       0);

  if(rc != GPG_ERR_NO_ERROR){

    fprintf_plus(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",

		 gpgme_strsource(rc), gpgme_strerror(rc));

    return -1;

  }

  /* Create new empty GPGME data buffer for the plaintext */

  rc = gpgme_data_new(&dh_plain);

  if(rc != GPG_ERR_NO_ERROR){

    fprintf_plus(stderr, "Mandos plugin mandos-client: "

		 "bad gpgme_data_new: %s: %s\n",

		 gpgme_strsource(rc), gpgme_strerror(rc));

    gpgme_data_release(dh_crypto);

    return -1;

  }

  /* Decrypt data from the cryptotext data buffer to the plaintext

     data buffer */

  rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);

  if(rc != GPG_ERR_NO_ERROR){

    fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",

		 gpgme_strsource(rc), gpgme_strerror(rc));

    plaintext_length = -1;

    if(debug){

      gpgme_decrypt_result_t result;

      result = gpgme_op_decrypt_result(mc->ctx);

      if(result == NULL){

	fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");

      } else {

	fprintf_plus(stderr, "Unsupported algorithm: %s\n",

		     result->unsupported_algorithm);

	fprintf_plus(stderr, "Wrong key usage: %u\n",

		     result->wrong_key_usage);

	if(result->file_name != NULL){

	  fprintf_plus(stderr, "File name: %s\n", result->file_name);

	}

	gpgme_recipient_t recipient;

	recipient = result->recipients;

	while(recipient != NULL){

	  fprintf_plus(stderr, "Public key algorithm: %s\n",

		       gpgme_pubkey_algo_name

		       (recipient->pubkey_algo));

	  fprintf_plus(stderr, "Key ID: %s\n", recipient->keyid);

	  fprintf_plus(stderr, "Secret key available: %s\n",

		       recipient->status == GPG_ERR_NO_SECKEY

		       ? "No" : "Yes");

	  recipient = recipient->next;

	}

      }

    }

    goto decrypt_end;

  }

  if(debug){

    fprintf_plus(stderr, "Decryption of OpenPGP data succeeded\n");

  }

  /* Seek back to the beginning of the GPGME plaintext data buffer */

  if(gpgme_data_seek(dh_plain, (off_t)0, SEEK_SET) == -1){

    perror_plus("gpgme_data_seek");

    plaintext_length = -1;

    goto decrypt_end;

  }

  *plaintext = NULL;

  while(true){

    plaintext_capacity = incbuffer(plaintext,

				   (size_t)plaintext_length,

				   plaintext_capacity);

    if(plaintext_capacity == 0){

      perror_plus("incbuffer");

      plaintext_length = -1;

      goto decrypt_end;

    }

    ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,

			  BUFFER_SIZE);

    /* Print the data, if any */

    if(ret == 0){

      /* EOF */

      break;

    }

    if(ret < 0){

      perror_plus("gpgme_data_read");

      plaintext_length = -1;

      goto decrypt_end;

    }

    plaintext_length += ret;

  }

  if(debug){

    fprintf_plus(stderr, "Decrypted password is: ");

    for(ssize_t i = 0; i < plaintext_length; i++){

      fprintf(stderr, "%02hhX ", (*plaintext)[i]);

    }

    fprintf(stderr, "\n");

  }

 decrypt_end:

  /* Delete the GPGME cryptotext data buffer */

  gpgme_data_release(dh_crypto);

  /* Delete the GPGME plaintext data buffer */

  gpgme_data_release(dh_plain);

  return plaintext_length;

}

__attribute__((warn_unused_result, const))

static const char *safe_string(const char *str){

  if(str == NULL)

    return "(unknown)";

  return str;

}

__attribute__((warn_unused_result))

static const char *safer_gnutls_strerror(int value){

  const char *ret = gnutls_strerror(value);

  return safe_string(ret);

}

/* GnuTLS log function callback */

__attribute__((nonnull))

static void debuggnutls(__attribute__((unused)) int level,

			const char* string){

  fprintf_plus(stderr, "GnuTLS: %s", string);

}

__attribute__((nonnull(1, 2, 4), warn_unused_result))

static int init_gnutls_global(const char *pubkeyfilename,

			      const char *seckeyfilename,

			      const char *dhparamsfilename,

			      mandos_context *mc){

  int ret;

  unsigned int uret;

  if(debug){

    fprintf_plus(stderr, "Initializing GnuTLS\n");

  }

  if(debug){

    /* "Use a log level over 10 to enable all debugging options."

     * - GnuTLS manual

     */

    gnutls_global_set_log_level(11);

    gnutls_global_set_log_function(debuggnutls);

  }

  /* OpenPGP credentials */

  ret = gnutls_certificate_allocate_credentials(&mc->cred);

  if(ret != GNUTLS_E_SUCCESS){

    fprintf_plus(stderr, "GnuTLS memory error: %s\n",

		 safer_gnutls_strerror(ret));

    return -1;

  }

  if(debug){

    fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"

		 " secret key %s as GnuTLS credentials\n",

		 pubkeyfilename,

		 seckeyfilename);

  }