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/proxy-subclass.h>
  33
  34 #define DEBUG_FLAG EMPATHY_DEBUG_TLS
  35 #include "empathy-debug.h"
  36 #include "empathy-utils.h"
  37
  38 #include "extensions/extensions.h"
  39
  40 static void async_initable_iface_init (GAsyncInitableIface *iface);
  41
  42 enum {
  43   PROP_OBJECT_PATH = 1,
  44   PROP_BUS_NAME,
  45
  46   /* proxy properties */
  47   PROP_CERT_TYPE,
  48   PROP_CERT_DATA,
  49   PROP_STATE,
  50   LAST_PROPERTY,
  51 };
  52
  53 typedef struct {
  54   gchar *object_path;
  55   gchar *bus_name;
  56
  57   TpProxy *proxy;
  58
  59   GSimpleAsyncResult *async_init_res;
  60
  61   /* TLSCertificate properties */
  62   gchar *cert_type;
  63   GPtrArray *cert_data;
  64   EmpTLSCertificateState state;
  65 } EmpathyTLSCertificatePriv;
  66
  67 G_DEFINE_TYPE_WITH_CODE (EmpathyTLSCertificate, empathy_tls_certificate,
  68     G_TYPE_OBJECT,
  69     G_IMPLEMENT_INTERFACE (G_TYPE_ASYNC_INITABLE, async_initable_iface_init));
  70
  71 #define GET_PRIV(obj) EMPATHY_GET_PRIV (obj, EmpathyTLSCertificate);
  72
  73 static gboolean
  74 tls_certificate_init_finish (GAsyncInitable *initable,
  75     GAsyncResult *res,
  76     GError **error)
  77 {
  78   gboolean retval = TRUE;
  79   EmpathyTLSCertificate *self = EMPATHY_TLS_CERTIFICATE (initable);
  80   EmpathyTLSCertificatePriv *priv = GET_PRIV (self);
  81
  82   if (g_simple_async_result_propagate_error (priv->async_init_res, error))
  83     retval = FALSE;
  84
  85   return retval;
  86 }
  87
  88 static GType
  89 array_of_ay_get_type (void)
  90 {
  91   static GType t = 0;
  92
  93   if (G_UNLIKELY (t == 0))
  94     {
  95       t = dbus_g_type_get_collection ("GPtrArray",
  96           dbus_g_type_get_collection ("GArray",
  97               G_TYPE_UCHAR));
  98     }
  99
 100   return t;
 101 }
 102
 103 static void
 104 tls_certificate_got_all_cb (TpProxy *proxy,
 105     GHashTable *properties,
 106     const GError *error,
 107     gpointer user_data,
 108     GObject *weak_object)
 109 {
 110   GPtrArray *cert_data;
 111   EmpathyTLSCertificate *self = EMPATHY_TLS_CERTIFICATE (weak_object);
 112   EmpathyTLSCertificatePriv *priv = GET_PRIV (self);
 113
 114   if (error != NULL)
 115     {
 116       g_simple_async_result_set_from_error (priv->async_init_res, error);
 117       g_simple_async_result_complete_in_idle (priv->async_init_res);
 118
 119       g_object_unref (priv->async_init_res);
 120
 121       return;
 122     }
 123
 124   priv->cert_type = g_strdup (tp_asv_get_string (properties,
 125           "CertificateType"));
 126   priv->state = tp_asv_get_uint32 (properties, "State", NULL);
 127
 128   cert_data = tp_asv_get_boxed (properties, "CertificateChainData",
 129       array_of_ay_get_type ());
 130   g_assert (cert_data != NULL);
 131   priv->cert_data = g_boxed_copy (array_of_ay_get_type (), cert_data);
 132
 133   DEBUG ("Got a certificate chain long %u, of type %s",
 134       priv->cert_data->len, priv->cert_type);
 135
 136   g_simple_async_result_complete_in_idle (priv->async_init_res);
 137   g_object_unref (priv->async_init_res);
 138 }
 139
 140 static void
 141 tls_certificate_init_async (GAsyncInitable *initable,
 142     gint io_priority,
 143     GCancellable *cancellable,
 144     GAsyncReadyCallback callback,
 145     gpointer user_data)
 146 {
 147   TpDBusDaemon *dbus;
 148   GError *error = NULL;
 149   EmpathyTLSCertificate *self = EMPATHY_TLS_CERTIFICATE (initable);
 150   EmpathyTLSCertificatePriv *priv = GET_PRIV (self);
 151
 152   g_assert (priv->object_path != NULL);
 153   g_assert (priv->bus_name != NULL);
 154
 155   priv->async_init_res = g_simple_async_result_new (G_OBJECT (self),
 156       callback, user_data, empathy_tls_certificate_new_async);
 157   dbus = tp_dbus_daemon_dup (&error);
 158
 159   if (error != NULL)
 160     {
 161       g_simple_async_result_set_from_error (priv->async_init_res, error);
 162       g_simple_async_result_complete_in_idle (priv->async_init_res);
 163
 164       g_error_free (error);
 165       g_object_unref (priv->async_init_res);
 166       return;
 167     }
 168
 169   DEBUG ("Creating a proxy for object at path %s, owned by %s",
 170       priv->object_path, priv->bus_name);
 171
 172   priv->proxy = g_object_new (TP_TYPE_PROXY,
 173       "object-path", priv->object_path,
 174       "bus-name", priv->bus_name,
 175       "dbus-daemon", dbus, NULL);
 176
 177   tp_proxy_add_interface_by_id (priv->proxy,
 178       EMP_IFACE_QUARK_AUTHENTICATION_TLS_CERTIFICATE);
 179
 180   /* call GetAll() on the certificate */
 181   tp_cli_dbus_properties_call_get_all (priv->proxy,
 182       -1, EMP_IFACE_AUTHENTICATION_TLS_CERTIFICATE,
 183       tls_certificate_got_all_cb, NULL, NULL, G_OBJECT (self));
 184
 185   g_object_unref (dbus);
 186 }
 187
 188 static void
 189 async_initable_iface_init (GAsyncInitableIface *iface)
 190 {
 191   iface->init_async = tls_certificate_init_async;
 192   iface->init_finish = tls_certificate_init_finish;
 193 }
 194
 195 static void
 196 empathy_tls_certificate_finalize (GObject *object)
 197 {
 198   EmpathyTLSCertificatePriv *priv = GET_PRIV (object);
 199
 200   DEBUG ("%p", object);
 201
 202   g_free (priv->object_path);
 203
 204   G_OBJECT_CLASS (empathy_tls_certificate_parent_class)->finalize (object);
 205 }
 206
 207 static void
 208 empathy_tls_certificate_get_property (GObject *object,
 209     guint property_id,
 210     GValue *value,
 211     GParamSpec *pspec)
 212 {
 213   EmpathyTLSCertificatePriv *priv = GET_PRIV (object);
 214
 215   switch (property_id)
 216     {
 217     case PROP_OBJECT_PATH:
 218       g_value_set_string (value, priv->object_path);
 219       break;
 220     case PROP_BUS_NAME:
 221       g_value_set_string (value, priv->bus_name);
 222       break;
 223     case PROP_CERT_TYPE:
 224       g_value_set_string (value, priv->cert_type);
 225       break;
 226     case PROP_CERT_DATA:
 227       g_value_set_boxed (value, priv->cert_data);
 228       break;
 229     case PROP_STATE:
 230       g_value_set_uint (value, priv->state);
 231       break;
 232     default:
 233       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 234       break;
 235     }
 236 }
 237
 238 static void
 239 empathy_tls_certificate_set_property (GObject *object,
 240     guint property_id,
 241     const GValue *value,
 242     GParamSpec *pspec)
 243 {
 244   EmpathyTLSCertificatePriv *priv = GET_PRIV (object);
 245
 246   switch (property_id)
 247     {
 248     case PROP_OBJECT_PATH:
 249       priv->object_path = g_value_dup_string (value);
 250       break;
 251     case PROP_BUS_NAME:
 252       priv->bus_name = g_value_dup_string (value);
 253       break;
 254     default:
 255       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 256       break;
 257     }
 258 }
 259
 260 static void
 261 empathy_tls_certificate_init (EmpathyTLSCertificate *self)
 262 {
 263   self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
 264       EMPATHY_TYPE_TLS_CERTIFICATE, EmpathyTLSCertificatePriv);
 265 }
 266
 267 static void
 268 empathy_tls_certificate_class_init (EmpathyTLSCertificateClass *klass)
 269 {
 270   GParamSpec *pspec;
 271   GObjectClass *oclass = G_OBJECT_CLASS (klass);
 272
 273   oclass->get_property = empathy_tls_certificate_get_property;
 274   oclass->set_property = empathy_tls_certificate_set_property;
 275   oclass->finalize = empathy_tls_certificate_finalize;
 276
 277   g_type_class_add_private (klass, sizeof (EmpathyTLSCertificatePriv));
 278
 279   pspec = g_param_spec_string ("object-path", "The object path",
 280       "The path on the bus where the object we proxy is living.",
 281       NULL,
 282       G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
 283   g_object_class_install_property (oclass, PROP_OBJECT_PATH, pspec);
 284
 285   pspec = g_param_spec_string ("bus-name", "The bus name",
 286       "The bus name owning this certificate.",
 287       NULL,
 288       G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
 289   g_object_class_install_property (oclass, PROP_BUS_NAME, pspec);
 290
 291   pspec = g_param_spec_string ("cert-type", "Certificate type",
 292       "The type of this certificate.",
 293       NULL,
 294       G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 295   g_object_class_install_property (oclass, PROP_CERT_TYPE, pspec);
 296
 297   pspec = g_param_spec_boxed ("cert-data", "Certificate chain data",
 298       "The raw DER-encoded certificate chain data.",
 299       array_of_ay_get_type (),
 300       G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 301   g_object_class_install_property (oclass, PROP_CERT_DATA, pspec);
 302
 303   pspec = g_param_spec_uint ("state", "State",
 304       "The state of this certificate.",
 305       EMP_TLS_CERTIFICATE_STATE_PENDING, NUM_EMP_TLS_CERTIFICATE_STATES -1,
 306       EMP_TLS_CERTIFICATE_STATE_PENDING,
 307       G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 308   g_object_class_install_property (oclass, PROP_STATE, pspec);
 309 }
 310
 311 static void
 312 cert_proxy_accept_cb (TpProxy *proxy,
 313     const GError *error,
 314     gpointer user_data,
 315     GObject *weak_object)
 316 {
 317   GSimpleAsyncResult *accept_result = user_data;
 318
 319   DEBUG ("Callback for accept(), error %p", error);
 320
 321   if (error != NULL)
 322     {
 323       DEBUG ("Error was %s", error->message);
 324       g_simple_async_result_set_from_error (accept_result, error);
 325     }
 326
 327   g_simple_async_result_complete (accept_result);
 328 }
 329
 330 static void
 331 cert_proxy_reject_cb (TpProxy *proxy,
 332     const GError *error,
 333     gpointer user_data,
 334     GObject *weak_object)
 335 {
 336   GSimpleAsyncResult *reject_result = user_data;
 337
 338   DEBUG ("Callback for reject(), error %p", error);
 339
 340   if (error != NULL)
 341     {
 342       DEBUG ("Error was %s", error->message);
 343       g_simple_async_result_set_from_error (reject_result, error);
 344     }
 345
 346   g_simple_async_result_complete (reject_result);
 347 }
 348
 349 static const gchar *
 350 reject_reason_get_dbus_error (EmpTLSCertificateRejectReason reason)
 351 {
 352   const gchar *retval = NULL;
 353
 354   switch (reason)
 355     {
 356     case EMP_TLS_CERTIFICATE_REJECT_REASON_UNTRUSTED:
 357       retval = tp_error_get_dbus_name (TP_ERROR_CERT_UNTRUSTED);
 358       break;
 359     case EMP_TLS_CERTIFICATE_REJECT_REASON_EXPIRED:
 360       retval = tp_error_get_dbus_name (TP_ERROR_CERT_EXPIRED);
 361       break;
 362     case EMP_TLS_CERTIFICATE_REJECT_REASON_NOT_ACTIVATED:
 363       retval = tp_error_get_dbus_name (TP_ERROR_CERT_NOT_ACTIVATED);
 364       break;
 365     case EMP_TLS_CERTIFICATE_REJECT_REASON_FINGERPRINT_MISMATCH:
 366       retval = tp_error_get_dbus_name (TP_ERROR_CERT_FINGERPRINT_MISMATCH);
 367       break;
 368     case EMP_TLS_CERTIFICATE_REJECT_REASON_HOSTNAME_MISMATCH:
 369       retval = tp_error_get_dbus_name (TP_ERROR_CERT_HOSTNAME_MISMATCH);
 370       break;
 371     case EMP_TLS_CERTIFICATE_REJECT_REASON_SELF_SIGNED:
 372       retval = tp_error_get_dbus_name (TP_ERROR_CERT_SELF_SIGNED);
 373       break;
 374     case EMP_TLS_CERTIFICATE_REJECT_REASON_REVOKED:
 375       retval = tp_error_get_dbus_name (TP_ERROR_CERT_REVOKED);
 376       break;
 377     case EMP_TLS_CERTIFICATE_REJECT_REASON_INSECURE:
 378       retval = tp_error_get_dbus_name (TP_ERROR_CERT_INSECURE);
 379       break;
 380     case EMP_TLS_CERTIFICATE_REJECT_REASON_LIMIT_EXCEEDED:
 381       retval = tp_error_get_dbus_name (TP_ERROR_CERT_LIMIT_EXCEEDED);
 382       break;
 383     case EMP_TLS_CERTIFICATE_REJECT_REASON_UNKNOWN:
 384     default:
 385       retval = tp_error_get_dbus_name (TP_ERROR_CERT_INVALID);
 386       break;
 387     }
 388
 389   return retval;
 390 }
 391
 392 void
 393 empathy_tls_certificate_new_async (const gchar *bus_name,
 394     const gchar *object_path,
 395     GAsyncReadyCallback callback,
 396     gpointer user_data)
 397 {
 398   g_assert (object_path != NULL);
 399
 400   g_async_initable_new_async (EMPATHY_TYPE_TLS_CERTIFICATE,
 401       G_PRIORITY_DEFAULT, NULL, callback, user_data,
 402       "bus-name", bus_name,
 403       "object-path", object_path, NULL);
 404 }
 405
 406 EmpathyTLSCertificate *
 407 empathy_tls_certificate_new_finish (GAsyncResult *res,
 408     GError **error)
 409 {
 410   GObject *object, *source_object;
 411
 412   source_object = g_async_result_get_source_object (res);
 413
 414   object = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object),
 415       res, error);
 416   g_object_unref (source_object);
 417
 418   if (object != NULL)
 419     return EMPATHY_TLS_CERTIFICATE (object);
 420   else
 421     return NULL;
 422 }
 423
 424 void
 425 empathy_tls_certificate_accept_async (EmpathyTLSCertificate *self,
 426     GAsyncReadyCallback callback,
 427     gpointer user_data)
 428 {
 429   GSimpleAsyncResult *accept_result;
 430   EmpathyTLSCertificatePriv *priv = GET_PRIV (self);
 431
 432   g_assert (EMPATHY_IS_TLS_CERTIFICATE (self));
 433
 434   DEBUG ("Accepting TLS certificate");
 435
 436   accept_result = g_simple_async_result_new (G_OBJECT (self),
 437       callback, user_data, empathy_tls_certificate_accept_async);
 438
 439   emp_cli_authentication_tls_certificate_call_accept (priv->proxy,
 440       -1, cert_proxy_accept_cb,
 441       accept_result, g_object_unref,
 442       G_OBJECT (self));
 443 }
 444
 445 gboolean
 446 empathy_tls_certificate_accept_finish (EmpathyTLSCertificate *self,
 447     GAsyncResult *result,
 448     GError **error)
 449 {
 450   if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
 451           error))
 452     return FALSE;
 453
 454   return TRUE;
 455 }
 456
 457 void
 458 empathy_tls_certificate_reject_async (EmpathyTLSCertificate *self,
 459     EmpTLSCertificateRejectReason reason,
 460     gboolean user_requested,
 461     GAsyncReadyCallback callback,
 462     gpointer user_data)
 463 {
 464   GHashTable *details;
 465   const gchar *dbus_error;
 466   GSimpleAsyncResult *reject_result;
 467   EmpathyTLSCertificatePriv *priv = GET_PRIV (self);
 468
 469   g_assert (EMPATHY_IS_TLS_CERTIFICATE (self));
 470
 471   DEBUG ("Rejecting TLS certificate with reason %u", reason);
 472
 473   dbus_error = reject_reason_get_dbus_error (reason);
 474   details = tp_asv_new ("user-requested", G_TYPE_BOOLEAN, user_requested,
 475       NULL);
 476   reject_result = g_simple_async_result_new (G_OBJECT (self),
 477       callback, user_data, empathy_tls_certificate_reject_async);
 478
 479   emp_cli_authentication_tls_certificate_call_reject (priv->proxy,
 480       -1, reason, dbus_error, details, cert_proxy_reject_cb,
 481       reject_result, g_object_unref, G_OBJECT (self));
 482
 483   g_hash_table_unref (details);
 484 }
 485
 486 gboolean
 487 empathy_tls_certificate_reject_finish (EmpathyTLSCertificate *self,
 488     GAsyncResult *result,
 489     GError **error)
 490 {
 491   if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
 492           error))
 493     return FALSE;
 494
 495   return TRUE;
 496 }
 497
 498 static gsize
 499 get_exported_size (gnutls_x509_crt_t cert)
 500 {
 501   gsize retval;
 502   guchar fake;
 503
 504   /* fake an export so we get the size to allocate */
 505   gnutls_x509_crt_export (cert, GNUTLS_X509_FMT_PEM,
 506       &fake, &retval);
 507
 508   DEBUG ("Should allocate %lu bytes", (gulong) retval);
 509
 510   return retval;
 511 }
 512
 513 void
 514 empathy_tls_certificate_store_ca (EmpathyTLSCertificate *self)
 515 {
 516   GArray *last_cert;
 517   gnutls_x509_crt_t cert;
 518   gnutls_datum_t datum = { NULL, 0 };
 519   gsize exported_len;
 520   guchar *exported_cert = NULL;
 521   gint res;
 522   gchar *user_certs_dir = NULL, *filename = NULL, *path = NULL;
 523   GError *error = NULL;
 524   EmpathyTLSCertificatePriv *priv = GET_PRIV (self);
 525
 526   last_cert = g_ptr_array_index (priv->cert_data, priv->cert_data->len - 1);
 527   datum.data = (guchar *) last_cert->data;
 528   datum.size = last_cert->len;
 529
 530   gnutls_x509_crt_init (&cert);
 531   gnutls_x509_crt_import (cert, &datum, GNUTLS_X509_FMT_DER);
 532
 533   /* make sure it's self-signed, otherwise it's not a CA */
 534   if (gnutls_x509_crt_check_issuer (cert, cert) <= 0)
 535     {
 536       DEBUG ("Can't import the CA, as it's not self-signed");
 537       gnutls_x509_crt_deinit (cert);
 538
 539       return;
 540     }
 541
 542   if (gnutls_x509_crt_get_ca_status (cert, NULL) <= 0)
 543     {
 544       DEBUG ("Can't import the CA, it's not a valid CA certificate");
 545       gnutls_x509_crt_deinit (cert);
 546
 547       goto out;
 548     }
 549
 550   exported_len = get_exported_size (cert);
 551   exported_cert = g_malloc (sizeof (guchar) * exported_len);
 552
 553   res = gnutls_x509_crt_export (cert, GNUTLS_X509_FMT_PEM,
 554       exported_cert, &exported_len);
 555
 556   if (res < 0)
 557     {
 558       DEBUG ("Failed to export the CA certificate; GnuTLS returned %d", res);
 559       gnutls_x509_crt_deinit (cert);
 560
 561       goto out;
 562     }
 563
 564   gnutls_x509_crt_deinit (cert);
 565
 566   /* write the file */
 567   user_certs_dir = g_build_filename (g_get_user_config_dir (),
 568       "telepathy", "certs", NULL);
 569
 570   res = g_mkdir_with_parents (user_certs_dir, S_IRWXU | S_IRWXG);
 571
 572   if (res < 0)
 573     {
 574       DEBUG ("Failed to create the user certificate directory: %s",
 575           g_strerror (errno));
 576
 577       goto out;
 578     }
 579
 580   do
 581     {
 582       g_free (path);
 583
 584       filename = g_strdup_printf ("cert-%p", cert);
 585       path = g_build_filename (user_certs_dir, filename, NULL);
 586
 587       g_free (filename);
 588     }
 589   while (g_file_test (path, G_FILE_TEST_EXISTS));
 590
 591   DEBUG ("Will save to %s", path);
 592
 593   g_file_set_contents (path, (const gchar *) exported_cert, exported_len,
 594       &error);
 595
 596   if (error != NULL)
 597     {
 598       DEBUG ("Can't save the CA certificate to %s: %s",
 599           path, error->message);
 600
 601       g_error_free (error);
 602     }
 603
 604  out:
 605   g_free (path);
 606   g_free (exported_cert);
 607   g_free (user_certs_dir);
 608 }