lib/ext/status_request.c

   1 /*
   2  * Copyright (C) 2012 Free Software Foundation, Inc.
   3  *
   4  * Author: Simon Josefsson, Nikos Mavrogiannopoulos
   5  *
   6  * This file is part of GnuTLS.
   7  *
   8  * The GnuTLS is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public License
  10  * as published by the Free Software Foundation; either version 3 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public License
  19  * along with this program.  If not, see <http://www.gnu.org/licenses/>
  20  *
  21  */
  22
  23 /*
  24   Status Request (OCSP) TLS extension.  See RFC 6066 section 8:
  25   https://tools.ietf.org/html/rfc6066#section-8
  26 */
  27
  28 #include "gnutls_int.h"
  29 #include "gnutls_errors.h"
  30 #include <gnutls_extensions.h>
  31 #include <ext/status_request.h>
  32 #include <gnutls_mbuffers.h>
  33 #include <gnutls_handshake.h>
  34
  35 typedef struct
  36 {
  37   gnutls_datum_t *responder_id;
  38   size_t responder_id_size;
  39   gnutls_datum_t request_extensions;
  40   gnutls_datum_t response;
  41
  42   gnutls_status_request_ocsp_func ocsp_func;
  43   void *ocsp_func_ptr;
  44   char *response_file;
  45   unsigned int expect_cstatus;
  46 } status_request_ext_st;
  47
  48 /*
  49   From RFC 6066.  Client sends:
  50
  51       struct {
  52           CertificateStatusType status_type;
  53           select (status_type) {
  54               case ocsp: OCSPStatusRequest;
  55           } request;
  56       } CertificateStatusRequest;
  57
  58       enum { ocsp(1), (255) } CertificateStatusType;
  59
  60       struct {
  61           ResponderID responder_id_list<0..2^16-1>;
  62           Extensions  request_extensions;
  63       } OCSPStatusRequest;
  64
  65       opaque ResponderID<1..2^16-1>;
  66       opaque Extensions<0..2^16-1>;
  67 */
  68
  69 static int
  70 client_send (gnutls_session_t session,
  71              gnutls_buffer_st* extdata,
  72              status_request_ext_st *priv)
  73 {
  74   int ret_len = 1 + 2;
  75   int ret;
  76   size_t i;
  77
  78   ret = _gnutls_buffer_append_prefix (extdata, 8, 1);
  79   if (ret < 0)
  80     return gnutls_assert_val (ret);
  81
  82   ret = _gnutls_buffer_append_prefix (extdata, 16, priv->responder_id_size);
  83   if (ret < 0)
  84     return gnutls_assert_val (ret);
  85
  86   for (i = 0; i < priv->responder_id_size; i++)
  87     {
  88       if (priv->responder_id[i].size <= 0)
  89         return gnutls_assert_val (GNUTLS_E_INVALID_REQUEST);
  90
  91       ret = _gnutls_buffer_append_data_prefix (extdata, 16,
  92                                                priv->responder_id[i].data,
  93                                                priv->responder_id[i].size);
  94       if (ret < 0)
  95         return gnutls_assert_val (ret);
  96
  97       ret_len += 2 + priv->responder_id[i].size;
  98     }
  99
 100   ret = _gnutls_buffer_append_data_prefix (extdata, 16,
 101                                            priv->request_extensions.data,
 102                                            priv->request_extensions.size);
 103   if (ret < 0)
 104     return gnutls_assert_val (ret);
 105
 106   ret_len += 2 + priv->request_extensions.size;
 107
 108   return ret_len;
 109 }
 110
 111 static int
 112 server_recv (gnutls_session_t session,
 113              status_request_ext_st *priv,
 114              const uint8_t * data,
 115              size_t size)
 116 {
 117   size_t i;
 118   ssize_t data_size = size;
 119
 120   /* minimum message is type (1) + responder_id_list (2) +
 121      request_extension (2) = 5 */
 122   if (data_size < 5)
 123     return gnutls_assert_val (GNUTLS_E_UNEXPECTED_PACKET_LENGTH);
 124
 125   /* We ignore non-ocsp CertificateStatusType.  The spec is unclear
 126      what should be done. */
 127   if (data[0] != 0x01)
 128     {
 129       gnutls_assert ();
 130       _gnutls_handshake_log ("EXT[%p]: unknown status_type %d\n",
 131                              session, data[0]);
 132       return 0;
 133     }
 134   DECR_LEN(data_size, 1);
 135   data++;
 136
 137   priv->responder_id_size = _gnutls_read_uint16 (data);
 138
 139   DECR_LEN(data_size, 2);
 140   data += 2;
 141
 142   if (data_size <= (ssize_t)(priv->responder_id_size * 2))
 143     return gnutls_assert_val (GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER);
 144
 145   priv->responder_id = gnutls_malloc (priv->responder_id_size
 146                                       * sizeof (*priv->responder_id));
 147   if (priv->responder_id == NULL)
 148     return gnutls_assert_val (GNUTLS_E_MEMORY_ERROR);
 149
 150   for (i = 0; i < priv->responder_id_size; i++)
 151     {
 152       size_t l;
 153
 154       DECR_LEN(data_size, 2);
 155
 156       l = _gnutls_read_uint16 (data);
 157       data += 2;
 158
 159       DECR_LEN(data_size, l);
 160
 161       priv->responder_id[i].data = gnutls_malloc (l);
 162       if (priv->responder_id[i].data == NULL)
 163         return gnutls_assert_val (GNUTLS_E_MEMORY_ERROR);
 164
 165       memcpy (priv->responder_id[i].data, data, l);
 166       priv->responder_id[i].size = l;
 167
 168       data += l;
 169     }
 170
 171   return 0;
 172 }
 173
 174 /*
 175   Servers return a certificate response along with their certificate
 176   by sending a "CertificateStatus" message immediately after the
 177   "Certificate" message (and before any "ServerKeyExchange" or
 178   "CertificateRequest" messages).  If a server returns a
 179   "CertificateStatus" message, then the server MUST have included an
 180   extension of type "status_request" with empty "extension_data" in
 181   the extended server hello.
 182 */
 183
 184 static int
 185 server_send (gnutls_session_t session,
 186              gnutls_buffer_st* extdata,
 187              status_request_ext_st *priv)
 188 {
 189   int ret;
 190
 191   if (priv->ocsp_func == NULL)
 192     return gnutls_assert_val (GNUTLS_E_SUCCESS);
 193
 194   ret = priv->ocsp_func (session, priv->ocsp_func_ptr, &priv->response);
 195   if (ret == GNUTLS_E_NO_CERTIFICATE_STATUS)
 196     return 0;
 197   else if (ret < 0)
 198     return gnutls_assert_val (ret);
 199
 200   return GNUTLS_E_INT_RET_0;
 201 }
 202
 203 static int
 204 client_recv (gnutls_session_t session,
 205              status_request_ext_st *priv,
 206              const uint8_t * data,
 207              size_t size)
 208 {
 209   if (size != 0)
 210     return gnutls_assert_val(GNUTLS_E_UNEXPECTED_PACKET_LENGTH);
 211   else
 212     {
 213       priv->expect_cstatus = 1;
 214       return 0;
 215     }
 216 }
 217
 218 static int
 219 _gnutls_status_request_send_params (gnutls_session_t session,
 220                                     gnutls_buffer_st* extdata)
 221 {
 222   extension_priv_data_t epriv;
 223   status_request_ext_st *priv;
 224   int ret;
 225
 226   ret = _gnutls_ext_get_session_data (session,
 227                                       GNUTLS_EXTENSION_STATUS_REQUEST,
 228                                       &epriv);
 229
 230   if (ret < 0 || epriv.ptr == NULL) /* it is ok not to have it */
 231     return 0;
 232
 233   priv = epriv.ptr;
 234
 235   if (session->security_parameters.entity == GNUTLS_CLIENT)
 236     return client_send (session, extdata, priv);
 237   return server_send (session, extdata, priv);
 238 }
 239
 240 static int
 241 _gnutls_status_request_recv_params (gnutls_session_t session,
 242                                     const uint8_t * data,
 243                                     size_t size)
 244 {
 245   extension_priv_data_t epriv;
 246   status_request_ext_st *priv;
 247   int ret;
 248
 249   ret = _gnutls_ext_get_session_data (session,
 250                                       GNUTLS_EXTENSION_STATUS_REQUEST,
 251                                       &epriv);
 252   if (ret < 0 || epriv.ptr == NULL) /* it is ok not to have it */
 253     return 0;
 254
 255   priv = epriv.ptr;
 256
 257   if (session->security_parameters.entity == GNUTLS_CLIENT)
 258     return client_recv (session, priv, data, size);
 259   return server_recv (session, priv, data, size);
 260 }
 261
 262 /**
 263  * gnutls_status_request_ocsp_client:
 264  * @session: is a #gnutls_session_t structure.
 265  * @responder_id: array with #gnutls_datum_t with DER data of responder id
 266  * @responder_id_size: number of members in @responder_id array
 267  * @extensions: a #gnutls_datum_t with DER encoded OCSP extensions
 268  *
 269  * This function is to be used by clients to request OCSP response
 270  * from the server, using the "status_request" TLS extension.  Only
 271  * OCSP status type is supported. A typical server has a single
 272  * OCSP response cached, so @responder_id and @extensions
 273  * should be null.
 274  *
 275  * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned,
 276  *   otherwise a negative error code is returned.
 277  **/
 278 int
 279 gnutls_status_request_ocsp_client (gnutls_session_t session,
 280                                    gnutls_datum_t *responder_id,
 281                                    size_t responder_id_size,
 282                                    gnutls_datum_t *extensions)
 283 {
 284   status_request_ext_st *priv;
 285   extension_priv_data_t epriv;
 286
 287   if (session->security_parameters.entity == GNUTLS_SERVER)
 288     return gnutls_assert_val (GNUTLS_E_INVALID_REQUEST);
 289
 290   epriv.ptr = priv = gnutls_calloc (1, sizeof (*priv));
 291   if (priv == NULL)
 292     return gnutls_assert_val (GNUTLS_E_MEMORY_ERROR);
 293
 294   priv->responder_id = responder_id;
 295   priv->responder_id_size = responder_id_size;
 296   if (extensions)
 297     {
 298       priv->request_extensions.data = extensions->data;
 299       priv->request_extensions.size = extensions->size;
 300     }
 301
 302   _gnutls_ext_set_session_data (session,
 303                                 GNUTLS_EXTENSION_STATUS_REQUEST,
 304                                 epriv);
 305
 306   return 0;
 307 }
 308
 309 /**
 310  * gnutls_status_request_get_ocsp:
 311  * @session: is a #gnutls_session_t structure.
 312  * @response: a #gnutls_datum_t with DER encoded OCSP response
 313  *
 314  * This function returns the OCSP status response received
 315  * from the TLS server. The @response should be treated as
 316  * constant. If no OCSP response is available then
 317  * %GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE is returned.
 318  *
 319  * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned,
 320  *   otherwise a negative error code is returned.
 321  **/
 322 int
 323 gnutls_status_request_get_ocsp (gnutls_session_t session,
 324                                 gnutls_datum_t *response)
 325 {
 326   status_request_ext_st *priv;
 327   extension_priv_data_t epriv;
 328   int ret;
 329
 330   if (session->security_parameters.entity == GNUTLS_SERVER)
 331     return gnutls_assert_val (GNUTLS_E_INVALID_REQUEST);
 332
 333   ret = _gnutls_ext_get_session_data (session,
 334                                       GNUTLS_EXTENSION_STATUS_REQUEST,
 335                                       &epriv);
 336   if (ret < 0)
 337     return gnutls_assert_val(ret);
 338
 339   priv = epriv.ptr;
 340
 341   if (priv == NULL ||  priv->response.data == NULL)
 342     return gnutls_assert_val(GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE);
 343
 344   response->data = priv->response.data;
 345   response->size = priv->response.size;
 346
 347   return 0;
 348 }
 349
 350 /**
 351  * gnutls_status_request_ocsp_server:
 352  * @session: is a #gnutls_session_t structure.
 353  * @ocsp_func: function pointer to OCSP status request callback.
 354  * @ptr: opaque pointer passed to callback function
 355  *
 356  * This function is to be used by server to register a callback to
 357  * handle OCSP status requests from the client.  The callback will be
 358  * invoked if the client supplied a status-request OCSP extension.
 359  * The callback function prototype is:
 360  *
 361  * typedef int (*gnutls_status_request_ocsp_func)
 362  *    (gnutls_session_t session, void *ptr, gnutls_datum_t *ocsp_response);
 363  *
 364  * The callback will be invoked if the client requests an OCSP certificate
 365  * status.  The callback may return %GNUTLS_E_NO_CERTIFICATE_STATUS, if
 366  * there is no recent OCSP response. If the callback returns %GNUTLS_E_SUCCESS,
 367  * the server will provide the client with the ocsp_response.
 368  *
 369  * The response must be a value allocated using gnutls_malloc(), and will be
 370  * deinitialized when needed.
 371  *
 372  * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned,
 373  *   otherwise a negative error code is returned.
 374  **/
 375 int
 376 gnutls_status_request_ocsp_server (gnutls_session_t session,
 377                                    gnutls_status_request_ocsp_func ocsp_func,
 378                                    void *ptr)
 379 {
 380   extension_priv_data_t epriv;
 381   status_request_ext_st* priv;
 382
 383   if (session->security_parameters.entity == GNUTLS_CLIENT)
 384     return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
 385
 386   priv = gnutls_calloc(1, sizeof(*priv));
 387   if (priv == NULL)
 388     return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR);
 389
 390   priv->ocsp_func = ocsp_func;
 391   priv->ocsp_func_ptr = ptr;
 392
 393   epriv.ptr = priv;
 394
 395   _gnutls_ext_set_session_data (session,
 396                                 GNUTLS_EXTENSION_STATUS_REQUEST,
 397                                 epriv);
 398
 399   return 0;
 400 }
 401
 402 static int file_ocsp_func(gnutls_session_t session, void *ptr, gnutls_datum_t *ocsp_response)
 403 {
 404 int ret;
 405 status_request_ext_st* priv = ptr;
 406
 407   ret = gnutls_load_file(priv->response_file, ocsp_response);
 408   if (ret < 0)
 409     return gnutls_assert_val(GNUTLS_E_NO_CERTIFICATE_STATUS);
 410
 411   return 0;
 412 }
 413
 414 /**
 415  * gnutls_status_request_ocsp_server_file:
 416  * @session: is a #gnutls_session_t structure.
 417  * @response_file: a filename of the OCSP response
 418  * @flags: should be zero
 419  *
 420  * This function sets the filename of an OCSP response, that will be
 421  * sent to the client if requests an OCSP certificate status.
 422  *
 423  * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned,
 424  *   otherwise a negative error code is returned.
 425  **/
 426 int
 427 gnutls_status_request_ocsp_server_file (gnutls_session_t session,
 428                                    const char* response_file,
 429                                    unsigned int flags)
 430 {
 431   extension_priv_data_t epriv;
 432   status_request_ext_st* priv;
 433
 434   if (session->security_parameters.entity == GNUTLS_CLIENT)
 435     return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
 436
 437   priv = gnutls_calloc(1, sizeof(*priv));
 438   if (priv == NULL)
 439     return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR);
 440
 441   priv->response_file = gnutls_strdup(response_file);
 442   if (priv->response_file == NULL)
 443     return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR);
 444
 445   priv->ocsp_func = file_ocsp_func;
 446   priv->ocsp_func_ptr = priv;
 447
 448   epriv.ptr = priv;
 449
 450   _gnutls_ext_set_session_data (session,
 451                                 GNUTLS_EXTENSION_STATUS_REQUEST,
 452                                 epriv);
 453   return 0;
 454 }
 455
 456 static void
 457 _gnutls_status_request_deinit_data (extension_priv_data_t epriv)
 458 {
 459   status_request_ext_st *priv = epriv.ptr;
 460   size_t i;
 461
 462   if (priv == NULL)
 463     return;
 464
 465   for (i = 0; i < priv->responder_id_size; i++)
 466     gnutls_free (priv->responder_id[i].data);
 467
 468   gnutls_free (priv->responder_id);
 469   gnutls_free (priv->request_extensions.data);
 470   gnutls_free (priv->response.data);
 471   gnutls_free (priv->response_file);
 472   gnutls_free (priv);
 473 }
 474
 475 static int
 476 _gnutls_status_request_pack (extension_priv_data_t epriv,
 477                              gnutls_buffer_st * ps)
 478 {
 479   return -1;
 480 }
 481
 482 static int
 483 _gnutls_status_request_unpack (gnutls_buffer_st * ps,
 484                                extension_priv_data_t * _priv)
 485 {
 486   return -1;
 487 }
 488
 489 extension_entry_st ext_mod_status_request = {
 490   .name = "STATUS REQUEST",
 491   .type = GNUTLS_EXTENSION_STATUS_REQUEST,
 492   .parse_type = GNUTLS_EXT_TLS,
 493   .recv_func = _gnutls_status_request_recv_params,
 494   .send_func = _gnutls_status_request_send_params,
 495   .pack_func = _gnutls_status_request_pack,
 496   .unpack_func = _gnutls_status_request_unpack,
 497   .deinit_func = _gnutls_status_request_deinit_data
 498 };
 499
 500 /* Functions to be called from handshake */
 501
 502 int
 503 _gnutls_send_server_certificate_status (gnutls_session_t session, int again)
 504 {
 505   mbuffer_st *bufel = NULL;
 506   uint8_t * data;
 507   int data_size = 0;
 508   int ret;
 509   status_request_ext_st *priv = NULL;
 510   extension_priv_data_t epriv;
 511   if (again == 0)
 512     {
 513       ret =
 514         _gnutls_ext_get_session_data (session,
 515                                       GNUTLS_EXTENSION_STATUS_REQUEST,
 516                                       &epriv);
 517       if (ret < 0)
 518         return 0;
 519       priv = epriv.ptr;
 520
 521       if (!priv->response.size)
 522         return 0;
 523
 524       data_size = priv->response.size + 4;
 525       bufel = _gnutls_handshake_alloc (session, data_size, data_size);
 526       if (!bufel)
 527         return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR);
 528
 529       data = _mbuffer_get_udata_ptr (bufel);
 530
 531       data[0] = 0x01;
 532       _gnutls_write_uint24(priv->response.size, &data[1]);
 533       memcpy(&data[4], priv->response.data, priv->response.size);
 534     }
 535   return _gnutls_send_handshake (session, data_size ? bufel : NULL,
 536                                  GNUTLS_HANDSHAKE_CERTIFICATE_STATUS);
 537 }
 538
 539 int
 540 _gnutls_recv_server_certificate_status (gnutls_session_t session)
 541 {
 542   uint8_t *data;
 543   int data_size;
 544   size_t r_size;
 545   gnutls_buffer_st buf;
 546   int ret;
 547   status_request_ext_st *priv = NULL;
 548   extension_priv_data_t epriv;
 549
 550   ret =
 551     _gnutls_ext_get_session_data (session, GNUTLS_EXTENSION_STATUS_REQUEST,
 552                                   &epriv);
 553   if (ret < 0)
 554     {
 555       gnutls_assert ();
 556       return 0;
 557     }
 558   priv = epriv.ptr;
 559
 560   if (!priv->expect_cstatus)
 561     return 0;
 562
 563   ret = _gnutls_recv_handshake (session,
 564                                 GNUTLS_HANDSHAKE_CERTIFICATE_STATUS,
 565                                 0, &buf);
 566   if (ret < 0)
 567     return gnutls_assert_val_fatal(ret);
 568
 569   data = buf.data;
 570   data_size = buf.length;
 571
 572   /* minimum message is type (1) + response (3) + data */
 573   if (data_size == 0)
 574     return 0;
 575   else if (data_size < 4)
 576     return gnutls_assert_val (GNUTLS_E_UNEXPECTED_PACKET_LENGTH);
 577
 578   if (data[0] != 0x01)
 579     {
 580       gnutls_assert ();
 581       _gnutls_handshake_log ("EXT[%p]: unknown status_type %d\n",
 582                              session, data[0]);
 583       return 0;
 584     }
 585   DECR_LENGTH_COM (data_size, 1, ret = GNUTLS_E_UNEXPECTED_PACKET_LENGTH; goto error);
 586   data++;
 587
 588   DECR_LENGTH_COM (data_size, 3, ret = GNUTLS_E_UNEXPECTED_PACKET_LENGTH; goto error);
 589   r_size = _gnutls_read_uint24(data);
 590   data += 3;
 591
 592   DECR_LENGTH_COM (data_size, r_size, ret = GNUTLS_E_UNEXPECTED_PACKET_LENGTH; goto error);
 593
 594   ret = _gnutls_set_datum(&priv->response, data, r_size);
 595   if (ret < 0)
 596     goto error;
 597
 598   ret = 0;
 599
 600 error:
 601   _gnutls_buffer_clear (&buf);
 602
 603   return ret;
 604 }