tests/empathy-tls-test.c

   1 #include <gnutls/gnutls.h>
   2 #include <telepathy-glib/telepathy-glib.h>
   3 #include <telepathy-glib/telepathy-glib-dbus.h>
   4
   5 #include "empathy-tls-verifier.h"
   6 #include "mock-pkcs11.h"
   7 #include "test-helper.h"
   8
   9 #define MOCK_TLS_CERTIFICATE_PATH "/mock/certificate"
  10
  11 /* Forward decl */
  12 GType mock_tls_certificate_get_type (void);
  13
  14 #define MOCK_TLS_CERTIFICATE(obj) \
  15   (G_TYPE_CHECK_INSTANCE_CAST((obj), mock_tls_certificate_get_type (), \
  16     MockTLSCertificate))
  17
  18 typedef struct _MockTLSCertificate {
  19   GObject parent;
  20   guint state;
  21   GPtrArray *rejections;
  22   gchar *cert_type;
  23   GPtrArray *cert_data;
  24 } MockTLSCertificate;
  25
  26 typedef struct _MockTLSCertificateClass {
  27   GObjectClass parent;
  28   TpDBusPropertiesMixinClass dbus_props_class;
  29 } MockTLSCertificateClass;
  30
  31 enum {
  32   PROP_0,
  33   PROP_STATE,
  34   PROP_REJECTIONS,
  35   PROP_CERTIFICATE_TYPE,
  36   PROP_CERTIFICATE_CHAIN_DATA
  37 };
  38
  39 static void mock_tls_certificate_iface_init (gpointer, gpointer);
  40
  41 G_DEFINE_TYPE_WITH_CODE(MockTLSCertificate, mock_tls_certificate, G_TYPE_OBJECT,
  42         G_IMPLEMENT_INTERFACE (TP_TYPE_SVC_AUTHENTICATION_TLS_CERTIFICATE,
  43                 mock_tls_certificate_iface_init)
  44         G_IMPLEMENT_INTERFACE (TP_TYPE_SVC_DBUS_PROPERTIES,
  45                 tp_dbus_properties_mixin_iface_init)
  46 )
  47
  48 static void
  49 mock_tls_certificate_init (MockTLSCertificate *self)
  50 {
  51   self->state = TP_TLS_CERTIFICATE_STATE_PENDING;
  52   self->cert_type = g_strdup ("x509");
  53   self->cert_data = g_ptr_array_new_with_free_func((GDestroyNotify) g_array_unref);
  54   self->rejections = g_ptr_array_new ();
  55 }
  56
  57 static void
  58 mock_tls_certificate_get_property (GObject *object,
  59         guint property_id,
  60         GValue *value,
  61         GParamSpec *pspec)
  62 {
  63   MockTLSCertificate *self = MOCK_TLS_CERTIFICATE (object);
  64
  65   switch (property_id)
  66     {
  67     case PROP_STATE:
  68       g_value_set_uint (value, self->state);
  69       break;
  70     case PROP_REJECTIONS:
  71       g_value_set_boxed (value, self->rejections);
  72       break;
  73     case PROP_CERTIFICATE_TYPE:
  74       g_value_set_string (value, self->cert_type);
  75       break;
  76     case PROP_CERTIFICATE_CHAIN_DATA:
  77       g_value_set_boxed (value, self->cert_data);
  78       break;
  79     default:
  80       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
  81       break;
  82   }
  83 }
  84
  85 static void
  86 mock_tls_certificate_finalize (GObject *object)
  87 {
  88   MockTLSCertificate *self = MOCK_TLS_CERTIFICATE (object);
  89
  90   tp_clear_boxed (TP_ARRAY_TYPE_TLS_CERTIFICATE_REJECTION_LIST,
  91       &self->rejections);
  92   g_free (self->cert_type);
  93   self->cert_type = NULL;
  94   g_ptr_array_unref (self->cert_data);
  95   self->cert_data = NULL;
  96
  97   G_OBJECT_CLASS (mock_tls_certificate_parent_class)->finalize (object);
  98 }
  99
 100 static void
 101 mock_tls_certificate_class_init (MockTLSCertificateClass *klass)
 102 {
 103   GObjectClass *oclass = G_OBJECT_CLASS (klass);
 104   GParamSpec *pspec;
 105
 106   static TpDBusPropertiesMixinPropImpl object_props[] = {
 107           { "State", "state", NULL },
 108           { "Rejections", "rejections", NULL },
 109           { "CertificateType", "certificate-type", NULL },
 110           { "CertificateChainData", "certificate-chain-data", NULL },
 111           { NULL }
 112   };
 113
 114   static TpDBusPropertiesMixinIfaceImpl prop_interfaces[] = {
 115     { TP_IFACE_AUTHENTICATION_TLS_CERTIFICATE,
 116       tp_dbus_properties_mixin_getter_gobject_properties,
 117       NULL,
 118       object_props,
 119     },
 120     { NULL }
 121   };
 122
 123   oclass->get_property = mock_tls_certificate_get_property;
 124   oclass->finalize = mock_tls_certificate_finalize;
 125
 126   pspec = g_param_spec_uint ("state",
 127       "State of this certificate",
 128       "The state of this TLS certificate.",
 129       0, NUM_TP_TLS_CERTIFICATE_STATES - 1,
 130       TP_TLS_CERTIFICATE_STATE_PENDING,
 131       G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 132   g_object_class_install_property (oclass, PROP_STATE, pspec);
 133
 134   pspec = g_param_spec_boxed ("rejections",
 135       "The reject reasons",
 136       "The reasons why this TLS certificate has been rejected",
 137       TP_ARRAY_TYPE_TLS_CERTIFICATE_REJECTION_LIST,
 138       G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 139   g_object_class_install_property (oclass, PROP_REJECTIONS, pspec);
 140
 141   pspec = g_param_spec_string ("certificate-type",
 142       "The certificate type",
 143       "The type of this certificate.",
 144       NULL,
 145       G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 146   g_object_class_install_property (oclass, PROP_CERTIFICATE_TYPE, pspec);
 147
 148   pspec = g_param_spec_boxed ("certificate-chain-data",
 149       "The certificate chain data",
 150       "The raw PEM-encoded trust chain of this certificate.",
 151       TP_ARRAY_TYPE_UCHAR_ARRAY_LIST,
 152       G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
 153   g_object_class_install_property (oclass, PROP_CERTIFICATE_CHAIN_DATA, pspec);
 154
 155   klass->dbus_props_class.interfaces = prop_interfaces;
 156   tp_dbus_properties_mixin_class_init (oclass,
 157       G_STRUCT_OFFSET (MockTLSCertificateClass, dbus_props_class));
 158 }
 159
 160 static void
 161 mock_tls_certificate_accept (TpSvcAuthenticationTLSCertificate *base,
 162         DBusGMethodInvocation *context)
 163 {
 164   MockTLSCertificate *self = MOCK_TLS_CERTIFICATE (base);
 165   self->state = TP_TLS_CERTIFICATE_STATE_ACCEPTED;
 166   tp_svc_authentication_tls_certificate_emit_accepted (self);
 167   tp_svc_authentication_tls_certificate_return_from_accept (context);
 168 }
 169
 170 static void
 171 mock_tls_certificate_reject (TpSvcAuthenticationTLSCertificate *base,
 172         const GPtrArray *in_Rejections,
 173         DBusGMethodInvocation *context)
 174 {
 175   MockTLSCertificate *self = MOCK_TLS_CERTIFICATE (base);
 176   self->state = TP_TLS_CERTIFICATE_STATE_REJECTED;
 177   tp_svc_authentication_tls_certificate_emit_rejected (self, in_Rejections);
 178   tp_svc_authentication_tls_certificate_return_from_reject (context);
 179 }
 180
 181 static void
 182 mock_tls_certificate_iface_init (gpointer g_iface,
 183         gpointer iface_data)
 184 {
 185   TpSvcAuthenticationTLSCertificateClass *klass =
 186     (TpSvcAuthenticationTLSCertificateClass*)g_iface;
 187
 188   tp_svc_authentication_tls_certificate_implement_accept (klass,
 189       mock_tls_certificate_accept);
 190   tp_svc_authentication_tls_certificate_implement_reject (klass,
 191       mock_tls_certificate_reject);
 192 }
 193
 194 #if 0
 195 static void
 196 mock_tls_certificate_assert_rejected (MockTLSCertificate *self,
 197         TpTLSCertificateRejectReason reason)
 198 {
 199   GValueArray *rejection;
 200   TpTLSCertificateRejectReason rejection_reason;
 201   gchar *rejection_error;
 202   GHashTable *rejection_details;
 203   guint i;
 204
 205   g_assert (self->state == TP_TLS_CERTIFICATE_STATE_REJECTED);
 206   g_assert (self->rejections);
 207   g_assert (self->rejections->len > 0);
 208
 209   for (i = 0; i < self->rejections->len; ++i)
 210     {
 211       rejection = g_ptr_array_index (self->rejections, i);
 212       tp_value_array_unpack (rejection, 3,
 213               G_TYPE_UINT, &rejection_reason,
 214               G_TYPE_STRING, &rejection_error,
 215               TP_HASH_TYPE_STRING_VARIANT_MAP, &rejection_details,
 216               NULL);
 217       g_free (rejection_error);
 218       g_hash_table_unref (rejection_details);
 219
 220       if (rejection_reason == reason)
 221         return;
 222     }
 223
 224   g_assert ("Certificate was not rejected for right reason" && 0);
 225 }
 226 #endif
 227
 228 static MockTLSCertificate*
 229 mock_tls_certificate_new_and_register (TpDBusDaemon *dbus,
 230         const gchar *path,
 231         ...)
 232 {
 233   MockTLSCertificate *cert;
 234   GError *error = NULL;
 235   gchar *filename, *contents;
 236   GArray *der;
 237   gsize length;
 238   va_list va;
 239
 240   cert = g_object_new (mock_tls_certificate_get_type (), NULL);
 241
 242   va_start (va, path);
 243   while (path != NULL) {
 244       filename = g_build_filename (g_getenv ("EMPATHY_SRCDIR"),
 245               "tests", "certificates", path, NULL);
 246       g_file_get_contents (filename, &contents, &length, &error);
 247       g_assert_no_error (error);
 248
 249       der = g_array_sized_new (TRUE, TRUE, sizeof (guchar), length);
 250       g_array_append_vals (der, contents, length);
 251       g_ptr_array_add (cert->cert_data, der);
 252
 253       g_free (contents);
 254       g_free (filename);
 255
 256       path = va_arg (va, gchar*);
 257   }
 258   va_end (va);
 259
 260   tp_dbus_daemon_register_object (dbus, MOCK_TLS_CERTIFICATE_PATH, cert);
 261   return cert;
 262 }
 263
 264 /* ----------------------------------------------------------------------------
 265  * TESTS
 266  */
 267
 268 typedef struct {
 269   GMainLoop *loop;
 270   TpDBusDaemon *dbus;
 271   const gchar *dbus_name;
 272   MockTLSCertificate *mock;
 273   TpTLSCertificate *cert;
 274   GAsyncResult *result;
 275 } Test;
 276
 277 static void
 278 setup (Test *test, gconstpointer data)
 279 {
 280   GError *error = NULL;
 281   GckModule *module;
 282   const gchar *trust_uris[2] = { MOCK_SLOT_ONE_URI, NULL };
 283
 284   test->loop = g_main_loop_new (NULL, FALSE);
 285
 286   test->dbus = tp_dbus_daemon_dup (&error);
 287   g_assert_no_error (error);
 288
 289   test->dbus_name = tp_dbus_daemon_get_unique_name (test->dbus);
 290
 291   test->result = NULL;
 292   test->cert = NULL;
 293
 294   /* Add our mock module as the only PKCS#11 module */
 295   module = gck_module_new (&mock_default_functions);
 296   mock_C_Initialize (NULL);
 297
 298   gcr_pkcs11_set_modules (NULL);
 299   gcr_pkcs11_add_module (module);
 300   gcr_pkcs11_set_trust_lookup_uris (trust_uris);
 301 }
 302
 303 static void
 304 teardown (Test *test, gconstpointer data)
 305 {
 306   mock_C_Finalize (NULL);
 307
 308   test->dbus_name = NULL;
 309
 310   if (test->mock)
 311     {
 312       tp_dbus_daemon_unregister_object (test->dbus, test->mock);
 313       g_object_unref (test->mock);
 314       test->mock = NULL;
 315     }
 316
 317   if (test->result)
 318     g_object_unref (test->result);
 319   test->result = NULL;
 320
 321   if (test->cert)
 322     g_object_unref (test->cert);
 323   test->cert = NULL;
 324
 325   g_main_loop_unref (test->loop);
 326   test->loop = NULL;
 327
 328   g_object_unref (test->dbus);
 329   test->dbus = NULL;
 330 }
 331
 332 static void
 333 add_certificate_to_mock (Test *test,
 334         const gchar *certificate,
 335         const gchar *peer)
 336 {
 337   GError *error = NULL;
 338   GcrCertificate *cert;
 339   gchar *contents;
 340   gsize length;
 341   gchar *path;
 342
 343   path = g_build_filename (g_getenv ("EMPATHY_SRCDIR"),
 344                            "tests", "certificates", certificate, NULL);
 345
 346   g_file_get_contents (path, &contents, &length, &error);
 347   g_assert_no_error (error);
 348
 349   cert = gcr_simple_certificate_new ((const guchar *)contents, length);
 350   mock_module_add_certificate (cert);
 351   mock_module_add_assertion (cert,
 352           peer ? CKT_X_PINNED_CERTIFICATE : CKT_X_ANCHORED_CERTIFICATE,
 353           GCR_PURPOSE_SERVER_AUTH, peer);
 354   g_object_unref (cert);
 355
 356   g_free (contents);
 357   g_free (path);
 358 }
 359
 360 static void
 361 fetch_callback_result (GObject *object,
 362         GAsyncResult *res,
 363         gpointer user_data)
 364 {
 365   Test *test = user_data;
 366   g_assert (!test->result);
 367   test->result = g_object_ref (res);
 368   g_main_loop_quit (test->loop);
 369 }
 370
 371 static void
 372 ensure_certificate_proxy (Test *test)
 373 {
 374   GError *error = NULL;
 375   GQuark features[] = { TP_TLS_CERTIFICATE_FEATURE_CORE, 0 };
 376
 377   if (test->cert)
 378     return;
 379
 380   /* Create and prepare a certificate */
 381   /* We don't use tp_tls_certificate_new() as we don't pass a parent */
 382   test->cert = g_object_new (TP_TYPE_TLS_CERTIFICATE,
 383       "dbus-daemon", test->dbus,
 384       "bus-name", test->dbus_name,
 385       "object-path", MOCK_TLS_CERTIFICATE_PATH,
 386       NULL);
 387
 388   tp_proxy_prepare_async (test->cert, features, fetch_callback_result, test);
 389   g_main_loop_run (test->loop);
 390   tp_proxy_prepare_finish (test->cert, test->result, &error);
 391   g_assert_no_error (error);
 392
 393   /* Clear for any future async stuff */
 394   g_object_unref (test->result);
 395   test->result = NULL;
 396 }
 397
 398 /* A simple test to make sure the test infrastructure is working */
 399 static void
 400 test_certificate_mock_basics (Test *test,
 401         gconstpointer data G_GNUC_UNUSED)
 402 {
 403   GError *error = NULL;
 404
 405   test->mock = mock_tls_certificate_new_and_register (test->dbus,
 406           "server-cert.cer", NULL);
 407
 408   ensure_certificate_proxy (test);
 409
 410   tp_tls_certificate_accept_async (test->cert, fetch_callback_result, test);
 411   g_main_loop_run (test->loop);
 412   tp_tls_certificate_accept_finish (test->cert, test->result, &error);
 413   g_assert_no_error (error);
 414
 415   g_assert (test->mock->state == TP_TLS_CERTIFICATE_STATE_ACCEPTED);
 416 }
 417
 418 static void
 419 test_certificate_verify_success_with_pkcs11_lookup (Test *test,
 420         gconstpointer data G_GNUC_UNUSED)
 421 {
 422   TpTLSCertificateRejectReason reason = 0;
 423   GError *error = NULL;
 424   EmpathyTLSVerifier *verifier;
 425   const gchar *reference_identities[] = {
 426     "test-server.empathy.gnome.org",
 427     NULL
 428   };
 429
 430   /*
 431    * In this test the mock TLS connection only has one certificate
 432    * not a full certificat echain. The root anchor certificate is
 433    * retrieved from PKCS#11 storage.
 434    */
 435
 436   test->mock = mock_tls_certificate_new_and_register (test->dbus,
 437           "server-cert.cer", NULL);
 438
 439   /* We add the collabora directory with the collabora root */
 440   add_certificate_to_mock (test, "certificate-authority.cer", NULL);
 441
 442   ensure_certificate_proxy (test);
 443
 444   verifier = empathy_tls_verifier_new (test->cert, "test-server.empathy.gnome.org",
 445       reference_identities);
 446   empathy_tls_verifier_verify_async (verifier, fetch_callback_result, test);
 447   g_main_loop_run (test->loop);
 448
 449   empathy_tls_verifier_verify_finish (verifier, test->result, &reason,
 450       NULL, &error);
 451   g_assert_no_error (error);
 452
 453   /* Yay the verification was a success! */
 454
 455   g_clear_error (&error);
 456   g_object_unref (verifier);
 457 }
 458
 459 static void
 460 test_certificate_verify_success_with_full_chain (Test *test,
 461         gconstpointer data G_GNUC_UNUSED)
 462 {
 463   TpTLSCertificateRejectReason reason = 0;
 464   GError *error = NULL;
 465   EmpathyTLSVerifier *verifier;
 466   const gchar *reference_identities[] = {
 467     "test-server.empathy.gnome.org",
 468     NULL
 469   };
 470
 471   /*
 472    * In this test the mock TLS connection has a full certificate
 473    * chain. We look for an anchor certificate in the chain.
 474    */
 475
 476   test->mock = mock_tls_certificate_new_and_register (test->dbus,
 477           "server-cert.cer", "certificate-authority.cer", NULL);
 478
 479   /* We add the collabora directory with the collabora root */
 480   add_certificate_to_mock (test, "certificate-authority.cer", NULL);
 481
 482   ensure_certificate_proxy (test);
 483
 484   verifier = empathy_tls_verifier_new (test->cert, "test-server.empathy.gnome.org",
 485       reference_identities);
 486   empathy_tls_verifier_verify_async (verifier, fetch_callback_result, test);
 487   g_main_loop_run (test->loop);
 488   empathy_tls_verifier_verify_finish (verifier, test->result, &reason,
 489       NULL, &error);
 490   g_assert_no_error (error);
 491
 492   /* Yay the verification was a success! */
 493
 494   g_clear_error (&error);
 495   g_object_unref (verifier);
 496 }
 497
 498 static void
 499 test_certificate_verify_root_not_found (Test *test,
 500         gconstpointer data G_GNUC_UNUSED)
 501 {
 502   TpTLSCertificateRejectReason reason = 0;
 503   GError *error = NULL;
 504   EmpathyTLSVerifier *verifier;
 505   const gchar *reference_identities[] = {
 506     "test-server.empathy.gnome.org",
 507     NULL
 508   };
 509
 510   test->mock = mock_tls_certificate_new_and_register (test->dbus,
 511           "server-cert.cer", NULL);
 512
 513   /* Note that we're not adding any place to find root certs */
 514
 515   ensure_certificate_proxy (test);
 516
 517   verifier = empathy_tls_verifier_new (test->cert, "test-server.empathy.gnome.org",
 518       reference_identities);
 519   empathy_tls_verifier_verify_async (verifier, fetch_callback_result, test);
 520   g_main_loop_run (test->loop);
 521
 522   empathy_tls_verifier_verify_finish (verifier, test->result, &reason,
 523       NULL, &error);
 524
 525   /* And it should say we're self-signed (oddly enough) */
 526   g_assert_error (error, G_IO_ERROR,
 527       TP_TLS_CERTIFICATE_REJECT_REASON_SELF_SIGNED);
 528
 529   g_clear_error (&error);
 530   g_object_unref (verifier);
 531 }
 532
 533 static void
 534 test_certificate_verify_root_not_anchored (Test *test,
 535         gconstpointer data G_GNUC_UNUSED)
 536 {
 537   TpTLSCertificateRejectReason reason = 0;
 538   GError *error = NULL;
 539   EmpathyTLSVerifier *verifier;
 540   const gchar *reference_identities[] = {
 541     "test-server.empathy.gnome.org",
 542     NULL
 543   };
 544
 545   test->mock = mock_tls_certificate_new_and_register (test->dbus,
 546           "server-cert.cer", "certificate-authority.cer", NULL);
 547
 548   /* Note that we're not adding any place to find root certs */
 549
 550   ensure_certificate_proxy (test);
 551
 552   verifier = empathy_tls_verifier_new (test->cert, "test-server.empathy.gnome.org",
 553       reference_identities);
 554   empathy_tls_verifier_verify_async (verifier, fetch_callback_result, test);
 555   g_main_loop_run (test->loop);
 556
 557   empathy_tls_verifier_verify_finish (verifier, test->result, &reason,
 558       NULL, &error);
 559
 560   /* And it should say we're self-signed (oddly enough) */
 561   g_assert_error (error, G_IO_ERROR,
 562       TP_TLS_CERTIFICATE_REJECT_REASON_SELF_SIGNED);
 563
 564   g_clear_error (&error);
 565   g_object_unref (verifier);
 566 }
 567
 568 static void
 569 test_certificate_verify_identities_invalid (Test *test,
 570         gconstpointer data G_GNUC_UNUSED)
 571 {
 572   TpTLSCertificateRejectReason reason = 0;
 573   GError *error = NULL;
 574   EmpathyTLSVerifier *verifier;
 575   const gchar *reference_identities[] = {
 576     "invalid.host.name",
 577     NULL
 578   };
 579
 580   test->mock = mock_tls_certificate_new_and_register (test->dbus,
 581           "server-cert.cer", "certificate-authority.cer", NULL);
 582
 583   /* We add the collabora directory with the collabora root */
 584   add_certificate_to_mock (test, "certificate-authority.cer", NULL);
 585
 586   ensure_certificate_proxy (test);
 587
 588   verifier = empathy_tls_verifier_new (test->cert, "invalid.host.name",
 589       reference_identities);
 590   empathy_tls_verifier_verify_async (verifier, fetch_callback_result, test);
 591   g_main_loop_run (test->loop);
 592
 593   empathy_tls_verifier_verify_finish (verifier, test->result, &reason,
 594       NULL, &error);
 595
 596   /* And it should say we're self-signed (oddly enough) */
 597   g_assert_error (error, G_IO_ERROR,
 598       TP_TLS_CERTIFICATE_REJECT_REASON_HOSTNAME_MISMATCH);
 599
 600   g_clear_error (&error);
 601   g_object_unref (verifier);
 602 }
 603
 604 static void
 605 test_certificate_verify_uses_reference_identities (Test *test,
 606         gconstpointer data G_GNUC_UNUSED)
 607 {
 608   TpTLSCertificateRejectReason reason = 0;
 609   GError *error = NULL;
 610   EmpathyTLSVerifier *verifier;
 611   const gchar *reference_identities[] = {
 612     "invalid.host.name",
 613     NULL
 614   };
 615
 616   test->mock = mock_tls_certificate_new_and_register (test->dbus,
 617           "server-cert.cer", "certificate-authority.cer", NULL);
 618
 619   /* We add the collabora directory with the collabora root */
 620   add_certificate_to_mock (test, "certificate-authority.cer", NULL);
 621
 622   ensure_certificate_proxy (test);
 623
 624   /* Should be using the reference_identities and not host name for checks */
 625   verifier = empathy_tls_verifier_new (test->cert, "test-server.empathy.gnome.org",
 626       reference_identities);
 627   empathy_tls_verifier_verify_async (verifier, fetch_callback_result, test);
 628   g_main_loop_run (test->loop);
 629
 630   empathy_tls_verifier_verify_finish (verifier, test->result, &reason,
 631       NULL, &error);
 632
 633   /* And it should say we're self-signed (oddly enough) */
 634   g_assert_error (error, G_IO_ERROR,
 635       TP_TLS_CERTIFICATE_REJECT_REASON_HOSTNAME_MISMATCH);
 636
 637   g_clear_error (&error);
 638   g_object_unref (verifier);
 639 }
 640
 641 static void
 642 test_certificate_verify_success_with_pinned (Test *test,
 643         gconstpointer data G_GNUC_UNUSED)
 644 {
 645   TpTLSCertificateRejectReason reason = 0;
 646   GError *error = NULL;
 647   EmpathyTLSVerifier *verifier;
 648   const gchar *reference_identities[] = {
 649     "test-server.empathy.gnome.org",
 650     NULL
 651   };
 652
 653   /*
 654    * In this test the mock TLS connection has a full certificate
 655    * chain. We look for an anchor certificate in the chain.
 656    */
 657
 658   test->mock = mock_tls_certificate_new_and_register (test->dbus,
 659           "server-cert.cer", NULL);
 660
 661   /* We add the collabora directory with the collabora root */
 662   add_certificate_to_mock (test, "server-cert.cer", "test-server.empathy.gnome.org");
 663
 664   ensure_certificate_proxy (test);
 665
 666   verifier = empathy_tls_verifier_new (test->cert, "test-server.empathy.gnome.org",
 667       reference_identities);
 668   empathy_tls_verifier_verify_async (verifier, fetch_callback_result, test);
 669   g_main_loop_run (test->loop);
 670   empathy_tls_verifier_verify_finish (verifier, test->result, &reason,
 671       NULL, &error);
 672   g_assert_no_error (error);
 673
 674   /* Yay the verification was a success! */
 675
 676   g_clear_error (&error);
 677   g_object_unref (verifier);
 678 }
 679
 680 static void
 681 test_certificate_verify_pinned_wrong_host (Test *test,
 682         gconstpointer data G_GNUC_UNUSED)
 683 {
 684   TpTLSCertificateRejectReason reason = 0;
 685   GError *error = NULL;
 686   EmpathyTLSVerifier *verifier;
 687   const gchar *reference_identities[] = {
 688     "test-server.empathy.gnome.org",
 689     NULL
 690   };
 691
 692   test->mock = mock_tls_certificate_new_and_register (test->dbus,
 693           "server-cert.cer", NULL);
 694
 695   /* Note that we're not adding any place to find root certs */
 696
 697   ensure_certificate_proxy (test);
 698
 699   verifier = empathy_tls_verifier_new (test->cert, "another.gnome.org",
 700       reference_identities);
 701   empathy_tls_verifier_verify_async (verifier, fetch_callback_result, test);
 702   g_main_loop_run (test->loop);
 703
 704   empathy_tls_verifier_verify_finish (verifier, test->result, &reason,
 705       NULL, &error);
 706
 707   /* And it should say we're self-signed */
 708   g_assert_error (error, G_IO_ERROR,
 709       TP_TLS_CERTIFICATE_REJECT_REASON_SELF_SIGNED);
 710
 711   g_clear_error (&error);
 712   g_object_unref (verifier);
 713 }
 714
 715 int
 716 main (int argc,
 717     char **argv)
 718 {
 719   int result;
 720
 721   test_init (argc, argv);
 722   gnutls_global_init ();
 723
 724   g_test_add ("/tls/certificate_basics", Test, NULL,
 725           setup, test_certificate_mock_basics, teardown);
 726   g_test_add ("/tls/certificate_verify_success_with_pkcs11_lookup", Test, NULL,
 727           setup, test_certificate_verify_success_with_pkcs11_lookup, teardown);
 728   g_test_add ("/tls/certificate_verify_success_with_full_chain", Test, NULL,
 729           setup, test_certificate_verify_success_with_full_chain, teardown);
 730   g_test_add ("/tls/certificate_verify_root_not_found", Test, NULL,
 731           setup, test_certificate_verify_root_not_found, teardown);
 732   g_test_add ("/tls/certificate_verify_root_not_anchored", Test, NULL,
 733           setup, test_certificate_verify_root_not_anchored, teardown);
 734   g_test_add ("/tls/certificate_verify_identities_invalid", Test, NULL,
 735           setup, test_certificate_verify_identities_invalid, teardown);
 736   g_test_add ("/tls/certificate_verify_uses_reference_identities", Test, NULL,
 737           setup, test_certificate_verify_uses_reference_identities, teardown);
 738   g_test_add ("/tls/certificate_verify_success_with_pinned", Test, NULL,
 739           setup, test_certificate_verify_success_with_pinned, teardown);
 740   g_test_add ("/tls/certificate_verify_pinned_wrong_host", Test, NULL,
 741           setup, test_certificate_verify_pinned_wrong_host, teardown);
 742
 743   result = g_test_run ();
 744   test_deinit ();
 745   return result;
 746 }