tls/openssl/gtlscertificate-openssl.c

   1 /*
   2  * gtlscertificate-openssl.c
   3  *
   4  * Copyright (C) 2015 NICE s.r.l.
   5  *
   6  * This file 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 file 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 License
  17  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  18  *
  19  * In addition, when the library is used with OpenSSL, a special
  20  * exception applies. Refer to the LICENSE_EXCEPTION file for details.
  21  *
  22  * Authors: Ignacio Casal Quinteiro
  23  */
  24
  25 #include "config.h"
  26
  27 #include <string.h>
  28 #include "openssl-include.h"
  29
  30 #include "gtlscertificate-openssl.h"
  31 #include "openssl-util.h"
  32 #include <glib/gi18n-lib.h>
  33
  34 typedef struct _GTlsCertificateOpensslPrivate
  35 {
  36   X509 *cert;
  37   EVP_PKEY *key;
  38
  39   GTlsCertificateOpenssl *issuer;
  40
  41   GError *construct_error;
  42
  43   guint have_cert : 1;
  44   guint have_key  : 1;
  45 } GTlsCertificateOpensslPrivate;
  46
  47 enum
  48 {
  49   PROP_0,
  50
  51   PROP_CERTIFICATE,
  52   PROP_CERTIFICATE_PEM,
  53   PROP_PRIVATE_KEY,
  54   PROP_PRIVATE_KEY_PEM,
  55   PROP_ISSUER
  56 };
  57
  58 static void     g_tls_certificate_openssl_initable_iface_init (GInitableIface  *iface);
  59
  60 G_DEFINE_TYPE_WITH_CODE (GTlsCertificateOpenssl, g_tls_certificate_openssl, G_TYPE_TLS_CERTIFICATE,
  61                          G_ADD_PRIVATE (GTlsCertificateOpenssl)
  62                          G_IMPLEMENT_INTERFACE (G_TYPE_INITABLE,
  63                                                 g_tls_certificate_openssl_initable_iface_init))
  64
  65 static void
  66 g_tls_certificate_openssl_finalize (GObject *object)
  67 {
  68   GTlsCertificateOpenssl *openssl = G_TLS_CERTIFICATE_OPENSSL (object);
  69   GTlsCertificateOpensslPrivate *priv;
  70
  71   priv = g_tls_certificate_openssl_get_instance_private (openssl);
  72
  73   if (priv->cert)
  74     X509_free (priv->cert);
  75   if (priv->key)
  76     EVP_PKEY_free (priv->key);
  77
  78   g_clear_object (&priv->issuer);
  79
  80   g_clear_error (&priv->construct_error);
  81
  82   G_OBJECT_CLASS (g_tls_certificate_openssl_parent_class)->finalize (object);
  83 }
  84
  85 static void
  86 g_tls_certificate_openssl_get_property (GObject    *object,
  87                                         guint       prop_id,
  88                                         GValue     *value,
  89                                         GParamSpec *pspec)
  90 {
  91   GTlsCertificateOpenssl *openssl = G_TLS_CERTIFICATE_OPENSSL (object);
  92   GTlsCertificateOpensslPrivate *priv;
  93   GByteArray *certificate;
  94   guint8 *data;
  95   BIO *bio;
  96   char *certificate_pem;
  97   int size;
  98
  99   priv = g_tls_certificate_openssl_get_instance_private (openssl);
 100
 101   switch (prop_id)
 102     {
 103     case PROP_CERTIFICATE:
 104       /* NOTE: we do the two calls to avoid openssl allocating the buffer for us */
 105       size = i2d_X509 (priv->cert, NULL);
 106       if (size < 0)
 107         certificate = NULL;
 108       else
 109         {
 110           certificate = g_byte_array_sized_new (size);
 111           certificate->len = size;
 112           data = certificate->data;
 113           size = i2d_X509 (priv->cert, &data);
 114           if (size < 0)
 115             {
 116               g_byte_array_free (certificate, TRUE);
 117               certificate = NULL;
 118             }
 119         }
 120       g_value_take_boxed (value, certificate);
 121       break;
 122
 123     case PROP_CERTIFICATE_PEM:
 124       bio = BIO_new (BIO_s_mem ());
 125
 126       if (!PEM_write_bio_X509 (bio, priv->cert) || !BIO_write (bio, "\0", 1))
 127         certificate_pem = NULL;
 128       else
 129         {
 130           BIO_get_mem_data (bio, &certificate_pem);
 131           g_value_set_string (value, certificate_pem);
 132
 133           BIO_free_all (bio);
 134         }
 135       break;
 136
 137     case PROP_ISSUER:
 138       g_value_set_object (value, priv->issuer);
 139       break;
 140
 141     default:
 142       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 143     }
 144 }
 145
 146 static void
 147 g_tls_certificate_openssl_set_property (GObject      *object,
 148                                        guint         prop_id,
 149                                        const GValue *value,
 150                                        GParamSpec   *pspec)
 151 {
 152   GTlsCertificateOpenssl *openssl = G_TLS_CERTIFICATE_OPENSSL (object);
 153   GTlsCertificateOpensslPrivate *priv;
 154   GByteArray *bytes;
 155   guint8 *data;
 156   BIO *bio;
 157   const char *string;
 158
 159   priv = g_tls_certificate_openssl_get_instance_private (openssl);
 160
 161   switch (prop_id)
 162     {
 163     case PROP_CERTIFICATE:
 164       bytes = g_value_get_boxed (value);
 165       if (!bytes)
 166         break;
 167       g_return_if_fail (priv->have_cert == FALSE);
 168       /* see that we cannot use bytes->data directly since it will move the pointer */
 169       data = bytes->data;
 170       priv->cert = d2i_X509 (NULL, (const unsigned char **)&data, bytes->len);
 171       if (priv->cert != NULL)
 172         priv->have_cert = TRUE;
 173       else if (!priv->construct_error)
 174         {
 175           priv->construct_error =
 176             g_error_new (G_TLS_ERROR, G_TLS_ERROR_BAD_CERTIFICATE,
 177                          _("Could not parse DER certificate: %s"),
 178                          ERR_error_string (ERR_get_error (), NULL));
 179         }
 180
 181       break;
 182
 183     case PROP_CERTIFICATE_PEM:
 184       string = g_value_get_string (value);
 185       if (!string)
 186         break;
 187       g_return_if_fail (priv->have_cert == FALSE);
 188       bio = BIO_new_mem_buf ((gpointer)string, -1);
 189       priv->cert = PEM_read_bio_X509 (bio, NULL, NULL, NULL);
 190       BIO_free (bio);
 191       if (priv->cert != NULL)
 192         priv->have_cert = TRUE;
 193       else if (!priv->construct_error)
 194         {
 195           priv->construct_error =
 196             g_error_new (G_TLS_ERROR, G_TLS_ERROR_BAD_CERTIFICATE,
 197                          _("Could not parse PEM certificate: %s"),
 198                          ERR_error_string (ERR_get_error (), NULL));
 199         }
 200       break;
 201
 202     case PROP_PRIVATE_KEY:
 203       bytes = g_value_get_boxed (value);
 204       if (!bytes)
 205         break;
 206       g_return_if_fail (priv->have_key == FALSE);
 207       bio = BIO_new_mem_buf (bytes->data, bytes->len);
 208       priv->key = d2i_PrivateKey_bio (bio, NULL);
 209       BIO_free (bio);
 210       if (priv->key != NULL)
 211         priv->have_key = TRUE;
 212       else if (!priv->construct_error)
 213         {
 214           priv->construct_error =
 215             g_error_new (G_TLS_ERROR, G_TLS_ERROR_BAD_CERTIFICATE,
 216                          _("Could not parse DER private key: %s"),
 217                          ERR_error_string (ERR_get_error (), NULL));
 218         }
 219       break;
 220
 221     case PROP_PRIVATE_KEY_PEM:
 222       string = g_value_get_string (value);
 223       if (!string)
 224         break;
 225       g_return_if_fail (priv->have_key == FALSE);
 226       bio = BIO_new_mem_buf ((gpointer)string, -1);
 227       priv->key = PEM_read_bio_PrivateKey (bio, NULL, NULL, NULL);
 228       BIO_free (bio);
 229       if (priv->key != NULL)
 230         priv->have_key = TRUE;
 231       else if (!priv->construct_error)
 232         {
 233           priv->construct_error =
 234             g_error_new (G_TLS_ERROR, G_TLS_ERROR_BAD_CERTIFICATE,
 235                          _("Could not parse PEM private key: %s"),
 236                          ERR_error_string (ERR_get_error (), NULL));
 237         }
 238       break;
 239
 240     case PROP_ISSUER:
 241       priv->issuer = g_value_dup_object (value);
 242       break;
 243
 244     default:
 245       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 246     }
 247 }
 248
 249 static void
 250 g_tls_certificate_openssl_init (GTlsCertificateOpenssl *openssl)
 251 {
 252 }
 253
 254 static gboolean
 255 g_tls_certificate_openssl_initable_init (GInitable       *initable,
 256                                          GCancellable    *cancellable,
 257                                          GError         **error)
 258 {
 259   GTlsCertificateOpenssl *openssl = G_TLS_CERTIFICATE_OPENSSL (initable);
 260   GTlsCertificateOpensslPrivate *priv;
 261
 262   priv = g_tls_certificate_openssl_get_instance_private (openssl);
 263
 264   if (priv->construct_error)
 265     {
 266       g_propagate_error (error, priv->construct_error);
 267       priv->construct_error = NULL;
 268       return FALSE;
 269     }
 270   else if (!priv->have_cert)
 271     {
 272       g_set_error_literal (error, G_TLS_ERROR, G_TLS_ERROR_BAD_CERTIFICATE,
 273                            _("No certificate data provided"));
 274       return FALSE;
 275     }
 276   else
 277     return TRUE;
 278 }
 279
 280 static GTlsCertificateFlags
 281 g_tls_certificate_openssl_verify (GTlsCertificate     *cert,
 282                                   GSocketConnectable  *identity,
 283                                   GTlsCertificate     *trusted_ca)
 284 {
 285   GTlsCertificateOpenssl *cert_openssl;
 286   GTlsCertificateOpensslPrivate *priv;
 287   GTlsCertificateFlags gtls_flags;
 288   X509 *x;
 289   STACK_OF(X509) *untrusted;
 290   gint i;
 291
 292   cert_openssl = G_TLS_CERTIFICATE_OPENSSL (cert);
 293   priv = g_tls_certificate_openssl_get_instance_private (cert_openssl);
 294   x = priv->cert;
 295
 296   untrusted = sk_X509_new_null ();
 297   for (; cert_openssl; cert_openssl = priv->issuer)
 298     {
 299       priv = g_tls_certificate_openssl_get_instance_private (cert_openssl);
 300       sk_X509_push (untrusted, priv->cert);
 301     }
 302
 303   gtls_flags = 0;
 304
 305   if (trusted_ca)
 306     {
 307       X509_STORE *store;
 308       X509_STORE_CTX *csc;
 309       STACK_OF(X509) *trusted;
 310
 311       store = X509_STORE_new ();
 312       csc = X509_STORE_CTX_new ();
 313
 314       if (!X509_STORE_CTX_init (csc, store, x, untrusted))
 315         {
 316           sk_X509_free (untrusted);
 317           X509_STORE_CTX_free (csc);
 318           X509_STORE_free (store);
 319           return G_TLS_CERTIFICATE_GENERIC_ERROR;
 320         }
 321
 322       trusted = sk_X509_new_null ();
 323       cert_openssl = G_TLS_CERTIFICATE_OPENSSL (trusted_ca);
 324       for (; cert_openssl; cert_openssl = priv->issuer)
 325         {
 326           priv = g_tls_certificate_openssl_get_instance_private (cert_openssl);
 327           sk_X509_push (trusted, priv->cert);
 328         }
 329
 330       X509_STORE_CTX_trusted_stack (csc, trusted);
 331       if (X509_verify_cert (csc) <= 0)
 332         gtls_flags |= g_tls_certificate_openssl_convert_error (X509_STORE_CTX_get_error (csc));
 333
 334       sk_X509_free (trusted);
 335       X509_STORE_CTX_free (csc);
 336       X509_STORE_free (store);
 337     }
 338
 339   /* We have to check these ourselves since openssl
 340    * does not give us flags and UNKNOWN_CA will take priority.
 341    */
 342   for (i = 0; i < sk_X509_num (untrusted); i++)
 343     {
 344       X509 *c = sk_X509_value (untrusted, i);
 345       ASN1_TIME *not_before = X509_get_notBefore (c);
 346       ASN1_TIME *not_after = X509_get_notAfter (c);
 347
 348       if (X509_cmp_current_time (not_before) > 0)
 349         gtls_flags |= G_TLS_CERTIFICATE_NOT_ACTIVATED;
 350
 351       if (X509_cmp_current_time (not_after) < 0)
 352         gtls_flags |= G_TLS_CERTIFICATE_EXPIRED;
 353     }
 354
 355   sk_X509_free (untrusted);
 356
 357   if (identity)
 358     gtls_flags |= g_tls_certificate_openssl_verify_identity (G_TLS_CERTIFICATE_OPENSSL (cert), identity);
 359
 360   return gtls_flags;
 361 }
 362
 363 static void
 364 g_tls_certificate_openssl_class_init (GTlsCertificateOpensslClass *klass)
 365 {
 366   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 367   GTlsCertificateClass *certificate_class = G_TLS_CERTIFICATE_CLASS (klass);
 368
 369   gobject_class->get_property = g_tls_certificate_openssl_get_property;
 370   gobject_class->set_property = g_tls_certificate_openssl_set_property;
 371   gobject_class->finalize     = g_tls_certificate_openssl_finalize;
 372
 373   certificate_class->verify = g_tls_certificate_openssl_verify;
 374
 375   g_object_class_override_property (gobject_class, PROP_CERTIFICATE, "certificate");
 376   g_object_class_override_property (gobject_class, PROP_CERTIFICATE_PEM, "certificate-pem");
 377   g_object_class_override_property (gobject_class, PROP_PRIVATE_KEY, "private-key");
 378   g_object_class_override_property (gobject_class, PROP_PRIVATE_KEY_PEM, "private-key-pem");
 379   g_object_class_override_property (gobject_class, PROP_ISSUER, "issuer");
 380 }
 381
 382 static void
 383 g_tls_certificate_openssl_initable_iface_init (GInitableIface  *iface)
 384 {
 385   iface->init = g_tls_certificate_openssl_initable_init;
 386 }
 387
 388 GTlsCertificate *
 389 g_tls_certificate_openssl_new (GBytes          *bytes,
 390                                GTlsCertificate *issuer)
 391 {
 392   GTlsCertificateOpenssl *openssl;
 393
 394   openssl = g_object_new (G_TYPE_TLS_CERTIFICATE_OPENSSL,
 395                           "issuer", issuer,
 396                           NULL);
 397   g_tls_certificate_openssl_set_data (openssl, bytes);
 398
 399   return G_TLS_CERTIFICATE (openssl);
 400 }
 401
 402 GTlsCertificate *
 403 g_tls_certificate_openssl_new_from_x509 (X509            *x,
 404                                          GTlsCertificate *issuer)
 405 {
 406   GTlsCertificateOpenssl *openssl;
 407   GTlsCertificateOpensslPrivate *priv;
 408
 409   openssl = g_object_new (G_TYPE_TLS_CERTIFICATE_OPENSSL,
 410                           "issuer", issuer,
 411                           NULL);
 412
 413   priv = g_tls_certificate_openssl_get_instance_private (openssl);
 414
 415   priv->cert = X509_dup (x);
 416   priv->have_cert = TRUE;
 417
 418   return G_TLS_CERTIFICATE (openssl);
 419 }
 420
 421 void
 422 g_tls_certificate_openssl_set_data (GTlsCertificateOpenssl *openssl,
 423                                     GBytes                 *bytes)
 424 {
 425   GTlsCertificateOpensslPrivate *priv;
 426   const unsigned char *data;
 427
 428   g_return_if_fail (G_IS_TLS_CERTIFICATE_OPENSSL (openssl));
 429
 430   priv = g_tls_certificate_openssl_get_instance_private (openssl);
 431
 432   g_return_if_fail (!priv->have_cert);
 433
 434   data = (const unsigned char *)g_bytes_get_data (bytes, NULL);
 435   priv->cert = d2i_X509 (NULL, &data, g_bytes_get_size (bytes));
 436
 437   if (priv->cert != NULL)
 438     priv->have_cert = TRUE;
 439 }
 440
 441 GBytes *
 442 g_tls_certificate_openssl_get_bytes (GTlsCertificateOpenssl *openssl)
 443 {
 444   GByteArray *array;
 445
 446   g_return_val_if_fail (G_IS_TLS_CERTIFICATE_OPENSSL (openssl), NULL);
 447
 448   g_object_get (openssl, "certificate", &array, NULL);
 449   return g_byte_array_free_to_bytes (array);
 450 }
 451
 452 X509 *
 453 g_tls_certificate_openssl_get_cert (GTlsCertificateOpenssl *openssl)
 454 {
 455   GTlsCertificateOpensslPrivate *priv;
 456
 457   g_return_val_if_fail (G_IS_TLS_CERTIFICATE_OPENSSL (openssl), FALSE);
 458
 459   priv = g_tls_certificate_openssl_get_instance_private (openssl);
 460
 461   return priv->cert;
 462 }
 463
 464 EVP_PKEY *
 465 g_tls_certificate_openssl_get_key (GTlsCertificateOpenssl *openssl)
 466 {
 467   GTlsCertificateOpensslPrivate *priv;
 468
 469   g_return_val_if_fail (G_IS_TLS_CERTIFICATE_OPENSSL (openssl), FALSE);
 470
 471   priv = g_tls_certificate_openssl_get_instance_private (openssl);
 472
 473   return priv->key;
 474 }
 475
 476 void
 477 g_tls_certificate_openssl_set_issuer (GTlsCertificateOpenssl *openssl,
 478                                       GTlsCertificateOpenssl *issuer)
 479 {
 480   GTlsCertificateOpensslPrivate *priv;
 481
 482   g_return_if_fail (G_IS_TLS_CERTIFICATE_OPENSSL (openssl));
 483   g_return_if_fail (!issuer || G_IS_TLS_CERTIFICATE_OPENSSL (issuer));
 484
 485   priv = g_tls_certificate_openssl_get_instance_private (openssl);
 486
 487   if (g_set_object (&priv->issuer, issuer))
 488     g_object_notify (G_OBJECT (openssl), "issuer");
 489 }
 490
 491 static gboolean
 492 verify_identity_hostname (GTlsCertificateOpenssl *openssl,
 493                           GSocketConnectable     *identity)
 494 {
 495   GTlsCertificateOpensslPrivate *priv;
 496   const char *hostname;
 497
 498   priv = g_tls_certificate_openssl_get_instance_private (openssl);
 499
 500   if (G_IS_NETWORK_ADDRESS (identity))
 501     hostname = g_network_address_get_hostname (G_NETWORK_ADDRESS (identity));
 502   else if (G_IS_NETWORK_SERVICE (identity))
 503     hostname = g_network_service_get_domain (G_NETWORK_SERVICE (identity));
 504   else
 505     return FALSE;
 506
 507   return g_tls_X509_check_host (priv->cert, hostname, strlen (hostname), 0, NULL) == 1;
 508 }
 509
 510 static gboolean
 511 verify_identity_ip (GTlsCertificateOpenssl *openssl,
 512                     GSocketConnectable     *identity)
 513 {
 514   GTlsCertificateOpensslPrivate *priv;
 515   GInetAddress *addr;
 516   gsize addr_size;
 517   const guint8 *addr_bytes;
 518   gboolean ret;
 519
 520   priv = g_tls_certificate_openssl_get_instance_private (openssl);
 521
 522   if (G_IS_INET_SOCKET_ADDRESS (identity))
 523     addr = g_object_ref (g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (identity)));
 524   else {
 525     const char *hostname;
 526
 527     if (G_IS_NETWORK_ADDRESS (identity))
 528       hostname = g_network_address_get_hostname (G_NETWORK_ADDRESS (identity));
 529     else if (G_IS_NETWORK_SERVICE (identity))
 530       hostname = g_network_service_get_domain (G_NETWORK_SERVICE (identity));
 531     else
 532       return FALSE;
 533
 534     addr = g_inet_address_new_from_string (hostname);
 535     if (!addr)
 536       return FALSE;
 537   }
 538
 539   addr_bytes = g_inet_address_to_bytes (addr);
 540   addr_size = g_inet_address_get_native_size (addr);
 541
 542   ret = g_tls_X509_check_ip (priv->cert, addr_bytes, addr_size, 0) == 1;
 543
 544   g_object_unref (addr);
 545   return ret;
 546 }
 547
 548 GTlsCertificateFlags
 549 g_tls_certificate_openssl_verify_identity (GTlsCertificateOpenssl *openssl,
 550                                            GSocketConnectable     *identity)
 551 {
 552   if (verify_identity_hostname (openssl, identity))
 553     return 0;
 554   else if (verify_identity_ip (openssl, identity))
 555     return 0;
 556
 557   /* FIXME: check sRVName and uniformResourceIdentifier
 558    * subjectAltNames, if appropriate for @identity.
 559    */
 560   TIZEN_LOGE("SSL HandShake - Bad Identity");
 561   return G_TLS_CERTIFICATE_BAD_IDENTITY;
 562 }
 563
 564 GTlsCertificateFlags
 565 g_tls_certificate_openssl_convert_error (guint openssl_error)
 566 {
 567   GTlsCertificateFlags gtls_flags;
 568
 569   gtls_flags = 0;
 570
 571   /* FIXME: should we add more ? */
 572   switch (openssl_error)
 573     {
 574     case X509_V_OK:
 575       break;
 576     case X509_V_ERR_CERT_NOT_YET_VALID:
 577       gtls_flags = G_TLS_CERTIFICATE_NOT_ACTIVATED;
 578       break;
 579     case X509_V_ERR_CERT_HAS_EXPIRED:
 580       gtls_flags = G_TLS_CERTIFICATE_EXPIRED;
 581       break;
 582     case X509_V_ERR_CERT_REVOKED:
 583       gtls_flags = G_TLS_CERTIFICATE_REVOKED;
 584       break;
 585     case X509_V_ERR_AKID_SKID_MISMATCH:
 586       gtls_flags = G_TLS_CERTIFICATE_BAD_IDENTITY;
 587       break;
 588     case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY:
 589     case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT:
 590 #ifdef TIZEN_EXT
 591     case X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN:
 592 #endif
 593       gtls_flags = G_TLS_CERTIFICATE_UNKNOWN_CA;
 594       break;
 595     default:
 596       g_message ("certificate error: %s", X509_verify_cert_error_string (openssl_error));
 597       gtls_flags = G_TLS_CERTIFICATE_GENERIC_ERROR;
 598     }
 599
 600   return gtls_flags;
 601 }
 602
 603 static gboolean
 604 is_issuer (GTlsCertificateOpenssl *cert,
 605            GTlsCertificateOpenssl *issuer)
 606 {
 607   X509 *x;
 608   X509 *issuer_x;
 609   X509_STORE *store;
 610   X509_STORE_CTX *csc;
 611   STACK_OF(X509) *trusted;
 612   gboolean ret = FALSE;
 613   gint err;
 614
 615   x = g_tls_certificate_openssl_get_cert (cert);
 616   issuer_x = g_tls_certificate_openssl_get_cert (issuer);
 617
 618   store = X509_STORE_new ();
 619   csc = X509_STORE_CTX_new ();
 620
 621   if (!X509_STORE_CTX_init (csc, store, x, NULL))
 622     goto end;
 623
 624   trusted = sk_X509_new_null ();
 625   sk_X509_push (trusted, issuer_x);
 626
 627   X509_STORE_CTX_trusted_stack (csc, trusted);
 628   X509_STORE_CTX_set_flags (csc, X509_V_FLAG_CB_ISSUER_CHECK);
 629
 630   /* FIXME: is this the right way to do it? */
 631   if (X509_verify_cert (csc) <= 0)
 632     {
 633       err = X509_STORE_CTX_get_error (csc);
 634       if (err == X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT)
 635         ret = TRUE;
 636     }
 637   else
 638     ret = TRUE;
 639
 640   sk_X509_free (trusted);
 641
 642 end:
 643   X509_STORE_CTX_free (csc);
 644   X509_STORE_free (store);
 645
 646   return ret;
 647 }
 648
 649 GTlsCertificateOpenssl *
 650 g_tls_certificate_openssl_build_chain (X509            *x,
 651                                        STACK_OF (X509) *chain)
 652 {
 653   GPtrArray *glib_certs;
 654   GTlsCertificateOpenssl *issuer;
 655   GTlsCertificateOpenssl *result;
 656   guint i, j;
 657
 658   g_return_val_if_fail (x != NULL, NULL);
 659   g_return_val_if_fail (chain, NULL);
 660
 661   glib_certs = g_ptr_array_new_full (sk_X509_num (chain), g_object_unref);
 662   g_ptr_array_add (glib_certs, g_tls_certificate_openssl_new_from_x509 (x, NULL));
 663   for (i = 1; i < sk_X509_num (chain); i++)
 664     g_ptr_array_add (glib_certs, g_tls_certificate_openssl_new_from_x509 (sk_X509_value (chain, i), NULL));
 665
 666   /* Some servers send certs out of order, or will send duplicate
 667    * certs, so we need to be careful when assigning the issuer of
 668    * our new GTlsCertificateOpenssl.
 669    */
 670   for (i = 0; i < glib_certs->len; i++)
 671     {
 672       issuer = NULL;
 673
 674       /* Check if the cert issued itself */
 675       if (is_issuer (glib_certs->pdata[i], glib_certs->pdata[i]))
 676         continue;
 677
 678       if (i < glib_certs->len - 1 &&
 679           is_issuer (glib_certs->pdata[i], glib_certs->pdata[i + 1]))
 680         {
 681           issuer = glib_certs->pdata[i + 1];
 682         }
 683       else
 684         {
 685           for (j = 0; j < glib_certs->len; j++)
 686             {
 687               if (j != i &&
 688                   is_issuer (glib_certs->pdata[i], glib_certs->pdata[j]))
 689                 {
 690                   issuer = glib_certs->pdata[j];
 691                   break;
 692                 }
 693             }
 694         }
 695
 696       if (issuer)
 697         g_tls_certificate_openssl_set_issuer (glib_certs->pdata[i], issuer);
 698     }
 699
 700   result = g_object_ref (glib_certs->pdata[0]);
 701   g_ptr_array_unref (glib_certs);
 702
 703   return result;
 704 }