hcconn_ssl.c

   1 /*
   2 ** Copyright (C) 2006 Thadeu Lima de Souza Cascardo <cascardo@minaslivre.org>
   3 ** Copyright (C) 2009 Thadeu Lima de Souza Cascardo <cascardo@holoscopio.com>
   4 **
   5 ** This program is free software; you can redistribute it and/or modify
   6 ** it under the terms of the GNU General Public License as published by
   7 ** the Free Software Foundation; either version 2 of the License, or
   8 ** (at your option) any later version.
   9 **
  10 ** This program is distributed in the hope that it will be useful,
  11 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 ** GNU General Public License for more details.
  14 **
  15 ** You should have received a copy of the GNU General Public License
  16 ** along with this program; if not, write to the Free Software
  17 ** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18 **
  19 */
  20
  21 #include <gnutls/gnutls.h>
  22 #include <glib.h>
  23 #include <string.h>
  24 #include <errno.h>
  25 #include <fcntl.h>
  26 #include "hcconn_internal.h"
  27
  28 struct ssl_data
  29 {
  30   gnutls_session_t session;
  31   GString *buffer;
  32   gboolean handshaking;
  33   gboolean failed;
  34   gpointer lowconn;
  35 };
  36
  37 #define DH_BITS 1024
  38 void *
  39 hc_conn_ssl_server_init_credentials (char *certfile, char *keyfile)
  40 {
  41   static int initialized = 0;
  42   static gnutls_certificate_credentials_t cred;
  43   gnutls_dh_params_t dh_params;
  44   if (initialized)
  45     return cred;
  46   gnutls_dh_params_init (&dh_params);
  47   gnutls_dh_params_generate2 (dh_params, DH_BITS);
  48   gnutls_certificate_allocate_credentials (&cred);
  49   gnutls_certificate_set_x509_key_file (cred, certfile, keyfile,
  50                                         GNUTLS_X509_FMT_PEM);
  51   gnutls_certificate_set_dh_params (cred, dh_params);
  52   initialized = 1;
  53   return cred;
  54 }
  55
  56 static void *
  57 ssl_server_get_credentials(void)
  58 {
  59   return hc_conn_ssl_server_init_credentials (NULL, NULL);
  60 }
  61
  62 static void
  63 ssl_server_session_new (gnutls_session_t *session)
  64 {
  65   static void *cred;
  66   cred = ssl_server_get_credentials ();
  67   gnutls_init (session, GNUTLS_SERVER);
  68   gnutls_set_default_priority (*session);
  69   gnutls_credentials_set (*session, GNUTLS_CRD_CERTIFICATE, cred);
  70   gnutls_dh_set_prime_bits (*session, DH_BITS);
  71 }
  72 #undef DH_BITS
  73
  74 static void
  75 ssl_client_session_new (gnutls_session_t *session)
  76 {
  77   int kx_prio[] = {GNUTLS_KX_RSA, 0};
  78   gnutls_certificate_credentials cred;
  79   gnutls_certificate_allocate_credentials (&cred);
  80   gnutls_init (session, GNUTLS_CLIENT);
  81   gnutls_set_default_priority (*session);
  82   gnutls_kx_set_priority (*session, kx_prio);
  83   gnutls_credentials_set (*session, GNUTLS_CRD_CERTIFICATE, cred);
  84 }
  85
  86 static struct ssl_data *
  87 ssl_data_new (int server)
  88 {
  89   struct ssl_data *ssl;
  90   ssl = g_slice_new (struct ssl_data);
  91   if (server)
  92     ssl_server_session_new (&ssl->session);
  93   else
  94     ssl_client_session_new (&ssl->session);
  95   ssl->buffer = g_string_sized_new (4096);
  96   ssl->handshaking = FALSE;
  97   ssl->failed = FALSE;
  98   return ssl;
  99 }
 100
 101 static void
 102 ssl_data_destroy (struct ssl_data *ssl)
 103 {
 104   gnutls_deinit (ssl->session);
 105   g_string_free (ssl->buffer, TRUE);
 106   g_slice_free (struct ssl_data, ssl);
 107 }
 108
 109 static ssize_t
 110 ssl_push (gnutls_transport_ptr_t ptr, const void *buffer, size_t len)
 111 {
 112   HCConn *conn = ptr;
 113   struct ssl_data *ssl = conn->layer;
 114   hc_conn_write (ssl->lowconn, (void *) buffer, len);
 115   return len;
 116 }
 117
 118 static ssize_t
 119 ssl_pull (gnutls_transport_ptr_t ptr, void *buffer, size_t len)
 120 {
 121   HCConn *conn = ptr;
 122   struct ssl_data *ssl = conn->layer;
 123   int r;
 124   if (ssl->handshaking == TRUE)
 125     {
 126       r = hc_conn_read (ssl->lowconn, buffer, len);
 127       return r;
 128     }
 129   if (len > ssl->buffer->len)
 130     {
 131       r = ssl->buffer->len;
 132       memcpy (buffer, ssl->buffer->str, r);
 133       g_string_truncate (ssl->buffer, 0);
 134     }
 135   else
 136     {
 137       r = len;
 138       memcpy (buffer, ssl->buffer->str, r);
 139       g_string_erase (ssl->buffer, 0, r);
 140     }
 141   if (r == 0)
 142     {
 143       gnutls_transport_set_global_errno (EAGAIN);
 144       return -1;
 145     }
 146   return r;
 147 }
 148
 149 static void
 150 ssl_server_handshake (struct ssl_data *ssl)
 151 {
 152   int error;
 153   if ((error = gnutls_handshake (ssl->session)) < 0)
 154     {
 155       if (gnutls_error_is_fatal (error))
 156         {
 157           g_critical ("Fatal error while doing TLS handshaking: %s\n",
 158                       gnutls_strerror (error));
 159           ssl->failed = TRUE;
 160         }
 161     }
 162   else
 163     {
 164       ssl->handshaking = FALSE;
 165     }
 166 }
 167
 168 static void
 169 ssl_server_connect (HCConn *conn)
 170 {
 171   struct ssl_data *ssl = conn->layer;
 172   gnutls_transport_set_ptr (ssl->session, (gnutls_transport_ptr_t) conn);
 173   gnutls_transport_set_push_function (ssl->session, ssl_push);
 174   gnutls_transport_set_pull_function (ssl->session, ssl_pull);
 175   ssl->handshaking = TRUE;
 176   ssl_server_handshake (ssl);
 177 }
 178
 179 static void
 180 hc_conn_ssl_close (gpointer data)
 181 {
 182   struct ssl_data *ssl = data;
 183   if (ssl != NULL)
 184     {
 185       gnutls_bye (ssl->session, GNUTLS_SHUT_RDWR);
 186       hc_conn_close (ssl->lowconn);
 187       ssl_data_destroy (ssl);
 188     }
 189 }
 190
 191 static ssize_t
 192 hc_conn_ssl_read (gpointer data, gchar *buffer, size_t len)
 193 {
 194   struct ssl_data *ssl = data;
 195   return gnutls_record_recv (ssl->session, buffer, len);
 196 }
 197
 198 static ssize_t
 199 hc_conn_ssl_write (gpointer data, gchar *buffer, size_t len)
 200 {
 201   struct ssl_data *ssl = data;
 202   return gnutls_record_send (ssl->session, buffer, len);
 203 }
 204
 205 void
 206 hc_conn_ssl_watch (HCConn *conn, HCEvent event, gpointer data)
 207 {
 208   char buffer[4096];
 209   HCConn *ssl_conn = data;
 210   struct ssl_data *ssl = ssl_conn->layer;
 211   int r;
 212   switch (event)
 213     {
 214     case HC_EVENT_READ:
 215       if (ssl->handshaking)
 216         {
 217           ssl_server_handshake (ssl);
 218           /* FIXME: create HC_CONN_ERROR */
 219           if (ssl->failed && ssl_conn->func)
 220             ssl_conn->func (ssl_conn, HC_EVENT_CLOSE, ssl_conn->data);
 221           return;
 222         }
 223       while ((r = hc_conn_read (ssl->lowconn, buffer, sizeof (buffer))) > 0)
 224         g_string_append_len (ssl->buffer, buffer, r);
 225       if (ssl_conn->func && !ssl->handshaking)
 226         ssl_conn->func (ssl_conn, event, ssl_conn->data);
 227       break;
 228     case HC_EVENT_CLOSE:
 229       if (ssl_conn->func)
 230         ssl_conn->func (ssl_conn, event, ssl_conn->data);
 231     }
 232 }
 233
 234 static int
 235 hc_conn_set_driver_ssl (HCConn *conn, HCConn *lowconn, int server)
 236 {
 237   struct ssl_data *ssl;
 238   ssl = ssl_data_new (server);
 239   if (ssl == NULL)
 240     return -1;
 241   ssl->lowconn = lowconn;
 242   conn->layer = ssl;
 243   conn->read = hc_conn_ssl_read;
 244   conn->write = hc_conn_ssl_write;
 245   conn->close = hc_conn_ssl_close;
 246   hc_conn_set_callback (lowconn, hc_conn_ssl_watch, conn);
 247   ssl_server_connect (conn);
 248   return 0;
 249 }
 250
 251 int
 252 hc_conn_set_driver_ssl_client (HCConn *conn, HCConn *lowconn)
 253 {
 254   return hc_conn_set_driver_ssl (conn, lowconn, 0);
 255 }
 256
 257 int
 258 hc_conn_set_driver_ssl_server (HCConn *conn, HCConn *lowconn)
 259 {
 260   return hc_conn_set_driver_ssl (conn, lowconn, 1);
 261 }