libempathy/empathy-tls-certificate.c

   1 /*
   2  * empathy-tls-certificate.c - Source for EmpathyTLSCertificate
   3  * Copyright (C) 2010 Collabora Ltd.
   4  * @author Cosimo Cecchi <cosimo.cecchi@collabora.co.uk>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  */
  20
  21 #include <config.h>
  22
  23 #include "empathy-tls-certificate.h"
  24
  25 #include <errno.h>
  26
  27 #include <glib/gstdio.h>
  28
  29 #include <gnutls/gnutls.h>
  30 #include <gnutls/x509.h>
  31
  32 #include <telepathy-glib/gtypes.h>
  33 #include <telepathy-glib/util.h>
  34
  35 #define DEBUG_FLAG EMPATHY_DEBUG_TLS
  36 #include "empathy-debug.h"
  37 #include "empathy-utils.h"
  38
  39 #include "extensions/extensions.h"
  40
  41 enum {
  42   /* proxy properties */
  43   PROP_CERT_TYPE = 1,
  44   PROP_CERT_DATA,
  45   PROP_STATE,
  46   LAST_PROPERTY,
  47 };
  48
  49 typedef struct {
  50   GSimpleAsyncResult *async_prepare_res;
  51
  52   /* TLSCertificate properties */
  53   gchar *cert_type;
  54   GPtrArray *cert_data;
  55   EmpTLSCertificateState state;
  56
  57   gboolean is_prepared;
  58 } EmpathyTLSCertificatePriv;
  59
  60 G_DEFINE_TYPE (EmpathyTLSCertificate, empathy_tls_certificate,
  61     TP_TYPE_PROXY);
  62
  63 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyTLSCertificate);
  64
  65 static void
  66 tls_certificate_got_all_cb (TpProxy *proxy,
  67     GHashTable *properties,
  68     const GError *error,
  69     gpointer user_data,
  70     GObject *weak_object)
  71 {
  72   GPtrArray *cert_data;
  73   EmpathyTLSCertificate *self = EMPATHY_TLS_CERTIFICATE (weak_object);
  74   EmpathyTLSCertificatePriv *priv = GET_PRIV (self);
  75
  76   if (error != NULL)
  77     {
  78       g_simple_async_result_set_from_error (priv->async_prepare_res, error);
  79       g_simple_async_result_complete (priv->async_prepare_res);
  80       tp_clear_object (&priv->async_prepare_res);
  81
  82       return;
  83     }
  84
  85   priv->cert_type = g_strdup (tp_asv_get_string (properties,
  86           "CertificateType"));
  87   priv->state = tp_asv_get_uint32 (properties, "State", NULL);
  88
  89   cert_data = tp_asv_get_boxed (properties, "CertificateChainData",
  90       TP_ARRAY_TYPE_UCHAR_ARRAY_LIST);
  91   g_assert (cert_data != NULL);
  92   priv->cert_data = g_boxed_copy (TP_ARRAY_TYPE_UCHAR_ARRAY_LIST, cert_data);
  93
  94   DEBUG ("Got a certificate chain long %u, of type %s",
  95       priv->cert_data->len, priv->cert_type);
  96
  97   priv->is_prepared = TRUE;
  98
  99   g_simple_async_result_complete (priv->async_prepare_res);
 100   tp_clear_object (&priv->async_prepare_res);
 101 }
 102
 103 void
 104 empathy_tls_certificate_prepare_async (EmpathyTLSCertificate *self,
 105     GAsyncReadyCallback callback,
 106     gpointer user_data)
 107 {
 108   EmpathyTLSCertificatePriv *priv = GET_PRIV (self);
 109
 110   /* emit an error if we're already preparing the object */
 111   if (priv->async_prepare_res != NULL)
 112     {
 113       g_simple_async_report_error_in_idle (G_OBJECT (self),
 114           callback, user_data,
 115           G_IO_ERROR, G_IO_ERROR_PENDING,
 116           "%s",
 117           "Prepare operation already in progress on the TLS certificate.");
 118
 119       return;
 120     }
 121
 122   /* if the object is already prepared, just complete in idle */
 123   if (priv->is_prepared)
 124     {
 125       tp_simple_async_report_success_in_idle (G_OBJECT (self),
 126           callback, user_data, empathy_tls_certificate_prepare_async);
 127
 128       return;
 129     }
 130
 131   priv->async_prepare_res = g_simple_async_result_new (G_OBJECT (self),
 132       callback, user_data, empathy_tls_certificate_prepare_async);
 133
 134   /* call GetAll() on the certificate */
 135   tp_cli_dbus_properties_call_get_all (self,
 136       -1, EMP_IFACE_AUTHENTICATION_TLS_CERTIFICATE,
 137       tls_certificate_got_all_cb, NULL, NULL,
 138       G_OBJECT (self));
 139 }
 140
 141 gboolean
 142 empathy_tls_certificate_prepare_finish (EmpathyTLSCertificate *self,
 143     GAsyncResult *result,
 144     GError **error)
 145 {
 146   gboolean retval = TRUE;
 147
 148   if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
 149           error))
 150     retval = FALSE;
 151
 152   return retval;
 153 }
 154
 155 static void
 156 empathy_tls_certificate_finalize (GObject *object)
 157 {
 158   EmpathyTLSCertificatePriv *priv = GET_PRIV (object);
 159
 160   DEBUG ("%p", object);
 161
 162   g_free (priv->cert_type);
 163   tp_clear_boxed (TP_ARRAY_TYPE_UCHAR_ARRAY_LIST, &priv->cert_data);
 164
 165   G_OBJECT_CLASS (empathy_tls_certificate_parent_class)->finalize (object);
 166 }
 167
 168 static void
 169 empathy_tls_certificate_get_property (GObject *object,
 170     guint property_id,
 171     GValue *value,
 172     GParamSpec *pspec)
 173 {
 174   EmpathyTLSCertificatePriv *priv = GET_PRIV (object);
 175
 176   switch (property_id)
 177     {
 178     case PROP_CERT_TYPE:
 179       g_value_set_string (value, priv->cert_type);
 180       break;
 181     case PROP_CERT_DATA:
 182       g_value_set_boxed (value, priv->cert_data);
 183       break;
 184     case PROP_STATE:
 185       g_value_set_uint (value, priv->state);
 186       break;
 187     default:
 188       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 189       break;
 190     }
 191 }
 192
 193 static void
 194 empathy_tls_certificate_init (EmpathyTLSCertificate *self)
 195 {
 196   self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
 197       EMPATHY_TYPE_TLS_CERTIFICATE, EmpathyTLSCertificatePriv);
 198 }
 199
 200 static void
 201 empathy_tls_certificate_class_init (EmpathyTLSCertificateClass *klass)
 202 {
 203   GParamSpec *pspec;
 204   GObjectClass *oclass = G_OBJECT_CLASS (klass);
 205   TpProxyClass *pclass = TP_PROXY_CLASS (klass);
 206
 207   oclass->get_property = empathy_tls_certificate_get_property;
 208   oclass->finalize = empathy_tls_certificate_finalize;
 209
 210   pclass->interface = EMP_IFACE_QUARK_AUTHENTICATION_TLS_CERTIFICATE;
 211   pclass->must_have_unique_name = TRUE;
 212
 213   g_type_class_add_private (klass, sizeof (EmpathyTLSCertificatePriv));
 214
 215   pspec = g_param_spec_string ("cert-type", "Certificate type",
 216       "The type of this certificate.",
 217       NULL,
 218       G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 219   g_object_class_install_property (oclass, PROP_CERT_TYPE, pspec);
 220
 221   pspec = g_param_spec_boxed ("cert-data", "Certificate chain data",
 222       "The raw DER-encoded certificate chain data.",
 223       TP_ARRAY_TYPE_UCHAR_ARRAY_LIST,
 224       G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 225   g_object_class_install_property (oclass, PROP_CERT_DATA, pspec);
 226
 227   pspec = g_param_spec_uint ("state", "State",
 228       "The state of this certificate.",
 229       EMP_TLS_CERTIFICATE_STATE_PENDING, NUM_EMP_TLS_CERTIFICATE_STATES -1,
 230       EMP_TLS_CERTIFICATE_STATE_PENDING,
 231       G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 232   g_object_class_install_property (oclass, PROP_STATE, pspec);
 233 }
 234
 235 static void
 236 cert_proxy_accept_cb (TpProxy *proxy,
 237     const GError *error,
 238     gpointer user_data,
 239     GObject *weak_object)
 240 {
 241   GSimpleAsyncResult *accept_result = user_data;
 242
 243   DEBUG ("Callback for accept(), error %p", error);
 244
 245   if (error != NULL)
 246     {
 247       DEBUG ("Error was %s", error->message);
 248       g_simple_async_result_set_from_error (accept_result, error);
 249     }
 250
 251   g_simple_async_result_complete (accept_result);
 252 }
 253
 254 static void
 255 cert_proxy_reject_cb (TpProxy *proxy,
 256     const GError *error,
 257     gpointer user_data,
 258     GObject *weak_object)
 259 {
 260   GSimpleAsyncResult *reject_result = user_data;
 261
 262   DEBUG ("Callback for reject(), error %p", error);
 263
 264   if (error != NULL)
 265     {
 266       DEBUG ("Error was %s", error->message);
 267       g_simple_async_result_set_from_error (reject_result, error);
 268     }
 269
 270   g_simple_async_result_complete (reject_result);
 271 }
 272
 273 static const gchar *
 274 reject_reason_get_dbus_error (EmpTLSCertificateRejectReason reason)
 275 {
 276   const gchar *retval = NULL;
 277
 278   switch (reason)
 279     {
 280     case EMP_TLS_CERTIFICATE_REJECT_REASON_UNTRUSTED:
 281       retval = tp_error_get_dbus_name (TP_ERROR_CERT_UNTRUSTED);
 282       break;
 283     case EMP_TLS_CERTIFICATE_REJECT_REASON_EXPIRED:
 284       retval = tp_error_get_dbus_name (TP_ERROR_CERT_EXPIRED);
 285       break;
 286     case EMP_TLS_CERTIFICATE_REJECT_REASON_NOT_ACTIVATED:
 287       retval = tp_error_get_dbus_name (TP_ERROR_CERT_NOT_ACTIVATED);
 288       break;
 289     case EMP_TLS_CERTIFICATE_REJECT_REASON_FINGERPRINT_MISMATCH:
 290       retval = tp_error_get_dbus_name (TP_ERROR_CERT_FINGERPRINT_MISMATCH);
 291       break;
 292     case EMP_TLS_CERTIFICATE_REJECT_REASON_HOSTNAME_MISMATCH:
 293       retval = tp_error_get_dbus_name (TP_ERROR_CERT_HOSTNAME_MISMATCH);
 294       break;
 295     case EMP_TLS_CERTIFICATE_REJECT_REASON_SELF_SIGNED:
 296       retval = tp_error_get_dbus_name (TP_ERROR_CERT_SELF_SIGNED);
 297       break;
 298     case EMP_TLS_CERTIFICATE_REJECT_REASON_REVOKED:
 299       retval = tp_error_get_dbus_name (TP_ERROR_CERT_REVOKED);
 300       break;
 301     case EMP_TLS_CERTIFICATE_REJECT_REASON_INSECURE:
 302       retval = tp_error_get_dbus_name (TP_ERROR_CERT_INSECURE);
 303       break;
 304     case EMP_TLS_CERTIFICATE_REJECT_REASON_LIMIT_EXCEEDED:
 305       retval = tp_error_get_dbus_name (TP_ERROR_CERT_LIMIT_EXCEEDED);
 306       break;
 307     case EMP_TLS_CERTIFICATE_REJECT_REASON_UNKNOWN:
 308     default:
 309       retval = tp_error_get_dbus_name (TP_ERROR_CERT_INVALID);
 310       break;
 311     }
 312
 313   return retval;
 314 }
 315
 316 EmpathyTLSCertificate *
 317 empathy_tls_certificate_new (TpDBusDaemon *dbus,
 318     const gchar *bus_name,
 319     const gchar *object_path,
 320     GError **error)
 321 {
 322   EmpathyTLSCertificate *retval = NULL;
 323
 324   if (!tp_dbus_check_valid_bus_name (bus_name,
 325           TP_DBUS_NAME_TYPE_UNIQUE, error))
 326     goto finally;
 327
 328   if (!tp_dbus_check_valid_object_path (object_path, error))
 329     goto finally;
 330
 331   retval = g_object_new (EMPATHY_TYPE_TLS_CERTIFICATE,
 332       "dbus-daemon", dbus,
 333       "bus-name", bus_name,
 334       "object-path", object_path,
 335       NULL);
 336
 337 finally:
 338   if (*error != NULL)
 339     DEBUG ("Error while creating the TLS certificate: %s",
 340         (*error)->message);
 341
 342   return retval;
 343 }
 344
 345 void
 346 empathy_tls_certificate_accept_async (EmpathyTLSCertificate *self,
 347     GAsyncReadyCallback callback,
 348     gpointer user_data)
 349 {
 350   GSimpleAsyncResult *accept_result;
 351
 352   g_assert (EMPATHY_IS_TLS_CERTIFICATE (self));
 353
 354   DEBUG ("Accepting TLS certificate");
 355
 356   accept_result = g_simple_async_result_new (G_OBJECT (self),
 357       callback, user_data, empathy_tls_certificate_accept_async);
 358
 359   emp_cli_authentication_tls_certificate_call_accept (TP_PROXY (self),
 360       -1, cert_proxy_accept_cb,
 361       accept_result, g_object_unref,
 362       G_OBJECT (self));
 363 }
 364
 365 gboolean
 366 empathy_tls_certificate_accept_finish (EmpathyTLSCertificate *self,
 367     GAsyncResult *result,
 368     GError **error)
 369 {
 370   if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
 371           error))
 372     return FALSE;
 373
 374   return TRUE;
 375 }
 376
 377 static GPtrArray *
 378 build_rejections_array (EmpTLSCertificateRejectReason reason,
 379     GHashTable *details)
 380 {
 381   GPtrArray *retval;
 382   GValueArray *rejection;
 383
 384   retval = g_ptr_array_new ();
 385   rejection = tp_value_array_build (3,
 386       G_TYPE_UINT, reason,
 387       G_TYPE_STRING, reject_reason_get_dbus_error (reason),
 388       TP_HASH_TYPE_STRING_VARIANT_MAP, details,
 389       NULL);
 390
 391   g_ptr_array_add (retval, rejection);
 392
 393   return retval;
 394 }
 395
 396 void
 397 empathy_tls_certificate_reject_async (EmpathyTLSCertificate *self,
 398     EmpTLSCertificateRejectReason reason,
 399     GHashTable *details,
 400     GAsyncReadyCallback callback,
 401     gpointer user_data)
 402 {
 403   GPtrArray *rejections;
 404   GSimpleAsyncResult *reject_result;
 405
 406   g_assert (EMPATHY_IS_TLS_CERTIFICATE (self));
 407
 408   DEBUG ("Rejecting TLS certificate with reason %u", reason);
 409
 410   rejections = build_rejections_array (reason, details);
 411   reject_result = g_simple_async_result_new (G_OBJECT (self),
 412       callback, user_data, empathy_tls_certificate_reject_async);
 413
 414   emp_cli_authentication_tls_certificate_call_reject (TP_PROXY (self),
 415       -1, rejections, cert_proxy_reject_cb,
 416       reject_result, g_object_unref, G_OBJECT (self));
 417
 418   tp_clear_boxed (EMP_ARRAY_TYPE_TLS_CERTIFICATE_REJECTION_LIST,
 419       &rejections);
 420 }
 421
 422 gboolean
 423 empathy_tls_certificate_reject_finish (EmpathyTLSCertificate *self,
 424     GAsyncResult *result,
 425     GError **error)
 426 {
 427   if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
 428           error))
 429     return FALSE;
 430
 431   return TRUE;
 432 }
 433
 434 static gsize
 435 get_exported_size (gnutls_x509_crt_t cert)
 436 {
 437   gsize retval = 2;
 438   guchar fake[2] = { 0, 0 };
 439
 440   /* fake an export so we get the size to allocate */
 441   gnutls_x509_crt_export (cert, GNUTLS_X509_FMT_PEM,
 442       fake, &retval);
 443
 444   DEBUG ("Should allocate %lu bytes", (gulong) retval);
 445
 446   return retval + 1;
 447 }
 448
 449 void
 450 empathy_tls_certificate_store_ca (EmpathyTLSCertificate *self)
 451 {
 452   GArray *last_cert;
 453   gnutls_x509_crt_t cert;
 454   gnutls_datum_t datum = { NULL, 0 };
 455   gsize exported_len;
 456   guchar *exported_cert = NULL;
 457   gint res, offset;
 458   gchar *user_certs_dir = NULL, *filename = NULL, *path = NULL;
 459   gchar *hostname = NULL;
 460   GError *error = NULL;
 461   EmpathyTLSCertificatePriv *priv = GET_PRIV (self);
 462
 463   last_cert = g_ptr_array_index (priv->cert_data, priv->cert_data->len - 1);
 464   datum.data = (guchar *) last_cert->data;
 465   datum.size = last_cert->len;
 466
 467   gnutls_x509_crt_init (&cert);
 468   gnutls_x509_crt_import (cert, &datum, GNUTLS_X509_FMT_DER);
 469
 470   /* make sure it's self-signed, otherwise it's not a CA */
 471   if (gnutls_x509_crt_check_issuer (cert, cert) <= 0)
 472     {
 473       DEBUG ("Can't import the CA, as it's not self-signed");
 474       gnutls_x509_crt_deinit (cert);
 475
 476       return;
 477     }
 478
 479   if (gnutls_x509_crt_get_ca_status (cert, NULL) <= 0)
 480     {
 481       DEBUG ("Can't import the CA, it's not a valid CA certificate");
 482       gnutls_x509_crt_deinit (cert);
 483
 484       goto out;
 485     }
 486
 487   exported_len = get_exported_size (cert);
 488   exported_cert = g_malloc (sizeof (guchar) * exported_len);
 489
 490   res = gnutls_x509_crt_export (cert, GNUTLS_X509_FMT_PEM,
 491       exported_cert, &exported_len);
 492
 493   if (res < 0)
 494     {
 495       DEBUG ("Failed to export the CA certificate; GnuTLS returned %d,"
 496           "and should be %lu bytes long", res, (gulong) exported_len);
 497       gnutls_x509_crt_deinit (cert);
 498
 499       goto out;
 500     }
 501
 502   hostname = empathy_get_x509_certificate_hostname (cert);
 503
 504   if (hostname == NULL)
 505     hostname = g_strdup ("ca");
 506
 507   gnutls_x509_crt_deinit (cert);
 508
 509   /* write the file */
 510   user_certs_dir = g_build_filename (g_get_user_config_dir (),
 511       "telepathy", "certs", NULL);
 512
 513   res = g_mkdir_with_parents (user_certs_dir, S_IRWXU | S_IRWXG);
 514
 515   if (res < 0)
 516     {
 517       DEBUG ("Failed to create the user certificate directory: %s",
 518           g_strerror (errno));
 519
 520       goto out;
 521     }
 522
 523   offset = 0;
 524
 525   do
 526     {
 527       g_free (path);
 528
 529       if (offset == 0)
 530         filename = g_strdup_printf ("cert-%s", hostname);
 531       else
 532         filename = g_strdup_printf ("cert-%s-%d", hostname, offset);
 533
 534       path = g_build_filename (user_certs_dir, filename, NULL);
 535
 536       offset++;
 537       g_free (filename);
 538     }
 539   while (g_file_test (path, G_FILE_TEST_EXISTS));
 540
 541   DEBUG ("Will save to %s", path);
 542
 543   g_file_set_contents (path, (const gchar *) exported_cert, exported_len,
 544       &error);
 545
 546   if (error != NULL)
 547     {
 548       DEBUG ("Can't save the CA certificate to %s: %s",
 549           path, error->message);
 550
 551       g_error_free (error);
 552     }
 553
 554  out:
 555   g_free (path);
 556   g_free (exported_cert);
 557   g_free (user_certs_dir);
 558   g_free (hostname);
 559 }