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@minaslivre.org>
   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       errno = (EAGAIN);
 144       return -1;
 145     }
 146   return r;
 147 }
 148
 149 static void
 150 ssl_server_handshake (HCConn *conn)
 151 {
 152   struct ssl_data *ssl = conn->layer;
 153   int error;
 154   if ((error = gnutls_handshake (ssl->session)) < 0)
 155     {
 156       if (gnutls_error_is_fatal (error))
 157         {
 158           g_critical ("Fatal error while doing TLS handshaking: %s\n",
 159                       gnutls_strerror (error));
 160           ssl->failed = TRUE;
 161         }
 162     }
 163   else
 164     {
 165       ssl->handshaking = FALSE;
 166       if (conn->func)
 167         conn->func (conn, HC_EVENT_CONNECT, conn->data);
 168     }
 169 }
 170
 171 static void
 172 ssl_server_connect (HCConn *conn)
 173 {
 174   struct ssl_data *ssl = conn->layer;
 175   gnutls_transport_set_ptr (ssl->session, (gnutls_transport_ptr_t) conn);
 176   gnutls_transport_set_push_function (ssl->session, ssl_push);
 177   gnutls_transport_set_pull_function (ssl->session, ssl_pull);
 178   ssl->handshaking = TRUE;
 179   ssl_server_handshake (conn);
 180 }
 181
 182 static void
 183 hc_conn_ssl_close (gpointer data)
 184 {
 185   struct ssl_data *ssl = data;
 186   if (ssl != NULL)
 187     {
 188       gnutls_bye (ssl->session, GNUTLS_SHUT_RDWR);
 189       hc_conn_close (ssl->lowconn);
 190       ssl_data_destroy (ssl);
 191     }
 192 }
 193
 194 static ssize_t
 195 hc_conn_ssl_read (gpointer data, gchar *buffer, size_t len)
 196 {
 197   struct ssl_data *ssl = data;
 198   return gnutls_record_recv (ssl->session, buffer, len);
 199 }
 200
 201 static ssize_t
 202 hc_conn_ssl_write (gpointer data, gchar *buffer, size_t len)
 203 {
 204   struct ssl_data *ssl = data;
 205   return gnutls_record_send (ssl->session, buffer, len);
 206 }
 207
 208 void
 209 hc_conn_ssl_watch (HCConn *conn, HCEvent event, gpointer data)
 210 {
 211   char buffer[4096];
 212   HCConn *ssl_conn = data;
 213   struct ssl_data *ssl = ssl_conn->layer;
 214   int r;
 215   switch (event)
 216     {
 217     case HC_EVENT_READ:
 218       if (ssl->handshaking)
 219         {
 220           ssl_server_handshake (ssl_conn);
 221           /* FIXME: create HC_CONN_ERROR */
 222           if (ssl->failed && ssl_conn->func)
 223             ssl_conn->func (ssl_conn, HC_EVENT_CLOSE, ssl_conn->data);
 224           return;
 225         }
 226       while ((r = hc_conn_read (ssl->lowconn, buffer, sizeof (buffer))) > 0)
 227         g_string_append_len (ssl->buffer, buffer, r);
 228       if (ssl_conn->func && !ssl->handshaking)
 229         ssl_conn->func (ssl_conn, event, ssl_conn->data);
 230       break;
 231     case HC_EVENT_CLOSE:
 232       if (ssl_conn->func)
 233         ssl_conn->func (ssl_conn, event, ssl_conn->data);
 234     }
 235 }
 236
 237 static int
 238 hc_conn_set_driver_ssl (HCConn *conn, HCConn *lowconn, int server)
 239 {
 240   struct ssl_data *ssl;
 241   ssl = ssl_data_new (server);
 242   if (ssl == NULL)
 243     return -1;
 244   ssl->lowconn = lowconn;
 245   conn->layer = ssl;
 246   conn->read = hc_conn_ssl_read;
 247   conn->write = hc_conn_ssl_write;
 248   conn->close = hc_conn_ssl_close;
 249   hc_conn_set_callback (lowconn, hc_conn_ssl_watch, conn);
 250   ssl_server_connect (conn);
 251   return 0;
 252 }
 253
 254 int
 255 hc_conn_set_driver_ssl_client (HCConn *conn, HCConn *lowconn)
 256 {
 257   return hc_conn_set_driver_ssl (conn, lowconn, 0);
 258 }
 259
 260 int
 261 hc_conn_set_driver_ssl_server (HCConn *conn, HCConn *lowconn)
 262 {
 263   return hc_conn_set_driver_ssl (conn, lowconn, 1);
 264 }
 265
 266 void
 267 hc_conn_ssl_server_set_priority (HCConn *conn, char *priority)
 268 {
 269   struct ssl_data *ssl;
 270   ssl = conn->layer;
 271   gnutls_priority_set_direct (ssl->session, priority, NULL);
 272 }